diff --git a/API.md b/API.md
index 51e35f69..e378b10a 100644
--- a/API.md
+++ b/API.md
@@ -2,6 +2,8 @@
 
 TVM Solidity compiler expands Solidity language with different API functions to facilitate TVM contract development.
 
+When deploying contracts, you should use the latest released version of Solidity. Apart from exceptional cases, only the latest version receives security fixes. Furthermore, breaking changes, as well as new features, are introduced regularly. We currently use a 0.y.z version number to indicate this fast pace of change.
+
 ## Table of Contents
 
 * [Compiler version](#compiler-version)
@@ -33,10 +35,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
       * [\<TvmSlice\>.loadInt() and \<TvmSlice\>.loadIntQ()](#tvmsliceloadint-and-tvmsliceloadintq)
       * [\<TvmSlice\>.loadUint() and \<TvmSlice\>.loadUintQ()](#tvmsliceloaduint-and-tvmsliceloaduintq)
       * [Load little-endian integers](#load-little-endian-integers)
-      * [\<TvmSlice\>.loadTons()](#tvmsliceloadtons)
       * [\<TvmSlice\>.loadSlice() and \<TvmSlice\>.loadSliceQ()](#tvmsliceloadslice-and-tvmsliceloadsliceq)
-      * [\<TvmSlice\>.loadFunctionParams()](#tvmsliceloadfunctionparams)
-      * [\<TvmSlice\>.loadStateVars()](#tvmsliceloadstatevars)
       * [\<TvmSlice\>.skip()](#tvmsliceskip)
       * [\<TvmSlice\>.loadZeroes(), \<TvmSlice\>.loadOnes() and \<TvmSlice\>.loadSame()](#tvmsliceloadzeroes-tvmsliceloadones-and-tvmsliceloadsame)
     * [TvmSlice preload primitives](#tvmslice-preload-primitives)
@@ -64,7 +63,6 @@ TVM Solidity compiler expands Solidity language with different API functions to
     * [\<TvmBuilder\>.storeUint()](#tvmbuilderstoreuint)
     * [Store little-endian integers](#store-little-endian-integers)
     * [\<TvmBuilder\>.storeRef()](#tvmbuilderstoreref)
-    * [\<TvmBuilder\>.storeTons()](#tvmbuilderstoretons)
   * [optional(T)](#optionalt)
     * [constructing an optional](#constructing-an-optional)
     * [\<optional(T)\>.hasValue()](#optionalthasvalue)
@@ -88,6 +86,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
   * [unchecked block](#unchecked-block)
 * [Changes and extensions in Solidity types](#changes-and-extensions-in-solidity-types)
   * [Integers](#integers)
+    * [\<Integer\>.cast()](#integercast) 
     * [bitSize() and uBitSize()](#bitsize-and-ubitsize)
   * [varInt and varUint](#varint-and-varuint)
   * [struct](#struct)
@@ -124,7 +123,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
     * [Object creating](#object-creating)
       * [constructor()](#constructor)
       * [address.makeAddrStd()](#addressmakeaddrstd)
-      * [address.makeAddrNone()](#addressmakeaddrnone)
+      * [address.addrNone](#addressaddrnone)
       * [address.makeAddrExtern()](#addressmakeaddrextern)
     * [Members](#members)
       * [\<address\>.wid](#addresswid)
@@ -159,6 +158,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
     * [\<mapping\>.keys() \<mapping\>.values()](#mappingkeys-mappingvalues)
   * [Fixed point number](#fixed-point-number)
   * [Function type](#function-type)
+  * [User-defined type](#user-defined-type)
   * [require, revert](#require-revert)
     * [require](#require)
     * [revert](#revert)
@@ -176,6 +176,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
   * [Decoding state variables](#decoding-state-variables)
   * [Keyword `constant`](#keyword-constant)
   * [Keyword `static`](#keyword-static)
+  * [Keyword `nostorage`](#keyword-nostorage)
   * [Keyword `public`](#keyword-public)
 * [Special contract functions](#special-contract-functions)
   * [receive](#receive)
@@ -230,10 +231,6 @@ TVM Solidity compiler expands Solidity language with different API functions to
       * [tvm.hash()](#tvmhash)
       * [tvm.checkSign()](#tvmchecksign)
     * [Deploy contract from contract](#deploy-contract-from-contract)
-      * [tvm.insertPubkey()](#tvminsertpubkey)
-      * [tvm.buildStateInit()](#tvmbuildstateinit)
-      * [tvm.buildDataInit()](#tvmbuilddatainit)
-      * [tvm.stateInitHash()](#tvmstateinithash)
       * [Deploy via new](#deploy-via-new)
         * [`stateInit` option usage](#stateinit-option-usage)
         * [`code` option usage](#code-option-usage)
@@ -242,17 +239,11 @@ TVM Solidity compiler expands Solidity language with different API functions to
       * [New contract address problem](#new-contract-address-problem)
     * [Misc functions from `tvm`](#misc-functions-from-tvm)
       * [tvm.code()](#tvmcode)
-      * [tvm.codeSalt()](#tvmcodesalt)
-      * [tvm.setCodeSalt()](#tvmsetcodesalt)
       * [tvm.pubkey()](#tvmpubkey)
       * [tvm.setPubkey()](#tvmsetpubkey)
       * [tvm.setCurrentCode()](#tvmsetcurrentcode)
       * [tvm.resetStorage()](#tvmresetstorage)
-      * [tvm.functionId()](#tvmfunctionid)
-      * [tvm.encodeBody()](#tvmencodebody)
       * [tvm.exit() and tvm.exit1()](#tvmexit-and-tvmexit1)
-      * [tvm.buildExtMsg()](#tvmbuildextmsg)
-      * [tvm.buildIntMsg()](#tvmbuildintmsg)
       * [tvm.sendrawmsg()](#tvmsendrawmsg)
   * [**math** namespace](#math-namespace)
     * [math.min() math.max()](#mathmin-mathmax)
@@ -277,6 +268,18 @@ TVM Solidity compiler expands Solidity language with different API functions to
     * [rnd.shuffle](#rndshuffle)
   * [**abi** namespace](#abi-namespace)
     * [abi.encode(), abi.decode()](#abiencode-abidecode)
+    * [abi.encodeData()](#abiencodedata)
+    * [abi.encodeOldDataInit()](#abiencodeolddatainit)
+    * [abi.decodeData()](#abidecodedata)
+    * [abi.encodeStateInit()](#abiencodestateinit)
+    * [abi.stateInitHash()](#abistateinithash)
+    * [abi.encodeBody()](#abiencodebody)
+    * [abi.decodeFunctionParams()](#abidecodefunctionparams)
+    * [abi.codeSalt()](#abicodesalt)
+    * [abi.setCodeSalt()](#abisetcodesalt)
+    * [abi.functionId()](#abifunctionid)
+    * [abi.encodeExtMsg()](#abiencodeextmsg)
+    * [abi.encodeIntMsg()](#abiencodeintmsg)
   * [**gosh** namespace](#gosh-namespace)
     * [gosh.diff and gosh.zipDiff](#goshdiff-and-goshzipdiff)
     * [gosh.applyPatch, gosh.applyPatchQ, gosh.applyZipPatch, gosh.applyZipPatchQ, gosh.applyZipBinPatch and gosh.applyZipBinPatchQ](#goshapplypatch-goshapplypatchq-goshapplyzippatch-goshapplyzippatchq-goshapplyzipbinpatch-and-goshapplyzipbinpatchq)
@@ -298,7 +301,7 @@ TVM Solidity compiler expands Solidity language with different API functions to
 
 ### Compiler version
 
-TVM Solidity compiler add its current version to the generated code. This version can be obtained:
+TVM Solidity compiler adds its current version to the generated code. This version can be obtained:
 
 1) using [tvm_linker](https://github.com/tonlabs/TVM-linker#2-decoding-of-boc-messages-prepared-externally) from a `*.tvc` file:
 
@@ -734,21 +737,13 @@ Loads a cell from the `TvmSlice` reference and converts it into a `TvmSlice`.
 
 (2) Same as (1) but returns `null` if it's impossible to load the integer.
 
-###### \<TvmSlice\>.loadTons()
-
-```TVMSolidity
-<TvmSlice>.loadTons() returns (uint128);
-```
-
-Loads (deserializes) **VarUInteger 16** and returns an unsigned 128-bit integer. See [TL-B scheme][3].
-
 ###### \<TvmSlice\>.loadSlice() and \<TvmSlice\>.loadSliceQ()
 
 ```TVMSolidity
 (1)
 <TvmSlice>.loadSlice(uint10 bits) returns (TvmSlice);
 (2)
-<TvmSlice>.loadSlice(uint10 bits, uint refs) returns (TvmSlice);
+<TvmSlice>.loadSlice(uint10 bits, uint2 refs) returns (TvmSlice);
 (3)
 <TvmSlice>.loadSliceQ(uint10 bits) returns (optional(TvmSlice));
 (4)
@@ -761,66 +756,6 @@ Loads (deserializes) **VarUInteger 16** and returns an unsigned 128-bit integer.
 
 (3) and (4) are same as (1) and (2) but return `optional` type.
 
-###### \<TvmSlice\>.loadFunctionParams()
-
-```TVMSolidity
-// Loads parameters of the public/external function without "responsible" attribute
-<TvmSlice>.loadFunctionParams(functionName) returns (TypeA /*a*/, TypeB /*b*/, ...);
-
-// Loads parameters of the public/external function with "responsible" attribute
-<TvmSlice>.loadFunctionParams(functionName) returns (uint32 callbackFunctionId, TypeA /*a*/, TypeB /*b*/, ...);
-
-// Loads constructor parameters
-<TvmSlice>.loadFunctionParams(ContractName) returns (TypeA /*a*/, TypeB /*b*/, ...);
-```
-
-Loads parameters of the function or constructor (if contract type is provided). This function is usually used in
-**[onBounce](#onbounce)** function.
-
-See example of how to use **onBounce** function:
-
-* [onBounceHandler](https://github.com/tonlabs/samples/blob/master/solidity/16_onBounceHandler.sol)
-
-###### \<TvmSlice\>.loadStateVars()
-
-```TVMSolidity
-<TvmSlice>.loadStateVars(ContractName) returns (uint256 /*pubkey*/, uint64 /*timestamp*/, bool /*constructorFlag*/, Type1 /*var1*/, Type2 /*var2*/, ...);
-```
-
-Loads state variables from `slice` that is obtained from the field `data` of `stateInit`
-
-Example:
-
-```
-contract A {
-	uint a = 111;
-	uint b = 22;
-	uint c = 3;
-	uint d = 44;
-	address e = address(12);
-	address f;
-}
-
-contract B {
-	function f(TvmCell data) public pure {
-		TvmSlice s = data.toSlice();
-		(uint256 pubkey, uint64 timestamp, bool flag,
-			uint a, uint b, uint c, uint d, address e, address f) = s.loadStateVars(A);
-			
-		// pubkey - pubkey of the contract A
-		// timestamp - timestamp that used for replay protection
-		// flag - always is equal to true
-		// a == 111
-		// b == 22
-		// c == 3
-		// d == 44
-		// e == address(12)
-		// f == address(0)
-		// s.empty()
-	}
-}
-```
-
 ###### \<TvmSlice\>.skip()
 
 ```TVMSolidity
@@ -1138,20 +1073,6 @@ Stores the little-endian integer.
 
 Stores `TvmBuilder b`/`TvmCell c`/`TvmSlice s` in the reference of the `TvmBuilder`.
 
-##### \<TvmBuilder\>.storeTons()
-
-```TVMSolidity
-<TvmBuilder>.storeTons(uint128 value);
-```
-
-Stores (serializes) an integer **value** and stores it in the `TvmBuilder` as
-**VarUInteger 16**. See [TL-B scheme][3].
-
-See example of how to work with TVM specific types:
-
-* [Message_construction](https://github.com/tonlabs/samples/blob/master/solidity/15_MessageSender.sol)
-* [Message_parsing](https://github.com/tonlabs/samples/blob/master/solidity/15_MessageReceiver.sol)
-
 #### optional(T)
 
 The template optional type manages an optional contained value, i.e. a value that may or may not be present.
@@ -1360,28 +1281,18 @@ for ((, uint value) : map) { // key is omitted
 
 #### repeat
 
-Allows repeating block of code several times.
-A `repeat` loop evaluates the expression only one time.
-This expression must have an unsigned integer type.
+```TVMSolidity
+repeat (exression) statement
+```
+
+Allows repeating the block of code several times. `exression` evaluates only one time.
 
 ```TVMSolidity
 uint a = 0;
 repeat(10) {
-    a ++;
+    ++a;
 }
 // a == 10
-
-// Despite a is changed in the cycle, code block will be repeated 10 times (10 is the initial value of a)
-repeat(a) {
-    a += 2;
-}
-// a == 30
-
-a = 11;
-repeat(a - 1) {
-    a -= 1;
-}
-// a == 1
 ```
 
 #### try-catch
@@ -1488,6 +1399,41 @@ Operators:
 * Shift operators: ``<<`` (left shift), ``>>`` (right shift)
 * Arithmetic operators: ``+``, ``-``, unary ``-``, ``*``, ``/``, ``%`` (modulo), ``**`` (exponentiation)
 
+##### \<Integer\>.cast()
+
+```TVMSolidity
+<Integer>.cast(T) returns (T)
+```
+
+Convert `<Integer>` to T type. `T` is integer type. Type of `<Integer>` and `T` must have same sign or bit-size. Never throws an exception. For example:
+
+```TVMSolidity
+uint8 a = 255;
+uint4 b = a.cast(uint4); // b == 15
+
+uint8 a = 255;
+int8 b = a.cast(int8); // b == -1
+
+uint8 a = 255;
+int4 b = a.cast(uint4).cast(int4); // b == -1
+
+uint8 a = 255;
+// int4 b = a.cast(int4); // compilation fail
+```
+
+**Note:** conversion via `T(x)` throws an exception if `x` does not fit into `T` type.  For example:
+
+```TVMSolidity
+uint8 a = 10;
+uint4 b = uint4(a); // OK, a == 10
+
+uint8 a = 100;
+uint4 b = uint4(a); // throws an exception because type(uint4).max == 15
+
+int8 a = -1;
+uint8 b = uint8(a); // throws an exception because type(uint8).min == 0
+```
+
 ##### bitSize() and uBitSize()
 
 ```TVMSolidity
@@ -1516,12 +1462,14 @@ uint16 s = uBitSize(0); // s == 0
 
 #### varInt and varUint
 
-`varInt`/`varInt16`/`varInt32`/`varUint`/`varUint16`/`varUint32` are kinds of [Integer](#integers)
+`varInt`/`varInt16`/`varInt32`/`varUint`/`varUint16`/`coins`/`varUint32` are kinds of [Integer](#integers)
 types. But they are serialized/deserialized according to [their TLB schemes](https://github.com/ton-blockchain/ton/blob/master/crypto/block/block.tlb#L112).
 These schemes are effective if you want to store or send integers, and they usually have small size.
 Use these types only if you are sure.
 `varInt` is equal to `varInt32`, `varInt32` - `int248` , `varInt16` - `int120`.
 `varUint` is equal to `varUint32`, `varUint32` - `uint248` , `varUint16` - `uint120`.
+`coins` is an alias for `varUint16`.
+
 Example:
 
 ```TVMSolidity
@@ -1755,17 +1703,32 @@ Returns byte length of the `string` data.
 ##### \<string\>.substr()
 
 ```TVMSolidity
-<string>.substr(uint from[, uint count]) returns (string);
+(1)
+<string>.substr(uint pos) returns (string);
+(2)
+<string>.substr(uint pos, uint count) returns (string);
+```
+
+(1) Returns a string that is a substring of this string. The substring begins with the character at the specified `pos` and extends to the end of this string.
+
+(2) Returns a string that is a substring of this string. The substring begins with the character at the specified `pos` and copies at most `count` characters from the source string. If the string is shorter, as many characters as possible are used.
+
+Throws an exception if `pos > string.byteLength()`.
+
+```TVMSolidity
+string text = "0123456789";
+string a = text.substr(1, 2); // a = "12"
+string b = text.substr(6); // b = "6789"
+string c = text.substr(6, 100); // c = "6789"
+string d = text.substr(777); // throws an exception
 ```
 
-Returns the substring starting from the byte with number **from** with byte length **count**.  
-**Note**: if count is not set, then the new `string` will be cut from the **from** byte to the end
-of the string.
+**Note:** if [Array Slices](https://docs.soliditylang.org/en/latest/types.html#array-slices) are used (they are written as `x[start:end]`),  then `0 <= start <= end <= byteLength()`.
 
 ```TVMSolidity
-string long = "0123456789";
-string a = long.substr(1, 2); // a = "12"
-string b = long.substr(6); // b = "6789"
+string str = "01234567890";
+string c = text.substr(6, 100); // c = "6789"
+string d = text[6:106]; // throws an exception
 ```
 
 ##### \<string\>.append()
@@ -1857,13 +1820,13 @@ string b = s.toLowerCase(); // b == "hello"
 format(string template, TypeA a, TypeB b, ...) returns (string);
 ```
 
-Builds a `string` with arbitrary parameters. Empty placeholder {} can be filled with integer
+Builds a `string` with arbitrary parameters. Empty placeholder `{}` can be filled with integer
 (in decimal view), address, string or fixed point number. Fixed point number is printed
 based on its type (`fixedMxN` is printed with `N` digits after dot).
 Placeholder should be specified in such formats:
+ * `"{}"` - empty placeholder
+ * `"{:[0]<width>{"x","d","X","t"}}"` - placeholder for integers. Fills num with 0 if format starts with "0".
 
-* `"{}"` - empty placeholder
-* `"{:[0]<width>{"x","d","X","t"}}"` - placeholder for integers. Fills num with 0 if format starts with "0".
 Formats integer to have specified `width`. Can format integers in decimal ("d" postfix), lower hex ("x")
 or upper hex ("X") form. Format "t" prints number (in nanoevers) as a fixed point sum.
 
@@ -1912,6 +1875,7 @@ res = stoi("123"); // res ==123
 string hexstr = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF123456789ABCDE";
 res = stoi(hexstr); // res == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF123456789ABCDE
 res = stoi("0xag"); // res == null
+res = stoi(""); // res == null
 ```
 
 ##### string conversion
@@ -1942,7 +1906,7 @@ uint address_value;
 address addrStd = address(address_value);
 ```
 
-Constructs an `address` of type **addr_std** with zero workchain id and given address value.
+Constructs `address` of type **addr_std** with zero workchain id and given address value.
 
 ##### address.makeAddrStd()
 
@@ -1952,15 +1916,15 @@ uint address;
 address addrStd = address.makeAddrStd(wid, address);
 ```
 
-Constructs an `address` of type **addr_std** with given workchain id **wid** and value **address_value**.
+Constructs `address` of type **addr_std** with given workchain id **wid** and value **address_value**.
 
-##### address.makeAddrNone()
+##### address.addrNone
 
 ```TVMSolidity
-address addrNone = address.makeAddrNone();
+address addrNone = address.addrNone;
 ```
 
-Constructs an `address` of type **addr_none**.
+Constructs `address` of type **addr_none**.
 
 ##### address.makeAddrExtern()
 
@@ -1970,7 +1934,7 @@ uint bitCnt;
 address addrExtern = address.makeAddrExtern(addrNumber, bitCnt);
 ```
 
-Constructs an `address` of type **addr_extern** with given **value** with **bitCnt** bit-length.
+Constructs `address` of type **addr_extern** with given **value** with **bitCnt** bit-length.
 
 ##### Members
 
@@ -1993,7 +1957,7 @@ Returns the `address` value of **addr_std** or **addr_var** if **addr_var** has
 ##### \<address\>.balance
 
 ```TVMSolidity
-address(this).balance returns (uint128);
+address(this).balance returns (varUint16);
 ```
 
 Returns balance of the current contract account in nanoevers.
@@ -2074,12 +2038,12 @@ Example:
 ##### \<address\>.transfer()
 
 ```TVMSolidity
-<address>.transfer(uint128 value, bool bounce, uint16 flag, TvmCell body, mapping(uint32 => varUint32) currencies, TvmCell stateInit);
+<address>.transfer(varUint16 value, bool bounce, uint16 flag, TvmCell body, mapping(uint32 => varUint32) currencies, TvmCell stateInit);
 ```
 
 Sends an internal outbound message to the `address`. Function parameters:
 
-* `value` (`uint128`) - amount of nanoevers sent attached to the message. Note: the sent value is
+* `value` (`varUint16`) - amount of nanoevers sent attached to the message. Note: the sent value is
 withdrawn from the contract's balance even if the contract has been called by internal inbound message.
 * `currencies` (`mapping(uint32 => varUint32)`) - additional currencies attached to the message. Defaults to
 an empty set.
@@ -2431,6 +2395,14 @@ function process(int a, int b, uint8 mode) public returns (int) {
 }
 ```
 
+#### User-defined type
+
+A user-defined value type allows creating a zero cost abstraction over an elementary value type. This is similar to an alias, but with stricter type requirements.
+
+More information can be found [here](https://docs.soliditylang.org/en/latest/types.html#user-defined-value-types).
+
+You can define an operator for user-defined type. See [here](https://docs.soliditylang.org/en/latest/contracts.html#using-for).
+
 #### require, revert
 
 In case of exception state variables of the contract are reverted to the state before
@@ -2732,7 +2704,7 @@ Defines that code is compiled with special selector that is needed to upgrade Fu
 
 You can decode state variables using tonos-cli. See `tonos-cli decode account --help`.
 
-See also: [\<TvmSlice\>.loadStateVars()](#tvmsliceloadstatevars).
+See also: [abi.decodeData()](#abidecodedata).
 
 #### Keyword `constant`
 
@@ -2766,6 +2738,22 @@ See also:
 * [`code` option usage](#code-option-usage)
 * [New contract address problem](#new-contract-address-problem)
 
+#### Keyword `nostorage`
+
+`nostorage` state variables are not saved in the contract's storage. They have default values at the
+beginning of each transaction. 
+
+```TVMSolidity
+contract C {
+    uint nostorage m_value;
+    function f() public {
+        // here m_value == 0
+        ++m_value;  
+        // here m_value == 1
+    }
+}
+```
+
 #### Keyword `public`
 
 For each public state variable, a getter function is generated. Generated
@@ -2885,7 +2873,7 @@ contract ContractB {
         }
 
         TvmBuilder b;
-        uint32 id = tvm.functionId(ContractA.f);
+        uint32 id = abi.functionId(ContractA.f);
         b.store(id, uint(2));
         // ContractA's fallback function won't be called because the message body doesn't contain
         // the second ContractA.f's parameter. It will cause cell underflow exception in ContractA.
@@ -3394,9 +3382,8 @@ uint8 refs = b.refs(); // refs == 1
 
 The expression `type(T)` can be used to retrieve information about the type T. 
 
-The following properties are available for an integer, variable integer and enum type `T`:
+The following properties are available for an integer, [variable integer](#varint-and-varuint) and enum type `T`:
  * `type(T).min` - the smallest value representable by type `T`.
-
  * `type(T).max` - the largest value representable by type `T`.
 
 #### **msg** namespace
@@ -3416,7 +3403,7 @@ Returns:
 ##### msg.value
 
 ```TVMSolidity
-msg.value (uint128)
+msg.value (varUint16)
 ```
 
 Returns:
@@ -3777,6 +3764,8 @@ tvm.initCodeHash() returns (uint256 hash)
 
 Returns the initial code hash that contract had when it was deployed.
 
+[Capabilities](#tvm-capabilities) required: `CapInitCodeHash`.
+
 ##### Hashing and cryptography
 
 ##### tvm.hash()
@@ -3848,143 +3837,6 @@ bool signatureIsValid = tvm.checkSign(data, signature, pubkey);
 
 ##### Deploy contract from contract
 
-##### tvm.insertPubkey()
-
-```TVMSolidity
-tvm.insertPubkey(TvmCell stateInit, uint256 pubkey) returns (TvmCell);
-```
-
-Inserts a public key into the `stateInit` data field. If the `stateInit` has wrong format, then throws an exception.
-
-##### tvm.buildStateInit()
-
-```TVMSolidity
-// 1)
-tvm.buildStateInit(TvmCell code, TvmCell data) returns (TvmCell stateInit);
-// 2)
-tvm.buildStateInit(TvmCell code, TvmCell data, uint8 splitDepth) returns (TvmCell stateInit);
-// 3)
-tvm.buildStateInit({code: TvmCell code, data: TvmCell data, splitDepth: uint8 splitDepth,
-    pubkey: uint256 pubkey, contr: contract Contract, varInit: {VarName0: varValue0, ...}});
-```
-
-Generates a `StateInit` ([TBLKCH][2] - 3.1.7.) from `code` and `data` `TvmCell`s.
-Member `splitDepth` of the tree of cell `StateInit`:
-
-1) is not set. Has no value.
-2) is set. `0 <= splitDepth <= 31`
-3) Arguments can also be set with names.
-
-List of possible names:
-* `code` (`TvmCell`) - defines the code field of the `StateInit`. Must be specified.
-* `data` (`TvmCell`) - defines the data field of the `StateInit`. Conflicts with `pubkey` and
-`varInit`. Can be omitted, in this case data field would be built from `pubkey` and `varInit`.
-* `splitDepth` (`uint8`) - splitting depth. `0 <= splitDepth <= 31`. Can be omitted. By default,
-it has no value.
-* `pubkey` (`uint256`) - defines the public key of the new contract. Conflicts with `data`.
-Can be omitted, default value is 0.
-* `varInit` (`initializer list`) - used to set [static](#keyword-static) variables of the contract.
-Conflicts with `data` and requires `contr` to be set. Can be omitted.
-* `contr` (`contract`) - defines the contract whose `StateInit` is being built. Mandatory to be set if the
-option `varInit` is specified.
-
-Examples of this function usage:
-
-```TvmSolidity
-contract A {
-    uint static var0;
-    address static var1;
-}
-
-contract C {
-
-    function f() public pure {
-        TvmCell code;
-        TvmCell data;
-        uint8 depth;
-        TvmCell stateInit = tvm.buildStateInit(code, data);
-        stateInit = tvm.buildStateInit(code, data, depth);
-    }
-
-    function f1() public pure {
-        TvmCell code;
-        TvmCell data;
-        uint8 depth;
-        uint pubkey;
-        uint var0;
-        address var1;
-
-        TvmCell stateInit1 = tvm.buildStateInit({code: code, data: data, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({code: code, splitDepth: depth, varInit: {var0: var0, var1: var1}, pubkey: pubkey, contr: A});
-        stateInit1 = tvm.buildStateInit({varInit: {var0: var0, var1: var1}, pubkey: pubkey, contr: A, code: code, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({contr: A, varInit: {var0: var0, var1: var1}, pubkey: pubkey, code: code, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({contr: A, varInit: {var0: var0, var1: var1}, pubkey: pubkey, code: code});
-        stateInit1 = tvm.buildStateInit({contr: A, varInit: {var0: var0, var1: var1}, code: code, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({pubkey: pubkey, code: code, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({code: code, splitDepth: depth});
-        stateInit1 = tvm.buildStateInit({code: code});
-    }
-}
-```
-
-##### tvm.buildDataInit()
-
-```TVMSolidity
-tvm.buildDataInit({pubkey: uint256 pubkey, contr: contract Contract, varInit: {VarName0: varValue0, ...}});
-```
-
-Generates `data` field of the `StateInit` ([TBLKCH][2] - 3.1.7.). Parameters are the same as in
-[tvm.buildStateInit()](#tvmbuildstateinit).
-
-```TVMSolidity
-// SimpleWallet.sol
-contract SimpleWallet {
-    uint static value;
-    // ...
-}
-
-// Usage
-TvmCell data = tvm.buildDataInit({
-    contr: SimpleWallet,
-    varInit: {mulRes: 12345},
-    pubkey: 0x3f82435f2bd40915c28f56d3c2f07af4108931ae8bf1ca9403dcf77d96250827
-});
-TvmCell code = ...;
-TvmCell stateInit = tvm.buildStateInit({code: code, data: data});
-
-// Note, the code above can be simplified to:
-TvmCell stateInit = tvm.buildStateInit({
-    code: code,
-    contr: SimpleWallet,
-    varInit: {mulRes: 12345},
-    pubkey: 0x3f82435f2bd40915c28f56d3c2f07af4108931ae8bf1ca9403dcf77d96250827
-});
-```
-
-##### tvm.stateInitHash()
-
-```TVMSolidity
-tvm.stateInitHash(uint256 codeHash, uint256 dataHash, uint16 codeDepth, uint16 dataDepth) returns (uint256);
-```
-
-Calculates hash of the stateInit for given code and data specifications.
-[Capabilities](#tvm-capabilities) required: `CapInitCodeHash`.
-
-Example:
-
-```TVMSolidity
-TvmCell code = ...;
-TvmCell data = ...;
-uint codeHash = tvm.hash(code);
-uint dataHash = tvm.hash(data);
-uint16 codeDepth = code.depth();
-uint16 dataDepth = data.depth();
-uint256 hash = tvm.stateInitHash(codeHash, dataHash, codeDepth, dataDepth);
-```
-
-See also [internal doc](https://github.com/tonlabs/TON-Solidity-Compiler/blob/master/docs/internal/stateInit_hash.md) to read more about this
-function mechanics.
-
 ##### Deploy via new
 
 Either `code` or `stateInit` option must be set when you deploy a contract
@@ -4056,7 +3908,7 @@ address newWallet = new SimpleWallet{
 
 The following options can be used with both `stateInit` and `code`:
 
-* `value` (`uint128`) - funds attached to the outbound internal message, that creates new account.
+* `value` (`varUint16`) - funds attached to the outbound internal message, that creates new account.
 This value must be set.
 * `currencies` (`mapping(uint32 => varUint32)`) - currencies attached to the outbound internal message.
 Defaults to an empty set.
@@ -4124,22 +3976,6 @@ Returns contract's code. [Capabilities](#tvm-capabilities) required: `CapMycode`
 
 See [SelfDeployer](https://github.com/tonlabs/samples/blob/master/solidity/21_self_deploy.sol).
 
-##### tvm.codeSalt()
-
-```TVMSolidity
-tvm.codeSalt(TvmCell code) returns (optional(TvmCell) optSalt);
-```
-
-If **code** contains salt, then **optSalt** contains one. Otherwise, **optSalt** doesn't contain any value.
-
-##### tvm.setCodeSalt()
-
-```TVMSolidity
-tvm.setCodeSalt(TvmCell code, TvmCell salt) returns (TvmCell newCode);
-```
-
-Inserts **salt** into **code** and returns new code **newCode**.
-
 ##### tvm.pubkey()
 
 ```TVMSolidity
@@ -4179,268 +4015,35 @@ tvm.resetStorage();
 
 Resets all state variables to their default values.
 
-##### tvm.functionId()
+##### tvm.exit() and tvm.exit1()
 
 ```TVMSolidity
-// id of public function
-tvm.functionId(functionName) returns (uint32);
-
-// id of public constructor
-tvm.functionId(ContractName) returns (uint32);
+tvm.exit();
+tvm.exit1();
 ```
 
-Returns the function id (uint32) of a public/external function or constructor.
+Functions are used to save state variables and quickly terminate execution of the smart contract.
+Exit code of the compute phase is equal to zero/one for `tvm.exit`/`tvm.exit1`.
 
 Example:
 
 ```TVMSolidity
-contract MyContract {
-    constructor(uint a) public {
-    }
-        /*...*/
+function g0(uint a) private {
+    if (a == 0) {
+        tvm.exit();
     }
+    //...
+}
 
-    function f() public pure returns (uint) {
-        /*...*/
+function g1(uint a) private {
+    if (a == 0) {
+        tvm.exit1();
     }
+    //...
+}
+```
 
-    function getConstructorID() public pure returns (uint32) {
-        uint32 functionId = tvm.functionId(MyContract);
-        return functionId;
-    }
-
-    function getFuncID() public pure returns (uint32) {
-        uint32 functionId = tvm.functionId(f);
-        return functionId;
-    }
-}
-```
-
-See example of how to use this function:
-
-* [onBounceHandler](https://github.com/tonlabs/samples/blob/master/solidity/16_onBounceHandler.sol)
-
-##### tvm.encodeBody()
-
-```TVMSolidity
-tvm.encodeBody(function, arg0, arg1, arg2, ...) returns (TvmCell);
-tvm.encodeBody(function, callbackFunction, arg0, arg1, arg2, ...) returns (TvmCell);
-tvm.encodeBody(contract, arg0, arg1, arg2, ...) returns (TvmCell);
-```
-
-Constructs a message body for the function call. Body can be used as a payload for  [\<address\>.transfer()](#addresstransfer).
-If the **function** is `responsible`, **callbackFunction** must be set.
-
-Example:
-
-```TVMSolidity
-contract Remote {
-    constructor(uint x, uint y, uint z) public { /* */ }
-    function func(uint256 num, int64 num2) public pure { /* */ }
-    function getCost(uint256 num) public responsible pure returns (uint128) { /* */ }
-}
-
-// deploy the contract
-TvmCell body = tvm.encodeBody(Remote, 100, 200, 300);
-addr.transfer({value: 10 ever, body: body, stateInit: stateInit });
-
-// call the function
-TvmCell body = tvm.encodeBody(Remote.func, 123, -654);
-addr.transfer({value: 10 ever, body: body});
-
-// call the responsible function
-TvmCell body = tvm.encodeBody(Remote.getCost, onGetCost, 105);
-addr.transfer({value: 10 ever, body: body});
-```
-
-See also:
-
-* [External function calls](#external-function-calls)
-* [\<TvmSlice\>.loadFunctionParams()](#tvmsliceloadfunctionparams)
-* [tvm.buildIntMsg()](#tvmbuildintmsg)
-
-##### tvm.exit() and tvm.exit1()
-
-```TVMSolidity
-tvm.exit();
-tvm.exit1();
-```
-
-Functions are used to save state variables and quickly terminate execution of the smart contract.
-Exit codes are equal to zero and one for `tvm.exit` and `tvm.exit1` respectively.
-
-Example:
-
-```TVMSolidity
-function g0(uint a) private {
-    if (a == 0) {
-        tvm.exit();
-    }
-    //...
-}
-
-function g1(uint a) private {
-    if (a == 0) {
-        tvm.exit1();
-    }
-    //...
-}
-```
-
-##### tvm.buildExtMsg()
-
-```TVMSolidity
-tvm.buildExtMsg({
-    dest: address,
-    time: uint64,
-    expire: uint32,
-    call: {functionIdentifier [, list of function arguments]},
-    sign: bool,
-    pubkey: optional(uint256),
-    callbackId: (uint32 | functionIdentifier),
-    onErrorId: (uint32 | functionIdentifier),
-    stateInit: TvmCell,
-    signBoxHandle: optional(uint32),
-    abiVer: uint8,
-    flags: uint8
-})
-returns (TvmCell);
-```
-
-Function should be used only offchain and intended to be used only in debot contracts.
-Allows creating an external inbound message, that calls the **func** function of the
-contract on address **destination** with specified function arguments.
-
-Mandatory parameters that are used to form a src field that is used for debots:
-
-* `callbackId` - identifier of the callback function.
-* `onErrorId` - identifier of the function that is called in case of an error.
-* `signBoxHandle` - handle of the sign box entity, that engine will use to sign the message.
-
-These parameters are stored in addr_extern and placed to the src field of the message.
-Message is of type [ext_in_msg_info](https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/block/block.tlb#L127)
-and src address is of type [addr_extern](https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/block/block.tlb#L101)
-but stores special data:
-
-* callback id - 32 bits;
-* on error id - 32 bits;
-* abi version - 8 bits; Can be specified manually and contain full abi version in little endian half bytes (e.g. version = "2.3" -> abiVer: 0x32)
-* header mask - 3 bits in such order: time, expire, pubkey;
-* optional value signBoxHandle - 1 bit (whether value exists) + \[32 bits\];
-* control flags byte - 8 bits. 
-  Currently used bits:
-    1 - override time (dengine will replace time value with current time)
-    2 - override exp (dengine will replace time value with actual expire value)
-    4 - async call (dengine must send message and don't wait for the result)
-
-Other function parameters define fields of the message:
-
-* `time` - message creation timestamp. Used for replay attack protection, encoded as 64 bit Unix
-time in milliseconds.
-* `expire` - Unix time (in seconds, 32 bit) after that message should not be processed by contract.
-* `pubkey` - public key from key pair used for signing the message body. This parameter is optional
-and can be omitted.
-* `sign` - constant bool flag that shows whether message should contain signature. If set to
-**true**, message is generated with signature field filled with zeroes. This parameter is optional
-and can be omitted (in this case is equal to **false**).
-
-User can also attach stateInit to the message using `stateInit` parameter.
-
-Function throws an exception with code 64 if function is called with wrong parameters (pubkey is set
-and has value, but sign is false or omitted).
-
-Example:
-
-```TVMSolidity
-
-interface Foo {
-    function bar(uint a, uint b) external pure;
-}
-
-contract Test {
-
-    TvmCell public m_cell;
-
-    function generate0() public {
-        tvm.accept();
-        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
-        m_cell = tvm.buildExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x123, expire: 0x12345, call: {Foo.bar, 111, 88}});
-    }
-
-    function generate1() public {
-        tvm.accept();
-        optional(uint) pubkey;
-        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
-        m_cell = tvm.buildExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x123, expire: 0x12345, call: {Foo.bar, 111, 88}, pubkey: pubkey});
-    }
-
-    function generate2() public {
-        tvm.accept();
-        optional(uint) pubkey;
-        pubkey.set(0x95c06aa743d1f9000dd64b75498f106af4b7e7444234d7de67ea26988f6181df);
-        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
-        optional(uint32) signBox;
-        signBox.set(0x12333112);
-        m_cell = tvm.buildExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x1771c58ef9a, expire: 0x600741e4, call: {Foo.bar, 111, 88}, pubkey: pubkey, sign: true, signBoxHandle: signBox});
-    }
-
-}
-```
-
-External inbound message can also be built and sent with construction similar to remote contract
-call. It requires suffix ".extMsg" and call options similar to `buildExtMsg` function call.
-**Note**: this type of call should be used only offchain in debot contracts.
-
-```TVMSolidity
-interface Foo {
-    function bar(uint a, uint b) external pure;
-}
-
-contract Test {
-
-    function test7() public {
-        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
-        Foo(addr).bar{expire: 0x12345, time: 0x123}(123, 45).extMsg;
-        optional(uint) pubkey;
-        optional(uint32) signBox;
-        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey}(123, 45).extMsg;
-        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey, sign: true}(123, 45).extMsg;
-        pubkey.set(0x95c06aa743d1f9000dd64b75498f106af4b7e7444234d7de67ea26988f6181df);
-        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey, sign: true}(123, 45).extMsg;
-        Foo(addr).bar{expire: 0x12345, time: 0x123, sign: true, signBoxHandle: signBox}(123, 45).extMsg;
-        Foo(addr).bar{expire: 0x12345, time: 0x123, sign: true, signBoxHandle: signBox, abiVer: 0x32, flags: 0x07}(123, 45).extMsg;
-    }
-}
-```
-
-##### tvm.buildIntMsg()
-
-```TVMSolidity
-tvm.buildIntMsg({
-    dest: address,
-    value: uint128,
-    call: {function, [callbackFunction,] arg0, arg1, arg2, ...},
-    bounce: bool,
-    currencies: mapping(uint32 => varUint32),
-    stateInit: TvmCell
-})
-returns (TvmCell);
-```
-
-Generates an internal outbound message that contains a function call. The result `TvmCell` can be used to send a
-message using [tvm.sendrawmsg()](#tvmsendrawmsg). If the `function` is `responsible`, then
-`callbackFunction` parameter must be set.
-
-`dest`, `value` and `call` parameters are mandatory. Another parameters can be omitted. See
-[\<address\>.transfer()](#addresstransfer) where these options and their default values are
-described.
-
-See also:
-
-* sample [22_sender.sol](https://github.com/tonlabs/samples/blob/master/solidity/22_sender.sol)
-* [tvm.encodeBody()](#tvmencodebody)
-
-#### tvm.sendrawmsg()
+#### tvm.sendrawmsg()
 
 ```TVMSolidity
 tvm.sendrawmsg(TvmCell msg, uint8 flag);
@@ -4448,7 +4051,7 @@ tvm.sendrawmsg(TvmCell msg, uint8 flag);
 
 Send the internal/external message `msg` with `flag`. It's a wrapper for opcode
 `SENDRAWMSG` ([TVM][1] - A.11.10).
-Internal message `msg` can be generated by [tvm.buildIntMsg()](#tvmbuildintmsg).
+Internal message `msg` can be generated by [abi.encodeIntMsg()](#abiencodeintmsg).
 Possible values of `flag` are described here: [\<address\>.transfer()](#addresstransfer).
 
 **Note:** make sure that `msg` has a correct format and follows the [TL-B scheme][3] of `Message X`.
@@ -4494,17 +4097,19 @@ Example:
 ##### math.abs()
 
 ```TVMSolidity
-math.abs(T val) returns (T);
+math.abs(T1 val) returns (T2);
 ```
 
-Computes the absolute value of the given integer.
+Computes the absolute value of the given integer. Throws an exception if absolute value of `val` does not fit into T2.
 
 Example:
 
 ```TVMSolidity
-int a = math.abs(-100); // a == 100
-int b = -100;
-int c = math.abs(b); // c == 100
+int256 a = -100;
+uint255 b = math.abs(a); // b == 100
+
+int256 a = type(int256).min;
+uint255 b = math.abs(a); // throws an exception
 ```
 
 ##### math.modpow2()
@@ -4631,7 +4236,7 @@ int8 sign = math.sign(0); // sign == 0
 ##### tx.logicaltime
 
 ```TVMSolidity
-tx.logicaltime returns (uint64);
+tx.logicaltime (uint64);
 ```
 
 Returns the logical time of the current transaction.
@@ -4639,7 +4244,7 @@ Returns the logical time of the current transaction.
 ##### tx.storageFee
 
 ```TVMSolidity
-tx.storageFee returns (uint120);
+tx.storageFee (varUint16);
 ```
 
 Returns the storage fee paid in the current transaction. [Capabilities](#tvm-capabilities) required: `CapStorageFeeToTvm`.
@@ -4649,7 +4254,7 @@ Returns the storage fee paid in the current transaction. [Capabilities](#tvm-cap
 ##### block.timestamp
 
 ```TVMSolidity
-block.timestamp returns (uint32);
+block.timestamp (uint32);
 ```
 
 Returns the current Unix time. Unix time is the same for the all transactions from one block. 
@@ -4657,7 +4262,7 @@ Returns the current Unix time. Unix time is the same for the all transactions fr
 ##### block.logicaltime
 
 ```TVMSolidity
-block.logicaltime returns (uint64);
+block.logicaltime (uint64);
 ```
 
 Returns the starting logical time of the current block.
@@ -4766,6 +4371,495 @@ TvmCell cell = abi.encode(uint(1), uint(2), uint(3), uint(4));
 // d == 4
 ```
 
+##### abi.encodeData()
+
+```TVMSolidity
+abi.encodeData({uint256 pubkey, contract Contract, varInit: {VarName0: varValue0, ...}});
+```
+
+Generates `data` field of the `StateInit` ([TBLKCH][2] - 3.1.7.). Parameters are the same as in
+[abi.encodeStateInit()](#abiencodestateinit).
+
+```TVMSolidity
+// SimpleWallet.sol
+contract SimpleWallet {
+    uint static m_id;
+    address static m_creator;
+    // ...
+}
+
+// Usage
+TvmCell data = abi.encodeData({
+    contr: SimpleWallet,
+    varInit: {m_id: 1, m_creator: address(this)},
+    pubkey: 0x3f82435f2bd40915c28f56d3c2f07af4108931ae8bf1ca9403dcf77d96250827
+});
+TvmCell code = ...;
+TvmCell stateInit = abi.encodeStateInit({code: code, data: data});
+
+// Note, the code above can be simplified to:
+TvmCell stateInit = abi.encodeStateInit({
+    code: code,
+    contr: SimpleWallet,
+    varInit: {m_id: 1, m_creator: address(this)},
+    pubkey: 0x3f82435f2bd40915c28f56d3c2f07af4108931ae8bf1ca9403dcf77d96250827
+});
+```
+
+##### abi.encodeOldDataInit()
+
+```TVMSolidity
+abi.encodeOldDataInit() returns (TvmCell);
+```
+
+Same as [abi.encodeData()](#abiencodedata) but generate data in the format that was used in the compiler < 0.72.0. This function can be used to deploy old contracts (that was compiled < 0.72.0) from new ones. Example:
+
+File with old contracts that was compiled by compiler < 0.72.0:
+```TVMSolidity
+pragma ever-solidity >= 0.72.0; // set new version
+
+contract SimpleContractA {
+    uint static m_x0;
+    uint static m_x1;
+}
+
+// Remove all code from old contracts but state variables and contructor declaration  
+contract SimpleContractB is SimpleContractA {
+    uint static m_x2;
+    constructor(string name) {
+    }
+}
+```
+
+File with new contracts:
+```TVMSolidity
+pragma ever-solidity >= 0.72.0;
+contract ContractCreator {
+    function deploy(uint pubkey, TvmCell code) public pure returns (address) {
+        TvmCell data = abi.encodeOldDataInit({
+            pubkey: pubkey,
+            varInit: {
+                m_x0: 100,
+                m_x1: 200,
+                m_x2: 300
+            },
+            contr: SimpleContractB
+        });
+        TvmCell stateInit = abi.encodeStateInit({
+            code: code,
+            data: data
+        });
+        SimpleContractB addr = new SimpleContractB{
+            wid: 0,
+            value: 1 ever,
+            stateInit: stateInit,
+            flag: 1
+        }("Hello, world!");
+        return addr;
+    }
+}
+```
+
+##### abi.decodeData()
+
+```TVMSolidity
+abi.decodeData(ContractName, TvmSlice) returns (uint256 /*pubkey*/, uint64 /*timestamp*/, bool /*constructorFlag*/, Type1 /*var1*/, Type2 /*var2*/, ...);
+```
+
+Loads state variables from `TvmSlice` that is obtained from the field `data` of `stateInit`.
+
+Example:
+
+```
+contract A {
+	uint a = 111;
+	uint b = 22;
+	uint c = 3;
+	uint d = 44;
+	address e = address(12);
+	address f;
+}
+
+contract B {
+	function f(TvmCell data) public pure {
+		TvmSlice s = data.toSlice();
+		(uint256 pubkey, uint64 timestamp, bool flag,
+			uint a, uint b, uint c, uint d, address e, address f) = abi.decodeData(A, s);
+			
+		// pubkey - pubkey of the contract A
+		// timestamp - timestamp that used for replay protection
+		// flag - always is equal to true
+		// a == 111
+		// b == 22
+		// c == 3
+		// d == 44
+		// e == address(12)
+		// f == address.addrNone
+		// s.empty()
+	}
+}
+```
+
+##### abi.encodeStateInit()
+
+```TVMSolidity
+// 1)
+abi.encodeStateInit(TvmCell code, TvmCell data) returns (TvmCell stateInit);
+// 2)
+abi.encodeStateInit(TvmCell code, TvmCell data, uint8 splitDepth) returns (TvmCell stateInit);
+// 3)
+abi.encodeStateInit({TvmCell code, TvmCell data, uint8 splitDepth,
+            uint256 pubkey, Contract contr, varInit: {VarName0: varValue0, ...}});
+```
+
+Generates a `StateInit` ([TBLKCH][2] - 3.1.7.) from `code` and `data` `TvmCell`s.
+Member `splitDepth` of the tree of cell `StateInit`:
+
+1) is not set. Has no value.
+2) is set. `0 <= splitDepth <= 31`
+3) Arguments can also be set with names.
+
+List of possible names:
+* `code` (`TvmCell`) - defines the code field of the `StateInit`. Must be specified.
+* `data` (`TvmCell`) - defines the data field of the `StateInit`. Conflicts with `pubkey` and
+  `varInit`. Can be omitted, in this case data field would be built from `pubkey` and `varInit`.
+* `splitDepth` (`uint8`) - splitting depth. `0 <= splitDepth <= 31`. Can be omitted. By default,
+  it has no value.
+* `pubkey` (`uint256`) - defines the public key of the new contract. Conflicts with `data`.
+  Can be omitted, default value is 0.
+* `varInit` (`initializer list`) - used to set [static](#keyword-static) variables of the contract.
+  Conflicts with `data` and requires `contr` to be set. Can be omitted.
+* `contr` (`contract`) - defines the contract whose `StateInit` is being built. Mandatory to be set if the
+  option `varInit` is specified.
+
+Examples of this function usage:
+
+```TvmSolidity
+contract A {
+    uint static var0;
+    address static var1;
+}
+
+contract C {
+
+    function f() public pure {
+        TvmCell code;
+        TvmCell data;
+        uint8 depth;
+        TvmCell stateInit = abi.encodeStateInit(code, data);
+        stateInit = abi.encodeStateInit(code, data, depth);
+    }
+
+    function f1() public pure {
+        TvmCell code;
+        TvmCell data;
+        uint8 depth;
+        uint pubkey;
+        uint var0;
+        address var1;
+
+        TvmCell stateInit1 = abi.encodeStateInit({code: code, data: data, splitDepth: depth});
+        stateInit1 = abi.encodeStateInit({code: code, splitDepth: depth, varInit: {var0: var0, var1: var1}, pubkey: pubkey, contr: A});
+        stateInit1 = abi.encodeStateInit({varInit: {var0: var0, var1: var1}, pubkey: pubkey, contr: A, code: code, splitDepth: depth});
+        stateInit1 = abi.encodeStateInit({contr: A, varInit: {var0: var0, var1: var1}, pubkey: pubkey, code: code, splitDepth: depth});
+        stateInit1 = abi.encodeStateInit({contr: A, varInit: {var0: var0, var1: var1}, pubkey: pubkey, code: code});
+        stateInit1 = abi.encodeStateInit({contr: A, varInit: {var0: var0, var1: var1}, code: code, splitDepth: depth});
+    }
+}
+```
+
+##### abi.stateInitHash()
+
+```TVMSolidity
+abi.stateInitHash(uint256 codeHash, uint256 dataHash, uint16 codeDepth, uint16 dataDepth) returns (uint256);
+```
+
+Calculates hash of the stateInit for given code and data specifications.
+
+Example:
+
+```TVMSolidity
+TvmCell code = ...;
+TvmCell data = ...;
+uint codeHash = tvm.hash(code);
+uint dataHash = tvm.hash(data);
+uint16 codeDepth = code.depth();
+uint16 dataDepth = data.depth();
+uint256 hash = abi.stateInitHash(codeHash, dataHash, codeDepth, dataDepth);
+```
+
+See also [internal doc](https://github.com/tonlabs/TON-Solidity-Compiler/blob/master/docs/internal/stateInit_hash.md) to read more about this
+function mechanics.
+
+##### abi.encodeBody()
+
+```TVMSolidity
+abi.encodeBody(function, arg0, arg1, arg2, ...) returns (TvmCell);
+abi.encodeBody(function, callbackFunction, arg0, arg1, arg2, ...) returns (TvmCell);
+abi.encodeBody(contract, arg0, arg1, arg2, ...) returns (TvmCell);
+```
+
+Constructs a message body for the function call. Body can be used as a payload for  [\<address\>.transfer()](#addresstransfer).
+If the **function** is `responsible`, **callbackFunction** must be set.
+
+Example:
+
+```TVMSolidity
+contract Remote {
+    constructor(uint x, uint y, uint z) public { /* */ }
+    function func(uint256 num, int64 num2) public pure { /* */ }
+    function getCost(uint256 num) public responsible pure returns (uint128) { /* */ }
+}
+
+// deploy the contract
+TvmCell body = abi.encodeBody(Remote, 100, 200, 300);
+addr.transfer({value: 10 ever, body: body, stateInit: stateInit });
+
+// call the function
+TvmCell body = abi.encodeBody(Remote.func, 123, -654);
+addr.transfer({value: 10 ever, body: body});
+
+// call the responsible function
+TvmCell body = abi.encodeBody(Remote.getCost, onGetCost, 105);
+addr.transfer({value: 10 ever, body: body});
+```
+
+See also:
+
+* [External function calls](#external-function-calls)
+* [abi.loadFunctionParams()](#abidecodefunctionparams)
+* [abi.encodeIntMsg()](#abiencodeintmsg)
+
+##### abi.decodeFunctionParams()
+
+```TVMSolidity
+// Loads parameters of the public/external function without "responsible" attribute
+abi.decodeFunctionParams(functionName) returns (TypeA /*a*/, TypeB /*b*/, ...);
+
+// Loads parameters of the public/external function with "responsible" attribute
+abi.decodeFunctionParams(functionName) returns (uint32 callbackFunctionId, TypeA /*a*/, TypeB /*b*/, ...);
+
+// Loads constructor parameters
+abi.decodeFunctionParams(ContractName) returns (TypeA /*a*/, TypeB /*b*/, ...);
+```
+
+Loads parameters of the function or constructor (if contract type is provided). This function is usually used in
+**[onBounce](#onbounce)** function.
+
+See example of how to use **onBounce** function:
+
+* [onBounceHandler](https://github.com/tonlabs/samples/blob/master/solidity/16_onBounceHandler.sol)
+
+##### abi.codeSalt()
+
+```TVMSolidity
+abi.codeSalt(TvmCell code) returns (optional(TvmCell) optSalt);
+```
+
+If **code** contains salt, then **optSalt** contains one. Otherwise, **optSalt** doesn't contain any value.
+
+##### abi.setCodeSalt()
+
+```TVMSolidity
+abi.setCodeSalt(TvmCell code, TvmCell salt) returns (TvmCell newCode);
+```
+
+Inserts **salt** into **code** and returns new code **newCode**.
+
+##### abi.functionId()
+
+```TVMSolidity
+// id of public function
+abi.functionId(functionName) returns (uint32);
+
+// id of public constructor
+abi.functionId(ContractName) returns (uint32);
+```
+
+Returns the function id (uint32) of a public/external function or constructor.
+
+Example:
+
+```TVMSolidity
+contract MyContract {
+    constructor(uint a) public {
+    }
+        /*...*/
+    }
+
+    function f() public pure returns (uint) {
+        /*...*/
+    }
+
+    function getConstructorID() public pure returns (uint32) {
+        uint32 functionId = abi.functionId(MyContract);
+        return functionId;
+    }
+
+    function getFuncID() public pure returns (uint32) {
+        uint32 functionId = abi.functionId(f);
+        return functionId;
+    }
+}
+```
+
+See example of how to use this function:
+
+* [onBounceHandler](https://github.com/tonlabs/samples/blob/master/solidity/16_onBounceHandler.sol)
+
+##### abi.encodeExtMsg()
+
+```TVMSolidity
+abi.encodeExtMsg({
+    dest: address,
+    time: uint64,
+    expire: uint32,
+    call: {functionIdentifier [, list of function arguments]},
+    sign: bool,
+    pubkey: optional(uint256),
+    callbackId: (uint32 | functionIdentifier),
+    onErrorId: (uint32 | functionIdentifier),
+    stateInit: TvmCell,
+    signBoxHandle: optional(uint32),
+    abiVer: uint8,
+    flags: uint8
+})
+returns (TvmCell);
+```
+
+Function should be used only offchain and intended to be used only in debot contracts.
+Allows creating an external inbound message, that calls the **func** function of the
+contract on address **destination** with specified function arguments.
+
+Mandatory parameters that are used to form a src field that is used for debots:
+
+* `callbackId` - identifier of the callback function.
+* `onErrorId` - identifier of the function that is called in case of an error.
+* `signBoxHandle` - handle of the sign box entity, that engine will use to sign the message.
+
+These parameters are stored in addr_extern and placed to the src field of the message.
+Message is of type [ext_in_msg_info](https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/block/block.tlb#L127)
+and src address is of type [addr_extern](https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/block/block.tlb#L101)
+but stores special data:
+
+* callback id - 32 bits;
+* on error id - 32 bits;
+* abi version - 8 bits; Can be specified manually and contain full abi version in little endian half bytes (e.g. version = "2.3" -> abiVer: 0x32)
+* header mask - 3 bits in such order: time, expire, pubkey;
+* optional value signBoxHandle - 1 bit (whether value exists) + \[32 bits\];
+* control flags byte - 8 bits. 
+  Currently used bits:
+    1 - override time (dengine will replace time value with current time)
+    2 - override exp (dengine will replace time value with actual expire value)
+    4 - async call (dengine must send message and don't wait for the result)
+
+Other function parameters define fields of the message:
+
+* `time` - message creation timestamp. Used for replay attack protection, encoded as 64 bit Unix
+time in milliseconds.
+* `expire` - Unix time (in seconds, 32 bit) after that message should not be processed by contract.
+* `pubkey` - public key from key pair used for signing the message body. This parameter is optional
+and can be omitted.
+* `sign` - constant bool flag that shows whether message should contain signature. If set to
+**true**, message is generated with signature field filled with zeroes. This parameter is optional
+and can be omitted (in this case is equal to **false**).
+
+User can also attach stateInit to the message using `stateInit` parameter.
+
+Function throws an exception with code 64 if function is called with wrong parameters (pubkey is set
+and has value, but sign is false or omitted).
+
+Example:
+
+```TVMSolidity
+
+interface Foo {
+    function bar(uint a, uint b) external pure;
+}
+
+contract Test {
+
+    TvmCell public m_cell;
+
+    function generate0() public {
+        tvm.accept();
+        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
+        m_cell = abi.encodeExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x123, expire: 0x12345, call: {Foo.bar, 111, 88}});
+    }
+
+    function generate1() public {
+        tvm.accept();
+        optional(uint) pubkey;
+        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
+        m_cell = abi.encodeExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x123, expire: 0x12345, call: {Foo.bar, 111, 88}, pubkey: pubkey});
+    }
+
+    function generate2() public {
+        tvm.accept();
+        optional(uint) pubkey;
+        pubkey.set(0x95c06aa743d1f9000dd64b75498f106af4b7e7444234d7de67ea26988f6181df);
+        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
+        optional(uint32) signBox;
+        signBox.set(0x12333112);
+        m_cell = abi.encodeExtMsg({callbackId: 0, onErrorId: 0, dest: addr, time: 0x1771c58ef9a, expire: 0x600741e4, call: {Foo.bar, 111, 88}, pubkey: pubkey, sign: true, signBoxHandle: signBox});
+    }
+
+}
+```
+
+External inbound message can also be built and sent with construction similar to remote contract
+call. It requires suffix ".extMsg" and call options similar to `buildExtMsg` function call.
+**Note**: this type of call should be used only offchain in debot contracts.
+
+```TVMSolidity
+interface Foo {
+    function bar(uint a, uint b) external pure;
+}
+
+contract Test {
+
+    function test7() public {
+        address addr = address.makeAddrStd(0, 0x0123456789012345678901234567890123456789012345678901234567890123);
+        Foo(addr).bar{expire: 0x12345, time: 0x123}(123, 45).extMsg;
+        optional(uint) pubkey;
+        optional(uint32) signBox;
+        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey}(123, 45).extMsg;
+        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey, sign: true}(123, 45).extMsg;
+        pubkey.set(0x95c06aa743d1f9000dd64b75498f106af4b7e7444234d7de67ea26988f6181df);
+        Foo(addr).bar{expire: 0x12345, time: 0x123, pubkey: pubkey, sign: true}(123, 45).extMsg;
+        Foo(addr).bar{expire: 0x12345, time: 0x123, sign: true, signBoxHandle: signBox}(123, 45).extMsg;
+        Foo(addr).bar{expire: 0x12345, time: 0x123, sign: true, signBoxHandle: signBox, abiVer: 0x32, flags: 0x07}(123, 45).extMsg;
+    }
+}
+```
+
+##### abi.encodeIntMsg()
+
+```TVMSolidity
+abi.encodeIntMsg({
+    dest: address,
+    value: uint128,
+    call: {function, [callbackFunction,] arg0, arg1, arg2, ...},
+    bounce: bool,
+    currencies: mapping(uint32 => varUint32),
+    stateInit: TvmCell
+})
+returns (TvmCell);
+```
+
+Generates an internal outbound message that contains a function call. The result `TvmCell` can be used to send a
+message using [tvm.sendrawmsg()](#tvmsendrawmsg). If the `function` is `responsible`, then
+`callbackFunction` parameter must be set.
+
+`dest`, `value` and `call` parameters are mandatory. Another parameters can be omitted. See
+[\<address\>.transfer()](#addresstransfer) where these options and their default values are
+described.
+
+See also:
+
+* sample [22_sender.sol](https://github.com/tonlabs/samples/blob/master/solidity/22_sender.sol)
+* [abi.encodeBody()](#abiencodebody)
+
 ### **gosh** namespace
 
 All `gosh.*` functions are experimental features and are available only in certain blockchain
@@ -4950,15 +5044,13 @@ Solidity runtime error codes:
   * **51** - Contract's constructor has already been called.
   * **52** - Replay protection exception. See `timestamp` in [pragma AbiHeader](#pragma-abiheader).
   * **54** - `<array>.pop` call for an empty array.
-  * **55** - See [tvm.insertPubkey()](#tvminsertpubkey).
   * **57** - External inbound message is expired. See `expire` in [pragma AbiHeader](#pragma-abiheader).
   * **58** - External inbound message has no signature but has public key. See `pubkey` in [pragma AbiHeader](#pragma-abiheader).
   * **60** - Inbound message has wrong function id. In the contract there are no functions with such function id and there is no fallback function that could handle the message. See [fallback](#fallback).
   * **61** - Deploying `StateInit` has no public key in `data` field.
   * **62** - Reserved for internal usage.
   * **63** - See [\<optional(T)\>.get()](#optionaltget).
-  * **64** - `tvm.buildExtMSg()` call with wrong parameters. See [tvm.buildExtMsg()](#tvmbuildextmsg).
-  * **66** - Convert an integer to a string with width less than number length. See [format()](#format).
+  * **64** - `abi.encodeExtMsg()` call with wrong parameters. See [abi.encodeExtMsg()](#abiencodeextmsg).
   * **67** - See [gasToValue](#gastovalue) and [valueToGas](#valuetogas).
   * **68** - There is no config parameter 20 or 21.
   * **69** - Zero to the power of zero calculation (`0**0` in TVM Solidity style or `0^0`).
diff --git a/Cargo.lock b/Cargo.lock
index 6af72adf..3eabf46f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -51,9 +51,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea5d730647d4fadd988536d06fecce94b7b4f2a7efdae548f1cf4b63205518ab"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
 dependencies = [
  "memchr",
 ]
@@ -75,9 +75,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.4"
+version = "0.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
+checksum = "96b09b5178381e0874812a9b157f7fe84982617e48f71f4e3235482775e5b540"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -89,33 +89,33 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.4"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140"
+checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.0"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
 dependencies = [
  "windows-sys",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.1"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
+checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
 dependencies = [
  "anstyle",
  "windows-sys",
@@ -123,9 +123,9 @@ dependencies = [
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.12"
+version = "2.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88903cb14723e4d4003335bb7f8a14f27691649105346a0f0957466c096adfe6"
+checksum = "00ad3f3a942eee60335ab4342358c161ee296829e0d16ff42fc1d6cb07815467"
 dependencies = [
  "anstyle",
  "bstr",
@@ -142,7 +142,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
  "winapi",
 ]
@@ -207,11 +207,23 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "blst"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c94087b935a822949d3291a9989ad2b2051ea141eda0fd4e478a75f6aa3e604b"
+dependencies = [
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
+]
+
 [[package]]
 name = "bstr"
-version = "1.6.2"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c2f7349907b712260e64b0afe2f84692af14a454be26187d9df565c7f69266a"
+checksum = "c48f0051a4b4c5e0b6d365cd04af53aeaa209e3cc15ec2cdb69e73cc87fbd0dc"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -220,15 +232,15 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.14.0"
+version = "3.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+checksum = "d32a994c2b3ca201d9b263612a374263f05e7adde37c4707f693dcd375076d1f"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
@@ -247,9 +259,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.31"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -270,9 +282,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.6"
+version = "4.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
+checksum = "c918d541ef2913577a0f9566e9ce27cb35b6df072075769e0b26cb5a554520da"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -280,9 +292,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.6"
+version = "4.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
+checksum = "9f3e7391dad68afb0c2ede1bf619f579a3dc9c2ec67f089baa397123a2f3d1eb"
 dependencies = [
  "anstream",
  "anstyle",
@@ -292,21 +304,21 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.4.2"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
+checksum = "307bc0538d5f0f83b8248db3087aa92fe504e4691294d0c96c0eabc33f47ba47"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
+checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
 
 [[package]]
 name = "cmake"
@@ -325,21 +337,21 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[package]]
 name = "const-oid"
-version = "0.9.5"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28c122c3980598d243d63d9a704629a2d748d101f278052ff068be5a4423ab6f"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.9"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
 dependencies = [
  "libc",
 ]
@@ -355,9 +367,9 @@ dependencies = [
 
 [[package]]
 name = "crc-catalog"
-version = "2.2.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
 [[package]]
 name = "crypto-common"
@@ -393,9 +405,9 @@ dependencies = [
 
 [[package]]
 name = "curve25519-dalek"
-version = "4.1.1"
+version = "4.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e89b8c6a2e4b1f45971ad09761aafb85514a84744b67a95e32c3cc1352d1f65c"
+checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -410,13 +422,13 @@ dependencies = [
 
 [[package]]
 name = "curve25519-dalek-derive"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fdaf97f4804dcebfa5862639bc9ce4121e82140bec2a987ac5140294865b5b"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
 ]
 
 [[package]]
@@ -477,12 +489,12 @@ dependencies = [
 
 [[package]]
 name = "ed25519"
-version = "2.2.2"
+version = "2.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60f6d271ca33075c88028be6f04d502853d63a5ece419d269c15315d4fc1cf1d"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
 dependencies = [
  "pkcs8",
- "signature 2.1.0",
+ "signature 2.2.0",
 ]
 
 [[package]]
@@ -501,24 +513,19 @@ dependencies = [
 
 [[package]]
 name = "ed25519-dalek"
-version = "2.0.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7277392b266383ef8396db7fdeb1e77b6c52fed775f5df15bb24f35b72156980"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
- "curve25519-dalek 4.1.1",
- "ed25519 2.2.2",
+ "curve25519-dalek 4.1.2",
+ "ed25519 2.2.3",
  "rand_core 0.6.4",
  "serde",
  "sha2 0.10.8",
+ "subtle",
  "zeroize",
 ]
 
-[[package]]
-name = "either"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
-
 [[package]]
 name = "failure"
 version = "0.1.8"
@@ -543,9 +550,9 @@ dependencies = [
 
 [[package]]
 name = "fiat-crypto"
-version = "0.2.1"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0870c84016d4b481be5c9f323c24f65e31e901ae618f0e80f4308fb00de1d2d"
+checksum = "1676f435fc1dadde4d03e43f5d62b259e1ce5f40bd4ffb21db2b42ebe59c1382"
 
 [[package]]
 name = "float-cmp"
@@ -579,9 +586,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.10"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
 dependencies = [
  "cfg-if",
  "libc",
@@ -590,9 +597,15 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.28.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "heck"
@@ -609,6 +622,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hermit-abi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd5256b483761cd23699d0da46cc6fd2ee3be420bbe6d020ae4a091e70b7e9fd"
+
 [[package]]
 name = "hex"
 version = "0.3.2"
@@ -623,16 +642,16 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.57"
+version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
- "windows",
+ "windows-core",
 ]
 
 [[package]]
@@ -644,26 +663,17 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.64"
+version = "0.3.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+checksum = "406cda4b368d531c842222cf9d2600a9a4acce8d29423695379c6868a143a9ee"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -676,9 +686,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.148"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "lockfree"
@@ -696,15 +706,15 @@ checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 
 [[package]]
 name = "memchr"
-version = "2.6.4"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
 dependencies = [
  "adler",
 ]
@@ -742,9 +752,9 @@ dependencies = [
 
 [[package]]
 name = "num-complex"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214"
+checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6"
 dependencies = [
  "num-traits",
 ]
@@ -762,19 +772,18 @@ dependencies = [
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
 [[package]]
 name = "num-iter"
-version = "0.1.43"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -795,27 +804,37 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.6",
+ "libc",
+]
+
 [[package]]
 name = "object"
-version = "0.32.1"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "opaque-debug"
@@ -841,9 +860,9 @@ dependencies = [
 
 [[package]]
 name = "platforms"
-version = "3.1.2"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4503fa043bf02cee09a9582e9554b4c6403b2ef55e4612e96561d294419429f8"
+checksum = "626dec3cac7cc0e1577a2ec3fc496277ec2baa084bebad95bb6fdbfae235f84c"
 
 [[package]]
 name = "ppv-lite86"
@@ -853,14 +872,13 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "predicates"
-version = "3.0.4"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dfc28575c2e3f19cb3c73b93af36460ae898d426eba6fc15b9bd2a5220758a0"
+checksum = "68b87bfd4605926cdfefc1c3b5f8fe560e3feca9d5552cf68c466d3d8236c7e8"
 dependencies = [
  "anstyle",
  "difflib",
  "float-cmp",
- "itertools",
  "normalize-line-endings",
  "predicates-core",
  "regex",
@@ -884,18 +902,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.67"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -959,7 +977,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.10",
+ "getrandom 0.2.12",
 ]
 
 [[package]]
@@ -973,9 +991,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.6"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -985,9 +1003,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.9"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -996,9 +1014,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.5"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "rustc-demangle"
@@ -1017,41 +1035,41 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.15"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 
 [[package]]
 name = "semver"
-version = "1.0.19"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0"
+checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
 
 [[package]]
 name = "serde"
-version = "1.0.188"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.188"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.107"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
 dependencies = [
  "itoa",
  "ryu",
@@ -1090,19 +1108,22 @@ checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
 
 [[package]]
 name = "signature"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "rand_core 0.6.4",
+]
 
 [[package]]
 name = "smallvec"
-version = "1.11.1"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 
 [[package]]
 name = "sold"
-version = "0.72.0"
+version = "0.73.0"
 dependencies = [
  "assert_cmd",
  "atty",
@@ -1123,9 +1144,9 @@ dependencies = [
 
 [[package]]
 name = "spki"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
  "base64ct",
  "der",
@@ -1142,9 +1163,9 @@ dependencies = [
 
 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "5ee073c9e4cd00e28217186dbe12796d692868f432bf2e97ee73bed0c56dfa01"
 
 [[package]]
 name = "subtle"
@@ -1165,9 +1186,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.37"
+version = "2.0.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8"
+checksum = "915aea9e586f80826ee59f8453c1101f9d1c4b3964cd2460185ee8e299ada496"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1192,10 +1213,19 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
 
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
 [[package]]
 name = "ton_abi"
-version = "2.3.147"
-source = "git+https://github.com/tonlabs/ever-abi.git?tag=2.3.147#a3194277b02417e4f01221f5cf6b943fc4bd6653"
+version = "2.4.14"
+source = "git+https://github.com/tonlabs/ever-abi.git?tag=2.4.14#df0aacbd2059f5bf16c7b29000b32a957a8440e2"
 dependencies = [
  "base64 0.10.1",
  "byteorder",
@@ -1214,13 +1244,9 @@ dependencies = [
 
 [[package]]
 name = "ton_block"
-version = "1.9.104"
-source = "git+https://github.com/tonlabs/ever-block.git?tag=1.9.104#2c6cf392260d047cff5962572a628c207ea28309"
+version = "1.9.122"
+source = "git+https://github.com/tonlabs/ever-block.git?tag=1.9.122#4330c36880e3bef543e18f4f6af1bb323da97b2a"
 dependencies = [
- "base64 0.13.1",
- "crc",
- "ed25519 1.5.3",
- "ed25519-dalek 1.0.1",
  "failure",
  "hex 0.4.3",
  "log",
@@ -1232,8 +1258,8 @@ dependencies = [
 
 [[package]]
 name = "ton_labs_assembler"
-version = "1.4.15"
-source = "git+https://github.com/tonlabs/ever-assembler.git?tag=1.4.15#0d0db5b69a5eec932dd53b83fb6c02c89897c1fe"
+version = "1.4.39"
+source = "git+https://github.com/tonlabs/ever-assembler.git?tag=1.4.39#fc2ac6d6f8ed1ceda60373de2188e844a88f0ea3"
 dependencies = [
  "clap",
  "failure",
@@ -1249,15 +1275,16 @@ dependencies = [
 
 [[package]]
 name = "ton_types"
-version = "2.0.28"
-source = "git+https://github.com/tonlabs/ever-types.git?tag=2.0.28#e6ce975e741634638e4d42f4e8b273ea4d046370"
+version = "2.0.32"
+source = "git+https://github.com/tonlabs/ever-types.git?tag=2.0.32#adc33ce8001ba52de4de9c2168e1f8e6a83ef5e0"
 dependencies = [
  "aes-ctr",
  "base64 0.13.1",
+ "blst",
  "crc",
- "curve25519-dalek 4.1.1",
- "ed25519 2.2.2",
- "ed25519-dalek 2.0.0",
+ "curve25519-dalek 4.1.2",
+ "ed25519 2.2.3",
+ "ed25519-dalek 2.1.1",
  "failure",
  "hex 0.4.3",
  "lazy_static",
@@ -1276,8 +1303,8 @@ dependencies = [
 
 [[package]]
 name = "ton_vm"
-version = "1.8.211"
-source = "git+https://github.com/tonlabs/ever-vm.git?tag=1.8.211#ca3e6e70793a86ec20d27d1463030ca864bf1f59"
+version = "1.9.6"
+source = "git+https://github.com/tonlabs/ever-vm.git?tag=1.9.6#fd7864b934e89c8c3578efcd5575e6cf116a9b03"
 dependencies = [
  "ed25519 1.5.3",
  "ed25519-dalek 1.0.1",
@@ -1365,9 +1392,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.87"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+checksum = "c1e124130aee3fb58c5bdd6b639a0509486b0338acaaae0c84a5124b0f588b7f"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -1375,24 +1402,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.87"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+checksum = "c9e7e1900c352b609c8488ad12639a311045f40a35491fb69ba8c12f758af70b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.87"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+checksum = "b30af9e2d358182b5c7449424f017eba305ed32a7010509ede96cdc4696c46ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1400,22 +1427,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.87"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.87"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+checksum = "4f186bd2dcf04330886ce82d6f33dd75a7bfcf69ecf5763b89fcde53b6ac9838"
 
 [[package]]
 name = "winapi"
@@ -1440,28 +1467,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "windows"
-version = "0.48.0"
+name = "windows-core"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
  "windows-targets",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.48.0"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
  "windows-targets",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
 dependencies = [
  "windows_aarch64_gnullvm",
  "windows_aarch64_msvc",
@@ -1474,53 +1501,53 @@ dependencies = [
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.5"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
 
 [[package]]
 name = "x25519-dalek"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb66477291e7e8d2b0ff1bcb900bf29489a9692816d79874bea351e7a8b6de96"
+checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
 dependencies = [
- "curve25519-dalek 4.1.1",
+ "curve25519-dalek 4.1.2",
  "rand_core 0.6.4",
  "serde",
  "zeroize",
@@ -1528,9 +1555,9 @@ dependencies = [
 
 [[package]]
 name = "zeroize"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
 dependencies = [
  "zeroize_derive",
 ]
@@ -1543,5 +1570,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.37",
+ "syn 2.0.49",
 ]
diff --git a/Changelog.md b/Changelog.md
index 7b61ecf4..97c557a1 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,4 +1,57 @@
-### 0.72.0 (2023-??-??)
+### 0.73.0 (2024-02-12)
+
+Update compiler frontend (from original version 0.8.17 to 0.8.24). Full changelog can be found [here](./compiler/Changelog.md).
+
+Breaking changes:
+ * Supported [ABI 2.4](https://github.com/tonlabs/ever-abi/blob/master/CHANGELOG.md#version-240).
+ * Deleted `tvm.insertPubkey()` function.
+ * Deleted `address.makeAddrNone()` function. Use [address.addrNone](./API.md#addressaddrnone).
+ * Default value for `address` type was `address(0)` but now it is [address.addrNone](./API.md#addressaddrnone).
+ * `byteN` in `*abi.json` file marked as `fixedbytesN`. See [ABI.md](https://github.com/tonlabs/ever-abi/blob/master/docs/ABI.md#fixedbytesn).
+ * [abi.encodeStateInit()](./API.md#abiencodestateinit), [abi.encodeData()](./API.md#abiencodedata) functions and [Deploy via new](./API.md#deploy-via-new) generate contract's data in the new format. To deploy old contracts (with version < 0.72.0) from new ones (with version >= 0.72.0) use [abi.encodeOldDataInit()](./API.md#abiencodeolddatainit).
+ * [format()](API.md#format) no longer throws an exception if formatted value exceeds the specified width. E.g. `format("{:1d}", 10) == "10"` now is correct, no exception.
+ * Functions and constructions previously working with `uint128` value, now using `varUint16`:
+   * [\<address\>.transfer()](API.md#addresstransfer)
+   * [deploy via **new**](API.md#deploy-via-new)
+   * [external function calls](API.md#external-function-calls)
+   * [\<address\>.balance](API.md#addressbalance)
+   * [msg.value](API.md#msgvalue)
+   * [abi.encodeIntMsg()](API.md#abiencodeintmsg)
+   * [return](API.md#return)
+ * Control construction [repeat](API.md#repeat) takes `uint31` instead of `uint256`.
+ * Supported [\<Integer\>.cast()](API.md#integercast) and changed conversion.
+
+Bugfixes:
+ * Fixed compiler assert fault that occurred in the case of using [user-defined value types](https://docs.soliditylang.org/en/latest/types.html#user-defined-value-types) as return parameter of public/external function.
+ * Fixed segmentation fault of the compiler that could occur in some cases of using invalid rational number (too large or division by zero), e.g. `math.muldiv(2**500, 1, 1);`.
+ * Now [\<string\>.substr()](API.md#stringsubstr) does not throw an exception if `pos + count > string.byteLength()`.
+ * Fixed minor bugs in TypeChecker.
+
+Compiler features:
+ * Supported defining operators for a [user-defined type](API.md#user-defined-type).
+ * Supported [keyword nostorage](API.md#keyword-nostorage).
+ * Now you can use the keyword [coins](API.md#varint-and-varuint) as an alias for `varUint16`
+
+Gas optimizations:
+ * Optimized functions that work with strings: concatenation, substring, format etc.
+ * Assorted stack optimizations.
+
+Other changes:
+ * Renamed some functions. Old functions are available and marked as deprecated. Renaming:
+   * `tvm.buildDataInit()` -> `abi.encodeData()`
+   * `<TvmSlice>.loadStateVars()` -> `abi.decodeData()`
+   * `tvm.buildStateInit()` -> `abi.encodeStateInit()`
+   * `tvm.stateInitHash()` -> `abi.stateInitHash()`
+   * `tvm.codeSalt()` -> `abi.codeSalt()`
+   * `tvm.setCodeSalt()` -> `abi.setCodeSalt()`
+   * `tvm.functionId()` -> `abi.functionId()`
+   * `tvm.buildExtMsg()` -> `abi.encodeExtMsg()`
+   * `tvm.buildIntMsg()` -> `abi.encodeIntMsg()`
+   * `tvm.encodeBody()` -> `abi.encodeBody()`
+   * `<TvmSlice>.loadFunctionParams()` -> `abi.decodeFunctionParams()`
+ * Marked functions `<TvmSlice>.loadTons()` and `<TvmBuilder>.storeTons()` as deprecated. Use `<TvmSlice>.load()` and `<TvmBuilder>.store()` that take `varUint16` type.
+
+### 0.72.0 (2023-10-31)
 
 Use [sold](https://github.com/tonlabs/TON-Solidity-Compiler/tree/master/sold) to compile contracts. If you used `solc`+`tvm_linker`, then use `solc`+[asm](https://github.com/tonlabs/ever-assembler). Generated `*.code` files have some another format.
 
diff --git a/README.md b/README.md
index b5fda561..017496ac 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ cd TON-Solidity-Compiler
 compiler\scripts\install_deps.ps1
 mkdir build
 cd build
-cmake -DBoost_DIR="..\compiler\deps\boost\lib\cmake\Boost-1.77.0" -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..\compiler
+cmake -DBOOST_ROOT="..\compiler\deps\boost\" -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded ..\compiler
 cmake --build . --config Release -- /m
 ```
 
diff --git a/compiler/.clang-format b/compiler/.clang-format
index edd5de4d..95b0feba 100644
--- a/compiler/.clang-format
+++ b/compiler/.clang-format
@@ -12,7 +12,7 @@ Language: Cpp
 BasedOnStyle: LLVM
 AccessModifierOffset: -4
 AlignAfterOpenBracket: AlwaysBreak
-AlignEscapedNewlinesLeft: true
+AlignEscapedNewlines: Left
 AlwaysBreakAfterReturnType: None
 AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
diff --git a/compiler/.gitignore b/compiler/.gitignore
index 4f171718..8ca5f86e 100644
--- a/compiler/.gitignore
+++ b/compiler/.gitignore
@@ -27,6 +27,9 @@ __pycache__
 *.a
 *.lib
 
+# ignore git mergetool backup files
+*.orig
+
 # Executables
 *.exe
 *.out
@@ -38,6 +41,7 @@ emscripten_build/
 /docs/_build
 /docs/_static/robots.txt
 /deps
+/reports
 
 # vim stuff
 [._]*.sw[a-p]
diff --git a/compiler/.readthedocs.yml b/compiler/.readthedocs.yml
new file mode 100644
index 00000000..c0c139b7
--- /dev/null
+++ b/compiler/.readthedocs.yml
@@ -0,0 +1,18 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+  builder: html
+  configuration: docs/conf.py
+
+formats:
+  - pdf
+  - epub
+
+python:
+  install:
+    - requirements: docs/requirements.txt
diff --git a/compiler/CMakeLists.txt b/compiler/CMakeLists.txt
index 75a8c5fe..d042cb0e 100644
--- a/compiler/CMakeLists.txt
+++ b/compiler/CMakeLists.txt
@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.13.0)
 
-set(ETH_CMAKE_DIR   "${CMAKE_CURRENT_LIST_DIR}/cmake"   CACHE PATH "The the path to the cmake directory")
+set(ETH_CMAKE_DIR   "${CMAKE_CURRENT_LIST_DIR}/cmake"   CACHE PATH "The path to the cmake directory")
 list(APPEND CMAKE_MODULE_PATH ${ETH_CMAKE_DIR})
 
 # Set the build type, if none was specified.
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-	if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
+	if(EXISTS "${PROJECT_SOURCE_DIR}/.git")
 		set(DEFAULT_BUILD_TYPE "RelWithDebInfo")
 	else()
 		set(DEFAULT_BUILD_TYPE "Release")
@@ -21,7 +21,7 @@ include(EthPolicy)
 eth_policy()
 
 # project name and version should be set after cmake_policy CMP0048
-set(PROJECT_VERSION "0.72.0")
+set(PROJECT_VERSION "0.73.0")
 # OSX target needed in order to support std::visit
 set(CMAKE_OSX_DEPLOYMENT_TARGET "10.14")
 project(solidity VERSION ${PROJECT_VERSION} LANGUAGES C CXX)
@@ -37,6 +37,7 @@ option(WITH_TESTS "Run solc tests" OFF)
 option(SOLC_STATIC_STDLIBS "Link solc against static versions of libgcc and libstdc++ on supported platforms" OFF)
 option(STRICT_Z3_VERSION "Use the latest version of Z3" ON)
 option(PEDANTIC "Enable extra warnings and pedantic build flags. Treat all warnings as errors." ON)
+option(PROFILE_OPTIMIZER_STEPS "Output performance metrics for the optimiser steps." OFF)
 
 # Setup cccache.
 include(EthCcache)
@@ -53,6 +54,11 @@ find_package(Threads)
 if(NOT PEDANTIC)
   message(WARNING "-- Pedantic build flags turned off. Warnings will not make compilation fail. This is NOT recommended in development builds.")
 endif()
+
+if (PROFILE_OPTIMIZER_STEPS)
+    add_definitions(-DPROFILE_OPTIMIZER_STEPS)
+endif()
+
 # Figure out what compiler and system are we using
 include(EthCompilerSettings)
 
@@ -61,22 +67,21 @@ include(EthUtils)
 
 # Create license.h from LICENSE.txt and template
 # Converting to char array is required due to MSVC's string size limit.
-file(READ ${CMAKE_SOURCE_DIR}/LICENSE.txt LICENSE_TEXT HEX)
+file(READ ${PROJECT_SOURCE_DIR}/LICENSE.txt LICENSE_TEXT HEX)
 string(REGEX MATCHALL ".." LICENSE_TEXT "${LICENSE_TEXT}")
 string(REGEX REPLACE ";" ",\n\t0x" LICENSE_TEXT "${LICENSE_TEXT}")
 set(LICENSE_TEXT "0x${LICENSE_TEXT}")
 
-configure_file("${CMAKE_SOURCE_DIR}/cmake/templates/license.h.in" include/license.h)
+configure_file("${PROJECT_SOURCE_DIR}/cmake/templates/license.h.in" include/license.h)
 
 include(EthOptions)
 configure_project(TESTS)
-set(LATEST_Z3_VERSION "4.11.0")
-set(MINIMUM_Z3_VERSION "4.8.0")
 
 add_subdirectory(libsolutil)
 add_subdirectory(liblangutil)
 add_subdirectory(libsolidity)
 add_subdirectory(libsolc)
+add_subdirectory(libstdlib)
 if (WITH_TESTS)
 	add_subdirectory(test2)
 endif()
diff --git a/compiler/CODE_OF_CONDUCT.md b/compiler/CODE_OF_CONDUCT.md
index 36813f36..4c75649a 100644
--- a/compiler/CODE_OF_CONDUCT.md
+++ b/compiler/CODE_OF_CONDUCT.md
@@ -55,10 +55,8 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at chris@ethereum.org which only goes to
-Christian Reitwiessner or axic@ethereum.org which only goes to Alex Beregszaszi.
-To report an issue involving either of them please email Hudson Jameson at
-hudson@ethereum.org.
+reported by contacting the project team at solidity@ethereum.org.
+To report an issue involving the Solidity team please email José Pedro Cabrita at zepedro@ethereum.org.
 All complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
diff --git a/compiler/CODING_STYLE.md b/compiler/CODING_STYLE.md
index 674c2add..5b9129fb 100644
--- a/compiler/CODING_STYLE.md
+++ b/compiler/CODING_STYLE.md
@@ -51,10 +51,11 @@ To set indentation and tab width settings uniformly, the repository contains an
 ## 1. Namespaces
 
 1. No `using namespace` declarations in header files.
-2. Use `using namespace std;` in cpp files, but avoid importing namespaces from boost and others.
-3. All symbols should be declared in a namespace except for final applications.
-4. Use anonymous namespaces for helpers whose scope is a cpp file only.
-5. Preprocessor symbols should be prefixed with the namespace in all-caps and an underscore.
+2. `using namespace solidity;` and other project local namespaces is fine in cpp files, and generally encouraged.
+3. Avoid `using namespace` at file level for third party libraries, such as boost, ranges, etc.
+4. All symbols should be declared in a namespace except for final applications.
+5. Use anonymous namespaces for helpers whose scope is a cpp file only.
+6. Preprocessor symbols should be prefixed with the namespace in all-caps and an underscore.
 
 Only in the header:
 ```cpp
@@ -65,16 +66,6 @@ std::tuple<float, float> meanAndSigma(std::vector<float> const& _v);
 }
 ```
 
-Only in the cpp file:
-```cpp
-#include <cassert>
-using namespace std;
-tuple<float, float> myNamespace::meanAndSigma(vector<float> const& _v)
-{
-  // ...
-}
-```
-
 ## 2. Preprocessor
 
 1. File comment is always at top, and includes:
@@ -116,7 +107,7 @@ Use `solAssert` and `solUnimplementedAssert` generously to check assumptions tha
 1. {Typename} + {qualifiers} + {name}.
 2. Only one per line.
 3. Associate */& with type, not variable (at ends with parser, but more readable, and safe if in conjunction with (b)).
-4. Favour declarations close to use; don't habitually declare at top of scope ala C.
+4. Favour declarations close to use; do not habitually declare at top of scope ala C.
 5. Pass non-trivial parameters as const reference, unless the data is to be copied into the function, then either pass by const reference or by value and use std::move.
 6. If a function returns multiple values, use std::tuple (std::pair acceptable) or better introduce a struct type. Do not use */& arguments.
 7. Use parameters of pointer type only if ``nullptr`` is a valid argument, use references otherwise. Often, ``std::optional`` is better suited than a raw pointer.
@@ -179,7 +170,7 @@ for (map<ComplexTypeOne, ComplexTypeTwo>::iterator i = l.begin(); i != l.end();
 
 ## 9. Naming
 
-1. Avoid unpronouncable names.
+1. Avoid unpronounceable names.
 2. Names should be shortened only if they are extremely common, but shortening should be generally avoided
 3. Avoid prefixes of initials (e.g. do not use `IMyInterface`, `CMyImplementation`)
 4. Find short, memorable & (at least semi-) descriptive names for commonly used classes or name-fragments:
diff --git a/compiler/Changelog.md b/compiler/Changelog.md
index 2167d5b7..d36470b0 100644
--- a/compiler/Changelog.md
+++ b/compiler/Changelog.md
@@ -1,3 +1,203 @@
+### 0.8.24 (2024-01-25)
+
+Language Features:
+ * Introduce global ``block.blobbasefee`` for retrieving the blob base fee of the current block.
+ * Introduce global function ``blobhash(uint)`` for retrieving versioned hashes of blobs, akin to the homonymous Yul builtin.
+ * Yul: Introduce builtin ``blobbasefee()`` for retrieving the blob base fee of the current block.
+ * Yul: Introduce builtin ``blobhash()`` for retrieving versioned hashes of blobs associated with the transaction.
+ * Yul: Introduce builtin ``mcopy()`` for cheaply copying data between memory areas.
+ * Yul: Introduce builtins ``tload()`` and ``tstore()`` for transient storage access.
+
+
+Compiler Features:
+* EVM: Support for the EVM Version "Cancun".
+* SMTChecker: Support `bytes.concat` except when string literals are passed as arguments.
+* Standard JSON Interface: Add experimental support to import EVM assembly in the format used by ``--asm-json``.
+* TypeChecker: Comparison of internal function pointers now yields a warning, as it can produce unexpected results with the legacy pipeline enabled.
+
+
+Bugfixes:
+ * AST import: Fix bug when importing inline assembly with empty ``let`` variable declaration.
+
+
+### 0.8.23 (2023-11-08)
+
+Important Bugfixes:
+ * Optimizer: Fix block deduplicator bug which led to blocks which are identical apart from the contents of ``verbatim`` instructions to be treated as equivalent and thus collapsed into a single one.
+
+
+Compiler Features:
+ * Commandline Interface: An empty ``--yul-optimizations`` sequence can now be always provided.
+ * Standard JSON Interface: An empty ``optimizerSteps`` sequence can now always be provided.
+
+
+### 0.8.22 (2023-10-25)
+
+Language Features:
+ * Allow defining events at file level.
+
+
+Compiler Features:
+ * Code Generator: Remove redundant overflow checks of certain ``for`` loops when the counter variable cannot overflow.
+ * Commandline Interface: Add ``--no-import-callback`` option that prevents the compiler from loading source files not given explicitly on the CLI or in Standard JSON input.
+ * Commandline Interface: Add an experimental ``--import-asm-json`` option that can import EVM assembly in the format used by ``--asm-json``.
+ * Commandline Interface: Use proper severity and coloring also for error messages produced outside of the compilation pipeline.
+ * EVM: Deprecate support for "homestead", "tangerineWhistle", "spuriousDragon" and "byzantium" EVM versions.
+ * Parser: Remove the experimental error recovery mode (``--error-recovery`` / ``settings.parserErrorRecovery``).
+ * SMTChecker: Support user-defined operators.
+ * Yul Optimizer: If ``PUSH0`` is supported, favor zero literals over storing zero values in variables.
+ * Yul Optimizer: Run the ``Rematerializer`` and ``UnusedPruner`` steps at the end of the default clean-up sequence.
+
+
+Bugfixes:
+ * AST: Fix wrong initial ID for Yul nodes in the AST.
+ * Code Generator: Fix output from via-IR code generator being dependent on which files were discovered by import callback. In some cases, a different AST ID assignment would alter the order of functions in internal dispatch, resulting in superficially different but semantically equivalent bytecode.
+ * NatSpec: Fix internal error when requesting userdoc or devdoc for a contract that emits an event defined in a foreign contract or interface.
+ * SMTChecker: Fix encoding error that causes loops to unroll after completion.
+ * SMTChecker: Fix inconsistency on constant condition checks when ``while`` or ``for`` loops are unrolled before the condition check.
+ * Yul Optimizer: Fix replacement decisions during CSE being affected by Yul variable names generated by the compiler, resulting in different (but equivalent) bytecode in some situations.
+
+
+### 0.8.21 (2023-07-19)
+
+Important Bugfixes:
+ * Code Generator: Always generate code for the expression in ``<expression>.selector`` in the legacy code generation pipeline.
+ * Yul Optimizer: Fix ``FullInliner`` step (``i``) not preserving the evaluation order of arguments passed into inlined functions in code that is not in expression-split form (i.e. when using a custom optimizer sequence in which the step not preceded by ``ExpressionSplitter`` (``x``)).
+
+
+Language Features:
+ * Allow qualified access to events from other contracts.
+ * Relax restrictions on initialization of immutable variables. Reads and writes may now happen at any point at construction time outside of functions and modifiers. Explicit initialization is no longer mandatory.
+
+
+Compiler Features:
+ * Commandline Interface: Add ``--ast-compact-json`` output in assembler mode.
+ * Commandline Interface: Add ``--ir-ast-json`` and ``--ir-optimized-ast-json`` outputs for Solidity input, providing AST in compact JSON format for IR and optimized IR.
+ * Commandline Interface: Respect ``--optimize-yul`` and ``--no-optimize-yul`` in compiler mode and accept them in assembler mode as well. ``--optimize --no-optimize-yul`` combination now allows enabling EVM assembly optimizer without enabling Yul optimizer.
+ * EWasm: Remove EWasm backend.
+ * Parser: Introduce ``pragma experimental solidity``, which will enable an experimental language mode that in particular has no stability guarantees between non-breaking releases and is not suited for production use.
+ * SMTChecker: Add ``--model-checker-print-query`` CLI option and ``settings.modelChecker.printQuery`` JSON option to output the SMTChecker queries in the SMTLIB2 format. This requires using ``smtlib2`` solver only.
+ * Standard JSON Interface: Add ``ast`` file-level output for Yul input.
+ * Standard JSON Interface: Add ``irAst`` and ``irOptimizedAst`` contract-level outputs for Solidity input, providing AST in compact JSON format for IR and optimized IR.
+ * Yul Optimizer: Remove experimental ``ReasoningBasedSimplifier`` optimization step.
+ * Yul Optimizer: Stack-to-memory mover is now enabled by default whenever possible for via IR code generation and pure Yul compilation.
+
+
+Bugfixes:
+ * Code Generator: Disallow complex expressions whose results are types, built-ins, modules or some unassignable functions. The legacy code generation pipeline would not actually evaluate them, discarding any side-effects they might have.
+ * Code Generator: Fix not entirely deterministic order of functions in unoptimized Yul output. The choice of C++ compiler in some cases would result in different (but equivalent) bytecode (especially from native binaries vs emscripten binaries).
+ * Commandline Interface: Fix internal error when using ``--stop-after parsing`` and requesting some of the outputs that require full analysis or compilation.
+ * Commandline Interface: It is no longer possible to specify both ``--optimize-yul`` and ``--no-optimize-yul`` at the same time.
+ * SMTChecker: Fix encoding of side-effects inside ``if`` and ``ternary conditional``statements in the BMC engine.
+ * SMTChecker: Fix false negative when a verification target can be violated only by trusted external call from another public function.
+ * SMTChecker: Fix generation of invalid SMT-LIB2 scripts in BMC engine with trusted mode for external calls when CHC engine times out.
+ * SMTChecker: Fix internal error caused by incorrectly classifying external function call using function pointer as a public getter.
+ * SMTChecker: Fix internal error caused by using external identifier to encode member access to functions that take an internal function as a parameter.
+ * Standard JSON Interface: Fix an incomplete AST being returned when analysis is interrupted by certain kinds of fatal errors.
+ * Type Checker: Disallow using certain unassignable function types in complex expressions.
+ * Type Checker: Function declaration types referring to different declarations are no longer convertible to each other.
+ * Yul Optimizer: Ensure that the assignment of memory slots for variables moved to memory does not depend on AST IDs that may depend on whether additional files are included during compilation.
+ * Yul Optimizer: Fix ``FullInliner`` step not ignoring code that is not in expression-split form.
+ * Yul Optimizer: Fix optimized IR being unnecessarily passed through the Yul optimizer again before bytecode generation.
+
+
+AST Changes:
+ * AST: Add the ``experimentalSolidity`` field to the ``SourceUnit`` nodes, which indicate whether the experimental parsing mode has been enabled via ``pragma experimental solidity``.
+
+
+### 0.8.20 (2023-05-10)
+
+Compiler Features:
+ * Assembler: Use ``push0`` for placing ``0`` on the stack for EVM versions starting from "Shanghai". This decreases the deployment and runtime costs.
+ * EVM: Set default EVM version to "Shanghai".
+ * EVM: Support for the EVM Version "Shanghai".
+ * NatSpec: Add support for NatSpec documentation in ``enum`` definitions.
+ * NatSpec: Add support for NatSpec documentation in ``struct`` definitions.
+ * NatSpec: Include NatSpec from events that are emitted by a contract but defined outside of it in userdoc and devdoc output.
+ * Optimizer: Re-implement simplified version of ``UnusedAssignEliminator`` and ``UnusedStoreEliminator``. It can correctly remove some unused assignments in deeply nested loops that were ignored by the old version.
+ * Parser: Unary plus is no longer recognized as a unary operator in the AST and triggers an error at the parsing stage (rather than later during the analysis).
+ * SMTChecker: Add CLI option ``--model-checker-bmc-loop-iterations`` and a JSON option ``settings.modelChecker.bmcLoopIterations`` that specify how many loop iterations the BMC engine should unroll. Note that false negatives are possible when unrolling loops. This is due to the possibility that bmc loop iteration setting is less than actual number of iterations needed to complete a loop.
+ * SMTChecker: Group all messages about unsupported language features in a single warning. The CLI option ``--model-checker-show-unsupported`` and the JSON option ``settings.modelChecker.showUnsupported`` can be enabled to show the full list.
+ * SMTChecker: Properties that are proved safe are now reported explicitly at the end of analysis. By default, only the number of safe properties is shown. The CLI option ``--model-checker-show-proved-safe`` and the JSON option ``settings.modelChecker.showProvedSafe`` can be enabled to show the full list of safe properties.
+ * Standard JSON Interface: Add experimental support for importing ASTs via Standard JSON.
+ * Yul EVM Code Transform: If available, use ``push0`` instead of ``codesize`` to produce an arbitrary value on stack in order to create equal stack heights between branches.
+
+
+Bugfixes:
+ * ABI: Include events in the ABI that are emitted by a contract but defined outside of it.
+ * Immutables: Disallow initialization of immutables in try/catch statements.
+ * SMTChecker: Fix false positives in ternary operators that contain verification targets in its branches, directly or indirectly.
+
+
+AST Changes:
+ * AST: Add the ``internalFunctionIDs`` field to the AST nodes of contracts containing IDs of functions that may be called via the internal dispatch. The field is a map from function AST IDs to internal dispatch function IDs. These IDs are always generated, but they are only used in via-IR code generation.
+ * AST: Add the ``usedEvents`` field to ``ContractDefinition`` which contains the AST IDs of all events emitted by the contract as well as all events defined and inherited by the contract.
+
+
+### 0.8.19 (2023-02-22)
+
+Language Features:
+ * Allow defining custom operators for user-defined value types via ``using {f as +} for T global`` syntax.
+
+
+Compiler Features:
+ * SMTChecker: New trusted mode that assumes that any compile-time available code is the actual used code even in external calls. This can be used via the CLI option ``--model-checker-ext-calls trusted`` or the JSON field ``settings.modelChecker.extCalls: "trusted"``.
+
+
+Bugfixes:
+ * Assembler: Avoid duplicating subassembly bytecode where possible.
+ * Code Generator: Avoid including references to the deployed label of referenced functions if they are called right away.
+ * ContractLevelChecker: Properly distinguish the case of missing base constructor arguments from having an unimplemented base function.
+ * SMTChecker: Fix internal error caused by unhandled ``z3`` expressions that come from the solver when bitwise operators are used.
+ * SMTChecker: Fix internal error when using the custom NatSpec annotation to abstract free functions.
+ * TypeChecker: Also allow external library functions in ``using for``.
+
+
+AST Changes:
+ * AST: Add ``function`` field to ``UnaryOperation`` and ``BinaryOperation`` AST nodes. ``functionList`` in ``UsingForDirective`` AST nodes will now contain ``operator`` and ``definition`` members instead of ``function`` when the list entry defines an operator.
+
+
+### 0.8.18 (2023-02-01)
+
+Language Features:
+ * Allow named parameters in mapping types.
+
+
+Compiler Features:
+ * Commandline Interface: Add ``--no-cbor-metadata`` that skips CBOR metadata from getting appended at the end of the bytecode.
+ * Commandline Interface: Return exit code ``2`` on uncaught exceptions.
+ * EVM: Deprecate ``block.difficulty`` and disallow ``difficulty()`` in inline assembly for EVM versions >= paris. The change is due to the renaming introduced by [EIP-4399](https://eips.ethereum.org/EIPS/eip-4399).
+ * EVM: Introduce ``block.prevrandao`` in Solidity and ``prevrandao()`` in inline assembly for EVM versions >= paris.
+ * EVM: Set the default EVM version to "Paris".
+ * EVM: Support for the EVM version "Paris".
+ * Language Server: Add basic document hover support.
+ * Natspec: Add event Natspec inheritance for devdoc.
+ * Optimizer: Added optimization rule ``and(shl(X, Y), shl(X, Z)) => shl(X, and(Y, Z))``.
+ * Parser: More detailed error messages about invalid version pragmas.
+ * SMTChecker: Make ``z3`` the default solver for the BMC and CHC engines instead of all solvers.
+ * SMTChecker: Support Eldarica as a Horn solver for the CHC engine when using the CLI option ``--model-checker-solvers eld``. The binary ``eld`` must be available in the system.
+ * Solidity Upgrade Tool: Remove ``solidity-upgrade`` tool.
+ * Standard JSON: Add a boolean field ``settings.metadata.appendCBOR`` that skips CBOR metadata from getting appended at the end of the bytecode.
+ * TypeChecker: Warn when using deprecated builtin ``selfdestruct``.
+ * Yul EVM Code Transform: Generate more optimal code for user-defined functions that always terminate a transaction. No return labels will be pushed for calls to functions that always terminate.
+ * Yul Optimizer: Allow replacing the previously hard-coded cleanup sequence by specifying custom steps after a colon delimiter (``:``) in the sequence string.
+ * Yul Optimizer: Eliminate ``keccak256`` calls if the value was already calculated by a previous call and can be reused.
+
+
+Bugfixes:
+ * Parser: Disallow several ``indexed`` attributes for the same event parameter.
+ * Parser: Disallow usage of the ``indexed`` attribute for modifier parameters.
+ * SMTChecker: Fix display error for negative integers that are one more than powers of two.
+ * SMTChecker: Fix internal error on chain assignments using static fully specified state variables.
+ * SMTChecker: Fix internal error on multiple wrong SMTChecker natspec entries.
+ * SMTChecker: Fix internal error when a public library function is called internally.
+ * SMTChecker: Fix internal error when deleting struct member of function type.
+ * SMTChecker: Fix internal error when using user-defined types as mapping indices or struct members.
+ * SMTChecker: Improved readability for large integers that are powers of two or almost powers of two in error messages.
+ * TypeChecker: Fix bug where private library functions could be attached with ``using for`` outside of their declaration scope.
+ * Yul Optimizer: Hash hex and decimal literals according to their value instead of their representation, improving the detection of equivalent functions.
+
+
 ### 0.8.17 (2022-09-08)
 
 Important Bugfixes:
diff --git a/compiler/README.md b/compiler/README.md
index 9637503b..e64f8cbf 100644
--- a/compiler/README.md
+++ b/compiler/README.md
@@ -3,10 +3,10 @@
 [![Matrix Chat](https://img.shields.io/badge/Matrix%20-chat-brightgreen?style=plastic&logo=matrix)](https://matrix.to/#/#ethereum_solidity:gitter.im)
 [![Gitter Chat](https://img.shields.io/badge/Gitter%20-chat-brightgreen?style=plastic&logo=gitter)](https://gitter.im/ethereum/solidity)
 [![Solidity Forum](https://img.shields.io/badge/Solidity_Forum%20-discuss-brightgreen?style=plastic&logo=discourse)](https://forum.soliditylang.org/)
-[![Twitter Follow](https://img.shields.io/twitter/follow/solidity_lang?style=plastic&logo=twitter)](https://twitter.com/solidity_lang)
+[![X Follow](https://img.shields.io/twitter/follow/solidity_lang?style=plastic&logo=x)](https://X.com/solidity_lang)
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/000335908?domain=https%3A%2F%2Ffosstodon.org%2F&logo=mastodon&style=plastic)](https://fosstodon.org/@solidity)
 
-You can talk to us on Gitter and Matrix, tweet at us on Twitter or create a new topic in the Solidity forum. Questions, feedback, and suggestions are welcome!
+You can talk to us on Gitter and Matrix, tweet at us on X (previously Twitter) or create a new topic in the Solidity forum. Questions, feedback, and suggestions are welcome!
 
 Solidity is a statically typed, contract-oriented, high-level language for implementing smart contracts on the Ethereum platform.
 
@@ -66,7 +66,7 @@ browser-based IDE. Here are some example contracts:
 
 ## Documentation
 
-The Solidity documentation is hosted at [Read the docs](https://docs.soliditylang.org).
+The Solidity documentation is hosted using [Read the Docs](https://docs.soliditylang.org).
 
 ## Development
 
@@ -79,8 +79,8 @@ You can find our current feature and bug priorities for forthcoming
 releases in the [projects section](https://github.com/ethereum/solidity/projects).
 
 ## Maintainers
-* [@axic](https://github.com/axic)
-* [@chriseth](https://github.com/chriseth)
+The Solidity programming language and compiler are open-source community projects governed by a core team.
+The core team is sponsored by the [Ethereum Foundation](https://ethereum.foundation/).
 
 ## License
 Solidity is licensed under [GNU General Public License v3.0](LICENSE.txt).
diff --git a/compiler/ReleaseChecklist.md b/compiler/ReleaseChecklist.md
index e1a6a4c1..167417a9 100644
--- a/compiler/ReleaseChecklist.md
+++ b/compiler/ReleaseChecklist.md
@@ -1,22 +1,43 @@
 ## Checklist for making a release:
 
 ### Requirements
- - [ ] Github account with access to [solidity](https://github.com/ethereum/solidity), [solc-js](https://github.com/ethereum/solc-js),
-       [solc-bin](https://github.com/ethereum/solc-bin), [homebrew-ethereum](https://github.com/ethereum/homebrew-ethereum),
-       [solidity-blog](https://github.com/ethereum/solidity-blog) and [solidity-portal](https://github.com/ethereum/solidity-portal) repositories.
+ - [ ] GitHub account with access to [solidity](https://github.com/ethereum/solidity), [solc-js](https://github.com/ethereum/solc-js),
+       [solc-bin](https://github.com/ethereum/solc-bin), [solidity-website](https://github.com/ethereum/solidity-website).
  - [ ] DockerHub account with push rights to the [``solc`` image](https://hub.docker.com/r/ethereum/solc).
- - [ ] Lauchpad (Ubuntu One) account with a membership in the ["Ethereum" team](https://launchpad.net/~ethereum) and
+ - [ ] Launchpad (Ubuntu One) account with a membership in the ["Ethereum" team](https://launchpad.net/~ethereum) and
        a gnupg key for your email in the ``ethereum.org`` domain (has to be version 1, gpg2 won't work).
+ - [ ] Ubuntu/Debian dependencies of the PPA scripts: ``devscripts``, ``debhelper``, ``dput``, ``git``, ``wget``, ``ca-certificates``.
  - [ ] [npm Registry](https://www.npmjs.com) account added as a collaborator for the [``solc`` package](https://www.npmjs.com/package/solc).
  - [ ] Access to the [solidity_lang Twitter account](https://twitter.com/solidity_lang).
  - [ ] [Reddit](https://www.reddit.com) account that is at least 10 days old with a minimum of 20 comment karma (``/r/ethereum`` requirements).
 
-### Blog Post
- - [ ] Create a post on [solidity-blog](https://github.com/ethereum/solidity-blog) in the ``Releases`` category and explain some of the new features or concepts.
- - [ ] Create a post on [solidity-blog](https://github.com/ethereum/solidity-blog) in the ``Security Alerts`` category in case of important bug(s).
+### Pre-flight checks
+At least a day before the release:
+ - [ ] Run ``make linkcheck`` from within ``docs/`` and fix any broken links it finds.
+       Ignore false positives caused by ``href`` anchors and dummy links not meant to work.
+ - [ ] Double-check that [the most recent docs builds at readthedocs](https://readthedocs.org/projects/solidity/builds/) succeeded.
+ - [ ] Make sure that all merged PRs that should have changelog entries do have them.
+ - [ ] Rerun CI on the top commits of main branches in all repositories that do not have daily activity by creating a test branch or PR:
+      - [ ] ``solc-js``
+      - [ ] ``solc-bin`` (make sure the bytecode comparison check did run)
+ - [ ] (Optional) Create a prerelease in our Ubuntu PPA by following the steps in the PPA section below on ``develop`` rather than on a tag.
+       This is recommended especially when dealing with PPA for the first time, when we add a new Ubuntu version or when the PPA scripts were modified in this release cycle.
+ - [ ] Verify that the release tarball of ``solc-js`` works.
+       Bump version locally, add ``soljson.js`` from CI, build it, compare the file structure with the previous version, install it locally and try to use it.
+
+### Drafts
+At least a day before the release:
+ - [ ] Create a draft PR to sort the changelog.
+ - [ ] Create draft PRs to bump version in ``solidity`` and ``solc-js``.
+       **Note**: The ``solc-js`` PR won't pass CI checks yet because it depends on the soljson binary from ``solc-bin``.
+ - [ ] Create a draft of the release on github.
+ - [ ] Create a draft PR to update soliditylang.org.
+ - [ ] Create drafts of blog posts.
+ - [ ] Prepare drafts of Twitter, Reddit and Solidity Forum announcements.
 
-### Documentation check
- - [ ] Run ``make linkcheck`` from within ``docs/`` and fix any broken links it finds. Ignore false positives caused by ``href`` anchors and dummy links not meant to work.
+### Blog Post
+ - [ ] Create a post on [solidity-website](https://github.com/ethereum/solidity-website/tree/main/src/posts) in the ``Releases`` category and explain some of the new features or concepts.
+ - [ ] Create a post on [solidity-website](https://github.com/ethereum/solidity-website/tree/main/src/posts) in the ``Security Alerts`` category in case of important bug(s).
 
 ### Changelog
  - [ ] Sort the changelog entries alphabetically and correct any errors you notice. Commit it.
@@ -27,13 +48,16 @@
  - [ ] Copy the changelog into the release blog post.
 
 ### Create the Release
- - [ ] Create a [release on github](https://github.com/ethereum/solidity/releases/new).
+ - [ ] Create a [release on GitHub](https://github.com/ethereum/solidity/releases/new).
        Set the target to the ``develop`` branch and the tag to the new version, e.g. ``v0.8.5``.
        Include the following warning: ``**The release is still in progress and the binaries may not yet be available from all sources.**``.
-       Don't publish it yet - click the ``Save draft`` button instead.
- - [ ] Thank voluntary contributors in the Github release notes (use ``git shortlog --summary --email v0.5.3..origin/develop``).
+       Do not publish it yet - click the ``Save draft`` button instead.
+ - [ ] Thank voluntary contributors in the GitHub release notes.
+       Use ``scripts/list_contributors.sh v<previous version>`` to get initial list of names.
+       Remove different variants of the same name manually before using the output.
  - [ ] Check that all tests on the latest commit in ``develop`` are green.
  - [ ] Click the ``Publish release`` button on the release page, creating the tag.
+       **Important: Must not be done before all the PRs, including changelog cleanup and date, are merged.**
  - [ ] Wait for the CI runs on the tag itself.
 
 ### Upload Release Artifacts and Publish Binaries
@@ -44,43 +68,51 @@
  - [ ] Take the ``github-binaries.tar`` tarball from ``c_release_binaries`` run of the tagged commit in circle-ci and add all binaries from it to the release page.
        Make sure it contains four binaries: ``solc-windows.exe``, ``solc-macos``, ``solc-static-linux`` and ``soljson.js``.
  - [ ] Take the ``solc-bin-binaries.tar`` tarball from ``c_release_binaries`` run of the tagged commit in circle-ci and add all binaries from it to solc-bin.
- - [ ] Run ``./update --reuse-hashes`` in ``solc-bin`` and verify that the script has updated ``list.js``, ``list.txt`` and ``list.json`` files correctly and that symlinks to the new release have been added in ``solc-bin/wasm/`` and ``solc-bin/emscripten-wasm32/``.
+ - [ ] Run ``npm run update -- --reuse-hashes`` in ``solc-bin`` and verify that the script has updated ``list.js``, ``list.txt`` and ``list.json`` files correctly and that symlinks to the new release have been added in ``solc-bin/wasm/`` and ``solc-bin/emscripten-wasm32/``.
  - [ ] Create a pull request in solc-bin and merge.
 
 ### Homebrew and MacOS
  - [ ] Update the version and the hash (``sha256sum solidity_$VERSION.tar.gz``) in the [``solidity`` formula in Homebrew core repository](https://github.com/Homebrew/homebrew-core/blob/master/Formula/solidity.rb).
- - [ ] Update the version and the hash (``sha256sum solidity_$VERSION.tar.gz``) in [our custom ``solidity`` Homebrew formula](https://github.com/ethereum/homebrew-ethereum/blob/master/solidity.rb).
 
 ### Docker
  - [ ] Run ``./scripts/docker_deploy_manual.sh v$VERSION``.
 
 ### PPA
  - [ ] Create ``.release_ppa_auth`` at the root of your local Solidity checkout and set ``LAUNCHPAD_EMAIL`` and ``LAUNCHPAD_KEYID`` to your key's email and key id.
- - [ ] Double-check that the ``DISTRIBUTIONS`` list in ``scripts/release_ppa.sh`` and ``scripts/deps-ppa/static-z3.sh`` contains the most recent versions of Ubuntu.
+ - [ ] Double-check that the ``DISTRIBUTIONS`` list in ``scripts/release_ppa.sh`` and ``scripts/deps-ppa/static_z3.sh`` contains the most recent versions of Ubuntu.
  - [ ] Make sure the [``~ethereum/cpp-build-deps`` PPA repository](https://launchpad.net/~ethereum/+archive/ubuntu/cpp-build-deps) contains ``libz3-static-dev builds`` for all current versions of Ubuntu.
-       If not, run ``scripts/deps-ppa/static-z3.sh`` (after changing email address and key id) and wait for the builds to succeed before continuing.
+       Note that it may be included in the ``z3-static`` multipackage (follow the ``View package details`` link to check).
+       If not present, run ``scripts/deps-ppa/static_z3.sh`` and wait for the builds to succeed before continuing.
  - [ ] Run ``scripts/release_ppa.sh v$VERSION`` to create the PPA release.
- - [ ] Wait for the [``~ethereum/ethereum-static`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum-static) build to be finished and published for *all platforms*.
+       This will create a single package containing static binary for older Ubuntu versions in the [``~ethereum/ethereum-static`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum-static)
+       and separate packages with dynamically-linked binaries for recent versions (those listed in ``DISTRIBUTIONS``) in the [``~ethereum/ethereum`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum).
+ - [ ] Wait for the build to be finished and published for *all architectures* (currently we only build for ``amd64``, but we may add ``arm`` in the future).
        **SERIOUSLY: DO NOT PROCEED EARLIER!!!**
-       *After* the static builds are *published*, copy the static package to the [``~ethereum/ethereum`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum)
+ - [ ] *After* the package with the static build is *published*, use it to create packages for older Ubuntu versions.
+       Copy the static package to the [``~ethereum/ethereum`` PPA](https://launchpad.net/~ethereum/+archive/ubuntu/ethereum)
        for the destination series ``Trusty``, ``Xenial`` and ``Bionic`` while selecting ``Copy existing binaries``.
 
 ### Release solc-js
  - [ ] Wait until solc-bin was properly deployed. You can test this via remix - a test run through remix is advisable anyway.
  - [ ] Increment the version number, create a pull request for that, merge it after tests succeeded.
- - [ ] Run ``npm run build:tarball`` in the updated ``solc-js`` repository to create ``solc-<version>.tgz``. Inspect the tarball to ensure that it contains an up to date compiler binary.
- - [ ] Run ``npm run publish:tarball`` to publish the newly created tarball.
  - [ ] Create a tag using ``git tag --annotate v$VERSION`` and push it with ``git push --tags``.
+ - [ ] Wait for the CI runs on the tag itself.
+ - [ ] Take the ``solc-x.y.z.tgz`` artifact from ``build-package`` run on the tagged commit in circle-ci.
+       Inspect the tarball to ensure that it contains an up-to-date compiler binary (``soljson.js``).
+ - [ ] Run ``npm publish solc-x.y.z.tgz`` to publish the newly created tarball.
 
 ### Post-release
  - [ ] Make sure the documentation for the new release has been published successfully.
        Go to the [documentation status page at ReadTheDocs](https://readthedocs.org/projects/solidity/) and verify that the new version is listed, works and is marked as default.
- - [ ] Remove "still in progress" warning from the release notes.
- - [ ] Publish the blog posts.
+ - [ ] Remove "still in progress" warning from the [release notes](https://github.com/ethereum/solidity/releases).
+ - [ ] Merge the [blog posts](https://github.com/ethereum/solidity-website/pulls) related to the release.
  - [ ] Create a commit to increase the version number on ``develop`` in ``CMakeLists.txt`` and add a new skeleton changelog entry.
- - [ ] Announce on Twitter, including links to the release and the blog post.
-       Use ``#xp`` at the end of the tweet to automatically cross post the announcement to Fosstodon.
+ - [ ] Update the release information section [in the source of soliditylang.org](https://github.com/ethereum/solidity-website/blob/main/src/pages/index.tsx).
+ - [ ] Announce on [Twitter](https://twitter.com/solidity_lang), including links to the release and the blog post.
+ - [ ] Announce on [Fosstodon](https://fosstodon.org/@solidity/), including links to the release and the blog post.
  - [ ] Share the announcement on Reddit in [``/r/ethdev``](https://reddit.com/r/ethdev/), cross-posted to [``/r/ethereum``](https://reddit.com/r/ethereum/).
- - [ ] Share the announcement the [Solidity forum](https://forum.soliditylang.org) in the ``Announcements`` category.
- - [ ] Update the release information section on [soliditylang.org](https://github.com/ethereum/solidity-portal).
- - [ ] Lean back, wait for bug reports and repeat from step 1 :)
+ - [ ] Share the announcement on the [Solidity forum](https://forum.soliditylang.org) in the ``Announcements`` category.
+ - [ ] Share the announcement on [Project Updates](https://discord.com/channels/420394352083337236/798974456704925696)
+ - [ ] Share the announcement on [`#solidity` channel on Matrix](https://matrix.to/#/#ethereum_solidity:gitter.im)
+ - [ ] Share the announcement on [`#solc-tooling`](https://matrix.to/#/#solc-tooling:matrix.org)
+ - [ ] Lean back, wait for bug reports and repeat from step 1 :).
diff --git a/compiler/ReviewChecklist.md b/compiler/ReviewChecklist.md
new file mode 100644
index 00000000..3f0af6f9
--- /dev/null
+++ b/compiler/ReviewChecklist.md
@@ -0,0 +1,200 @@
+# PR Review Checklist
+The Solidity compiler is a critical piece of infrastructure in the Ethereum ecosystem.
+For this reason, our review process is quite strict and all PRs have to fulfill certain quality
+expectations and guidelines.
+The list below is meant to reduce the workload on the core team by helping contributors self-identify
+and solve common issues before they are pointed out in the review.
+It is also meant to serve as a final checklist for reviewers to go through before approving a PR.
+
+## Before You Submit a PR
+- [ ] **Do you have any other open PRs?**
+    Work on a PR is not done until it is merged or closed.
+    Our reviewing capacity is limited, so we require that external contributors work on **no more than one PR at a time**.
+    - If your PR is not getting reviewed, feel free to bring it to our attention on the [#solidity-dev](https://gitter.im/ethereum/solidity-dev) channel.
+    - Unless they were requested, we are going to close any excess PRs, leaving only the earliest one open.
+        You may reopen them, one at a time, when your current PR is done.
+- [ ] **Is the issue ready to be worked on?**
+    - If the issue does not have a desirability label (`nice to have`, `should have`,
+        `must have eventually`, `must have`, `roadmap`) we have not yet decided whether to implement it.
+    - If the issue has the `needs design` label, we have not yet decided how it should be implemented.
+    - `good first issue candidate` means that the issue will potentially be a `good first issue`
+        eventually but at the moment it is not yet ready to be worked on.
+- [ ] **Is this a breaking change?** Breaking changes should be based on the `breaking` branch rather than on the `develop` branch.
+- [ ] **Does the PR actually address the issue?**
+    - [ ] Mention the issue number in the PR description.
+        If the PR solves it completely, use the `Fixes #<issue number>` form so that Github will close the issue automatically.
+    - [ ] Do not include the issue number in the PR title, branch name or commit description.
+- [ ] When submitting a PR from a fork **create a branch and give it a descriptive name.**
+    E.g. `fix-array-abi-encoding-bug`.
+    Do not submit PRs directly from the `develop` branch of your fork since it makes rebasing and fetching new changes harder.
+- [ ] **Does the PR depend on other PRs?**
+    - [ ] If the PR has dependencies, mention them in bold in the description.
+    - [ ] Avoid basing PRs from forks on branches other than `develop` or `breaking` because
+        GitHub closes them when the base branch gets merged.
+        Do this only for PRs created directly in the main repo.
+- [ ] **Does the PR update test expectations to match the modified code?** If not, your PR will not pass some of the `_soltest_`,  jobs in CI.
+    In many cases the expectations can be updated automatically:
+    - `cmdlineTests.sh --update` for command-line tests.
+    - `isoltest --enforce-gas-cost --accept-updates` for soltest-based tests.
+        - If your PR affects gas costs, an extra run of `isoltest --enforce-gas-cost --optimize --accept-updates` is needed to update gas expectations with optimizer enabled.
+    - Review updated files before committing them.
+        **Are expectations correct and do updated tests still serve their purpose?**
+
+## Abandoned PRs
+- [ ] **Is the submitter still responsive?**
+    - If the PR had no activity from the submitter in the last 2 weeks (despite receiving reviews and our prompts) we consider it abandoned.
+- [ ] **Is the abandoned PR easy to finish or relevant?**
+    - Apply the `takeover` label if the PR can be finished without significant effort or is something that actually needs to be done right now.
+        Otherwise close it.
+        It can still be taken over later or reopened by the submitter but until then we should not be getting sidetracked by it.
+
+## Light Review
+Before an in-depth review, it is recommended to give new PRs a quick, superficial review, which
+is not meant to provide complete and detailed feedback, but instead give the submitter a rough idea
+if the PR is even on the right track and let them solve the obvious problems on their own.
+
+Light review should focus on the following three areas:
+- [ ] **Are there any obvious mistakes?** Style issues, bad practices, easy to identify bugs, etc.
+- [ ] **Is there anything missing?** Tests (of the right kind), documentation, etc. Does it address the whole issue?
+- [ ] **Is it the right solution?** Are there better ways to do this? Is the change even necessary?
+
+If the answers above are "Yes, Yes, No", thank the contributor for their effort and **close the PR**.
+
+## Coding Style and Good Practices
+- [ ] Does the PR follow our [coding style](CODING_STYLE.md)?
+
+### Reliability
+- [ ] **Use assertions liberally.** If you are certain your assumption will not be broken, prove it with `solAssert()`.
+- [ ] **Validate inputs and handle errors**. Note that assertions are **not** validation.
+
+### Readability
+- [ ] **Choose good names.**
+    - [ ] Is the name straightforward to understand?
+        Do you feel the need to jump back to the definition and remind yourself what it was whenever you see it?
+    - [ ] Is the name unambiguous in the context where it is used?
+    - [ ] Avoid abbreviations.
+- [ ] **Source files, classes and public functions should have docstrings.**
+- [ ] **Avoid code duplication.** But not fanatically. Minimal amounts of duplication are acceptable if it aids readability.
+- [ ] **Do not leave dead or commented-out code behind.** You can still see old code in history.
+      If you really have a good reason to do it, always leave a comment explaining what it is and why it is there.
+- [ ] **Mark hacks as such.** If you have to leave behind a temporary workaround, make
+    sure to include a comment that explains why and in what circumstances it can be removed.
+    Preferably link to an issue you reported upstream.
+- [ ] **Avoid obvious comments.**
+- [ ] **Do include comments when the reader may need extra context to understand the code.**
+
+### Commits and PRs
+- [ ] **Avoid hiding functional changes inside refactors.**
+    E.g. when fixing a small bug, or changing user-visible behavior, put the change in a separate commit.
+    Do not mix it with another change that renames things or reformats the code around, making the fix itself hard to identify.
+- [ ] **Whenever possible, split off refactors or unrelated changes into separate PRs.**
+    Smaller PRs are easier and quicker to review.
+    Splitting off refactors helps focus on the main point of the PR.
+
+### Common Pitfalls
+The following points are all covered by the coding style but come up so often that it is worth singling them out here:
+- [ ] **Always initialize value types in the definition,** even if you are sure you will assign them later.
+- [ ] **Use "east const" style.** I.e. `T const*`, not `const T *`.
+- [ ] **Keep indentation consistent.** See our [`.editorconfig`](.editorconfig).
+    - [ ] Tabs for C++. But use them for indentation only. Any whitespace later on the line must consist of spaces.
+    - [ ] 4 spaces for most other file types.
+- [ ] **Use `auto` sparingly.** Only use it when the actual type is very long and complicated or when it is
+    already used elsewhere in the same expression.
+- [ ] **Indent braces and parentheses in a way that makes nesting clear.**
+- [ ] **Use `using namespace` only in `.cpp` files.** Use it for `std` and our own modules.
+    Avoid unnecessary `std::` prefix in `.cpp` files (except for `std::move` and `std::forward`).
+- [ ] **Use range-based loops and destructuring.**
+- [ ] **Include any headers you use directly,** even if they are implicitly included through other headers.
+
+## Documentation
+- [ ] **Does the PR update relevant documentation?**
+
+### Documentation Style and Good Practices
+- [ ] **Use double backticks in RST (``` ``x`` ```). Prefer single backticks in Markdown (`` `x` ``),**
+    but note that double backticks are valid too and we use them in some cases for legacy reasons.
+- [ ] **Always start a new sentence on a new line.**
+    This way you do not have to rewrap the surrounding text when you rewrite the sentence.
+    This also makes changes actually easier to spot in the diff.
+
+## Testing
+
+### What to Test
+- [ ] **Is newly added code adequately covered by tests?** Have you considered all the important corner cases?
+- If it is a bugfix:
+    - [ ] **The PR must include tests that reproduce the bug.**
+    - [ ] **Are there gaps in test coverage of the buggy feature?** Fill them by adding more tests.
+    - [ ] **Try to break it.** Can you of any similar features that could also be buggy?
+        Play with the repro and include prominent variants as separate test cases, even if they don't trigger a bug.
+- [ ] **Positive cases (code that compiles) should have a semantic test.**
+- [ ] **Negative cases (code with compilation errors) should have a syntax test.**
+- [ ] **Avoid mixing positive and negative cases in the same syntax test.**
+    If the test produces an error, we stop at the analysis stage and we will not detect
+    problems that only occur in code generation, optimizer or assembler.
+    - [ ] If you have to do it, at least mark positive cases inside the file with a short comment.
+        - This way, when the test is updated, it is easier to verify that these cases still do not trigger an error.
+- [ ] New syntax: **does it have an [`ASTJSON`](test/libsolidity/ASTJSON/) test?**
+- [ ] New CLI or StandardJSON option:
+    - [ ] **Does it have a [command-line test](test/cmdlineTests/)?**
+    - [ ] **Is the option listed for every input mode in [`CommandLineParser` tests](test/solc/CommandLineParser.cpp)?**
+- [ ] **Did you consider interactions with other language features?**
+    - [ ] Are all types covered? Structs? Enums? Contracts/libraries/interfaces? User-defined value types?
+        Value types: integers, fixed bytes, `address`, `address payable`, `bool`? Function pointers?
+        Static and dynamic arrays? `string` and `bytes`? Mappings?
+        Values of types that cannot be named: literals, tuples, array slices, storage references?
+    - [ ] If it accepts a function, does it also accept an event or an error? These have function types but are not functions.
+    - [ ] If it affects free functions, what about internal library functions?
+    - [ ] Attached library functions? Functions attached with `using for`?
+    - [ ] Possible combinations of `storage`, `memory`, `calldata`, `immutable`, `constant`?
+        Remember that internal functions can take `storage` arguments.
+    - [ ] Does it work at construction time as well? What if you store it at construction time and read after deployment?
+    - [ ] What about importing it from a different module or inheriting it?
+    - [ ] Have you tested it with the ternary operator?
+
+### Test Style and Good Practices
+- [ ] **Make test case file names long and specific enough** so that it is easy to guess what is inside.
+    When checking if we have the case already covered the name is usually the only clue we see.
+    - [ ] Place them in the right subdirectory.
+    - [ ] **Avoid simply appending numbers to the name to distinguish similar cases.**
+        Coming up with good names is hard but figuring out if any of hundreds of tests with names that
+        match your search actually fits your case is even harder.
+- [ ] **Do not include version pragma and the SPDX comment in semantic and syntax test cases**.
+    In other test types include them if necessary to suppress warnings.
+- [ ] **If you have to use a version pragma, avoid hard-coding version.** Use `pragma solidity *`.
+- [ ] **When writing StandardJSON command-line tests, use `urls` instead of `content`** and put
+    the Solidity or Yul code in a separate file.
+
+## Compiler-specific
+- [ ] **Are error messages sensible and understandable to users?**
+- [ ] **Are error codes consistent?**
+    - [ ] Avoid randomly changing or reassigning error codes.
+    - [ ] Avoid defining separate codes for trivial variants of the same issue.
+        Make it easy for tools to consistently refer to the same error with the same code.
+- [ ] **Error messages should end with a full stop.**
+- [ ] **Prefer Ranges v3 to Boost where possible.**
+
+## Take a Step Back
+- [ ] **Do you fully understand what the PR does and why?**
+- [ ] **Are you confident that the code works and does not break unrelated functionality?**
+- [ ] **Is this a reasonable way to achieve the goal stated in the issue?**
+- [ ] **Is the code simple?** Does the PR achieve its objective at the cost of significant
+    complexity that may be a source of future bugs?
+- [ ] **Is the code efficient?** Does the PR introduce any major performance bottlenecks?
+- [ ] **Does the PR introduce any breaking changes beyond what was agreed in the issue?**
+
+## Final Checks Before Merging
+- [ ] **Is the PR rebased on top of the `develop` branch** (or `breaking` if it is a breaking change)?
+- [ ] **Did all CI checks pass?**
+    - Note that we have a few jobs that tend to randomly fail due to outside factors, especially external tests (with `_ext_` in the name).
+        If these fail, rebase on latest `develop` (or `breaking`) and try rerunning them.
+        Note also that not all of these checks are required for the PR to be merged.
+- [ ] If the change is visible to users, **does the PR have a [changelog](Changelog.md) entry?**
+    - [ ] Is the changelog entry in the right section?
+        Make sure to move it up if there was a release recently.
+- [ ] **Is commit history simple and understandable?**
+    - [ ] Each commit should be a self-contained, logical step leading the goal of the PR, without going back and forth.
+        In particular, review fixups should be squashed into the commits they fix.
+    - [ ] Do not include any merge commits in your branch. Please use rebase to keep up to date with the base branch.
+- [ ] **Is the PR properly labeled?**
+    - Use `external contribution` label to mark PRs not coming from the core team.
+    - If the PR depends on other PRs, use `has dependencies` and set the base branch accordingly.
+    - Labels like `documentation` or `optimizer` are helpful for filtering PRs.
diff --git a/compiler/cmake/EthCompilerSettings.cmake b/compiler/cmake/EthCompilerSettings.cmake
index 9803818d..d43e18f7 100644
--- a/compiler/cmake/EthCompilerSettings.cmake
+++ b/compiler/cmake/EthCompilerSettings.cmake
@@ -28,7 +28,7 @@ if(PEDANTIC)
 endif()
 
 # Prevent the path of the source directory from ending up in the binary via __FILE__ macros.
-eth_add_cxx_compiler_flag_if_supported("-fmacro-prefix-map=${CMAKE_SOURCE_DIR}=/solidity")
+eth_add_cxx_compiler_flag_if_supported("-fmacro-prefix-map=${PROJECT_SOURCE_DIR}=/solidity")
 
 # -Wpessimizing-move warns when a call to std::move would prevent copy elision
 # if the argument was not wrapped in a call.  This happens when moving a local
@@ -58,13 +58,20 @@ if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MA
 		add_compile_options(-Wmissing-declarations)
 		add_compile_options(-Wno-unknown-pragmas)
 		add_compile_options(-Wimplicit-fallthrough)
-#		add_compile_options(-Wsign-conversion) # TODO return this after
-#		add_compile_options(-Wconversion) # TODO return this after
+#		add_compile_options(-Wsign-conversion) # TODO DELETE return this after
+#		add_compile_options(-Wconversion) # TODO DELETE return this after
 
 		check_cxx_compiler_flag(-Wextra-semi WEXTRA_SEMI)
 		if(WEXTRA_SEMI)
 			add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wextra-semi>)
 		endif()
+		# See https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=6b927b1297e66e26e62e722bf15c921dcbbd25b9
+		check_cxx_compiler_flag(-Wno-dangling-reference WNO_DANGLING_REFERENCE)
+		if (WNO_DANGLING_REFERENCE)
+            add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-dangling-reference>)
+		endif()
+
+
 		eth_add_cxx_compiler_flag_if_supported(-Wfinal-dtor-non-final-class)
 		eth_add_cxx_compiler_flag_if_supported(-Wnewline-eof)
 		eth_add_cxx_compiler_flag_if_supported(-Wsuggest-destructor-override)
diff --git a/compiler/cmake/fmtlib.cmake b/compiler/cmake/fmtlib.cmake
index 5ed196ce..032a68cd 100644
--- a/compiler/cmake/fmtlib.cmake
+++ b/compiler/cmake/fmtlib.cmake
@@ -2,11 +2,11 @@ include(FetchContent)
 
 FetchContent_Declare(
 	fmtlib
-	PREFIX "${CMAKE_BINARY_DIR}/deps"
-	DOWNLOAD_DIR "${CMAKE_SOURCE_DIR}/deps/downloads"
-	DOWNLOAD_NAME fmt-8.0.1.tar.gz
-	URL https://github.com/fmtlib/fmt/archive/8.0.1.tar.gz
-	URL_HASH SHA256=b06ca3130158c625848f3fb7418f235155a4d389b2abc3a6245fb01cb0eb1e01
+	PREFIX "${PROJECT_BINARY_DIR}/deps"
+	DOWNLOAD_DIR "${PROJECT_SOURCE_DIR}/deps/downloads"
+	DOWNLOAD_NAME fmt-9.1.0.tar.gz
+	URL https://github.com/fmtlib/fmt/archive/9.1.0.tar.gz
+	URL_HASH SHA256=5dea48d1fcddc3ec571ce2058e13910a0d4a6bab4cc09a809d8b1dd1c88ae6f2
 )
 
 if (CMAKE_VERSION VERSION_LESS "3.14.0")
diff --git a/compiler/cmake/jsoncpp.cmake b/compiler/cmake/jsoncpp.cmake
index 29b8f5f0..c47c2697 100644
--- a/compiler/cmake/jsoncpp.cmake
+++ b/compiler/cmake/jsoncpp.cmake
@@ -6,7 +6,7 @@ else()
     set(JSONCPP_CMAKE_COMMAND ${CMAKE_COMMAND})
 endif()
 
-set(prefix "${CMAKE_BINARY_DIR}/deps")
+set(prefix "${PROJECT_BINARY_DIR}/deps")
 set(JSONCPP_LIBRARY "${prefix}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}jsoncpp${CMAKE_STATIC_LIBRARY_SUFFIX}")
 set(JSONCPP_INCLUDE_DIR "${prefix}/include")
 
@@ -40,9 +40,10 @@ if (WIN32 AND POLICY CMP0091 AND CMAKE_MSVC_RUNTIME_LIBRARY)
     list(APPEND JSONCPP_CMAKE_ARGS "-DCMAKE_MSVC_RUNTIME_LIBRARY=${CMAKE_MSVC_RUNTIME_LIBRARY}")
 endif()
 
+string(REPLACE ";" "$<SEMICOLON>" CMAKE_OSX_ARCHITECTURES_ "${CMAKE_OSX_ARCHITECTURES}")
 ExternalProject_Add(jsoncpp-project
     PREFIX "${prefix}"
-    DOWNLOAD_DIR "${CMAKE_SOURCE_DIR}/deps/downloads"
+    DOWNLOAD_DIR "${PROJECT_SOURCE_DIR}/deps/downloads"
     DOWNLOAD_NAME jsoncpp-1.9.3.tar.gz
     URL https://github.com/open-source-parsers/jsoncpp/archive/1.9.3.tar.gz
     URL_HASH SHA256=8593c1d69e703563d94d8c12244e2e18893eeb9a8a9f8aa3d09a327aa45c8f7d
@@ -57,6 +58,7 @@ ExternalProject_Add(jsoncpp-project
                -DJSONCPP_WITH_PKGCONFIG_SUPPORT=OFF
                -DCMAKE_CXX_FLAGS=${JSONCPP_CXX_FLAGS}
                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+               -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES_}
                ${JSONCPP_CMAKE_ARGS}
     ${byproducts}
 )
diff --git a/compiler/cmake/range-v3.cmake b/compiler/cmake/range-v3.cmake
index 75ed5a92..d2f54452 100644
--- a/compiler/cmake/range-v3.cmake
+++ b/compiler/cmake/range-v3.cmake
@@ -6,12 +6,12 @@ else()
     set(RANGE_V3_CMAKE_COMMAND ${CMAKE_COMMAND})
 endif()
 
-set(prefix "${CMAKE_BINARY_DIR}/deps")
+set(prefix "${PROJECT_BINARY_DIR}/deps")
 set(RANGE_V3_INCLUDE_DIR "${prefix}/include")
 
 ExternalProject_Add(range-v3-project
     PREFIX "${prefix}"
-    DOWNLOAD_DIR "${CMAKE_SOURCE_DIR}/deps/downloads"
+    DOWNLOAD_DIR "${PROJECT_SOURCE_DIR}/deps/downloads"
     DOWNLOAD_NAME range-v3-0.12.0.tar.gz
     URL https://github.com/ericniebler/range-v3/archive/0.12.0.tar.gz
     URL_HASH SHA256=015adb2300a98edfceaf0725beec3337f542af4915cec4d0b89fa0886f4ba9cb
diff --git a/compiler/cmake/templates/ewasm_polyfill.in b/compiler/cmake/templates/ewasm_polyfill.in
deleted file mode 100644
index 8ac36428..00000000
--- a/compiler/cmake/templates/ewasm_polyfill.in
+++ /dev/null
@@ -1,13 +0,0 @@
-// The generation of this file is defined in libyul/CMakeLists.txt.
-// This file was generated by using the content of libyul/backends/wasm/polyfill/@EWASM_POLYFILL_NAME@.yul.
-
-#pragma once
-
-namespace solidity::yul::wasm::polyfill
-{
-
-static char const @EWASM_POLYFILL_NAME@[] = {
-	@EWASM_POLYFILL_CONTENT@, 0
-};
-
-} // namespace solidity::yul::wasm::polyfill
diff --git a/compiler/docs/050-breaking-changes.rst b/compiler/docs/050-breaking-changes.rst
index 3f41ac86..a40bbcf6 100644
--- a/compiler/docs/050-breaking-changes.rst
+++ b/compiler/docs/050-breaking-changes.rst
@@ -137,7 +137,7 @@ For most of the topics the compiler will provide suggestions.
   ``payable`` or create a new internal function for the program logic that
   uses ``msg.value``.
 
-* For clarity reasons, the command line interface now requires ``-`` if the
+* For clarity reasons, the command-line interface now requires ``-`` if the
   standard input is used as source.
 
 Deprecated Elements
@@ -147,18 +147,18 @@ This section lists changes that deprecate prior features or syntax.  Note that
 many of these changes were already enabled in the experimental mode
 ``v0.5.0``.
 
-Command Line and JSON Interfaces
+Command-line and JSON Interfaces
 --------------------------------
 
-* The command line option ``--formal`` (used to generate Why3 output for
+* The command-line option ``--formal`` (used to generate Why3 output for
   further formal verification) was deprecated and is now removed.  A new
   formal verification module, the SMTChecker, is enabled via ``pragma
   experimental SMTChecker;``.
 
-* The command line option ``--julia`` was renamed to ``--yul`` due to the
+* The command-line option ``--julia`` was renamed to ``--yul`` due to the
   renaming of the intermediate language ``Julia`` to ``Yul``.
 
-* The ``--clone-bin`` and ``--combined-json clone-bin`` command line options
+* The ``--clone-bin`` and ``--combined-json clone-bin`` command-line options
   were removed.
 
 * Remappings with empty prefix are disallowed.
diff --git a/compiler/docs/060-breaking-changes.rst b/compiler/docs/060-breaking-changes.rst
index 915a9f33..e7c93057 100644
--- a/compiler/docs/060-breaking-changes.rst
+++ b/compiler/docs/060-breaking-changes.rst
@@ -12,7 +12,7 @@ For the full list check
 Changes the Compiler Might not Warn About
 =========================================
 
-This section lists changes where the behaviour of your code might
+This section lists changes where the behavior of your code might
 change without the compiler telling you about it.
 
 * The resulting type of an exponentiation is the type of the base. It used to be the smallest type
@@ -53,6 +53,8 @@ For most of the topics the compiler will provide suggestions.
   If the name contains a dot, its prefix up to the dot may not conflict with any declaration outside the inline
   assembly block.
 
+* In inline assembly, opcodes that do not take arguments are now represented as "built-in functions" instead of standalone identifiers. So ``gas`` is now ``gas()``.
+
 * State variable shadowing is now disallowed.  A derived contract can only
   declare a state variable ``x``, if there is no visible state variable with
   the same name in any of its bases.
@@ -103,23 +105,23 @@ Interface Changes
 =================
 
 This section lists changes that are unrelated to the language itself, but that have an effect on the interfaces of
-the compiler. These may change the way how you use the compiler on the command line, how you use its programmable
+the compiler. These may change the way how you use the compiler on the command-line, how you use its programmable
 interface, or how you analyze the output produced by it.
 
 New Error Reporter
 ~~~~~~~~~~~~~~~~~~
 
-A new error reporter was introduced, which aims at producing more accessible error messages on the command line.
-It is enabled by default, but passing ``--old-reporter`` falls back to the the deprecated old error reporter.
+A new error reporter was introduced, which aims at producing more accessible error messages on the command-line.
+It is enabled by default, but passing ``--old-reporter`` falls back to the deprecated old error reporter.
 
 Metadata Hash Options
 ~~~~~~~~~~~~~~~~~~~~~
 
 The compiler now appends the `IPFS <https://ipfs.io/>`_ hash of the metadata file to the end of the bytecode by default
 (for details, see documentation on :doc:`contract metadata <metadata>`). Before 0.6.0, the compiler appended the
-`Swarm <https://ethersphere.github.io/swarm-home/>`_ hash by default, and in order to still support this behaviour,
-the new command line option ``--metadata-hash`` was introduced. It allows you to select the hash to be produced and
-appended, by passing either ``ipfs`` or ``swarm`` as value to the ``--metadata-hash`` command line option.
+`Swarm <https://ethersphere.github.io/swarm-home/>`_ hash by default, and in order to still support this behavior,
+the new command-line option ``--metadata-hash`` was introduced. It allows you to select the hash to be produced and
+appended, by passing either ``ipfs`` or ``swarm`` as value to the ``--metadata-hash`` command-line option.
 Passing the value ``none`` completely removes the hash.
 
 These changes can also be used via the :ref:`Standard JSON Interface<compiler-api>` and effect the metadata JSON generated by the compiler.
@@ -174,3 +176,6 @@ This section gives detailed instructions on how to update prior code for every b
   ``override`` to every overriding function. For multiple inheritance, add ``override(A, B, ..)``,
   where you list all contracts that define the overridden function in the parentheses. When
   multiple bases define the same function, the inheriting contract must override all conflicting functions.
+
+* In inline assembly, add ``()`` to all opcodes that do not otherwise accept an argument.
+  For example, change ``pc`` to ``pc()``, and ``gas`` to ``gas()``.
diff --git a/compiler/docs/080-breaking-changes.rst b/compiler/docs/080-breaking-changes.rst
index b322d2a4..524d12ac 100644
--- a/compiler/docs/080-breaking-changes.rst
+++ b/compiler/docs/080-breaking-changes.rst
@@ -10,18 +10,18 @@ For the full list check
 Silent Changes of the Semantics
 ===============================
 
-This section lists changes where existing code changes its behaviour without
+This section lists changes where existing code changes its behavior without
 the compiler notifying you about it.
 
 * Arithmetic operations revert on underflow and overflow. You can use ``unchecked { ... }`` to use
-  the previous wrapping behaviour.
+  the previous wrapping behavior.
 
   Checks for overflow are very common, so we made them the default to increase readability of code,
   even if it comes at a slight increase of gas costs.
 
 * ABI coder v2 is activated by default.
 
-  You can choose to use the old behaviour using ``pragma abicoder v1;``.
+  You can choose to use the old behavior using ``pragma abicoder v1;``.
   The pragma ``pragma experimental ABIEncoderV2;`` is still valid, but it is deprecated and has no effect.
   If you want to be explicit, please use ``pragma abicoder v2;`` instead.
 
@@ -57,7 +57,7 @@ New Restrictions
 
 This section lists changes that might cause existing contracts to not compile anymore.
 
-* There are new restrictions related to explicit conversions of literals. The previous behaviour in
+* There are new restrictions related to explicit conversions of literals. The previous behavior in
   the following cases was likely ambiguous:
 
   1. Explicit conversions from negative literals and literals larger than ``type(uint160).max`` to
@@ -106,7 +106,7 @@ This section lists changes that might cause existing contracts to not compile an
 
 * The global functions ``log0``, ``log1``, ``log2``, ``log3`` and ``log4`` have been removed.
 
-  These are low-level functions that were largely unused. Their behaviour can be accessed from inline assembly.
+  These are low-level functions that were largely unused. Their behavior can be accessed from inline assembly.
 
 * ``enum`` definitions cannot contain more than 256 members.
 
@@ -173,4 +173,4 @@ How to update your code
 - Change ``msg.sender.transfer(x)`` to ``payable(msg.sender).transfer(x)`` or use a stored variable of ``address payable`` type.
 - Change ``x**y**z`` to ``(x**y)**z``.
 - Use inline assembly as a replacement for ``log0``, ..., ``log4``.
-- Negate unsigned integers by subtracting them from the maximum value of the type and adding 1 (e.g. ``type(uint256).max - x + 1``, while ensuring that `x` is not zero)
+- Negate unsigned integers by subtracting them from the maximum value of the type and adding 1 (e.g. ``type(uint256).max - x + 1``, while ensuring that ``x`` is not zero)
diff --git a/compiler/docs/Makefile b/compiler/docs/Makefile
index 3cc98f69..01660bd3 100644
--- a/compiler/docs/Makefile
+++ b/compiler/docs/Makefile
@@ -34,7 +34,6 @@ help:
 	@echo "  epub       to make an epub"
 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
 	@echo "  text       to make text files"
 	@echo "  man        to make manual pages"
 	@echo "  texinfo    to make Texinfo files"
@@ -116,12 +115,6 @@ latexpdf:
 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
 
-latexpdfja:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through platex and dvipdfmx..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
 text:
 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
 	@echo
diff --git a/compiler/docs/README.md b/compiler/docs/README.md
new file mode 100644
index 00000000..a3b5f25a
--- /dev/null
+++ b/compiler/docs/README.md
@@ -0,0 +1,23 @@
+# Solidity Language Docs
+
+## Local environment setup
+
+1. Install python https://www.python.org/downloads/
+1. Install sphinx (the tool used to generate the docs) https://www.sphinx-doc.org/en/master/usage/installation.html
+
+Go to `/docs` and run `./docs.sh` to install dependencies and build the project:
+
+```sh
+cd docs
+./docs.sh
+```
+
+That will output the generated htmls under _build/
+
+## Serve environment
+
+```py
+python3 -m http.server -d _build/html --cgi 8080
+```
+
+Visit dev server at http://localhost:8080
diff --git a/compiler/docs/_static/css/custom-dark.css b/compiler/docs/_static/css/custom-dark.css
new file mode 100644
index 00000000..044a8f80
--- /dev/null
+++ b/compiler/docs/_static/css/custom-dark.css
@@ -0,0 +1,595 @@
+
+
+/* DARK MODE STYLING */
+
+/* code directives */
+
+:root[style*=dark] .method dt,
+:root[style*=dark] .class dt,
+:root[style*=dark] .data dt,
+:root[style*=dark] .attribute dt,
+:root[style*=dark] .function dt,
+:root[style*=dark] .classmethod dt,
+:root[style*=dark] .exception dt,
+:root[style*=dark] .descclassname,
+:root[style*=dark] .descname {
+  background-color: #2d2d2d !important;
+}
+
+:root[style*=dark] .rst-content dl:not(.docutils) dt {
+  background-color: #0008;
+  border-top: solid 3px #fff2;
+  border-left: solid 3px #fff2;
+}
+
+:root[style*=dark] em.property {
+  color: #888888;
+}
+
+
+/* tables */
+
+:root[style*=dark] .rst-content table.docutils td {
+  border: 0px;
+}
+
+:root[style*=dark] .rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td {
+  background-color: #0002;
+}
+
+:root[style*=dark] .rst-content pre {
+  background: none;
+}
+
+/* inlined code highlights */
+
+:root[style*=dark] .xref,
+:root[style*=dark] .py-meth {
+  color: #aaddff !important;
+  font-weight: normal !important;
+}
+
+/* highlight color search text */
+
+:root[style*=dark] .rst-content .highlighted {
+  background: #ff5722;
+  box-shadow: 0 0 0 2px #f0978b;
+}
+
+/* notes, warnings, hints */
+
+:root[style*=dark] .hint .admonition-title {
+  background: #2aa87c !important;
+}
+
+:root[style*=dark] .warning .admonition-title {
+  background: #cc4444 !important;
+}
+
+:root[style*=dark] .admonition-title {
+  background: #3a7ca8 !important;
+}
+
+:root[style*=dark] .admonition,
+:root[style*=dark] .note {
+  background-color: #0008 !important;
+}
+
+
+/* table of contents */
+
+:root[style*=dark] .sidebar {
+  background-color: #191919 !important;
+}
+
+:root[style*=dark] .sidebar-title {
+  background-color: #2b2b2b !important;
+}
+
+:root[style*=dark] .wy-menu-vertical code.docutils.literal.notranslate {
+  background: none !important;
+  border: none !important;
+}
+
+
+:root[style*=dark] .toc-backref {
+  color: grey !important;
+}
+
+:root[style*=dark] .highlight {
+  background: #0008;
+  color: #f8f8f2
+}
+
+:root[style*=dark] .highlight .c {
+  color: #888
+}
+
+
+/* Comment */
+
+:root[style*=dark] .highlight .err {
+  color: #960050;
+  background-color: #1e0010
+}
+
+
+/* Error */
+
+:root[style*=dark] .highlight .k {
+  color: #66d9ef
+}
+
+
+/* Keyword */
+
+:root[style*=dark] .highlight .l {
+  color: #ae81ff
+}
+
+
+/* Literal */
+
+:root[style*=dark] .highlight .n {
+  color: #f8f8f2
+}
+
+
+/* Name */
+
+:root[style*=dark] .highlight .o {
+  color: #f92672
+}
+
+
+/* Operator */
+
+:root[style*=dark] .highlight .p {
+  color: #f8f8f2
+}
+
+
+/* Punctuation */
+
+:root[style*=dark] .highlight .ch {
+  color: #888
+}
+
+
+/* Comment.Hashbang */
+
+:root[style*=dark] .highlight .cm {
+  color: #888
+}
+
+
+/* Comment.Multiline */
+
+:root[style*=dark] .highlight .cp {
+  color: #888
+}
+
+
+/* Comment.Preproc */
+
+:root[style*=dark] .highlight .cpf {
+  color: #888
+}
+
+
+/* Comment.PreprocFile */
+
+:root[style*=dark] .highlight .c1 {
+  color: #888
+}
+
+
+/* Comment.Single */
+
+:root[style*=dark] .highlight .cs {
+  color: #888
+}
+
+
+/* Comment.Special */
+
+:root[style*=dark] .highlight .gd {
+  color: #f92672
+}
+
+
+/* Generic.Deleted */
+
+:root[style*=dark] .highlight .ge {
+  font-style: italic
+}
+
+
+/* Generic.Emph */
+
+:root[style*=dark] .highlight .gi {
+  color: #a6e22e
+}
+
+
+/* Generic.Inserted */
+
+:root[style*=dark] .highlight .gs {
+  font-weight: bold
+}
+
+
+/* Generic.Strong */
+
+:root[style*=dark] .highlight .gu {
+  color: #888
+}
+
+
+/* Generic.Subheading */
+
+:root[style*=dark] .highlight .kc {
+  color: #66d9ef
+}
+
+
+/* Keyword.Constant */
+
+:root[style*=dark] .highlight .kd {
+  color: #66d9ef
+}
+
+
+/* Keyword.Declaration */
+
+:root[style*=dark] .highlight .kn {
+  color: #f92672
+}
+
+
+/* Keyword.Namespace */
+
+:root[style*=dark] .highlight .kp {
+  color: #66d9ef
+}
+
+
+/* Keyword.Pseudo */
+
+:root[style*=dark] .highlight .kr {
+  color: #66d9ef
+}
+
+
+/* Keyword.Reserved */
+
+:root[style*=dark] .highlight .kt {
+  color: #66d9ef
+}
+
+
+/* Keyword.Type */
+
+:root[style*=dark] .highlight .ld {
+  color: #e6db74
+}
+
+
+/* Literal.Date */
+
+:root[style*=dark] .highlight .m {
+  color: #ae81ff
+}
+
+
+/* Literal.Number */
+
+:root[style*=dark] .highlight .s {
+  color: #e6db74
+}
+
+
+/* Literal.String */
+
+:root[style*=dark] .highlight .na {
+  color: #a6e22e
+}
+
+
+/* Name.Attribute */
+
+:root[style*=dark] .highlight .nb {
+  color: #f8f8f2
+}
+
+
+/* Name.Builtin */
+
+:root[style*=dark] .highlight .nc {
+  color: #a6e22e
+}
+
+
+/* Name.Class */
+
+:root[style*=dark] .highlight .no {
+  color: #66d9ef
+}
+
+
+/* Name.Constant */
+
+:root[style*=dark] .highlight .nd {
+  color: #a6e22e
+}
+
+
+/* Name.Decorator */
+
+:root[style*=dark] .highlight .ni {
+  color: #f8f8f2
+}
+
+
+/* Name.Entity */
+
+:root[style*=dark] .highlight .ne {
+  color: #a6e22e
+}
+
+
+/* Name.Exception */
+
+:root[style*=dark] .highlight .nf {
+  color: #a6e22e
+}
+
+
+/* Name.Function */
+
+:root[style*=dark] .highlight .nl {
+  color: #f8f8f2
+}
+
+
+/* Name.Label */
+
+:root[style*=dark] .highlight .nn {
+  color: #f8f8f2
+}
+
+
+/* Name.Namespace */
+
+:root[style*=dark] .highlight .nx {
+  color: #a6e22e
+}
+
+
+/* Name.Other */
+
+:root[style*=dark] .highlight .py {
+  color: #f8f8f2
+}
+
+
+/* Name.Property */
+
+:root[style*=dark] .highlight .nt {
+  color: #f92672
+}
+
+
+/* Name.Tag */
+
+:root[style*=dark] .highlight .nv {
+  color: #f8f8f2
+}
+
+
+/* Name.Variable */
+
+:root[style*=dark] .highlight .ow {
+  color: #f92672
+}
+
+
+/* Operator.Word */
+
+:root[style*=dark] .highlight .w {
+  color: #f8f8f2
+}
+
+
+/* Text.Whitespace */
+
+:root[style*=dark] .highlight .mb {
+  color: #ae81ff
+}
+
+
+/* Literal.Number.Bin */
+
+:root[style*=dark] .highlight .mf {
+  color: #ae81ff
+}
+
+
+/* Literal.Number.Float */
+
+:root[style*=dark] .highlight .mh {
+  color: #ae81ff
+}
+
+
+/* Literal.Number.Hex */
+
+:root[style*=dark] .highlight .mi {
+  color: #ae81ff
+}
+
+
+/* Literal.Number.Integer */
+
+:root[style*=dark] .highlight .mo {
+  color: #ae81ff
+}
+
+
+/* Literal.Number.Oct */
+
+:root[style*=dark] .highlight .sa {
+  color: #e6db74
+}
+
+
+/* Literal.String.Affix */
+
+:root[style*=dark] .highlight .sb {
+  color: #e6db74
+}
+
+
+/* Literal.String.Backtick */
+
+:root[style*=dark] .highlight .sc {
+  color: #e6db74
+}
+
+
+/* Literal.String.Char */
+
+:root[style*=dark] .highlight .dl {
+  color: #e6db74
+}
+
+
+/* Literal.String.Delimiter */
+
+:root[style*=dark] .highlight .sd {
+  color: #e6db74
+}
+
+
+/* Literal.String.Doc */
+
+:root[style*=dark] .highlight .s2 {
+  color: #e6db74
+}
+
+
+/* Literal.String.Double */
+
+:root[style*=dark] .highlight .se {
+  color: #ae81ff
+}
+
+
+/* Literal.String.Escape */
+
+:root[style*=dark] .highlight .sh {
+  color: #e6db74
+}
+
+
+/* Literal.String.Heredoc */
+
+:root[style*=dark] .highlight .si {
+  color: #e6db74
+}
+
+
+/* Literal.String.Interpol */
+
+:root[style*=dark] .highlight .sx {
+  color: #e6db74
+}
+
+
+/* Literal.String.Other */
+
+:root[style*=dark] .highlight .sr {
+  color: #e6db74
+}
+
+
+/* Literal.String.Regex */
+
+:root[style*=dark] .highlight .s1 {
+  color: #e6db74
+}
+
+
+/* Literal.String.Single */
+
+:root[style*=dark] .highlight .ss {
+  color: #e6db74
+}
+
+
+/* Literal.String.Symbol */
+
+:root[style*=dark] .highlight .bp {
+  color: #f8f8f2
+}
+
+
+/* Name.Builtin.Pseudo */
+
+:root[style*=dark] .highlight .fm {
+  color: #a6e22e
+}
+
+
+/* Name.Function.Magic */
+
+:root[style*=dark] .highlight .vc {
+  color: #f8f8f2
+}
+
+
+/* Name.Variable.Class */
+
+:root[style*=dark] .highlight .vg {
+  color: #f8f8f2
+}
+
+
+/* Name.Variable.Global */
+
+:root[style*=dark] .highlight .vi {
+  color: #f8f8f2
+}
+
+
+/* Name.Variable.Instance */
+
+:root[style*=dark] .highlight .vm {
+  color: #f8f8f2
+}
+
+
+/* Name.Variable.Magic */
+
+:root[style*=dark] .highlight .il {
+  color: #ae81ff
+}
+
+
+/* Grammar */
+
+:root[style*=dark] .railroad-diagram {
+  fill: white;
+}
+
+:root[style*=dark] .railroad-diagram path {
+  stroke: white;
+}
+
+:root[style*=dark] .railroad-diagram rect {
+  stroke: white;
+}
+
+:root[style*=dark] .a4 .sig-name {
+  background-color: transparent !important;
+}
diff --git a/compiler/docs/_static/css/custom.css b/compiler/docs/_static/css/custom.css
index 4ff53f3a..25ab2654 100644
--- a/compiler/docs/_static/css/custom.css
+++ b/compiler/docs/_static/css/custom.css
@@ -1,23 +1,185 @@
+/* ROOT DECLARATIONS */
+:root {
+    /* Text */
+    --color-a: #2B247C;
+    --color-b: #672AC8;
+    --color-c: #5554D9;
+    --color-d: #9F94E8;
+    --color-e: #AEC0F1;
+    --color-f: #E6E3EC;
+    /* Background */
+
+    --white: #FAF8FF;
+    --black: #110C4E;
+    --menu-bg: #2B247C06;
+    --shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+
+    --navHeight: 4.5rem;
+    --sideWidth: 300px;
+    --maxWidth: 80rem;
+    --desktopInlinePadding: 2rem;
+    --mobileInlinePadding: 1rem;
+    --currentVersionHeight: 45px;
+
+    text-rendering: geometricPrecision;
+    -webkit-font-smoothing: antialiased;
+}
+
+a,
+button {
+    border-radius: 0;
+}
+
+:root[style*=dark] {
+    --color-a: #E6E3EC !important;
+    --color-b: #AEC0F1 !important;
+    --color-c: #9F94E8 !important;
+    --color-d: #5554D9 !important;
+    --color-e: #672AC8 !important;
+    --color-f: #2B247C !important;
+
+    --white: #110C4E !important;
+    --black: #FAF8FF !important;
+    --menu-bg: #E6E3EC06 !important;
+}
+
+html,
+body,
+.unified-header::before,
+.wy-nav-side,
+.rst-versions,
+code,
+div,
+input[type=text],
+a,
+.wy-grid-for-nav {
+    transition: background 150ms ease-in-out;
+}
+
+html,
+body,
+.wy-grid-for-nav {
+    background-color: var(--color-f) !important;
+}
+
+body {
+    font-family: "Overpass", sans-serif;
+}
+
+a {
+    color: var(--color-c);
+}
+
+a, section {
+    scroll-margin-top: calc(var(--navHeight) + 2rem);
+}
+
+hr {
+    margin-block: 2rem;
+    border-color: var(--color-d) !important;
+}
+
+
+/* HEADER STYLES */
+h1 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 44px;
+    color: var(--color-a) !important;
+    line-height: 1.1;
+    text-wrap: balance;
+    margin-top: 4rem;
+    margin-bottom: 1.5rem;
+}
+
+section:first-of-type h1:first-of-type {
+    font-family: 'Overpass mono', monospace;
+    font-size: 48px;
+    margin-top: 3rem;
+    margin-bottom: 5rem;
+}
+
+h2 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 38px;
+    color: var(--color-a) !important;
+    line-height: 46px;
+    text-wrap: balance;
+    margin-top: 4rem;
+    margin-bottom: 1.5rem;
+}
+
+*:not([role=navigation])>p[role=heading]>span,
+h3 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 32px;
+    color: var(--color-a) !important;
+    line-height: 46px;
+    text-wrap: balance;
+    margin-top: 4rem;
+    margin-bottom: 1.5rem;
+}
+
+h4 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 32px;
+    color: var(--color-a) !important;
+    line-height: 46px;
+    text-wrap: balance;
+    margin-top: 3rem;
+    margin-bottom: 1.5rem;
+}
+
+h5 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 18px;
+    color: var(--color-a) !important;
+    line-height: 1.4;
+    text-wrap: balance;
+}
+
+h6 {
+    font-family: 'Overpass', sans-serif;
+    font-weight: 700;
+    font-size: 16px;
+    color: var(--color-a) !important;
+    line-height: 1.4;
+    text-wrap: balance;
+}
+
+span.pre,
 pre {
-    white-space: pre-wrap;       /* css-3 */
-    white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
-    white-space: -pre-wrap;      /* Opera 4-6 */
-    white-space: -o-pre-wrap;    /* Opera 7 */
+    /* css-3 */
+    white-space: pre-wrap;
+    /* Mozilla, since 1999 */
+    white-space: -moz-pre-wrap;
+    /* Opera 4-6 */
+    white-space: -pre-wrap;
+    /* Opera 7 */
+    white-space: -o-pre-wrap;
     word-wrap: break-word;
+    font-family: 'Overpass Mono', monospace;
 }
 
-.wy-table-responsive table td, .wy-table-responsive table th {
+small,
+small * {
+    font-size: 12px;
+}
+
+.wy-table-responsive table td,
+.wy-table-responsive table th {
     white-space: normal;
 }
+
 .rst-content table.docutils td {
     vertical-align: top;
 }
 
 /* links */
-.rst-content a:not(:visited) {
-    color: #002fa7;
-}
-
 .rst-content .highlighted {
     background: #eac545;
 }
@@ -27,60 +189,638 @@ pre {
     background: #fafafa;
 }
 
-.wy-side-nav-search img.logo {
-    width: 100px !important;
-    padding: 0;
+/* project version (displayed under project logo) */
+.wy-side-nav-search>div.version {
+    color: var(--color-b);
+    margin-top: 0;
+    margin-bottom: 0.5rem;
+    text-align: start;
 }
 
-.wy-side-nav-search > a {
-    padding: 0;
+/* Link to Remix IDE shown next to code snippets */
+.rst-content p.remix-link-container {
+    display: block;
+    text-align: right;
     margin: 0;
+    line-height: 1em;
 }
 
-/* project version (displayed under project logo) */
-.wy-side-nav-search .version {
-    color: #272525 !important;
+.rst-content .remix-link-container a.remix-link {
+    font-size: 0.7em;
+    padding: 0.1em 0.5em;
+    background: transparent;
+    color: var(--color-a) !important;
+    border: 1px solid var(--color-a);
+    text-decoration: none;
 }
 
-/* menu section headers */
-.wy-menu .caption {
-    color: #65afff !important;
+.rst-content div.highlight-solidity,
+.rst-content div.highlight-yul {
+    margin-top: 0;
 }
 
-/* Link to Remix IDE shown next to code snippets */
-p.remix-link-container {
+/* CUSTOMIZATION UPDATES */
+
+.wy-nav-content-wrap,
+.wy-nav-content {
+    background: transparent !important;
+}
+
+.wy-side-nav-search {
+    background-color: transparent !important;
+    color: var(--color-a) !important;
+    box-shadow: 0 4 4 0 var(--color-a);
+    border-bottom: 1px solid var(--color-d) !important;
+}
+
+.wy-side-nav-search svg {
+    color: var(--color-a) !important;
+}
+
+.wy-nav-top {
+    background-color: transparent !important;
+    color: var(--color-a) !important;
+}
+
+.wy-nav-top a {
+    color: var(--color-a) !important;
+}
+
+.wy-breadcrumbs a.icon-home:before {
+    content: "Documentation";
+    font-family: "Overpass", sans-serif;
+}
+
+.rst-content table.docutils thead {
+    color: var(--color-a);
+}
+
+code.docutils.literal.notranslate {
+    padding: 2px 4px;
+    font-size: 0.875em;
+    font-family: "Overpass Mono", monospace;
+    background: var(--white);
+    color: var(--color-c);
+    border: 0px;
+}
+
+dt code.docutils.literal.notranslate {
+    background: none;
+}
+
+.wy-nav-content {
+    color: var(--color-a);
+}
+
+/* .rst-content a:not(:visited) { */
+/* color: var(--color-b) !important; */
+/* } */
+
+.rst-content a:visited {
+    color: var(--color-c) !important;
+}
+
+.rst-content a {
+    text-decoration: underline;
+}
+
+.rst-content a:where(:focus, :focus-visible, :hover) {
+    color: var(--color-d) !important;
+}
+
+.wy-side-scroll a {
+    color: var(--color-a);
+    background: transparent;
+    font-size: 1rem;
+    line-height: 125%;
+}
+
+.wy-menu-vertical li.current a,
+.wy-menu-vertical li.current li a,
+.wy-menu-vertical li.current li a code {
+    border: none;
+    color: var(--color-a);
+}
+
+ul.current ul,
+.wy-menu-vertical li.current a:hover,
+.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,
+.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,
+.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,
+.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,
+.wy-menu-vertical li.current {
+    background: var(--menu-bg) !important;
+}
+
+.wy-menu.wy-menu-vertical>ul {
+    margin-bottom: 3rem;
+}
+
+.wy-menu.wy-menu-vertical>p {
+    color: var(--color-c);
+}
+
+.wy-menu-vertical li.on a,
+.wy-menu-vertical li.current>a {
+    background: var(--menu-bg) !important;
+    border-bottom: 0px !important;
+    border-top: 0px !important;
+}
+
+.btn {
+    border-radius: 0;
+    text-decoration: none !important;
+}
+
+.wy-breadcrumbs-aside a,
+.wy-breadcrumbs-aside a:visited,
+a.fa.fa-github,
+a.fa.fa-github:visited,
+a.fa.fa-github:not(:visited),
+a.btn.btn-neutral:visited,
+a.btn.btn-neutral:not(:visited),
+a.btn.btn-neutral {
+    background: transparent !important;
+    color: var(--color-a) !important;
+    border: 2px solid var(--color-a) !important;
+    text-decoration: none;
+}
+
+.rst-content .remix-link-container a.remix-link:hover,
+.wy-breadcrumbs-aside a:hover,
+a.fa.fa-github:hover,
+a.btn.btn-neutral:hover {
+    background: var(--white) !important;
+    color: var(--color-b) !important;
+    border-color: var(--color-b) !important;
+}
+
+footer .rst-footer-buttons {
+    display: flex;
+    justify-content: center;
+    gap: 2rem;
+}
+
+/**
+ * Customization for the unified layout
+ */
+
+/* Site wrapper, and two children: header and rest */
+.unified-wrapper {
     position: relative;
-    right: -100%;        /* Positioned next to the the top-right corner of the code block following it. */
+    display: flex;
+    flex-direction: column;
+    inset: 0;
+    max-width: var(--maxWidth);
+    margin-inline: auto;
+}
+
+/* Site header */
+.unified-header {
+    position: fixed;
+    top: 0;
+    inset-inline: 0;
+    z-index: 99999;
+    display: flex;
+    align-items: center;
+    box-shadow: var(--shadow);
 }
 
-a.remix-link {
-    position: absolute;  /* Remove it from normal flow not to affect the original position of the snippet. */
-    top: 0.5em;
-    width: 3.236em;      /* Size of the margin (= right-side padding in .wy-nav-content in the current theme). */
+.unified-header .inner-header {
+    display: flex;
+    margin-inline: auto;
+    width: 100%;
+    max-width: var(--maxWidth);
+    align-items: center;
+    justify-content: space-between;
+    padding-inline: var(--desktopInlinePadding);
+    padding-block: 1rem;
 }
 
-a.remix-link .link-icon {
-    background: url("../img/solid-share-arrow.svg") no-repeat;
+.unified-header::before {
+    content: "";
+    position: absolute;
+    inset: 0;
+    opacity: 95%;
+    background: var(--color-f);
+    z-index: -1;
+    backdrop-filter: blur(3px);
+}
+
+.unified-header .home-link {
     display: block;
-    width: 1.5em;
-    height: 1.5em;
-    margin: auto;
+    text-decoration: none;
+    width: 25px;
+    height: 40px;
 }
 
-a.remix-link .link-text {
-    display: none;       /* Visible only on hover. */
-    width: 3.3em;        /* Narrow enough to get two lines of text. */
-    margin: auto;
-    text-align: center;
-    font-size: 0.8em;
-    line-height: normal;
-    color: black;
+.unified-header .home-link:hover .solidity-logo {
+    transform: scale(1.1);
+    transition: transform 100ms ease-in-out;
 }
 
-a.remix-link:hover {
+.unified-header img.solidity-logo {
+    transform: scale(1);
+    transition: transform 100ms ease-in-out;
+    width: 100%;
+    height: 100%;
+}
+
+.unified-header .nav-bar {
+    display: flex;
+    align-items: center;
+    justify-content: flex-end;
+}
+
+.unified-header .nav-bar .nav-button-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+}
+
+.unified-header .nav-link {
+    display: inline-block;
+    padding-inline: 8px;
+    padding-block: 4px;
+    font-size: 14px;
+    font-family: 'Overpass Mono', monospace;
+    text-decoration: none;
+    color: var(--color-a);
+    letter-spacing: -0.02em;
+    font-weight: 400;
+    box-sizing: content-box;
+    border-bottom: 1px solid transparent;
+    white-space: nowrap;
+}
+
+.unified-header .nav-link.active {
+    background: var(--white);
+}
+
+.unified-header .nav-link:hover {
+    color: var(--color-c);
+    border-bottom: 1px solid var(--color-c);
+}
+
+/* Rest: Flex-row, with two children: side bar, and content */
+.unified-wrapper .wy-grid-for-nav {
+    position: relative !important;
+    display: flex;
+    margin-inline: auto;
+}
+
+/* First child: Side bar */
+.unified-wrapper .wy-grid-for-nav nav.wy-nav-side {
+    position: fixed;
+    display: flex;
+    flex-direction: column;
+    background: var(--color-f);
+    color: var(--color-a);
+    padding-bottom: unset !important;
+    z-index: 10 !important;
+    min-height: unset !important;
+    width: var(--sideWidth) !important;
+    top: var(--navHeight);
+    bottom: 0;
+    left: auto;
+    overflow: auto;
+}
+
+.unified-wrapper .wy-grid-for-nav nav.wy-nav-side .wy-side-scroll {
+    position: static !important;
+    width: unset !important;
+    overflow: unset !important;
+    height: unset !important;
+    padding-bottom: 2rem;
+}
+
+.unified-wrapper .wy-grid-for-nav nav.wy-nav-side .wy-side-scroll .wy-side-nav-search {
+    margin: 0 !important;
+    width: var(--sideWidth) !important;
+}
+
+.wy-nav-side,
+.wy-side-scroll,
+.wy-side-nav-search,
+.my-menu {
+    width: 100% !important;
+}
+
+.wy-nav-side input[type=text] {
+    font-family: "Overpass", sans-serif;
+    border-radius: 0;
+    border-color: var(--color-d);
+    background: var(--white);
+    box-shadow: none;
+    color: var(--color-a);
+}
+
+.wy-nav-side input[type=text]::placeholder {
+    font-family: "Overpass", sans-serif;
+    color: var(--color-e);
+    font-size: 16px;
+    position: relative;
+    top: 4px;
+}
+
+/* Second child: Content */
+.unified-wrapper .wy-grid-for-nav .wy-nav-content {
+    width: 100%;
+    max-width: unset !important; /* override */
+    padding-inline: var(--desktopInlinePadding);
+    margin-inline-start: var(--sideWidth);
+    margin-top: var(--navHeight);
+}
+
+.unified-wrapper .wy-grid-for-nav .wy-nav-content .rst-content {
+    max-width: min(70ch, calc(100vw -  2 * var(--desktopInlinePadding) - var(--sideWidth)));
+    margin-inline: auto;
+}
+
+.unified-wrapper.menu-open .backdrop {
     opacity: 0.5;
 }
 
-a.remix-link:hover .link-text {
+.unified-wrapper .wy-nav-side,
+.unified-wrapper .rst-versions {
+    left: auto;
+
+}
+
+.unified-wrapper .backdrop {
+    opacity: 0;
+    transition: opacity 200ms ease-in-out;
+}
+
+@media (max-width: 768px) {
+    h2 {
+        margin-top: 3rem;
+        margin-bottom: 1rem;
+    }
+
+    h3 {
+        margin-top: 3rem;
+        margin-bottom: 1rem;
+    }
+
+    h4 {
+        margin-top: 2rem;
+        margin-bottom: 1rem;
+    }
+
+    /* Menu closed styles */
+    .unified-header .nav-link {
+        display: none;
+    }
+
+    .unified-header .inner-header {
+        padding-inline: var(--mobileInlinePadding);
+    }
+
+    .unified-wrapper .wy-grid-for-nav nav.wy-nav-side {
+        transform: translateX(-100%);
+        transition: transform 200ms ease-in-out;
+    }
+
+    /* Menu open styles */
+    .unified-wrapper.menu-open nav.wy-nav-side {
+        transform: translateX(0);
+        transition: transform 200ms ease-in-out;
+    }
+
+    .unified-wrapper.menu-open .rst-versions {
+        position: sticky;
+        bottom: 0;
+        width: 100%;
+    }
+
+    .unified-wrapper.menu-open .backdrop {
+        display: block;
+        position: fixed;
+        inset: 0;
+        opacity: 1;
+        transition: opacity 200ms ease-in-out;
+        z-index: 5;
+        background: #0006;
+    }
+
+    a.skip-to-content {
+        display: none;
+    }
+
+    .wy-nav-content {
+        margin-inline-start: 0 !important;
+    }
+
+    .rst-content {
+        max-width: 100% !important;
+    }
+
+    .wy-side-scroll {
+        padding-bottom: 0 !important;
+    }
+}
+
+ul.search .context {
+    color: var(--color-a) !important;
+}
+
+.rst-versions {
+    background: var(--color-f);
+}
+
+.rst-versions.shift-up {
+    height: unset !important;
+    max-height: unset !important;
+    overflow-y: unset !important;
+}
+
+.rst-content dl:not(.docutils) dt {
+    color: var(--color-a);
+    background-color: #fff8;
+    border-top: solid 3px #0002;
+    border-inline-start: solid 3px #0002;
+    padding: 2px 6px;
+}
+
+.rst-versions .rst-current-version {
+    border-color: var(--color-d) !important;
+}
+
+.rst-current-version *,
+.rst-current-version .fa:before,
+.rst-current-version .fa-element {
+    color: var(--color-b) !important;
+}
+
+.rst-current-version dt,
+.rst-current-version dd,
+.rst-current-version dd a,
+.rst-other-versions dl:last-of-type dt,
+.rst-other-versions dl:last-of-type dd,
+.rst-other-versions dl:last-of-type dd a {
+    font-size: 14px !important;
+}
+
+.rst-other-versions {
+    background: var(--white) !important;
+    color: var(--color-a) !important;
+    max-height: calc(100vh - var(--navHeight) - var(--currentVersionHeight));
+    overflow-y: scroll;
+}
+
+.rst-other-versions a {
+    text-decoration: underline;
+    color: var(--color-c) !important;
+}
+
+.rst-other-versions dt {
+    color: var(--color-a) !important;
+}
+
+.rst-other-versions dl {
+    margin-bottom: 1.5rem !important;
+}
+
+.rst-other-versions dl:last-of-type {
+    margin-top: 2rem !important;
+}
+
+/* Bottom Search */
+.wy-nav-side input[type=text],
+.rst-other-versions dl:last-of-type dd {
+    width: 100%;
+}
+
+.rst-other-versions dl:last-of-type dt {
+    color: var(--color-b) !important;
+}
+
+.rst-other-versions dl:last-of-type div[style*=padding],
+.rst-other-versions dl dd:first-of-type a {
+    padding-inline-start: 0 !important;
+}
+
+button.toctree-expand {
+    color: var(--black) !important;
+}
+
+/* Light/dark color mode toggle 🌓 */
+button.color-toggle {
+    display: inline-flex;
+    appearance: none;
+    -webkit-box-align: center;
+    align-items: center;
+    -webkit-box-pack: center;
+    justify-content: center;
+    user-select: none;
+    outline: none;
+    height: 28px;
+    width: 28px;
+    background: none;
+    border: none;
+    padding: 6px;
+    margin: 6px;
+    transition-duration: 200ms;
+    transition-property: background-color,
+        color,
+        fill,
+        stroke,
+        opacity;
+}
+
+button.color-toggle:focus-visible {
+    outline: 2px solid var(--color-c);
+    color: var(--color-c);
+}
+
+button.color-toggle:hover {
+    color: var(--color-c);
+    background: #0002;
+}
+
+button.color-toggle .color-toggle-icon {
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    display: inline-block;
+    line-height: 1em;
+    -webkit-flex-shrink: 0;
+    -ms-flex-negative: 0;
+    flex-shrink: 0;
+    vertical-align: middle;
+    /* color: var(--color-a); */
+}
+
+
+button.mobile-menu-button {
+    display: none;
+}
+
+@media (max-width: 768px) {
+    nav.wy-nav-top {
+        display: none;
+    }
+
+    button.mobile-menu-button {
+        display: flex;
+    }
+}
+
+
+.hidden {
+    display: none;
+}
+
+#search-results .search li:first-child,
+#search-results .search li {
+    border-color: var(--color-d);
+}
+
+#search-results .search li:last-child {
+    border: 0px;
+}
+
+.forum-link::after {
+    content: ' ↗';
+    font-size: 14px;
+    font-family: 'Overpass Mono', monospace;
+}
+
+.wy-breadcrumbs>li {
+    padding-top: 8px;
+}
+
+.wy-breadcrumbs-aside a {
+    padding: 0.5rem 0.75rem;
+    font-size: 12px;
+    font-family: "'Overpass'", sans-serif;
+    font-weight: 700;
+}
+
+a.skip-to-content:visited,
+a.skip-to-content:not(:visited),
+a.skip-to-content {
     display: block;
+    pointer-events: none;
+    width: fit-content;
+    opacity: 0;
+    transition: opacity 200ms ease-in-out;
+    padding: 2px 4px;
+    font-size: 14px;
+    margin-inline-end: auto;
+    margin-inline-start: 1.5rem;
+    color: var(--color-a);
+    white-space: nowrap;
 }
+
+a.skip-to-content:focus {
+    opacity: 1;
+    transition: opacity 200ms ease-in-out;
+}
+
+#content {
+    scroll-margin-top: 6rem;
+    scroll-behavior: smooth;
+}
\ No newline at end of file
diff --git a/compiler/docs/_static/css/dark.css b/compiler/docs/_static/css/dark.css
deleted file mode 100644
index a87ff09e..00000000
--- a/compiler/docs/_static/css/dark.css
+++ /dev/null
@@ -1,635 +0,0 @@
-/* links */
-
-.rst-content a:not(:visited) {
-    color: #aaddff !important;
-}
-
-/* code directives */
-
-.method dt,
-.class dt,
-.data dt,
-.attribute dt,
-.function dt,
-.classmethod dt,
-.exception dt,
-.descclassname,
-.descname {
-    background-color: #2d2d2d !important;
-}
-
-.rst-content dl:not(.docutils) dt {
-    color: #aaddff;
-    background-color: #2d2d2d;
-    border-top: solid 3px #525252;
-    border-left: solid 3px #525252;
-}
-
-em.property {
-    color: #888888;
-}
-
-
-/* tables */
-
-.rst-content table.docutils thead {
-    color: #ddd;
-}
-
-.rst-content table.docutils td {
-    border: 0px;
-}
-
-.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td {
-    background-color: #5a5a5a;
-}
-
-.rst-content pre {
-    background: none;
-}
-
-/* inlined code highlights */
-
-.xref,
-.py-meth,
-.rst-content a code {
-    color: #aaddff !important;
-    font-weight: normal !important;
-}
-
-.rst-content code {
-    color: #eee !important;
-    font-weight: normal !important;
-}
-
-code.literal {
-    background-color: #2d2d2d !important;
-    border: 1px solid #6d6d6d !important;
-}
-
-code.docutils.literal.notranslate {
-    color: #ddd;
-}
-
-/* highlight color search text */
-
-.rst-content .highlighted {
-    background: #ff5722;
-    box-shadow: 0 0 0 2px #f0978b;
-}
-
-/* notes, warnings, hints */
-
-.hint .admonition-title {
-    background: #2aa87c !important;
-}
-
-.warning .admonition-title {
-    background: #cc4444 !important;
-}
-
-.admonition-title {
-    background: #3a7ca8 !important;
-}
-
-.admonition,
-.note {
-    background-color: #2d2d2d !important;
-}
-
-
-/* table of contents */
-
-.wy-nav-content-wrap {
-    background-color: rgba(0, 0, 0, 0.6) !important;
-}
-
-.sidebar {
-    background-color: #191919 !important;
-}
-
-.sidebar-title {
-    background-color: #2b2b2b !important;
-}
-
-.wy-menu-vertical a {
-    color: #ddd;
-}
-
-.wy-menu-vertical code.docutils.literal.notranslate {
-    color: #404040;
-    background: none !important;
-    border: none !important;
-}
-
-.wy-nav-content {
-    background: #3c3c3c;
-    color: #dddddd;
-}
-
-.wy-menu-vertical li.on a,
-.wy-menu-vertical li.current>a {
-    background: #a3a3a3;
-    border-bottom: 0px !important;
-    border-top: 0px !important;
-}
-
-.wy-menu-vertical li.current {
-    background: #b3b3b3;
-}
-
-.toc-backref {
-    color: grey !important;
-}
-
-.highlight .hll {
-    background-color: #49483e
-}
-
-.highlight {
-    background: #222;
-    color: #f8f8f2
-}
-
-.highlight .c {
-    color: #888
-}
-
-
-/* Comment */
-
-.highlight .err {
-    color: #960050;
-    background-color: #1e0010
-}
-
-
-/* Error */
-
-.highlight .k {
-    color: #66d9ef
-}
-
-
-/* Keyword */
-
-.highlight .l {
-    color: #ae81ff
-}
-
-
-/* Literal */
-
-.highlight .n {
-    color: #f8f8f2
-}
-
-
-/* Name */
-
-.highlight .o {
-    color: #f92672
-}
-
-
-/* Operator */
-
-.highlight .p {
-    color: #f8f8f2
-}
-
-
-/* Punctuation */
-
-.highlight .ch {
-    color: #888
-}
-
-
-/* Comment.Hashbang */
-
-.highlight .cm {
-    color: #888
-}
-
-
-/* Comment.Multiline */
-
-.highlight .cp {
-    color: #888
-}
-
-
-/* Comment.Preproc */
-
-.highlight .cpf {
-    color: #888
-}
-
-
-/* Comment.PreprocFile */
-
-.highlight .c1 {
-    color: #888
-}
-
-
-/* Comment.Single */
-
-.highlight .cs {
-    color: #888
-}
-
-
-/* Comment.Special */
-
-.highlight .gd {
-    color: #f92672
-}
-
-
-/* Generic.Deleted */
-
-.highlight .ge {
-    font-style: italic
-}
-
-
-/* Generic.Emph */
-
-.highlight .gi {
-    color: #a6e22e
-}
-
-
-/* Generic.Inserted */
-
-.highlight .gs {
-    font-weight: bold
-}
-
-
-/* Generic.Strong */
-
-.highlight .gu {
-    color: #888
-}
-
-
-/* Generic.Subheading */
-
-.highlight .kc {
-    color: #66d9ef
-}
-
-
-/* Keyword.Constant */
-
-.highlight .kd {
-    color: #66d9ef
-}
-
-
-/* Keyword.Declaration */
-
-.highlight .kn {
-    color: #f92672
-}
-
-
-/* Keyword.Namespace */
-
-.highlight .kp {
-    color: #66d9ef
-}
-
-
-/* Keyword.Pseudo */
-
-.highlight .kr {
-    color: #66d9ef
-}
-
-
-/* Keyword.Reserved */
-
-.highlight .kt {
-    color: #66d9ef
-}
-
-
-/* Keyword.Type */
-
-.highlight .ld {
-    color: #e6db74
-}
-
-
-/* Literal.Date */
-
-.highlight .m {
-    color: #ae81ff
-}
-
-
-/* Literal.Number */
-
-.highlight .s {
-    color: #e6db74
-}
-
-
-/* Literal.String */
-
-.highlight .na {
-    color: #a6e22e
-}
-
-
-/* Name.Attribute */
-
-.highlight .nb {
-    color: #f8f8f2
-}
-
-
-/* Name.Builtin */
-
-.highlight .nc {
-    color: #a6e22e
-}
-
-
-/* Name.Class */
-
-.highlight .no {
-    color: #66d9ef
-}
-
-
-/* Name.Constant */
-
-.highlight .nd {
-    color: #a6e22e
-}
-
-
-/* Name.Decorator */
-
-.highlight .ni {
-    color: #f8f8f2
-}
-
-
-/* Name.Entity */
-
-.highlight .ne {
-    color: #a6e22e
-}
-
-
-/* Name.Exception */
-
-.highlight .nf {
-    color: #a6e22e
-}
-
-
-/* Name.Function */
-
-.highlight .nl {
-    color: #f8f8f2
-}
-
-
-/* Name.Label */
-
-.highlight .nn {
-    color: #f8f8f2
-}
-
-
-/* Name.Namespace */
-
-.highlight .nx {
-    color: #a6e22e
-}
-
-
-/* Name.Other */
-
-.highlight .py {
-    color: #f8f8f2
-}
-
-
-/* Name.Property */
-
-.highlight .nt {
-    color: #f92672
-}
-
-
-/* Name.Tag */
-
-.highlight .nv {
-    color: #f8f8f2
-}
-
-
-/* Name.Variable */
-
-.highlight .ow {
-    color: #f92672
-}
-
-
-/* Operator.Word */
-
-.highlight .w {
-    color: #f8f8f2
-}
-
-
-/* Text.Whitespace */
-
-.highlight .mb {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Bin */
-
-.highlight .mf {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Float */
-
-.highlight .mh {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Hex */
-
-.highlight .mi {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Integer */
-
-.highlight .mo {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Oct */
-
-.highlight .sa {
-    color: #e6db74
-}
-
-
-/* Literal.String.Affix */
-
-.highlight .sb {
-    color: #e6db74
-}
-
-
-/* Literal.String.Backtick */
-
-.highlight .sc {
-    color: #e6db74
-}
-
-
-/* Literal.String.Char */
-
-.highlight .dl {
-    color: #e6db74
-}
-
-
-/* Literal.String.Delimiter */
-
-.highlight .sd {
-    color: #e6db74
-}
-
-
-/* Literal.String.Doc */
-
-.highlight .s2 {
-    color: #e6db74
-}
-
-
-/* Literal.String.Double */
-
-.highlight .se {
-    color: #ae81ff
-}
-
-
-/* Literal.String.Escape */
-
-.highlight .sh {
-    color: #e6db74
-}
-
-
-/* Literal.String.Heredoc */
-
-.highlight .si {
-    color: #e6db74
-}
-
-
-/* Literal.String.Interpol */
-
-.highlight .sx {
-    color: #e6db74
-}
-
-
-/* Literal.String.Other */
-
-.highlight .sr {
-    color: #e6db74
-}
-
-
-/* Literal.String.Regex */
-
-.highlight .s1 {
-    color: #e6db74
-}
-
-
-/* Literal.String.Single */
-
-.highlight .ss {
-    color: #e6db74
-}
-
-
-/* Literal.String.Symbol */
-
-.highlight .bp {
-    color: #f8f8f2
-}
-
-
-/* Name.Builtin.Pseudo */
-
-.highlight .fm {
-    color: #a6e22e
-}
-
-
-/* Name.Function.Magic */
-
-.highlight .vc {
-    color: #f8f8f2
-}
-
-
-/* Name.Variable.Class */
-
-.highlight .vg {
-    color: #f8f8f2
-}
-
-
-/* Name.Variable.Global */
-
-.highlight .vi {
-    color: #f8f8f2
-}
-
-
-/* Name.Variable.Instance */
-
-.highlight .vm {
-    color: #f8f8f2
-}
-
-
-/* Name.Variable.Magic */
-
-.highlight .il {
-    color: #ae81ff
-}
-
-
-/* Literal.Number.Integer.Long */
-
-
-/* Link to Remix IDE shown over code snippets */
-a.remix-link {
-    filter: invert(1); /* The icon is black. In dark mode we want it white. */
-}
diff --git a/compiler/docs/_static/css/fonts.css b/compiler/docs/_static/css/fonts.css
new file mode 100644
index 00000000..1a987a6d
--- /dev/null
+++ b/compiler/docs/_static/css/fonts.css
@@ -0,0 +1,2 @@
+@import url("https://fonts.cdnfonts.com/css/overpass");
+@import url("https://fonts.cdnfonts.com/css/overpass-mono");
\ No newline at end of file
diff --git a/compiler/docs/_static/css/pygments.css b/compiler/docs/_static/css/pygments.css
new file mode 100644
index 00000000..0e640681
--- /dev/null
+++ b/compiler/docs/_static/css/pygments.css
@@ -0,0 +1,399 @@
+pre {
+  line-height: 125%;
+}
+
+td.linenos .normal {
+  color: inherit;
+  background-color: transparent;
+  padding-left: 5px;
+  padding-right: 5px;
+}
+
+span.linenos {
+  color: inherit;
+  background-color: transparent;
+  padding-left: 5px;
+  padding-right: 5px;
+}
+
+td.linenos .special {
+  color: #000000;
+  background-color: #ffffc0;
+  padding-left: 5px;
+  padding-right: 5px;
+}
+
+span.linenos.special {
+  color: #000000;
+  background-color: #ffffc0;
+  padding-left: 5px;
+  padding-right: 5px;
+}
+
+.highlight .hll {
+  background-color: #ffffcc
+}
+
+.highlight {
+  background: #eeffcc;
+}
+
+.highlight .c {
+  color: #408090;
+  font-style: italic
+}
+
+/* Comment */
+.highlight .err {
+  border: 1px solid #FF0000
+}
+
+/* Error */
+.highlight .k {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Keyword */
+.highlight .o {
+  color: #666666
+}
+
+/* Operator */
+.highlight .ch {
+  color: #408090;
+  font-style: italic
+}
+
+/* Comment.Hashbang */
+.highlight .cm {
+  color: #408090;
+  font-style: italic
+}
+
+/* Comment.Multiline */
+.highlight .cp {
+  color: #007020
+}
+
+/* Comment.Preproc */
+.highlight .cpf {
+  color: #408090;
+  font-style: italic
+}
+
+/* Comment.PreprocFile */
+.highlight .c1 {
+  color: #408090;
+  font-style: italic
+}
+
+/* Comment.Single */
+.highlight .cs {
+  color: #408090;
+  background-color: #fff0f0
+}
+
+/* Comment.Special */
+.highlight .gd {
+  color: #A00000
+}
+
+/* Generic.Deleted */
+.highlight .ge {
+  font-style: italic
+}
+
+/* Generic.Emph */
+.highlight .gr {
+  color: #FF0000
+}
+
+/* Generic.Error */
+.highlight .gh {
+  color: #000080;
+  font-weight: bold
+}
+
+/* Generic.Heading */
+.highlight .gi {
+  color: #00A000
+}
+
+/* Generic.Inserted */
+.highlight .go {
+  color: #333333
+}
+
+/* Generic.Output */
+.highlight .gp {
+  color: #c65d09;
+  font-weight: bold
+}
+
+/* Generic.Prompt */
+.highlight .gs {
+  font-weight: bold
+}
+
+/* Generic.Strong */
+.highlight .gu {
+  color: #800080;
+  font-weight: bold
+}
+
+/* Generic.Subheading */
+.highlight .gt {
+  color: #0044DD
+}
+
+/* Generic.Traceback */
+.highlight .kc {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Keyword.Constant */
+.highlight .kd {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Keyword.Declaration */
+.highlight .kn {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Keyword.Namespace */
+.highlight .kp {
+  color: #007020
+}
+
+/* Keyword.Pseudo */
+.highlight .kr {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Keyword.Reserved */
+.highlight .kt {
+  color: #902000
+}
+
+/* Keyword.Type */
+.highlight .m {
+  color: #208050
+}
+
+/* Literal.Number */
+.highlight .s {
+  color: #4070a0
+}
+
+/* Literal.String */
+.highlight .na {
+  color: #4070a0
+}
+
+/* Name.Attribute */
+.highlight .nb {
+  color: #007020
+}
+
+/* Name.Builtin */
+.highlight .nc {
+  color: #0e84b5;
+  font-weight: bold
+}
+
+/* Name.Class */
+.highlight .no {
+  color: #60add5
+}
+
+/* Name.Constant */
+.highlight .nd {
+  color: #555555;
+  font-weight: bold
+}
+
+/* Name.Decorator */
+.highlight .ni {
+  color: #d55537;
+  font-weight: bold
+}
+
+/* Name.Entity */
+.highlight .ne {
+  color: #007020
+}
+
+/* Name.Exception */
+.highlight .nf {
+  color: #06287e
+}
+
+/* Name.Function */
+.highlight .nl {
+  color: #002070;
+  font-weight: bold
+}
+
+/* Name.Label */
+.highlight .nn {
+  color: #0e84b5;
+  font-weight: bold
+}
+
+/* Name.Namespace */
+.highlight .nt {
+  color: #062873;
+  font-weight: bold
+}
+
+/* Name.Tag */
+.highlight .nv {
+  color: #bb60d5
+}
+
+/* Name.Variable */
+.highlight .ow {
+  color: #007020;
+  font-weight: bold
+}
+
+/* Operator.Word */
+.highlight .w {
+  color: #bbbbbb
+}
+
+/* Text.Whitespace */
+.highlight .mb {
+  color: #208050
+}
+
+/* Literal.Number.Bin */
+.highlight .mf {
+  color: #208050
+}
+
+/* Literal.Number.Float */
+.highlight .mh {
+  color: #208050
+}
+
+/* Literal.Number.Hex */
+.highlight .mi {
+  color: #208050
+}
+
+/* Literal.Number.Integer */
+.highlight .mo {
+  color: #208050
+}
+
+/* Literal.Number.Oct */
+.highlight .sa {
+  color: #4070a0
+}
+
+/* Literal.String.Affix */
+.highlight .sb {
+  color: #4070a0
+}
+
+/* Literal.String.Backtick */
+.highlight .sc {
+  color: #4070a0
+}
+
+/* Literal.String.Char */
+.highlight .dl {
+  color: #4070a0
+}
+
+/* Literal.String.Delimiter */
+.highlight .sd {
+  color: #4070a0;
+  font-style: italic
+}
+
+/* Literal.String.Doc */
+.highlight .s2 {
+  color: #4070a0
+}
+
+/* Literal.String.Double */
+.highlight .se {
+  color: #4070a0;
+  font-weight: bold
+}
+
+/* Literal.String.Escape */
+.highlight .sh {
+  color: #4070a0
+}
+
+/* Literal.String.Heredoc */
+.highlight .si {
+  color: #70a0d0;
+  font-style: italic
+}
+
+/* Literal.String.Interpol */
+.highlight .sx {
+  color: #c65d09
+}
+
+/* Literal.String.Other */
+.highlight .sr {
+  color: #235388
+}
+
+/* Literal.String.Regex */
+.highlight .s1 {
+  color: #4070a0
+}
+
+/* Literal.String.Single */
+.highlight .ss {
+  color: #517918
+}
+
+/* Literal.String.Symbol */
+.highlight .bp {
+  color: #007020
+}
+
+/* Name.Builtin.Pseudo */
+.highlight .fm {
+  color: #06287e
+}
+
+/* Name.Function.Magic */
+.highlight .vc {
+  color: #bb60d5
+}
+
+/* Name.Variable.Class */
+.highlight .vg {
+  color: #bb60d5
+}
+
+/* Name.Variable.Global */
+.highlight .vi {
+  color: #bb60d5
+}
+
+/* Name.Variable.Instance */
+.highlight .vm {
+  color: #bb60d5
+}
+
+/* Name.Variable.Magic */
+.highlight .il {
+  color: #208050
+}
+
+/* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/compiler/docs/_static/css/toggle.css b/compiler/docs/_static/css/toggle.css
index add134f6..6f03e6fb 100644
--- a/compiler/docs/_static/css/toggle.css
+++ b/compiler/docs/_static/css/toggle.css
@@ -9,6 +9,13 @@ input[type=checkbox] {
     padding: 10px;
     display: flex;
     justify-content: space-between;
+    background-color: var(--color-f);
+    border-top: 1px solid var(--color-c);
+}
+
+.fa-caret-down,
+.fa-book {
+    color: var(--color-a) !important;
 }
 
 .rst-versions .rst-current-version .fa-book,
@@ -76,8 +83,6 @@ html.transition *:after {
     transition-delay: 0 !important;
 }
 
-nav.wy-nav-side {
-    /* The default padding of 2em is too small and the "Keyword Index" link gets obscured
-     * by the version toggle. */
-    padding-bottom: 3em;
-}
+.wy-menu-vertical a:hover {
+    background-color: #0002;
+}
\ No newline at end of file
diff --git a/compiler/docs/_static/img/favicon.ico b/compiler/docs/_static/img/favicon.ico
new file mode 100644
index 00000000..a2b8f877
Binary files /dev/null and b/compiler/docs/_static/img/favicon.ico differ
diff --git a/compiler/docs/_static/img/favicon.png b/compiler/docs/_static/img/favicon.png
new file mode 100644
index 00000000..3991d87e
Binary files /dev/null and b/compiler/docs/_static/img/favicon.png differ
diff --git a/compiler/docs/_static/img/hamburger-dark.svg b/compiler/docs/_static/img/hamburger-dark.svg
new file mode 100644
index 00000000..26d9fed9
--- /dev/null
+++ b/compiler/docs/_static/img/hamburger-dark.svg
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="#E6E3EC" xmlns="http://www.w3.org/2000/svg" focusable="false" class="color-toggle-icon" aria-hidden="true">
+<path d="M 3 5 A 1.0001 1.0001 0 1 0 3 7 L 21 7 A 1.0001 1.0001 0 1 0 21 5 L 3 5 z M 3 11 A 1.0001 1.0001 0 1 0 3 13 L 21 13 A 1.0001 1.0001 0 1 0 21 11 L 3 11 z M 3 17 A 1.0001 1.0001 0 1 0 3 19 L 21 19 A 1.0001 1.0001 0 1 0 21 17 L 3 17 z" />
+</svg>
\ No newline at end of file
diff --git a/compiler/docs/_static/img/hamburger-light.svg b/compiler/docs/_static/img/hamburger-light.svg
new file mode 100644
index 00000000..d5d0d0ae
--- /dev/null
+++ b/compiler/docs/_static/img/hamburger-light.svg
@@ -0,0 +1,3 @@
+<svg width="24px" height="24px" fill="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" focusable="false" class="color-toggle-icon" aria-hidden="true">
+<path fill="#2B247C" d="M 3 5 A 1.0001 1.0001 0 1 0 3 7 L 21 7 A 1.0001 1.0001 0 1 0 21 5 L 3 5 z M 3 11 A 1.0001 1.0001 0 1 0 3 13 L 21 13 A 1.0001 1.0001 0 1 0 21 11 L 3 11 z M 3 17 A 1.0001 1.0001 0 1 0 3 19 L 21 19 A 1.0001 1.0001 0 1 0 21 17 L 3 17 z" />
+</svg>
\ No newline at end of file
diff --git a/compiler/docs/_static/img/logo-dark.svg b/compiler/docs/_static/img/logo-dark.svg
new file mode 100644
index 00000000..92a12a9f
--- /dev/null
+++ b/compiler/docs/_static/img/logo-dark.svg
@@ -0,0 +1,8 @@
+<svg width="100" height="160" viewBox="0 0 100 160" fill="#E6E3EC" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.8" d="M50 44.3013L25 1L0 44.3013L25 87.6025L50 44.3013Z" />
+<path opacity="0.45" d="M50 44.3091L75 1.00781L25 1.00781L0 44.3091H50Z" />
+<path opacity="0.6" d="M75 1.00781L25 1.00781L50 44.3091H100L75 1.00781Z" />
+<path opacity="0.8" d="M50 115.699L75 159L100 115.699L75 72.3975L50 115.699Z" />
+<path opacity="0.45" d="M50 115.691L25 158.993H75L100 115.691L50 115.691Z" />
+<path opacity="0.6" d="M25 158.993H75L50 115.691L0 115.691L25 158.993Z" />
+</svg>
diff --git a/compiler/docs/_static/img/logo.svg b/compiler/docs/_static/img/logo.svg
new file mode 100644
index 00000000..19391843
--- /dev/null
+++ b/compiler/docs/_static/img/logo.svg
@@ -0,0 +1,8 @@
+<svg width="100" height="160" viewBox="0 0 100 160" fill="#2B247C" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.8" d="M50 44.3013L25 1L0 44.3013L25 87.6025L50 44.3013Z" />
+<path opacity="0.45" d="M50 44.3091L75 1.00781L25 1.00781L0 44.3091H50Z" />
+<path opacity="0.6" d="M75 1.00781L25 1.00781L50 44.3091H100L75 1.00781Z" />
+<path opacity="0.8" d="M50 115.699L75 159L100 115.699L75 72.3975L50 115.699Z" />
+<path opacity="0.45" d="M50 115.691L25 158.993H75L100 115.691L50 115.691Z" />
+<path opacity="0.6" d="M25 158.993H75L50 115.691L0 115.691L25 158.993Z" />
+</svg>
diff --git a/compiler/docs/_static/img/moon.svg b/compiler/docs/_static/img/moon.svg
new file mode 100644
index 00000000..607dc1b4
--- /dev/null
+++ b/compiler/docs/_static/img/moon.svg
@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="#2B247C" xmlns="http://www.w3.org/2000/svg" focusable="false" class="color-toggle-icon" aria-hidden="true">
+<path d="M21.4,13.7C20.6,13.9,19.8,14,19,14c-5,0-9-4-9-9c0-0.8,0.1-1.6,0.3-2.4c0.1-0.3,0-0.7-0.3-1 c-0.3-0.3-0.6-0.4-1-0.3C4.3,2.7,1,7.1,1,12c0,6.1,4.9,11,11,11c4.9,0,9.3-3.3,10.6-8.1c0.1-0.3,0-0.7-0.3-1 C22.1,13.7,21.7,13.6,21.4,13.7z" />
+</svg>
\ No newline at end of file
diff --git a/compiler/docs/_static/img/sun.svg b/compiler/docs/_static/img/sun.svg
new file mode 100644
index 00000000..f86fd22b
--- /dev/null
+++ b/compiler/docs/_static/img/sun.svg
@@ -0,0 +1,13 @@
+<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" focusable="false" class="color-toggle-icon" aria-hidden="true">
+  <g stroke-linejoin="round" stroke-linecap="round" stroke-width="2" fill="none" stroke="#E6E3EC">
+    <circle cx="12" cy="12" r="5" />
+    <path d="M12 1v2" />
+    <path d="M12 21v2" />
+    <path d="M4.22 4.22l1.42 1.42" />
+    <path d="M18.36 18.36l1.42 1.42" />
+    <path d="M1 12h2" />
+    <path d="M21 12h2" />
+    <path d="M4.22 19.78l1.42-1.42" />
+    <path d="M18.36 5.64l1.42-1.42" />
+  </g>
+</svg>
\ No newline at end of file
diff --git a/compiler/docs/_static/js/constants.js b/compiler/docs/_static/js/constants.js
new file mode 100644
index 00000000..67fa16cd
--- /dev/null
+++ b/compiler/docs/_static/js/constants.js
@@ -0,0 +1,38 @@
+// Site URL
+const SITE_URL = "https://docs.soliditylang.org"
+const { origin, pathname } = location;
+const pathSplit = pathname.split("/");
+const rootPath = origin.includes(SITE_URL) && pathSplit.length > 3 ? pathSplit.splice(1, 2).join("/") : ''
+const ROOT_URL = `${origin}/${rootPath}`;
+
+// Color mode constants
+const [DARK, LIGHT] = ["dark", "light"];
+const LIGHT_LOGO_PATH = `${ROOT_URL}/_static/img/logo.svg`;
+const DARK_LOGO_PATH = `${ROOT_URL}/_static/img/logo-dark.svg`;
+const SUN_ICON_PATH = `${ROOT_URL}/_static/img/sun.svg`;
+const MOON_ICON_PATH = `${ROOT_URL}/_static/img/moon.svg`;
+const LIGHT_HAMBURGER_PATH = `${ROOT_URL}/_static/img/hamburger-light.svg`;
+const DARK_HAMBURGER_PATH = `${ROOT_URL}/_static/img/hamburger-dark.svg`;
+const COLOR_TOGGLE_ICON_CLASS = "color-toggle-icon";
+const SOLIDITY_LOGO_CLASS = "solidity-logo";
+const LS_COLOR_SCHEME = "color-scheme";
+
+// Solidity navigation constants
+const SOLIDITY_HOME_URL = "https://soliditylang.org";
+const BLOG_URL = `${SOLIDITY_HOME_URL}/blog`;
+const DOCS_URL = "/";
+const USE_CASES_PATH = `${SOLIDITY_HOME_URL}/use-cases`;
+const CONTRIBUTE_PATH = `/en/latest/contributing.html`;
+const ABOUT_PATH = `${SOLIDITY_HOME_URL}/about`;
+const FORUM_URL = "https://forum.soliditylang.org/";
+const NAV_LINKS = [
+  { name: "Blog", href: BLOG_URL },
+  { name: "Documentation", href: DOCS_URL },
+  { name: "Use cases", href: USE_CASES_PATH },
+  { name: "Contribute", href: CONTRIBUTE_PATH },
+  { name: "About", href: ABOUT_PATH },
+  { name: "Forum", href: FORUM_URL },
+];
+
+const MOBILE_MENU_TOGGLE_CLASS = "shift";
+const WRAPPER_CLASS = "unified-wrapper";
diff --git a/compiler/docs/_static/js/initialize.js b/compiler/docs/_static/js/initialize.js
new file mode 100644
index 00000000..a20d4fce
--- /dev/null
+++ b/compiler/docs/_static/js/initialize.js
@@ -0,0 +1,250 @@
+const getLogoSrc = (isDark) => (isDark ? DARK_LOGO_PATH : LIGHT_LOGO_PATH);
+
+const getModeIconSrc = (isDark) => (isDark ? SUN_ICON_PATH : MOON_ICON_PATH);
+
+const getMenuIconSrc = (isDark) =>
+  isDark ? DARK_HAMBURGER_PATH : LIGHT_HAMBURGER_PATH;
+
+function addFooterNote() {
+  const contentInfo = document.querySelector("div[role=contentinfo]");
+  const footerNote = document.createElement("p");
+  footerNote.classList.add("footer-note");
+  footerNote.innerHTML =
+    'Customized with ❤️ by the <a href="https://ethereum.org/" target="_blank">ethereum.org</a> team.';
+  contentInfo.parentNode.insertBefore(footerNote, contentInfo.nextSibling);
+}
+
+function rearrangeDom() {
+  const bodyDivs = document.querySelectorAll("body>div");
+  bodyDivs.forEach((div) => div.remove());
+  const wrapperDiv = document.createElement("div");
+  wrapperDiv.classList.add(WRAPPER_CLASS);
+  bodyDivs.forEach((div) => wrapperDiv.appendChild(div));
+  document.body.prepend(wrapperDiv);
+
+  const rstVersions = document.querySelector(".rst-versions");
+  rstVersions.remove();
+  const wyNavSide = document.querySelector("nav.wy-nav-side");
+  wyNavSide.appendChild(rstVersions);
+  const backdrop = document.createElement("div");
+  backdrop.classList.add("backdrop");
+  wrapperDiv.appendChild(backdrop);
+
+  const content = document.querySelector(".wy-nav-content");
+  content.id = "content";
+  const oldWrap = document.querySelector("section.wy-nav-content-wrap");
+  oldWrap.remove();
+  document.querySelector(".wy-grid-for-nav").appendChild(content);
+}
+
+function buildHeader() {
+  const isDarkMode = localStorage.getItem(LS_COLOR_SCHEME) == DARK;
+
+  const header = document.createElement("div");
+  header.classList.add("unified-header");
+  document.querySelector(`.${WRAPPER_CLASS}`).prepend(header);
+
+  const innerHeader = document.createElement("div");
+  innerHeader.classList.add("inner-header");
+  header.appendChild(innerHeader);
+
+  const homeLink = document.createElement("a");
+  homeLink.classList.add("home-link");
+  homeLink.href = SOLIDITY_HOME_URL;
+  homeLink.ariaLabel = "Solidity home";
+  innerHeader.appendChild(homeLink);
+
+  const logo = document.createElement("img");
+  logo.classList.add(SOLIDITY_LOGO_CLASS);
+  logo.src = getLogoSrc(isDarkMode);
+  logo.alt = "Solidity logo";
+  homeLink.appendChild(logo);
+
+  const skipToContent = document.createElement("a");
+  skipToContent.classList.add("skip-to-content");
+  skipToContent.href = "#content";
+  skipToContent.innerText = "{skip to content}";
+  innerHeader.appendChild(skipToContent);
+
+  const navBar = document.createElement("nav");
+  navBar.classList.add("nav-bar");
+  innerHeader.appendChild(navBar);
+
+  const linkElements = NAV_LINKS.map(({ name, href }) => {
+    const link = document.createElement("a");
+    link.classList.add("nav-link");
+    link.setAttribute("key", name);
+    link.setAttribute("href", href);
+    link.setAttribute("aria-label", name);
+    if (href === FORUM_URL) {
+      link.classList.add("forum-link");
+      link.setAttribute("target", "_blank");
+      link.setAttribute("rel", "noopener noreferrer");
+    }
+    link.innerText = name;
+    return link;
+  });
+  linkElements.forEach((link) => navBar.appendChild(link));
+
+  // Flex wrapper for color mode and mobile menu buttons
+  const navButtonContainer = document.createElement("div");
+  navButtonContainer.classList.add("nav-button-container");
+  navBar.appendChild(navButtonContainer);
+
+  // Build color toggle
+  const toggleIcon = document.createElement("img");
+  toggleIcon.classList.add(COLOR_TOGGLE_ICON_CLASS);
+  toggleIcon.src = getModeIconSrc(isDarkMode);
+  toggleIcon.alt = "Color mode toggle icon";
+  toggleIcon.setAttribute("aria-hidden", "true");
+  toggleIcon.setAttribute("key", "toggle icon");
+  const colorModeButton = document.createElement("button");
+  colorModeButton.classList.add("color-toggle");
+  colorModeButton.setAttribute("type", "button");
+  colorModeButton.setAttribute("aria-label", "Toggle light dark mode");
+  colorModeButton.setAttribute("key", "color mode button");
+  colorModeButton.addEventListener("click", toggleColorMode);
+  colorModeButton.appendChild(toggleIcon);
+  navButtonContainer.appendChild(colorModeButton);
+
+  // Build mobile hamburger menu
+  const menuIcon = document.createElement("img");
+  menuIcon.classList.add(COLOR_TOGGLE_ICON_CLASS);
+  menuIcon.src = getMenuIconSrc(isDarkMode);
+  menuIcon.alt = "Toggle menu";
+  menuIcon.setAttribute("aria-hidden", "true");
+  menuIcon.setAttribute("key", "menu icon");
+  const menuButton = document.createElement("button");
+  menuButton.classList.add("color-toggle");
+  menuButton.classList.add("mobile-menu-button");
+  menuButton.setAttribute("type", "button");
+  menuButton.setAttribute("aria-label", "Toggle menu");
+  menuButton.setAttribute("key", "menu button");
+  menuButton.addEventListener("click", toggleMenu);
+  menuButton.appendChild(menuIcon);
+  navButtonContainer.appendChild(menuButton);
+}
+
+const updateActiveNavLink = () => {
+  const navLinks = document.querySelectorAll(".unified-header .nav-link");
+  navLinks.forEach((link) => {
+    const href = link.getAttribute("href");
+    if (document.documentURI.includes("contributing.html")) {
+      link.classList[href.includes("contributing.html") ? "add" : "remove"](
+        "active"
+      );
+    } else {
+      link.classList[document.documentURI.includes(href) ? "add" : "remove"](
+        "active"
+      );
+    }
+  });
+};
+
+document.addEventListener("locationchange", updateActiveNavLink);
+
+function updateGitHubEditPath() {
+  // Replaces the version number in the GitHub edit path with "develop"
+  const gitHubEditAnchor = document.querySelector(".wy-breadcrumbs-aside > a");
+  const url = new URL(gitHubEditAnchor.href);
+  const split = url.pathname.split("/");
+  const versionIndex = split.indexOf("blob") + 1;
+  split[versionIndex] = "develop";
+  url.pathname = split.join("/");
+  gitHubEditAnchor.setAttribute("href", url.toString());
+  gitHubEditAnchor.setAttribute("target", "_blank");
+  gitHubEditAnchor.setAttribute("rel", "noopener noreferrer");
+}
+
+function initialize() {
+  // Rearrange DOM elements for styling
+  rearrangeDom();
+
+  // Check localStorage for existing color scheme preference
+  var prefersDark = localStorage.getItem(LS_COLOR_SCHEME) == DARK;
+  // Check link for search param "color"... it may be "light" or "dark"
+  var urlParams = new URLSearchParams(window.location.search);
+  if (urlParams.size > 0) {
+    // This is used for color mode continuity between the main Solidity Lang site and the docs
+    var colorSchemeParam = urlParams.get("color");
+    // If present, overwrite prefersDark accordingly
+    if (colorSchemeParam) {
+      prefersDark = colorSchemeParam == DARK;
+    }
+
+    // Remove "color" search param from URL
+    const { location, title } = document;
+    const { pathname, origin, search, hash } = location;
+    const newSearchParams = new URLSearchParams(search);
+    newSearchParams.delete("color");
+    const sanitizedSearch =
+      newSearchParams.size < 1 ? "" : "?" + newSearchParams.toString();
+    window.history.replaceState(
+      origin,
+      title,
+      pathname + sanitizedSearch + hash
+    );
+  }
+
+  // In case none existed, establish localStorage color scheme preference
+  var mode = prefersDark ? DARK : LIGHT;
+  localStorage.setItem(LS_COLOR_SCHEME, mode);
+
+  // Select the root element and set the style attribute to denote color-scheme attribute
+  document
+    .querySelector(":root")
+    .setAttribute("style", `--color-scheme: ${mode}`);
+
+  // Remove old input and RTD logo anchor element
+  document.querySelector("input[name=mode]").remove();
+  document.querySelector("label[for=switch]").remove();
+  document.querySelector(".wy-side-nav-search > a").remove();
+
+  // Add footer note
+  addFooterNote();
+
+  // Build header
+  buildHeader();
+
+  // Close menu
+  toggleMenu({ force: false });
+
+  // Update active nav link
+  updateActiveNavLink();
+
+  // Update GitHub edit path to direct to `develop` branch
+  updateGitHubEditPath();
+}
+
+document.addEventListener("DOMContentLoaded", initialize);
+
+const handleClick = (e) => {
+  if (e.target.closest(".backdrop")) {
+    toggleMenu({ force: false });
+  }
+
+  if (e.target.closest("a")) {
+    const target = e.target.closest("a");
+    const href = target.getAttribute("href");
+    if (href.includes(SOLIDITY_HOME_URL)) {
+      const url = new URL(href);
+      const params = new URLSearchParams(url.search);
+      params.set("color", localStorage.getItem(LS_COLOR_SCHEME));
+      url.search = params.toString();
+      target.setAttribute("href", url.toString());
+    }
+  }
+};
+document.addEventListener("click", handleClick);
+
+const handleKeyDown = (e) => {
+  if (e.metaKey && e.key === "k") {
+    document.querySelector("#rtd-search-form input").focus();
+  } else if (e.key === "Escape") {
+    toggleMenu({ force: false });
+  }
+  if (e.metaKey && e.code === "Backslash") {
+    toggleColorMode();
+  }
+};
+document.addEventListener("keydown", handleKeyDown);
diff --git a/compiler/docs/_static/js/toggle.js b/compiler/docs/_static/js/toggle.js
index 780ea9ee..6ea2dd1f 100644
--- a/compiler/docs/_static/js/toggle.js
+++ b/compiler/docs/_static/js/toggle.js
@@ -1,39 +1,47 @@
-document.addEventListener('DOMContentLoaded', function() {
+function toggleColorMode() {
+  // Check localStorage for previous color scheme preference, assign the opposite
+  var newMode = localStorage.getItem(LS_COLOR_SCHEME) == DARK ? LIGHT : DARK;
 
-    function toggleCssMode(isDay) {
-        var mode = (isDay ? "Day" : "Night");
-        localStorage.setItem("css-mode", mode);
+  // Update localStorage with new color scheme preference
+  localStorage.setItem(LS_COLOR_SCHEME, newMode);
 
-        var url_root = DOCUMENTATION_OPTIONS.URL_ROOT == "./" ? "" : DOCUMENTATION_OPTIONS.URL_ROOT;
-        var daysheet = $(`link[href="${url_root}_static/pygments.css"]`)[0].sheet;
-        daysheet.disabled = !isDay;
+  // Update the root element with the new color scheme preference
+  document
+    .querySelector(":root")
+    .setAttribute("style", `--color-scheme: ${newMode}`);
 
-        var nightsheet = $(`link[href="${url_root}_static/css/dark.css"]`)[0];
-        if (!isDay && nightsheet === undefined) {
-            var element = document.createElement("link");
-            element.setAttribute("rel", "stylesheet");
-            element.setAttribute("type", "text/css");
-            element.setAttribute("href", `${url_root}_static/css/dark.css`);
-            document.getElementsByTagName("head")[0].appendChild(element);
-            return;
-        }
-        if (nightsheet !== undefined) {
-            nightsheet.sheet.disabled = isDay;
-        }
-    }
-
-    var initial = localStorage.getItem("css-mode") != "Night";
-    var checkbox = document.querySelector('input[name=mode]');
+  // Update logo
+  document
+    .querySelector(`img.${SOLIDITY_LOGO_CLASS}`)
+    .setAttribute("src", newMode === LIGHT ? LIGHT_LOGO_PATH : DARK_LOGO_PATH);
 
-    toggleCssMode(initial);
-    checkbox.checked = initial;
+  // Update color mode toggle icon
+  document
+    .querySelector(`img.${COLOR_TOGGLE_ICON_CLASS}`)
+    .setAttribute("src", newMode === LIGHT ? MOON_ICON_PATH : SUN_ICON_PATH);
 
-    checkbox.addEventListener('change', function() {
-        document.documentElement.classList.add('transition');
-        window.setTimeout(() => {
-            document.documentElement.classList.remove('transition');
-        }, 1000)
-        toggleCssMode(this.checked);
-    })
+  // Update hamburger menu icon color
+  document
+    .querySelector("button.mobile-menu-button img")
+    .setAttribute(
+      "src",
+      newMode === LIGHT ? LIGHT_HAMBURGER_PATH : DARK_HAMBURGER_PATH
+    );
+}
 
-});
\ No newline at end of file
+function toggleMenu(options = {}) {
+  const handleClassToggle = ({ classList }, className) => {
+    if (typeof options.force !== "undefined") {
+      classList.toggle(className, options.force);
+    } else {
+      classList.toggle(className);
+    }
+  };
+  document
+    .querySelectorAll('[data-toggle="rst-versions"]')
+    .forEach((e) => handleClassToggle(e, MOBILE_MENU_TOGGLE_CLASS));
+  document
+    .querySelectorAll('[data-toggle="wy-nav-shift"]')
+    .forEach((e) => handleClassToggle(e, MOBILE_MENU_TOGGLE_CLASS));
+  handleClassToggle(document.querySelector(`.${WRAPPER_CLASS}`), "menu-open");
+}
diff --git a/compiler/docs/abi-spec.rst b/compiler/docs/abi-spec.rst
index 9164ae6a..0d48b51d 100644
--- a/compiler/docs/abi-spec.rst
+++ b/compiler/docs/abi-spec.rst
@@ -191,9 +191,9 @@ on the type of ``X`` being
 
 - ``T[]`` where ``X`` has ``k`` elements (``k`` is assumed to be of type ``uint256``):
 
-  ``enc(X) = enc(k) enc([X[0], ..., X[k-1]])``
+  ``enc(X) = enc(k) enc((X[0], ..., X[k-1]))``
 
-  i.e. it is encoded as if it were an array of static size ``k``, prefixed with
+  i.e. it is encoded as if it were a tuple with ``k`` elements of the same type (resp. an array of static size ``k``), prefixed with
   the number of elements.
 
 - ``bytes``, of length ``k`` (which is assumed to be of type ``uint256``):
@@ -252,7 +252,21 @@ Given the contract:
     }
 
 
-Thus, for our ``Foo`` example if we wanted to call ``baz`` with the parameters ``69`` and
+Thus, for our ``Foo`` example, if we wanted to call ``bar`` with the argument ``["abc", "def"]``, we would pass 68 bytes total, broken down into:
+
+- ``0xfce353f6``: the Method ID. This is derived from the signature ``bar(bytes3[2])``.
+- ``0x6162630000000000000000000000000000000000000000000000000000000000``: the first part of the first
+  parameter, a ``bytes3`` value ``"abc"`` (left-aligned).
+- ``0x6465660000000000000000000000000000000000000000000000000000000000``: the second part of the first
+  parameter, a ``bytes3`` value ``"def"`` (left-aligned).
+
+In total:
+
+.. code-block:: none
+
+    0xfce353f661626300000000000000000000000000000000000000000000000000000000006465660000000000000000000000000000000000000000000000000000000000
+
+If we wanted to call ``baz`` with the parameters ``69`` and
 ``true``, we would pass 68 bytes total, which can be broken down into:
 
 - ``0xcdcd77c0``: the Method ID. This is derived as the first 4 bytes of the Keccak hash of
@@ -271,20 +285,6 @@ In total:
 It returns a single ``bool``. If, for example, it were to return ``false``, its output would be
 the single byte array ``0x0000000000000000000000000000000000000000000000000000000000000000``, a single bool.
 
-If we wanted to call ``bar`` with the argument ``["abc", "def"]``, we would pass 68 bytes total, broken down into:
-
-- ``0xfce353f6``: the Method ID. This is derived from the signature ``bar(bytes3[2])``.
-- ``0x6162630000000000000000000000000000000000000000000000000000000000``: the first part of the first
-  parameter, a ``bytes3`` value ``"abc"`` (left-aligned).
-- ``0x6465660000000000000000000000000000000000000000000000000000000000``: the second part of the first
-  parameter, a ``bytes3`` value ``"def"`` (left-aligned).
-
-In total:
-
-.. code-block:: none
-
-    0xfce353f661626300000000000000000000000000000000000000000000000000000000006465660000000000000000000000000000000000000000000000000000000000
-
 If we wanted to call ``sam`` with the arguments ``"dave"``, ``true`` and ``[1,2,3]``, we would
 pass 292 bytes total, broken down into:
 
@@ -311,7 +311,7 @@ Use of Dynamic Types
 A call to a function with the signature ``f(uint256,uint32[],bytes10,bytes)`` with values
 ``(0x123, [0x456, 0x789], "1234567890", "Hello, world!")`` is encoded in the following way:
 
-We take the first four bytes of ``sha3("f(uint256,uint32[],bytes10,bytes)")``, i.e. ``0x8be65246``.
+We take the first four bytes of ``keccak("f(uint256,uint32[],bytes10,bytes)")``, i.e. ``0x8be65246``.
 Then we encode the head parts of all four arguments. For the static types ``uint256`` and ``bytes10``,
 these are directly the values we want to pass, whereas for the dynamic types ``uint32[]`` and ``bytes``,
 we use the offset in bytes to the start of their data area, measured from the start of the value
@@ -563,7 +563,7 @@ A function description is a JSON object with the fields:
   blockchain state <pure-functions>`), ``view`` (:ref:`specified to not modify the blockchain
   state <view-functions>`), ``nonpayable`` (function does not accept Ether - the default) and ``payable`` (function accepts Ether).
 
-Constructor and fallback function never have ``name`` or ``outputs``. Fallback function doesn't have ``inputs`` either.
+Constructor, receive, and fallback never have ``name`` or ``outputs``. Receive and fallback do not have ``inputs`` either.
 
 .. note::
     Sending non-zero Ether to non-payable function will revert the transaction.
@@ -581,7 +581,7 @@ An event description is a JSON object with fairly similar fields:
   * ``name``: the name of the parameter.
   * ``type``: the canonical type of the parameter (more below).
   * ``components``: used for tuple types (more below).
-  * ``indexed``: ``true`` if the field is part of the log's topics, ``false`` if it one of the log's data segment.
+  * ``indexed``: ``true`` if the field is part of the log's topics, ``false`` if it is one of the log's data segments.
 
 - ``anonymous``: ``true`` if the event was declared as ``anonymous``.
 
diff --git a/compiler/docs/analysing-compilation-output.rst b/compiler/docs/analysing-compilation-output.rst
index 892b18b9..183f7732 100644
--- a/compiler/docs/analysing-compilation-output.rst
+++ b/compiler/docs/analysing-compilation-output.rst
@@ -11,7 +11,7 @@ visual diff of the assembly before and after a change is often very enlightening
 
 Consider the following contract (named, say ``contract.sol``):
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.5.0 <0.9.0;
diff --git a/compiler/docs/assembly.rst b/compiler/docs/assembly.rst
index b527ffba..e08ff9f6 100644
--- a/compiler/docs/assembly.rst
+++ b/compiler/docs/assembly.rst
@@ -362,7 +362,7 @@ in memory is automatically considered memory-safe and does not need to be annota
 .. warning::
     It is your responsibility to make sure that the assembly actually satisfies the memory model. If you annotate
     an assembly block as memory-safe, but violate one of the memory assumptions, this **will** lead to incorrect and
-    undefined behaviour that cannot easily be discovered by testing.
+    undefined behavior that cannot easily be discovered by testing.
 
 In case you are developing a library that is meant to be compatible across multiple versions
 of Solidity, you can use a special comment to annotate an assembly block as memory-safe:
@@ -375,4 +375,4 @@ of Solidity, you can use a special comment to annotate an assembly block as memo
     }
 
 Note that we will disallow the annotation via comment in a future breaking release; so, if you are not concerned with
-backwards-compatibility with older compiler versions, prefer using the dialect string.
+backward-compatibility with older compiler versions, prefer using the dialect string.
diff --git a/compiler/docs/brand-guide.rst b/compiler/docs/brand-guide.rst
index 5601b16a..cf471c5e 100644
--- a/compiler/docs/brand-guide.rst
+++ b/compiler/docs/brand-guide.rst
@@ -67,7 +67,7 @@ When using the Solidity logo, please respect the Solidity logo guidelines.
 Solidity Logo Guidelines
 ========================
 
-.. image:: logo.svg
+.. image:: solidity_logo.svg
   :width: 256
 
 *(Right click on the logo to download it.)*
diff --git a/compiler/docs/bugs.json b/compiler/docs/bugs.json
index 03dafbe4..c853f95e 100644
--- a/compiler/docs/bugs.json
+++ b/compiler/docs/bugs.json
@@ -1,4 +1,40 @@
 [
+    {
+        "uid": "SOL-2023-3",
+        "name": "VerbatimInvalidDeduplication",
+        "summary": "All ``verbatim`` blocks are considered identical by deduplicator and can incorrectly be unified when surrounded by identical opcodes.",
+        "description": "The block deduplicator is a step of the opcode-based optimizer which identifies equivalent assembly blocks and merges them into a single one. However, when blocks contained ``verbatim``, their comparison was performed incorrectly, leading to the collapse of assembly blocks which are identical except for the contents of the ``verbatim`` items. Since ``verbatim`` is only available in Yul, compilation of Solidity sources is not affected.",
+        "link": "https://blog.soliditylang.org/2023/11/08/verbatim-invalid-deduplication-bug/",
+        "introduced": "0.8.5",
+        "fixed": "0.8.23",
+        "severity": "low"
+    },
+    {
+        "uid": "SOL-2023-2",
+        "name": "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+        "summary": "Optimizer sequences containing FullInliner do not preserve the evaluation order of arguments of inlined function calls in code that is not in expression-split form.",
+        "description": "Function call arguments in Yul are evaluated right to left. This order matters when the argument expressions have side-effects, and changing it may change contract behavior. FullInliner is an optimizer step that can replace a function call with the body of that function. The transformation involves assigning argument expressions to temporary variables, which imposes an explicit evaluation order. FullInliner was written with the assumption that this order does not necessarily have to match usual argument evaluation order because the argument expressions have no side-effects. In most circumstances this assumption is true because the default optimization step sequence contains the ExpressionSplitter step. ExpressionSplitter ensures that the code is in *expression-split form*, which means that function calls cannot appear nested inside expressions, and all function call arguments have to be variables. The assumption is, however, not guaranteed to be true in general. Version 0.6.7 introduced a setting allowing users to specify an arbitrary optimization step sequence, making it possible for the FullInliner to actually encounter argument expressions with side-effects, which can result in behavior differences between optimized and unoptimized bytecode. Contracts compiled without optimization or with the default optimization sequence are not affected. To trigger the bug the user has to explicitly choose compiler settings that contain a sequence with FullInliner step not preceded by ExpressionSplitter.",
+        "link": "https://blog.soliditylang.org/2023/07/19/full-inliner-non-expression-split-argument-evaluation-order-bug/",
+        "introduced": "0.6.7",
+        "fixed": "0.8.21",
+        "severity": "low",
+        "conditions": {
+            "yulOptimizer": true
+        }
+    },
+    {
+        "uid": "SOL-2023-1",
+        "name": "MissingSideEffectsOnSelectorAccess",
+        "summary": "Accessing the ``.selector`` member on complex expressions leaves the expression unevaluated in the legacy code generation.",
+        "description": "When accessing the ``.selector`` member on an expression with side-effects, like an assignment, a function call or a conditional, the expression would not be evaluated in the legacy code generation. This would happen in expressions where the functions used in the expression were all known at compilation time, regardless of whether the whole expression could be evaluated at compilation time or not. Note that the code generated by the IR pipeline was unaffected and would behave as expected.",
+        "link": "https://blog.soliditylang.org/2023/07/19/missing-side-effects-on-selector-access-bug/",
+        "introduced": "0.6.2",
+        "fixed": "0.8.21",
+        "severity": "low",
+        "conditions": {
+            "viaIR": false
+        }
+    },
     {
         "uid": "SOL-2022-7",
         "name": "StorageWriteRemovalBeforeConditionalTermination",
@@ -60,7 +96,7 @@
     },
     {
         "uid": "SOL-2022-2",
-        "name": "NestedCallataArrayAbiReencodingSizeValidation",
+        "name": "NestedCalldataArrayAbiReencodingSizeValidation",
         "summary": "ABI-reencoding of nested dynamic calldata arrays did not always perform proper size checks against the size of calldata and could read beyond ``calldatasize()``.",
         "description": "Calldata validation for nested dynamic types is deferred until the first access to the nested values. Such an access may for example be a copy to memory or an index or member access to the outer type. While in most such accesses calldata validation correctly checks that the data area of the nested array is completely contained in the passed calldata (i.e. in the range [0, calldatasize()]), this check may not be performed, when ABI encoding such nested types again directly from calldata. For instance, this can happen, if a value in calldata with a nested dynamic array is passed to an external call, used in ``abi.encode`` or emitted as event. In such cases, if the data area of the nested array extends beyond ``calldatasize()``, ABI encoding it did not revert, but continued reading values from beyond ``calldatasize()`` (i.e. zero values).",
         "link": "https://blog.soliditylang.org/2022/05/17/calldata-reencode-size-check-bug/",
diff --git a/compiler/docs/bugs.rst b/compiler/docs/bugs.rst
index 75a23e49..350b1e7a 100644
--- a/compiler/docs/bugs.rst
+++ b/compiler/docs/bugs.rst
@@ -68,7 +68,7 @@ conditions
     If no conditions are given, assume that the bug is present.
 check
     This field contains different checks that report whether the smart contract
-    contains the bug or not. The first type of check are Javascript regular
+    contains the bug or not. The first type of check are JavaScript regular
     expressions that are to be matched against the source code ("source-regex")
     if the bug is present.  If there is no match, then the bug is very likely
     not present. If there is a match, the bug might be present.  For improved
diff --git a/compiler/docs/bugs_by_version.json b/compiler/docs/bugs_by_version.json
index 11ddd40b..156b846d 100644
--- a/compiler/docs/bugs_by_version.json
+++ b/compiler/docs/bugs_by_version.json
@@ -1085,7 +1085,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1103,7 +1103,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1120,7 +1120,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1137,7 +1137,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1154,7 +1154,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1173,7 +1173,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1191,7 +1191,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1208,7 +1208,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1348,7 +1348,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1369,7 +1369,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1389,7 +1389,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1407,7 +1407,7 @@
         "bugs": [
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1422,10 +1422,12 @@
     },
     "0.6.10": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1436,10 +1438,12 @@
     },
     "0.6.11": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1450,10 +1454,12 @@
     },
     "0.6.12": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1464,9 +1470,10 @@
     },
     "0.6.2": {
         "bugs": [
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1481,9 +1488,10 @@
     },
     "0.6.3": {
         "bugs": [
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1498,9 +1506,10 @@
     },
     "0.6.4": {
         "bugs": [
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
             "EmptyByteArrayCopy",
@@ -1515,9 +1524,10 @@
     },
     "0.6.5": {
         "bugs": [
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1532,9 +1542,10 @@
     },
     "0.6.6": {
         "bugs": [
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1548,9 +1559,11 @@
     },
     "0.6.7": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1564,9 +1577,11 @@
     },
     "0.6.8": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1577,10 +1592,12 @@
     },
     "0.6.9": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1592,10 +1609,12 @@
     },
     "0.7.0": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1606,10 +1625,12 @@
     },
     "0.7.1": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1621,10 +1642,12 @@
     },
     "0.7.2": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1635,10 +1658,12 @@
     },
     "0.7.3": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching",
@@ -1648,10 +1673,12 @@
     },
     "0.7.4": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
@@ -1660,10 +1687,12 @@
     },
     "0.7.5": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
@@ -1672,10 +1701,12 @@
     },
     "0.7.6": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
@@ -1684,10 +1715,12 @@
     },
     "0.8.0": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
@@ -1696,10 +1729,12 @@
     },
     "0.8.1": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
@@ -1708,46 +1743,61 @@
     },
     "0.8.10": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation"
+            "NestedCalldataArrayAbiReencodingSizeValidation"
         ],
         "released": "2021-11-09"
     },
     "0.8.11": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "AbiEncodeCallLiteralAsFixedBytesBug"
         ],
         "released": "2021-12-20"
     },
     "0.8.12": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "AbiEncodeCallLiteralAsFixedBytesBug"
         ],
         "released": "2022-02-16"
     },
     "0.8.13": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "StorageWriteRemovalBeforeConditionalTermination",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "InlineAssemblyMemorySideEffects",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation"
+            "NestedCalldataArrayAbiReencodingSizeValidation"
         ],
         "released": "2022-03-16"
     },
     "0.8.14": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "StorageWriteRemovalBeforeConditionalTermination",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
@@ -1757,6 +1807,9 @@
     },
     "0.8.15": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "StorageWriteRemovalBeforeConditionalTermination",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup"
         ],
@@ -1764,32 +1817,87 @@
     },
     "0.8.16": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "StorageWriteRemovalBeforeConditionalTermination"
         ],
         "released": "2022-08-08"
     },
     "0.8.17": {
-        "bugs": [],
+        "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess"
+        ],
         "released": "2022-09-08"
     },
+    "0.8.18": {
+        "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess"
+        ],
+        "released": "2023-02-01"
+    },
+    "0.8.19": {
+        "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess"
+        ],
+        "released": "2023-02-22"
+    },
     "0.8.2": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory",
             "KeccakCaching"
         ],
         "released": "2021-03-02"
     },
+    "0.8.20": {
+        "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess"
+        ],
+        "released": "2023-05-10"
+    },
+    "0.8.21": {
+        "bugs": [
+            "VerbatimInvalidDeduplication"
+        ],
+        "released": "2023-07-19"
+    },
+    "0.8.22": {
+        "bugs": [
+            "VerbatimInvalidDeduplication"
+        ],
+        "released": "2023-10-25"
+    },
+    "0.8.23": {
+        "bugs": [],
+        "released": "2023-11-08"
+    },
+    "0.8.24": {
+        "bugs": [],
+        "released": "2024-01-25"
+    },
     "0.8.3": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables",
             "ABIDecodeTwoDimensionalArrayMemory"
         ],
@@ -1797,50 +1905,64 @@
     },
     "0.8.4": {
         "bugs": [
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables"
         ],
         "released": "2021-04-21"
     },
     "0.8.5": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables"
         ],
         "released": "2021-06-10"
     },
     "0.8.6": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables"
         ],
         "released": "2021-06-22"
     },
     "0.8.7": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "SignedImmutables"
         ],
         "released": "2021-08-11"
     },
     "0.8.8": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation",
+            "NestedCalldataArrayAbiReencodingSizeValidation",
             "UserDefinedValueTypesBug",
             "SignedImmutables"
         ],
@@ -1848,10 +1970,13 @@
     },
     "0.8.9": {
         "bugs": [
+            "VerbatimInvalidDeduplication",
+            "FullInlinerNonExpressionSplitArgumentEvaluationOrder",
+            "MissingSideEffectsOnSelectorAccess",
             "AbiReencodingHeadOverflowWithStaticArrayCleanup",
             "DirtyBytesArrayToStorage",
             "DataLocationChangeInInternalOverride",
-            "NestedCallataArrayAbiReencodingSizeValidation"
+            "NestedCalldataArrayAbiReencodingSizeValidation"
         ],
         "released": "2021-09-29"
     }
diff --git a/compiler/docs/cheatsheet.rst b/compiler/docs/cheatsheet.rst
index 3a7d478b..2b68d731 100644
--- a/compiler/docs/cheatsheet.rst
+++ b/compiler/docs/cheatsheet.rst
@@ -2,16 +2,17 @@
 Cheatsheet
 **********
 
-.. index:: operator; precedence
+.. index:: operator;precedence
 
 Order of Precedence of Operators
 ================================
+
 .. include:: types/operator-precedence-table.rst
 
-.. index:: assert, block, coinbase, difficulty, number, block;number, timestamp, block;timestamp, msg, data, gas, sender, value, gas price, origin, revert, require, keccak256, ripemd160, sha256, ecrecover, addmod, mulmod, cryptography, this, super, selfdestruct, balance, codehash, send
+.. index:: abi;decode, abi;encode, abi;encodePacked, abi;encodeWithSelector, abi;encodeCall, abi;encodeWithSignature
 
-Global Variables
-================
+ABI Encoding and Decoding Functions
+===================================
 
 - ``abi.decode(bytes memory encodedData, (...)) returns (...)``: :ref:`ABI <ABI>`-decodes
   the provided data. The types are given in parentheses as second argument.
@@ -24,17 +25,55 @@ Global Variables
 - ``abi.encodeCall(function functionPointer, (...)) returns (bytes memory)``: ABI-encodes a call to ``functionPointer`` with the arguments found in the
   tuple. Performs a full type-check, ensuring the types match the function signature. Result equals ``abi.encodeWithSelector(functionPointer.selector, (...))``
 - ``abi.encodeWithSignature(string memory signature, ...) returns (bytes memory)``: Equivalent
-  to ``abi.encodeWithSelector(bytes4(keccak256(bytes(signature)), ...)``
+  to ``abi.encodeWithSelector(bytes4(keccak256(bytes(signature))), ...)``
+
+.. index:: bytes;concat, string;concat
+
+Members of ``bytes`` and  ``string``
+====================================
+
 - ``bytes.concat(...) returns (bytes memory)``: :ref:`Concatenates variable number of
   arguments to one byte array<bytes-concat>`
+
 - ``string.concat(...) returns (string memory)``: :ref:`Concatenates variable number of
   arguments to one string array<string-concat>`
+
+.. index:: address;balance, address;codehash, address;send, address;code, address;transfer
+
+Members of ``address``
+======================
+
+- ``<address>.balance`` (``uint256``): balance of the :ref:`address` in Wei
+- ``<address>.code`` (``bytes memory``): code at the :ref:`address` (can be empty)
+- ``<address>.codehash`` (``bytes32``): the codehash of the :ref:`address`
+- ``<address>.call(bytes memory) returns (bool, bytes memory)``: issue low-level ``CALL`` with the given payload,
+  returns success condition and return data
+- ``<address>.delegatecall(bytes memory) returns (bool, bytes memory)``: issue low-level ``DELEGATECALL`` with the given payload,
+  returns success condition and return data
+- ``<address>.staticcall(bytes memory) returns (bool, bytes memory)``: issue low-level ``STATICCALL`` with the given payload,
+  returns success condition and return data
+- ``<address payable>.send(uint256 amount) returns (bool)``: send given amount of Wei to :ref:`address`,
+  returns ``false`` on failure
+- ``<address payable>.transfer(uint256 amount)``: send given amount of Wei to :ref:`address`, throws on failure
+
+.. index:: blockhash, blobhash, block, block;basefee, block;blobbasefee, block;chainid, block;coinbase, block;difficulty, block;gaslimit, block;number, block;prevrandao, block;timestamp
+.. index:: gasleft, msg;data, msg;sender, msg;sig, msg;value, tx;gasprice, tx;origin
+
+Block and Transaction Properties
+================================
+
+- ``blockhash(uint blockNumber) returns (bytes32)``: hash of the given block - only works for 256 most recent blocks
+- ``blobhash(uint index) returns (bytes32)``: versioned hash of the ``index``-th blob associated with the current transaction.
+  A versioned hash consists of a single byte representing the version (currently ``0x01``), followed by the last 31 bytes
+  of the SHA256 hash of the KZG commitment (`EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_).
 - ``block.basefee`` (``uint``): current block's base fee (`EIP-3198 <https://eips.ethereum.org/EIPS/eip-3198>`_ and `EIP-1559 <https://eips.ethereum.org/EIPS/eip-1559>`_)
+- ``block.blobbasefee`` (``uint``): current block's blob base fee (`EIP-7516 <https://eips.ethereum.org/EIPS/eip-7516>`_ and `EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_)
 - ``block.chainid`` (``uint``): current chain id
 - ``block.coinbase`` (``address payable``): current block miner's address
-- ``block.difficulty`` (``uint``): current block difficulty
+- ``block.difficulty`` (``uint``): current block difficulty (``EVM < Paris``). For other EVM versions it behaves as a deprecated alias for ``block.prevrandao`` that will be removed in the next breaking release
 - ``block.gaslimit`` (``uint``): current block gaslimit
 - ``block.number`` (``uint``): current block number
+- ``block.prevrandao`` (``uint``): random number provided by the beacon chain (``EVM >= Paris``) (see `EIP-4399 <https://eips.ethereum.org/EIPS/eip-4399>`_ )
 - ``block.timestamp`` (``uint``): current block timestamp in seconds since Unix epoch
 - ``gasleft() returns (uint256)``: remaining gas
 - ``msg.data`` (``bytes``): complete calldata
@@ -43,6 +82,12 @@ Global Variables
 - ``msg.value`` (``uint``): number of wei sent with the message
 - ``tx.gasprice`` (``uint``): gas price of the transaction
 - ``tx.origin`` (``address``): sender of the transaction (full call chain)
+
+.. index:: assert, require, revert
+
+Validations and Assertions
+==========================
+
 - ``assert(bool condition)``: abort execution and revert state changes if condition is ``false`` (use for internal error)
 - ``require(bool condition)``: abort execution and revert state changes if condition is ``false`` (use
   for malformed input or error in external component)
@@ -50,7 +95,12 @@ Global Variables
   condition is ``false`` (use for malformed input or error in external component). Also provide error message.
 - ``revert()``: abort execution and revert state changes
 - ``revert(string memory message)``: abort execution and revert state changes providing an explanatory string
-- ``blockhash(uint blockNumber) returns (bytes32)``: hash of the given block - only works for 256 most recent blocks
+
+.. index:: cryptography, keccak256, sha256, ripemd160, ecrecover, addmod, mulmod
+
+Mathematical and Cryptographic Functions
+========================================
+
 - ``keccak256(bytes memory) returns (bytes32)``: compute the Keccak-256 hash of the input
 - ``sha256(bytes memory) returns (bytes32)``: compute the SHA-256 hash of the input
 - ``ripemd160(bytes memory) returns (bytes20)``: compute the RIPEMD-160 hash of the input
@@ -60,15 +110,21 @@ Global Variables
   arbitrary precision and does not wrap around at ``2**256``. Assert that ``k != 0`` starting from version 0.5.0.
 - ``mulmod(uint x, uint y, uint k) returns (uint)``: compute ``(x * y) % k`` where the multiplication is performed
   with arbitrary precision and does not wrap around at ``2**256``. Assert that ``k != 0`` starting from version 0.5.0.
+
+.. index:: this, super, selfdestruct
+
+Contract-related
+================
+
 - ``this`` (current contract's type): the current contract, explicitly convertible to ``address`` or ``address payable``
-- ``super``: the contract one level higher in the inheritance hierarchy
+- ``super``: a contract one level higher in the inheritance hierarchy
 - ``selfdestruct(address payable recipient)``: destroy the current contract, sending its funds to the given address
-- ``<address>.balance`` (``uint256``): balance of the :ref:`address` in Wei
-- ``<address>.code`` (``bytes memory``): code at the :ref:`address` (can be empty)
-- ``<address>.codehash`` (``bytes32``): the codehash of the :ref:`address`
-- ``<address payable>.send(uint256 amount) returns (bool)``: send given amount of Wei to :ref:`address`,
-  returns ``false`` on failure
-- ``<address payable>.transfer(uint256 amount)``: send given amount of Wei to :ref:`address`, throws on failure
+
+.. index:: type;name, type;creationCode, type;runtimeCode, type;interfaceId, type;min, type;max
+
+Type Information
+================
+
 - ``type(C).name`` (``string``): the name of the contract
 - ``type(C).creationCode`` (``bytes memory``): creation bytecode of the given contract, see :ref:`Type Information<meta-type>`.
 - ``type(C).runtimeCode`` (``bytes memory``): runtime bytecode of the given contract, see :ref:`Type Information<meta-type>`.
@@ -104,11 +160,11 @@ Modifiers
 - ``view`` for functions: Disallows modification of state.
 - ``payable`` for functions: Allows them to receive Ether together with a call.
 - ``constant`` for state variables: Disallows assignment (except initialisation), does not occupy storage slot.
-- ``immutable`` for state variables: Allows exactly one assignment at construction time and is constant afterwards. Is stored in code.
+- ``immutable`` for state variables: Allows assignment at construction time and is constant when deployed. Is stored in code.
 - ``anonymous`` for events: Does not store event signature as topic.
 - ``indexed`` for event parameters: Stores the parameter as topic.
 - ``virtual`` for functions and modifiers: Allows the function's or modifier's
-  behaviour to be changed in derived contracts.
+  behavior to be changed in derived contracts.
 - ``override``: States that this function, modifier or public state variable changes
-  the behaviour of a function or modifier in a base contract.
+  the behavior of a function or modifier in a base contract.
 
diff --git a/compiler/docs/common-patterns.rst b/compiler/docs/common-patterns.rst
index 1793ebd2..cbc219b5 100644
--- a/compiler/docs/common-patterns.rst
+++ b/compiler/docs/common-patterns.rst
@@ -18,7 +18,7 @@ introduces a potential security risk. You may read
 more about this on the :ref:`security_considerations` page.
 
 The following is an example of the withdrawal pattern in practice in
-a contract where the goal is to send the most money to the
+a contract where the goal is to send the most of some compensation, e.g. Ether, to the
 contract in order to become the "richest", inspired by
 `King of the Ether <https://www.kingoftheether.com/>`_.
 
@@ -34,7 +34,7 @@ you receive the funds of the person who is now the richest.
         address public richest;
         uint public mostSent;
 
-        mapping (address => uint) pendingWithdrawals;
+        mapping(address => uint) pendingWithdrawals;
 
         /// The amount of Ether sent was not higher than
         /// the currently highest amount.
@@ -55,7 +55,7 @@ you receive the funds of the person who is now the richest.
         function withdraw() public {
             uint amount = pendingWithdrawals[msg.sender];
             // Remember to zero the pending refund before
-            // sending to prevent re-entrancy attacks
+            // sending to prevent reentrancy attacks
             pendingWithdrawals[msg.sender] = 0;
             payable(msg.sender).transfer(amount);
         }
diff --git a/compiler/docs/conf.py b/compiler/docs/conf.py
index 10aa406f..ddc3ee81 100644
--- a/compiler/docs/conf.py
+++ b/compiler/docs/conf.py
@@ -31,7 +31,10 @@ def setup(sphinx):
     sphinx.add_lexer('Solidity', SolidityLexer)
     sphinx.add_lexer('Yul', YulLexer)
 
+    sphinx.add_css_file('css/fonts.css')
     sphinx.add_css_file('css/custom.css')
+    sphinx.add_css_file('css/custom-dark.css')
+    sphinx.add_css_file('css/pygments.css')
 
 # -- General configuration ------------------------------------------------
 
@@ -45,6 +48,7 @@ def setup(sphinx):
     'sphinx_a4doc',
     'html_extra_template_renderer',
     'remix_code_links',
+    'sphinx.ext.imgconverter',
 ]
 
 a4_base_path = os.path.dirname(__file__) + '/grammar'
@@ -63,7 +67,7 @@ def setup(sphinx):
 
 # General information about the project.
 project = 'Solidity'
-project_copyright = '2016-2021, Ethereum'
+project_copyright = '2016-2023, The Solidity Authors'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -131,7 +135,6 @@ def setup(sphinx):
 # documentation.
 html_theme_options = {
     'logo_only': True,
-    'style_nav_header_background': '#65afff',
     'display_version': True,
 }
 
@@ -147,12 +150,12 @@ def setup(sphinx):
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = "logo.svg"
+# html_logo = "logo.svg"
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+html_favicon = "_static/img/favicon.ico"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
@@ -161,7 +164,7 @@ def setup(sphinx):
 
 html_css_files = ["css/toggle.css"]
 
-html_js_files = ["js/toggle.js"]
+html_js_files = ["js/constants.js", "js/initialize.js", "js/toggle.js"]
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
@@ -209,7 +212,7 @@ def setup(sphinx):
 #html_show_sourcelink = True
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+html_show_sphinx = False
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
 #html_show_copyright = True
diff --git a/compiler/docs/contracts/constant-state-variables.rst b/compiler/docs/contracts/constant-state-variables.rst
index 2e94397b..a1bc24f5 100644
--- a/compiler/docs/contracts/constant-state-variables.rst
+++ b/compiler/docs/contracts/constant-state-variables.rst
@@ -30,19 +30,23 @@ Not all types for constants and immutables are implemented at this time. The onl
 .. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
-    pragma solidity >=0.7.4;
+    pragma solidity ^0.8.21;
 
     uint constant X = 32**22 + 8;
 
     contract C {
         string constant TEXT = "abc";
         bytes32 constant MY_HASH = keccak256("abc");
-        uint immutable decimals;
+        uint immutable decimals = 18;
         uint immutable maxBalance;
         address immutable owner = msg.sender;
 
         constructor(uint decimals_, address ref) {
-            decimals = decimals_;
+            if (decimals_ != 0)
+                // Immutables are only immutable when deployed.
+                // At construction time they can be assigned to any number of times.
+                decimals = decimals_;
+
             // Assignments to immutables can even access the environment.
             maxBalance = ref.balance;
         }
@@ -74,25 +78,34 @@ Immutable
 =========
 
 Variables declared as ``immutable`` are a bit less restricted than those
-declared as ``constant``: Immutable variables can be assigned an arbitrary
-value in the constructor of the contract or at the point of their declaration.
-They can be assigned only once and can, from that point on, be read even during
-construction time.
+declared as ``constant``: Immutable variables can be assigned a
+value at construction time.
+The value can be changed at any time before deployment and then it becomes permanent.
+
+One additional restriction is that immutables can only be assigned to inside expressions for which
+there is no possibility of being executed after creation.
+This excludes all modifier definitions and functions other than constructors.
+
+There are no restrictions on reading immutable variables.
+The read is even allowed to happen before the variable is written to for the first time because variables in
+Solidity always have a well-defined initial value.
+For this reason it is also allowed to never explicitly assign a value to an immutable.
+
+.. warning::
+    When accessing immutables at construction time, please keep the :ref:`initialization order
+    <state-variable-initialization-order>` in mind.
+    Even if you provide an explicit initializer, some expressions may end up being evaluated before
+    that initializer, especially when they are at a different level in inheritance hierarchy.
+
+.. note::
+    Before Solidity 0.8.21 initialization of immutable variables was more restrictive.
+    Such variables had to be initialized exactly once at construction time and could not be read
+    before then.
 
 The contract creation code generated by the compiler will modify the
 contract's runtime code before it is returned by replacing all references
 to immutables with the values assigned to them. This is important if
 you are comparing the
 runtime code generated by the compiler with the one actually stored in the
-blockchain.
-
-.. note::
-  Immutables that are assigned at their declaration are only considered
-  initialized once the constructor of the contract is executing.
-  This means you cannot initialize immutables inline with a value
-  that depends on another immutable. You can do this, however,
-  inside the constructor of the contract.
-
-  This is a safeguard against different interpretations about the order
-  of state variable initialization and constructor execution, especially
-  with regards to inheritance.
+blockchain. The compiler outputs where these immutables are located in the deployed bytecode
+in the ``immutableReferences`` field of the :ref:`compiler JSON standard output <compiler-api>`.
diff --git a/compiler/docs/contracts/creating-contracts.rst b/compiler/docs/contracts/creating-contracts.rst
index f574a5a6..8eb4e5f5 100644
--- a/compiler/docs/contracts/creating-contracts.rst
+++ b/compiler/docs/contracts/creating-contracts.rst
@@ -8,7 +8,7 @@ Contracts can be created "from outside" via Ethereum transactions or from within
 
 IDEs, such as `Remix <https://remix.ethereum.org/>`_, make the creation process seamless using UI elements.
 
-One way to create contracts programmatically on Ethereum is via the JavaScript API `web3.js <https://github.com/ethereum/web3.js>`_.
+One way to create contracts programmatically on Ethereum is via the JavaScript API `web3.js <https://github.com/web3/web3.js>`_.
 It has a function called `web3.eth.Contract <https://web3js.readthedocs.io/en/1.0/web3-eth-contract.html#new-contract>`_
 to facilitate contract creation.
 
diff --git a/compiler/docs/contracts/events.rst b/compiler/docs/contracts/events.rst
index 8618e752..8c73c316 100644
--- a/compiler/docs/contracts/events.rst
+++ b/compiler/docs/contracts/events.rst
@@ -9,12 +9,13 @@ Events
 Solidity events give an abstraction on top of the EVM's logging functionality.
 Applications can subscribe and listen to these events through the RPC interface of an Ethereum client.
 
-Events are inheritable members of contracts. When you call them, they cause the
+Events can be defined at file level or as inheritable members of contracts (including interfaces and libraries).
+When you call them, they cause the
 arguments to be stored in the transaction's log - a special data structure
-in the blockchain. These logs are associated with the address of the contract,
+in the blockchain. These logs are associated with the address of the contract that emitted them,
 are incorporated into the blockchain, and stay there as long as a block is
 accessible (forever as of now, but this might
-change with Serenity). The Log and its event data is not accessible from within
+change in the future). The Log and its event data is not accessible from within
 contracts (not even from the contract that created them).
 
 It is possible to request a Merkle proof for logs, so if
@@ -151,6 +152,6 @@ The output of the above looks like the following (trimmed):
 Additional Resources for Understanding Events
 =============================================
 
-- `Javascript documentation <https://github.com/ethereum/web3.js/blob/1.x/docs/web3-eth-contract.rst#events>`_
+- `JavaScript documentation <https://github.com/web3/web3.js/blob/1.x/docs/web3-eth-contract.rst#events>`_
 - `Example usage of events <https://github.com/ethchange/smart-exchange/blob/master/lib/contracts/SmartExchange.sol>`_
 - `How to access them in js <https://github.com/ethchange/smart-exchange/blob/master/lib/exchange_transactions.js>`_
diff --git a/compiler/docs/contracts/function-modifiers.rst b/compiler/docs/contracts/function-modifiers.rst
index f2311954..454e12ab 100644
--- a/compiler/docs/contracts/function-modifiers.rst
+++ b/compiler/docs/contracts/function-modifiers.rst
@@ -6,7 +6,7 @@
 Function Modifiers
 ******************
 
-Modifiers can be used to change the behaviour of functions in a declarative way.
+Modifiers can be used to change the behavior of functions in a declarative way.
 For example,
 you can use a modifier to automatically check a condition prior to executing the function.
 
@@ -19,6 +19,7 @@ if they are marked ``virtual``. For details, please see
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.1 <0.9.0;
+    // This will report a warning due to deprecated selfdestruct
 
     contract owned {
         constructor() { owner = payable(msg.sender); }
@@ -60,7 +61,7 @@ if they are marked ``virtual``. For details, please see
     }
 
     contract Register is priced, destructible {
-        mapping (address => bool) registeredAddresses;
+        mapping(address => bool) registeredAddresses;
         uint price;
 
         constructor(uint initialPrice) { price = initialPrice; }
@@ -131,7 +132,7 @@ variables are set to their :ref:`default values<default-value>` just as if the f
 body.
 
 The ``_`` symbol can appear in the modifier multiple times. Each occurrence is replaced with
-the function body.
+the function body, and the function returns the return value of the final occurrence.
 
 Arbitrary expressions are allowed for modifier arguments and in this context,
 all symbols visible from the function are visible in the modifier. Symbols
diff --git a/compiler/docs/contracts/functions.rst b/compiler/docs/contracts/functions.rst
index f14e4b8a..5b82a93b 100644
--- a/compiler/docs/contracts/functions.rst
+++ b/compiler/docs/contracts/functions.rst
@@ -1,4 +1,4 @@
-.. index:: ! functions
+.. index:: ! functions, ! function;free
 
 .. _functions:
 
@@ -250,7 +250,7 @@ Reverting a state change is not considered a "state modification", as only chang
 state made previously in code that did not have the ``view`` or ``pure`` restriction
 are reverted and that code has the option to catch the ``revert`` and not pass it on.
 
-This behaviour is also in line with the ``STATICCALL`` opcode.
+This behavior is also in line with the ``STATICCALL`` opcode.
 
 .. warning::
   It is not possible to prevent functions from reading the state at the level
@@ -277,7 +277,7 @@ This behaviour is also in line with the ``STATICCALL`` opcode.
 Special Functions
 =================
 
-.. index:: ! receive ether function, function;receive ! receive
+.. index:: ! receive ether function, function;receive, ! receive
 
 .. _receive-ether-function:
 
@@ -297,7 +297,7 @@ on plain Ether transfers (e.g. via ``.send()`` or ``.transfer()``). If no such
 function exists, but a payable :ref:`fallback function <fallback-function>`
 exists, the fallback function will be called on a plain Ether transfer. If
 neither a receive Ether nor a payable fallback function is present, the
-contract cannot receive Ether through regular transactions and throws an
+contract cannot receive Ether through a transaction that does not represent a payable function call and throws an
 exception.
 
 In the worst case, the ``receive`` function can only rely on 2300 gas being
diff --git a/compiler/docs/contracts/inheritance.rst b/compiler/docs/contracts/inheritance.rst
index a33a36d2..c787c5af 100644
--- a/compiler/docs/contracts/inheritance.rst
+++ b/compiler/docs/contracts/inheritance.rst
@@ -40,7 +40,7 @@ Details are given in the following example.
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.0 <0.9.0;
-
+    // This will report a warning due to deprecated selfdestruct
 
     contract Owned {
         constructor() { owner = payable(msg.sender); }
@@ -54,7 +54,7 @@ Details are given in the following example.
     // accessed externally via `this`, though.
     contract Destructible is Owned {
         // The keyword `virtual` means that the function can change
-        // its behaviour in derived classes ("overriding").
+        // its behavior in derived classes ("overriding").
         function destroy() virtual public {
             if (msg.sender == owner) selfdestruct(owner);
         }
@@ -115,7 +115,7 @@ Details are given in the following example.
 
         // Here, we only specify `override` and not `virtual`.
         // This means that contracts deriving from `PriceFeed`
-        // cannot change the behaviour of `destroy` anymore.
+        // cannot change the behavior of `destroy` anymore.
         function destroy() public override(Destructible, Named) { Named.destroy(); }
         function get() public view returns(uint r) { return info; }
 
@@ -130,6 +130,7 @@ seen in the following example:
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.0 <0.9.0;
+    // This will report a warning due to deprecated selfdestruct
 
     contract owned {
         constructor() { owner = payable(msg.sender); }
@@ -162,6 +163,7 @@ explicitly in the final override, but this function will bypass
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.0 <0.9.0;
+    // This will report a warning due to deprecated selfdestruct
 
     contract owned {
         constructor() { owner = payable(msg.sender); }
@@ -291,7 +293,7 @@ and ends at a contract mentioning a function with that signature
 that does not override.
 
 If you do not mark a function that overrides as ``virtual``, derived
-contracts can no longer change the behaviour of that function.
+contracts can no longer change the behavior of that function.
 
 .. note::
 
@@ -434,11 +436,11 @@ You can use internal parameters in a constructor (for example storage pointers).
 the contract has to be marked :ref:`abstract <abstract-contract>`, because these parameters
 cannot be assigned valid values from outside but only through the constructors of derived contracts.
 
-.. warning ::
+.. warning::
     Prior to version 0.4.22, constructors were defined as functions with the same name as the contract.
     This syntax was deprecated and is not allowed anymore in version 0.5.0.
 
-.. warning ::
+.. warning::
     Prior to version 0.7.0, you had to specify the visibility of constructors as either
     ``internal`` or ``public``.
 
@@ -485,7 +487,7 @@ One way is directly in the inheritance list (``is Base(7)``).  The other is in
 the way a modifier is invoked as part of
 the derived constructor (``Base(y * y)``). The first way to
 do it is more convenient if the constructor argument is a
-constant and defines the behaviour of the contract or
+constant and defines the behavior of the contract or
 describes it. The second way has to be used if the
 constructor arguments of the base depend on those of the
 derived contract. Arguments have to be given either in the
@@ -588,9 +590,11 @@ One area where inheritance linearization is especially important and perhaps not
 Inheriting Different Kinds of Members of the Same Name
 ======================================================
 
-It is an error when any of the following pairs in a contract have the same name due to inheritance:
-  - a function and a modifier
-  - a function and an event
-  - an event and a modifier
+The only situations where, due to inheritance, a contract may contain multiple definitions sharing
+the same name are:
 
-As an exception, a state variable getter can override an external function.
+- Overloading of functions.
+- Overriding of virtual functions.
+- Overriding of external virtual functions by state variable getters.
+- Overriding of virtual modifiers.
+- Overloading of events.
diff --git a/compiler/docs/contracts/interfaces.rst b/compiler/docs/contracts/interfaces.rst
index cc71cf64..a3085667 100644
--- a/compiler/docs/contracts/interfaces.rst
+++ b/compiler/docs/contracts/interfaces.rst
@@ -65,7 +65,7 @@ inheritance.
 Types defined inside interfaces and other contract-like structures
 can be accessed from other contracts: ``Token.TokenType`` or ``Token.Coin``.
 
-.. warning:
+.. warning::
 
     Interfaces have supported ``enum`` types since :doc:`Solidity version 0.5.0 <050-breaking-changes>`, make
     sure the pragma version specifies this version as a minimum.
diff --git a/compiler/docs/contracts/using-for.rst b/compiler/docs/contracts/using-for.rst
index b4a60585..a05cb277 100644
--- a/compiler/docs/contracts/using-for.rst
+++ b/compiler/docs/contracts/using-for.rst
@@ -1,4 +1,4 @@
-.. index:: ! using for, library
+.. index:: ! using for, library, ! operator;user-defined, function;free
 
 .. _using-for:
 
@@ -6,36 +6,87 @@
 Using For
 *********
 
-The directive ``using A for B;`` can be used to attach
-functions (``A``) as member functions to any type (``B``).
-These functions will receive the object they are called on
+The directive ``using A for B`` can be used to attach
+functions (``A``) as operators to user-defined value types
+or as member functions to any type (``B``).
+The member functions receive the object they are called on
 as their first parameter (like the ``self`` variable in Python).
+The operator functions receive operands as parameters.
 
 It is valid either at file level or inside a contract,
 at contract level.
 
 The first part, ``A``, can be one of:
 
-- a list of file-level or library functions (``using {f, g, h, L.t} for uint;``) -
-  only those functions will be attached to the type.
-- the name of a library (``using L for uint;``) -
-  all functions (both public and internal ones) of the library are attached to the type
+- A list of functions, optionally with an operator name assigned (e.g.
+  ``using {f, g as +, h, L.t} for uint``).
+  If no operator is specified, the function can be either a library function or a free function and
+  is attached to the type as a member function.
+  Otherwise it must be a free function and it becomes the definition of that operator on the type.
+- The name of a library (e.g. ``using L for uint``) -
+  all non-private functions of the library are attached to the type
+  as member functions
 
 At file level, the second part, ``B``, has to be an explicit type (without data location specifier).
-Inside contracts, you can also use ``using L for *;``,
+Inside contracts, you can also use ``*`` in place of the type (e.g. ``using L for *;``),
 which has the effect that all functions of the library ``L``
 are attached to *all* types.
 
-If you specify a library, *all* functions in the library are attached,
+If you specify a library, *all* non-private functions in the library get attached,
 even those where the type of the first parameter does not
 match the type of the object. The type is checked at the
 point the function is called and function overload
 resolution is performed.
 
-If you use a list of functions (``using {f, g, h, L.t} for uint;``),
+If you use a list of functions (e.g. ``using {f, g, h, L.t} for uint``),
 then the type (``uint``) has to be implicitly convertible to the
 first parameter of each of these functions. This check is
 performed even if none of these functions are called.
+Note that private library functions can only be specified when ``using for`` is inside a library.
+
+If you define an operator (e.g. ``using {f as +} for T``), then the type (``T``) must be a
+:ref:`user-defined value type <user-defined-value-types>` and the definition must be a ``pure`` function.
+Operator definitions must be global.
+The following operators can be defined this way:
+
++------------+----------+---------------------------------------------+
+| Category   | Operator | Possible signatures                         |
++============+==========+=============================================+
+| Bitwise    | ``&``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``|``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``^``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``~``    | ``function (T) pure returns (T)``           |
++------------+----------+---------------------------------------------+
+| Arithmetic | ``+``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``-``    | ``function (T, T) pure returns (T)``        |
+|            +          +---------------------------------------------+
+|            |          | ``function (T) pure returns (T)``           |
+|            +----------+---------------------------------------------+
+|            | ``*``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``/``    | ``function (T, T) pure returns (T)``        |
+|            +----------+---------------------------------------------+
+|            | ``%``    | ``function (T, T) pure returns (T)``        |
++------------+----------+---------------------------------------------+
+| Comparison | ``==``   | ``function (T, T) pure returns (bool)``     |
+|            +----------+---------------------------------------------+
+|            | ``!=``   | ``function (T, T) pure returns (bool)``     |
+|            +----------+---------------------------------------------+
+|            | ``<``    | ``function (T, T) pure returns (bool)``     |
+|            +----------+---------------------------------------------+
+|            | ``<=``   | ``function (T, T) pure returns (bool)``     |
+|            +----------+---------------------------------------------+
+|            | ``>``    | ``function (T, T) pure returns (bool)``     |
+|            +----------+---------------------------------------------+
+|            | ``>=``   | ``function (T, T) pure returns (bool)``     |
++------------+----------+---------------------------------------------+
+
+Note that unary and binary ``-`` need separate definitions.
+The compiler will choose the right definition based on how the operator is invoked.
 
 The ``using A for B;`` directive is active only within the current
 scope (either the contract or the current module/source unit),
@@ -45,7 +96,7 @@ outside of the contract or module in which it is used.
 When the directive is used at file level and applied to a
 user-defined type which was defined at file level in the same file,
 the word ``global`` can be added at the end. This will have the
-effect that the functions are attached to the type everywhere
+effect that the functions and operators are attached to the type everywhere
 the type is available (including other files), not only in the
 scope of the using statement.
 
@@ -149,3 +200,37 @@ if you pass memory or value types, a copy will be performed, even in case of the
 ``self`` variable. The only situation where no copy will be performed
 is when storage reference variables are used or when internal library
 functions are called.
+
+Another example shows how to define a custom operator for a user-defined type:
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity ^0.8.19;
+
+    type UFixed16x2 is uint16;
+
+    using {
+        add as +,
+        div as /
+    } for UFixed16x2 global;
+
+    uint32 constant SCALE = 100;
+
+    function add(UFixed16x2 a, UFixed16x2 b) pure returns (UFixed16x2) {
+        return UFixed16x2.wrap(UFixed16x2.unwrap(a) + UFixed16x2.unwrap(b));
+    }
+
+    function div(UFixed16x2 a, UFixed16x2 b) pure returns (UFixed16x2) {
+        uint32 a32 = UFixed16x2.unwrap(a);
+        uint32 b32 = UFixed16x2.unwrap(b);
+        uint32 result32 = a32 * SCALE / b32;
+        require(result32 <= type(uint16).max, "Divide overflow");
+        return UFixed16x2.wrap(uint16(a32 * SCALE / b32));
+    }
+
+    contract Math {
+        function avg(UFixed16x2 a, UFixed16x2 b) public pure returns (UFixed16x2) {
+            return (a + b) / UFixed16x2.wrap(200);
+        }
+    }
diff --git a/compiler/docs/contracts/visibility-and-getters.rst b/compiler/docs/contracts/visibility-and-getters.rst
index 8932c507..5bf46dea 100644
--- a/compiler/docs/contracts/visibility-and-getters.rst
+++ b/compiler/docs/contracts/visibility-and-getters.rst
@@ -200,12 +200,12 @@ The next example is more complex:
         struct Data {
             uint a;
             bytes3 b;
-            mapping (uint => uint) map;
+            mapping(uint => uint) map;
             uint[3] c;
             uint[] d;
             bytes e;
         }
-        mapping (uint => mapping(bool => Data[])) public data;
+        mapping(uint => mapping(bool => Data[])) public data;
     }
 
 It generates a function of the following form. The mapping and arrays (with the
diff --git a/compiler/docs/contributing.rst b/compiler/docs/contributing.rst
index 9da7f02d..ac4e2375 100644
--- a/compiler/docs/contributing.rst
+++ b/compiler/docs/contributing.rst
@@ -12,7 +12,7 @@ In particular, we appreciate support in the following areas:
   `"good first issue" <https://github.com/ethereum/solidity/labels/good%20first%20issue>`_ which are
   meant as introductory issues for external contributors.
 * Improving the documentation.
-* Translating the documentation into more languages.
+* `Translating <https://github.com/solidity-docs>`_ the documentation into more languages.
 * Responding to questions from other users on `StackExchange
   <https://ethereum.stackexchange.com>`_ and the `Solidity Gitter Chat
   <https://gitter.im/ethereum/solidity>`_.
@@ -28,11 +28,11 @@ Team Calls
 ==========
 
 If you have issues or pull requests to discuss, or are interested in hearing what
-the team and contributors are working on, you can join our public team calls:
+the team and contributors are working on, you can join our public team call:
 
-- Mondays and Wednesdays at 3pm CET/CEST.
+- Wednesdays at 3PM CET/CEST.
 
-Both calls take place on `Jitsi <https://meet.ethereum.org/solidity>`_.
+The call takes place on `Jitsi <https://meet.ethereum.org/solidity>`_.
 
 How to Report Issues
 ====================
@@ -45,11 +45,14 @@ reporting issues, please mention the following details:
 * Source code (if applicable).
 * Operating system.
 * Steps to reproduce the issue.
-* Actual vs. expected behaviour.
+* Actual vs. expected behavior.
 
 Reducing the source code that caused the issue to a bare minimum is always
 very helpful, and sometimes even clarifies a misunderstanding.
 
+For technical discussions about language design, a post in the
+`Solidity forum <https://forum.soliditylang.org/>`_ is the correct place (see :ref:`solidity_language_design`).
+
 Workflow for Pull Requests
 ==========================
 
@@ -77,6 +80,9 @@ Finally, please make sure you respect the `coding style
 for this project. Also, even though we do CI testing, please test your code and
 ensure that it builds locally before submitting a pull request.
 
+We highly recommend going through our `review checklist <https://github.com/ethereum/solidity/blob/develop/ReviewChecklist.md>`_ before submitting the pull request.
+We thoroughly review every PR and will help you get it right, but there are many common problems that can be easily avoided, making the review much smoother.
+
 Thank you for your help!
 
 Running the Compiler Tests
@@ -87,8 +93,7 @@ Prerequisites
 
 For running all compiler tests you may want to optionally install a few
 dependencies (`evmone <https://github.com/ethereum/evmone/releases>`_,
-`libz3 <https://github.com/Z3Prover/z3>`_, and
-`libhera <https://github.com/ewasm/hera>`_).
+`libz3 <https://github.com/Z3Prover/z3>`_).
 
 On macOS systems, some of the testing scripts expect GNU coreutils to be installed.
 This can be easiest accomplished using Homebrew: ``brew install coreutils``.
@@ -96,9 +101,9 @@ This can be easiest accomplished using Homebrew: ``brew install coreutils``.
 On Windows systems, make sure that you have a privilege to create symlinks,
 otherwise several tests may fail.
 Administrators should have that privilege, but you may also
-`grant it to other users <https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links#policy-management>`_
+`grant it to other users <https://learn.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links#policy-management>`_
 or
-`enable Developer Mode <https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development>`_.
+`enable Developer Mode <https://learn.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development>`_.
 
 Running the Tests
 -----------------
@@ -109,7 +114,7 @@ Running ``build/test/soltest`` or its wrapper ``scripts/soltest.sh`` is sufficie
 
 The ``./scripts/tests.sh`` script executes most Solidity tests automatically,
 including those bundled into the `Boost C++ Test Framework <https://www.boost.org/doc/libs/release/libs/test/doc/html/index.html>`_
-application ``soltest`` (or its wrapper ``scripts/soltest.sh``), as well as command line tests and
+application ``soltest`` (or its wrapper ``scripts/soltest.sh``), as well as command-line tests and
 compilation tests.
 
 The test system automatically tries to discover the location of
@@ -123,13 +128,7 @@ for the ``evmone`` shared object can be specified via the ``ETH_EVMONE`` environ
 If you do not have it installed, you can skip these tests by passing the ``--no-semantic-tests``
 flag to ``scripts/soltest.sh``.
 
-Running Ewasm tests is disabled by default and can be explicitly enabled
-via ``./scripts/soltest.sh --ewasm`` and requires `hera <https://github.com/ewasm/hera>`_
-to be found by ``soltest``.
-The mechanism for locating the ``hera`` library is the same as for ``evmone``, except that the
-variable for specifying an explicit location is called ``ETH_HERA``.
-
-The ``evmone`` and ``hera`` libraries should both end with the file name
+The ``evmone`` library should both end with the file name
 extension ``.so`` on Linux, ``.dll`` on Windows systems and ``.dylib`` on macOS.
 
 For running SMT tests, the ``libz3`` library must be installed and locatable
@@ -140,7 +139,7 @@ SMT tests by exporting ``SMT_FLAGS=--no-smt`` before running ``./scripts/tests.s
 running ``./scripts/soltest.sh --no-smt``.
 These tests are ``libsolidity/smtCheckerTests`` and ``libsolidity/smtCheckerTestsJSON``.
 
-.. note ::
+.. note::
 
     To get a list of all unit tests run by Soltest, run ``./build/test/soltest --list_content=HRF``.
 
@@ -161,7 +160,7 @@ See especially:
 - `run_test (-t) <https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/utf_reference/rt_param_reference/run_test.html>`_ to run specific tests cases, and
 - `report-level (-r) <https://www.boost.org/doc/libs/release/libs/test/doc/html/boost_test/utf_reference/rt_param_reference/report_level.html>`_ give a more detailed report.
 
-.. note ::
+.. note::
 
     Those working in a Windows environment wanting to run the above basic sets
     without libz3. Using Git Bash, you use: ``./build/test/Release/soltest.exe -- --no-smt``.
@@ -169,6 +168,7 @@ See especially:
 
 If you want to debug using GDB, make sure you build differently than the "usual".
 For example, you could run the following command in your ``build`` folder:
+
 .. code-block:: bash
 
    cmake -DCMAKE_BUILD_TYPE=Debug ..
@@ -239,7 +239,7 @@ provides a way to edit, update or skip the current contract file, or quit the ap
 
 It offers several options for failing tests:
 
-- ``edit``: ``isoltest`` tries to open the contract in an editor so you can adjust it. It either uses the editor given on the command line (as ``isoltest --editor /path/to/editor``), in the environment variable ``EDITOR`` or just ``/usr/bin/editor`` (in that order).
+- ``edit``: ``isoltest`` tries to open the contract in an editor so you can adjust it. It either uses the editor given on the command-line (as ``isoltest --editor /path/to/editor``), in the environment variable ``EDITOR`` or just ``/usr/bin/editor`` (in that order).
 - ``update``: Updates the expectations for contract under test. This updates the annotations by removing unmet expectations and adding missing expectations. The test is then run again.
 - ``skip``: Skips the execution of this particular test.
 - ``quit``: Quits ``isoltest``.
@@ -269,6 +269,62 @@ and re-run the test. It now passes again:
     Do not put more than one contract into a single file, unless you are testing inheritance or cross-contract calls.
     Each file should test one aspect of your new feature.
 
+Command-line Tests
+------------------
+
+Our suite of end-to-end command-line tests checks the behaviour of the compiler binary as a whole
+in various scenarios.
+These tests are located in `test/cmdlineTests/ <https://github.com/ethereum/solidity/tree/develop/test/cmdlineTests>`_,
+one per subdirectory, and can be executed using the ``cmdlineTests.sh`` script.
+
+By default the script runs all available tests.
+You can also provide one or more `file name patterns <https://www.gnu.org/software/bash/manual/bash.html#Filename-Expansion>`_,
+in which case only the tests matching at least one pattern will be executed.
+It is also possible to exclude files matching a specific pattern by prefixing it with ``--exclude``.
+
+By default the script assumes that a ``solc`` binary is available inside the ``build/`` subdirectory
+inside the working copy.
+If you build the compiler outside of the source tree, you can use the ``SOLIDITY_BUILD_DIR`` environment
+variable to specify a different location for the build directory.
+
+Example:
+
+.. code-block:: bash
+
+    export SOLIDITY_BUILD_DIR=~/solidity/build/
+    test/cmdlineTests.sh "standard_*" "*_yul_*" --exclude "standard_yul_*"
+
+The commands above will run tests from directories starting with ``test/cmdlineTests/standard_`` and
+subdirectories of ``test/cmdlineTests/`` that have ``_yul_`` somewhere in the name,
+but no test whose name starts with ``standard_yul_`` will be executed.
+It will also assume that the file ``solidity/build/solc/solc`` inside your home directory is the
+compiler binary (unless you are on Windows -- then ``solidity/build/solc/Release/solc.exe``).
+
+There are several kinds of command-line tests:
+
+- *Standard JSON test*: contains at least an ``input.json`` file.
+  In general may contain:
+
+    - ``input.json``: input file to be passed to the ``--standard-json`` option on the command line.
+    - ``output.json``: expected Standard JSON output.
+    - ``args``: extra command-line arguments passed to ``solc``.
+
+- *CLI test*: contains at least an ``input.*`` file (other than ``input.json``).
+  In general may contain:
+
+    - ``input.*``: a single input file, whose name will be supplied to ``solc`` on the command line.
+      Usually ``input.sol`` or ``input.yul``.
+    - ``args``: extra command-line arguments passed to ``solc``.
+    - ``stdin``: content to be passed to ``solc`` via standard input.
+    - ``output``: expected content of the standard output.
+    - ``err``: expected content of the standard error output.
+    - ``exit``: expected exit code. If not provided, zero is expected.
+
+- *Script test*: contains a ``test.*`` file.
+  In general may contain:
+
+    - ``test.*``: a single script to run, usually ``test.sh`` or ``test.py``.
+      The script must be executable.
 
 Running the Fuzzer via AFL
 ==========================
@@ -350,7 +406,7 @@ The AFL documentation states that the corpus (the initial input files) should no
 too large. The files themselves should not be larger than 1 kB and there should be
 at most one input file per functionality, so better start with a small number of.
 There is also a tool called ``afl-cmin`` that can trim input files
-that result in similar behaviour of the binary.
+that result in similar behavior of the binary.
 
 Now run the fuzzer (the ``-m`` extends the size of memory to 60 MB):
 
@@ -397,18 +453,17 @@ contributions to Solidity.
 English Language
 ----------------
 
-Use English, with British English spelling preferred, unless using project or brand names. Try to reduce the usage of
-local slang and references, making your language as clear to all readers as possible. Below are some references to help:
+Use International English, unless using project or brand names. Try to reduce the usage of
+local slang and references, making your language as clear to all readers as possible.
+Below are some references to help:
 
 * `Simplified technical English <https://en.wikipedia.org/wiki/Simplified_Technical_English>`_
 * `International English <https://en.wikipedia.org/wiki/International_English>`_
-* `British English spelling <https://en.oxforddictionaries.com/spelling/british-and-spelling>`_
-
 
 .. note::
 
     While the official Solidity documentation is written in English, there are community contributed :ref:`translations`
-    in other languages available. Please refer to the `translation guide <https://github.com/solidity-docs/translation-guide>`_
+    in other languages available. Please refer to the `translation guide <https://github.com/solidity-docs#solidity-documentation-translation-guide>`_
     for information on how to contribute to the community translations.
 
 Title Case for Headings
@@ -477,6 +532,8 @@ Running Documentation Tests
 Make sure your contributions pass our documentation tests by running ``./docs/docs.sh`` that installs dependencies
 needed for documentation and checks for any problems such as broken links or syntax issues.
 
+.. _solidity_language_design:
+
 Solidity Language Design
 ========================
 
diff --git a/compiler/docs/control-structures.rst b/compiler/docs/control-structures.rst
index 18a52221..ea8a9c56 100644
--- a/compiler/docs/control-structures.rst
+++ b/compiler/docs/control-structures.rst
@@ -173,7 +173,6 @@ parameters from the function declaration, but can be in arbitrary order.
         function set(uint key, uint value) public {
             data[key] = value;
         }
-
     }
 
 Omitted Names in Function Definitions
@@ -366,13 +365,13 @@ i.e. the following is not valid: ``(x, uint y) = (1, 2);``
 .. warning::
     Be careful when assigning to multiple variables at the same time when
     reference types are involved, because it could lead to unexpected
-    copying behaviour.
+    copying behavior.
 
 Complications for Arrays and Structs
 ------------------------------------
 
 The semantics of assignments are more complicated for non-value types like arrays and structs,
-including ``bytes`` and ``string``, see :ref:`Data location and assignment behaviour <data-location-assignment>` for details.
+including ``bytes`` and ``string``, see :ref:`Data location and assignment behavior <data-location-assignment>` for details.
 
 In the example below the call to ``g(x)`` has no effect on ``x`` because it creates
 an independent copy of the storage value in memory. However, ``h(x)`` successfully modifies ``x``
@@ -511,7 +510,7 @@ additional checks.
 Since Solidity 0.8.0, all arithmetic operations revert on over- and underflow by default,
 thus making the use of these libraries unnecessary.
 
-To obtain the previous behaviour, an ``unchecked`` block can be used:
+To obtain the previous behavior, an ``unchecked`` block can be used:
 
 .. code-block:: solidity
 
@@ -651,7 +650,7 @@ in the following situations:
 
 For the following cases, the error data from the external call
 (if provided) is forwarded. This means that it can either cause
-an `Error` or a `Panic` (or whatever else was given):
+an ``Error`` or a ``Panic`` (or whatever else was given):
 
 #. If a ``.transfer()`` fails.
 #. If you call a function via a message call but it does not finish
@@ -686,7 +685,7 @@ and ``assert`` for internal error checking.
             addr.transfer(msg.value / 2);
             // Since transfer throws an exception on failure and
             // cannot call back here, there should be no way for us to
-            // still have half of the money.
+            // still have half of the Ether.
             assert(address(this).balance == balanceBeforeTransfer - msg.value / 2);
             return address(this).balance;
         }
@@ -720,7 +719,7 @@ The ``revert`` statement takes a custom error as direct argument without parenth
 
     revert CustomError(arg1, arg2);
 
-For backwards-compatibility reasons, there is also the ``revert()`` function, which uses parentheses
+For backward-compatibility reasons, there is also the ``revert()`` function, which uses parentheses
 and accepts a string:
 
     revert();
diff --git a/compiler/docs/examples/blind-auction.rst b/compiler/docs/examples/blind-auction.rst
index b0a86f24..47e19033 100644
--- a/compiler/docs/examples/blind-auction.rst
+++ b/compiler/docs/examples/blind-auction.rst
@@ -16,11 +16,11 @@ Simple Open Auction
 ===================
 
 The general idea of the following simple auction contract is that everyone can
-send their bids during a bidding period. The bids already include sending money
-/ Ether in order to bind the bidders to their bid. If the highest bid is
-raised, the previous highest bidder gets their money back.  After the end of
+send their bids during a bidding period. The bids already include sending some compensation,
+e.g. Ether, in order to bind the bidders to their bid. If the highest bid is
+raised, the previous highest bidder gets their Ether back.  After the end of
 the bidding period, the contract has to be called manually for the beneficiary
-to receive their money - contracts cannot activate themselves.
+to receive their Ether - contracts cannot activate themselves.
 
 .. code-block:: solidity
 
@@ -92,19 +92,19 @@ to receive their money - contracts cannot activate themselves.
                 revert AuctionAlreadyEnded();
 
             // If the bid is not higher, send the
-            // money back (the revert statement
+            // Ether back (the revert statement
             // will revert all changes in this
             // function execution including
-            // it having received the money).
+            // it having received the Ether).
             if (msg.value <= highestBid)
                 revert BidNotHighEnough(highestBid);
 
             if (highestBid != 0) {
-                // Sending back the money by simply using
+                // Sending back the Ether by simply using
                 // highestBidder.send(highestBid) is a security risk
                 // because it could execute an untrusted contract.
                 // It is always safer to let the recipients
-                // withdraw their money themselves.
+                // withdraw their Ether themselves.
                 pendingReturns[highestBidder] += highestBid;
             }
             highestBidder = msg.sender;
@@ -177,19 +177,19 @@ During the **bidding period**, a bidder does not actually send their bid, but
 only a hashed version of it.  Since it is currently considered practically
 impossible to find two (sufficiently long) values whose hash values are equal,
 the bidder commits to the bid by that.  After the end of the bidding period,
-the bidders have to reveal their bids: They send their values unencrypted and
+the bidders have to reveal their bids: They send their values unencrypted, and
 the contract checks that the hash value is the same as the one provided during
 the bidding period.
 
 Another challenge is how to make the auction **binding and blind** at the same
-time: The only way to prevent the bidder from just not sending the money after
+time: The only way to prevent the bidder from just not sending the Ether after
 they won the auction is to make them send it together with the bid. Since value
 transfers cannot be blinded in Ethereum, anyone can see the value.
 
 The following contract solves this problem by accepting any value that is
 larger than the highest bid. Since this can of course only be checked during
 the reveal phase, some bids might be **invalid**, and this is on purpose (it
-even provides an explicit flag to place invalid bids with high value
+even provides an explicit flag to place invalid bids with high-value
 transfers): Bidders can confuse competition by placing several high or low
 invalid bids.
 
diff --git a/compiler/docs/examples/micropayment.rst b/compiler/docs/examples/micropayment.rst
index c95d7c5e..50f28005 100644
--- a/compiler/docs/examples/micropayment.rst
+++ b/compiler/docs/examples/micropayment.rst
@@ -2,7 +2,7 @@
 Micropayment Channel
 ********************
 
-In this section we will learn how to build an example implementation
+In this section, we will learn how to build an example implementation
 of a payment channel. It uses cryptographic signatures to make
 repeated transfers of Ether between the same parties secure, instantaneous, and
 without transaction fees. For the example, we need to understand how to
@@ -17,14 +17,14 @@ Alice is the sender and Bob is the recipient.
 Alice only needs to send cryptographically signed messages off-chain
 (e.g. via email) to Bob and it is similar to writing checks.
 
-Alice and Bob use signatures to authorise transactions, which is possible with smart contracts on Ethereum.
+Alice and Bob use signatures to authorize transactions, which is possible with smart contracts on Ethereum.
 Alice will build a simple smart contract that lets her transmit Ether, but instead of calling a function herself
 to initiate a payment, she will let Bob do that, and therefore pay the transaction fee.
 
 The contract will work as follows:
 
     1. Alice deploys the ``ReceiverPays`` contract, attaching enough Ether to cover the payments that will be made.
-    2. Alice authorises a payment by signing a message with her private key.
+    2. Alice authorizes a payment by signing a message with her private key.
     3. Alice sends the cryptographically signed message to Bob. The message does not need to be kept secret
        (explained later), and the mechanism for sending it does not matter.
     4. Bob claims his payment by presenting the signed message to the smart contract, it verifies the
@@ -36,7 +36,7 @@ Creating the signature
 Alice does not need to interact with the Ethereum network
 to sign the transaction, the process is completely offline.
 In this tutorial, we will sign messages in the browser
-using `web3.js <https://github.com/ethereum/web3.js>`_ and
+using `web3.js <https://github.com/web3/web3.js>`_ and
 `MetaMask <https://metamask.io>`_, using the method described in `EIP-712 <https://github.com/ethereum/EIPs/pull/712>`_,
 as it provides a number of other security benefits.
 
@@ -86,7 +86,7 @@ Packing arguments
 Now that we have identified what information to include in the signed message,
 we are ready to put the message together, hash it, and sign it. For simplicity,
 we concatenate the data. The `ethereumjs-abi <https://github.com/ethereumjs/ethereumjs-abi>`_
-library provides a function called ``soliditySHA3`` that mimics the behaviour of
+library provides a function called ``soliditySHA3`` that mimics the behavior of
 Solidity's ``keccak256`` function applied to arguments encoded using ``abi.encodePacked``.
 Here is a JavaScript function that creates the proper signature for the ``ReceiverPays`` example:
 
@@ -144,6 +144,7 @@ The full contract
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.0 <0.9.0;
+    // This will report a warning due to deprecated selfdestruct
     contract ReceiverPays {
         address owner = msg.sender;
 
@@ -259,7 +260,7 @@ Messages are cryptographically signed by the sender and then transmitted directl
 Each message includes the following information:
 
     * The smart contract's address, used to prevent cross-contract replay attacks.
-    * The total amount of Ether that is owed the recipient so far.
+    * The total amount of Ether that is owed to the recipient so far.
 
 A payment channel is closed just once, at the end of a series of transfers.
 Because of this, only one of the messages sent is redeemed. This is why
@@ -341,6 +342,7 @@ The full contract
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.7.0 <0.9.0;
+    // This will report a warning due to deprecated selfdestruct
     contract SimplePaymentChannel {
         address payable public sender;      // The account sending payments.
         address payable public recipient;   // The account receiving the payments.
diff --git a/compiler/docs/examples/modular.rst b/compiler/docs/examples/modular.rst
index 697699ae..9ae2849c 100644
--- a/compiler/docs/examples/modular.rst
+++ b/compiler/docs/examples/modular.rst
@@ -7,7 +7,7 @@ Modular Contracts
 A modular approach to building your contracts helps you reduce the complexity
 and improve the readability which will help to identify bugs and vulnerabilities
 during development and code review.
-If you specify and control the behaviour of each module in isolation, the
+If you specify and control the behavior of each module in isolation, the
 interactions you have to consider are only those between the module specifications
 and not every other moving part of the contract.
 In the example below, the contract uses the ``move`` method
@@ -34,7 +34,7 @@ and the sum of all balances is an invariant across the lifetime of the contract.
     contract Token {
         mapping(address => uint256) balances;
         using Balances for *;
-        mapping(address => mapping (address => uint256)) allowed;
+        mapping(address => mapping(address => uint256)) allowed;
 
         event Transfer(address from, address to, uint amount);
         event Approval(address owner, address spender, uint amount);
diff --git a/compiler/docs/examples/safe-remote.rst b/compiler/docs/examples/safe-remote.rst
index e42b017f..a2651af2 100644
--- a/compiler/docs/examples/safe-remote.rst
+++ b/compiler/docs/examples/safe-remote.rst
@@ -6,18 +6,18 @@ Safe Remote Purchase
 
 Purchasing goods remotely currently requires multiple parties that need to trust each other.
 The simplest configuration involves a seller and a buyer. The buyer would like to receive
-an item from the seller and the seller would like to get money (or an equivalent)
+an item from the seller and the seller would like to get some compensation, e.g. Ether,
 in return. The problematic part is the shipment here: There is no way to determine for
 sure that the item arrived at the buyer.
 
 There are multiple ways to solve this problem, but all fall short in one or the other way.
 In the following example, both parties have to put twice the value of the item into the
-contract as escrow. As soon as this happened, the money will stay locked inside
+contract as escrow. As soon as this happened, the Ether will stay locked inside
 the contract until the buyer confirms that they received the item. After that,
 the buyer is returned the value (half of their deposit) and the seller gets three
 times the value (their deposit plus the value). The idea behind
 this is that both parties have an incentive to resolve the situation or otherwise
-their money is locked forever.
+their Ether is locked forever.
 
 This contract of course does not solve the problem, but gives an overview of how
 you can use state machine-like constructs inside a contract.
diff --git a/compiler/docs/ext/remix_code_links.py b/compiler/docs/ext/remix_code_links.py
index 2fc15ddd..55fc0ef5 100644
--- a/compiler/docs/ext/remix_code_links.py
+++ b/compiler/docs/ext/remix_code_links.py
@@ -22,23 +22,16 @@ def remix_code_url(source_code, language, solidity_version):
     # NOTE: base64 encoded data may contain +, = and / characters. Remix seems to handle them just
     # fine without any escaping.
     base64_encoded_source = base64.b64encode(source_code.encode('utf-8')).decode('ascii')
-    return f"https://remix.ethereum.org/?language={language}&version={solidity_version}&code={base64_encoded_source}"
+    return f"https://remix.ethereum.org/?#language={language}&version={solidity_version}&code={base64_encoded_source}"
 
 
 def build_remix_link_node(url):
-    link_icon_node = docutils.nodes.inline()
-    link_icon_node.set_class('link-icon')
-
-    link_text_node = docutils.nodes.inline(text="open in Remix")
-    link_text_node.set_class('link-text')
-
-    reference_node = docutils.nodes.reference('', '', internal=False, refuri=url)
-    reference_node.set_class('remix-link')
-    reference_node += [link_icon_node, link_text_node]
+    reference_node = docutils.nodes.reference('', 'open in Remix', internal=False, refuri=url, target='_blank')
+    reference_node['classes'].append('remix-link')
 
     paragraph_node = docutils.nodes.paragraph()
-    paragraph_node.set_class('remix-link-container')
-    paragraph_node += reference_node
+    paragraph_node['classes'].append('remix-link-container')
+    paragraph_node.append(reference_node)
     return paragraph_node
 
 
@@ -49,22 +42,24 @@ def insert_remix_link(app, doctree, solidity_version):
     for literal_block_node in doctree.traverse(docutils.nodes.literal_block):
         assert 'language' in literal_block_node.attributes
         language = literal_block_node.attributes['language'].lower()
-        if language in ['solidity', 'yul']:
-            text_nodes = list(literal_block_node.traverse(docutils.nodes.Text))
-            assert len(text_nodes) == 1
-
-            remix_url = remix_code_url(text_nodes[0], language, solidity_version)
-            url_length = len(remix_url.encode('utf-8'))
-            if url_length > MAX_SAFE_URL_LENGTH:
-                logger.warning(
-                    "Remix URL generated from the code snippet exceeds the maximum safe URL length "
-                    " (%d > %d bytes).",
-                    url_length,
-                    MAX_SAFE_URL_LENGTH,
-                    location=(literal_block_node.source, literal_block_node.line),
-                )
-
-            insert_node_before(literal_block_node, build_remix_link_node(remix_url))
+        if language not in ['solidity', 'yul']:
+            continue
+
+        text_nodes = list(literal_block_node.traverse(docutils.nodes.Text))
+        assert len(text_nodes) == 1
+
+        remix_url = remix_code_url(text_nodes[0], language, solidity_version)
+        url_length = len(remix_url.encode('utf-8'))
+        if url_length > MAX_SAFE_URL_LENGTH:
+            logger.warning(
+                "Remix URL generated from the code snippet exceeds the maximum safe URL length "
+                " (%d > %d bytes).",
+                url_length,
+                MAX_SAFE_URL_LENGTH,
+                location=(literal_block_node.source, literal_block_node.line),
+            )
+
+        insert_node_before(literal_block_node, build_remix_link_node(remix_url))
 
 
 def setup(app):
diff --git a/compiler/docs/grammar/SolidityLexer.g4 b/compiler/docs/grammar/SolidityLexer.g4
index c47dc411..43648ceb 100644
--- a/compiler/docs/grammar/SolidityLexer.g4
+++ b/compiler/docs/grammar/SolidityLexer.g4
@@ -62,7 +62,7 @@ New: 'new';
 /**
  * Unit denomination for numbers.
  */
-NumberUnit: 'wei' | 'gwei' | 'ether' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'years';
+SubDenomination: 'wei' | 'gwei' | 'ether' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'years';
 Override: 'override';
 Payable: 'payable';
 Pragma: 'pragma' -> pushMode(PragmaMode);
@@ -90,6 +90,7 @@ Try: 'try';
 Type: 'type';
 Ufixed: 'ufixed' | ('ufixed' [1-9][0-9]+ 'x' [1-9][0-9]+);
 Unchecked: 'unchecked';
+Unicode: 'unicode';
 /**
  * Sized unsigned integer types.
  * uint is an alias of uint256.
@@ -198,9 +199,7 @@ fragment EscapeSequence:
 /**
  * A single quoted string literal allowing arbitrary unicode characters.
  */
-UnicodeStringLiteral:
-	'unicode"' DoubleQuotedUnicodeStringCharacter* '"'
-	| 'unicode\'' SingleQuotedUnicodeStringCharacter* '\'';
+UnicodeStringLiteral: 'unicode' (('"' DoubleQuotedUnicodeStringCharacter* '"') | ('\'' SingleQuotedUnicodeStringCharacter* '\''));
 //@doc:inline
 fragment DoubleQuotedUnicodeStringCharacter: ~["\r\n\\] | EscapeSequence;
 //@doc:inline
@@ -222,6 +221,14 @@ fragment EvenHexDigits: HexCharacter HexCharacter ('_'? HexCharacter HexCharacte
 //@doc:inline
 fragment HexCharacter: [0-9A-Fa-f];
 
+/**
+ * Scanned but not used by any rule, i.e, disallowed.
+ * solc parser considers number starting with '0', not immediately followed by '.' or 'x' as
+ * octal, even if non octal digits '8' and '9' are present.
+ */
+OctalNumber: '0' DecimalDigits ('.' DecimalDigits)?;
+
+
 /**
  * A decimal number literal consists of decimal digits that may be delimited by underscores and
  * an optional positive or negative exponent.
@@ -232,6 +239,12 @@ DecimalNumber: (DecimalDigits | (DecimalDigits? '.' DecimalDigits)) ([eE] '-'? D
 fragment DecimalDigits: [0-9] ('_'? [0-9])* ;
 
 
+/**
+ * This is needed to avoid successfully parsing a number followed by a string with no whitespace between.
+ */
+DecimalNumberFollowedByIdentifier: DecimalNumber Identifier;
+
+
 /**
  * An identifier in solidity has to start with a letter, a dollar-sign or an underscore and
  * may additionally contain numbers after the first symbol.
@@ -285,14 +298,14 @@ YulEVMBuiltin:
 	'stop' | 'add' | 'sub' | 'mul' | 'div' | 'sdiv' | 'mod' | 'smod' | 'exp' | 'not'
 	| 'lt' | 'gt' | 'slt' | 'sgt' | 'eq' | 'iszero' | 'and' | 'or' | 'xor' | 'byte'
 	| 'shl' | 'shr' | 'sar' | 'addmod' | 'mulmod' | 'signextend' | 'keccak256'
-	| 'pop' | 'mload' | 'mstore' | 'mstore8' | 'sload' | 'sstore' | 'msize' | 'gas'
+	| 'pop' | 'mload' | 'mstore' | 'mstore8' | 'sload' | 'sstore' | 'tload' | 'tstore'| 'msize' | 'gas'
 	| 'address' | 'balance' | 'selfbalance' | 'caller' | 'callvalue' | 'calldataload'
 	| 'calldatasize' | 'calldatacopy' | 'extcodesize' | 'extcodecopy' | 'returndatasize'
-	| 'returndatacopy' | 'extcodehash' | 'create' | 'create2' | 'call' | 'callcode'
+	| 'returndatacopy' | 'mcopy' | 'extcodehash' | 'create' | 'create2' | 'call' | 'callcode'
 	| 'delegatecall' | 'staticcall' | 'return' | 'revert' | 'selfdestruct' | 'invalid'
 	| 'log0' | 'log1' | 'log2' | 'log3' | 'log4' | 'chainid' | 'origin' | 'gasprice'
-	| 'blockhash' | 'coinbase' | 'timestamp' | 'number' | 'difficulty' | 'gaslimit'
-	| 'basefee';
+	| 'blockhash' | 'blobhash' | 'coinbase' | 'timestamp' | 'number' | 'difficulty'
+	| 'prevrandao' | 'gaslimit' | 'basefee' | 'blobbasefee';
 
 YulLBrace: '{' -> pushMode(YulMode);
 YulRBrace: '}' -> popMode;
diff --git a/compiler/docs/grammar/SolidityParser.g4 b/compiler/docs/grammar/SolidityParser.g4
index 92718b97..4a756029 100644
--- a/compiler/docs/grammar/SolidityParser.g4
+++ b/compiler/docs/grammar/SolidityParser.g4
@@ -22,6 +22,7 @@ sourceUnit: (
 	| enumDefinition
 	| userDefinedValueTypeDefinition
 	| errorDefinition
+	| eventDefinition
 )* EOF;
 
 //@doc: inline
@@ -152,7 +153,7 @@ stateMutability: Pure | View | Payable;
  */
 overrideSpecifier: Override (LParen overrides+=identifierPath (Comma overrides+=identifierPath)* RParen)?;
 /**
- * The definition of contract, library and interface functions.
+ * The definition of contract, library, interface or free functions.
  * Depending on the context in which the function is defined, further restrictions may apply,
  * e.g. functions in interfaces have to be unimplemented, i.e. may not contain a body block.
  */
@@ -161,7 +162,7 @@ locals[
 	boolean visibilitySet = false,
 	boolean mutabilitySet = false,
 	boolean virtualSet = false,
-	boolean overrideSpecifierSet = false
+	boolean overrideSpecifierSet = false,
 ]
 :
 	Function (identifier | Fallback | Receive)
@@ -175,6 +176,7 @@ locals[
 	 )*
 	(Returns LParen returnParameters=parameterList RParen)?
 	(Semicolon | body=block);
+
 /**
  * The definition of a modifier.
  * Note that within the body block of a modifier, the underscore cannot be used as identifier,
@@ -312,10 +314,30 @@ errorDefinition:
 	Semicolon;
 
 /**
- * Using directive to bind library functions and free functions to types.
+ * Operators that users are allowed to implement for some types with `using for`.
+ */
+userDefinableOperator:
+	BitAnd
+	| BitNot
+	| BitOr
+	| BitXor
+	| Add
+	| Div
+	| Mod
+	| Mul
+	| Sub
+	| Equal
+	| GreaterThan
+	| GreaterThanOrEqual
+	| LessThan
+	| LessThanOrEqual
+	| NotEqual;
+
+/**
+ * Using directive to attach library functions and free functions to types.
  * Can occur within contracts and libraries and at the file level.
  */
-usingDirective: Using (identifierPath | (LBrace identifierPath (Comma identifierPath)* RBrace)) For (Mul | typeName) Global? Semicolon;
+usingDirective: Using (identifierPath | (LBrace identifierPath (As userDefinableOperator)? (Comma identifierPath (As userDefinableOperator)?)* RBrace)) For (Mul | typeName) Global? Semicolon;
 /**
  * A type name can be an elementary type, a function type, a mapping type, a user-defined type
  * (e.g. a contract or struct) or an array type.
@@ -347,7 +369,7 @@ dataLocation: Memory | Storage | Calldata;
  */
 expression:
 	expression LBrack index=expression? RBrack # IndexAccess
-	| expression LBrack start=expression? Colon end=expression? RBrack # IndexRangeAccess
+	| expression LBrack startIndex=expression? Colon endIndex=expression? RBrack # IndexRangeAccess
 	| expression Period (identifier | Address) # MemberAccess
 	| expression LBrace (namedArgument (Comma namedArgument)*)? RBrace # FunctionCallOptions
 	| expression callArgumentList # FunctionCall
@@ -368,12 +390,13 @@ expression:
 	| expression Or expression # OrOperation
 	|<assoc=right> expression Conditional expression Colon expression # Conditional
 	|<assoc=right> expression assignOp expression # Assignment
-	| New typeName # NewExpression
+	| New typeName # NewExpr
 	| tupleExpression # Tuple
 	| inlineArrayExpression # InlineArray
  	| (
 		identifier
 		| literal
+		| literalWithSubDenomination
 		| elementaryTypeName[false]
 	  ) # PrimaryExpression
 ;
@@ -392,6 +415,9 @@ inlineArrayExpression: LBrack (expression ( Comma expression)* ) RBrack;
 identifier: Identifier | From | Error | Revert | Global;
 
 literal: stringLiteral | numberLiteral | booleanLiteral | hexStringLiteral | unicodeStringLiteral;
+
+literalWithSubDenomination: numberLiteral SubDenomination;
+
 booleanLiteral: True | False;
 /**
  * A full string literal consists of either one or several consecutive quoted strings.
@@ -409,7 +435,8 @@ unicodeStringLiteral: UnicodeStringLiteral+;
 /**
  * Number literals can be decimal or hexadecimal numbers with an optional unit.
  */
-numberLiteral: (DecimalNumber | HexNumber) NumberUnit?;
+numberLiteral: DecimalNumber | HexNumber;
+
 /**
  * A curly-braced block of statements. Opens its own scope.
  */
@@ -504,7 +531,7 @@ variableDeclarationTuple:
 variableDeclarationStatement: ((variableDeclaration (Assign expression)?) | (variableDeclarationTuple Assign expression)) Semicolon;
 expressionStatement: expression Semicolon;
 
-mappingType: Mapping LParen key=mappingKeyType DoubleArrow value=typeName RParen;
+mappingType: Mapping LParen key=mappingKeyType name=identifier? DoubleArrow value=typeName name=identifier? RParen;
 /**
  * Only elementary types or user defined types are viable as mapping keys.
  */
diff --git a/compiler/docs/index.rst b/compiler/docs/index.rst
index 7576b363..600173d6 100644
--- a/compiler/docs/index.rst
+++ b/compiler/docs/index.rst
@@ -1,38 +1,35 @@
 Solidity
 ========
 
-Solidity is an object-oriented, high-level language for implementing smart
-contracts. Smart contracts are programs which govern the behaviour of accounts
-within the Ethereum state.
+Solidity is an object-oriented, high-level language for implementing smart contracts.
+Smart contracts are programs that govern the behavior of accounts within the Ethereum state.
 
 Solidity is a `curly-bracket language <https://en.wikipedia.org/wiki/List_of_programming_languages_by_type#Curly-bracket_languages>`_ designed to target the Ethereum Virtual Machine (EVM).
-It is influenced by C++, Python and JavaScript. You can find more details about which languages Solidity has been inspired by in the :doc:`language influences <language-influences>` section.
+It is influenced by C++, Python, and JavaScript.
+You can find more details about which languages Solidity has been inspired by in the :doc:`language influences <language-influences>` section.
 
-Solidity is statically typed, supports inheritance, libraries and complex
-user-defined types among other features.
+Solidity is statically typed, supports inheritance, libraries, and complex user-defined types, among other features.
 
-With Solidity you can create contracts for uses such as voting, crowdfunding, blind auctions,
-and multi-signature wallets.
+With Solidity, you can create contracts for uses such as voting, crowdfunding, blind auctions, and multi-signature wallets.
 
-When deploying contracts, you should use the latest released
-version of Solidity. Apart from exceptional cases, only the latest version receives
+When deploying contracts, you should use the latest released version of Solidity.
+Apart from exceptional cases, only the latest version receives
 `security fixes <https://github.com/ethereum/solidity/security/policy#supported-versions>`_.
-Furthermore, breaking changes as well as
-new features are introduced regularly. We currently use
-a 0.y.z version number `to indicate this fast pace of change <https://semver.org/#spec-item-4>`_.
+Furthermore, breaking changes, as well as new features, are introduced regularly.
+We currently use a 0.y.z version number `to indicate this fast pace of change <https://semver.org/#spec-item-4>`_.
 
 .. warning::
 
-  Solidity recently released the 0.8.x version that introduced a lot of breaking
-  changes. Make sure you read :doc:`the full list <080-breaking-changes>`.
+  Solidity recently released the 0.8.x version that introduced a lot of breaking changes.
+  Make sure you read :doc:`the full list <080-breaking-changes>`.
 
 Ideas for improving Solidity or this documentation are always welcome,
 read our :doc:`contributors guide <contributing>` for more details.
 
 .. Hint::
 
-  You can download this documentation as PDF, HTML or Epub by clicking on the versions
-  flyout menu in the bottom-left corner and selecting the preferred download format.
+  You can download this documentation as PDF, HTML or Epub
+  by clicking on the versions flyout menu in the bottom-left corner and selecting the preferred download format.
 
 
 Getting Started
@@ -40,8 +37,7 @@ Getting Started
 
 **1. Understand the Smart Contract Basics**
 
-If you are new to the concept of smart contracts we recommend you to get started by digging
-into the "Introduction to Smart Contracts" section, which covers:
+If you are new to the concept of smart contracts, we recommend you to get started by digging into the "Introduction to Smart Contracts" section, which covers the following:
 
 * :ref:`A simple example smart contract <simple-smart-contract>` written in Solidity.
 * :ref:`Blockchain Basics <blockchain-basics>`.
@@ -59,29 +55,27 @@ simply choose your preferred option and follow the steps outlined on the :ref:`i
 
 .. hint::
   You can try out code examples directly in your browser with the
-  `Remix IDE <https://remix.ethereum.org>`_. Remix is a web browser based IDE
-  that allows you to write, deploy and administer Solidity smart contracts, without
-  the need to install Solidity locally.
+  `Remix IDE <https://remix.ethereum.org>`_.
+  Remix is a web browser-based IDE that allows you to write, deploy and administer Solidity smart contracts,
+  without the need to install Solidity locally.
 
 .. warning::
-    As humans write software, it can have bugs. You should follow established
-    software development best-practices when writing your smart contracts. This
-    includes code review, testing, audits, and correctness proofs. Smart contract
-    users are sometimes more confident with code than their authors, and
-    blockchains and smart contracts have their own unique issues to
-    watch out for, so before working on production code, make sure you read the
-    :ref:`security_considerations` section.
+    As humans write software, it can have bugs.
+    Therefore, you should follow established software development best practices when writing your smart contracts.
+    This includes code review, testing, audits, and correctness proofs.
+    Smart contract users are sometimes more confident with code than their authors,
+    and blockchains and smart contracts have their own unique issues to watch out for,
+    so before working on production code, make sure you read the :ref:`security_considerations` section.
 
 **4. Learn More**
 
-If you want to learn more about building decentralized applications on Ethereum, the
-`Ethereum Developer Resources <https://ethereum.org/en/developers/>`_
-can help you with further general documentation around Ethereum, and a wide selection of tutorials,
-tools and development frameworks.
+If you want to learn more about building decentralized applications on Ethereum,
+the `Ethereum Developer Resources <https://ethereum.org/en/developers/>`_ can help you with further general documentation around Ethereum,
+and a wide selection of tutorials, tools, and development frameworks.
 
 If you have any questions, you can try searching for answers or asking on the
-`Ethereum StackExchange <https://ethereum.stackexchange.com/>`_, or
-our `Gitter channel <https://gitter.im/ethereum/solidity/>`_.
+`Ethereum StackExchange <https://ethereum.stackexchange.com/>`_,
+or our `Gitter channel <https://gitter.im/ethereum/solidity>`_.
 
 .. _translations:
 
@@ -89,23 +83,26 @@ Translations
 ------------
 
 Community contributors help translate this documentation into several languages.
-Note that they have varying degrees of completeness and up-to-dateness. The English
-version stands as a reference.
+Note that they have varying degrees of completeness and up-to-dateness.
+The English version stands as a reference.
 
 You can switch between languages by clicking on the flyout menu in the bottom-left corner
 and selecting the preferred language.
 
+* `Chinese <https://docs.soliditylang.org/zh/latest/>`_
 * `French <https://docs.soliditylang.org/fr/latest/>`_
 * `Indonesian <https://github.com/solidity-docs/id-indonesian>`_
-* `Persian <https://github.com/solidity-docs/fa-persian>`_
 * `Japanese <https://github.com/solidity-docs/ja-japanese>`_
 * `Korean <https://github.com/solidity-docs/ko-korean>`_
-* `Chinese <https://github.com/solidity-docs/zh-cn-chinese/>`_
+* `Persian <https://github.com/solidity-docs/fa-persian>`_
+* `Russian <https://github.com/solidity-docs/ru-russian>`_
+* `Spanish <https://github.com/solidity-docs/es-spanish>`_
+* `Turkish <https://docs.soliditylang.org/tr/latest/>`_
 
 .. note::
 
-   We recently set up a new GitHub organization and translation workflow to help streamline the
-   community efforts. Please refer to the `translation guide <https://github.com/solidity-docs/translation-guide>`_
+   We set up a GitHub organization and translation workflow to help streamline the community efforts.
+   Please refer to the translation guide in the `solidity-docs org <https://github.com/solidity-docs>`_
    for information on how to start a new language or contribute to the community translations.
 
 Contents
@@ -118,8 +115,8 @@ Contents
    :caption: Basics
 
    introduction-to-smart-contracts.rst
-   installing-solidity.rst
    solidity-by-example.rst
+   installing-solidity.rst
 
 .. toctree::
    :maxdepth: 2
@@ -158,21 +155,31 @@ Contents
 
 .. toctree::
    :maxdepth: 2
-   :caption: Additional Material
+   :caption: Advisory content
 
+   security-considerations.rst
+   bugs.rst
    050-breaking-changes.rst
    060-breaking-changes.rst
    070-breaking-changes.rst
    080-breaking-changes.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Additional Material
+
    natspec-format.rst
-   security-considerations.rst
    smtchecker.rst
-   resources.rst
-   path-resolution.rst
    yul.rst
+   path-resolution.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Resources
+
    style-guide.rst
    common-patterns.rst
-   bugs.rst
+   resources.rst
    contributing.rst
-   brand-guide.rst
    language-influences.rst
+   brand-guide.rst
diff --git a/compiler/docs/installing-solidity.rst b/compiler/docs/installing-solidity.rst
index 9a613d75..2f048fe3 100644
--- a/compiler/docs/installing-solidity.rst
+++ b/compiler/docs/installing-solidity.rst
@@ -10,12 +10,12 @@ Versioning
 ==========
 
 Solidity versions follow `Semantic Versioning <https://semver.org>`_. In
-addition, patch level releases with major release 0 (i.e. 0.x.y) will not
+addition, patch-level releases with major release 0 (i.e. 0.x.y) will not
 contain breaking changes. That means code that compiles with version 0.x.y
 can be expected to compile with 0.x.z where z > y.
 
-In addition to releases, we provide **nightly development builds** with the
-intention of making it easy for developers to try out upcoming features and
+In addition to releases, we provide **nightly development builds** to make
+it easy for developers to try out upcoming features and
 provide early feedback. Note, however, that while the nightly builds are usually
 very stable, they contain bleeding-edge code from the development branch and are
 not guaranteed to be always working. Despite our best efforts, they might
@@ -33,12 +33,12 @@ Remix
 
 `Access Remix online <https://remix.ethereum.org/>`_, you do not need to install anything.
 If you want to use it without connection to the Internet, go to
-https://github.com/ethereum/remix-live/tree/gh-pages and download the ``.zip`` file as
-explained on that page. Remix is also a convenient option for testing nightly builds
+https://github.com/ethereum/remix-live/tree/gh-pages#readme and follow the instructions on that page.
+Remix is also a convenient option for testing nightly builds
 without installing multiple Solidity versions.
 
-Further options on this page detail installing commandline Solidity compiler software
-on your computer. Choose a commandline compiler if you are working on a larger contract
+Further options on this page detail installing command-line Solidity compiler software
+on your computer. Choose a command-line compiler if you are working on a larger contract
 or if you require more compilation options.
 
 .. _solcjs:
@@ -54,7 +54,7 @@ the full-featured compiler, ``solc``. The usage of ``solcjs`` is documented insi
 `repository <https://github.com/ethereum/solc-js>`_.
 
 Note: The solc-js project is derived from the C++
-`solc` by using Emscripten which means that both use the same compiler source code.
+`solc` by using Emscripten, which means that both use the same compiler source code.
 `solc-js` can be used in JavaScript projects directly (such as Remix).
 Please refer to the solc-js repository for instructions.
 
@@ -64,18 +64,18 @@ Please refer to the solc-js repository for instructions.
 
 .. note::
 
-    The commandline executable is named ``solcjs``.
+    The command-line executable is named ``solcjs``.
 
-    The commandline options of ``solcjs`` are not compatible with ``solc`` and tools (such as ``geth``)
-    expecting the behaviour of ``solc`` will not work with ``solcjs``.
+    The command-line options of ``solcjs`` are not compatible with ``solc`` and tools (such as ``geth``)
+    expecting the behavior of ``solc`` will not work with ``solcjs``.
 
 Docker
 ======
 
-Docker images of Solidity builds are available using the ``solc`` image from the ``ethereum`` organisation.
-Use the ``stable`` tag for the latest released version, and ``nightly`` for potentially unstable changes in the develop branch.
+Docker images of Solidity builds are available using the ``solc`` image from the ``ethereum`` organization.
+Use the ``stable`` tag for the latest released version, and ``nightly`` for potentially unstable changes in the ``develop`` branch.
 
-The Docker image runs the compiler executable, so you can pass all compiler arguments to it.
+The Docker image runs the compiler executable so that you can pass all compiler arguments to it.
 For example, the command below pulls the stable version of the ``solc`` image (if you do not have it already),
 and runs it in a new container, passing the ``--help`` argument.
 
@@ -83,13 +83,13 @@ and runs it in a new container, passing the ``--help`` argument.
 
     docker run ethereum/solc:stable --help
 
-You can also specify release build versions in the tag, for example, for the 0.5.4 release.
+For example, You can specify release build versions in the tag for the 0.5.4 release.
 
 .. code-block:: bash
 
     docker run ethereum/solc:0.5.4 --help
 
-To use the Docker image to compile Solidity files on the host machine mount a
+To use the Docker image to compile Solidity files on the host machine, mount a
 local folder for input and output, and specify the contract to compile. For example.
 
 .. code-block:: bash
@@ -97,7 +97,7 @@ local folder for input and output, and specify the contract to compile. For exam
     docker run -v /local/path:/sources ethereum/solc:stable -o /sources/output --abi --bin /sources/Contract.sol
 
 You can also use the standard JSON interface (which is recommended when using the compiler with tooling).
-When using this interface it is not necessary to mount any directories as long as the JSON input is
+When using this interface, it is not necessary to mount any directories as long as the JSON input is
 self-contained (i.e. it does not refer to any external files that would have to be
 :ref:`loaded by the import callback <initial-vfs-content-standard-json-with-import-callback>`).
 
@@ -130,13 +130,15 @@ The nightly version can be installed using these commands:
     sudo apt-get install solc
 
 Furthermore, some Linux distributions provide their own packages. These packages are not directly
-maintained by us, but usually kept up-to-date by the respective package maintainers.
+maintained by us but usually kept up-to-date by the respective package maintainers.
 
-For example, Arch Linux has packages for the latest development version:
+For example, Arch Linux has packages for the latest development version as AUR packages: `solidity <https://aur.archlinux.org/packages/solidity>`_
+and `solidity-bin <https://aur.archlinux.org/packages/solidity-bin>`_.
 
-.. code-block:: bash
+.. note::
 
-    pacman -S solidity
+    Please be aware that `AUR <https://wiki.archlinux.org/title/Arch_User_Repository>`_ packages
+    are user-produced content and unofficial packages. Exercise caution when using them.
 
 There is also a `snap package <https://snapcraft.io/solc>`_, however, it is **currently unmaintained**.
 It is installable in all the `supported Linux distros <https://snapcraft.io/docs/core/install>`_. To
@@ -212,12 +214,12 @@ out-of-the-box but it is also meant to be friendly to third-party tools:
   HTTPS without any authentication, rate limiting or the need to use git.
 - Content is served with correct `Content-Type` headers and lenient CORS configuration so that it
   can be directly loaded by tools running in the browser.
-- Binaries do not require installation or unpacking (with the exception of older Windows builds
+- Binaries do not require installation or unpacking (exception for older Windows builds
   bundled with necessary DLLs).
-- We strive for a high level of backwards-compatibility. Files, once added, are not removed or moved
+- We strive for a high level of backward-compatibility. Files, once added, are not removed or moved
   without providing a symlink/redirect at the old location. They are also never modified
   in place and should always match the original checksum. The only exception would be broken or
-  unusable files with a potential to cause more harm than good if left as is.
+  unusable files with the potential to cause more harm than good if left as is.
 - Files are served over both HTTP and HTTPS. As long as you obtain the file list in a secure way
   (via git, HTTPS, IPFS or just have it cached locally) and verify hashes of the binaries
   after downloading them, you do not have to use HTTPS for the binaries themselves.
@@ -228,7 +230,7 @@ that we do not rename them if the naming convention changes and we do not add bu
 that were not supported at the time of release. This only happens in ``solc-bin``.
 
 The ``solc-bin`` repository contains several top-level directories, each representing a single platform.
-Each one contains a ``list.json`` file listing the available binaries. For example in
+Each one includes a ``list.json`` file listing the available binaries. For example in
 ``emscripten-wasm32/list.json`` you will find the following information about version 0.7.4:
 
 .. code-block:: json
@@ -259,7 +261,7 @@ This means that:
 - The file might in future be available on Swarm at `16c5f09109c793db99fe35f037c6092b061bd39260ee7a677c8a97f18c955ab1`_.
 - You can verify the integrity of the binary by comparing its keccak256 hash to
   ``0x300330ecd127756b824aa13e843cb1f43c473cb22eaf3750d5fb9c99279af8c3``.  The hash can be computed
-  on the command line using ``keccak256sum`` utility provided by `sha3sum`_ or `keccak256() function
+  on the command-line using ``keccak256sum`` utility provided by `sha3sum`_ or `keccak256() function
   from ethereumjs-util`_ in JavaScript.
 - You can also verify the integrity of the binary by comparing its sha256 hash to
   ``0x2b55ed5fec4d9625b6c7b3ab1abd2b7fb7dd2a9c68543bf0323db2c7e2d55af2``.
@@ -310,7 +312,6 @@ This means that:
 
 Building from Source
 ====================
-
 Prerequisites - All Operating Systems
 -------------------------------------
 
@@ -319,14 +320,15 @@ The following are dependencies for all builds of Solidity:
 +-----------------------------------+-------------------------------------------------------+
 | Software                          | Notes                                                 |
 +===================================+=======================================================+
-| `CMake`_ (version 3.13+)          | Cross-platform build file generator.                  |
+| `CMake`_ (version 3.21.3+ on      | Cross-platform build file generator.                  |
+| Windows, 3.13+ otherwise)         |                                                       |
 +-----------------------------------+-------------------------------------------------------+
 | `Boost`_ (version 1.77+ on        | C++ libraries.                                        |
 | Windows, 1.65+ otherwise)         |                                                       |
 +-----------------------------------+-------------------------------------------------------+
 | `Git`_                            | Command-line tool for retrieving source code.         |
 +-----------------------------------+-------------------------------------------------------+
-| `z3`_ (version 4.8+, Optional)    | For use with SMT checker.                             |
+| `z3`_ (version 4.8.16+, Optional) | For use with SMT checker.                             |
 +-----------------------------------+-------------------------------------------------------+
 | `cvc4`_ (Optional)                | For use with SMT checker.                             |
 +-----------------------------------+-------------------------------------------------------+
@@ -340,7 +342,7 @@ The following are dependencies for all builds of Solidity:
 .. note::
     Solidity versions prior to 0.5.10 can fail to correctly link against Boost versions 1.70+.
     A possible workaround is to temporarily rename ``<Boost install path>/lib/cmake/Boost-1.70.0``
-    prior to running the cmake command to configure solidity.
+    prior to running the cmake command to configure Solidity.
 
     Starting from 0.5.10 linking against Boost 1.70+ should work without manual intervention.
 
@@ -378,7 +380,7 @@ Prerequisites - macOS
 ---------------------
 
 For macOS builds, ensure that you have the latest version of
-`Xcode installed <https://developer.apple.com/xcode/download/>`_.
+`Xcode installed <https://developer.apple.com/xcode/resources/>`_.
 This contains the `Clang C++ compiler <https://en.wikipedia.org/wiki/Clang>`_, the
 `Xcode IDE <https://en.wikipedia.org/wiki/Xcode>`_ and other Apple development
 tools that are required for building C++ applications on OS X.
@@ -428,7 +430,7 @@ in Visual Studio 2019 Build Tools or Visual Studio 2019:
 * C++/CLI support
 
 .. _Visual Studio 2019: https://www.visualstudio.com/vs/
-.. _Visual Studio 2019 Build Tools: https://www.visualstudio.com/downloads/#build-tools-for-visual-studio-2019
+.. _Visual Studio 2019 Build Tools: https://visualstudio.microsoft.com/vs/older-downloads/#visual-studio-2019-and-other-products
 
 We have a helper script which you can use to install all required external dependencies:
 
@@ -448,7 +450,7 @@ To clone the source code, execute the following command:
     git clone --recursive https://github.com/ethereum/solidity.git
     cd solidity
 
-If you want to help developing Solidity,
+If you want to help develop Solidity,
 you should fork Solidity and add your personal fork as a second remote:
 
 .. code-block:: bash
@@ -456,7 +458,7 @@ you should fork Solidity and add your personal fork as a second remote:
     git remote add personal git@github.com:[username]/solidity.git
 
 .. note::
-    This method will result in a prerelease build leading to e.g. a flag
+    This method will result in a pre-release build leading to e.g. a flag
     being set in each bytecode produced by such a compiler.
     If you want to re-build a released Solidity compiler, then
     please use the source tarball on the github release page:
@@ -526,7 +528,7 @@ If you are interested what CMake options are available run ``cmake .. -LH``.
 SMT Solvers
 -----------
 Solidity can be built against SMT solvers and will do so by default if
-they are found in the system. Each solver can be disabled by a `cmake` option.
+they are found in the system. Each solver can be disabled by a ``cmake`` option.
 
 *Note: In some cases, this can also be a potential workaround for build failures.*
 
@@ -579,4 +581,4 @@ Example:
 4. A breaking change is introduced --> version is bumped to 0.5.0.
 5. The 0.5.0 release is made.
 
-This behaviour works well with the  :ref:`version pragma <version_pragma>`.
+This behavior works well with the  :ref:`version pragma <version_pragma>`.
diff --git a/compiler/docs/internals/layout_in_storage.rst b/compiler/docs/internals/layout_in_storage.rst
index 53670eeb..7afcfc2a 100644
--- a/compiler/docs/internals/layout_in_storage.rst
+++ b/compiler/docs/internals/layout_in_storage.rst
@@ -208,7 +208,7 @@ of types), arrays have its ``base`` type, and structs list their ``members`` in
 the same format as the top-level ``storage`` (see :ref:`above
 <storage-layout-top-level>`).
 
-.. note ::
+.. note::
   The JSON output format of a contract's storage layout is still considered experimental
   and is subject to change in non-breaking releases of Solidity.
 
@@ -232,7 +232,7 @@ value and reference types, types that are encoded packed, and nested types.
         uint y;
         S s;
         address addr;
-        mapping (uint => mapping (address => bool)) map;
+        mapping(uint => mapping(address => bool)) map;
         uint[] array;
         string s1;
         bytes b1;
diff --git a/compiler/docs/internals/optimizer.rst b/compiler/docs/internals/optimizer.rst
index 3c12f0ad..70896333 100644
--- a/compiler/docs/internals/optimizer.rst
+++ b/compiler/docs/internals/optimizer.rst
@@ -5,8 +5,11 @@
 The Optimizer
 *************
 
-The Solidity compiler uses two different optimizer modules: The "old" optimizer
-that operates at the opcode level and the "new" optimizer that operates on Yul IR code.
+The Solidity compiler involves optimizations at three different levels (in order of execution):
+
+- Optimizations during code generation based on a direct analysis of Solidity code.
+- Optimizing transformations on the Yul IR code.
+- Optimizations at the opcode level.
 
 The opcode-based optimizer applies a set of `simplification rules <https://github.com/ethereum/solidity/blob/develop/libevmasm/RuleList.h>`_
 to opcodes. It also combines equal code sets and removes unused code.
@@ -20,6 +23,17 @@ the function calls. Similarly, if a function is
 side-effect free and its result is multiplied by zero, you can remove the function
 call completely.
 
+The codegen-based optimizer affects the initial low-level code produced from the Solidity input.
+In the legacy pipeline, the bytecode is generated immediately and most of the optimizations of this
+kind are implicit and not configurable, the only exception being an optimization which changes the
+order of literals in binary operations.
+The IR-based pipeline takes a different approach and produces Yul IR closely matching the structure
+of the Solidity code, with nearly all optimizations deferred to the Yul optimizer module.
+In that case codegen-level optimization is done only in very limited cases which are difficult to
+handle in Yul IR, but are straightforward with the high-level information from analysis phase at hand.
+An example of such an optimization is the bypass of checked arithmetic when incrementing the counter
+in certain idiomatic ``for`` loops.
+
 Currently, the parameter ``--optimize`` activates the opcode-based optimizer for the
 generated bytecode and the Yul optimizer for the Yul code generated internally, for example for ABI coder v2.
 One can use ``solc --ir-optimized --optimize`` to produce an
@@ -27,9 +41,15 @@ optimized Yul IR for a Solidity source. Similarly, one can use ``solc --strict-a
 for a stand-alone Yul mode.
 
 .. note::
-    The `peephole optimizer <https://en.wikipedia.org/wiki/Peephole_optimization>`_ and the inliner are always
+    Some optimizer steps, such as, for example, the `peephole optimizer <https://en.wikipedia.org/wiki/Peephole_optimization>`_
+    and the :ref:`unchecked loop increment optimizer <unchecked-loop-optimizer>` are always
     enabled by default and can only be turned off via the :ref:`Standard JSON <compiler-api>`.
 
+.. note::
+    An empty optimizer sequence is accepted even without ``--optimize`` in order to fully disable
+    the user-supplied portion of the Yul :ref:`optimizer sequence <selecting-optimizations>`, as by default,
+    even when the optimizer is not turned on, the :ref:`unused pruner <unused-pruner>` step will be run.
+
 You can find more details on both optimizer modules and their optimization steps below.
 
 Benefits of Optimizing Solidity Code
@@ -281,60 +301,82 @@ The following transformation steps are the main components:
 - Redundant Assign Eliminator
 - Full Inliner
 
+.. _optimizer-steps:
+
 Optimizer Steps
 ---------------
 
 This is a list of all steps the Yul-based optimizer sorted alphabetically. You can find more information
 on the individual steps and their sequence below.
 
-- :ref:`block-flattener`.
-- :ref:`circular-reference-pruner`.
-- :ref:`common-subexpression-eliminator`.
-- :ref:`conditional-simplifier`.
-- :ref:`conditional-unsimplifier`.
-- :ref:`control-flow-simplifier`.
-- :ref:`dead-code-eliminator`.
-- :ref:`equal-store-eliminator`.
-- :ref:`equivalent-function-combiner`.
-- :ref:`expression-joiner`.
-- :ref:`expression-simplifier`.
-- :ref:`expression-splitter`.
-- :ref:`for-loop-condition-into-body`.
-- :ref:`for-loop-condition-out-of-body`.
-- :ref:`for-loop-init-rewriter`.
-- :ref:`expression-inliner`.
-- :ref:`full-inliner`.
-- :ref:`function-grouper`.
-- :ref:`function-hoister`.
-- :ref:`function-specializer`.
-- :ref:`literal-rematerialiser`.
-- :ref:`load-resolver`.
-- :ref:`loop-invariant-code-motion`.
-- :ref:`redundant-assign-eliminator`.
-- :ref:`reasoning-based-simplifier`.
-- :ref:`rematerialiser`.
-- :ref:`SSA-reverser`.
-- :ref:`SSA-transform`.
-- :ref:`structural-simplifier`.
-- :ref:`unused-function-parameter-pruner`.
-- :ref:`unused-pruner`.
-- :ref:`var-decl-initializer`.
+============ ===============================
+Abbreviation Full name
+============ ===============================
+``f``        :ref:`block-flattener`
+``l``        :ref:`circular-reference-pruner`
+``c``        :ref:`common-subexpression-eliminator`
+``C``        :ref:`conditional-simplifier`
+``U``        :ref:`conditional-unsimplifier`
+``n``        :ref:`control-flow-simplifier`
+``D``        :ref:`dead-code-eliminator`
+``E``        :ref:`equal-store-eliminator`
+``v``        :ref:`equivalent-function-combiner`
+``e``        :ref:`expression-inliner`
+``j``        :ref:`expression-joiner`
+``s``        :ref:`expression-simplifier`
+``x``        :ref:`expression-splitter`
+``I``        :ref:`for-loop-condition-into-body`
+``O``        :ref:`for-loop-condition-out-of-body`
+``o``        :ref:`for-loop-init-rewriter`
+``i``        :ref:`full-inliner`
+``g``        :ref:`function-grouper`
+``h``        :ref:`function-hoister`
+``F``        :ref:`function-specializer`
+``T``        :ref:`literal-rematerialiser`
+``L``        :ref:`load-resolver`
+``M``        :ref:`loop-invariant-code-motion`
+``r``        :ref:`redundant-assign-eliminator`
+``m``        :ref:`rematerialiser`
+``V``        :ref:`SSA-reverser`
+``a``        :ref:`SSA-transform`
+``t``        :ref:`structural-simplifier`
+``p``        :ref:`unused-function-parameter-pruner`
+``S``        :ref:`unused-store-eliminator`
+``u``        :ref:`unused-pruner`
+``d``        :ref:`var-decl-initializer`
+============ ===============================
+
+Some steps depend on properties ensured by ``BlockFlattener``, ``FunctionGrouper``, ``ForLoopInitRewriter``.
+For this reason the Yul optimizer always applies them before applying any steps supplied by the user.
+
+.. _selecting-optimizations:
 
 Selecting Optimizations
 -----------------------
 
-By default the optimizer applies its predefined sequence of optimization steps to
-the generated assembly. You can override this sequence and supply your own using
-the ``--yul-optimizations`` option:
+By default the optimizer applies its predefined sequence of optimization steps to the generated assembly.
+You can override this sequence and supply your own using the ``--yul-optimizations`` option:
 
 .. code-block:: bash
 
-    solc --optimize --ir-optimized --yul-optimizations 'dhfoD[xarrscLMcCTU]uljmul'
+    solc --optimize --ir-optimized --yul-optimizations 'dhfoD[xarrscLMcCTU]uljmul:fDnTOcmu'
+
+The order of steps is significant and affects the quality of the output.
+Moreover, applying a step may uncover new optimization opportunities for others that were already applied,
+so repeating steps is often beneficial.
 
 The sequence inside ``[...]`` will be applied multiple times in a loop until the Yul code
 remains unchanged or until the maximum number of rounds (currently 12) has been reached.
+Brackets (``[]``) may be used multiple times in a sequence, but can not be nested.
+
+An important thing to note, is that there are some hardcoded steps that are always run before and after the
+user-supplied sequence, or the default sequence if one was not supplied by the user.
 
-Available abbreviations are listed in the :ref:`Yul optimizer docs <optimization-step-sequence>`.
+The cleanup sequence delimiter ``:`` is optional, and is used to supply a custom cleanup sequence
+in order to replace the default one. If omitted, the optimizer will simply apply the default cleanup
+sequence. In addition, the delimiter may be placed at the beginning of the user-supplied sequence,
+which will result in the optimization sequence being empty, whereas conversely, if placed at the end of
+the sequence, will be treated as an empty cleanup sequence.
 
 Preprocessing
 -------------
@@ -549,7 +591,7 @@ It is not applied to loop iteration-condition, because the loop control flow doe
 this "outlining" of the inner expressions in all cases. We can sidestep this limitation by applying
 :ref:`for-loop-condition-into-body` to move the iteration condition into loop body.
 
-The final program should be in a form such that (with the exception of loop conditions)
+The final program should be in an *expression-split form*, where (with the exception of loop conditions)
 function calls cannot appear nested inside expressions
 and all function call arguments have to be variables.
 
@@ -800,10 +842,10 @@ if the common subexpression eliminator was run right before it.
 
 .. _expression-simplifier:
 
-Expression Simplifier
-^^^^^^^^^^^^^^^^^^^^^
+ExpressionSimplifier
+^^^^^^^^^^^^^^^^^^^^
 
-The Expression Simplifier uses the Dataflow Analyzer and makes use
+The ExpressionSimplifier uses the Dataflow Analyzer and makes use
 of a list of equivalence transforms on expressions like ``X + 0 -> X``
 to simplify the code.
 
@@ -837,22 +879,6 @@ Works best if the code is in SSA form.
 
 Prerequisite: Disambiguator, ForLoopInitRewriter.
 
-.. _reasoning-based-simplifier:
-
-ReasoningBasedSimplifier
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-This optimizer uses SMT solvers to check whether ``if`` conditions are constant.
-
-- If ``constraints AND condition`` is UNSAT, the condition is never true and the whole body can be removed.
-- If ``constraints AND NOT condition`` is UNSAT, the condition is always true and can be replaced by ``1``.
-
-The simplifications above can only be applied if the condition is movable.
-
-It is only effective on the EVM dialect, but safe to use on other dialects.
-
-Prerequisite: Disambiguator, SSATransform.
-
 Statement-Scale Simplifications
 -------------------------------
 
@@ -933,7 +959,7 @@ DeadCodeEliminator
 This optimization stage removes unreachable code.
 
 Unreachable code is any code within a block which is preceded by a
-leave, return, invalid, break, continue, selfdestruct or revert.
+leave, return, invalid, break, continue, selfdestruct, revert or by a call to a user-defined function that recurses infinitely.
 
 Function definitions are retained as they might be called by earlier
 code and thus are considered reachable.
@@ -1096,6 +1122,52 @@ The step LiteralRematerialiser is not required for correctness. It helps deal wi
 ``function f(x) -> y { revert(y, y} }`` where the literal ``y`` will be replaced by its value ``0``,
 allowing us to rewrite the function.
 
+.. index:: ! unused store eliminator
+.. _unused-store-eliminator:
+
+UnusedStoreEliminator
+^^^^^^^^^^^^^^^^^^^^^
+
+Optimizer component that removes redundant ``sstore`` and memory store statements.
+In case of an ``sstore``, if all outgoing code paths revert (due to an explicit ``revert()``, ``invalid()``, or infinite recursion) or
+lead to another ``sstore`` for which the optimizer can tell that it will overwrite the first store, the statement will be removed.
+However, if there is a read operation between the initial ``sstore`` and the revert, or the overwriting ``sstore``, the statement
+will not be removed.
+Such read operations include: external calls, user-defined functions with any storage access, and ``sload`` of a slot that cannot be
+proven to differ from the slot written by the initial ``sstore``.
+
+For example, the following code
+
+.. code-block:: yul
+
+    {
+        let c := calldataload(0)
+        sstore(c, 1)
+        if c {
+            sstore(c, 2)
+        }
+        sstore(c, 3)
+    }
+
+will be transformed into the code below after the Unused Store Eliminator step is run
+
+.. code-block:: yul
+
+    {
+        let c := calldataload(0)
+        if c { }
+        sstore(c, 3)
+    }
+
+For memory store operations, things are generally simpler, at least in the outermost yul block as all such
+statements will be removed if they are never read from in any code path.
+At function analysis level, however, the approach is similar to ``sstore``, as we do not know whether the memory location will
+be read once we leave the function's scope, so the statement will be removed only if all code paths lead to a memory overwrite.
+
+Best run in SSA form.
+
+Prerequisites: Disambiguator, ForLoopInitRewriter.
+
 .. _equivalent-function-combiner:
 
 EquivalentFunctionCombiner
@@ -1141,7 +1213,7 @@ This component can only be used on sources with unique names.
 FullInliner
 ^^^^^^^^^^^
 
-The Full Inliner replaces certain calls of certain functions
+The FullInliner replaces certain calls of certain functions
 by the function's body. This is not very helpful in most cases, because
 it just increases the code size but does not have a benefit. Furthermore,
 code is usually very expensive and we would often rather have shorter
@@ -1165,6 +1237,11 @@ we can run the optimizer on this specialized function. If it
 results in heavy gains, the specialized function is kept,
 otherwise the original function is used instead.
 
+FunctionHoister and ExpressionSplitter are recommended as prerequisites since they make the step
+more efficient, but are not required for correctness.
+In particular, function calls with other function calls as arguments are not inlined, but running
+ExpressionSplitter beforehand ensures that there are no such calls in the input.
+
 Cleanup
 -------
 
@@ -1207,8 +1284,8 @@ This is a tiny step that helps in reversing the effects of the SSA transform
 if it is combined with the Common Subexpression Eliminator and the
 Unused Pruner.
 
-The SSA form we generate is detrimental to code generation on the EVM and
-WebAssembly alike because it generates many local variables. It would
+The SSA form we generate is detrimental to code generation
+because it produces many local variables. It would
 be better to just re-use existing variables with assignments instead of
 fresh variable declarations.
 
@@ -1327,14 +1404,62 @@ into
 
 The LiteralRematerialiser should be run before this step.
 
+Codegen-Based Optimizer Module
+==============================
 
-WebAssembly specific
---------------------
+Currently, the codegen-based optimizer module provides two optimizations.
 
-MainFunction
-^^^^^^^^^^^^
+The first one, available in the legacy code generator, moves literals to the right side of
+commutative binary operators, which helps exploit their associativity.
+
+The other one, available in the IR-based code generator, enables the use of unchecked arithmetic
+when generating code for incrementing the counter variable of certain idiomatic ``for`` loops.
+This avoids wasting gas by identifying some conditions that guarantee that the counter variable
+cannot overflow.
+This eliminates the need to use a verbose unchecked arithmetic block inside the loop body to
+increment the counter variable.
+
+.. _unchecked-loop-optimizer:
 
-Changes the topmost block to be a function with a specific name ("main") which has no
-inputs nor outputs.
+Unchecked Loop Increment
+------------------------
+
+Introduced in Solidity ``0.8.22``, the overflow check optimization step is concerned with identifying
+the conditions under which the ``for`` loop counter can be safely incremented
+without overflow checks.
+
+This optimization is **only** applied to ``for`` loops of the general form:
+
+.. code-block:: solidity
+
+    for (uint i = X; i < Y; ++i) {
+        // variable i is not modified in the loop body
+    }
+
+The condition and the fact that the counter variable is only ever incremented
+guarantee that it never overflows.
+The precise requirements for the loop to be eligible for the optimization are as follows:
+
+- The loop condition is a comparison of the form ``i < Y``, for a local counter variable ``i``
+  (called the "loop counter" hereon) and an expression ``Y``.
+- The built-in operator ``<`` is necessarily used in the loop condition and is the only operator
+  that triggers the optimization. ``<=`` and the like are intentionally excluded. Additionally,
+  user-defined operators are **not** eligible.
+- The loop expression is a prefix or postfix increment of the counter variable, i.e, ``i++`` or ``++i``.
+- The loop counter is a local variable of a built-in integer type.
+- The loop counter is **not** modified by the loop body or by the expression used as the loop condition.
+- The comparison is performed on the same type as the loop counter, meaning that the type of the
+  right-hand-side expression is implicitly convertible to the type of the counter, such that the latter
+  is not implicitly widened before the comparison.
+
+To clarify the last condition, consider the following example:
+
+.. code-block:: solidity
+
+    for (uint8 i = 0; i < uint16(1000); i++) {
+        // ...
+    }
 
-Depends on the Function Grouper.
+In this case, the counter ``i`` has its type implicitly converted from ``uint8``
+to ``uint16`` before the comparison and the condition is in fact never false, so
+the overflow check for the increment cannot be removed.
diff --git a/compiler/docs/internals/source_mappings.rst b/compiler/docs/internals/source_mappings.rst
index 11027b8a..68c29d95 100644
--- a/compiler/docs/internals/source_mappings.rst
+++ b/compiler/docs/internals/source_mappings.rst
@@ -26,7 +26,7 @@ that are not part of the original input but are referenced from the source
 mappings. These source files together with their identifiers can be
 obtained via ``output['contracts'][sourceName][contractName]['evm']['bytecode']['generatedSources']``.
 
-.. note ::
+.. note::
     In the case of instructions that are not associated with any particular source file,
     the source mapping assigns an integer identifier of ``-1``. This may happen for
     bytecode sections stemming from compiler-generated inline assembly statements.
diff --git a/compiler/docs/internals/variable_cleanup.rst b/compiler/docs/internals/variable_cleanup.rst
index 9fec6929..bab3c8be 100644
--- a/compiler/docs/internals/variable_cleanup.rst
+++ b/compiler/docs/internals/variable_cleanup.rst
@@ -4,9 +4,10 @@
 Cleaning Up Variables
 *********************
 
-When a value is shorter than 256 bit, in some cases the remaining bits
-must be cleaned.
-The Solidity compiler is designed to clean such remaining bits before any operations
+Ultimately, all values in the EVM are stored in 256 bit words.
+Thus, in some cases, when the type of a value has less than 256 bits,
+it is necessary to clean the remaining bits.
+The Solidity compiler is designed to do such cleaning before any operations
 that might be adversely affected by the potential garbage in the remaining bits.
 For example, before writing a value to  memory, the remaining bits need
 to be cleared because the memory contents can be used for computing
@@ -28,25 +29,83 @@ the boolean values before they are used as the condition for
 In addition to the design principle above, the Solidity compiler
 cleans input data when it is loaded onto the stack.
 
-Different types have different rules for cleaning up invalid values:
-
-+---------------+---------------+-------------------+
-|Type           |Valid Values   |Invalid Values Mean|
-+===============+===============+===================+
-|enum of n      |0 until n - 1  |exception          |
-|members        |               |                   |
-+---------------+---------------+-------------------+
-|bool           |0 or 1         |1                  |
-+---------------+---------------+-------------------+
-|signed integers|sign-extended  |currently silently |
-|               |word           |wraps; in the      |
-|               |               |future exceptions  |
-|               |               |will be thrown     |
-|               |               |                   |
-|               |               |                   |
-+---------------+---------------+-------------------+
-|unsigned       |higher bits    |currently silently |
-|integers       |zeroed         |wraps; in the      |
-|               |               |future exceptions  |
-|               |               |will be thrown     |
-+---------------+---------------+-------------------+
+The following table describes the cleaning rules applied to different types,
+where ``higher bits`` refers to the remaining bits in case the type has less than 256 bits.
+
++---------------+---------------+-------------------------+
+|Type           |Valid Values   |Cleanup of Invalid Values|
++===============+===============+=========================+
+|enum of n      |0 until n - 1  |throws exception         |
+|members        |               |                         |
++---------------+---------------+-------------------------+
+|bool           |0 or 1         |results in 1             |
++---------------+---------------+-------------------------+
+|signed integers|higher bits    |currently silently       |
+|               |set to the     |signextends to a valid   |
+|               |sign bit       |value, i.e. all higher   |
+|               |               |bits are set to the sign |
+|               |               |bit; may throw an        |
+|               |               |exception in the future  |
++---------------+---------------+-------------------------+
+|unsigned       |higher bits    |currently silently masks |
+|integers       |zeroed         |to a valid value, i.e.   |
+|               |               |all higher bits are set  |
+|               |               |to zero; may throw an    |
+|               |               |exception in the future  |
++---------------+---------------+-------------------------+
+
+Note that valid and invalid values are dependent on their type size.
+Consider ``uint8``, the unsigned 8-bit type, which has the following valid values:
+
+.. code-block:: none
+
+    0000...0000 0000 0000
+    0000...0000 0000 0001
+    0000...0000 0000 0010
+    ....
+    0000...0000 1111 1111
+
+Any invalid value will have the higher bits set to zero:
+
+.. code-block:: none
+
+    0101...1101 0010 1010   invalid value
+    0000...0000 0010 1010   cleaned value
+
+For ``int8``, the signed 8-bit type, the valid values are:
+
+Negative
+
+.. code-block:: none
+
+    1111...1111 1111 1111
+    1111...1111 1111 1110
+    ....
+    1111...1111 1000 0000
+
+Positive
+
+.. code-block:: none
+
+    0000...0000 0000 0000
+    0000...0000 0000 0001
+    0000...0000 0000 0010
+    ....
+    0000...0000 1111 1111
+
+The compiler will ``signextend`` the sign bit, which is 1 for negative and 0 for
+positive values, overwriting the higher bits:
+
+Negative
+
+.. code-block:: none
+
+    0010...1010 1111 1111   invalid value
+    1111...1111 1111 1111   cleaned value
+
+Positive
+
+.. code-block:: none
+
+    1101...0101 0000 0100   invalid value
+    0000...0000 0000 0100   cleaned value
diff --git a/compiler/docs/introduction-to-smart-contracts.rst b/compiler/docs/introduction-to-smart-contracts.rst
index 875e5ebc..c4cc1201 100644
--- a/compiler/docs/introduction-to-smart-contracts.rst
+++ b/compiler/docs/introduction-to-smart-contracts.rst
@@ -91,7 +91,7 @@ registering with a username and password, all you need is an Ethereum keypair.
         // The keyword "public" makes variables
         // accessible from other contracts
         address public minter;
-        mapping (address => uint) public balances;
+        mapping(address => uint) public balances;
 
         // Events allow clients to react to specific
         // contract changes you declare
@@ -151,7 +151,7 @@ You do not need to do this, the compiler figures it out for you.
 
 .. index:: mapping
 
-The next line, ``mapping (address => uint) public balances;`` also
+The next line, ``mapping(address => uint) public balances;`` also
 creates a public state variable, but it is a more complex datatype.
 The :ref:`mapping <mapping-types>` type maps addresses to :ref:`unsigned integers <integers>`.
 
@@ -185,7 +185,7 @@ arguments ``from``, ``to`` and ``amount``, which makes it possible to track
 transactions.
 
 To listen for this event, you could use the following
-JavaScript code, which uses `web3.js <https://github.com/ethereum/web3.js/>`_ to create the ``Coin`` contract object,
+JavaScript code, which uses `web3.js <https://github.com/web3/web3.js/>`_ to create the ``Coin`` contract object,
 and any user interface calls the automatically generated ``balances`` function from above:
 
 .. code-block:: javascript
@@ -282,7 +282,7 @@ the source account is also not modified.
 Furthermore, a transaction is always cryptographically signed by the sender (creator).
 This makes it straightforward to guard access to specific modifications of the
 database. In the example of the electronic currency, a simple check ensures that
-only the person holding the keys to the account can transfer money from it.
+only the person holding the keys to the account can transfer some compensation, e.g. Ether, from it.
 
 .. index:: ! block
 
@@ -300,9 +300,9 @@ and then they will be executed and distributed among all participating nodes.
 If two transactions contradict each other, the one that ends up being second will
 be rejected and not become part of the block.
 
-These blocks form a linear sequence in time and that is where the word "blockchain"
-derives from. Blocks are added to the chain in rather regular intervals - for
-Ethereum this is roughly every 17 seconds.
+These blocks form a linear sequence in time, and that is where the word "blockchain" derives from.
+Blocks are added to the chain at regular intervals, although these intervals may be subject to change in the future.
+For the most up-to-date information, it is recommended to monitor the network, for example, on `Etherscan <https://etherscan.io/chart/blocktime>`_.
 
 As part of the "order selection mechanism" (which is called "mining") it may happen that
 blocks are reverted from time to time, but only at the "tip" of the chain. The more
@@ -562,6 +562,11 @@ is removed from the state. Removing the contract in theory sounds like a good
 idea, but it is potentially dangerous, as if someone sends Ether to removed
 contracts, the Ether is forever lost.
 
+.. warning::
+    From version 0.8.18 and up, the use of ``selfdestruct`` in both Solidity and Yul will trigger a
+    deprecation warning, since the ``SELFDESTRUCT`` opcode will eventually undergo breaking changes in behavior
+    as stated in `EIP-6049 <https://eips.ethereum.org/EIPS/eip-6049>`_.
+
 .. warning::
     Even if a contract is removed by ``selfdestruct``, it is still part of the
     history of the blockchain and probably retained by most Ethereum nodes.
@@ -586,7 +591,7 @@ Precompiled Contracts
 There is a small set of contract addresses that are special:
 The address range between ``1`` and (including) ``8`` contains
 "precompiled contracts" that can be called as any other contract
-but their behaviour (and their gas consumption) is not defined
+but their behavior (and their gas consumption) is not defined
 by EVM code stored at that address (they do not contain code)
 but instead is implemented in the EVM execution environment itself.
 
diff --git a/compiler/docs/ir-breaking-changes.rst b/compiler/docs/ir-breaking-changes.rst
index 7e4efce6..4917cfc7 100644
--- a/compiler/docs/ir-breaking-changes.rst
+++ b/compiler/docs/ir-breaking-changes.rst
@@ -15,13 +15,13 @@ The IR-based code generator was introduced with an aim to not only allow
 code generation to be more transparent and auditable but also
 to enable more powerful optimization passes that span across functions.
 
-You can enable it on the command line using ``--via-ir``
+You can enable it on the command-line using ``--via-ir``
 or with the option ``{"viaIR": true}`` in standard-json and we
 encourage everyone to try it out!
 
 For several reasons, there are tiny semantic differences between the old
 and the IR-based code generator, mostly in areas where we would not
-expect people to rely on this behaviour anyway.
+expect people to rely on this behavior anyway.
 This section highlights the main differences between the old and the IR-based codegen.
 
 Semantic Only Changes
@@ -30,6 +30,8 @@ Semantic Only Changes
 This section lists the changes that are semantic-only, thus potentially
 hiding new and different behavior in existing code.
 
+.. _state-variable-initialization-order:
+
 - The order of state variable initialization has changed in case of inheritance.
 
   The order used to be:
@@ -122,8 +124,8 @@ hiding new and different behavior in existing code.
           modifier mod() { _; _; }
       }
 
-  If you execute ``f(0)`` in the old code generator, it will return ``2``, while
-  it will return ``1`` when using the new code generator.
+  If you execute ``f(0)`` in the old code generator, it will return ``1``, while
+  it will return ``0`` when using the new code generator.
 
   .. code-block:: solidity
 
@@ -174,8 +176,8 @@ hiding new and different behavior in existing code.
 
   The function ``preincr_u8(1)`` returns the following values:
 
-  - Old code generator: 3 (``1 + 2``) but the return value is unspecified in general
-  - New code generator: 4 (``2 + 2``) but the return value is not guaranteed
+  - Old code generator: ``3`` (``1 + 2``) but the return value is unspecified in general
+  - New code generator: ``4`` (``2 + 2``) but the return value is not guaranteed
 
   .. index:: ! evaluation order; function arguments
 
@@ -247,7 +249,7 @@ hiding new and different behavior in existing code.
           }
       }
 
-  The function `f()` behaves as follows:
+  The function ``f()`` behaves as follows:
 
   - Old code generator: runs out of gas while zeroing the array contents after the large memory allocation
   - New code generator: reverts due to free memory pointer overflow (does not run out of gas)
diff --git a/compiler/docs/layout-of-source-files.rst b/compiler/docs/layout-of-source-files.rst
index 9a584785..600f2ed0 100644
--- a/compiler/docs/layout-of-source-files.rst
+++ b/compiler/docs/layout-of-source-files.rst
@@ -40,7 +40,7 @@ The comment is recognized by the compiler anywhere in the file at the
 file level, but it is recommended to put it at the top of the file.
 
 More information about how to use SPDX license identifiers
-can be found at the `SPDX website <https://spdx.org/ids-how>`_.
+can be found at the `SPDX website <https://spdx.dev/learn/handling-license-info/#how>`_.
 
 
 .. index:: ! pragma
@@ -182,7 +182,7 @@ Syntax and Semantics
 Solidity supports import statements to help modularise your code that
 are similar to those available in JavaScript
 (from ES6 on). However, Solidity does not support the concept of
-a `default export <https://developer.mozilla.org/en-US/docs/web/javascript/reference/statements/export#Description>`_.
+a `default export <https://developer.mozilla.org/en-US/docs/web/javascript/reference/statements/export#description>`_.
 
 At a global level, you can use import statements of the following form:
 
diff --git a/compiler/docs/logo.svg b/compiler/docs/logo.svg
index 86b9f499..19391843 100644
--- a/compiler/docs/logo.svg
+++ b/compiler/docs/logo.svg
@@ -1,27 +1,8 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 16.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.1" id="Layer_1" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns"
-	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="1300px" height="1300px"
-	 viewBox="0 0 1300 1300" enable-background="new 0 0 1300 1300" xml:space="preserve">
-<title>Vector 1</title>
-<desc>Created with Sketch.</desc>
-<g id="Page-1" sketch:type="MSPage">
-	<g id="solidity" transform="translate(402.000000, 118.000000)" sketch:type="MSLayerGroup">
-		<g id="Group" sketch:type="MSShapeGroup">
-			<path id="Shape" opacity="0.45" enable-background="new    " d="M371.772,135.308L241.068,367.61H-20.158l130.614-232.302
-				H371.772"/>
-			<path id="Shape_1_" opacity="0.6" enable-background="new    " d="M241.068,367.61h261.318L371.772,135.308H110.456
-				L241.068,367.61z"/>
-			<path id="Shape_2_" opacity="0.8" enable-background="new    " d="M110.456,599.822L241.068,367.61L110.456,135.308
-				L-20.158,367.61L110.456,599.822z"/>
-			<path id="Shape_3_" opacity="0.45" enable-background="new    " d="M111.721,948.275l130.704-232.303h261.318L373.038,948.275
-				H111.721"/>
-			<path id="Shape_4_" opacity="0.6" enable-background="new    " d="M242.424,715.973H-18.893l130.613,232.303h261.317
-				L242.424,715.973z"/>
-			<path id="Shape_5_" opacity="0.8" enable-background="new    " d="M373.038,483.761L242.424,715.973l130.614,232.303
-				l130.704-232.303L373.038,483.761z"/>
-		</g>
-	</g>
-</g>
+<svg width="100" height="160" viewBox="0 0 100 160" fill="#2B247C" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.8" d="M50 44.3013L25 1L0 44.3013L25 87.6025L50 44.3013Z" />
+<path opacity="0.45" d="M50 44.3091L75 1.00781L25 1.00781L0 44.3091H50Z" />
+<path opacity="0.6" d="M75 1.00781L25 1.00781L50 44.3091H100L75 1.00781Z" />
+<path opacity="0.8" d="M50 115.699L75 159L100 115.699L75 72.3975L50 115.699Z" />
+<path opacity="0.45" d="M50 115.691L25 158.993H75L100 115.691L50 115.691Z" />
+<path opacity="0.6" d="M25 158.993H75L50 115.691L0 115.691L25 158.993Z" />
 </svg>
diff --git a/compiler/docs/make.bat b/compiler/docs/make.bat
index bc06e706..d11deb3f 100644
--- a/compiler/docs/make.bat
+++ b/compiler/docs/make.bat
@@ -28,6 +28,7 @@ if "%1" == "help" (
 	echo.  devhelp    to make HTML files and a Devhelp project
 	echo.  epub       to make an epub
 	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  latexpdf   to make LaTeX files and run them through pdflatex
 	echo.  text       to make text files
 	echo.  man        to make manual pages
 	echo.  texinfo    to make Texinfo files
@@ -155,16 +156,6 @@ if "%1" == "latexpdf" (
 	goto end
 )
 
-if "%1" == "latexpdfja" (
-	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
-	cd %BUILDDIR%/latex
-	make all-pdf-ja
-	cd %BUILDDIR%/..
-	echo.
-	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
-	goto end
-)
-
 if "%1" == "text" (
 	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
 	if errorlevel 1 exit /b 1
diff --git a/compiler/docs/metadata.rst b/compiler/docs/metadata.rst
index 317ad220..ede16a73 100644
--- a/compiler/docs/metadata.rst
+++ b/compiler/docs/metadata.rst
@@ -6,18 +6,19 @@ Contract Metadata
 
 .. index:: metadata, contract verification
 
-The Solidity compiler automatically generates a JSON file, the contract
-metadata, that contains information about the compiled contract. You can use
-this file to query the compiler version, the sources used, the ABI and NatSpec
-documentation to more safely interact with the contract and verify its source
-code.
+The Solidity compiler automatically generates a JSON file.
+The file contains two kinds of information about the compiled contract:
+
+- How to interact with the contract: ABI, and NatSpec documentation.
+- How to reproduce the compilation and verify a deployed contract:
+  compiler version, compiler settings, and source files used.
 
 The compiler appends by default the IPFS hash of the metadata file to the end
-of the bytecode (for details, see below) of each contract, so that you can
-retrieve the file in an authenticated way without having to resort to a
-centralized data provider. The other available options are the Swarm hash and
-not appending the metadata hash to the bytecode.  These can be configured via
-the :ref:`Standard JSON Interface<compiler-api>`.
+of the runtime bytecode (not necessarily the creation bytecode) of each contract,
+so that, if published, you can retrieve the file in an authenticated way without
+having to resort to a centralized data provider. The other available options are
+the Swarm hash and not appending the metadata hash to the bytecode. These can be
+configured via the :ref:`Standard JSON Interface<compiler-api>`.
 
 You have to publish the metadata file to IPFS, Swarm, or another service so
 that others can access it. You create the file by using the ``solc --metadata``
@@ -30,106 +31,50 @@ shall match with the one contained in the bytecode.
 
 The metadata file has the following format. The example below is presented in a
 human-readable way. Properly formatted metadata should use quotes correctly,
-reduce whitespace to a minimum and sort the keys of all objects to arrive at a
-unique formatting. Comments are not permitted and used here only for
+reduce whitespace to a minimum, and sort the keys of all objects in alphabetical order
+to arrive at a canonical formatting. Comments are not permitted and are used here only for
 explanatory purposes.
 
 .. code-block:: javascript
 
     {
-      // Required: The version of the metadata format
-      "version": "1",
-      // Required: Source code language, basically selects a "sub-version"
-      // of the specification
-      "language": "Solidity",
       // Required: Details about the compiler, contents are specific
       // to the language.
       "compiler": {
-        // Required for Solidity: Version of the compiler
-        "version": "0.8.2+commit.661d1103",
         // Optional: Hash of the compiler binary which produced this output
-        "keccak256": "0x123..."
-      },
-      // Required: Compilation source files/source units, keys are file paths
-      "sources":
-      {
-        "myDirectory/myFile.sol": {
-          // Required: keccak256 hash of the source file
-          "keccak256": "0x123...",
-          // Required (unless "content" is used, see below): Sorted URL(s)
-          // to the source file, protocol is more or less arbitrary, but an
-          // IPFS URL is recommended
-          "urls": [ "bzz-raw://7d7a...", "dweb:/ipfs/QmN..." ],
-          // Optional: SPDX license identifier as given in the source file
-          "license": "MIT"
-        },
-        "destructible": {
-          // Required: keccak256 hash of the source file
-          "keccak256": "0x234...",
-          // Required (unless "url" is used): literal contents of the source file
-          "content": "contract destructible is owned { function destroy() { if (msg.sender == owner) selfdestruct(owner); } }"
-        }
-      },
-      // Required: Compiler settings
-      "settings":
-      {
-        // Required for Solidity: Sorted list of import remappings
-        "remappings": [ ":g=/dir" ],
-        // Optional: Optimizer settings. The fields "enabled" and "runs" are deprecated
-        // and are only given for backwards-compatibility.
-        "optimizer": {
-          "enabled": true,
-          "runs": 500,
-          "details": {
-            // peephole defaults to "true"
-            "peephole": true,
-            // inliner defaults to "true"
-            "inliner": true,
-            // jumpdestRemover defaults to "true"
-            "jumpdestRemover": true,
-            "orderLiterals": false,
-            "deduplicate": false,
-            "cse": false,
-            "constantOptimizer": false,
-            "yul": true,
-            // Optional: Only present if "yul" is "true"
-            "yulDetails": {
-              "stackAllocation": false,
-              "optimizerSteps": "dhfoDgvulfnTUtnIf..."
-            }
-          }
-        },
-        "metadata": {
-          // Reflects the setting used in the input json, defaults to "false"
-          "useLiteralContent": true,
-          // Reflects the setting used in the input json, defaults to "ipfs"
-          "bytecodeHash": "ipfs"
-        },
-        // Required for Solidity: File path and the name of the contract or library this
-        // metadata is created for.
-        "compilationTarget": {
-          "myDirectory/myFile.sol": "MyContract"
-        },
-        // Required for Solidity: Addresses for libraries used
-        "libraries": {
-          "MyLib": "0x123123..."
-        }
+        "keccak256": "0x123...",
+        // Required for Solidity: Version of the compiler
+        "version": "0.8.2+commit.661d1103"
       },
+      // Required: Source code language, basically selects a "sub-version"
+      // of the specification
+      "language": "Solidity",
       // Required: Generated information about the contract.
-      "output":
-      {
+      "output": {
         // Required: ABI definition of the contract. See "Contract ABI Specification"
         "abi": [/* ... */],
-        // Required: NatSpec developer documentation of the contract.
+        // Required: NatSpec developer documentation of the contract. See https://docs.soliditylang.org/en/latest/natspec-format.html for details.
         "devdoc": {
-          "version": 1 // NatSpec version
-          "kind": "dev",
           // Contents of the @author NatSpec field of the contract
           "author": "John Doe",
-          // Contents of the @title NatSpec field of the contract
-          "title": "MyERC20: an example ERC20"
           // Contents of the @dev NatSpec field of the contract
           "details": "Interface of the ERC20 standard as defined in the EIP. See https://eips.ethereum.org/EIPS/eip-20 for details",
+          "errors": {
+            "MintToZeroAddress()" : {
+              "details": "Cannot mint to zero address"
+            }
+          },
+          "events": {
+            "Transfer(address,address,uint256)": {
+              "details": "Emitted when `value` tokens are moved from one account (`from`) toanother (`to`).",
+              "params": {
+                "from": "The sender address",
+                "to": "The receiver address",
+                "value": "The token amount"
+              }
+            }
+          },
+          "kind": "dev",
           "methods": {
             "transfer(address,uint256)": {
               // Contents of the @dev NatSpec field of the method
@@ -138,7 +83,7 @@ explanatory purposes.
               "params": {
                 "_value": "The amount tokens to be transferred",
                 "_to": "The receiver address"
-              }
+              },
               // Contents of the @return NatSpec field.
               "returns": {
                 // Return var name (here "success") if exists. "_0" as key if return var is unnamed
@@ -151,34 +96,104 @@ explanatory purposes.
               // Contents of the @dev NatSpec field of the state variable
               "details": "Must be set during contract creation. Can then only be changed by the owner"
             }
-          }
-          "events": {
-             "Transfer(address,address,uint256)": {
-               "details": "Emitted when `value` tokens are moved from one account (`from`) toanother (`to`)."
-               "params": {
-                 "from": "The sender address"
-                 "to": "The receiver address"
-                 "value": "The token amount"
-               }
-             }
-          }
+          },
+          // Contents of the @title NatSpec field of the contract
+          "title": "MyERC20: an example ERC20",
+          "version": 1 // NatSpec version
         },
-        // Required: NatSpec user documentation of the contract
+        // Required: NatSpec user documentation of the contract. See "NatSpec Format"
         "userdoc": {
-          "version": 1 // NatSpec version
+          "errors": {
+            "ApprovalCallerNotOwnerNorApproved()": [
+              {
+                "notice": "The caller must own the token or be an approved operator."
+              }
+            ]
+          },
+          "events": {
+            "Transfer(address,address,uint256)": {
+              "notice": "`_value` tokens have been moved from `from` to `to`"
+            }
+          },
           "kind": "user",
           "methods": {
             "transfer(address,uint256)": {
               "notice": "Transfers `_value` tokens to address `_to`"
             }
           },
-          "events": {
-            "Transfer(address,address,uint256)": {
-              "notice": "`_value` tokens have been moved from `from` to `to`"
+          "version": 1 // NatSpec version
+        }
+      },
+      // Required: Compiler settings. Reflects the settings in the JSON input during compilation.
+      // Check the documentation of standard JSON input's "settings" field
+      "settings": {
+        // Required for Solidity: File path and the name of the contract or library this
+        // metadata is created for.
+        "compilationTarget": {
+          "myDirectory/myFile.sol": "MyContract"
+        },
+        // Required for Solidity.
+        "evmVersion": "london",
+        // Required for Solidity: Addresses for libraries used.
+        "libraries": {
+          "MyLib": "0x123123..."
+        },
+        "metadata": {
+          // Reflects the setting used in the input json, defaults to "true"
+          "appendCBOR": true,
+          // Reflects the setting used in the input json, defaults to "ipfs"
+          "bytecodeHash": "ipfs",
+          // Reflects the setting used in the input json, defaults to "false"
+          "useLiteralContent": true
+        },
+        // Optional: Optimizer settings. The fields "enabled" and "runs" are deprecated
+        // and are only given for backward-compatibility.
+        "optimizer": {
+          "details": {
+            "constantOptimizer": false,
+            "cse": false,
+            "deduplicate": false,
+            // inliner defaults to "false"
+            "inliner": false,
+            // jumpdestRemover defaults to "true"
+            "jumpdestRemover": true,
+            "orderLiterals": false,
+            // peephole defaults to "true"
+            "peephole": true,
+            "yul": true,
+            // Optional: Only present if "yul" is "true"
+            "yulDetails": {
+              "optimizerSteps": "dhfoDgvulfnTUtnIf...",
+              "stackAllocation": false
             }
-          }
+          },
+          "enabled": true,
+          "runs": 500
+        },
+        // Required for Solidity: Sorted list of import remappings.
+        "remappings": [ ":g=/dir" ]
+      },
+      // Required: Compilation source files/source units, keys are file paths
+      "sources": {
+        "destructible": {
+          // Required (unless "url" is used): literal contents of the source file
+          "content": "contract destructible is owned { function destroy() { if (msg.sender == owner) selfdestruct(owner); } }",
+          // Required: keccak256 hash of the source file
+          "keccak256": "0x234..."
+        },
+        "myDirectory/myFile.sol": {
+          // Required: keccak256 hash of the source file
+          "keccak256": "0x123...",
+          // Optional: SPDX license identifier as given in the source file
+          "license": "MIT",
+          // Required (unless "content" is used, see above): Sorted URL(s)
+          // to the source file, protocol is more or less arbitrary, but an
+          // IPFS URL is recommended
+          "urls": [ "bzz-raw://7d7a...", "dweb:/ipfs/QmN..." ]
         }
-      }
+      },
+      // Required: The version of the metadata format
+      "version": 1
     }
 
 .. warning::
@@ -198,41 +213,46 @@ explanatory purposes.
 Encoding of the Metadata Hash in the Bytecode
 =============================================
 
-Because we might support other ways to retrieve the metadata file in the future,
-the mapping ``{"ipfs": <IPFS hash>, "solc": <compiler version>}`` is stored
-`CBOR <https://tools.ietf.org/html/rfc7049>`_-encoded. Since the mapping might
-contain more keys (see below) and the beginning of that
-encoding is not easy to find, its length is added in a two-byte big-endian
-encoding. The current version of the Solidity compiler usually adds the following
-to the end of the deployed bytecode
+The compiler currently by default appends the
+`IPFS hash (in CID v0) <https://docs.ipfs.tech/concepts/content-addressing/#version-0-v0>`_
+of the canonical metadata file and the compiler version to the end of the bytecode.
+Optionally, a Swarm hash instead of the IPFS, or an experimental flag is used.
+Below are all the possible fields:
 
-.. code-block:: text
+.. code-block:: javascript
 
-    0xa2
-    0x64 'i' 'p' 'f' 's' 0x58 0x22 <34 bytes IPFS hash>
-    0x64 's' 'o' 'l' 'c' 0x43 <3 byte version encoding>
-    0x00 0x33
+    {
+      "ipfs": "<metadata hash>",
+      // If "bytecodeHash" was "bzzr1" in compiler settings not "ipfs" but "bzzr1"
+      "bzzr1": "<metadata hash>",
+      // Previous versions were using "bzzr0" instead of "bzzr1"
+      "bzzr0": "<metadata hash>",
+      // If any experimental features that affect code generation are used
+      "experimental": true,
+      "solc": "<compiler version>"
+    }
+
+Because we might support other ways to retrieve the
+metadata file in the future, this information is stored
+`CBOR <https://tools.ietf.org/html/rfc7049>`_-encoded. The last two bytes in the bytecode
+indicate the length of the CBOR encoded information. By looking at this length, the
+relevant part of the bytecode can be decoded with a CBOR decoder.
 
-So in order to retrieve the data, the end of the deployed bytecode can be checked
-to match that pattern and the IPFS hash can be used to retrieve the file (if pinned/published).
+Check the `Metadata Playground <https://playground.sourcify.dev/>`_ to see it in action.
 
 Whereas release builds of solc use a 3 byte encoding of the version as shown
-above (one byte each for major, minor and patch version number), prerelease builds
+above (one byte each for major, minor and patch version number), pre-release builds
 will instead use a complete version string including commit hash and build date.
 
-.. note::
-  The CBOR mapping can also contain other keys, so it is better to fully
-  decode the data instead of relying on it starting with ``0xa264``.
-  For example, if any experimental features that affect code generation
-  are used, the mapping will also contain ``"experimental": true``.
+The commandline flag ``--no-cbor-metadata`` can be used to skip metadata
+from getting appended at the end of the deployed bytecode. Equivalently, the
+boolean field ``settings.metadata.appendCBOR`` in Standard JSON input can be set to false.
 
 .. note::
-  The compiler currently uses the IPFS hash of the metadata by default, but
-  it may also use the bzzr1 hash or some other hash in the future, so do
-  not rely on this sequence to start with ``0xa2 0x64 'i' 'p' 'f' 's'``.  We
-  might also add additional data to this CBOR structure, so the best option
-  is to use a proper CBOR parser.
-
+  The CBOR mapping can also contain other keys, so it is better to fully
+  decode the data by looking at the end of the bytecode for the CBOR length,
+  and to use a proper CBOR parser. Do not rely on it starting with ``0xa264``
+  or ``0xa2 0x64 'i' 'p' 'f' 's'``.
 
 Usage for Automatic Interface Generation and NatSpec
 ====================================================
@@ -246,24 +266,27 @@ is JSON-decoded into a structure like above.
 The component can then use the ABI to automatically generate a rudimentary
 user interface for the contract.
 
-Furthermore, the wallet can use the NatSpec user documentation to display a human-readable confirmation message to the user
-whenever they interact with the contract, together with requesting
-authorization for the transaction signature.
+Furthermore, the wallet can use the NatSpec user documentation to display a
+human-readable confirmation message to the user whenever they interact with
+the contract, together with requesting authorization for the transaction signature.
 
 For additional information, read :doc:`Ethereum Natural Language Specification (NatSpec) format <natspec-format>`.
 
 Usage for Source Code Verification
 ==================================
 
-In order to verify the compilation, sources can be retrieved from IPFS/Swarm
-via the link in the metadata file.
-The compiler of the correct version (which is checked to be part of the "official" compilers)
-is invoked on that input with the specified settings. The resulting
-bytecode is compared to the data of the creation transaction or ``CREATE`` opcode data.
-This automatically verifies the metadata since its hash is part of the bytecode.
-Excess data corresponds to the constructor input data, which should be decoded
-according to the interface and presented to the user.
+If pinned/published, it is possible to retrieve the metadata of the contract from IPFS/Swarm.
+The metadata file also contains the URLs or the IPFS hashes of the source files, as well as
+the compilation settings, i.e. everything needed to reproduce a compilation.
+
+With this information it is then possible to verify the source code of a contract by
+reproducing the compilation, and comparing the bytecode from the compilation with
+the bytecode of the deployed contract.
+
+This automatically verifies the metadata since its hash is part of the bytecode, as well
+as the source codes, because their hashes are part of the metadata. Any change in the files
+or settings would result in a different metadata hash. The metadata here serves
+as a fingerprint of the whole compilation.
 
-In the repository `sourcify <https://github.com/ethereum/sourcify>`_
-(`npm package <https://www.npmjs.com/package/source-verify>`_) you can see
-example code that shows how to use this feature.
+`Sourcify <https://sourcify.dev>`_ makes use of this feature for "full/perfect verification",
+as well as pinning the files publicly on IPFS to be accessed with the metadata hash.
diff --git a/compiler/docs/natspec-format.rst b/compiler/docs/natspec-format.rst
index 28848dae..0265fef3 100644
--- a/compiler/docs/natspec-format.rst
+++ b/compiler/docs/natspec-format.rst
@@ -46,7 +46,7 @@ for the purposes of NatSpec.
 
 -  For Vyper, use ``"""`` indented to the inner contents with bare
    comments. See the `Vyper
-   documentation <https://vyper.readthedocs.io/en/latest/natspec.html>`__.
+   documentation <https://docs.vyperlang.org/en/latest/natspec.html>`__.
 
 The following example shows a contract and a function using all available tags.
 
@@ -58,7 +58,7 @@ The following example shows a contract and a function using all available tags.
 
   This may change in the future.
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.2 < 0.9.0;
@@ -154,10 +154,6 @@ to the end-user as:
 
 if a function is being called and the input ``a`` is assigned a value of 10.
 
-Specifying these dynamic expressions is outside the scope of the Solidity
-documentation and you may read more at
-`the radspec project <https://github.com/aragon/radspec>`__.
-
 .. _header-inheritance:
 
 Inheritance Notes
diff --git a/compiler/docs/path-resolution.rst b/compiler/docs/path-resolution.rst
index 40a72706..ff4930bc 100644
--- a/compiler/docs/path-resolution.rst
+++ b/compiler/docs/path-resolution.rst
@@ -21,7 +21,7 @@ source unit is assigned a unique *source unit name* which is an opaque and unstr
 When you use the :ref:`import statement <import>`, you specify an *import path* that references a
 source unit name.
 
-.. index:: ! import callback, ! Host Filesystem Loader
+.. index:: ! import callback, ! Host Filesystem Loader, ! --no-import-callback
 .. _import-callback:
 
 Import Callback
@@ -36,11 +36,12 @@ An import callback is free to interpret source unit names in an arbitrary way, n
 If there is no callback available when one is needed or if it fails to locate the source code,
 compilation fails.
 
-The command-line compiler provides the *Host Filesystem Loader* - a rudimentary callback
+By default, the command-line compiler provides the *Host Filesystem Loader* - a rudimentary callback
 that interprets a source unit name as a path in the local filesystem.
+This callback can be disabled using the ``--no-import-callback`` command-line option.
 The `JavaScript interface <https://github.com/ethereum/solc-js>`_ does not provide any by default,
 but one can be provided by the user.
-This mechanism can be used to obtain source code from locations other then the local filesystem
+This mechanism can be used to obtain source code from locations other than the local filesystem
 (which may not even be accessible, e.g. when the compiler is running in a browser).
 For example the `Remix IDE <https://remix.ethereum.org/>`_ provides a versatile callback that
 lets you `import files from HTTP, IPFS and Swarm URLs or refer directly to packages in NPM registry
@@ -139,7 +140,7 @@ The initial content of the VFS depends on how you invoke the compiler:
 
 #. **Standard input**
 
-   On the command line it is also possible to provide the source by sending it to compiler's
+   On the command-line it is also possible to provide the source by sending it to compiler's
    standard input:
 
    .. code-block:: bash
@@ -197,7 +198,7 @@ source unit name.
 
     A source unit name is just an identifier and even if its value happens to look like a path, it
     is not subject to the normalization rules you would typically expect in a shell.
-    Any ``/./`` or ``/../`` seguments or sequences of multiple slashes remain a part of it.
+    Any ``/./`` or ``/../`` segments or sequences of multiple slashes remain a part of it.
     When the source is provided via Standard JSON interface it is entirely possible to associate
     different content with source unit names that would refer to the same file on disk.
 
@@ -248,19 +249,15 @@ and is bounded by two path separators.
 A separator is a forward slash or the beginning/end of the string.
 For example in ``./abc/..//`` there are three path segments: ``.``, ``abc`` and ``..``.
 
-The compiler computes a source unit name from the import path in the following way:
+The compiler resolves the import into a source unit name based on the import path, in the following way:
 
-1. First a prefix is computed
+#. We start with the source unit name of the importing source unit.
+#. The last path segment with preceding slashes is removed from the resolved name.
+#. Then, for every segment in the import path, starting from the leftmost one:
 
-    - Prefix is initialized with the source unit name of the importing source unit.
-    - The last path segment with preceding slashes is removed from the prefix.
-    - Then, the leading part of the normalized import path, consisting only of ``/`` and ``.``
-      characters is considered.
-      For every ``..`` segment found in this part the last path segment with preceding slashes is
-      removed from the prefix.
-
-2. Then the prefix is prepended to the normalized import path.
-   If the prefix is non-empty, a single slash is inserted between it and the import path.
+    - If the segment is ``.``, it is skipped.
+    - If the segment is ``..``, the last path segment with preceding slashes is removed from the resolved name.
+    - Otherwise, the segment (preceded by a single slash if the resolved name is not empty), is appended to the resolved name.
 
 The removal of the last path segment with preceding slashes is understood to
 work as follows:
@@ -268,14 +265,10 @@ work as follows:
 1. Everything past the last slash is removed (i.e. ``a/b//c.sol`` becomes ``a/b//``).
 2. All trailing slashes are removed (i.e. ``a/b//`` becomes ``a/b``).
 
-The normalization rules are the same as for UNIX paths, namely:
-
-- All the internal ``.`` segments are removed.
-- Every internal ``..`` segment backtracks one level up in the hierarchy.
-- Multiple slashes are squashed into a single one.
-
-Note that normalization is performed only on the import path.
-The source unit name of the importing module that is used for the prefix remains unnormalized.
+Note that the process normalizes the part of the resolved source unit name that comes from the import path according
+to the usual rules for UNIX paths, i.e. all ``.`` and ``..`` are removed and multiple slashes are
+squashed into a single one.
+On the other hand, the part that comes from the source unit name of the importing module remains unnormalized.
 This ensures that the ``protocol://`` part does not turn into ``protocol:/`` if the importing file
 is identified with a URL.
 
@@ -353,13 +346,13 @@ of the compiler.
 CLI Path Normalization and Stripping
 ------------------------------------
 
-On the command line the compiler behaves just as you would expect from any other program:
+On the command-line the compiler behaves just as you would expect from any other program:
 it accepts paths in a format native to the platform and relative paths are relative to the current
 working directory.
-The source unit names assigned to files whose paths are specified on the command line, however,
+The source unit names assigned to files whose paths are specified on the command-line, however,
 should not change just because the project is being compiled on a different platform or because the
 compiler happens to have been invoked from a different directory.
-To achieve this, paths to source files coming from the command line must be converted to a canonical
+To achieve this, paths to source files coming from the command-line must be converted to a canonical
 form, and, if possible, made relative to the base path or one of the include paths.
 
 The normalization rules are as follows:
@@ -416,7 +409,7 @@ The resulting file path becomes the source unit name.
     Prior to version 0.8.8, CLI path stripping was not performed and the only normalization applied
     was the conversion of path separators.
     When working with older versions of the compiler it is recommended to invoke the compiler from
-    the base path and to only use relative paths on the command line.
+    the base path and to only use relative paths on the command-line.
 
 .. index:: ! allowed paths, ! --allow-paths, remapping; target
 .. _allowed-paths:
@@ -429,7 +422,7 @@ locations that are considered safe by default:
 
 - Outside of Standard JSON mode:
 
-  - The directories containing input files listed on the command line.
+  - The directories containing input files listed on the command-line.
   - The directories used as :ref:`remapping <import-remapping>` targets.
     If the target is not a directory (i.e does not end with ``/``, ``/.`` or ``/..``) the directory
     containing the target is used instead.
@@ -523,7 +516,7 @@ you can use the following in your source file:
 
 The compiler will look for the file in the VFS under ``dapp-bin/library/math.sol``.
 If the file is not available there, the source unit name will be passed to the Host Filesystem
-Loader, which will then look in ``/project/dapp-bin/library/iterable_mapping.sol``.
+Loader, which will then look in ``/project/dapp-bin/library/math.sol``.
 
 .. warning::
 
@@ -559,7 +552,7 @@ you checked out to ``/project/dapp-bin_old``, then you can run:
 This means that all imports in ``module2`` point to the old version but imports in ``module1``
 point to the new version.
 
-Here are the detailed rules governing the behaviour of remappings:
+Here are the detailed rules governing the behavior of remappings:
 
 #. **Remappings only affect the translation between import paths and source unit names.**
 
diff --git a/compiler/docs/requirements.txt b/compiler/docs/requirements.txt
index 23c8f904..b1b21a86 100644
--- a/compiler/docs/requirements.txt
+++ b/compiler/docs/requirements.txt
@@ -4,7 +4,7 @@
 sphinx_rtd_theme>=0.5.2
 
 pygments-lexer-solidity>=0.7.0
-sphinx-a4doc>=1.2.1
+sphinx-a4doc>=1.6.0
 
 # Sphinx 2.1.0 is the oldest version that accepts a lexer class in add_lexer()
-sphinx>=2.1.0
+sphinx>=2.1.0, <6.0
diff --git a/compiler/docs/resources.rst b/compiler/docs/resources.rst
index c70b35fb..85b3cf9a 100644
--- a/compiler/docs/resources.rst
+++ b/compiler/docs/resources.rst
@@ -23,12 +23,9 @@ Integrated (Ethereum) Development Environments
         Python-based development and testing framework for smart contracts targeting the Ethereum Virtual Machine.
 
     * `Dapp <https://dapp.tools/>`_
-        Tool for building, testing and deploying smart contracts from the command line.
+        Tool for building, testing and deploying smart contracts from the command-line.
 
-    * `Embark <https://framework.embarklabs.io/>`_
-        Developer platform for building and deploying decentralized applications.
-
-    * `Foundry <https://github.com/gakonst/foundry>`_
+    * `Foundry <https://github.com/foundry-rs/foundry>`_
         Fast, portable and modular toolkit for Ethereum application development written in Rust.
 
     * `Hardhat <https://hardhat.org/>`_
@@ -37,23 +34,12 @@ Integrated (Ethereum) Development Environments
     * `Remix <https://remix.ethereum.org/>`_
         Browser-based IDE with integrated compiler and Solidity runtime environment without server-side components.
 
-    * `Truffle <https://www.trufflesuite.com/truffle>`_
+    * `Truffle <https://trufflesuite.com/truffle/>`_
         Ethereum development framework.
 
 Editor Integrations
 ===================
 
-* Atom
-
-    * `Etheratom <https://github.com/0mkara/etheratom>`_
-        Plugin for the Atom editor that features syntax highlighting, compilation and a runtime environment (Backend node & VM compatible).
-
-    * `Atom Solidity Linter <https://atom.io/packages/linter-solidity>`_
-        Plugin for the Atom editor that provides Solidity linting.
-
-    * `Atom Solium Linter <https://atom.io/packages/linter-solium>`_
-        Configurable Solidity linter for Atom using Solium (now Ethlint) as a base.
-
 * Emacs
 
     * `Emacs Solidity <https://github.com/ethereum/emacs-solidity/>`_
@@ -61,30 +47,42 @@ Editor Integrations
 
 * IntelliJ
 
-    * `IntelliJ IDEA plugin <https://plugins.jetbrains.com/plugin/9475-intellij-solidity>`_
-        Solidity plugin for IntelliJ IDEA (and all other JetBrains IDEs)
+    * `IntelliJ IDEA plugin <https://plugins.jetbrains.com/plugin/9475-solidity/>`_
+        Solidity plugin for IntelliJ IDEA (and all other JetBrains IDEs).
 
-* Sublime
+* Sublime Text
 
     * `Package for SublimeText - Solidity language syntax <https://packagecontrol.io/packages/Ethereum/>`_
         Solidity syntax highlighting for SublimeText editor.
 
 * Vim
 
-    * `Vim Solidity <https://github.com/tomlion/vim-solidity/>`_
-        Plugin for the Vim editor providing syntax highlighting.
+    * `Vim Solidity by Thesis <https://github.com/thesis/vim-solidity/>`_
+        Syntax highlighting for Solidity in Vim.
+
+    * `Vim Solidity by TovarishFin <https://github.com/TovarishFin/vim-solidity>`_
+        Vim syntax file for Solidity.
 
     * `Vim Syntastic <https://github.com/vim-syntastic/syntastic>`_
         Plugin for the Vim editor providing compile checking.
 
-* Visual Studio Code
+* Visual Studio Code (VS Code)
+
+    * `Ethereum Remix Visual Studio Code extension <https://github.com/ethereum/remix-vscode>`_
+        Ethereum Remix extension pack for VS Code
 
-    * `Visual Studio Code extension <https://juan.blanco.ws/solidity-contracts-in-visual-studio-code/>`_
+    * `Solidity Visual Studio Code extension, by Juan Blanco <https://juan.blanco.ws/solidity-contracts-in-visual-studio-code/>`_
         Solidity plugin for Microsoft Visual Studio Code that includes syntax highlighting and the Solidity compiler.
 
+    * `Solidity Visual Studio Code extension, by Nomic Foundation <https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity>`_
+        Solidity and Hardhat support by the Hardhat team, including: syntax highlighting, jump to definition, renames, quick fixes and inline solc warnings and errors.
+
     * `Solidity Visual Auditor extension <https://marketplace.visualstudio.com/items?itemName=tintinweb.solidity-visual-auditor>`_
         Adds security centric syntax and semantic highlighting to Visual Studio Code.
 
+    * `Truffle for VS Code <https://marketplace.visualstudio.com/items?itemName=trufflesuite-csi.truffle-vscode>`_
+        Build, debug and deploy smart contracts on Ethereum and EVM-compatible blockchains.
+
 Solidity Tools
 ==============
 
@@ -112,9 +110,6 @@ Solidity Tools
 * `leafleth <https://github.com/clemlak/leafleth>`_
     A documentation generator for Solidity smart-contracts.
 
-* `PIET <https://piet.slock.it/>`_
-    A tool to develop, audit and use Solidity smart contracts through a simple graphical interface.
-
 * `Scaffold-ETH <https://github.com/scaffold-eth/scaffold-eth>`_
     Forkable Ethereum development stack focused on fast product iterations.
 
diff --git a/compiler/docs/security-considerations.rst b/compiler/docs/security-considerations.rst
index 6507f7c1..92d60104 100644
--- a/compiler/docs/security-considerations.rst
+++ b/compiler/docs/security-considerations.rst
@@ -7,28 +7,28 @@ Security Considerations
 While it is usually quite easy to build software that works as expected,
 it is much harder to check that nobody can use it in a way that was **not** anticipated.
 
-In Solidity, this is even more important because you can use smart contracts
-to handle tokens or, possibly, even more valuable things. Furthermore, every
-execution of a smart contract happens in public and, in addition to that,
-the source code is often available.
-
-Of course you always have to consider how much is at stake:
-You can compare a smart contract with a web service that is open to the
-public (and thus, also to malicious actors) and perhaps even open source.
-If you only store your grocery list on that web service, you might not have
-to take too much care, but if you manage your bank account using that web service,
-you should be more careful.
-
-This section will list some pitfalls and general security recommendations but
-can, of course, never be complete.  Also, keep in mind that even if your smart
-contract code is bug-free, the compiler or the platform itself might have a
-bug. A list of some publicly known security-relevant bugs of the compiler can
-be found in the :ref:`list of known bugs<known_bugs>`, which is also
-machine-readable. Note that there is a bug bounty program that covers the code
-generator of the Solidity compiler.
-
-As always, with open source documentation, please help us extend this section
-(especially, some examples would not hurt)!
+In Solidity, this is even more important because you can use smart contracts to handle tokens or,
+possibly, even more valuable things.
+Furthermore, every execution of a smart contract happens in public and,
+in addition to that, the source code is often available.
+
+Of course, you always have to consider how much is at stake:
+You can compare a smart contract with a web service that is open to the public
+(and thus, also to malicious actors) and perhaps even open-source.
+If you only store your grocery list on that web service, you might not have to take too much care,
+but if you manage your bank account using that web service, you should be more careful.
+
+This section will list some pitfalls and general security recommendations
+but can, of course, never be complete.
+Also, keep in mind that even if your smart contract code is bug-free,
+the compiler or the platform itself might have a bug.
+A list of some publicly known security-relevant bugs of the compiler can be found
+in the :ref:`list of known bugs<known_bugs>`, which is also machine-readable.
+Note that there is a `Bug Bounty Program <https://ethereum.org/en/bug-bounty/>`_
+that covers the code generator of the Solidity compiler.
+
+As always, with open-source documentation,
+please help us extend this section (especially, some examples would not hurt)!
 
 NOTE: In addition to the list below, you can find more security recommendations and best practices
 `in Guy Lando's knowledge list <https://github.com/guylando/KnowledgeLists/blob/master/EthereumSmartContracts.md>`_ and
@@ -41,20 +41,18 @@ Pitfalls
 Private Information and Randomness
 ==================================
 
-Everything you use in a smart contract is publicly visible, even
-local variables and state variables marked ``private``.
+Everything you use in a smart contract is publicly visible,
+even local variables and state variables marked ``private``.
 
-Using random numbers in smart contracts is quite tricky if you do not want
-miners to be able to cheat.
+Using random numbers in smart contracts is quite tricky if you do not want block builders to be able to cheat.
 
-Re-Entrancy
-===========
+Reentrancy
+==========
 
-Any interaction from a contract (A) with another contract (B) and any transfer
-of Ether hands over control to that contract (B). This makes it possible for B
-to call back into A before this interaction is completed. To give an example,
-the following code contains a bug (it is just a snippet and not a
-complete contract):
+Any interaction from a contract (A) with another contract (B)
+and any transfer of Ether hands over control to that contract (B).
+This makes it possible for B to call back into A before this interaction is completed.
+To give an example, the following code contains a bug (it is just a snippet and not a complete contract):
 
 .. code-block:: solidity
 
@@ -72,12 +70,12 @@ complete contract):
         }
     }
 
-The problem is not too serious here because of the limited gas as part
-of ``send``, but it still exposes a weakness: Ether transfer can always
-include code execution, so the recipient could be a contract that calls
-back into ``withdraw``. This would let it get multiple refunds and
-basically retrieve all the Ether in the contract. In particular, the
-following contract will allow an attacker to refund multiple times
+The problem is not too serious here because of the limited gas as part of ``send``,
+but it still exposes a weakness:
+Ether transfer can always include code execution,
+so the recipient could be a contract that calls back into ``withdraw``.
+This would let it get multiple refunds and, basically, retrieve all the Ether in the contract.
+In particular, the following contract will allow an attacker to refund multiple times
 as it uses ``call`` which forwards all remaining gas by default:
 
 .. code-block:: solidity
@@ -97,8 +95,7 @@ as it uses ``call`` which forwards all remaining gas by default:
         }
     }
 
-To avoid re-entrancy, you can use the Checks-Effects-Interactions pattern as
-demonstrated below:
+To avoid reentrancy, you can use the Checks-Effects-Interactions pattern as demonstrated below:
 
 .. code-block:: solidity
 
@@ -116,58 +113,58 @@ demonstrated below:
         }
     }
 
-The Checks-Effects-Interactions pattern ensures that all code paths through a contract complete all required checks
-of the supplied parameters before modifying the contract's state (Checks); only then it makes any changes to the state (Effects);
-it may make calls to functions in other contracts *after* all planned state changes have been written to
-storage (Interactions). This is a common foolproof way to prevent *re-entrancy attacks*, where an externally called
-malicious contract is able to double-spend an allowance, double-withdraw a balance, among other things, by using logic that calls back into the
-original contract before it has finalized its transaction.
-
-Note that re-entrancy is not only an effect of Ether transfer but of any
-function call on another contract. Furthermore, you also have to take
-multi-contract situations into account. A called contract could modify the
-state of another contract you depend on.
+The Checks-Effects-Interactions pattern ensures that all code paths through a contract
+complete all required checks of the supplied parameters before modifying the contract's state (Checks);
+only then it makes any changes to the state (Effects);
+it may make calls to functions in other contracts
+*after* all planned state changes have been written to storage (Interactions).
+This is a common foolproof way to prevent *reentrancy attacks*,
+where an externally called malicious contract can double-spend an allowance,
+double-withdraw a balance, among other things,
+by using logic that calls back into the original contract before it has finalized its transaction.
+
+Note that reentrancy is not only an effect of Ether transfer
+but of any function call on another contract.
+Furthermore, you also have to take multi-contract situations into account.
+A called contract could modify the state of another contract you depend on.
 
 Gas Limit and Loops
 ===================
 
-Loops that do not have a fixed number of iterations, for example, loops that depend on storage values, have to be used carefully:
-Due to the block gas limit, transactions can only consume a certain amount of gas. Either explicitly or just due to
-normal operation, the number of iterations in a loop can grow beyond the block gas limit which can cause the complete
-contract to be stalled at a certain point. This may not apply to ``view`` functions that are only executed
-to read data from the blockchain. Still, such functions may be called by other contracts as part of on-chain operations
-and stall those. Please be explicit about such cases in the documentation of your contracts.
+Loops that do not have a fixed number of iterations, for example,
+loops that depend on storage values, have to be used carefully:
+Due to the block gas limit, transactions can only consume a certain amount of gas.
+Either explicitly or just due to normal operation,
+the number of iterations in a loop can grow beyond the block gas limit
+which can cause the complete contract to be stalled at a certain point.
+This may not apply to ``view`` functions that are only executed to read data from the blockchain.
+Still, such functions may be called by other contracts as part of on-chain operations and stall those.
+Please be explicit about such cases in the documentation of your contracts.
 
 Sending and Receiving Ether
 ===========================
 
-- Neither contracts nor "external accounts" are currently able to prevent that someone sends them Ether.
-  Contracts can react on and reject a regular transfer, but there are ways
-  to move Ether without creating a message call. One way is to simply "mine to"
-  the contract address and the second way is using ``selfdestruct(x)``.
+- Neither contracts nor "external accounts" are currently able to prevent someone from sending them Ether.
+  Contracts can react on and reject a regular transfer, but there are ways to move Ether without creating a message call.
+  One way is to simply "mine to" the contract address and the second way is using ``selfdestruct(x)``.
 
-- If a contract receives Ether (without a function being called),
-  either the :ref:`receive Ether <receive-ether-function>`
+- If a contract receives Ether (without a function being called), either the :ref:`receive Ether <receive-ether-function>`
   or the :ref:`fallback <fallback-function>` function is executed.
-  If it does not have a receive nor a fallback function, the Ether will be
-  rejected (by throwing an exception). During the execution of one of these
-  functions, the contract can only rely on the "gas stipend" it is passed (2300
-  gas) being available to it at that time. This stipend is not enough to modify
-  storage (do not take this for granted though, the stipend might change with
-  future hard forks). To be sure that your contract can receive Ether in that
-  way, check the gas requirements of the receive and fallback functions
+  If it does not have a ``receive`` nor a ``fallback`` function, the Ether will be rejected (by throwing an exception).
+  During the execution of one of these functions, the contract can only rely on the "gas stipend" it is passed (2300 gas)
+  being available to it at that time.
+  This stipend is not enough to modify storage (do not take this for granted though, the stipend might change with future hard forks).
+  To be sure that your contract can receive Ether in that way, check the gas requirements of the receive and fallback functions
   (for example in the "details" section in Remix).
 
-- There is a way to forward more gas to the receiving contract using
-  ``addr.call{value: x}("")``. This is essentially the same as ``addr.transfer(x)``,
-  only that it forwards all remaining gas and opens up the ability for the
-  recipient to perform more expensive actions (and it returns a failure code
-  instead of automatically propagating the error). This might include calling back
-  into the sending contract or other state changes you might not have thought of.
+- There is a way to forward more gas to the receiving contract using ``addr.call{value: x}("")``.
+  This is essentially the same as ``addr.transfer(x)``, only that it forwards all remaining gas
+  and opens up the ability for the recipient to perform more expensive actions
+  (and it returns a failure code instead of automatically propagating the error).
+  This might include calling back into the sending contract or other state changes you might not have thought of.
   So it allows for great flexibility for honest users but also for malicious actors.
 
-- Use the most precise units to represent the wei amount as possible, as you lose
-  any that is rounded due to a lack of precision.
+- Use the most precise units to represent the Wei amount as possible, as you lose any that is rounded due to a lack of precision.
 
 - If you want to send Ether using ``address.transfer``, there are certain details to be aware of:
 
@@ -191,24 +188,28 @@ Sending and Receiving Ether
 Call Stack Depth
 ================
 
-External function calls can fail any time because they exceed the maximum
-call stack size limit of 1024. In such situations, Solidity throws an exception.
+External function calls can fail at any time
+because they exceed the maximum call stack size limit of 1024.
+In such situations, Solidity throws an exception.
 Malicious actors might be able to force the call stack to a high value
-before they interact with your contract. Note that, since `Tangerine Whistle <https://eips.ethereum.org/EIPS/eip-608>`_ hardfork, the `63/64 rule <https://eips.ethereum.org/EIPS/eip-150>`_ makes call stack depth attack impractical. Also note that the call stack and the expression stack are unrelated, even though both have a size limit of 1024 stack slots.
+before they interact with your contract.
+Note that, since `Tangerine Whistle <https://eips.ethereum.org/EIPS/eip-608>`_ hardfork,
+the `63/64 rule <https://eips.ethereum.org/EIPS/eip-150>`_ makes call stack depth attack impractical.
+Also note that the call stack and the expression stack are unrelated,
+even though both have a size limit of 1024 stack slots.
 
-Note that ``.send()`` does **not** throw an exception if the call stack is
-depleted but rather returns ``false`` in that case. The low-level functions
-``.call()``, ``.delegatecall()`` and ``.staticcall()`` behave in the same way.
+Note that ``.send()`` does **not** throw an exception if the call stack is depleted
+but rather returns ``false`` in that case.
+The low-level functions ``.call()``, ``.delegatecall()`` and ``.staticcall()`` behave in the same way.
 
 Authorized Proxies
 ==================
 
-If your contract can act as a proxy, i.e. if it can call arbitrary contracts
-with user-supplied data, then the user can essentially assume the identity
-of the proxy contract. Even if you have other protective measures in place,
-it is best to build your contract system such that the proxy does not have
-any permissions (not even for itself). If needed, you can accomplish that
-using a second proxy:
+If your contract can act as a proxy, i.e. if it can call arbitrary contracts with user-supplied data,
+then the user can essentially assume the identity of the proxy contract.
+Even if you have other protective measures in place, it is best to build your contract system such
+that the proxy does not have any permissions (not even for itself).
+If needed, you can accomplish that using a second proxy:
 
 .. code-block:: solidity
 
@@ -236,7 +237,8 @@ using a second proxy:
 tx.origin
 =========
 
-Never use tx.origin for authorization. Let's say you have a wallet contract like this:
+Never use ``tx.origin`` for authorization.
+Let's say you have a wallet contract like this:
 
 .. code-block:: solidity
 
@@ -279,7 +281,11 @@ Now someone tricks you into sending Ether to the address of this attack wallet:
         }
     }
 
-If your wallet had checked ``msg.sender`` for authorization, it would get the address of the attack wallet, instead of the owner address. But by checking ``tx.origin``, it gets the original address that kicked off the transaction, which is still the owner address. The attack wallet instantly drains all your funds.
+If your wallet had checked ``msg.sender`` for authorization, it would get the address of the attack wallet,
+instead of the owner's address.
+But by checking ``tx.origin``, it gets the original address that kicked off the transaction,
+which is still the owner's address.
+The attack wallet instantly drains all your funds.
 
 .. _underflow-overflow:
 
@@ -319,16 +325,14 @@ Try to use ``require`` to limit the size of inputs to a reasonable range and use
 Clearing Mappings
 =================
 
-The Solidity type ``mapping`` (see :ref:`mapping-types`) is a storage-only
-key-value data structure that does not keep track of the keys that were
-assigned a non-zero value.  Because of that, cleaning a mapping without extra
-information about the written keys is not possible.
-If a ``mapping`` is used as the base type of a dynamic storage array, deleting
-or popping the array will have no effect over the ``mapping`` elements.  The
-same happens, for example, if a ``mapping`` is used as the type of a member
-field of a ``struct`` that is the base type of a dynamic storage array.  The
-``mapping`` is also ignored in assignments of structs or arrays containing a
-``mapping``.
+The Solidity type ``mapping`` (see :ref:`mapping-types`) is a storage-only key-value data structure
+that does not keep track of the keys that were assigned a non-zero value.
+Because of that, cleaning a mapping without extra information about the written keys is not possible.
+If a ``mapping`` is used as the base type of a dynamic storage array,
+deleting or popping the array will have no effect over the ``mapping`` elements.
+The same happens, for example, if a ``mapping`` is used as the type of a member field of a ``struct``
+that is the base type of a dynamic storage array.
+The ``mapping`` is also ignored in assignments of structs or arrays containing a ``mapping``.
 
 .. code-block:: solidity
 
@@ -336,7 +340,7 @@ field of a ``struct`` that is the base type of a dynamic storage array.  The
     pragma solidity >=0.6.0 <0.9.0;
 
     contract Map {
-        mapping (uint => uint)[] array;
+        mapping(uint => uint)[] array;
 
         function allocate(uint newMaps) public {
             for (uint i = 0; i < newMaps; i++)
@@ -356,15 +360,12 @@ field of a ``struct`` that is the base type of a dynamic storage array.  The
         }
     }
 
-Consider the example above and the following sequence of calls: ``allocate(10)``,
-``writeMap(4, 128, 256)``.
+Consider the example above and the following sequence of calls: ``allocate(10)``, ``writeMap(4, 128, 256)``.
 At this point, calling ``readMap(4, 128)`` returns 256.
-If we call ``eraseMaps``, the length of state variable ``array`` is zeroed, but
-since its ``mapping`` elements cannot be zeroed, their information stays alive
-in the contract's storage.
-After deleting ``array``, calling ``allocate(5)`` allows us to access
-``array[4]`` again, and calling ``readMap(4, 128)`` returns 256 even without
-another call to ``writeMap``.
+If we call ``eraseMaps``, the length of the state variable ``array`` is zeroed,
+but since its ``mapping`` elements cannot be zeroed, their information stays alive in the contract's storage.
+After deleting ``array``, calling ``allocate(5)`` allows us to access ``array[4]`` again,
+and calling ``readMap(4, 128)`` returns 256 even without another call to ``writeMap``.
 
 If your ``mapping`` information must be deleted, consider using a library similar to
 `iterable mapping <https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol>`_,
@@ -375,10 +376,11 @@ Minor Details
 
 - Types that do not occupy the full 32 bytes might contain "dirty higher order bits".
   This is especially important if you access ``msg.data`` - it poses a malleability risk:
-  You can craft transactions that call a function ``f(uint8 x)`` with a raw byte argument
-  of ``0xff000001`` and with ``0x00000001``. Both are fed to the contract and both will
-  look like the number ``1`` as far as ``x`` is concerned, but ``msg.data`` will
-  be different, so if you use ``keccak256(msg.data)`` for anything, you will get different results.
+  You can craft transactions that call a function ``f(uint8 x)``
+  with a raw byte argument of ``0xff000001`` and with ``0x00000001``.
+  Both are fed to the contract and both will look like the number ``1`` as far as ``x`` is concerned,
+  but ``msg.data`` will be different, so if you use ``keccak256(msg.data)`` for anything,
+  you will get different results.
 
 ***************
 Recommendations
@@ -388,48 +390,45 @@ Take Warnings Seriously
 =======================
 
 If the compiler warns you about something, you should change it.
-Even if you do not think that this particular warning has security
-implications, there might be another issue buried beneath it.
-Any compiler warning we issue can be silenced by slight changes to the
-code.
+Even if you do not think that this particular warning has security implications,
+there might be another issue buried beneath it.
+Any compiler warning we issue can be silenced by slight changes to the code.
 
-Always use the latest version of the compiler to be notified about all recently
-introduced warnings.
+Always use the latest version of the compiler to be notified about all recently introduced warnings.
 
-Messages of type ``info`` issued by the compiler are not dangerous, and simply
-represent extra suggestions and optional information that the compiler thinks
-might be useful to the user.
+Messages of type ``info``, issued by the compiler, are not dangerous
+and simply represent extra suggestions and optional information
+that the compiler thinks might be useful to the user.
 
 Restrict the Amount of Ether
 ============================
 
-Restrict the amount of Ether (or other tokens) that can be stored in a smart
-contract. If your source code, the compiler or the platform has a bug, these
-funds may be lost. If you want to limit your loss, limit the amount of Ether.
+Restrict the amount of Ether (or other tokens) that can be stored in a smart contract.
+If your source code, the compiler or the platform has a bug, these funds may be lost.
+If you want to limit your loss, limit the amount of Ether.
 
 Keep it Small and Modular
 =========================
 
-Keep your contracts small and easily understandable. Single out unrelated
-functionality in other contracts or into libraries. General recommendations
-about source code quality of course apply: Limit the amount of local variables,
-the length of functions and so on. Document your functions so that others
-can see what your intention was and whether it is different than what the code does.
+Keep your contracts small and easily understandable.
+Single out unrelated functionality in other contracts or into libraries.
+General recommendations about the source code quality of course apply:
+Limit the amount of local variables, the length of functions and so on.
+Document your functions so that others can see what your intention was
+and whether it is different than what the code does.
 
 Use the Checks-Effects-Interactions Pattern
 ===========================================
 
-Most functions will first perform some checks (who called the function,
-are the arguments in range, did they send enough Ether, does the person
-have tokens, etc.). These checks should be done first.
+Most functions will first perform some checks and they should be done first
+(who called the function, are the arguments in range, did they send enough Ether,
+does the person have tokens, etc.).
 
-As the second step, if all checks passed, effects to the state variables
-of the current contract should be made. Interaction with other contracts
-should be the very last step in any function.
+As the second step, if all checks passed, effects to the state variables of the current contract should be made.
+Interaction with other contracts should be the very last step in any function.
 
-Early contracts delayed some effects and waited for external function
-calls to return in a non-error state. This is often a serious mistake
-because of the re-entrancy problem explained above.
+Early contracts delayed some effects and waited for external function calls to return in a non-error state.
+This is often a serious mistake because of the reentrancy problem explained above.
 
 Note that, also, calls to known contracts might in turn cause calls to
 unknown contracts, so it is probably better to just always apply this pattern.
@@ -437,24 +436,23 @@ unknown contracts, so it is probably better to just always apply this pattern.
 Include a Fail-Safe Mode
 ========================
 
-While making your system fully decentralised will remove any intermediary,
-it might be a good idea, especially for new code, to include some kind
-of fail-safe mechanism:
+While making your system fully decentralized will remove any intermediary,
+it might be a good idea, especially for new code, to include some kind of fail-safe mechanism:
 
-You can add a function in your smart contract that performs some
-self-checks like "Has any Ether leaked?",
+You can add a function in your smart contract that performs some self-checks like "Has any Ether leaked?",
 "Is the sum of the tokens equal to the balance of the contract?" or similar things.
-Keep in mind that you cannot use too much gas for that, so help through off-chain
-computations might be needed there.
+Keep in mind that you cannot use too much gas for that,
+so help through off-chain computations might be needed there.
 
-If the self-check fails, the contract automatically switches into some kind
-of "failsafe" mode, which, for example, disables most of the features, hands over
-control to a fixed and trusted third party or just converts the contract into
-a simple "give me back my money" contract.
+If the self-check fails, the contract automatically switches into some kind of "failsafe" mode,
+which, for example, disables most of the features,
+hands over control to a fixed and trusted third party
+or just converts the contract into a simple "give me back my Ether" contract.
 
 Ask for Peer Review
 ===================
 
 The more people examine a piece of code, the more issues are found.
-Asking people to review your code also helps as a cross-check to find out whether your code
-is easy to understand - a very important criterion for good smart contracts.
+Asking people to review your code also helps as a cross-check to find out
+whether your code is easy to understand -
+a very important criterion for good smart contracts.
diff --git a/compiler/docs/smtchecker.rst b/compiler/docs/smtchecker.rst
index 6d2f4373..f8085b63 100644
--- a/compiler/docs/smtchecker.rst
+++ b/compiler/docs/smtchecker.rst
@@ -73,7 +73,7 @@ Tutorial
 Overflow
 ========
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -97,7 +97,7 @@ Overflow
 
 The contract above shows an overflow check example.
 The SMTChecker does not check underflow and overflow by default for Solidity >=0.8.7,
-so we need to use the command line option ``--model-checker-targets "underflow,overflow"``
+so we need to use the command-line option ``--model-checker-targets "underflow,overflow"``
 or the JSON option ``settings.modelChecker.targets = ["underflow", "overflow"]``.
 See :ref:`this section for targets configuration<smtchecker_targets>`.
 Here, it reports the following:
@@ -122,7 +122,7 @@ Here, it reports the following:
 If we add ``require`` statements that filter out overflow cases,
 the SMTChecker proves that no overflow is reachable (by not reporting warnings):
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -160,7 +160,7 @@ Since ``f`` is indeed monotonically increasing, the SMTChecker proves that our
 property is correct. You are encouraged to play with the property and the function
 definition to see what results come out!
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -182,7 +182,7 @@ The following code searches for the maximum element of an unrestricted array of
 numbers, and asserts the property that the found element must be greater or
 equal every element in the array.
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -216,7 +216,7 @@ All the properties are correctly proven safe. Feel free to change the
 properties and/or add restrictions on the array to see different results.
 For example, changing the code to
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -268,7 +268,7 @@ Let us place a robot at position (0, 0). The robot can only move diagonally, one
 and cannot move outside the grid. The robot's state machine can be represented by the smart contract
 below.
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -319,7 +319,7 @@ We can also trick the SMTChecker into giving us a path to a certain position we
 think might be reachable.  We can add the property that (2, 4) is *not*
 reachable, by adding the following function.
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     function reach_2_4() public view {
         assert(!(x == 2 && y == 4));
@@ -368,7 +368,7 @@ In some cases, it is possible to automatically infer properties over state
 variables that are still true even if the externally called code can do
 anything, including reenter the caller contract.
 
-.. code-block:: Solidity
+.. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity >=0.8.0;
@@ -412,7 +412,7 @@ is already "locked", so it would not be possible to change the value of ``x``,
 regardless of what the unknown called code does.
 
 If we "forget" to use the ``mutex`` modifier on function ``set``, the
-SMTChecker is able to synthesize the behaviour of the externally called code so
+SMTChecker is able to synthesize the behavior of the externally called code so
 that the assertion fails:
 
 .. code-block:: text
@@ -483,6 +483,14 @@ All targets are checked by default, except underflow and overflow for Solidity >
 There is no precise heuristic on how and when to split verification targets,
 but it can be useful especially when dealing with large contracts.
 
+Proved Targets
+==============
+
+If there are any proved targets, the SMTChecker issues one warning per engine stating
+how many targets were proved. If the user wishes to see all the specific
+proved targets, the CLI option ``--model-checker-show-proved`` and
+the JSON option ``settings.modelChecker.showProved = true`` can be used.
+
 Unproved Targets
 ================
 
@@ -491,6 +499,23 @@ how many unproved targets there are. If the user wishes to see all the specific
 unproved targets, the CLI option ``--model-checker-show-unproved`` and
 the JSON option ``settings.modelChecker.showUnproved = true`` can be used.
 
+Unsupported Language Features
+=============================
+
+Certain Solidity language features are not completely supported by the SMT
+encoding that the SMTChecker applies, for example assembly blocks.
+The unsupported construct is abstracted via overapproximation to preserve
+soundness, meaning any properties reported safe are safe even though this
+feature is unsupported.
+However such abstraction may cause false positives when the target properties
+depend on the precise behavior of the unsupported feature.
+If the encoder encounters such cases it will by default report a generic warning
+stating how many unsupported features it has seen.
+If the user wishes to see all the specific unsupported features, the CLI option
+``--model-checker-show-unsupported`` and the JSON option
+``settings.modelChecker.showUnsupported = true`` can be used, where their default
+value is ``false``.
+
 Verified Contracts
 ==================
 
@@ -518,13 +543,196 @@ which has the following form:
         "source2.sol": ["contract2", "contract3"]
     }
 
+Trusted External Calls
+======================
+
+By default, the SMTChecker does not assume that compile-time available code
+is the same as the runtime code for external calls. Take the following contracts
+as an example:
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.0;
+
+    contract Ext {
+        uint public x;
+        function setX(uint _x) public { x = _x; }
+    }
+    contract MyContract {
+        function callExt(Ext _e) public {
+            _e.setX(42);
+            assert(_e.x() == 42);
+        }
+    }
+
+When ``MyContract.callExt`` is called, an address is given as the argument.
+At deployment time, we cannot know for sure that address ``_e`` actually
+contains a deployment of contract ``Ext``.
+Therefore, the SMTChecker will warn that the assertion above can be violated,
+which is true, if ``_e`` contains another contract than ``Ext``.
+
+However, it can be useful to treat these external calls as trusted, for example,
+to test that different implementations of an interface conform to the same property.
+This means assuming that address ``_e`` indeed was deployed as contract ``Ext``.
+This mode can be enabled via the CLI option ``--model-checker-ext-calls=trusted``
+or the JSON field ``settings.modelChecker.extCalls: "trusted"``.
+
+Please be aware that enabling this mode can make the SMTChecker analysis much more
+computationally costly.
+
+An important part of this mode is that it is applied to contract types and high
+level external calls to contracts, and not low level calls such as ``call`` and
+``delegatecall``. The storage of an address is stored per contract type, and
+the SMTChecker assumes that an externally called contract has the type of the
+caller expression.  Therefore, casting an ``address`` or a contract to
+different contract types will yield different storage values and can give
+unsound results if the assumptions are inconsistent, such as the example below:
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.0;
+
+    contract D {
+        constructor(uint _x) { x = _x; }
+        uint public x;
+        function setX(uint _x) public { x = _x; }
+    }
+
+    contract E {
+        constructor() { x = 2; }
+        uint public x;
+        function setX(uint _x) public { x = _x; }
+    }
+
+    contract C {
+        function f() public {
+            address d = address(new D(42));
+
+            // `d` was deployed as `D`, so its `x` should be 42 now.
+            assert(D(d).x() == 42); // should hold
+            assert(D(d).x() == 43); // should fail
+
+            // E and D have the same interface, so the following
+            // call would also work at runtime.
+            // However, the change to `E(d)` is not reflected in `D(d)`.
+            E(d).setX(1024);
+
+            // Reading from `D(d)` now will show old values.
+            // The assertion below should fail at runtime,
+            // but succeeds in this mode's analysis (unsound).
+            assert(D(d).x() == 42);
+            // The assertion below should succeed at runtime,
+            // but fails in this mode's analysis (false positive).
+            assert(D(d).x() == 1024);
+        }
+    }
+
+Due to the above, make sure that the trusted external calls to a certain
+variable of ``address`` or ``contract`` type always have the same caller
+expression type.
+
+It is also helpful to cast the called contract's variable as the type of the
+most derived type in case of inheritance.
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.0;
+
+    interface Token {
+        function balanceOf(address _a) external view returns (uint);
+        function transfer(address _to, uint _amt) external;
+    }
+
+    contract TokenCorrect is Token {
+        mapping (address => uint) balance;
+        constructor(address _a, uint _b) {
+            balance[_a] = _b;
+        }
+        function balanceOf(address _a) public view override returns (uint) {
+            return balance[_a];
+        }
+        function transfer(address _to, uint _amt) public override {
+            require(balance[msg.sender] >= _amt);
+            balance[msg.sender] -= _amt;
+            balance[_to] += _amt;
+        }
+    }
+
+    contract Test {
+        function property_transfer(address _token, address _to, uint _amt) public {
+            require(_to != address(this));
+
+            TokenCorrect t = TokenCorrect(_token);
+
+            uint xPre = t.balanceOf(address(this));
+            require(xPre >= _amt);
+            uint yPre = t.balanceOf(_to);
+
+            t.transfer(_to, _amt);
+            uint xPost = t.balanceOf(address(this));
+            uint yPost = t.balanceOf(_to);
+
+            assert(xPost == xPre - _amt);
+            assert(yPost == yPre + _amt);
+        }
+    }
+
+Note that in function ``property_transfer``, the external calls are
+performed on variable ``t``.
+
+Another caveat of this mode are calls to state variables of contract type
+outside the analyzed contract. In the code below, even though ``B`` deploys
+``A``, it is also possible for the address stored in ``B.a`` to be called by
+anyone outside of ``B`` in between transactions to ``B`` itself. To reflect the
+possible changes to ``B.a``, the encoding allows an unbounded number of calls
+to be made to ``B.a`` externally. The encoding will keep track of ``B.a``'s
+storage, therefore assertion (2) should hold. However, currently the encoding
+allows such calls to be made from ``B`` conceptually, therefore assertion (3)
+fails.  Making the encoding stronger logically is an extension of the trusted
+mode and is under development. Note that the encoding does not keep track of
+storage for ``address`` variables, therefore if ``B.a`` had type ``address``
+the encoding would assume that its storage does not change in between
+transactions to ``B``.
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.0;
+
+    contract A {
+        uint public x;
+        address immutable public owner;
+        constructor() {
+            owner = msg.sender;
+        }
+        function setX(uint _x) public {
+            require(msg.sender == owner);
+            x = _x;
+        }
+    }
+
+    contract B {
+        A a;
+        constructor() {
+            a = new A();
+            assert(a.x() == 0); // (1) should hold
+        }
+        function g() public view {
+            assert(a.owner() == address(this)); // (2) should hold
+            assert(a.x() == 0); // (3) should hold, but fails due to a false positive
+        }
+    }
+
 Reported Inferred Inductive Invariants
 ======================================
 
 For properties that were proved safe with the CHC engine,
 the SMTChecker can retrieve inductive invariants that were inferred by the Horn
 solver as part of the proof.
-Currently two types of invariants can be reported to the user:
+Currently only two types of invariants can be reported to the user:
 
 - Contract Invariants: these are properties over the contract's state variables
   that are true before and after every possible transaction that the contract may ever run. For example, ``x >= y``, where ``x`` and ``y`` are a contract's state variables.
@@ -543,7 +751,7 @@ and modulo operations inside Horn rules. Because of that, by default the
 Solidity division and modulo operations are encoded using the constraint
 ``a = b * d + m`` where ``d = a / b`` and ``m = a % b``.
 However, other solvers, such as Eldarica, prefer the syntactically precise operations.
-The command line flag ``--model-checker-div-mod-no-slacks`` and the JSON option
+The command-line flag ``--model-checker-div-mod-no-slacks`` and the JSON option
 ``settings.modelChecker.divModNoSlacks`` can be used to toggle the encoding
 depending on the used solver preferences.
 
@@ -614,25 +822,26 @@ which is primarily an SMT solver and makes `Spacer
 <https://github.com/uuverifiers/eldarica>`_ which does both.
 
 The user can choose which solvers should be used, if available, via the CLI
-option ``--model-checker-solvers {all,cvc4,smtlib2,z3}`` or the JSON option
+option ``--model-checker-solvers {all,cvc4,eld,smtlib2,z3}`` or the JSON option
 ``settings.modelChecker.solvers=[smtlib2,z3]``, where:
 
 - ``cvc4`` is only available if the ``solc`` binary is compiled with it. Only BMC uses ``cvc4``.
+- ``eld`` is used via its binary which must be installed in the system. Only CHC uses ``eld``, and only if ``z3`` is not enabled.
 - ``smtlib2`` outputs SMT/Horn queries in the `smtlib2 <http://smtlib.cs.uiowa.edu/>`_ format.
   These can be used together with the compiler's `callback mechanism <https://github.com/ethereum/solc-js>`_ so that
   any solver binary from the system can be employed to synchronously return the results of the queries to the compiler.
-  This is currently the only way to use Eldarica, for example, since it does not have a C++ API.
   This can be used by both BMC and CHC depending on which solvers are called.
 - ``z3`` is available
 
   - if ``solc`` is compiled with it;
-  - if a dynamic ``z3`` library of version 4.8.x is installed in a Linux system (from Solidity 0.7.6);
-  - statically in ``soljson.js`` (from Solidity 0.6.9), that is, the Javascript binary of the compiler.
+  - if a dynamic ``z3`` library of version >=4.8.x is installed in a Linux system (from Solidity 0.7.6);
+  - statically in ``soljson.js`` (from Solidity 0.6.9), that is, the JavaScript binary of the compiler.
 
 .. note::
   z3 version 4.8.16 broke ABI compatibility with previous versions and cannot
   be used with solc <=0.8.13. If you are using z3 >=4.8.16 please use solc
-  >=0.8.14.
+  >=0.8.14, and conversely, only use older z3 with older solc releases.
+  We also recommend using the latest z3 release which is what SMTChecker also does.
 
 Since both BMC and CHC use ``z3``, and ``z3`` is available in a greater variety
 of environments, including in the browser, most users will almost never need to be
diff --git a/compiler/docs/solidity_logo.svg b/compiler/docs/solidity_logo.svg
new file mode 100644
index 00000000..86b9f499
--- /dev/null
+++ b/compiler/docs/solidity_logo.svg
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="1300px" height="1300px"
+	 viewBox="0 0 1300 1300" enable-background="new 0 0 1300 1300" xml:space="preserve">
+<title>Vector 1</title>
+<desc>Created with Sketch.</desc>
+<g id="Page-1" sketch:type="MSPage">
+	<g id="solidity" transform="translate(402.000000, 118.000000)" sketch:type="MSLayerGroup">
+		<g id="Group" sketch:type="MSShapeGroup">
+			<path id="Shape" opacity="0.45" enable-background="new    " d="M371.772,135.308L241.068,367.61H-20.158l130.614-232.302
+				H371.772"/>
+			<path id="Shape_1_" opacity="0.6" enable-background="new    " d="M241.068,367.61h261.318L371.772,135.308H110.456
+				L241.068,367.61z"/>
+			<path id="Shape_2_" opacity="0.8" enable-background="new    " d="M110.456,599.822L241.068,367.61L110.456,135.308
+				L-20.158,367.61L110.456,599.822z"/>
+			<path id="Shape_3_" opacity="0.45" enable-background="new    " d="M111.721,948.275l130.704-232.303h261.318L373.038,948.275
+				H111.721"/>
+			<path id="Shape_4_" opacity="0.6" enable-background="new    " d="M242.424,715.973H-18.893l130.613,232.303h261.317
+				L242.424,715.973z"/>
+			<path id="Shape_5_" opacity="0.8" enable-background="new    " d="M373.038,483.761L242.424,715.973l130.614,232.303
+				l130.704-232.303L373.038,483.761z"/>
+		</g>
+	</g>
+</g>
+</svg>
diff --git a/compiler/docs/structure-of-a-contract.rst b/compiler/docs/structure-of-a-contract.rst
index 740cce86..51d99a80 100644
--- a/compiler/docs/structure-of-a-contract.rst
+++ b/compiler/docs/structure-of-a-contract.rst
@@ -112,11 +112,11 @@ Events are convenience interfaces with the EVM logging facilities.
 .. code-block:: solidity
 
     // SPDX-License-Identifier: GPL-3.0
-    pragma solidity >=0.4.21 <0.9.0;
+    pragma solidity ^0.8.22;
 
-    contract SimpleAuction {
-        event HighestBidIncreased(address bidder, uint amount); // Event
+    event HighestBidIncreased(address bidder, uint amount); // Event
 
+    contract SimpleAuction {
         function bid() public payable {
             // ...
             emit HighestBidIncreased(msg.sender, msg.value); // Triggering event
diff --git a/compiler/docs/style-guide.rst b/compiler/docs/style-guide.rst
index 75de18ac..427ede5e 100644
--- a/compiler/docs/style-guide.rst
+++ b/compiler/docs/style-guide.rst
@@ -16,19 +16,19 @@ Many projects will implement their own style guides.  In the event of
 conflicts, project specific style guides take precedence.
 
 The structure and many of the recommendations within this style guide were
-taken from python's
-`pep8 style guide <https://www.python.org/dev/peps/pep-0008/>`_.
+taken from Python's
+`pep8 style guide <https://peps.python.org/pep-0008/>`_.
 
 The goal of this guide is *not* to be the right way or the best way to write
-Solidity code.  The goal of this guide is *consistency*.  A quote from python's
-`pep8 <https://www.python.org/dev/peps/pep-0008/#a-foolish-consistency-is-the-hobgoblin-of-little-minds>`_
+Solidity code.  The goal of this guide is *consistency*.  A quote from Python's
+`pep8 <https://peps.python.org/pep-0008/#a-foolish-consistency-is-the-hobgoblin-of-little-minds>`_
 captures this concept well.
 
 .. note::
 
     A style guide is about consistency. Consistency with this style guide is important. Consistency within a project is more important. Consistency within one module or function is most important.
 
-    But most importantly: **know when to be inconsistent** -- sometimes the style guide just doesn't apply. When in doubt, use your best judgment. Look at other examples and decide what looks best. And don't hesitate to ask!
+    But most importantly: **know when to be inconsistent** -- sometimes the style guide just doesn't apply. When in doubt, use your best judgment. Look at other examples and decide what looks best. And do not hesitate to ask!
 
 
 ***********
@@ -233,7 +233,7 @@ Yes:
         bytes32[] options
     );
 
-    LongAndLotsOfArgs(
+    emit LongAndLotsOfArgs(
         sender,
         recipient,
         publicKey,
@@ -251,7 +251,7 @@ No:
                             uint256 amount,
                             bytes32[] options);
 
-    LongAndLotsOfArgs(sender,
+    emit LongAndLotsOfArgs(sender,
                       recipient,
                       publicKey,
                       amount,
@@ -448,7 +448,7 @@ No:
     y            = 2;
     longVariable = 3;
 
-Don't include a whitespace in the receive and fallback functions:
+Do not include a whitespace in the receive and fallback functions:
 
 Yes:
 
@@ -1045,27 +1045,55 @@ No:
 Order of Layout
 ***************
 
-Layout contract elements in the following order:
+Contract elements should be laid out in the following order:
 
 1. Pragma statements
 2. Import statements
-3. Interfaces
-4. Libraries
-5. Contracts
+3. Events
+4. Errors
+5. Interfaces
+6. Libraries
+7. Contracts
 
 Inside each contract, library or interface, use the following order:
 
 1. Type declarations
 2. State variables
 3. Events
-4. Modifiers
-5. Functions
+4. Errors
+5. Modifiers
+6. Functions
 
 .. note::
 
     It might be clearer to declare types close to their use in events or state
     variables.
 
+Yes:
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.4 <0.9.0;
+
+    abstract contract Math {
+        error DivideByZero();
+        function divide(int256 numerator, int256 denominator) public virtual returns (uint256);
+    }
+
+No:
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >=0.8.4 <0.9.0;
+
+    abstract contract Math {
+        function divide(int256 numerator, int256 denominator) public virtual returns (uint256);
+        error DivideByZero();
+    }
+
+
 ******************
 Naming Conventions
 ******************
@@ -1130,15 +1158,15 @@ Yes:
     contract Owned {
         address public owner;
 
-        constructor() {
-            owner = msg.sender;
-        }
-
         modifier onlyOwner {
             require(msg.sender == owner);
             _;
         }
 
+        constructor() {
+            owner = msg.sender;
+        }
+
         function transferOwnership(address newOwner) public onlyOwner {
             owner = newOwner;
         }
@@ -1169,15 +1197,15 @@ No:
     contract owned {
         address public owner;
 
-        constructor() {
-            owner = msg.sender;
-        }
-
         modifier onlyOwner {
             require(msg.sender == owner);
             _;
         }
 
+        constructor() {
+            owner = msg.sender;
+        }
+
         function transferOwnership(address newOwner) public onlyOwner {
             owner = newOwner;
         }
@@ -1258,6 +1286,21 @@ Avoiding Naming Collisions
 This convention is suggested when the desired name collides with that of
 an existing state variable, function, built-in or otherwise reserved name.
 
+Underscore Prefix for Non-external Functions and Variables
+==========================================================
+
+* ``_singleLeadingUnderscore``
+
+This convention is suggested for non-external functions and state variables (``private`` or ``internal``). State variables without a specified visibility are ``internal`` by default.
+
+When designing a smart contract, the public-facing API (functions that can be called by any account)
+is an important consideration.
+Leading underscores allow you to immediately recognize the intent of such functions,
+but more importantly, if you change a function from non-external to external (including ``public``)
+and rename it accordingly, this forces you to review every call site while renaming.
+This can be an important manual check against unintended external functions
+and a common source of security vulnerabilities (avoid find-replace-all tooling for this change).
+
 .. _style_guide_natspec:
 
 *******
diff --git a/compiler/docs/types/conversion.rst b/compiler/docs/types/conversion.rst
index e6c68df4..dafb336b 100644
--- a/compiler/docs/types/conversion.rst
+++ b/compiler/docs/types/conversion.rst
@@ -44,7 +44,7 @@ Explicit Conversions
 
 If the compiler does not allow implicit conversion but you are confident a conversion will work,
 an explicit type conversion is sometimes possible. This may
-result in unexpected behaviour and allows you to bypass some security
+result in unexpected behavior and allows you to bypass some security
 features of the compiler, so be sure to test that the
 result is what you want and expect!
 
@@ -130,6 +130,7 @@ If the array is shorter than the target type, it will be padded with zeros at th
         }
     }
 
+.. index:: ! literal;conversion, literal;rational, literal;hexadecimal number
 .. _types-conversion-literals:
 
 Conversions between Literals and Elementary Types
@@ -152,6 +153,8 @@ that is large enough to represent it without truncation:
     converted to an integer type. From 0.8.0, such explicit conversions are as strict as implicit
     conversions, i.e., they are only allowed if the literal fits in the resulting range.
 
+.. index:: literal;string, literal;hexadecimal
+
 Fixed-Size Byte Arrays
 ----------------------
 
@@ -182,6 +185,8 @@ if their number of characters matches the size of the bytes type:
     bytes2 e = "x"; // not allowed
     bytes2 f = "xyz"; // not allowed
 
+.. index:: literal;address
+
 Addresses
 ---------
 
diff --git a/compiler/docs/types/mapping-types.rst b/compiler/docs/types/mapping-types.rst
index c59d6e84..454caaf0 100644
--- a/compiler/docs/types/mapping-types.rst
+++ b/compiler/docs/types/mapping-types.rst
@@ -4,12 +4,13 @@
 Mapping Types
 =============
 
-Mapping types use the syntax ``mapping(KeyType => ValueType)`` and variables
-of mapping type are declared using the syntax ``mapping(KeyType => ValueType) VariableName``.
-The ``KeyType`` can be any
-built-in value type, ``bytes``, ``string``, or any contract or enum type. Other user-defined
-or complex types, such as mappings, structs or array types are not allowed.
-``ValueType`` can be any type, including mappings, arrays and structs.
+Mapping types use the syntax ``mapping(KeyType KeyName? => ValueType ValueName?)`` and variables of
+mapping type are declared using the syntax ``mapping(KeyType KeyName? => ValueType ValueName?)
+VariableName``. The ``KeyType`` can be any built-in value type, ``bytes``, ``string``, or any
+contract or enum type. Other user-defined or complex types, such as mappings, structs or array types
+are not allowed. ``ValueType`` can be any type, including mappings, arrays and structs. ``KeyName``
+and ``ValueName`` are optional (so ``mapping(KeyType => ValueType)`` works as well) and can be any
+valid identifier that is not a type.
 
 You can think of mappings as `hash tables <https://en.wikipedia.org/wiki/Hash_table>`_, which are virtually initialised
 such that every possible key exists and is mapped to a value whose
@@ -29,8 +30,10 @@ of contract functions that are publicly visible.
 These restrictions are also true for arrays and structs that contain mappings.
 
 You can mark state variables of mapping type as ``public`` and Solidity creates a
-:ref:`getter <visibility-and-getters>` for you. The ``KeyType`` becomes a parameter for the getter.
-If ``ValueType`` is a value type or a struct, the getter returns ``ValueType``.
+:ref:`getter <visibility-and-getters>` for you. The ``KeyType`` becomes a parameter
+with name ``KeyName`` (if specified) for the getter.
+If ``ValueType`` is a value type or a struct, the getter returns ``ValueType`` with
+name ``ValueName`` (if specified).
 If ``ValueType`` is an array or a mapping, the getter has one parameter for
 each ``KeyType``, recursively.
 
@@ -64,6 +67,25 @@ contract that returns the value at the specified address.
 The example below is a simplified version of an
 `ERC20 token <https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol>`_.
 ``_allowances`` is an example of a mapping type inside another mapping type.
+
+In the example below, the optional ``KeyName`` and ``ValueName`` are provided for the mapping.
+It does not affect any contract functionality or bytecode, it only sets the ``name`` field
+for the inputs and outputs in the ABI for the mapping's getter.
+
+.. code-block:: solidity
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity ^0.8.18;
+
+    contract MappingExampleWithNames {
+        mapping(address user => uint balance) public balances;
+
+        function update(uint newBalance) public {
+            balances[msg.sender] = newBalance;
+        }
+    }
+
+
 The example below uses ``_allowances`` to record the amount someone else is allowed to withdraw from your account.
 
 .. code-block:: solidity
@@ -73,8 +95,8 @@ The example below uses ``_allowances`` to record the amount someone else is allo
 
     contract MappingExample {
 
-        mapping (address => uint256) private _balances;
-        mapping (address => mapping (address => uint256)) private _allowances;
+        mapping(address => uint256) private _balances;
+        mapping(address => mapping(address => uint256)) private _allowances;
 
         event Transfer(address indexed from, address indexed to, uint256 value);
         event Approval(address indexed owner, address indexed spender, uint256 value);
diff --git a/compiler/docs/types/reference-types.rst b/compiler/docs/types/reference-types.rst
index a6b5728c..d2e9300e 100644
--- a/compiler/docs/types/reference-types.rst
+++ b/compiler/docs/types/reference-types.rst
@@ -47,8 +47,8 @@ non-persistent area where function arguments are stored, and behaves mostly like
 
 .. _data-location-assignment:
 
-Data location and assignment behaviour
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Data location and assignment behavior
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Data locations are not only relevant for persistency of data, but also for the semantics of assignments:
 
@@ -133,9 +133,13 @@ It is possible to mark state variable arrays ``public`` and have Solidity create
 The numeric index becomes a required parameter for the getter.
 
 Accessing an array past its end causes a failing assertion. Methods ``.push()`` and ``.push(value)`` can be used
-to append a new element at the end of the array, where ``.push()`` appends a zero-initialized element and returns
+to append a new element at the end of a dynamically-sized array, where ``.push()`` appends a zero-initialized element and returns
 a reference to it.
 
+.. note::
+    Dynamically-sized arrays can only be resized in storage.
+    In memory, such arrays can be of arbitrary size but the size cannot be changed once an array is allocated.
+
 .. index:: ! string, ! bytes
 
 .. _strings:
@@ -231,7 +235,7 @@ with the :ref:`default value<default-value>`.
         }
     }
 
-.. index:: ! array;literals, ! inline;arrays
+.. index:: ! literal;array, ! inline;arrays
 
 Array Literals
 ^^^^^^^^^^^^^^
@@ -368,7 +372,7 @@ Array Members
 
 .. note::
     In EVM versions before Byzantium, it was not possible to access
-    dynamic arrays return from function calls. If you call functions
+    dynamic arrays returned from function calls. If you call functions
     that return dynamic arrays, make sure to use an EVM that is set to
     Byzantium mode.
 
@@ -578,10 +582,10 @@ and the assignment will effectively garble the length of ``x``.
 To be safe, only enlarge bytes arrays by at most one element during a single
 assignment and do not simultaneously index-access the array in the same statement.
 
-While the above describes the behaviour of dangling storage references in the
+While the above describes the behavior of dangling storage references in the
 current version of the compiler, any code with dangling references should be
-considered to have *undefined behaviour*. In particular, this means that
-any future version of the compiler may change the behaviour of code that
+considered to have *undefined behavior*. In particular, this means that
+any future version of the compiler may change the behavior of code that
 involves dangling references.
 
 Be sure to avoid dangling references in your code!
@@ -637,7 +641,7 @@ Array slices are useful to ABI-decode secondary data passed in function paramete
         /// after doing basic validation on the address argument.
         function forward(bytes calldata payload) external {
             bytes4 sig = bytes4(payload[:4]);
-            // Due to truncating behaviour, bytes4(payload) performs identically.
+            // Due to truncating behavior, bytes4(payload) performs identically.
             // bytes4 sig = bytes4(payload);
             if (sig == bytes4(keccak256("setOwner(address)"))) {
                 address owner = abi.decode(payload[4:], (address));
@@ -682,11 +686,11 @@ shown in the following example:
             uint fundingGoal;
             uint numFunders;
             uint amount;
-            mapping (uint => Funder) funders;
+            mapping(uint => Funder) funders;
         }
 
         uint numCampaigns;
-        mapping (uint => Campaign) campaigns;
+        mapping(uint => Campaign) campaigns;
 
         function newCampaign(address payable beneficiary, uint goal) public returns (uint campaignID) {
             campaignID = numCampaigns++; // campaignID is return variable
diff --git a/compiler/docs/types/value-types.rst b/compiler/docs/types/value-types.rst
index 1e8e3e7f..d44d2fd7 100644
--- a/compiler/docs/types/value-types.rst
+++ b/compiler/docs/types/value-types.rst
@@ -4,8 +4,7 @@
 Value Types
 ===========
 
-The following types are also called value types because variables of these
-types will always be passed by value, i.e. they are always copied when they
+The following are called value types because their variables will always be passed by value, i.e. they are always copied when they
 are used as function arguments or in assignments.
 
 .. index:: ! bool, ! true, ! false
@@ -47,7 +46,7 @@ access the minimum and maximum value representable by the type.
 
   Integers in Solidity are restricted to a certain range. For example, with ``uint32``, this is ``0`` up to ``2**32 - 1``.
   There are two modes in which arithmetic is performed on these types: The "wrapping" or "unchecked" mode and the "checked" mode.
-  By default, arithmetic is always "checked", which mean that if the result of an operation falls outside the value range
+  By default, arithmetic is always "checked", meaning that if an operation's result falls outside the value range
   of the type, the call is reverted through a :ref:`failing assertion<assert-and-require>`. You can switch to "unchecked" mode
   using ``unchecked { ... }``. More details can be found in the section about :ref:`unchecked <unchecked>`.
 
@@ -141,7 +140,7 @@ Exponentiation
 
 Exponentiation is only available for unsigned types in the exponent. The resulting type
 of an exponentiation is always equal to the type of the base. Please take care that it is
-large enough to hold the result and prepare for potential assertion failures or wrapping behaviour.
+large enough to hold the result and prepare for potential assertion failures or wrapping behavior.
 
 .. note::
   In checked mode, exponentiation only uses the comparatively cheap ``exp`` opcode for small bases.
@@ -182,7 +181,7 @@ Operators:
 Address
 -------
 
-The address type comes in two flavours, which are largely identical:
+The address type comes in two largely identical flavors:
 
 - ``address``: Holds a 20 byte value (size of an Ethereum address).
 - ``address payable``: Same as ``address``, but with the additional members ``transfer`` and ``send``.
@@ -258,13 +257,13 @@ reverts on failure.
 
 * ``send``
 
-Send is the low-level counterpart of ``transfer``. If the execution fails, the current contract will not stop with an exception, but ``send`` will return ``false``.
+``send`` is the low-level counterpart of ``transfer``. If the execution fails, the current contract will not stop with an exception, but ``send`` will return ``false``.
 
 .. warning::
     There are some dangers in using ``send``: The transfer fails if the call stack depth is at 1024
     (this can always be forced by the caller) and it also fails if the recipient runs out of gas. So in order
     to make safe Ether transfers, always check the return value of ``send``, use ``transfer`` or even better:
-    use a pattern where the recipient withdraws the money.
+    use a pattern where the recipient withdraws the Ether.
 
 * ``call``, ``delegatecall`` and ``staticcall``
 
@@ -424,7 +423,7 @@ Dynamically-sized byte array
 ``string``:
     Dynamically-sized UTF-8-encoded string, see :ref:`arrays`. Not a value-type!
 
-.. index:: address, literal;address
+.. index:: address, ! literal;address
 
 .. _address_literals:
 
@@ -440,7 +439,7 @@ an error. You can prepend (for integer types) or append (for bytesNN types) zero
 .. note::
     The mixed-case address checksum format is defined in `EIP-55 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md>`_.
 
-.. index:: literal, literal;rational
+.. index:: integer, rational number, ! literal;rational
 
 .. _rational_literals:
 
@@ -518,7 +517,7 @@ regardless of the type of the right (exponent) operand.
     uint128 a = 1;
     uint128 b = 2.5 + a + 0.5;
 
-.. index:: literal, literal;string, string
+.. index:: ! literal;string, string
 .. _string_literals:
 
 String Literals and Types
@@ -565,6 +564,8 @@ character sequence ``abcdef``.
 Any Unicode line terminator which is not a newline (i.e. LF, VF, FF, CR, NEL, LS, PS) is considered to
 terminate the string literal. Newline only terminates the string literal if it is not preceded by a ``\``.
 
+.. index:: ! literal;unicode
+
 Unicode Literals
 ----------------
 
@@ -575,7 +576,7 @@ They also support the very same escape sequences as regular string literals.
 
     string memory a = unicode"Hello 😃";
 
-.. index:: literal, bytes
+.. index:: ! literal;hexadecimal, bytes
 
 Hexadecimal Literals
 --------------------
@@ -589,7 +590,8 @@ of the hexadecimal sequence.
 Multiple hexadecimal literals separated by whitespace are concatenated into a single literal:
 ``hex"00112233" hex"44556677"`` is equivalent to ``hex"0011223344556677"``
 
-Hexadecimal literals behave like :ref:`string literals <string_literals>` and have the same convertibility restrictions.
+Hexadecimal literals in some ways behave like :ref:`string literals <string_literals>` but are not
+implicitly convertible to the ``string`` type.
 
 .. index:: enum
 
@@ -653,18 +655,18 @@ smallest and respectively largest value of the given enum.
 
 .. _user-defined-value-types:
 
-User Defined Value Types
+User-defined Value Types
 ------------------------
 
-A user defined value type allows creating a zero cost abstraction over an elementary value type.
+A user-defined value type allows creating a zero cost abstraction over an elementary value type.
 This is similar to an alias, but with stricter type requirements.
 
-A user defined value type is defined using ``type C is V``, where ``C`` is the name of the newly
+A user-defined value type is defined using ``type C is V``, where ``C`` is the name of the newly
 introduced type and ``V`` has to be a built-in value type (the "underlying type"). The function
 ``C.wrap`` is used to convert from the underlying type to the custom type. Similarly, the
 function ``C.unwrap`` is used to convert from the custom type to the underlying type.
 
-The type ``C`` does not have any operators or bound member functions. In particular, even the
+The type ``C`` does not have any operators or attached member functions. In particular, even the
 operator ``==`` is not defined. Explicit and implicit conversions to and from other types are
 disallowed.
 
@@ -680,7 +682,7 @@ type with 18 decimals and a minimal library to do arithmetic operations on the t
     // SPDX-License-Identifier: GPL-3.0
     pragma solidity ^0.8.8;
 
-    // Represent a 18 decimal, 256 bit wide fixed point type using a user defined value type.
+    // Represent a 18 decimal, 256 bit wide fixed point type using a user-defined value type.
     type UFixed256x18 is uint256;
 
     /// A minimal library to do fixed point operations on UFixed256x18.
@@ -770,6 +772,16 @@ confusing, but in essence, if a function is ``payable``, this means that it
 also accepts a payment of zero Ether, so it also is ``non-payable``.
 On the other hand, a ``non-payable`` function will reject Ether sent to it,
 so ``non-payable`` functions cannot be converted to ``payable`` functions.
+To clarify, rejecting ether is more restrictive than not rejecting ether.
+This means you can override a payable function with a non-payable but not the
+other way around.
+
+Additionally, When you define a ``non-payable`` function pointer,
+the compiler does not enforce that the pointed function will actually reject ether.
+Instead, it enforces that the function pointer is never used to send ether.
+Which makes it possible to assign a ``payable`` function pointer to a ``non-payable``
+function pointer ensuring both types behave the same way, i.e, both cannot be used
+to send ether.
 
 If a function type variable is not initialised, calling it results
 in a :ref:`Panic error<assert-and-require>`. The same happens if you call a function after using ``delete``
@@ -789,6 +801,24 @@ This includes private, internal and public functions of both contracts and libra
 functions.
 External function types, on the other hand, are only compatible with public and external contract
 functions.
+
+.. note::
+    External functions with ``calldata`` parameters are incompatible with external function types with ``calldata`` parameters.
+    They are compatible with the corresponding types with ``memory`` parameters instead.
+    For example, there is no function that can be pointed at by a value of type ``function (string calldata) external`` while
+    ``function (string memory) external`` can point at both ``function f(string memory) external {}`` and
+    ``function g(string calldata) external {}``.
+    This is because for both locations the arguments are passed to the function in the same way.
+    The caller cannot pass its calldata directly to an external function and always ABI-encodes the arguments into memory.
+    Marking the parameters as ``calldata`` only affects the implementation of the external function and is
+    meaningless in a function pointer on the caller's side.
+
+.. warning::
+    Comparison of internal function pointers can have unexpected results in the legacy pipeline with the optimizer enabled,
+    as it can collapse identical functions into one, which will then lead to said function pointers comparing as equal instead of not.
+    Such comparisons are not advised, and will lead to the compiler issuing a warning, until the next breaking release (0.9.0),
+    when the warning will be upgraded to an error, thereby making such comparisons disallowed.
+
 Libraries are excluded because they require a ``delegatecall`` and use :ref:`a different ABI
 convention for their selectors <library-selectors>`.
 Functions declared in interfaces do not have definitions so pointing at them does not make sense either.
diff --git a/compiler/docs/units-and-global-variables.rst b/compiler/docs/units-and-global-variables.rst
index b1939629..a0422c32 100644
--- a/compiler/docs/units-and-global-variables.rst
+++ b/compiler/docs/units-and-global-variables.rst
@@ -1,8 +1,10 @@
+.. index:: ! denomination
+
 **************************************
 Units and Globally Available Variables
 **************************************
 
-.. index:: wei, finney, szabo, gwei, ether
+.. index:: ! wei, ! finney, ! szabo, ! gwei, ! ether, ! denomination;ether
 
 Ether Units
 ===========
@@ -21,7 +23,7 @@ The only effect of the subdenomination suffix is a multiplication by a power of
 .. note::
     The denominations ``finney`` and ``szabo`` have been removed in version 0.7.0.
 
-.. index:: time, seconds, minutes, hours, days, weeks, years
+.. index:: ! seconds, ! minutes, ! hours, ! days, ! weeks, ! years, ! denomination;time
 
 Time Units
 ==========
@@ -52,7 +54,7 @@ interpret a function parameter in days, you can in the following way:
 
     function f(uint start, uint daysAfter) public {
         if (block.timestamp >= start + daysAfter * 1 days) {
-          // ...
+            // ...
         }
     }
 
@@ -65,19 +67,24 @@ There are special variables and functions which always exist in the global
 namespace and are mainly used to provide information about the blockchain
 or are general-use utility functions.
 
-.. index:: abi, block, coinbase, difficulty, encode, number, block;number, timestamp, block;timestamp, msg, data, gas, sender, value, gas price, origin
+.. index:: abi, block, coinbase, difficulty, prevrandao, encode, number, block;number, timestamp, block;timestamp, block;basefee, block;blobbasefee, msg, data, gas, sender, value, gas price, origin
 
 
 Block and Transaction Properties
 --------------------------------
 
 - ``blockhash(uint blockNumber) returns (bytes32)``: hash of the given block when ``blocknumber`` is one of the 256 most recent blocks; otherwise returns zero
+- ``blobhash(uint index) returns (bytes32)``: versioned hash of the ``index``-th blob associated with the current transaction.
+  A versioned hash consists of a single byte representing the version (currently ``0x01``), followed by the last 31 bytes
+  of the SHA256 hash of the KZG commitment (`EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_).
 - ``block.basefee`` (``uint``): current block's base fee (`EIP-3198 <https://eips.ethereum.org/EIPS/eip-3198>`_ and `EIP-1559 <https://eips.ethereum.org/EIPS/eip-1559>`_)
+- ``block.blobbasefee`` (``uint``): current block's blob base fee (`EIP-7516 <https://eips.ethereum.org/EIPS/eip-7516>`_ and `EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_)
 - ``block.chainid`` (``uint``): current chain id
 - ``block.coinbase`` (``address payable``): current block miner's address
-- ``block.difficulty`` (``uint``): current block difficulty
+- ``block.difficulty`` (``uint``): current block difficulty (``EVM < Paris``). For other EVM versions it behaves as a deprecated alias for ``block.prevrandao`` (`EIP-4399 <https://eips.ethereum.org/EIPS/eip-4399>`_ )
 - ``block.gaslimit`` (``uint``): current block gaslimit
 - ``block.number`` (``uint``): current block number
+- ``block.prevrandao`` (``uint``): random number provided by the beacon chain (``EVM >= Paris``)
 - ``block.timestamp`` (``uint``): current block timestamp as seconds since unix epoch
 - ``gasleft() returns (uint256)``: remaining gas
 - ``msg.data`` (``bytes calldata``): complete calldata
@@ -104,7 +111,7 @@ Block and Transaction Properties
 
     Both the timestamp and the block hash can be influenced by miners to some degree.
     Bad actors in the mining community can for example run a casino payout function on a chosen hash
-    and just retry a different hash if they did not receive any money.
+    and just retry a different hash if they did not receive any compensation, e.g. Ether.
 
     The current block timestamp must be strictly larger than the timestamp of the last block,
     but the only guarantee is that it will be somewhere between the timestamps of two
@@ -231,8 +238,8 @@ Mathematical and Cryptographic Functions
     for _transaction_ signatures (see `EIP-2 <https://eips.ethereum.org/EIPS/eip-2#specification>`_), but
     the ecrecover function remained unchanged.
 
-    This is usually not a problem unless you require signatures to be unique or
-    use them to identify items. OpenZeppelin have a `ECDSA helper library <https://docs.openzeppelin.com/contracts/2.x/api/cryptography#ECDSA>`_ that you can use as a wrapper for ``ecrecover`` without this issue.
+    This is usually not a problem unless you require signatures to be unique or use them to identify items.
+    OpenZeppelin has an `ECDSA helper library <https://docs.openzeppelin.com/contracts/4.x/api/utils#ECDSA>`_ that you can use as a wrapper for ``ecrecover`` without this issue.
 
 .. note::
 
@@ -279,7 +286,7 @@ For more information, see the section on :ref:`address`.
     There are some dangers in using ``send``: The transfer fails if the call stack depth is at 1024
     (this can always be forced by the caller) and it also fails if the recipient runs out of gas. So in order
     to make safe Ether transfers, always check the return value of ``send``, use ``transfer`` or even better:
-    Use a pattern where the recipient withdraws the money.
+    Use a pattern where the recipient withdraws the Ether.
 
 .. warning::
     Due to the fact that the EVM considers a call to a non-existing contract to always succeed,
@@ -310,13 +317,16 @@ For more information, see the section on :ref:`address`.
     semantics than ``delegatecall``.
 
 
-.. index:: this, selfdestruct
+.. index:: this, selfdestruct, super
 
-Contract Related
+Contract-related
 ----------------
 
 ``this`` (current contract's type)
-    the current contract, explicitly convertible to :ref:`address`
+    The current contract, explicitly convertible to :ref:`address`
+
+``super``
+    A contract one level higher in the inheritance hierarchy
 
 ``selfdestruct(address payable recipient)``
     Destroy the current contract, sending its funds to the given :ref:`address`
@@ -326,11 +336,13 @@ Contract Related
     - the receiving contract's receive function is not executed.
     - the contract is only really destroyed at the end of the transaction and ``revert`` s might "undo" the destruction.
 
-
-
-
 Furthermore, all functions of the current contract are callable directly including the current function.
 
+.. warning::
+    From version 0.8.18 and up, the use of ``selfdestruct`` in both Solidity and Yul will trigger a
+    deprecation warning, since the ``SELFDESTRUCT`` opcode will eventually undergo breaking changes in behavior
+    as stated in `EIP-6049 <https://eips.ethereum.org/EIPS/eip-6049>`_.
+
 .. note::
     Prior to version 0.5.0, there was a function called ``suicide`` with the same
     semantics as ``selfdestruct``.
@@ -372,7 +384,7 @@ The following properties are available for a contract type ``C``:
 In addition to the properties above, the following properties are available
 for an interface type ``I``:
 
-``type(I).interfaceId``:
+``type(I).interfaceId``
     A ``bytes4`` value containing the `EIP-165 <https://eips.ethereum.org/EIPS/eip-165>`_
     interface identifier of the given interface ``I``. This identifier is defined as the ``XOR`` of all
     function selectors defined within the interface itself - excluding all inherited functions.
@@ -394,4 +406,4 @@ These keywords are reserved in Solidity. They might become part of the syntax in
 ``define``, ``final``, ``implements``, ``in``, ``inline``, ``let``, ``macro``, ``match``,
 ``mutable``, ``null``, ``of``, ``partial``, ``promise``, ``reference``, ``relocatable``,
 ``sealed``, ``sizeof``, ``static``, ``supports``, ``switch``, ``typedef``, ``typeof``,
-``var``.
\ No newline at end of file
+``var``.
diff --git a/compiler/docs/using-the-compiler.rst b/compiler/docs/using-the-compiler.rst
index d6bf94a2..97abbdba 100644
--- a/compiler/docs/using-the-compiler.rst
+++ b/compiler/docs/using-the-compiler.rst
@@ -15,7 +15,7 @@ Using the Commandline Compiler
 Basic Usage
 -----------
 
-One of the build targets of the Solidity repository is ``solc``, the solidity commandline compiler.
+One of the build targets of the Solidity repository is ``solc``, the Solidity commandline compiler.
 Using ``solc --help`` provides you with an explanation of all options. The compiler can produce various outputs, ranging from simple binaries and assembly over an abstract syntax tree (parse tree) to estimations of gas usage.
 If you only want to compile a single file, you run it as ``solc --bin sourceFile.sol`` and it will print the binary. If you want to get some of the more advanced output variants of ``solc``, it is probably better to tell it to output everything to separate files using ``solc -o outputDirectory --bin --ast-compact-json --asm sourceFile.sol``.
 
@@ -54,7 +54,7 @@ or ../ <direct-imports>` are treated as relative to the directories specified us
 Furthermore, the part of the path added via these options will not appear in the contract metadata.
 
 For security reasons the compiler has :ref:`restrictions on what directories it can access <allowed-paths>`.
-Directories of source files specified on the command line and target paths of
+Directories of source files specified on the command-line and target paths of
 remappings are automatically allowed to be accessed by the file reader, but everything
 else is rejected by default.
 Additional paths (and their subdirectories) can be allowed via the
@@ -114,15 +114,15 @@ Setting the EVM Version to Target
 *********************************
 
 When you compile your contract code you can specify the Ethereum virtual machine
-version to compile for to avoid particular features or behaviours.
+version to compile for to avoid particular features or behaviors.
 
 .. warning::
 
    Compiling for the wrong EVM version can result in wrong, strange and failing
-   behaviour. Please ensure, especially if running a private chain, that you
+   behavior. Please ensure, especially if running a private chain, that you
    use matching EVM versions.
 
-On the command line, you can select the EVM version as follows:
+On the command-line, you can select the EVM version as follows:
 
 .. code-block:: shell
 
@@ -147,20 +147,20 @@ Target Options
 Below is a list of target EVM versions and the compiler-relevant changes introduced
 at each version. Backward compatibility is not guaranteed between each version.
 
-- ``homestead``
+- ``homestead`` (*support deprecated*)
    - (oldest version)
-- ``tangerineWhistle``
+- ``tangerineWhistle`` (*support deprecated*)
    - Gas cost for access to other accounts increased, relevant for gas estimation and the optimizer.
    - All gas sent by default for external calls, previously a certain amount had to be retained.
-- ``spuriousDragon``
+- ``spuriousDragon`` (*support deprecated*)
    - Gas cost for the ``exp`` opcode increased, relevant for gas estimation and the optimizer.
-- ``byzantium``
+- ``byzantium`` (*support deprecated*)
    - Opcodes ``returndatacopy``, ``returndatasize`` and ``staticcall`` are available in assembly.
    - The ``staticcall`` opcode is used when calling non-library view or pure functions, which prevents the functions from modifying state at the EVM level, i.e., even applies when you use invalid type conversions.
    - It is possible to access dynamic data returned from function calls.
    - ``revert`` opcode introduced, which means that ``revert()`` will not waste gas.
 - ``constantinople``
-   - Opcodes ``create2`, ``extcodehash``, ``shl``, ``shr`` and ``sar`` are available in assembly.
+   - Opcodes ``create2``, ``extcodehash``, ``shl``, ``shr`` and ``sar`` are available in assembly.
    - Shifting operators use shifting opcodes and thus need less gas.
 - ``petersburg``
    - The compiler behaves the same way as with constantinople.
@@ -170,9 +170,17 @@ at each version. Backward compatibility is not guaranteed between each version.
    - Gas costs for ``SLOAD``, ``*CALL``, ``BALANCE``, ``EXT*`` and ``SELFDESTRUCT`` increased. The
      compiler assumes cold gas costs for such operations. This is relevant for gas estimation and
      the optimizer.
-- ``london`` (**default**)
+- ``london``
    - The block's base fee (`EIP-3198 <https://eips.ethereum.org/EIPS/eip-3198>`_ and `EIP-1559 <https://eips.ethereum.org/EIPS/eip-1559>`_) can be accessed via the global ``block.basefee`` or ``basefee()`` in inline assembly.
-
+- ``paris``
+   - Introduces ``prevrandao()`` and ``block.prevrandao``, and changes the semantics of the now deprecated ``block.difficulty``, disallowing ``difficulty()`` in inline assembly (see `EIP-4399 <https://eips.ethereum.org/EIPS/eip-4399>`_).
+- ``shanghai`` (**default**)
+   - Smaller code size and gas savings due to the introduction of ``push0`` (see `EIP-3855 <https://eips.ethereum.org/EIPS/eip-3855>`_).
+- ``cancun``
+   - The block's blob base fee (`EIP-7516 <https://eips.ethereum.org/EIPS/eip-7516>`_ and `EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_) can be accessed via the global ``block.blobbasefee`` or ``blobbasefee()`` in inline assembly.
+   - Introduces ``blobhash()`` in inline assembly and a corresponding global function to retrieve versioned hashes of blobs associated with the transaction (see `EIP-4844 <https://eips.ethereum.org/EIPS/eip-4844>`_).
+   - Opcode ``mcopy`` is available in assembly (see `EIP-5656 <https://eips.ethereum.org/EIPS/eip-5656>`_).
+   - Opcodes ``tstore`` and ``tload`` are available in assembly (see `EIP-1153 <https://eips.ethereum.org/EIPS/eip-1153>`_).
 
 .. index:: ! standard JSON, ! --standard-json
 .. _compiler-api:
@@ -200,7 +208,7 @@ Input Description
 .. code-block:: javascript
 
     {
-      // Required: Source code language. Currently supported are "Solidity" and "Yul".
+      // Required: Source code language. Currently supported are "Solidity", "Yul", "SolidityAST" (experimental), "EVMAssembly" (experimental).
       "language": "Solidity",
       // Required
       "sources":
@@ -224,7 +232,7 @@ Input Description
             "bzzr://56ab...",
             "ipfs://Qma...",
             "/tmp/path/to/file.sol"
-            // If files are used, their directories should be added to the command line via
+            // If files are used, their directories should be added to the command-line via
             // `--allow-paths <path>`.
           ]
         },
@@ -234,6 +242,33 @@ Input Description
           "keccak256": "0x234...",
           // Required (unless "urls" is used): literal contents of the source file
           "content": "contract destructible is owned { function shutdown() { if (msg.sender == owner) selfdestruct(owner); } }"
+        },
+        "myFile.sol_json.ast":
+        {
+          // If language is set to "SolidityAST", an AST needs to be supplied under the "ast" key
+          // and there can be only one source file present.
+          // The format is the same as used by the `ast` output.
+          // Note that importing ASTs is experimental and in particular that:
+          // - importing invalid ASTs can produce undefined results and
+          // - no proper error reporting is available on invalid ASTs.
+          // Furthermore, note that the AST import only consumes the fields of the AST as
+          // produced by the compiler in "stopAfter": "parsing" mode and then re-performs
+          // analysis, so any analysis-based annotations of the AST are ignored upon import.
+          "ast": { ... }
+        },
+        "myFile_evm.json":
+        {
+          // If language is set to "EVMAssembly", an EVM Assembly JSON object needs to be supplied
+          // under the "assemblyJson" key and there can be only one source file present.
+          // The format is the same as used by the `evm.legacyAssembly` output or `--asm-json`
+          // output on the command line.
+          // Note that importing EVM assembly is experimental.
+          "assemblyJson":
+          {
+            ".code": [ ... ],
+            ".data": { ... }, // optional
+            "sourceList": [ ... ] // optional (if no `source` node was defined in any `.code` object)
+          }
         }
       },
       // Optional
@@ -261,9 +296,9 @@ Input Description
             // The peephole optimizer is always on if no details are given,
             // use details to switch it off.
             "peephole": true,
-            // The inliner is always on if no details are given,
-            // use details to switch it off.
-            "inliner": true,
+            // The inliner is always off if no details are given,
+            // use details to switch it on.
+            "inliner": false,
             // The unused jumpdest remover is always on if no details are given,
             // use details to switch it off.
             "jumpdestRemover": true,
@@ -276,6 +311,9 @@ Input Description
             "cse": false,
             // Optimize representation of literal numbers and strings in code.
             "constantOptimizer": false,
+            // Use unchecked arithmetic when incrementing the counter of for loops
+            // under certain circumstances. It is always on if no details are given.
+            "simpleCounterForLoopUncheckedIncrement": true,
             // The new Yul optimizer. Mostly operates on the code of ABI coder v2
             // and inline assembly.
             // It is activated together with the global optimizer setting
@@ -287,16 +325,27 @@ Input Description
               // Improve allocation of stack slots for variables, can free up stack slots early.
               // Activated by default if the Yul optimizer is activated.
               "stackAllocation": true,
-              // Select optimization steps to be applied.
-              // Optional, the optimizer will use the default sequence if omitted.
+              // Select optimization steps to be applied. It is also possible to modify both the
+              // optimization sequence and the clean-up sequence. Instructions for each sequence
+              // are separated with the ":" delimiter and the values are provided in the form of
+              // optimization-sequence:clean-up-sequence. For more information see
+              // "The Optimizer > Selecting Optimizations".
+              // This field is optional, and if not provided, the default sequences for both
+              // optimization and clean-up are used. If only one of the sequences is provided
+              // the other will not be run.
+              // If only the delimiter ":" is provided then neither the optimization nor the clean-up
+              // sequence will be run.
+              // If set to an empty value, only the default clean-up sequence is used and
+              // no optimization steps are applied.
               "optimizerSteps": "dhfoDgvulfnTUtnIf..."
             }
           }
         },
         // Version of the EVM to compile for.
         // Affects type checking and code generation. Can be homestead,
-        // tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, istanbul or berlin
-        "evmVersion": "byzantium",
+        // tangerineWhistle, spuriousDragon, byzantium, constantinople,
+        // petersburg, istanbul, berlin, london, paris or shanghai (default)
+        "evmVersion": "shanghai",
         // Optional: Change compilation pipeline to go through the Yul intermediate representation.
         // This is false by default.
         "viaIR": true,
@@ -323,6 +372,9 @@ Input Description
         },
         // Metadata settings (optional)
         "metadata": {
+          // The CBOR metadata is appended at the end of the bytecode by default.
+          // Setting this to false omits the metadata from the runtime and deploy time code.
+          "appendCBOR": true,
           // Use only literal content and not URLs (false by default)
           "useLiteralContent": true,
           // Use the given hash method for the metadata hash that is appended to the bytecode.
@@ -334,7 +386,7 @@ Input Description
         // Addresses of the libraries. If not all libraries are given here,
         // it can result in unlinked objects whose output data is different.
         "libraries": {
-          // The top level key is the the name of the source file where the library is used.
+          // The top level key is the name of the source file where the library is used.
           // If remappings are used, this source file should match the global path
           // after remappings were applied.
           // If this key is an empty string, that refers to a global level.
@@ -366,7 +418,9 @@ Input Description
         //   userdoc - User documentation (natspec)
         //   metadata - Metadata
         //   ir - Yul intermediate representation of the code before optimization
+        //   irAst - AST of Yul intermediate representation of the code before optimization
         //   irOptimized - Intermediate representation after optimization
+        //   irOptimizedAst - AST of intermediate representation after optimization
         //   storageLayout - Slots, offsets and types of the contract's state variables.
         //   evm.assembly - New assembly format
         //   evm.legacyAssembly - Old-style assembly format in JSON
@@ -380,10 +434,8 @@ Input Description
         //   evm.deployedBytecode.immutableReferences - Map from AST ids to bytecode ranges that reference immutables
         //   evm.methodIdentifiers - The list of function hashes
         //   evm.gasEstimates - Function gas estimates
-        //   ewasm.wast - Ewasm in WebAssembly S-expressions format
-        //   ewasm.wasm - Ewasm in WebAssembly binary format
         //
-        // Note that using a using `evm`, `evm.bytecode`, `ewasm`, etc. will select every
+        // Note that using `evm`, `evm.bytecode`, etc. will select every
         // target part of that output. Additionally, `*` can be used as a wildcard to request everything.
         //
         "outputSelection": {
@@ -419,10 +471,18 @@ Input Description
           "divModNoSlacks": false,
           // Choose which model checker engine to use: all (default), bmc, chc, none.
           "engine": "chc",
+          // Choose whether external calls should be considered trusted in case the
+          // code of the called function is available at compile-time.
+          // For details see the SMTChecker section.
+          "extCalls": "trusted",
           // Choose which types of invariants should be reported to the user: contract, reentrancy.
           "invariants": ["contract", "reentrancy"],
+          // Choose whether to output all proved targets. The default is `false`.
+          "showProved": true,
           // Choose whether to output all unproved targets. The default is `false`.
           "showUnproved": true,
+          // Choose whether to output all unsupported language features. The default is `false`.
+          "showUnsupported": true,
           // Choose which solvers should be used, if available.
           // See the Formal Verification section for the solvers description.
           "solvers": ["cvc4", "smtlib2", "z3"],
@@ -469,7 +529,7 @@ Output Description
           // Mandatory: Error type, such as "TypeError", "InternalCompilerError", "Exception", etc.
           // See below for complete list of types.
           "type": "TypeError",
-          // Mandatory: Component where the error originated, such as "general", "ewasm", etc.
+          // Mandatory: Component where the error originated, such as "general" etc.
           "component": "general",
           // Mandatory ("error", "warning" or "info", but please note that this may be extended in the future)
           "severity": "error",
@@ -506,8 +566,14 @@ Output Description
             "userdoc": {},
             // Developer documentation (natspec)
             "devdoc": {},
-            // Intermediate representation (string)
+            // Intermediate representation before optimization (string)
             "ir": "",
+            // AST of intermediate representation before optimization
+            "irAst":  {/* ... */},
+            // Intermediate representation after optimization (string)
+            "irOptimized": "",
+            // AST of intermediate representation after optimization
+            "irOptimizedAst": {/* ... */},
             // See the Storage Layout documentation.
             "storageLayout": {"storage": [/* ... */], "types": {/* ... */} },
             // EVM-related outputs
@@ -585,13 +651,6 @@ Output Description
                   "heavyLifting()": "infinite"
                 }
               }
-            },
-            // Ewasm related outputs
-            "ewasm": {
-              // S-expressions format
-              "wast": "",
-              // Binary format (hex string)
-              "wasm": ""
             }
           }
         }
@@ -614,231 +673,6 @@ Error Types
 10. ``Exception``: Unknown failure during compilation - this should be reported as an issue.
 11. ``CompilerError``: Invalid use of the compiler stack - this should be reported as an issue.
 12. ``FatalError``: Fatal error not processed correctly - this should be reported as an issue.
-13. ``YulException``: Error during Yul Code generation - this should be reported as an issue.
+13. ``YulException``: Error during Yul code generation - this should be reported as an issue.
 14. ``Warning``: A warning, which didn't stop the compilation, but should be addressed if possible.
 15. ``Info``: Information that the compiler thinks the user might find useful, but is not dangerous and does not necessarily need to be addressed.
-
-
-.. _compiler-tools:
-
-Compiler Tools
-**************
-
-solidity-upgrade
-----------------
-
-``solidity-upgrade`` can help you to semi-automatically upgrade your contracts
-to breaking language changes. While it does not and cannot implement all
-required changes for every breaking release, it still supports the ones, that
-would need plenty of repetitive manual adjustments otherwise.
-
-.. note::
-
-    ``solidity-upgrade`` carries out a large part of the work, but your
-    contracts will most likely need further manual adjustments. We recommend
-    using a version control system for your files. This helps reviewing and
-    eventually rolling back the changes made.
-
-.. warning::
-
-    ``solidity-upgrade`` is not considered to be complete or free from bugs, so
-    please use with care.
-
-How it Works
-~~~~~~~~~~~~
-
-You can pass (a) Solidity source file(s) to ``solidity-upgrade [files]``. If
-these make use of ``import`` statement which refer to files outside the
-current source file's directory, you need to specify directories that
-are allowed to read and import files from, by passing
-``--allow-paths [directory]``. You can ignore missing files by passing
-``--ignore-missing``.
-
-``solidity-upgrade`` is based on ``libsolidity`` and can parse, compile and
-analyse your source files, and might find applicable source upgrades in them.
-
-Source upgrades are considered to be small textual changes to your source code.
-They are applied to an in-memory representation of the source files
-given. The corresponding source file is updated by default, but you can pass
-``--dry-run`` to simulate to whole upgrade process without writing to any file.
-
-The upgrade process itself has two phases. In the first phase source files are
-parsed, and since it is not possible to upgrade source code on that level,
-errors are collected and can be logged by passing ``--verbose``. No source
-upgrades available at this point.
-
-In the second phase, all sources are compiled and all activated upgrade analysis
-modules are run alongside compilation. By default, all available modules are
-activated. Please read the documentation on
-:ref:`available modules <upgrade-modules>` for further details.
-
-
-This can result in compilation errors that may
-be fixed by source upgrades. If no errors occur, no source upgrades are being
-reported and you're done.
-If errors occur and some upgrade module reported a source upgrade, the first
-reported one gets applied and compilation is triggered again for all given
-source files. The previous step is repeated as long as source upgrades are
-reported. If errors still occur, you can log them by passing ``--verbose``.
-If no errors occur, your contracts are up to date and can be compiled with
-the latest version of the compiler.
-
-.. _upgrade-modules:
-
-Available Upgrade Modules
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-+----------------------------+---------+--------------------------------------------------+
-| Module                     | Version | Description                                      |
-+============================+=========+==================================================+
-| ``constructor``            | 0.5.0   | Constructors must now be defined using the       |
-|                            |         | ``constructor`` keyword.                         |
-+----------------------------+---------+--------------------------------------------------+
-| ``visibility``             | 0.5.0   | Explicit function visibility is now mandatory,   |
-|                            |         | defaults to ``public``.                          |
-+----------------------------+---------+--------------------------------------------------+
-| ``abstract``               | 0.6.0   | The keyword ``abstract`` has to be used if a     |
-|                            |         | contract does not implement all its functions.   |
-+----------------------------+---------+--------------------------------------------------+
-| ``virtual``                | 0.6.0   | Functions without implementation outside an      |
-|                            |         | interface have to be marked ``virtual``.         |
-+----------------------------+---------+--------------------------------------------------+
-| ``override``               | 0.6.0   | When overriding a function or modifier, the new  |
-|                            |         | keyword ``override`` must be used.               |
-+----------------------------+---------+--------------------------------------------------+
-| ``dotsyntax``              | 0.7.0   | The following syntax is deprecated:              |
-|                            |         | ``f.gas(...)()``, ``f.value(...)()`` and         |
-|                            |         | ``(new C).value(...)()``. Replace these calls by |
-|                            |         | ``f{gas: ..., value: ...}()`` and                |
-|                            |         | ``(new C){value: ...}()``.                       |
-+----------------------------+---------+--------------------------------------------------+
-| ``now``                    | 0.7.0   | The ``now`` keyword is deprecated. Use           |
-|                            |         | ``block.timestamp`` instead.                     |
-+----------------------------+---------+--------------------------------------------------+
-| ``constructor-visibility`` | 0.7.0   | Removes visibility of constructors.              |
-|                            |         |                                                  |
-+----------------------------+---------+--------------------------------------------------+
-
-Please read :doc:`0.5.0 release notes <050-breaking-changes>`,
-:doc:`0.6.0 release notes <060-breaking-changes>`,
-:doc:`0.7.0 release notes <070-breaking-changes>` and :doc:`0.8.0 release notes <080-breaking-changes>` for further details.
-
-Synopsis
-~~~~~~~~
-
-.. code-block:: none
-
-    Usage: solidity-upgrade [options] contract.sol
-
-    Allowed options:
-        --help               Show help message and exit.
-        --version            Show version and exit.
-        --allow-paths path(s)
-                             Allow a given path for imports. A list of paths can be
-                             supplied by separating them with a comma.
-        --ignore-missing     Ignore missing files.
-        --modules module(s)  Only activate a specific upgrade module. A list of
-                             modules can be supplied by separating them with a comma.
-        --dry-run            Apply changes in-memory only and don't write to input
-                             file.
-        --verbose            Print logs, errors and changes. Shortens output of
-                             upgrade patches.
-        --unsafe             Accept *unsafe* changes.
-
-
-
-Bug Reports / Feature Requests
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you found a bug or if you have a feature request, please
-`file an issue <https://github.com/ethereum/solidity/issues/new/choose>`_ on Github.
-
-
-Example
-~~~~~~~
-
-Assume that you have the following contract in ``Source.sol``:
-
-.. code-block:: Solidity
-
-    pragma solidity >=0.6.0 <0.6.4;
-    // This will not compile after 0.7.0
-    // SPDX-License-Identifier: GPL-3.0
-    contract C {
-        // FIXME: remove constructor visibility and make the contract abstract
-        constructor() internal {}
-    }
-
-    contract D {
-        uint time;
-
-        function f() public payable {
-            // FIXME: change now to block.timestamp
-            time = now;
-        }
-    }
-
-    contract E {
-        D d;
-
-        // FIXME: remove constructor visibility
-        constructor() public {}
-
-        function g() public {
-            // FIXME: change .value(5) =>  {value: 5}
-            d.f.value(5)();
-        }
-    }
-
-
-
-Required Changes
-^^^^^^^^^^^^^^^^
-
-The above contract will not compile starting from 0.7.0. To bring the contract up to date with the
-current Solidity version, the following upgrade modules have to be executed:
-``constructor-visibility``, ``now`` and ``dotsyntax``. Please read the documentation on
-:ref:`available modules <upgrade-modules>` for further details.
-
-
-Running the Upgrade
-^^^^^^^^^^^^^^^^^^^
-
-It is recommended to explicitly specify the upgrade modules by using ``--modules`` argument.
-
-.. code-block:: bash
-
-    solidity-upgrade --modules constructor-visibility,now,dotsyntax Source.sol
-
-The command above applies all changes as shown below. Please review them carefully (the pragmas will
-have to be updated manually.)
-
-.. code-block:: Solidity
-
-    // SPDX-License-Identifier: GPL-3.0
-    pragma solidity >=0.7.0 <0.9.0;
-    abstract contract C {
-        // FIXME: remove constructor visibility and make the contract abstract
-        constructor() {}
-    }
-
-    contract D {
-        uint time;
-
-        function f() public payable {
-            // FIXME: change now to block.timestamp
-            time = block.timestamp;
-        }
-    }
-
-    contract E {
-        D d;
-
-        // FIXME: remove constructor visibility
-        constructor() {}
-
-        function g() public {
-            // FIXME: change .value(5) =>  {value: 5}
-            d.f{value: 5}();
-        }
-    }
diff --git a/compiler/docs/yul.rst b/compiler/docs/yul.rst
index 7ce01016..3cf2785f 100644
--- a/compiler/docs/yul.rst
+++ b/compiler/docs/yul.rst
@@ -9,13 +9,9 @@ Yul
 Yul (previously also called JULIA or IULIA) is an intermediate language that can be
 compiled to bytecode for different backends.
 
-Support for EVM 1.0, EVM 1.5 and Ewasm is planned, and it is designed to
-be a usable common denominator of all three
-platforms. It can already be used in stand-alone mode and
-for "inline assembly" inside Solidity
-and there is an experimental implementation of the Solidity compiler
-that uses Yul as an intermediate language. Yul is a good target for
-high-level optimisation stages that can benefit all target platforms equally.
+It can be used in stand-alone mode and for "inline assembly" inside Solidity.
+The compiler uses Yul as an intermediate language in the IR-based code generator ("new codegen" or "IR-based codegen").
+Yul is a good target for high-level optimisation stages that can benefit all target platforms equally.
 
 Motivation and High-level Description
 =====================================
@@ -89,7 +85,6 @@ It can be compiled using ``solc --strict-assembly``. The builtin functions
 
 It is also possible to implement the same function using a for-loop
 instead of with recursion. Here, ``lt(a, b)`` computes whether ``a`` is less than ``b``.
-less-than comparison.
 
 .. code-block:: yul
 
@@ -157,7 +152,7 @@ where an object is expected.
 Inside a code block, the following elements can be used
 (see the later sections for more details):
 
-- literals, i.e. ``0x123``, ``42`` or ``"abc"`` (strings up to 32 characters)
+- literals, e.g. ``0x123``, ``42`` or ``"abc"`` (strings up to 32 characters)
 - calls to builtin functions, e.g. ``add(1, mload(0))``
 - variable declarations, e.g. ``let x := 7``, ``let x := add(y, 3)`` or ``let x`` (initial value of 0 is assigned)
 - identifiers (variables), e.g. ``add(3, x)``
@@ -171,6 +166,8 @@ Inside a code block, the following elements can be used
 Multiple syntactical elements can follow each other simply separated by
 whitespace, i.e. there is no terminating ``;`` or newline required.
 
+.. index:: ! literal;in Yul
+
 Literals
 --------
 
@@ -243,7 +240,7 @@ they have to be assigned to local variables.
 For built-in functions of the EVM, functional expressions
 can be directly translated to a stream of opcodes:
 You just read the expression from right to left to obtain the
-opcodes. In the case of the first line in the example, this
+opcodes. In the case of the second line in the example, this
 is ``PUSH1 3 PUSH1 0x80 MLOAD ADD PUSH1 0x80 MSTORE``.
 
 For calls to user-defined functions, the arguments are also
@@ -744,7 +741,7 @@ EVM Dialect
 -----------
 
 The default dialect of Yul currently is the EVM dialect for the currently selected version of the EVM.
-with a version of the EVM. The only type available in this dialect
+The only type available in this dialect
 is ``u256``, the 256-bit native type of the Ethereum Virtual Machine.
 Since it is the default type of this dialect, it can be omitted.
 
@@ -755,11 +752,12 @@ This document does not want to be a full description of the Ethereum virtual mac
 Please refer to a different document if you are interested in the precise semantics.
 
 Opcodes marked with ``-`` do not return a result and all others return exactly one value.
-Opcodes marked with ``F``, ``H``, ``B``, ``C``, ``I`` and ``L`` are present since Frontier, Homestead,
-Byzantium, Constantinople, Istanbul or London respectively.
+Opcodes marked with ``F``, ``H``, ``B``, ``C``, ``I``, ``L``, ``P`` and ``N`` are present since Frontier,
+Homestead, Byzantium, Constantinople, Istanbul, London, Paris or Cancun respectively.
 
 In the following, ``mem[a...b)`` signifies the bytes of memory starting at position ``a`` up to
-but not including position ``b`` and ``storage[p]`` signifies the storage contents at slot ``p``.
+but not including position ``b``, ``storage[p]`` signifies the storage contents at slot ``p``, and
+similarly, ``transientStorage[p]`` signifies the transient storage contents at slot ``p``.
 
 Since Yul manages local variables and control-flow,
 opcodes that interfere with these features are not available. This includes
@@ -836,6 +834,10 @@ the ``dup`` and ``swap`` instructions as well as ``jump`` instructions, labels a
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | sstore(p, v)            | `-` | F | storage[p] := v                                                 |
 +-------------------------+-----+---+-----------------------------------------------------------------+
+| tload(p)                |     | N | transientStorage[p]                                             |
++-------------------------+-----+---+-----------------------------------------------------------------+
+| tstore(p, v)            | `-` | N | transientStorage[p] := v                                        |
++-------------------------+-----+---+-----------------------------------------------------------------+
 | msize()                 |     | F | size of memory, i.e. largest accessed memory index              |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | gas()                   |     | F | gas still available to execution                                |
@@ -868,6 +870,8 @@ the ``dup`` and ``swap`` instructions as well as ``jump`` instructions, labels a
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | returndatacopy(t, f, s) | `-` | B | copy s bytes from returndata at position f to mem at position t |
 +-------------------------+-----+---+-----------------------------------------------------------------+
+| mcopy(t, f, s)          | `-` | N | copy s bytes from mem at position f to mem at position t        |
++-------------------------+-----+---+-----------------------------------------------------------------+
 | extcodehash(a)          |     | C | code hash of address a                                          |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | create(v, p, n)         |     | F | create new contract with code mem[p...(p+n)) and send v wei     |
@@ -903,37 +907,44 @@ the ``dup`` and ``swap`` instructions as well as ``jump`` instructions, labels a
 | revert(p, s)            | `-` | B | end execution, revert state changes, return data mem[p...(p+s)) |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | selfdestruct(a)         | `-` | F | end execution, destroy current contract and send funds to a     |
+|                         |     |   | (deprecated)                                                    |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | invalid()               | `-` | F | end execution with invalid instruction                          |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| log0(p, s)              | `-` | F | log without topics and data mem[p...(p+s))                      |
+| log0(p, s)              | `-` | F | log data mem[p...(p+s))                                         |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| log1(p, s, t1)          | `-` | F | log with topic t1 and data mem[p...(p+s))                       |
+| log1(p, s, t1)          | `-` | F | log data mem[p...(p+s)) with topic t1                           |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| log2(p, s, t1, t2)      | `-` | F | log with topics t1, t2 and data mem[p...(p+s))                  |
+| log2(p, s, t1, t2)      | `-` | F | log data mem[p...(p+s)) with topics t1, t2                      |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| log3(p, s, t1, t2, t3)  | `-` | F | log with topics t1, t2, t3 and data mem[p...(p+s))              |
+| log3(p, s, t1, t2, t3)  | `-` | F | log data mem[p...(p+s)) with topics t1, t2, t3                  |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| log4(p, s, t1, t2, t3,  | `-` | F | log with topics t1, t2, t3, t4 and data mem[p...(p+s))          |
+| log4(p, s, t1, t2, t3,  | `-` | F | log data mem[p...(p+s)) with topics t1, t2, t3, t4              |
 | t4)                     |     |   |                                                                 |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | chainid()               |     | I | ID of the executing chain (EIP-1344)                            |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | basefee()               |     | L | current block's base fee (EIP-3198 and EIP-1559)                |
 +-------------------------+-----+---+-----------------------------------------------------------------+
+| blobbasefee()           |     | N | current block's blob base fee (EIP-7516 and EIP-4844)           |
++-------------------------+-----+---+-----------------------------------------------------------------+
 | origin()                |     | F | transaction sender                                              |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | gasprice()              |     | F | gas price of the transaction                                    |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | blockhash(b)            |     | F | hash of block nr b - only for last 256 blocks excluding current |
 +-------------------------+-----+---+-----------------------------------------------------------------+
+| blobhash(i)             |     | N | versioned hash of transaction's i-th blob                       |
++-------------------------+-----+---+-----------------------------------------------------------------+
 | coinbase()              |     | F | current mining beneficiary                                      |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | timestamp()             |     | F | timestamp of the current block in seconds since the epoch       |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | number()                |     | F | current block number                                            |
 +-------------------------+-----+---+-----------------------------------------------------------------+
-| difficulty()            |     | F | difficulty of the current block                                 |
+| difficulty()            |     | F | difficulty of the current block (see note below)                |
++-------------------------+-----+---+-----------------------------------------------------------------+
+| prevrandao()            |     | P | randomness provided by the beacon chain (see note below)        |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 | gaslimit()              |     | F | block gas limit of the current block                            |
 +-------------------------+-----+---+-----------------------------------------------------------------+
@@ -948,6 +959,20 @@ the ``dup`` and ``swap`` instructions as well as ``jump`` instructions, labels a
   You need to use the ``returndatasize`` opcode to check which part of this memory area contains the return data.
   The remaining bytes will retain their values as of before the call.
 
+.. note::
+  The ``difficulty()`` instruction is disallowed in EVM version >= Paris.
+  With the Paris network upgrade the semantics of the instruction that was previously called
+  ``difficulty`` have been changed and the instruction was renamed to ``prevrandao``.
+  It can now return arbitrary values in the full 256-bit range, whereas the highest recorded
+  difficulty value within Ethash was ~54 bits.
+  This change is described in `EIP-4399 <https://eips.ethereum.org/EIPS/eip-4399>`_.
+  Please note that irrelevant to which EVM version is selected in the compiler, the semantics of
+  instructions depend on the final chain of deployment.
+
+.. warning::
+    From version 0.8.18 and up, the use of ``selfdestruct`` in both Solidity and Yul will trigger a
+    deprecation warning, since the ``SELFDESTRUCT`` opcode will eventually undergo breaking changes in behavior
+    as stated in `EIP-6049 <https://eips.ethereum.org/EIPS/eip-6049>`_.
 
 In some internal dialects, there are additional functions:
 
@@ -981,7 +1006,7 @@ Its first and only argument must be a string literal and uniquely represents the
 Identifiers can be arbitrary but when the compiler produces Yul code from Solidity sources,
 it uses a library name qualified with the name of the source unit that defines that library.
 To link the code with a particular library address, the same identifier must be provided to the
-``--libraries`` option on the command line.
+``--libraries`` option on the command-line.
 
 For example this code
 
@@ -1062,12 +1087,12 @@ or even opcodes unknown to the Solidity compiler, care has to be taken
 when using ``verbatim`` together with the optimizer. Even when the
 optimizer is switched off, the code generator has to determine
 the stack layout, which means that e.g. using ``verbatim`` to modify
-the stack height can lead to undefined behaviour.
+the stack height can lead to undefined behavior.
 
 The following is a non-exhaustive list of restrictions on
 verbatim bytecode that are not checked by
 the compiler. Violations of these restrictions can result in
-undefined behaviour.
+undefined behavior.
 
 - Control-flow should not jump into or out of verbatim blocks,
   but it can jump within the same verbatim block.
@@ -1174,14 +1199,13 @@ An example Yul Object is shown below:
             datacopy(offset, dataoffset("Contract2"), size)
             // constructor parameter is a single number 0x1234
             mstore(add(offset, size), 0x1234)
-            pop(create(offset, add(size, 32), 0))
+            pop(create(0, offset, add(size, 32)))
 
             // now return the runtime object (the currently
             // executing code is the constructor code)
             size := datasize("Contract1_deployed")
             offset := allocate(size)
-            // This will turn into a memory->memory copy for Ewasm and
-            // a codecopy for EVM
+            // This will turn into a codecopy for EVM
             datacopy(offset, dataoffset("Contract1_deployed"), size)
             return(offset, size)
         }
@@ -1245,65 +1269,8 @@ In Solidity mode, the Yul optimizer is activated together with the regular optim
 Optimization Step Sequence
 --------------------------
 
-By default the Yul optimizer applies its predefined sequence of optimization steps to the generated assembly.
-You can override this sequence and supply your own using the ``--yul-optimizations`` option:
-
-.. code-block:: sh
-
-    solc --optimize --ir-optimized --yul-optimizations 'dhfoD[xarrscLMcCTU]uljmul'
-
-The order of steps is significant and affects the quality of the output.
-Moreover, applying a step may uncover new optimization opportunities for others that were already
-applied so repeating steps is often beneficial.
-By enclosing part of the sequence in square brackets (``[]``) you tell the optimizer to repeatedly
-apply that part until it no longer improves the size of the resulting assembly.
-You can use brackets multiple times in a single sequence but they cannot be nested.
-
-The following optimization steps are available:
-
-============ ===============================
-Abbreviation Full name
-============ ===============================
-``f``        ``BlockFlattener``
-``l``        ``CircularReferencesPruner``
-``c``        ``CommonSubexpressionEliminator``
-``C``        ``ConditionalSimplifier``
-``U``        ``ConditionalUnsimplifier``
-``n``        ``ControlFlowSimplifier``
-``D``        ``DeadCodeEliminator``
-``v``        ``EquivalentFunctionCombiner``
-``e``        ``ExpressionInliner``
-``j``        ``ExpressionJoiner``
-``s``        ``ExpressionSimplifier``
-``x``        ``ExpressionSplitter``
-``I``        ``ForLoopConditionIntoBody``
-``O``        ``ForLoopConditionOutOfBody``
-``o``        ``ForLoopInitRewriter``
-``i``        ``FullInliner``
-``g``        ``FunctionGrouper``
-``h``        ``FunctionHoister``
-``F``        ``FunctionSpecializer``
-``T``        ``LiteralRematerialiser``
-``L``        ``LoadResolver``
-``M``        ``LoopInvariantCodeMotion``
-``r``        ``RedundantAssignEliminator``
-``R``        ``ReasoningBasedSimplifier`` - highly experimental
-``m``        ``Rematerialiser``
-``V``        ``SSAReverser``
-``a``        ``SSATransform``
-``t``        ``StructuralSimplifier``
-``u``        ``UnusedPruner``
-``p``        ``UnusedFunctionParameterPruner``
-``d``        ``VarDeclInitializer``
-============ ===============================
-
-Some steps depend on properties ensured by ``BlockFlattener``, ``FunctionGrouper``, ``ForLoopInitRewriter``.
-For this reason the Yul optimizer always applies them before applying any steps supplied by the user.
-
-The ReasoningBasedSimplifier is an optimizer step that is currently not enabled
-in the default set of steps. It uses an SMT solver to simplify arithmetic expressions
-and boolean conditions. It has not received thorough testing or validation yet and can produce
-non-reproducible results, so please use with care!
+Detailed information regarding the optimization sequence as well as a list of abbreviations is
+available in the :ref:`optimizer docs <optimizer-steps>`.
 
 .. _erc20yul:
 
diff --git a/compiler/lib/stdlib_sol.tvm b/compiler/lib/stdlib_sol.tvm
deleted file mode 100644
index b710f010..00000000
--- a/compiler/lib/stdlib_sol.tvm
+++ /dev/null
@@ -1,2629 +0,0 @@
-.globl	insert_pubkey
-.type	insert_pubkey, @function
-CALL $insert_pubkey_macro$
-
-.macro insert_pubkey_macro
-.loc stdlib.sol, 14
-SWAP
-CTOS
-.loc stdlib.sol, 15
-NEWC
-.loc stdlib.sol, 18
-OVER
-LDI 1
-POP S3
-PUSHCONT {
-	.loc stdlib.sol, 19
-	STSLICECONST 1
-	.loc stdlib.sol, 20
-	OVER
-	LDU 32
-	POP S3
-	.loc stdlib.sol, 21
-	SWAP
-	STSLICECONST 1
-	STU 32
-}
-PUSHCONT {
-	.loc stdlib.sol, 23
-	STSLICECONST 0
-}
-IFELSE
-.loc stdlib.sol, 27
-OVER
-LDI 1
-POP S3
-PUSHCONT {
-	.loc stdlib.sol, 28
-	STSLICECONST 1
-	.loc stdlib.sol, 29
-	OVER
-	LDI 1
-	LDI 1
-	POP S4
-	.loc stdlib.sol, 30
-	XCHG S2
-	STI 1
-	STI 1
-}
-PUSHCONT {
-	.loc stdlib.sol, 32
-	STSLICECONST 0
-}
-IFELSE
-.loc stdlib.sol, 36
-OVER
-LDDICT
-POP S3
-SWAP
-STDICT
-.loc stdlib.sol, 40
-NEWDICT
-.loc stdlib.sol, 41
-PUSH S2
-LDI 1
-POP S4
-PUSHCONT {
-	.loc stdlib.sol, 42
-	PUSH S2
-	LDREFRTOS
-	SWAP
-	POP S4
-	.loc stdlib.sol, 43
-	PLDDICT
-	NIP
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 45
-ROLL 3
-PUSHINT 0
-ROTREV
-NEWC
-STU 256
-ROTREV
-PUSHINT 64
-DICTUSETB
-.loc stdlib.sol, 47
-NEWC
-STDICT
-.loc stdlib.sol, 48
-OVER
-STSLICECONST 1
-POP S2
-.loc stdlib.sol, 49
-STBREFR
-.loc stdlib.sol, 53
-OVER
-LDDICT
-POP S3
-SWAP
-STDICT
-.loc stdlib.sol, 55
-SWAP
-SEMPTY
-THROWIFNOT 55
-.loc stdlib.sol, 57
-ENDC
-.loc stdlib.sol, 0
-
-.globl	replay_protection
-.type	replay_protection, @function
-CALL $replay_protection_macro$
-
-.macro replay_protection_macro
-.loc stdlib.sol, 61
-GETGLOB 3
-OVER
-LESS
-THROWIFNOT 52
-.loc stdlib.sol, 62
-DUP
-NOW
-PUSHINT 1000
-MUL
-PUSHINT 1800000
-ADD
-LESS
-THROWIFNOT 52
-.loc stdlib.sol, 63
-SETGLOB 3
-.loc stdlib.sol, 0
-
-.globl	__tonToGas
-.type	__tonToGas, @function
-CALL $__tonToGas_macro$
-
-.macro __tonToGas_macro
-.loc stdlib.sol, 67
-PUSHPOW2 16
-SWAP
-CALLREF {
-	CALL $__gasGasPrice_macro$
-}
-MULDIV
-.loc stdlib.sol, 0
-
-.globl	__gasToTon
-.type	__gasToTon, @function
-CALL $__gasToTon_macro$
-
-.macro __gasToTon_macro
-.loc stdlib.sol, 71
-CALLREF {
-	CALL $__gasGasPrice_macro$
-}
-PUSHPOW2 16
-MULDIVC
-.loc stdlib.sol, 0
-
-.globl	__gasGasPrice
-.type	__gasGasPrice, @function
-CALL $__gasGasPrice_macro$
-
-.macro __gasGasPrice_macro
-.loc stdlib.sol, 75
-DUP
-EQINT 0
-OVER
-EQINT -1
-OR
-THROWIFNOT 67
-.loc stdlib.sol, 76
-PUSHINT 20
-PUSHINT 21
-CONDSEL
-CONFIGPARAM
-DUP
-PUSHCONT {
-	PUSHREF {
-	}
-	SWAP
-}
-IFNOT
-.loc stdlib.sol, 77
-THROWIFNOT 68
-.loc stdlib.sol, 78
-CTOS
-.loc stdlib.sol, 79
-LDU 8
-LDU 64
-LDU 64
-LDU 8
-PLDU 64
-BLKDROP2 4, 1
-.loc stdlib.sol, 0
-
-.globl	__exp
-.type	__exp, @function
-CALL $__exp_macro$
-
-.macro __exp_macro
-.loc stdlib.sol, 83
-PUSHINT 1
-.loc stdlib.sol, 84
-PUSHCONT {
-	OVER
-	NEQINT 0
-}
-PUSHCONT {
-	.loc stdlib.sol, 85
-	OVER
-	MODPOW2 1
-	PUSHCONT {
-		.loc stdlib.sol, 86
-		PUSH S2
-		MUL
-		.loc stdlib.sol, 87
-		OVER
-		DEC
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 89
-		PUSH2 S2, S2
-		MUL
-		POP S3
-		.loc stdlib.sol, 90
-		OVER
-		RSHIFT 1
-	}
-	IFELSE
-	POP S2
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 93
-BLKDROP2 2, 1
-.loc stdlib.sol, 0
-
-.globl	parseInteger
-.type	parseInteger, @function
-CALL $parseInteger_macro$
-
-.macro parseInteger_macro
-.loc stdlib.sol, 99
-TUPLE 0
-.loc stdlib.sol, 100
-PUSH S2
-PUSHCONT {
-	.loc stdlib.sol, 101
-	PUSHINT 0
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	.loc stdlib.sol, 102
-	BLKDROP2 2, 1
-	.loc stdlib.sol, 0
-}
-IFNOTJMP
-.loc stdlib.sol, 104
-PUSHINT 0
-.loc stdlib.sol, 105
-PUSHCONT {
-	PUSH S3
-	NEQINT 0
-}
-PUSHCONT {
-	.loc stdlib.sol, 106
-	OVER2
-	DIVMOD
-	POP S2
-	POP S4
-	.loc stdlib.sol, 107
-	DUP2
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S2
-	.loc stdlib.sol, 0
-}
-WHILE
-DROP
-BLKDROP2 2, 1
-.loc stdlib.sol, 0
-
-.globl	convertIntToDecStr_short
-.type	convertIntToDecStr_short, @function
-CALL $convertIntToDecStr_short_macro$
-
-.macro convertIntToDecStr_short_macro
-.loc stdlib.sol, 112
-ROTREV
-PUSH S2
-ABS
-PUSHINT 0
-DUP
-ROLL 5
-LESSINT 0
-CALLREF {
-	CALL $convertIntToDecStr_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	convertIntToDecStr
-.type	convertIntToDecStr, @function
-CALL $convertIntToDecStr_macro$
-
-.macro convertIntToDecStr_macro
-.loc stdlib.sol, 116
-PUSH S4
-BREMBITS
-RSHIFT 3
-.loc stdlib.sol, 117
-DUP
-PUSHCONT {
-	.loc stdlib.sol, 118
-	BLKPUSH 2, 6
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S7
-	.loc stdlib.sol, 119
-	NEWC
-	POP S6
-	.loc stdlib.sol, 120
-	DROP
-	PUSHINT 127
-	.loc stdlib.sol, 0
-}
-IFNOT
-.loc stdlib.sol, 122
-ROT
-PUSHINT 48
-PUSHINT 32
-CONDSEL
-.loc stdlib.sol, 123
-ROT
-PUSHCONT {
-	.loc stdlib.sol, 124
-	PUSH S4
-	STSLICECONST x2d
-	POP S5
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 125
-OVER
-DEC
-POP S2
-.loc stdlib.sol, 126
-OVER
-PUSHCONT {
-	.loc stdlib.sol, 127
-	BLKPUSH 2, 5
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S6
-	.loc stdlib.sol, 128
-	NEWC
-	POP S5
-	.loc stdlib.sol, 129
-	PUSHINT 127
-	POP S2
-	.loc stdlib.sol, 0
-}
-IFNOT
-.loc stdlib.sol, 131
-ROLL 3
-PUSHINT 10
-CALLREF {
-	CALL $parseInteger_macro$
-}
-.loc stdlib.sol, 132
-DUP
-CALLREF {
-	DUP
-	TLEN
-	DUP
-	PUSHCONT {
-		DEC
-		PUSHPOW2DEC 8
-		MUL
-		SWAP
-		LAST
-		TLEN
-		ADD
-	}
-	PUSHCONT {
-		NIP
-	}
-	IFELSE
-}
-.loc stdlib.sol, 133
-PUSH S4
-PUSHCONT {
-	.loc stdlib.sol, 134
-	PUSH2 S4, S0
-	LESS
-	PUSH S5
-	GTINT 127
-	OR
-	THROWIF 66
-	.loc stdlib.sol, 136
-	PUSH2 S4, S0
-	SUB
-	.loc stdlib.sol, 137
-	PUSH2 S0, S4
-	LEQ
-	PUSHCONT {
-		.loc stdlib.sol, 138
-		DUP
-		PUSHCONT {
-			.loc stdlib.sol, 139
-			PUSH2 S6, S3
-			STUR 8
-			POP S7
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 141
-		PUSH2 S4, S0
-		SUB
-		POP S5
-		.loc stdlib.sol, 142
-		PUSH S4
-		PUSHCONT {
-			.loc stdlib.sol, 143
-			BLKPUSH 2, 7
-			CALLREF {
-				XCPU S1, S0
-				TLEN
-				PUSHCONT {
-					TPOP
-					DUP
-					TLEN
-					PUSHPOW2DEC 8
-					SUB
-					PUSHCONT {
-						TPUSH
-						TUPLE 0
-					}
-					IFNOT
-				}
-				PUSHCONT {
-					TUPLE 0
-				}
-				IFELSE
-				ROT
-				TPUSH
-				TPUSH
-			}
-			POP S8
-			.loc stdlib.sol, 144
-			NEWC
-			POP S7
-			.loc stdlib.sol, 145
-			PUSHINT 127
-			POP S5
-			.loc stdlib.sol, 0
-		}
-		IFNOT
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 148
-		PUSH S4
-		PUSHCONT {
-			.loc stdlib.sol, 149
-			PUSH2 S6, S3
-			STUR 8
-			POP S7
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 151
-		BLKPUSH 2, 7
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S8
-		.loc stdlib.sol, 152
-		NEWC
-		POP S7
-		.loc stdlib.sol, 153
-		PUSH2 S0, S4
-		SUB
-		PUSHCONT {
-			.loc stdlib.sol, 154
-			PUSH2 S6, S3
-			STUR 8
-			POP S7
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 156
-		PUSHINT 127
-		OVER
-		SUB
-		PUSH S5
-		ADD
-		POP S5
-	}
-	IFELSE
-	.loc stdlib.sol, 0
-	DROP
-}
-IF
-.loc stdlib.sol, 159
-PUSH2 S0, S3
-LEQ
-PUSHCONT {
-	.loc stdlib.sol, 160
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 161
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 162
-		PUSH S6
-		PUSHINT 48
-		ROT
-		ADD
-		STUR 8
-		POP S6
-		.loc stdlib.sol, 0
-	}
-	REPEAT
-}
-PUSHCONT {
-	.loc stdlib.sol, 165
-	PUSH S3
-	PUSHCONT {
-		.loc stdlib.sol, 166
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 167
-		PUSH S6
-		PUSHINT 48
-		ROT
-		ADD
-		STUR 8
-		POP S6
-		.loc stdlib.sol, 0
-	}
-	REPEAT
-	.loc stdlib.sol, 169
-	BLKPUSH 2, 6
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S7
-	.loc stdlib.sol, 170
-	NEWC
-	POP S6
-	.loc stdlib.sol, 171
-	PUSH2 S0, S3
-	SUB
-	PUSHCONT {
-		.loc stdlib.sol, 172
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 173
-		PUSH S6
-		PUSHINT 48
-		ROT
-		ADD
-		STUR 8
-		POP S6
-		.loc stdlib.sol, 0
-	}
-	REPEAT
-}
-IFELSE
-.loc stdlib.sol, 177
-BLKDROP 5
-.loc stdlib.sol, 0
-
-.globl	convertAddressToHexString
-.type	convertAddressToHexString, @function
-CALL $convertAddressToHexString_macro$
-
-.macro convertAddressToHexString_macro
-.loc stdlib.sol, 181
-REWRITESTDADDR
-.loc stdlib.sol, 182
-OVER2
-ROLL 3
-CALLREF {
-	CALL $convertIntToHexStr_short_macro$
-}
-POP S3
-POP S3
-.loc stdlib.sol, 183
-OVER
-BREMBITS
-.loc stdlib.sol, 184
-GTINT 8
-PUSHCONT {
-	.loc stdlib.sol, 187
-	BLKPUSH 2, 2
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S3
-	.loc stdlib.sol, 188
-	NEWC
-	POP S2
-	.loc stdlib.sol, 189
-}
-IFNOT
-OVER
-STSLICECONST x3a
-POP S2
-.loc stdlib.sol, 191
-PUSHINT 64
-TRUE
-DUP
-FALSE
-CALLREF {
-	CALL $convertIntToHexStr_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	convertFixedPointToString
-.type	convertFixedPointToString, @function
-CALL $convertFixedPointToString_macro$
-
-.macro convertFixedPointToString_macro
-.loc stdlib.sol, 195
-OVER
-ABS
-.loc stdlib.sol, 196
-PUSHINT 10
-PUSH3 S2, S0, S2
-OR
-THROWIFNOT 69
-CALLREF {
-	CALL $__exp_macro$
-}
-DIVMOD
-.loc stdlib.sol, 197
-BLKPUSH 2, 5
-ROLL 3
-PUSHINT 0
-DUP
-ROLL 7
-SGN
-LESSINT 0
-CALLREF {
-	CALL $convertIntToDecStr_macro$
-}
-POP S4
-POP S4
-.loc stdlib.sol, 198
-PUSH S2
-BREMBITS
-.loc stdlib.sol, 199
-GTINT 8
-PUSHCONT {
-	.loc stdlib.sol, 202
-	OVER2
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S4
-	.loc stdlib.sol, 203
-	NEWC
-	POP S3
-	.loc stdlib.sol, 204
-}
-IFNOT
-PUSH S2
-STSLICECONST x2e
-POP S3
-.loc stdlib.sol, 206
-SWAP
-TRUE
-FALSE
-CALLREF {
-	CALL $convertIntToDecStr_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	convertIntToHexStr_short
-.type	convertIntToHexStr_short, @function
-CALL $convertIntToHexStr_short_macro$
-
-.macro convertIntToHexStr_short_macro
-.loc stdlib.sol, 210
-ROTREV
-PUSH S2
-ABS
-PUSHINT 0
-DUP
-TRUE
-ROLL 6
-LESSINT 0
-CALLREF {
-	CALL $convertIntToHexStr_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	convertIntToHexStr
-.type	convertIntToHexStr, @function
-CALL $convertIntToHexStr_macro$
-
-.macro convertIntToHexStr_macro
-.loc stdlib.sol, 214
-PUSH S5
-BREMBITS
-RSHIFT 3
-.loc stdlib.sol, 215
-DUP
-PUSHCONT {
-	.loc stdlib.sol, 216
-	BLKPUSH 2, 7
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S8
-	.loc stdlib.sol, 217
-	NEWC
-	POP S7
-	.loc stdlib.sol, 218
-	DROP
-	PUSHINT 127
-	.loc stdlib.sol, 0
-}
-IFNOT
-.loc stdlib.sol, 220
-ROLL 3
-PUSHINT 48
-PUSHINT 32
-CONDSEL
-.loc stdlib.sol, 221
-ROT
-PUSHCONT {
-	.loc stdlib.sol, 222
-	PUSH S5
-	STSLICECONST x2d
-	POP S6
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 223
-OVER
-DEC
-POP S2
-.loc stdlib.sol, 224
-OVER
-PUSHCONT {
-	.loc stdlib.sol, 225
-	BLKPUSH 2, 6
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S7
-	.loc stdlib.sol, 226
-	NEWC
-	POP S6
-	.loc stdlib.sol, 227
-	PUSHINT 127
-	POP S2
-	.loc stdlib.sol, 0
-}
-IFNOT
-.loc stdlib.sol, 229
-ROLL 4
-PUSHINT 16
-CALLREF {
-	CALL $parseInteger_macro$
-}
-.loc stdlib.sol, 230
-DUP
-CALLREF {
-	DUP
-	TLEN
-	DUP
-	PUSHCONT {
-		DEC
-		PUSHPOW2DEC 8
-		MUL
-		SWAP
-		LAST
-		TLEN
-		ADD
-	}
-	PUSHCONT {
-		NIP
-	}
-	IFELSE
-}
-.loc stdlib.sol, 232
-PUSH S5
-PUSHCONT {
-	.loc stdlib.sol, 233
-	PUSH2 S5, S0
-	LESS
-	PUSH S6
-	GTINT 127
-	OR
-	THROWIF 69
-	.loc stdlib.sol, 235
-	PUSH2 S5, S0
-	SUB
-	.loc stdlib.sol, 236
-	PUSH2 S0, S4
-	LEQ
-	PUSHCONT {
-		.loc stdlib.sol, 237
-		DUP
-		PUSHCONT {
-			.loc stdlib.sol, 238
-			PUSH2 S7, S3
-			STUR 8
-			POP S8
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 240
-		PUSH2 S4, S0
-		SUB
-		POP S5
-		.loc stdlib.sol, 241
-		PUSH S4
-		PUSHCONT {
-			.loc stdlib.sol, 242
-			BLKPUSH 2, 8
-			CALLREF {
-				XCPU S1, S0
-				TLEN
-				PUSHCONT {
-					TPOP
-					DUP
-					TLEN
-					PUSHPOW2DEC 8
-					SUB
-					PUSHCONT {
-						TPUSH
-						TUPLE 0
-					}
-					IFNOT
-				}
-				PUSHCONT {
-					TUPLE 0
-				}
-				IFELSE
-				ROT
-				TPUSH
-				TPUSH
-			}
-			POP S9
-			.loc stdlib.sol, 243
-			NEWC
-			POP S8
-			.loc stdlib.sol, 244
-			PUSHINT 127
-			POP S5
-			.loc stdlib.sol, 0
-		}
-		IFNOT
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 247
-		PUSH S4
-		PUSHCONT {
-			.loc stdlib.sol, 248
-			PUSH2 S7, S3
-			STUR 8
-			POP S8
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 250
-		BLKPUSH 2, 8
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S9
-		.loc stdlib.sol, 251
-		NEWC
-		POP S8
-		.loc stdlib.sol, 252
-		PUSH2 S0, S4
-		SUB
-		PUSHCONT {
-			.loc stdlib.sol, 253
-			PUSH2 S7, S3
-			STUR 8
-			POP S8
-			.loc stdlib.sol, 0
-		}
-		REPEAT
-		.loc stdlib.sol, 255
-		PUSHINT 127
-		OVER
-		SUB
-		PUSH S5
-		ADD
-		POP S5
-	}
-	IFELSE
-	.loc stdlib.sol, 0
-	DROP
-}
-IF
-.loc stdlib.sol, 258
-PUSH2 S0, S3
-LEQ
-PUSHCONT {
-	.loc stdlib.sol, 259
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 260
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 261
-		DUP
-		LESSINT 10
-		PUSHCONT {
-			.loc stdlib.sol, 262
-			PUSH S7
-			PUSHINT 48
-		}
-		PUSHCONT {
-			.loc stdlib.sol, 264
-			PUSH2 S7, S5
-			PUSHINT 87
-			PUSHINT 55
-			CONDSEL
-		}
-		IFELSE
-		PUSH S2
-		ADD
-		STUR 8
-		POP S8
-		.loc stdlib.sol, 0
-		DROP
-	}
-	REPEAT
-}
-PUSHCONT {
-	.loc stdlib.sol, 267
-	PUSH S3
-	PUSHCONT {
-		.loc stdlib.sol, 268
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 269
-		DUP
-		LESSINT 10
-		PUSHCONT {
-			.loc stdlib.sol, 270
-			PUSH S7
-			PUSHINT 48
-		}
-		PUSHCONT {
-			.loc stdlib.sol, 272
-			PUSH2 S7, S5
-			PUSHINT 87
-			PUSHINT 55
-			CONDSEL
-		}
-		IFELSE
-		PUSH S2
-		ADD
-		STUR 8
-		POP S8
-		.loc stdlib.sol, 0
-		DROP
-	}
-	REPEAT
-	.loc stdlib.sol, 274
-	BLKPUSH 2, 7
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S8
-	.loc stdlib.sol, 275
-	NEWC
-	POP S7
-	.loc stdlib.sol, 276
-	PUSH2 S0, S3
-	SUB
-	PUSHCONT {
-		.loc stdlib.sol, 277
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 278
-		DUP
-		LESSINT 10
-		PUSHCONT {
-			.loc stdlib.sol, 279
-			PUSH S7
-			PUSHINT 48
-		}
-		PUSHCONT {
-			.loc stdlib.sol, 281
-			PUSH2 S7, S5
-			PUSHINT 87
-			PUSHINT 55
-			CONDSEL
-		}
-		IFELSE
-		PUSH S2
-		ADD
-		STUR 8
-		POP S8
-		.loc stdlib.sol, 0
-		DROP
-	}
-	REPEAT
-}
-IFELSE
-.loc stdlib.sol, 284
-BLKDROP 6
-.loc stdlib.sol, 0
-
-.globl	storeStringInBuilders
-.type	storeStringInBuilders, @function
-CALL $storeStringInBuilders_macro$
-
-.macro storeStringInBuilders_macro
-.loc stdlib.sol, 288
-OVER
-BREMBITS
-ADDCONST -7
-.loc stdlib.sol, 289
-OVER
-SBITREFS
-.loc stdlib.sol, 290
-DUP
-PUSHCONT {
-	.loc stdlib.sol, 291
-	PUSH S3
-	PUSHINT 0
-	PUSH S2
-	SSKIPFIRST
-	POP S4
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 292
-DROP
-OVER
-LEQ
-.loc stdlib.sol, 293
-PUSHCONT {
-	.loc stdlib.sol, 296
-	DUP2
-	LDSLICEX
-	POP S3
-	.loc stdlib.sol, 297
-	PUSH S3
-	STSLICE
-	POP S3
-	.loc stdlib.sol, 298
-	OVER2
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S4
-	.loc stdlib.sol, 299
-	NEWC
-	POP S3
-	.loc stdlib.sol, 300
-}
-IFNOT
-PUSH2 S1, S2
-STSLICE
-BLKDROP2 3, 1
-.loc stdlib.sol, 0
-
-.globl	assembleList
-.type	assembleList, @function
-CALL $assembleList_macro$
-
-.macro assembleList_macro
-.loc stdlib.sol, 306
-PUSHCONT {
-	OVER
-	TLEN
-	ISZERO
-	NOT
-}
-PUSHCONT {
-	.loc stdlib.sol, 307
-	OVER
-	CALLREF {
-		TPOP
-		TPOP
-		ROTREV
-		DUP
-		TLEN
-		PUSHCONT {
-			TPUSH
-		}
-		PUSHCONT {
-			DROP
-		}
-		IFELSE
-	}
-	POP S3
-	.loc stdlib.sol, 308
-	STBREF
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 311
-ENDC
-NIP
-.loc stdlib.sol, 0
-
-.globl	__stoi
-.type	__stoi, @function
-CALL $__stoi_macro$
-
-.macro __stoi_macro
-.loc stdlib.sol, 315
-CTOS
-.loc stdlib.sol, 316
-DUP
-SBITS
-LESSINT 8
-PUSHCONT {
-	.loc stdlib.sol, 317
-	DROP
-	NULL
-	.loc stdlib.sol, 0
-}
-IFJMP
-.loc stdlib.sol, 319
-BLKPUSH 2, 0
-.loc stdlib.sol, 320
-LDU 8
-POP S2
-.loc stdlib.sol, 321
-DUP
-EQINT 45
-.loc stdlib.sol, 322
-PUSHINT 0
-.loc stdlib.sol, 323
-PUSH S3
-SBITS
-.loc stdlib.sol, 324
-PUSH2 S2, S0
-GTINT 15
-AND
-PUSHCONT {
-	.loc stdlib.sol, 325
-	PUSH S4
-	LDU 8
-	LDU 8
-	POP S7
-	POP S3
-	POP S4
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 327
-PUSH S2
-NOT
-SWAP
-GTINT 7
-AND
-PUSHCONT {
-	.loc stdlib.sol, 328
-	PUSH S3
-	LDU 8
-	POP S5
-	NIP
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 330
-ROT
-EQINT 48
-SWAP
-EQINT 120
-AND
-.loc stdlib.sol, 332
-OVER
-PUSHCONT {
-	.loc stdlib.sol, 333
-	PUSH S3
-	LDU 8
-	POP S5
-	DROP
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 334
-DUP
-PUSHCONT {
-	.loc stdlib.sol, 335
-	PUSH S3
-	LDU 8
-	LDU 8
-	POP S6
-	DROP2
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 337
-PUSHINT 0
-.loc stdlib.sol, 339
-PUSH S4
-SBITS
-RSHIFT 3
-.loc stdlib.sol, 341
-FALSE ; decl return flag
-ROLL 3
-PUSHCONT {
-	.loc stdlib.sol, 342
-	FALSE ; decl return flag
-	PUSH S2
-	PUSHCONT {
-		.loc stdlib.sol, 343
-		PUSH S6
-		LDU 8
-		POP S8
-		.loc stdlib.sol, 344
-		PUSH S4
-		MULCONST 16
-		POP S5
-		.loc stdlib.sol, 345
-		DUP
-		GTINT 47
-		OVER
-		LESSINT 58
-		AND
-		PUSHCONT {
-			.loc stdlib.sol, 346
-			DUP
-			ADDCONST -48
-			PUSH S5
-			ADD
-			POP S5
-			.loc stdlib.sol, 0
-		}
-		PUSHCONT {
-			DUP
-			GTINT 64
-			OVER
-			LESSINT 71
-			AND
-			PUSHCONT {
-				.loc stdlib.sol, 348
-				DUP
-				ADDCONST -55
-				PUSH S5
-				ADD
-				POP S5
-				.loc stdlib.sol, 0
-			}
-			PUSHCONT {
-				DUP
-				GTINT 96
-				OVER
-				LESSINT 103
-				AND
-				PUSHCONT {
-					.loc stdlib.sol, 350
-					DUP
-					ADDCONST -87
-					PUSH S5
-					ADD
-					POP S5
-					.loc stdlib.sol, 0
-				}
-				PUSHCONT {
-					.loc stdlib.sol, 352
-					BLKDROP 8
-					NULL
-					PUSHINT 4
-					RETALT
-					.loc stdlib.sol, 0
-				}
-				IFELSE
-			}
-			IFELSE
-		}
-		IFELSE
-		DROP
-		.loc stdlib.sol, 0
-	}
-	REPEATBRK
-	DUP
-	IFRET
-	DROP
-	.loc stdlib.sol, 0
-}
-PUSHCONT {
-	.loc stdlib.sol, 356
-	FALSE ; decl return flag
-	PUSH S2
-	PUSHCONT {
-		.loc stdlib.sol, 357
-		PUSH S6
-		LDU 8
-		POP S8
-		.loc stdlib.sol, 358
-		DUP
-		LESSINT 48
-		OVER
-		GTINT 57
-		OR
-		PUSHCONT {
-			BLKDROP 8
-			NULL
-			PUSHINT 4
-			RETALT
-		}
-		IFJMP
-		.loc stdlib.sol, 360
-		PUSH S4
-		MULCONST 10
-		POP S5
-		.loc stdlib.sol, 361
-		ADDCONST -48
-		PUSH S4
-		ADD
-		POP S4
-		.loc stdlib.sol, 0
-	}
-	REPEATBRK
-	DUP
-	IFRET
-	DROP
-	.loc stdlib.sol, 0
-}
-IFELSE
-IFRET
-.loc stdlib.sol, 364
-DROP
-SWAP
-PUSHCONT {
-	.loc stdlib.sol, 365
-	NEGATE
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 366
-BLKDROP2 2, 1
-.loc stdlib.sol, 0
-
-.globl	strToList
-.type	strToList, @function
-CALL $strToList_macro$
-
-.macro strToList_macro
-.loc stdlib.sol, 370
-TUPLE 0
-.loc stdlib.sol, 371
-SWAP
-CTOS
-.loc stdlib.sol, 372
-PUSHCONT {
-	DUP
-	SREFS
-	NEQINT 0
-}
-PUSHCONT {
-	.loc stdlib.sol, 373
-	LDREFRTOS
-	.loc stdlib.sol, 375
-	SWAP
-	NEWC
-	STSLICE
-	.loc stdlib.sol, 376
-	PUXC S2, S-1
-	CALLREF {
-		XCPU S1, S0
-		TLEN
-		PUSHCONT {
-			TPOP
-			DUP
-			TLEN
-			PUSHPOW2DEC 8
-			SUB
-			PUSHCONT {
-				TPUSH
-				TUPLE 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			TUPLE 0
-		}
-		IFELSE
-		ROT
-		TPUSH
-		TPUSH
-	}
-	POP S2
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 380
-NEWC
-STSLICE
-.loc stdlib.sol, 0
-
-.globl	bytes_substr
-.type	bytes_substr, @function
-CALL $bytes_substr_macro$
-
-.macro bytes_substr_macro
-.loc stdlib.sol, 385
-PUSH S3
-PUSHPOW2DEC 32
-CDATASIZE
-DROP
-NIP
-.loc stdlib.sol, 386
-RSHIFT 3
-.loc stdlib.sol, 387
-SWAP
-PUSHCONT {
-	.loc stdlib.sol, 388
-	DUP
-	POP S2
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 389
-PUSH2 S1, S2
-GEQ
-THROWIFNOT 70
-.loc stdlib.sol, 390
-XCPU S1, S2
-SUB
-.loc stdlib.sol, 391
-SWAP
-BLKPUSH 2, 2
-ADD
-GEQ
-THROWIFNOT 70
-.loc stdlib.sol, 392
-CALLREF {
-	CALL $__subCell_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	__substr
-.type	__substr, @function
-CALL $__substr_macro$
-
-.macro __substr_macro
-.loc stdlib.sol, 396
-PUSH S2
-PUSHPOW2DEC 32
-CDATASIZE
-DROP
-NIP
-.loc stdlib.sol, 397
-RSHIFT 3
-.loc stdlib.sol, 398
-OVER
-EQINT -1
-PUSHCONT {
-	.loc stdlib.sol, 399
-	PUSH2 S0, S2
-	SUB
-	FITS 256
-	POP S2
-	.loc stdlib.sol, 0
-}
-IF
-.loc stdlib.sol, 400
-BLKPUSH 2, 2
-UFITS 256
-ADD
-GEQ
-THROWIFNOT 70
-.loc stdlib.sol, 401
-UFITS 256
-CALLREF {
-	CALL $__subCell_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	__subCell
-.type	__subCell, @function
-CALL $__subCell_macro$
-
-.macro __subCell_macro
-.loc stdlib.sol, 404
-PUSHREF {
-}
-.loc stdlib.sol, 405
-OVER
-PUSHCONT {
-	.loc stdlib.sol, 406
-	BLKDROP2 3, 1
-	.loc stdlib.sol, 0
-}
-IFNOTJMP
-.loc stdlib.sol, 408
-DROP
-SWAP
-PUSHINT 127
-DIVMOD
-.loc stdlib.sol, 409
-ROLL 3
-CTOS
-.loc stdlib.sol, 410
-ROT
-PUSHCONT {
-	.loc stdlib.sol, 411
-	LDREFRTOS
-	NIP
-	.loc stdlib.sol, 0
-}
-REPEAT
-.loc stdlib.sol, 413
-SWAP
-MULCONST 8
-SDSKIPFIRST
-.loc stdlib.sol, 414
-TUPLE 0
-.loc stdlib.sol, 415
-NEWC
-.loc stdlib.sol, 416
-PUSHCONT {
-	PUSH S3
-	NEQINT 0
-}
-PUSHCONT {
-	.loc stdlib.sol, 417
-	OVER2
-	SBITS
-	RSHIFT 3
-	PUSH S2
-	BREMBITS
-	RSHIFT 3
-	MIN
-	MIN
-	.loc stdlib.sol, 418
-	PUSH3 S1, S3, S0
-	LSHIFT 3
-	UFITS 16
-	LDSLICEX
-	POP S6
-	STSLICER
-	POP S2
-	.loc stdlib.sol, 419
-	PUSH S4
-	SUBR
-	POP S4
-	.loc stdlib.sol, 420
-	PUSH S3
-	PUSHCONT {
-		.loc stdlib.sol, 421
-		PUSH S2
-		SBITS
-		PUSHCONT {
-			.loc stdlib.sol, 422
-			PUSH S2
-			LDREFRTOS
-			NIP
-			POP S3
-			.loc stdlib.sol, 0
-		}
-		IFNOT
-		.loc stdlib.sol, 424
-		DUP
-		BREMBITS
-		LESSINT 8
-		PUSHCONT {
-			.loc stdlib.sol, 425
-			CALLREF {
-				XCPU S1, S0
-				TLEN
-				PUSHCONT {
-					TPOP
-					DUP
-					TLEN
-					PUSHPOW2DEC 8
-					SUB
-					PUSHCONT {
-						TPUSH
-						TUPLE 0
-					}
-					IFNOT
-				}
-				PUSHCONT {
-					TUPLE 0
-				}
-				IFELSE
-				ROT
-				TPUSH
-				TPUSH
-			}
-			.loc stdlib.sol, 426
-			NEWC
-			.loc stdlib.sol, 0
-		}
-		IF
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 430
-CALLREF {
-	CALL $assembleList_macro$
-}
-BLKDROP2 2, 1
-.loc stdlib.sol, 0
-
-.globl	compareLongStrings
-.type	compareLongStrings, @function
-CALL $compareLongStrings_macro$
-
-.macro compareLongStrings_macro
-.loc stdlib.sol, 437
-SWAP
-CTOS
-.loc stdlib.sol, 438
-SWAP
-CTOS
-.loc stdlib.sol, 439
-FALSE ; decl return flag
-PUSHCONT {
-	.loc stdlib.sol, 440
-	BLKPUSH 2, 2
-	SDLEXCMP
-	.loc stdlib.sol, 441
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 442
-		BLKDROP2 3, 1
-		PUSHINT 4
-		RETALT
-		.loc stdlib.sol, 0
-	}
-	IFJMP
-	.loc stdlib.sol, 444
-	DROP
-	PUSH S2
-	SREFS
-	.loc stdlib.sol, 445
-	PUSH S2
-	SREFS
-	.loc stdlib.sol, 446
-	DUP2
-	GREATER
-	PUSHCONT {
-		BLKDROP 5
-		PUSHINT 1
-		PUSHINT 4
-		RETALT
-	}
-	IFJMP
-	.loc stdlib.sol, 448
-	PUSH2 S0, S1
-	GREATER
-	PUSHCONT {
-		BLKDROP 5
-		PUSHINT -1
-		PUSHINT 4
-		RETALT
-	}
-	IFJMP
-	.loc stdlib.sol, 450
-	ADD
-	PUSHCONT {
-		BLKDROP 3
-		PUSHINT 0
-		PUSHINT 4
-		RETALT
-	}
-	IFNOTJMP
-	.loc stdlib.sol, 452
-	PUSH S2
-	LDREFRTOS
-	NIP
-	POP S3
-	.loc stdlib.sol, 453
-	OVER
-	LDREFRTOS
-	NIP
-	POP S2
-	.loc stdlib.sol, 0
-}
-AGAINBRK
-IFRET
-.loc stdlib.sol, 455
-DROP2
-PUSHINT 0
-.loc stdlib.sol, 0
-
-.globl	concatenateStrings
-.type	concatenateStrings, @function
-CALL $concatenateStrings_macro$
-
-.macro concatenateStrings_macro
-.loc stdlib.sol, 459
-SWAP
-CALLREF {
-	CALL $strToList_macro$
-}
-.loc stdlib.sol, 460
-ROT
-CTOS
-.loc stdlib.sol, 461
-BLKPUSH 3, 2
-CALLREF {
-	CALL $storeStringInBuilders_macro$
-}
-POP S3
-POP S3
-.loc stdlib.sol, 462
-PUSHCONT {
-	DUP
-	PUSHINT 1
-	SCHKREFSQ
-}
-PUSHCONT {
-	.loc stdlib.sol, 463
-	LDREFRTOS
-	NIP
-	.loc stdlib.sol, 464
-	BLKPUSH 3, 2
-	CALLREF {
-		CALL $storeStringInBuilders_macro$
-	}
-	POP S3
-	POP S3
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 466
-DROP
-CALLREF {
-	CALL $assembleList_macro$
-}
-.loc stdlib.sol, 0
-
-.globl	__strchr
-.type	__strchr, @function
-CALL $__strchr_macro$
-
-.macro __strchr_macro
-.loc stdlib.sol, 469
-NULL
-.loc stdlib.sol, 470
-PUSHINT 0
-.loc stdlib.sol, 471
-ROLL 3
-CTOS
-NULL
-FALSE ; decl return flag
-PUSHCONT {
-	PUSH S2
-	SEMPTY
-	NOT
-}
-PUSHCONT {
-	PUSH S2
-	LDUQ 8
-	PUSHCONT {
-		PLDREF
-		CTOS
-		LDU 8
-	}
-	IFNOT
-	POP S4
-	POP S2
-	.loc stdlib.sol, 472
-	PUSH2 S1, S5
-	EQUAL
-	PUSHCONT {
-		.loc stdlib.sol, 473
-		ROLL 3
-		BLKDROP2 5, 1
-		PUSHINT 4
-		RETALT
-		.loc stdlib.sol, 0
-	}
-	IFJMP
-	.loc stdlib.sol, 475
-	PUSH S3
-	INC
-	POP S4
-	.loc stdlib.sol, 0
-}
-WHILEBRK
-IFRET
-BLKDROP 3
-NIP
-.loc stdlib.sol, 0
-
-.globl	__strrchr
-.type	__strrchr, @function
-CALL $__strrchr_macro$
-
-.macro __strrchr_macro
-.loc stdlib.sol, 479
-NULL
-.loc stdlib.sol, 480
-PUSHINT 0
-.loc stdlib.sol, 481
-ROLL 3
-CTOS
-NULL
-PUSHCONT {
-	OVER
-	SEMPTY
-	NOT
-}
-PUSHCONT {
-	OVER
-	LDUQ 8
-	PUSHCONT {
-		PLDREF
-		CTOS
-		LDU 8
-	}
-	IFNOT
-	POP S3
-	NIP
-	.loc stdlib.sol, 482
-	PUSH2 S0, S4
-	EQUAL
-	PUSHCONT {
-		.loc stdlib.sol, 483
-		PUSH S2
-		POP S4
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 485
-	PUSH S2
-	INC
-	POP S3
-	.loc stdlib.sol, 0
-}
-WHILE
-BLKDROP 3
-NIP
-.loc stdlib.sol, 0
-
-.globl	__strstr
-.type	__strstr, @function
-CALL $__strstr_macro$
-
-.macro __strstr_macro
-.loc stdlib.sol, 514
-NULL
-.loc stdlib.sol, 515
-PUSH S2
-CTOS
-.loc stdlib.sol, 516
-PUSH S2
-CTOS
-.loc stdlib.sol, 517
-DUP
-PUSHPOW2DEC 32
-SDATASIZE
-DROP
-NIP
-.loc stdlib.sol, 518
-PUSH S2
-PUSHPOW2DEC 32
-SDATASIZE
-DROP
-NIP
-.loc stdlib.sol, 519
-DUP2
-GREATER
-PUSHCONT {
-	.loc stdlib.sol, 520
-	ROLL 4
-	BLKDROP2 6, 1
-	.loc stdlib.sol, 0
-}
-IFJMP
-.loc stdlib.sol, 522
-OVER
-RSHIFT 3
-POP S2
-.loc stdlib.sol, 523
-RSHIFT 3
-.loc stdlib.sol, 524
-PUSH2 S0, S2
-.loc stdlib.sol, 525
-LDU 8
-POP S5
-.loc stdlib.sol, 526
-FALSE ; decl return flag
-PUSHCONT {
-	PUSH2 S3, S4
-	GEQ
-}
-PUSHCONT {
-	.loc stdlib.sol, 527
-	PUSH S6
-	LDU 8
-	POP S8
-	.loc stdlib.sol, 528
-	PUSH S7
-	SBITREFS
-	.loc stdlib.sol, 529
-	OVER
-	LESSINT 8
-	OVER
-	GTINT 0
-	AND
-	PUSHCONT {
-		.loc stdlib.sol, 530
-		PUSH S9
-		LDREFRTOS
-		NIP
-		POP S10
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 532
-	PUSH2 S2, S4
-	EQUAL
-	PUSHCONT {
-		.loc stdlib.sol, 533
-		BLKPUSH 2, 9
-		PUSHCONT {
-			.loc stdlib.sol, 491
-			OVER
-			SBITS
-			.loc stdlib.sol, 492
-			OVER
-			SBITS
-			.loc stdlib.sol, 493
-			FALSE ; decl return flag
-			PUSHCONT {
-				PUSH S2
-				NEQINT 0
-				PUSH S2
-				NEQINT 0
-				AND
-			}
-			PUSHCONT {
-				.loc stdlib.sol, 494
-				BLKPUSH 2, 2
-				MIN
-				.loc stdlib.sol, 495
-				PUSH2 S5, S0
-				LDSLICEX
-				POP S7
-				.loc stdlib.sol, 496
-				PUSH2 S5, S1
-				LDSLICEX
-				POP S7
-				.loc stdlib.sol, 497
-				PUSH2 S5, S2
-				SUB
-				POP S6
-				.loc stdlib.sol, 498
-				ROT
-				PUSH S4
-				SUBR
-				POP S4
-				.loc stdlib.sol, 499
-				SDEQ
-				PUSHCONT {
-					.loc stdlib.sol, 500
-					BLKDROP 5
-					FALSE
-					PUSHINT 4
-					RETALT
-					.loc stdlib.sol, 0
-				}
-				IFNOTJMP
-				.loc stdlib.sol, 502
-				PUSH S2
-				EQINT 0
-				PUSH S5
-				SREFS
-				NEQINT 0
-				AND
-				PUSHCONT {
-					.loc stdlib.sol, 503
-					PUSH S4
-					LDREFRTOS
-					NIP
-					POP S5
-					.loc stdlib.sol, 504
-					PUSH S4
-					SBITS
-					POP S3
-					.loc stdlib.sol, 0
-				}
-				IF
-				.loc stdlib.sol, 506
-				OVER
-				EQINT 0
-				PUSH S4
-				SREFS
-				NEQINT 0
-				AND
-				PUSHCONT {
-					.loc stdlib.sol, 507
-					PUSH S3
-					LDREFRTOS
-					NIP
-					POP S4
-					.loc stdlib.sol, 508
-					PUSH S3
-					SBITS
-					POP S2
-					.loc stdlib.sol, 0
-				}
-				IF
-				.loc stdlib.sol, 0
-			}
-			WHILEBRK
-			IFRET
-			.loc stdlib.sol, 511
-			BLKDROP 4
-			TRUE
-			.loc stdlib.sol, 490
-		}
-		CALLX
-		.loc stdlib.sol, 0
-		PUSHCONT {
-			.loc stdlib.sol, 534
-			BLKSWAP 2, 5
-			SUBR
-			UFITS 32
-			POP S9
-			.loc stdlib.sol, 535
-			ROLL 8
-			BLKDROP2 10, 1
-			PUSHINT 4
-			RETALT
-			.loc stdlib.sol, 0
-		}
-		IFJMP
-	}
-	IF
-	.loc stdlib.sol, 538
-	BLKDROP 3
-	PUSH S3
-	DEC
-	POP S4
-	.loc stdlib.sol, 0
-}
-WHILEBRK
-IFRET
-.loc stdlib.sol, 540
-BLKDROP 6
-BLKDROP2 2, 1
-.loc stdlib.sol, 0
-
-.globl	__toLowerCase
-.type	__toLowerCase, @function
-CALL $__toLowerCase_macro$
-
-.macro __toLowerCase_macro
-.loc stdlib.sol, 549
-NEWC
-NULL
-PAIR
-.loc stdlib.sol, 550
-PUSHINT 0
-.loc stdlib.sol, 551
-ROT
-CTOS
-NULL
-PUSHCONT {
-	OVER
-	SEMPTY
-	NOT
-}
-PUSHCONT {
-	OVER
-	LDUQ 8
-	PUSHCONT {
-		PLDREF
-		CTOS
-		LDU 8
-	}
-	IFNOT
-	POP S3
-	NIP
-	.loc stdlib.sol, 552
-	BLKPUSH 2, 0
-	.loc stdlib.sol, 553
-	GTINT 64
-	OVER
-	LESSINT 91
-	AND
-	PUSHCONT {
-		.loc stdlib.sol, 554
-		ADDCONST 32
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 556
-	PUSH2 S4, S4
-	FIRST
-	XCHG S1, S2
-	STU 8
-	SETINDEX 0
-	POP S4
-	.loc stdlib.sol, 557
-	PUSH S2
-	INC
-	POP S3
-	.loc stdlib.sol, 558
-	PUSH S2
-	EQINT 127
-	PUSHCONT {
-		.loc stdlib.sol, 559
-		NEWC
-		.loc stdlib.sol, 560
-		PUSH S4
-		PAIR
-		POP S4
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 0
-}
-WHILE
-BLKDROP 3
-.loc stdlib.sol, 563
-DUP
-FIRST
-.loc stdlib.sol, 564
-PUSHCONT {
-	OVER
-	SECOND
-	ISNULL
-	NOT
-}
-PUSHCONT {
-	.loc stdlib.sol, 565
-	OVER
-	SECOND
-	DUP
-	ISNULL
-	THROWIF 63
-	POP S2
-	.loc stdlib.sol, 566
-	OVER
-	FIRST
-	.loc stdlib.sol, 567
-	STBREF
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 570
-ENDC
-NIP
-.loc stdlib.sol, 0
-
-.globl	__toUpperCase
-.type	__toUpperCase, @function
-CALL $__toUpperCase_macro$
-
-.macro __toUpperCase_macro
-.loc stdlib.sol, 574
-NEWC
-NULL
-PAIR
-.loc stdlib.sol, 575
-PUSHINT 0
-.loc stdlib.sol, 576
-ROT
-CTOS
-NULL
-PUSHCONT {
-	OVER
-	SEMPTY
-	NOT
-}
-PUSHCONT {
-	OVER
-	LDUQ 8
-	PUSHCONT {
-		PLDREF
-		CTOS
-		LDU 8
-	}
-	IFNOT
-	POP S3
-	NIP
-	.loc stdlib.sol, 577
-	BLKPUSH 2, 0
-	.loc stdlib.sol, 578
-	GTINT 96
-	OVER
-	LESSINT 123
-	AND
-	PUSHCONT {
-		.loc stdlib.sol, 579
-		ADDCONST -32
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 581
-	PUSH2 S4, S4
-	FIRST
-	XCHG S1, S2
-	STU 8
-	SETINDEX 0
-	POP S4
-	.loc stdlib.sol, 582
-	PUSH S2
-	INC
-	POP S3
-	.loc stdlib.sol, 583
-	PUSH S2
-	EQINT 127
-	PUSHCONT {
-		.loc stdlib.sol, 584
-		NEWC
-		.loc stdlib.sol, 585
-		PUSH S4
-		PAIR
-		POP S4
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 0
-}
-WHILE
-BLKDROP 3
-.loc stdlib.sol, 588
-DUP
-FIRST
-.loc stdlib.sol, 589
-PUSHCONT {
-	OVER
-	SECOND
-	ISNULL
-	NOT
-}
-PUSHCONT {
-	.loc stdlib.sol, 590
-	OVER
-	SECOND
-	DUP
-	ISNULL
-	THROWIF 63
-	POP S2
-	.loc stdlib.sol, 591
-	OVER
-	FIRST
-	.loc stdlib.sol, 592
-	STBREF
-	.loc stdlib.sol, 0
-}
-WHILE
-.loc stdlib.sol, 595
-ENDC
-NIP
-.loc stdlib.sol, 0
-
-.globl	stateInitHash
-.type	stateInitHash, @function
-CALL $stateInitHash_macro$
-
-.macro stateInitHash_macro
-.loc stdlib.sol, 599
-NEWC
-.loc stdlib.sol, 601
-STSLICECONST x020134
-.loc stdlib.sol, 613
-ROT
-STUR 16
-.loc stdlib.sol, 614
-STU 16
-.loc stdlib.sol, 616
-ROT
-STUR 256
-.loc stdlib.sol, 617
-STU 256
-.loc stdlib.sol, 618
-ENDC
-CTOS
-SHA256U
-.loc stdlib.sol, 0
-
diff --git a/compiler/liblangutil/CMakeLists.txt b/compiler/liblangutil/CMakeLists.txt
index 31210220..f8a36dd8 100644
--- a/compiler/liblangutil/CMakeLists.txt
+++ b/compiler/liblangutil/CMakeLists.txt
@@ -25,7 +25,6 @@ set(sources
 	SourceReferenceFormatter.h
 	Token.cpp
 	Token.h
-	UndefMacros.h
 	UniqueErrorReporter.h
 
 	TVMVersion.h
diff --git a/compiler/liblangutil/CharStream.cpp b/compiler/liblangutil/CharStream.cpp
index 6ecd85bf..c6b58ef6 100644
--- a/compiler/liblangutil/CharStream.cpp
+++ b/compiler/liblangutil/CharStream.cpp
@@ -51,7 +51,6 @@
 #include <liblangutil/CharStream.h>
 #include <liblangutil/Exceptions.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 
@@ -79,21 +78,21 @@ char CharStream::setPosition(size_t _location)
 	return get();
 }
 
-string CharStream::lineAtPosition(int _position) const
+std::string CharStream::lineAtPosition(int _position) const
 {
 	// if _position points to \n, it returns the line before the \n
-	using size_type = string::size_type;
-	size_type searchStart = min<size_type>(m_source.size(), size_type(_position));
+	using size_type = std::string::size_type;
+	size_type searchStart = std::min<size_type>(m_source.size(), size_type(_position));
 	if (searchStart > 0)
 		searchStart--;
 	size_type lineStart = m_source.rfind('\n', searchStart);
-	if (lineStart == string::npos)
+	if (lineStart == std::string::npos)
 		lineStart = 0;
 	else
 		lineStart++;
-	string line = m_source.substr(
+	std::string line = m_source.substr(
 		lineStart,
-		min(m_source.find('\n', lineStart), m_source.size()) - lineStart
+		std::min(m_source.find('\n', lineStart), m_source.size()) - lineStart
 	);
 	if (!line.empty() && line.back() == '\r')
 		line.pop_back();
@@ -102,9 +101,9 @@ string CharStream::lineAtPosition(int _position) const
 
 LineColumn CharStream::translatePositionToLineColumn(int _position) const
 {
-	using size_type = string::size_type;
-	using diff_type = string::difference_type;
-	size_type searchPosition = min<size_type>(m_source.size(), size_type(_position));
+	using size_type = std::string::size_type;
+	using diff_type = std::string::difference_type;
+	size_type searchPosition = std::min<size_type>(m_source.size(), size_type(_position));
 	int lineNumber = static_cast<int>(count(m_source.begin(), m_source.begin() + diff_type(searchPosition), '\n'));
 	size_type lineStart;
 	if (searchPosition == 0)
@@ -112,24 +111,24 @@ LineColumn CharStream::translatePositionToLineColumn(int _position) const
 	else
 	{
 		lineStart = m_source.rfind('\n', searchPosition - 1);
-		lineStart = lineStart == string::npos ? 0 : lineStart + 1;
+		lineStart = lineStart == std::string::npos ? 0 : lineStart + 1;
 	}
 	return LineColumn{lineNumber, static_cast<int>(searchPosition - lineStart)};
 }
 
-string_view CharStream::text(SourceLocation const& _location) const
+std::string_view CharStream::text(SourceLocation const& _location) const
 {
 	if (!_location.hasText())
 		return {};
 	solAssert(_location.sourceName && *_location.sourceName == m_name, "");
 	solAssert(static_cast<size_t>(_location.end) <= m_source.size(), "");
-	return string_view{m_source}.substr(
+	return std::string_view{m_source}.substr(
 		static_cast<size_t>(_location.start),
 		static_cast<size_t>(_location.end - _location.start)
 	);
 }
 
-string CharStream::singleLineSnippet(string const& _sourceCode, SourceLocation const& _location)
+std::string CharStream::singleLineSnippet(std::string const& _sourceCode, SourceLocation const& _location)
 {
 	if (!_location.hasText())
 		return {};
@@ -137,39 +136,39 @@ string CharStream::singleLineSnippet(string const& _sourceCode, SourceLocation c
 	if (static_cast<size_t>(_location.start) >= _sourceCode.size())
 		return {};
 
-	string cut = _sourceCode.substr(static_cast<size_t>(_location.start), static_cast<size_t>(_location.end - _location.start));
+	std::string cut = _sourceCode.substr(static_cast<size_t>(_location.start), static_cast<size_t>(_location.end - _location.start));
 	auto newLinePos = cut.find_first_of("\n\r");
-	if (newLinePos != string::npos)
+	if (newLinePos != std::string::npos)
 		cut = cut.substr(0, newLinePos) + "...";
 
 	return cut;
 }
 
-optional<int> CharStream::translateLineColumnToPosition(LineColumn const& _lineColumn) const
+std::optional<int> CharStream::translateLineColumnToPosition(LineColumn const& _lineColumn) const
 {
 	return translateLineColumnToPosition(m_source, _lineColumn);
 }
 
-optional<int> CharStream::translateLineColumnToPosition(std::string const& _text, LineColumn const& _input)
+std::optional<int> CharStream::translateLineColumnToPosition(std::string const& _text, LineColumn const& _input)
 {
 	if (_input.line < 0)
-		return nullopt;
+		return std::nullopt;
 
 	size_t offset = 0;
 	for (int i = 0; i < _input.line; i++)
 	{
 		offset = _text.find('\n', offset);
 		if (offset == _text.npos)
-			return nullopt;
+			return std::nullopt;
 		offset++; // Skip linefeed.
 	}
 
 	size_t endOfLine = _text.find('\n', offset);
-	if (endOfLine == string::npos)
+	if (endOfLine == std::string::npos)
 		endOfLine = _text.size();
 
 	if (offset + static_cast<size_t>(_input.column) > endOfLine)
-		return nullopt;
+		return std::nullopt;
 	return offset + static_cast<size_t>(_input.column);
 }
 
diff --git a/compiler/liblangutil/DebugInfoSelection.cpp b/compiler/liblangutil/DebugInfoSelection.cpp
index 6ff023c0..88e09cdb 100644
--- a/compiler/liblangutil/DebugInfoSelection.cpp
+++ b/compiler/liblangutil/DebugInfoSelection.cpp
@@ -30,7 +30,6 @@
 
 #include <vector>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::util;
@@ -50,7 +49,7 @@ DebugInfoSelection const DebugInfoSelection::Only(bool DebugInfoSelection::* _me
 	return result;
 }
 
-optional<DebugInfoSelection> DebugInfoSelection::fromString(string_view _input)
+std::optional<DebugInfoSelection> DebugInfoSelection::fromString(std::string_view _input)
 {
 	// TODO: Make more stuff constexpr and make it a static_assert().
 	solAssert(componentMap().count("all") == 0, "");
@@ -61,11 +60,11 @@ optional<DebugInfoSelection> DebugInfoSelection::fromString(string_view _input)
 	if (_input == "none")
 		return None();
 
-	return fromComponents(_input | ranges::views::split(',') | ranges::to<vector<string>>);
+	return fromComponents(_input | ranges::views::split(',') | ranges::to<std::vector<std::string>>);
 }
 
-optional<DebugInfoSelection> DebugInfoSelection::fromComponents(
-	vector<string> const& _componentNames,
+std::optional<DebugInfoSelection> DebugInfoSelection::fromComponents(
+	std::vector<std::string> const& _componentNames,
 	bool _acceptWildcards
 )
 {
@@ -75,16 +74,16 @@ optional<DebugInfoSelection> DebugInfoSelection::fromComponents(
 	for (auto const& component: _componentNames)
 	{
 		if (component == "*")
-			return (_acceptWildcards ? make_optional(DebugInfoSelection::All()) : nullopt);
+			return (_acceptWildcards ? std::make_optional(DebugInfoSelection::All()) : std::nullopt);
 
 		if (!selection.enable(component))
-			return nullopt;
+			return std::nullopt;
 	}
 
 	return selection;
 }
 
-bool DebugInfoSelection::enable(string _component)
+bool DebugInfoSelection::enable(std::string _component)
 {
 	auto memberIt = componentMap().find(boost::trim_copy(_component));
 	if (memberIt == componentMap().end())
@@ -146,9 +145,9 @@ bool DebugInfoSelection::operator==(DebugInfoSelection const& _other) const noex
 	return true;
 }
 
-ostream& langutil::operator<<(ostream& _stream, DebugInfoSelection const& _selection)
+std::ostream& langutil::operator<<(std::ostream& _stream, DebugInfoSelection const& _selection)
 {
-	vector<string> selectedComponentNames;
+	std::vector<std::string> selectedComponentNames;
 	for (auto const& [name, member]: _selection.componentMap())
 		if (_selection.*member)
 			selectedComponentNames.push_back(name);
diff --git a/compiler/liblangutil/EVMVersion.cpp b/compiler/liblangutil/EVMVersion.cpp
new file mode 100644
index 00000000..438932a1
--- /dev/null
+++ b/compiler/liblangutil/EVMVersion.cpp
@@ -0,0 +1,64 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * EVM versioning.
+ */
+
+#include <liblangutil/EVMVersion.h>
+#include <libevmasm/Instruction.h>
+
+using namespace solidity;
+using namespace solidity::evmasm;
+using namespace solidity::langutil;
+
+bool EVMVersion::hasOpcode(Instruction _opcode) const
+{
+	switch (_opcode)
+	{
+	case Instruction::RETURNDATACOPY:
+	case Instruction::RETURNDATASIZE:
+		return supportsReturndata();
+	case Instruction::STATICCALL:
+		return hasStaticCall();
+	case Instruction::SHL:
+	case Instruction::SHR:
+	case Instruction::SAR:
+		return hasBitwiseShifting();
+	case Instruction::CREATE2:
+		return hasCreate2();
+	case Instruction::EXTCODEHASH:
+		return hasExtCodeHash();
+	case Instruction::CHAINID:
+		return hasChainID();
+	case Instruction::SELFBALANCE:
+		return hasSelfBalance();
+	case Instruction::BASEFEE:
+		return hasBaseFee();
+	case Instruction::BLOBHASH:
+		return hasBlobHash();
+	case Instruction::BLOBBASEFEE:
+		return hasBlobBaseFee();
+	case Instruction::MCOPY:
+		return hasMcopy();
+	case Instruction::TSTORE:
+	case Instruction::TLOAD:
+		return supportsTransientStorage();
+	default:
+		return true;
+	}
+}
diff --git a/compiler/liblangutil/EVMVersion.h b/compiler/liblangutil/EVMVersion.h
index 3b36d39c..4887159a 100644
--- a/compiler/liblangutil/EVMVersion.h
+++ b/compiler/liblangutil/EVMVersion.h
@@ -21,12 +21,19 @@
 
 #pragma once
 
+#include <cstdint>
 #include <optional>
 #include <string>
 
 #include <boost/operators.hpp>
 
 
+namespace solidity::evmasm
+{
+/// Virtual machine bytecode instruction. Forward declared from libevmasm/Instruction.h
+enum class Instruction: uint8_t;
+}
+
 namespace solidity::langutil
 {
 
@@ -50,10 +57,13 @@ class EVMVersion:
 	static EVMVersion istanbul() { return {Version::Istanbul}; }
 	static EVMVersion berlin() { return {Version::Berlin}; }
 	static EVMVersion london() { return {Version::London}; }
+	static EVMVersion paris() { return {Version::Paris}; }
+	static EVMVersion shanghai() { return {Version::Shanghai}; }
+	static EVMVersion cancun() { return {Version::Cancun}; }
 
 	static std::optional<EVMVersion> fromString(std::string const& _version)
 	{
-		for (auto const& v: {homestead(), tangerineWhistle(), spuriousDragon(), byzantium(), constantinople(), petersburg(), istanbul(), berlin(), london()})
+		for (auto const& v: {homestead(), tangerineWhistle(), spuriousDragon(), byzantium(), constantinople(), petersburg(), istanbul(), berlin(), london(), paris(), shanghai(), cancun()})
 			if (_version == v.name())
 				return v;
 		return std::nullopt;
@@ -75,6 +85,9 @@ class EVMVersion:
 		case Version::Istanbul: return "istanbul";
 		case Version::Berlin: return "berlin";
 		case Version::London: return "london";
+		case Version::Paris: return "paris";
+		case Version::Shanghai: return "shanghai";
+		case Version::Cancun: return "cancun";
 		}
 		return "INVALID";
 	}
@@ -88,17 +101,23 @@ class EVMVersion:
 	bool hasChainID() const { return *this >= istanbul(); }
 	bool hasSelfBalance() const { return *this >= istanbul(); }
 	bool hasBaseFee() const { return *this >= london(); }
+	bool hasBlobBaseFee() const { return *this >= cancun(); }
+	bool hasPrevRandao() const { return *this >= paris(); }
+	bool hasPush0() const { return *this >= shanghai(); }
+	bool hasBlobHash() const { return *this >= cancun(); }
+	bool hasMcopy() const { return *this >= cancun(); }
+	bool supportsTransientStorage() const { return *this >= cancun(); }
 
 	/// Whether we have to retain the costs for the call opcode itself (false),
 	/// or whether we can just forward easily all remaining gas (true).
 	bool canOverchargeGasForCall() const { return *this >= tangerineWhistle(); }
 
 private:
-	enum class Version { Homestead, TangerineWhistle, SpuriousDragon, Byzantium, Constantinople, Petersburg, Istanbul, Berlin, London };
+	enum class Version { Homestead, TangerineWhistle, SpuriousDragon, Byzantium, Constantinople, Petersburg, Istanbul, Berlin, London, Paris, Shanghai, Cancun };
 
 	EVMVersion(Version _version): m_version(_version) {}
 
-	Version m_version = Version::London;
+	Version m_version = Version::Shanghai;
 };
 
 }
diff --git a/compiler/liblangutil/ErrorReporter.cpp b/compiler/liblangutil/ErrorReporter.cpp
index f99247b3..298e4f63 100644
--- a/compiler/liblangutil/ErrorReporter.cpp
+++ b/compiler/liblangutil/ErrorReporter.cpp
@@ -25,7 +25,6 @@
 #include <liblangutil/SourceLocation.h>
 #include <memory>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 
@@ -37,7 +36,7 @@ ErrorReporter& ErrorReporter::operator=(ErrorReporter const& _errorReporter)
 	return *this;
 }
 
-void ErrorReporter::warning(ErrorId _error, string const& _description)
+void ErrorReporter::warning(ErrorId _error, std::string const& _description)
 {
 	error(_error, Error::Type::Warning, SourceLocation(), _description);
 }
@@ -45,7 +44,7 @@ void ErrorReporter::warning(ErrorId _error, string const& _description)
 void ErrorReporter::warning(
 	ErrorId _error,
 	SourceLocation const& _location,
-	string const& _description
+	std::string const& _description
 )
 {
 	error(_error, Error::Type::Warning, _location, _description);
@@ -54,27 +53,27 @@ void ErrorReporter::warning(
 void ErrorReporter::warning(
 	ErrorId _error,
 	SourceLocation const& _location,
-	string const& _description,
+	std::string const& _description,
 	SecondarySourceLocation const& _secondaryLocation
 )
 {
 	error(_error, Error::Type::Warning, _location, _secondaryLocation, _description);
 }
 
-void ErrorReporter::error(ErrorId _errorId, Error::Type _type, SourceLocation const& _location, string const& _description)
+void ErrorReporter::error(ErrorId _errorId, Error::Type _type, SourceLocation const& _location, std::string const& _description)
 {
 	if (checkForExcessiveErrors(_type))
 		return;
 
-	m_errorList.push_back(make_shared<Error>(_errorId, _type, _description, _location));
+	m_errorList.push_back(std::make_shared<Error>(_errorId, _type, _description, _location));
 }
 
-void ErrorReporter::error(ErrorId _errorId, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+void ErrorReporter::error(ErrorId _errorId, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	if (checkForExcessiveErrors(_type))
 		return;
 
-	m_errorList.push_back(make_shared<Error>(_errorId, _type, _description, _location, _secondaryLocation));
+	m_errorList.push_back(std::make_shared<Error>(_errorId, _type, _description, _location, _secondaryLocation));
 }
 
 bool ErrorReporter::hasExcessiveErrors() const
@@ -89,7 +88,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 		m_warningCount++;
 
 		if (m_warningCount == c_maxWarningsAllowed)
-			m_errorList.push_back(make_shared<Error>(4591_error, Error::Type::Warning, "There are more than 256 warnings. Ignoring the rest."));
+			m_errorList.push_back(std::make_shared<Error>(4591_error, Error::Type::Warning, "There are more than 256 warnings. Ignoring the rest."));
 
 		if (m_warningCount >= c_maxWarningsAllowed)
 			return true;
@@ -99,7 +98,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 		m_infoCount++;
 
 		if (m_infoCount == c_maxInfosAllowed)
-			m_errorList.push_back(make_shared<Error>(2833_error, Error::Type::Info, "There are more than 256 infos. Ignoring the rest."));
+			m_errorList.push_back(std::make_shared<Error>(2833_error, Error::Type::Info, "There are more than 256 infos. Ignoring the rest."));
 
 		if (m_infoCount >= c_maxInfosAllowed)
 			return true;
@@ -110,7 +109,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 
 		if (m_errorCount > c_maxErrorsAllowed)
 		{
-			m_errorList.push_back(make_shared<Error>(4013_error, Error::Type::Warning, "There are more than 256 errors. Aborting."));
+			m_errorList.push_back(std::make_shared<Error>(4013_error, Error::Type::Warning, "There are more than 256 errors. Aborting."));
 			BOOST_THROW_EXCEPTION(FatalError());
 		}
 	}
@@ -118,13 +117,13 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 	return false;
 }
 
-void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	error(_error, _type, _location, _secondaryLocation, _description);
 	BOOST_THROW_EXCEPTION(FatalError());
 }
 
-void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, string const& _description)
+void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, std::string const& _description)
 {
 	error(_error, _type, _location, _description);
 	BOOST_THROW_EXCEPTION(FatalError());
@@ -140,7 +139,7 @@ void ErrorReporter::clear()
 	m_errorList.clear();
 }
 
-void ErrorReporter::declarationError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+void ErrorReporter::declarationError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	error(
 		_error,
@@ -151,7 +150,7 @@ void ErrorReporter::declarationError(ErrorId _error, SourceLocation const& _loca
 	);
 }
 
-void ErrorReporter::declarationError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::declarationError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	error(
 		_error,
@@ -170,7 +169,7 @@ void ErrorReporter::fatalDeclarationError(ErrorId _error, SourceLocation const&
 		_description);
 }
 
-void ErrorReporter::parserError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::parserError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	error(
 		_error,
@@ -180,7 +179,7 @@ void ErrorReporter::parserError(ErrorId _error, SourceLocation const& _location,
 	);
 }
 
-void ErrorReporter::fatalParserError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::fatalParserError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	fatalError(
 		_error,
@@ -190,7 +189,7 @@ void ErrorReporter::fatalParserError(ErrorId _error, SourceLocation const& _loca
 	);
 }
 
-void ErrorReporter::syntaxError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::syntaxError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	error(
 		_error,
@@ -200,7 +199,7 @@ void ErrorReporter::syntaxError(ErrorId _error, SourceLocation const& _location,
 	);
 }
 
-void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	error(
 		_error,
@@ -211,7 +210,7 @@ void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, S
 	);
 }
 
-void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	error(
 		_error,
@@ -222,7 +221,7 @@ void ErrorReporter::typeError(ErrorId _error, SourceLocation const& _location, s
 }
 
 
-void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	fatalError(
 		_error,
@@ -233,7 +232,7 @@ void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _locati
 	);
 }
 
-void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	fatalError(
 		_error,
@@ -243,7 +242,7 @@ void ErrorReporter::fatalTypeError(ErrorId _error, SourceLocation const& _locati
 	);
 }
 
-void ErrorReporter::docstringParsingError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ErrorReporter::docstringParsingError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	error(
 		_error,
@@ -256,13 +255,13 @@ void ErrorReporter::docstringParsingError(ErrorId _error, SourceLocation const&
 void ErrorReporter::info(
 	ErrorId _error,
 	SourceLocation const& _location,
-	string const& _description
+	std::string const& _description
 )
 {
 	error(_error, Error::Type::Info, _location, _description);
 }
 
-void ErrorReporter::info(ErrorId _error, string const& _description)
+void ErrorReporter::info(ErrorId _error, std::string const& _description)
 {
 	error(_error, Error::Type::Info, SourceLocation(), _description);
 }
diff --git a/compiler/liblangutil/ErrorReporter.h b/compiler/liblangutil/ErrorReporter.h
index 67fc76e8..6901e87b 100644
--- a/compiler/liblangutil/ErrorReporter.h
+++ b/compiler/liblangutil/ErrorReporter.h
@@ -30,7 +30,8 @@
 #include <liblangutil/SourceLocation.h>
 #include <libsolutil/StringUtils.h>
 
-#include <boost/range/adaptor/filtered.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/filter.hpp>
 
 namespace solidity::langutil
 {
@@ -106,9 +107,8 @@ class ErrorReporter
 		std::initializer_list<std::string> const descs = { _descriptions... };
 		solAssert(descs.size() > 0, "Need error descriptions!");
 
-		auto filterEmpty = boost::adaptors::filtered([](std::string const& _s) { return !_s.empty(); });
-
-		std::string errorStr = util::joinHumanReadable(descs | filterEmpty, " ");
+		auto nonEmpty = [](std::string const& _s) { return !_s.empty(); };
+		std::string errorStr = util::joinHumanReadable(descs | ranges::views::filter(nonEmpty) | ranges::to_vector, " ");
 
 		error(_error, Error::Type::TypeError, _location, errorStr);
 	}
diff --git a/compiler/liblangutil/Exceptions.cpp b/compiler/liblangutil/Exceptions.cpp
index 2595c775..108acd12 100644
--- a/compiler/liblangutil/Exceptions.cpp
+++ b/compiler/liblangutil/Exceptions.cpp
@@ -26,10 +26,29 @@
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/algorithm/string/trim.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 
+std::map<Error::Type, std::string> const Error::m_errorTypeNames = {
+	{Error::Type::IOError, "IOError"},
+	{Error::Type::FatalError, "FatalError"},
+	{Error::Type::JSONError, "JSONError"},
+	{Error::Type::InternalCompilerError, "InternalCompilerError"},
+	{Error::Type::CompilerError, "CompilerError"},
+	{Error::Type::Exception, "Exception"},
+	{Error::Type::CodeGenerationError, "CodeGenerationError"},
+	{Error::Type::DeclarationError, "DeclarationError"},
+	{Error::Type::DocstringParsingError, "DocstringParsingError"},
+	{Error::Type::ParserError, "ParserError"},
+	{Error::Type::SyntaxError, "SyntaxError"},
+	{Error::Type::TypeError, "TypeError"},
+	{Error::Type::UnimplementedFeatureError, "UnimplementedFeatureError"},
+	{Error::Type::YulException, "YulException"},
+	{Error::Type::SMTLogicException, "SMTLogicException"},
+	{Error::Type::Warning, "Warning"},
+	{Error::Type::Info, "Info"},
+};
+
 Error::Error(
 	ErrorId _errorId, Error::Type _type,
 	std::string const& _description,
@@ -39,34 +58,6 @@ Error::Error(
 	m_errorId(_errorId),
 	m_type(_type)
 {
-	switch (m_type)
-	{
-	case Type::CodeGenerationError:
-		m_typeName = "CodeGenerationError";
-		break;
-	case Type::DeclarationError:
-		m_typeName = "DeclarationError";
-		break;
-	case Type::DocstringParsingError:
-		m_typeName = "DocstringParsingError";
-		break;
-	case Type::Info:
-		m_typeName = "Info";
-		break;
-	case Type::ParserError:
-		m_typeName = "ParserError";
-		break;
-	case Type::SyntaxError:
-		m_typeName = "SyntaxError";
-		break;
-	case Type::TypeError:
-		m_typeName = "TypeError";
-		break;
-	case Type::Warning:
-		m_typeName = "Warning";
-		break;
-	}
-
 	if (_location.isValid())
 		*this << errinfo_sourceLocation(_location);
 	if (!_secondaryLocation.infos.empty())
@@ -84,15 +75,3 @@ SecondarySourceLocation const* Error::secondarySourceLocation() const noexcept
 {
 	return boost::get_error_info<errinfo_secondarySourceLocation>(*this);
 }
-
-optional<Error::Severity> Error::severityFromString(string _input)
-{
-	boost::algorithm::to_lower(_input);
-	boost::algorithm::trim(_input);
-
-	for (Severity severity: {Severity::Error, Severity::Warning, Severity::Info})
-		if (_input == formatErrorSeverityLowercase(severity))
-			return severity;
-
-	return nullopt;
-}
diff --git a/compiler/liblangutil/Exceptions.h b/compiler/liblangutil/Exceptions.h
index fb6f23cf..b0701f99 100644
--- a/compiler/liblangutil/Exceptions.h
+++ b/compiler/liblangutil/Exceptions.h
@@ -31,11 +31,13 @@
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/facilities/empty.hpp>
 #include <boost/preprocessor/facilities/overload.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
 
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
-#include <memory>
 
 namespace solidity::langutil
 {
@@ -168,21 +170,31 @@ class Error: virtual public util::Exception
 public:
 	enum class Type
 	{
+		Info,
+		Warning,
 		CodeGenerationError,
 		DeclarationError,
 		DocstringParsingError,
 		ParserError,
 		TypeError,
 		SyntaxError,
-		Warning,
-		Info
+		IOError,
+		FatalError,
+		JSONError,
+		InternalCompilerError,
+		CompilerError,
+		Exception,
+		UnimplementedFeatureError,
+		YulException,
+		SMTLogicException,
 	};
 
 	enum class Severity
 	{
-		Error,
+		// NOTE: We rely on these being ordered from least to most severe.
+		Info,
 		Warning,
-		Info
+		Error,
 	};
 
 	Error(
@@ -195,7 +207,7 @@ class Error: virtual public util::Exception
 
 	ErrorId errorId() const { return m_errorId; }
 	Type type() const { return m_type; }
-	std::string const& typeName() const { return m_typeName; }
+	Severity severity() const { return errorSeverity(m_type); }
 
 	SourceLocation const* sourceLocation() const noexcept;
 	SecondarySourceLocation const* secondarySourceLocation() const noexcept;
@@ -211,11 +223,19 @@ class Error: virtual public util::Exception
 
 	static constexpr Severity errorSeverity(Type _type)
 	{
-		if (_type == Type::Info)
-			return Severity::Info;
-		if (_type == Type::Warning)
-			return Severity::Warning;
-		return Severity::Error;
+		switch (_type)
+		{
+			case Type::Info: return Severity::Info;
+			case Type::Warning: return Severity::Warning;
+			default: return Severity::Error;
+		}
+	}
+
+	static constexpr Severity errorSeverityOrType(std::variant<Error::Type, Error::Severity> _typeOrSeverity)
+	{
+		if (std::holds_alternative<Error::Type>(_typeOrSeverity))
+			return errorSeverity(std::get<Error::Type>(_typeOrSeverity));
+		return std::get<Error::Severity>(_typeOrSeverity);
 	}
 
 	static bool isError(Severity _severity)
@@ -237,36 +257,50 @@ class Error: virtual public util::Exception
 	}
 
 	static std::string formatErrorSeverity(Severity _severity)
-	{
-		if (_severity == Severity::Info)
-			return "Info";
-		if (_severity == Severity::Warning)
-			return "Warning";
-		solAssert(isError(_severity), "");
-		return "Error";
-	}
-
-	static std::string formatErrorSeverityLowercase(Severity _severity)
 	{
 		switch (_severity)
 		{
-		case Severity::Info:
-			return "info";
-		case Severity::Warning:
-			return "warning";
-		case Severity::Error:
-			solAssert(isError(_severity), "");
-			return "error";
+		case Severity::Info: return "Info";
+		case Severity::Warning: return "Warning";
+		case Severity::Error: return "Error";
 		}
-		solAssert(false, "");
+		util::unreachable();
+	}
+
+	static std::string formatErrorType(Type _type)
+	{
+		return m_errorTypeNames.at(_type);
+	}
+
+	static std::optional<Type> parseErrorType(std::string _name)
+	{
+		static std::map<std::string, Error::Type> const m_errorTypesByName = util::invertMap(m_errorTypeNames);
+
+		if (m_errorTypesByName.count(_name) == 0)
+			return std::nullopt;
+
+		return m_errorTypesByName.at(_name);
 	}
 
-	static std::optional<Severity> severityFromString(std::string _input);
+	static std::string formatTypeOrSeverity(std::variant<Error::Type, Error::Severity> _typeOrSeverity)
+	{
+		if (std::holds_alternative<Error::Type>(_typeOrSeverity))
+			return formatErrorType(std::get<Error::Type>(_typeOrSeverity));
+		return formatErrorSeverity(std::get<Error::Severity>(_typeOrSeverity));
+	}
+
+	static std::string formatErrorSeverityLowercase(Severity _severity)
+	{
+		std::string severityValue = formatErrorSeverity(_severity);
+		boost::algorithm::to_lower(severityValue);
+		return severityValue;
+	}
 
 private:
 	ErrorId m_errorId;
 	Type m_type;
-	std::string m_typeName;
+
+	static std::map<Type, std::string> const m_errorTypeNames;
 };
 
 }
diff --git a/compiler/liblangutil/ParserBase.cpp b/compiler/liblangutil/ParserBase.cpp
index 91f67861..fde0f27e 100644
--- a/compiler/liblangutil/ParserBase.cpp
+++ b/compiler/liblangutil/ParserBase.cpp
@@ -25,7 +25,6 @@
 #include <liblangutil/Scanner.h>
 #include <liblangutil/ErrorReporter.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 
@@ -44,7 +43,7 @@ Token ParserBase::peekNextToken() const
 	return m_scanner->peekNextToken();
 }
 
-string ParserBase::currentLiteral() const
+std::string ParserBase::currentLiteral() const
 {
 	return m_scanner->currentLiteral();
 }
@@ -54,7 +53,7 @@ Token ParserBase::advance()
 	return m_scanner->next();
 }
 
-string ParserBase::tokenName(Token _token)
+std::string ParserBase::tokenName(Token _token)
 {
 	if (_token == Token::Identifier)
 		return "identifier";
@@ -75,56 +74,10 @@ void ParserBase::expectToken(Token _value, bool _advance)
 {
 	Token tok = m_scanner->currentToken();
 	if (tok != _value)
-	{
-		string const expectedToken = ParserBase::tokenName(_value);
-		if (m_parserErrorRecovery)
-			parserError(6635_error, "Expected " + expectedToken + " but got " + tokenName(tok));
-		else
-			fatalParserError(2314_error, "Expected " + expectedToken + " but got " + tokenName(tok));
-		// Do not advance so that recovery can sync or make use of the current token.
-		// This is especially useful if the expected token
-		// is the only one that is missing and is at the end of a construct.
-		// "{ ... ; }" is such an example.
-		//        ^
-		_advance = false;
-	}
-	if (_advance)
-		advance();
-}
-
-void ParserBase::expectTokenOrConsumeUntil(Token _value, string const& _currentNodeName, bool _advance)
-{
-	solAssert(m_inParserRecovery, "The function is supposed to be called during parser recovery only.");
-
-	Token tok = m_scanner->currentToken();
-	if (tok != _value)
-	{
-		SourceLocation errorLoc = currentLocation();
-		int startPosition = errorLoc.start;
-		while (m_scanner->currentToken() != _value && m_scanner->currentToken() != Token::EOS)
-			advance();
-
-		string const expectedToken = ParserBase::tokenName(_value);
-		if (m_scanner->currentToken() == Token::EOS)
-		{
-			// rollback to where the token started, and raise exception to be caught at a higher level.
-			m_scanner->setPosition(static_cast<size_t>(startPosition));
-			string const msg = "In " + _currentNodeName + ", " + expectedToken + "is expected; got " + ParserBase::tokenName(tok) + " instead.";
-			fatalParserError(1957_error, errorLoc, msg);
-		}
-		else
-		{
-			parserWarning(3796_error, "Recovered in " + _currentNodeName + " at " + expectedToken + ".");
-			m_inParserRecovery = false;
-		}
-	}
-	else
-	{
-		string expectedToken = ParserBase::tokenName(_value);
-		parserWarning(3347_error, "Recovered in " + _currentNodeName + " at " + expectedToken + ".");
-		m_inParserRecovery = false;
-	}
-
+		fatalParserError(
+			2314_error,
+			"Expected " + ParserBase::tokenName(_value) + " but got " + tokenName(tok)
+		);
 	if (_advance)
 		advance();
 }
@@ -142,32 +95,32 @@ void ParserBase::decreaseRecursionDepth()
 	m_recursionDepth--;
 }
 
-void ParserBase::parserWarning(ErrorId _error, string const& _description)
+void ParserBase::parserWarning(ErrorId _error, std::string const& _description)
 {
 	m_errorReporter.warning(_error, currentLocation(), _description);
 }
 
-void ParserBase::parserWarning(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ParserBase::parserWarning(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	m_errorReporter.warning(_error, _location, _description);
 }
 
-void ParserBase::parserError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ParserBase::parserError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	m_errorReporter.parserError(_error, _location, _description);
 }
 
-void ParserBase::parserError(ErrorId _error, string const& _description)
+void ParserBase::parserError(ErrorId _error, std::string const& _description)
 {
 	parserError(_error, currentLocation(), _description);
 }
 
-void ParserBase::fatalParserError(ErrorId _error, string const& _description)
+void ParserBase::fatalParserError(ErrorId _error, std::string const& _description)
 {
 	fatalParserError(_error, currentLocation(), _description);
 }
 
-void ParserBase::fatalParserError(ErrorId _error, SourceLocation const& _location, string const& _description)
+void ParserBase::fatalParserError(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 {
 	m_errorReporter.fatalParserError(_error, _location, _description);
 }
diff --git a/compiler/liblangutil/ParserBase.h b/compiler/liblangutil/ParserBase.h
index f72400f6..88fc76a9 100644
--- a/compiler/liblangutil/ParserBase.h
+++ b/compiler/liblangutil/ParserBase.h
@@ -38,14 +38,9 @@ struct ErrorId;
 class ParserBase
 {
 public:
-	/// Set @a _parserErrorRecovery to true for additional error
-	/// recovery.  This is experimental and intended for use
-	/// by front-end tools that need partial AST information even
-	/// when errors occur.
-	explicit ParserBase(ErrorReporter& errorReporter, bool _parserErrorRecovery = false): m_errorReporter(errorReporter)
-	{
-		m_parserErrorRecovery = _parserErrorRecovery;
-	}
+	explicit ParserBase(ErrorReporter& errorReporter):
+		m_errorReporter(errorReporter)
+	{}
 
 	virtual ~ParserBase() = default;
 
@@ -70,13 +65,9 @@ class ParserBase
 	///@{
 	///@name Helper functions
 	/// If current token value is not @a _value, throw exception otherwise advance token
-	//  @a if _advance is true and error recovery is in effect.
+	//  if @a _advance is true
 	void expectToken(Token _value, bool _advance = true);
 
-	/// Like expectToken but if there is an error ignores tokens until
-	/// the expected token or EOS is seen. If EOS is encountered, back up to the error point,
-	/// and throw an exception so that a higher grammar rule has an opportunity to recover.
-	void expectTokenOrConsumeUntil(Token _value, std::string const& _currentNodeName, bool _advance = true);
 	Token currentToken() const;
 	Token peekNextToken() const;
 	std::string tokenName(Token _token);
@@ -108,10 +99,6 @@ class ParserBase
 	ErrorReporter& m_errorReporter;
 	/// Current recursion depth during parsing.
 	size_t m_recursionDepth = 0;
-	/// True if we are in parser error recovery. Usually this means we are scanning for
-	/// a synchronization token like ';', or '}'. We use this to reduce cascaded error messages.
-	bool m_inParserRecovery = false;
-	bool m_parserErrorRecovery = false;
 };
 
 }
diff --git a/compiler/liblangutil/Scanner.cpp b/compiler/liblangutil/Scanner.cpp
index 3602073b..806efa31 100644
--- a/compiler/liblangutil/Scanner.cpp
+++ b/compiler/liblangutil/Scanner.cpp
@@ -61,12 +61,11 @@
 #include <tuple>
 #include <array>
 
-using namespace std;
 
 namespace solidity::langutil
 {
 
-string to_string(ScannerError _errorCode)
+std::string to_string(ScannerError _errorCode)
 {
 	switch (_errorCode)
 	{
@@ -92,7 +91,7 @@ string to_string(ScannerError _errorCode)
 }
 
 
-ostream& operator<<(ostream& os, ScannerError _errorCode)
+std::ostream& operator<<(std::ostream& os, ScannerError _errorCode)
 {
 	return os << to_string(_errorCode);
 }
@@ -275,12 +274,12 @@ namespace
 ///          to the user.
 static ScannerError validateBiDiMarkup(CharStream& _stream, size_t _startPosition)
 {
-	static array<pair<string_view, int>, 5> constexpr directionalSequences{
-		pair<string_view, int>{"\xE2\x80\xAD", 1}, // U+202D (LRO - Left-to-Right Override)
-		pair<string_view, int>{"\xE2\x80\xAE", 1}, // U+202E (RLO - Right-to-Left Override)
-		pair<string_view, int>{"\xE2\x80\xAA", 1}, // U+202A (LRE - Left-to-Right Embedding)
-		pair<string_view, int>{"\xE2\x80\xAB", 1}, // U+202B (RLE - Right-to-Left Embedding)
-		pair<string_view, int>{"\xE2\x80\xAC", -1} // U+202C (PDF - Pop Directional Formatting
+	static std::array<std::pair<std::string_view, int>, 5> constexpr directionalSequences{
+		std::pair<std::string_view, int>{"\xE2\x80\xAD", 1}, // U+202D (LRO - Left-to-Right Override)
+		std::pair<std::string_view, int>{"\xE2\x80\xAE", 1}, // U+202E (RLO - Right-to-Left Override)
+		std::pair<std::string_view, int>{"\xE2\x80\xAA", 1}, // U+202A (LRE - Left-to-Right Embedding)
+		std::pair<std::string_view, int>{"\xE2\x80\xAB", 1}, // U+202B (RLE - Right-to-Left Embedding)
+		std::pair<std::string_view, int>{"\xE2\x80\xAC", -1} // U+202C (PDF - Pop Directional Formatting
 	};
 
 	size_t endPosition = _stream.position();
@@ -540,8 +539,8 @@ void Scanner::scanToken()
 
 	Token token;
 	// M and N are for the purposes of grabbing different type sizes
-	unsigned m{};
-	unsigned n{};
+	unsigned m = 0;
+	unsigned n = 0;
 	do
 	{
 		// Remember the position of the next token
@@ -666,7 +665,7 @@ void Scanner::scanToken()
 		case '.':
 			// . Number
 			advance();
-			if (isDecimalDigit(m_char))
+			if (m_kind != ScannerKind::ExperimentalSolidity && isDecimalDigit(m_char))
 				token = scanNumber('.');
 			else
 				token = Token::Period;
@@ -712,7 +711,7 @@ void Scanner::scanToken()
 		default:
 			if (isIdentifierStart(m_char))
 			{
-				tie(token, m, n) = scanIdentifierOrKeyword();
+				std::tie(token, m, n) = scanIdentifierOrKeyword();
 
 				// Special case for hexadecimal literals
 				if (token == Token::Hex)
@@ -757,7 +756,7 @@ void Scanner::scanToken()
 	m_tokens[NextNext].location.end = static_cast<int>(sourcePos());
 	m_tokens[NextNext].location.sourceName = m_sourceName;
 	m_tokens[NextNext].token = token;
-	m_tokens[NextNext].extendedTokenInfo = make_tuple(m, n);
+	m_tokens[NextNext].extendedTokenInfo = std::make_tuple(m, n);
 }
 
 bool Scanner::scanEscape()
@@ -1011,7 +1010,7 @@ Token Scanner::scanNumber(char _charSeen)
 	return Token::Number;
 }
 
-tuple<Token, unsigned, unsigned> Scanner::scanIdentifierOrKeyword()
+std::tuple<Token, unsigned, unsigned> Scanner::scanIdentifierOrKeyword()
 {
 	solAssert(isIdentifierStart(m_char), "");
 	LiteralScope literal(this, LITERAL_TYPE_STRING);
@@ -1020,15 +1019,28 @@ tuple<Token, unsigned, unsigned> Scanner::scanIdentifierOrKeyword()
 	while (isIdentifierPart(m_char) || (m_char == '.' && m_kind == ScannerKind::Yul))
 		addLiteralCharAndAdvance();
 	literal.complete();
+
 	auto const token = TokenTraits::fromIdentifierOrKeyword(m_tokens[NextNext].literal);
-	if (m_kind == ScannerKind::Yul)
+	switch (m_kind)
 	{
+	case ScannerKind::Solidity:
+		// Turn experimental Solidity keywords that are not keywords in legacy Solidity into identifiers.
+		if (TokenTraits::isExperimentalSolidityOnlyKeyword(std::get<0>(token)))
+			return std::make_tuple(Token::Identifier, 0, 0);
+		break;
+	case ScannerKind::Yul:
 		// Turn Solidity identifier into a Yul keyword
 		if (m_tokens[NextNext].literal == "leave")
 			return std::make_tuple(Token::Leave, 0, 0);
 		// Turn non-Yul keywords into identifiers.
 		if (!TokenTraits::isYulKeyword(std::get<0>(token)))
 			return std::make_tuple(Token::Identifier, 0, 0);
+		break;
+	case ScannerKind::ExperimentalSolidity:
+		// Turn legacy Solidity keywords that are not keywords in experimental Solidity into identifiers.
+		if (!TokenTraits::isExperimentalSolidityKeyword(std::get<0>(token)))
+			return std::make_tuple(Token::Identifier, 0, 0);
+		break;
 	}
 	return token;
 }
diff --git a/compiler/liblangutil/Scanner.h b/compiler/liblangutil/Scanner.h
index c45a2ec2..eaa2b3b5 100644
--- a/compiler/liblangutil/Scanner.h
+++ b/compiler/liblangutil/Scanner.h
@@ -69,7 +69,8 @@ class ParserRecorder;
 enum class ScannerKind
 {
 	Solidity,
-	Yul
+	Yul,
+	ExperimentalSolidity
 };
 
 enum class ScannerError
diff --git a/compiler/liblangutil/SemVerHandler.cpp b/compiler/liblangutil/SemVerHandler.cpp
index ceb562ae..2358eec5 100644
--- a/compiler/liblangutil/SemVerHandler.cpp
+++ b/compiler/liblangutil/SemVerHandler.cpp
@@ -27,18 +27,20 @@
 
 #include <functional>
 #include <limits>
+#include <fmt/format.h>
 
-using namespace std;
+using namespace std::string_literals;
 using namespace solidity;
 using namespace solidity::langutil;
+using namespace solidity::util;
 
-SemVerMatchExpressionParser::SemVerMatchExpressionParser(vector<Token> _tokens, vector<string> _literals):
+SemVerMatchExpressionParser::SemVerMatchExpressionParser(std::vector<Token> _tokens, std::vector<std::string> _literals):
 	m_tokens(std::move(_tokens)), m_literals(std::move(_literals))
 {
 	solAssert(m_tokens.size() == m_literals.size(), "");
 }
 
-SemVerVersion::SemVerVersion(string const& _versionString)
+SemVerVersion::SemVerVersion(std::string const& _versionString)
 {
 	auto i = _versionString.begin();
 	auto end = _versionString.end();
@@ -52,7 +54,7 @@ SemVerVersion::SemVerVersion(string const& _versionString)
 		if (level < 2)
 		{
 			if (i == end || *i != '.')
-				BOOST_THROW_EXCEPTION(SemVerError());
+				solThrow(SemVerError, "Invalid versionString: "s + _versionString);
 			else
 				++i;
 		}
@@ -61,16 +63,16 @@ SemVerVersion::SemVerVersion(string const& _versionString)
 	{
 		auto prereleaseStart = ++i;
 		while (i != end && *i != '+') ++i;
-		prerelease = string(prereleaseStart, i);
+		prerelease = std::string(prereleaseStart, i);
 	}
 	if (i != end && *i == '+')
 	{
 		auto buildStart = ++i;
 		while (i != end) ++i;
-		build = string(buildStart, i);
+		build = std::string(buildStart, i);
 	}
 	if (i != end)
-		BOOST_THROW_EXCEPTION(SemVerError());
+		solThrow(SemVerError, "Invalid versionString "s + _versionString);
 }
 
 bool SemVerMatchExpression::MatchComponent::matches(SemVerVersion const& _version) const
@@ -156,12 +158,12 @@ bool SemVerMatchExpression::matches(SemVerVersion const& _version) const
 	return false;
 }
 
-optional<SemVerMatchExpression> SemVerMatchExpressionParser::parse()
+SemVerMatchExpression SemVerMatchExpressionParser::parse()
 {
 	reset();
 
 	if (m_tokens.empty())
-		return nullopt;
+		solThrow(SemVerError, "Empty version pragma.");
 
 	try
 	{
@@ -171,14 +173,19 @@ optional<SemVerMatchExpression> SemVerMatchExpressionParser::parse()
 			if (m_pos >= m_tokens.size())
 				break;
 			if (currentToken() != Token::Or)
-				BOOST_THROW_EXCEPTION(SemVerError());
+			{
+				solThrow(
+					SemVerError,
+					"You can only combine version ranges using the || operator."
+				);
+			}
 			nextToken();
 		}
 	}
-	catch (SemVerError const&)
+	catch (SemVerError const& e)
 	{
 		reset();
-		return nullopt;
+		throw e;
 	}
 
 	return m_expression;
@@ -265,14 +272,22 @@ unsigned SemVerMatchExpressionParser::parseVersionPart()
 		{
 			c = currentChar();
 			if (v * 10 < v || v * 10 + static_cast<unsigned>(c - '0') < v * 10)
-				BOOST_THROW_EXCEPTION(SemVerError());
+				solThrow(SemVerError, "Integer too large to be used in a version number.");
 			v = v * 10 + static_cast<unsigned>(c - '0');
 			nextChar();
 		}
 		return v;
 	}
+	else if (c == char(-1))
+		solThrow(SemVerError, "Expected version number but reached end of pragma.");
 	else
-		BOOST_THROW_EXCEPTION(SemVerError());
+		solThrow(
+			SemVerError, fmt::format(
+				"Expected the start of a version number but instead found character '{}'. "
+				"Version number is invalid or the pragma is not terminated with a semicolon.",
+				c
+			)
+		);
 }
 
 char SemVerMatchExpressionParser::currentChar() const
diff --git a/compiler/liblangutil/SemVerHandler.h b/compiler/liblangutil/SemVerHandler.h
index bce4d736..cf344502 100644
--- a/compiler/liblangutil/SemVerHandler.h
+++ b/compiler/liblangutil/SemVerHandler.h
@@ -25,17 +25,18 @@
 
 #include <liblangutil/Token.h>
 #include <libsolutil/Assertions.h>
+#include <liblangutil/Exceptions.h>
 
 #include <string>
-#include <optional>
 #include <utility>
 #include <vector>
 
 namespace solidity::langutil
 {
 
-class SemVerError: public util::Exception
+struct SemVerError: public util::Exception
 {
+
 };
 
 #undef major
@@ -87,8 +88,8 @@ class SemVerMatchExpressionParser
 public:
 	SemVerMatchExpressionParser(std::vector<Token> _tokens, std::vector<std::string> _literals);
 
-	/// Returns an expression if it was parseable, or nothing otherwise.
-	std::optional<SemVerMatchExpression> parse();
+	/// Returns an expression if it was parsable, or throws a SemVerError otherwise.
+	SemVerMatchExpression parse();
 
 private:
 	void reset();
diff --git a/compiler/liblangutil/SourceLocation.cpp b/compiler/liblangutil/SourceLocation.cpp
index 72f2506e..61fe40f9 100644
--- a/compiler/liblangutil/SourceLocation.cpp
+++ b/compiler/liblangutil/SourceLocation.cpp
@@ -25,14 +25,13 @@
 
 using namespace solidity;
 using namespace solidity::langutil;
-using namespace std;
 
-SourceLocation solidity::langutil::parseSourceLocation(string const& _input, vector<shared_ptr<string const>> const& _sourceNames)
+SourceLocation solidity::langutil::parseSourceLocation(std::string const& _input, std::vector<std::shared_ptr<std::string const>> const& _sourceNames)
 {
 	// Expected input: "start:length:sourceindex"
 	enum SrcElem: size_t { Start, Length, Index };
 
-	vector<string> pos;
+	std::vector<std::string> pos;
 
 	boost::algorithm::split(pos, _input, boost::is_any_of(":"));
 
diff --git a/compiler/liblangutil/SourceReferenceExtractor.cpp b/compiler/liblangutil/SourceReferenceExtractor.cpp
index 373ad6b1..9389a77a 100644
--- a/compiler/liblangutil/SourceReferenceExtractor.cpp
+++ b/compiler/liblangutil/SourceReferenceExtractor.cpp
@@ -22,20 +22,20 @@
 
 #include <algorithm>
 #include <cmath>
+#include <variant>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 
 SourceReferenceExtractor::Message SourceReferenceExtractor::extract(
 	CharStreamProvider const& _charStreamProvider,
 	util::Exception const& _exception,
-	string _severity
+	std::variant<Error::Type, Error::Severity> _typeOrSeverity
 )
 {
 	SourceLocation const* location = boost::get_error_info<errinfo_sourceLocation>(_exception);
 
-	string const* message = boost::get_error_info<util::errinfo_comment>(_exception);
+	std::string const* message = boost::get_error_info<util::errinfo_comment>(_exception);
 	SourceReference primary = extract(_charStreamProvider, location, message ? *message : "");
 
 	std::vector<SourceReference> secondary;
@@ -44,16 +44,16 @@ SourceReferenceExtractor::Message SourceReferenceExtractor::extract(
 		for (auto const& info: secondaryLocation->infos)
 			secondary.emplace_back(extract(_charStreamProvider, &info.second, info.first));
 
-	return Message{std::move(primary), _severity, std::move(secondary), nullopt};
+	return Message{std::move(primary), _typeOrSeverity, std::move(secondary), std::nullopt};
 }
 
 SourceReferenceExtractor::Message SourceReferenceExtractor::extract(
 	CharStreamProvider const& _charStreamProvider,
-	Error const& _error
+	Error const& _error,
+	std::variant<Error::Type, Error::Severity> _typeOrSeverity
 )
 {
-	string severity = Error::formatErrorSeverity(Error::errorSeverity(_error.type()));
-	Message message = extract(_charStreamProvider, _error, severity);
+	Message message = extract(_charStreamProvider, static_cast<util::Exception>(_error), _typeOrSeverity);
 	message.errorId = _error.errorId();
 	return message;
 }
@@ -77,7 +77,7 @@ SourceReference SourceReferenceExtractor::extract(
 	LineColumn end = charStream.translatePositionToLineColumn(_location->end);
 	bool const isMultiline = start.line != end.line;
 
-	string line = charStream.lineAtPosition(_location->start);
+	std::string line = charStream.lineAtPosition(_location->start);
 
 	int locationLength =
 		isMultiline ?
@@ -87,7 +87,7 @@ SourceReference SourceReferenceExtractor::extract(
 	if (locationLength > 150)
 	{
 		auto const lhs = static_cast<size_t>(start.column) + 35;
-		string::size_type const rhs = (isMultiline ? line.length() : static_cast<size_t>(end.column)) - 35;
+		std::string::size_type const rhs = (isMultiline ? line.length() : static_cast<size_t>(end.column)) - 35;
 		line = line.substr(0, lhs) + " ... " + line.substr(rhs);
 		end.column = start.column + 75;
 		locationLength = 75;
@@ -97,9 +97,9 @@ SourceReference SourceReferenceExtractor::extract(
 	{
 		int const len = static_cast<int>(line.length());
 		line = line.substr(
-			static_cast<size_t>(max(0, start.column - 35)),
-			static_cast<size_t>(min(start.column, 35)) + static_cast<size_t>(
-				min(locationLength + 35, len - start.column)
+			static_cast<size_t>(std::max(0, start.column - 35)),
+			static_cast<size_t>(std::min(start.column, 35)) + static_cast<size_t>(
+				std::min(locationLength + 35, len - start.column)
 			)
 		);
 		if (start.column + locationLength + 35 < len)
@@ -118,7 +118,7 @@ SourceReference SourceReferenceExtractor::extract(
 		interest,
 		isMultiline,
 		line,
-		min(start.column, static_cast<int>(line.length())),
-		min(end.column, static_cast<int>(line.length()))
+		std::min(start.column, static_cast<int>(line.length())),
+		std::min(end.column, static_cast<int>(line.length()))
 	};
 }
diff --git a/compiler/liblangutil/SourceReferenceExtractor.h b/compiler/liblangutil/SourceReferenceExtractor.h
index 3b418fcf..3f7751f0 100644
--- a/compiler/liblangutil/SourceReferenceExtractor.h
+++ b/compiler/liblangutil/SourceReferenceExtractor.h
@@ -24,6 +24,7 @@
 #include <string>
 #include <tuple>
 #include <vector>
+#include <variant>
 
 namespace solidity::langutil
 {
@@ -55,12 +56,21 @@ namespace SourceReferenceExtractor
 	struct Message
 	{
 		SourceReference primary;
-		std::string severity; // "Error", "Warning", "Info", ...
+		std::variant<Error::Type, Error::Severity> _typeOrSeverity;
 		std::vector<SourceReference> secondary;
 		std::optional<ErrorId> errorId;
 	};
 
-	Message extract(CharStreamProvider const& _charStreamProvider, util::Exception const& _exception, std::string _severity);
+	Message extract(
+		CharStreamProvider const& _charStreamProvider,
+		util::Exception const& _exception,
+		std::variant<Error::Type, Error::Severity> _typeOrSeverity
+	);
+	Message extract(
+		CharStreamProvider const& _charStreamProvider,
+		Error const& _error,
+		std::variant<Error::Type, Error::Severity> _typeOrSeverity
+	);
 	Message extract(CharStreamProvider const& _charStreamProvider, Error const& _error);
 	SourceReference extract(CharStreamProvider const& _charStreamProvider, SourceLocation const* _location, std::string message = "");
 }
diff --git a/compiler/liblangutil/SourceReferenceFormatter.cpp b/compiler/liblangutil/SourceReferenceFormatter.cpp
index a38c5e61..c48cb328 100644
--- a/compiler/liblangutil/SourceReferenceFormatter.cpp
+++ b/compiler/liblangutil/SourceReferenceFormatter.cpp
@@ -26,8 +26,8 @@
 #include <libsolutil/UTF8.h>
 #include <iomanip>
 #include <string_view>
+#include <variant>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::util;
@@ -55,6 +55,28 @@ std::string SourceReferenceFormatter::formatErrorInformation(Error const& _error
 	);
 }
 
+char const* SourceReferenceFormatter::errorTextColor(Error::Severity _severity)
+{
+	switch (_severity)
+	{
+	case Error::Severity::Error: return RED;
+	case Error::Severity::Warning: return YELLOW;
+	case Error::Severity::Info: return WHITE;
+	}
+	util::unreachable();
+}
+
+char const* SourceReferenceFormatter::errorHighlightColor(Error::Severity _severity)
+{
+	switch (_severity)
+	{
+	case Error::Severity::Error: return RED_BACKGROUND;
+	case Error::Severity::Warning: return ORANGE_BACKGROUND_256;
+	case Error::Severity::Info: return GRAY_BACKGROUND;
+	}
+	util::unreachable();
+}
+
 AnsiColorized SourceReferenceFormatter::normalColored() const
 {
 	return AnsiColorized(m_stream, m_colored, {WHITE});
@@ -65,26 +87,14 @@ AnsiColorized SourceReferenceFormatter::frameColored() const
 	return AnsiColorized(m_stream, m_colored, {BOLD, BLUE});
 }
 
-AnsiColorized SourceReferenceFormatter::errorColored(optional<Error::Severity> _severity) const
+AnsiColorized SourceReferenceFormatter::errorColored(std::ostream& _stream, bool _colored, Error::Severity _severity)
 {
-	// We used to color messages of any severity as errors so this seems like a good default
-	// for cases where severity cannot be determined.
-	char const* textColor = RED;
-
-	if (_severity.has_value())
-		switch (_severity.value())
-		{
-		case Error::Severity::Error: textColor = RED; break;
-		case Error::Severity::Warning: textColor = YELLOW; break;
-		case Error::Severity::Info: textColor = WHITE; break;
-		}
-
-	return AnsiColorized(m_stream, m_colored, {BOLD, textColor});
+	return AnsiColorized(_stream, _colored, {BOLD, errorTextColor(_severity)});
 }
 
-AnsiColorized SourceReferenceFormatter::messageColored() const
+AnsiColorized SourceReferenceFormatter::messageColored(std::ostream& _stream, bool _colored)
 {
-	return AnsiColorized(m_stream, m_colored, {BOLD, WHITE});
+	return AnsiColorized(_stream, _colored, {BOLD, WHITE});
 }
 
 AnsiColorized SourceReferenceFormatter::secondaryColored() const
@@ -114,15 +124,15 @@ void SourceReferenceFormatter::printSourceLocation(SourceReference const& _ref)
 		return; // No line available, nothing else to print
 	}
 
-	string line = std::to_string(_ref.position.line + 1); // one-based line number as string
-	string leftpad = string(line.size(), ' ');
+	std::string line = std::to_string(_ref.position.line + 1); // one-based line number as string
+	std::string leftpad = std::string(line.size(), ' ');
 
 	// line 0: source name
 	m_stream << leftpad;
 	frameColored() << "-->";
 	m_stream << ' ' << _ref.sourceName << ':' << line << ':' << (_ref.position.column + 1) << ":\n";
 
-	string_view text = _ref.text;
+	std::string_view text = _ref.text;
 
 	if (m_charStreamProvider.charStream(_ref.sourceName).isImportedFromAST())
 		return;
@@ -176,15 +186,26 @@ void SourceReferenceFormatter::printSourceLocation(SourceReference const& _ref)
 	}
 }
 
-void SourceReferenceFormatter::printExceptionInformation(SourceReferenceExtractor::Message const& _msg)
+void SourceReferenceFormatter::printPrimaryMessage(
+	std::ostream& _stream,
+	std::string _message,
+	std::variant<Error::Type, Error::Severity> _typeOrSeverity,
+	std::optional<ErrorId> _errorId,
+	bool _colored,
+	bool _withErrorIds
+)
 {
-	// exception header line
-	optional<Error::Severity> severity = Error::severityFromString(_msg.severity);
-	errorColored(severity) << _msg.severity;
-	if (m_withErrorIds && _msg.errorId.has_value())
-		errorColored(severity) << " (" << _msg.errorId.value().error << ")";
-	messageColored() << ": " << _msg.primary.message << '\n';
+	errorColored(_stream, _colored, Error::errorSeverityOrType(_typeOrSeverity)) << Error::formatTypeOrSeverity(_typeOrSeverity);
+
+	if (_withErrorIds && _errorId.has_value())
+		errorColored(_stream, _colored, Error::errorSeverityOrType(_typeOrSeverity)) << " (" << _errorId.value().error << ")";
 
+	messageColored(_stream, _colored) << ": " << _message << '\n';
+}
+
+void SourceReferenceFormatter::printExceptionInformation(SourceReferenceExtractor::Message const& _msg)
+{
+	printPrimaryMessage(m_stream, _msg.primary.message, _msg._typeOrSeverity, _msg.errorId, m_colored, m_withErrorIds);
 	printSourceLocation(_msg.primary);
 
 	for (auto const& secondary: _msg.secondary)
@@ -197,7 +218,12 @@ void SourceReferenceFormatter::printExceptionInformation(SourceReferenceExtracto
 	m_stream << '\n';
 }
 
-void SourceReferenceFormatter::printExceptionInformation(util::Exception const& _exception, std::string const& _severity)
+void SourceReferenceFormatter::printExceptionInformation(util::Exception const& _exception, Error::Type _type)
+{
+	printExceptionInformation(SourceReferenceExtractor::extract(m_charStreamProvider, _exception, _type));
+}
+
+void SourceReferenceFormatter::printExceptionInformation(util::Exception const& _exception, Error::Severity _severity)
 {
 	printExceptionInformation(SourceReferenceExtractor::extract(m_charStreamProvider, _exception, _severity));
 }
@@ -210,5 +236,11 @@ void SourceReferenceFormatter::printErrorInformation(ErrorList const& _errors)
 
 void SourceReferenceFormatter::printErrorInformation(Error const& _error)
 {
-	printExceptionInformation(SourceReferenceExtractor::extract(m_charStreamProvider, _error));
+	SourceReferenceExtractor::Message message =
+		SourceReferenceExtractor::extract(
+			m_charStreamProvider,
+			_error,
+			Error::errorSeverity(_error.type())
+		);
+	printExceptionInformation(message);
 }
diff --git a/compiler/liblangutil/SourceReferenceFormatter.h b/compiler/liblangutil/SourceReferenceFormatter.h
index e18400b6..7163199d 100644
--- a/compiler/liblangutil/SourceReferenceFormatter.h
+++ b/compiler/liblangutil/SourceReferenceFormatter.h
@@ -46,19 +46,52 @@ class SourceReferenceFormatter
 		bool _colored,
 		bool _withErrorIds
 	):
-		m_stream(_stream), m_charStreamProvider(_charStreamProvider), m_colored(_colored), m_withErrorIds(_withErrorIds)
+		m_stream(_stream),
+		m_charStreamProvider(_charStreamProvider),
+		m_colored(_colored),
+		m_withErrorIds(_withErrorIds)
 	{}
 
+	// WARNING: Use the xyzErrorInformation() variants over xyzExceptionInformation() when you
+	// do have access to an Error instance. Error is implicitly convertible to util::Exception
+	// but the conversion loses the error ID.
+
 	/// Prints source location if it is given.
 	void printSourceLocation(SourceReference const& _ref);
 	void printExceptionInformation(SourceReferenceExtractor::Message const& _msg);
-	void printExceptionInformation(util::Exception const& _exception, std::string const& _severity);
+	void printExceptionInformation(util::Exception const& _exception, Error::Type _type);
+	void printExceptionInformation(util::Exception const& _exception, Error::Severity _severity);
 	void printErrorInformation(langutil::ErrorList const& _errors);
 	void printErrorInformation(Error const& _error);
 
 	static std::string formatExceptionInformation(
 		util::Exception const& _exception,
-		std::string const& _name,
+		Error::Type _type,
+		CharStreamProvider const& _charStreamProvider,
+		bool _colored = false
+	)
+	{
+		std::ostringstream errorOutput;
+		SourceReferenceFormatter formatter(errorOutput, _charStreamProvider, _colored, false /* _withErrorIds */);
+		formatter.printExceptionInformation(_exception, _type);
+		return errorOutput.str();
+	}
+
+	static std::string formatExceptionInformation(
+		util::Exception const& _exception,
+		Error::Severity _severity,
+		CharStreamProvider const& _charStreamProvider,
+		bool _colored = false
+	)
+	{
+		std::ostringstream errorOutput;
+		SourceReferenceFormatter formatter(errorOutput, _charStreamProvider, _colored, false /* _withErrorIds */);
+		formatter.printExceptionInformation(_exception, _severity);
+		return errorOutput.str();
+	}
+
+	static std::string formatErrorInformation(
+		Error const& _error,
 		CharStreamProvider const& _charStreamProvider,
 		bool _colored = false,
 		bool _withErrorIds = false
@@ -66,33 +99,56 @@ class SourceReferenceFormatter
 	{
 		std::ostringstream errorOutput;
 		SourceReferenceFormatter formatter(errorOutput, _charStreamProvider, _colored, _withErrorIds);
-		formatter.printExceptionInformation(_exception, _name);
+		formatter.printErrorInformation(_error);
 		return errorOutput.str();
 	}
 
 	static std::string formatErrorInformation(
-		Error const& _error,
-		CharStreamProvider const& _charStreamProvider
+		langutil::ErrorList const& _errors,
+		CharStreamProvider const& _charStreamProvider,
+		bool _colored = false,
+		bool _withErrorIds = false
 	)
 	{
-		return formatExceptionInformation(
-			_error,
-			Error::formatErrorSeverity(Error::errorSeverity(_error.type())),
-			_charStreamProvider
-		);
+		std::ostringstream errorOutput;
+		SourceReferenceFormatter formatter(errorOutput, _charStreamProvider, _colored, _withErrorIds);
+		formatter.printErrorInformation(_errors);
+		return errorOutput.str();
 	}
 
 	static std::string formatErrorInformation(Error const& _error, CharStream const& _charStream);
 
+	static void printPrimaryMessage(
+		std::ostream& _stream,
+		std::string _message,
+		std::variant<Error::Type, Error::Severity> _typeOrSeverity,
+		std::optional<ErrorId> _errorId = std::nullopt,
+		bool _colored = false,
+		bool _withErrorIds = false
+	);
+
+	/// The default text color for printing error messages of a given severity in the terminal.
+	/// Assumes a dark background color.
+	static char const* errorTextColor(Error::Severity _severity);
+
+	/// The default background color for highlighting source fragments corresponding to an error
+	/// of a given severity in the terminal. Assumes a light text color.
+	/// @note This is *not* meant to be used for the same text in combination with @a errorTextColor().
+	///       It's an alternative way to highlight it, while preserving the original text color.
+	static char const* errorHighlightColor(Error::Severity _severity);
+
 private:
 	util::AnsiColorized normalColored() const;
 	util::AnsiColorized frameColored() const;
-	util::AnsiColorized errorColored(std::optional<langutil::Error::Severity> _severity) const;
-	util::AnsiColorized messageColored() const;
+	util::AnsiColorized errorColored(Error::Severity _severity) const { return errorColored(m_stream, m_colored, _severity); }
+	util::AnsiColorized messageColored() const { return messageColored(m_stream, m_colored); }
 	util::AnsiColorized secondaryColored() const;
 	util::AnsiColorized highlightColored() const;
 	util::AnsiColorized diagColored() const;
 
+	static util::AnsiColorized errorColored(std::ostream& _stream, bool _colored, langutil::Error::Severity _severity);
+	static util::AnsiColorized messageColored(std::ostream& _stream, bool _colored);
+
 private:
 	std::ostream& m_stream;
 	CharStreamProvider const& m_charStreamProvider;
diff --git a/compiler/liblangutil/Token.cpp b/compiler/liblangutil/Token.cpp
index 6c0f0c58..60fcfbeb 100644
--- a/compiler/liblangutil/Token.cpp
+++ b/compiler/liblangutil/Token.cpp
@@ -46,9 +46,6 @@
 
 #include <map>
 
-
-using namespace std;
-
 namespace solidity::langutil
 {
 
@@ -72,25 +69,26 @@ std::string ElementaryTypeNameToken::toString(bool const& tokenValue) const
 
 void ElementaryTypeNameToken::assertDetails(Token _baseType, unsigned const& _first, unsigned const& _second)
 {
-	solAssert(TokenTraits::isElementaryTypeName(_baseType), "Expected elementary type name: " + string(TokenTraits::toString(_baseType)));
+	solAssert(TokenTraits::isElementaryTypeName(_baseType), "Expected elementary type name: " + std::string(TokenTraits::toString(_baseType)));
 	if (_baseType == Token::BytesM)
 	{
 		solAssert(_second == 0, "There should not be a second size argument to type bytesM.");
-		solAssert(_first <= 32, "No elementary type bytes" + to_string(_first) + ".");
+		solAssert(_first <= 32, "No elementary type bytes" + std::to_string(_first) + ".");
 	}
 	else if (_baseType == Token::UIntM || _baseType == Token::IntM)
 	{
-		solAssert(_second == 0, "There should not be a second size argument to type " + string(TokenTraits::toString(_baseType)) + ".");
+		unsigned bitLength = _baseType == Token::UInt ? 256 : 257;
+		solAssert(_second == 0, "There should not be a second size argument to type " + std::string(TokenTraits::toString(_baseType)) + ".");
 		solAssert(
-			_first > 0 && _first <= 256,
-			"No elementary type " + string(TokenTraits::toString(_baseType)) + to_string(_first) + "."
+			_first <= bitLength,
+			"No elementary type " + std::string(TokenTraits::toString(_baseType)) + std::to_string(_first) + "."
 		);
 	}
 	else if (_baseType == Token::UFixedMxN || _baseType == Token::FixedMxN)
 	{
 		solAssert(
-			_first >= 8 && _first <= 256 && _first % 8 == 0 && _second <= 80,
-			"No elementary type " + string(TokenTraits::toString(_baseType)) + to_string(_first) + "x" + to_string(_second) + "."
+			_first >= 8 && _first <= 256 && _second <= 80,
+			"No elementary type " + std::string(TokenTraits::toString(_baseType)) + std::to_string(_first) + "x" + std::to_string(_second) + "."
 		);
 	}
 	else if (_baseType == Token::VarUintM || _baseType == Token::VarIntM)
@@ -141,29 +139,29 @@ std::string friendlyName(Token tok)
 }
 
 
-static Token keywordByName(string const& _name)
+static Token keywordByName(std::string const& _name)
 {
 	// The following macros are used inside TOKEN_LIST and cause non-keyword tokens to be ignored
 	// and keywords to be put inside the keywords variable.
 #define KEYWORD(name, string, precedence) {string, Token::name},
 #define TOKEN(name, string, precedence)
-	static map<string, Token> const keywords({TOKEN_LIST(TOKEN, KEYWORD)});
+	static std::map<std::string, Token> const keywords({TOKEN_LIST(TOKEN, KEYWORD)});
 #undef KEYWORD
 #undef TOKEN
 	auto it = keywords.find(_name);
 	return it == keywords.end() ? Token::Identifier : it->second;
 }
 
-bool isYulKeyword(string const& _literal)
+bool isYulKeyword(std::string const& _literal)
 {
 	return _literal == "leave" || isYulKeyword(keywordByName(_literal));
 }
 
-tuple<Token, unsigned int, unsigned int> fromIdentifierOrKeyword(string const& _literal)
+std::tuple<Token, unsigned int, unsigned int> fromIdentifierOrKeyword(std::string const& _literal)
 {
 	// Used for `bytesM`, `uintM`, `intM`, `fixedMxN`, `ufixedMxN`.
 	// M/N must be shortest representation. M can never be 0. N can be zero.
-	auto parseSize = [](string::const_iterator _begin, string::const_iterator _end) -> int
+	auto parseSize = [](std::string::const_iterator _begin, std::string::const_iterator _end) -> int
 	{
 		// No number.
 		if (distance(_begin, _end) == 0)
@@ -190,7 +188,7 @@ tuple<Token, unsigned int, unsigned int> fromIdentifierOrKeyword(string const& _
 	auto positionM = find_if(_literal.begin(), _literal.end(), util::isDigit);
 	if (positionM != _literal.end())
 	{
-		string baseType(_literal.begin(), positionM);
+		std::string baseType(_literal.begin(), positionM);
 		auto positionX = find_if_not(positionM, _literal.end(), util::isDigit);
 		int m = parseSize(positionM, positionX);
 		Token keyword = keywordByName(baseType);
@@ -199,23 +197,24 @@ tuple<Token, unsigned int, unsigned int> fromIdentifierOrKeyword(string const& _
 		if (keyword == Token::VarUint || keyword == Token::VarInt) {
 			if (m == 16 || m == 32) {
 				if (keyword == Token::VarUint)
-					return make_tuple(Token::VarUintM, m, 0);
-				return make_tuple(Token::VarIntM, m, 0);
+					return std::make_tuple(Token::VarUintM, m, 0);
+				return std::make_tuple(Token::VarIntM, m, 0);
 			}
 		}
 		else if (keyword == Token::Bytes)
 		{
 			if (0 < m && m <= 32 && positionX == _literal.end())
-				return make_tuple(Token::BytesM, m, 0);
+				return std::make_tuple(Token::BytesM, m, 0);
 		}
 		else if (keyword == Token::UInt || keyword == Token::Int)
 		{
-			if (0 < m && m <= 256 && positionX == _literal.end())
+			int bitLength = keyword == Token::UInt ? 256 : 257;
+			if (0 < m && m <= bitLength && positionX == _literal.end())
 			{
 				if (keyword == Token::UInt)
-					return make_tuple(Token::UIntM, m, 0);
+					return std::make_tuple(Token::UIntM, m, 0);
 				else
-					return make_tuple(Token::IntM, m, 0);
+					return std::make_tuple(Token::IntM, m, 0);
 			}
 		}
 		else if (keyword == Token::UFixed || keyword == Token::Fixed)
@@ -228,20 +227,20 @@ tuple<Token, unsigned int, unsigned int> fromIdentifierOrKeyword(string const& _
 			) {
 				int n = parseSize(positionX + 1, _literal.end());
 				if (
-					8 <= m && m <= 256 && m % 8 == 0 &&
+					8 <= m && m <= 256 &&
 					0 <= n && n <= 80
 				) {
 					if (keyword == Token::UFixed)
-						return make_tuple(Token::UFixedMxN, m, n);
+						return std::make_tuple(Token::UFixedMxN, m, n);
 					else
-						return make_tuple(Token::FixedMxN, m, n);
+						return std::make_tuple(Token::FixedMxN, m, n);
 				}
 			}
 		}
-		return make_tuple(Token::Identifier, 0, 0);
+		return std::make_tuple(Token::Identifier, 0, 0);
 	}
 
-	return make_tuple(keywordByName(_literal), 0, 0);
+	return std::make_tuple(keywordByName(_literal), 0, 0);
 }
 
 }
diff --git a/compiler/liblangutil/Token.h b/compiler/liblangutil/Token.h
index 2553a74e..5515e18b 100644
--- a/compiler/liblangutil/Token.h
+++ b/compiler/liblangutil/Token.h
@@ -42,8 +42,6 @@
 
 #pragma once
 
-#include <liblangutil/UndefMacros.h>
-
 #include <iosfwd>
 #include <string>
 #include <tuple>
@@ -179,8 +177,9 @@ namespace solidity::langutil
 	K(Mapping, "mapping", 0)                                           \
 	K(Modifier, "modifier", 0)                                         \
 	K(New, "new", 0)                                                   \
+	K(NoStorage, "nostorage", 0)                                       \
 	K(Optional, "optional", 0)                                         \
-	K(TvmVector, "vector", 0)                                           \
+	K(TvmVector, "vector", 0)                                          \
 	K(Override, "override", 0)                                         \
 	K(Payable, "payable", 0)                                           \
 	K(Public, "public", 0)                                             \
@@ -258,6 +257,7 @@ namespace solidity::langutil
 	K(VarInt, "varInt", 0)                                             \
 	T(VarIntM, "varIntM", 0)                                           \
 	K(VarUint, "varUint", 0)                                           \
+	K(coins, "coins", 0)                                               \
 	T(VarUintM, "varUintM", 0)                                         \
 	T(TypesEnd, nullptr, 0) /* used as type enum end marker */         \
 	\
@@ -310,6 +310,16 @@ namespace solidity::langutil
 	/* Yul-specific tokens, but not keywords. */                       \
 	T(Leave, "leave", 0)                                               \
 	\
+	T(NonExperimentalEnd, nullptr, 0) /* used as non-experimental enum end marker */ \
+	/* Experimental Solidity specific keywords. */                     \
+	K(Class, "class", 0)                                               \
+	K(Instantiation, "instantiation", 0)                               \
+	K(Integer, "Integer", 0)                                           \
+	K(Itself, "itself", 0)                                             \
+	K(StaticAssert, "static_assert", 0)                                \
+	K(Builtin, "__builtin", 0)                                         \
+	T(ExperimentalEnd, nullptr, 0) /* used as experimental enum end marker */ \
+	\
 	/* Illegal token - not able to scan. */                            \
 	T(Illegal, "ILLEGAL", 0)                                           \
 	\
@@ -332,7 +342,7 @@ namespace TokenTraits
 	constexpr size_t count() { return static_cast<size_t>(Token::NUM_TOKENS); }
 
 	// Predicates
-	constexpr bool isElementaryTypeName(Token tok) { return Token::Int <= tok && tok < Token::TypesEnd; }
+	constexpr bool isElementaryTypeName(Token _token) { return Token::Int <= _token && _token < Token::TypesEnd; }
 	constexpr bool isAssignmentOp(Token tok) { return Token::Assign <= tok && tok <= Token::AssignMod; }
 	constexpr bool isBinaryOp(Token op) { return Token::Comma <= op && op <= Token::Exp; }
 	constexpr bool isCommutativeOp(Token op) { return op == Token::BitOr || op == Token::BitXor || op == Token::BitAnd ||
@@ -342,7 +352,7 @@ namespace TokenTraits
 
 	constexpr bool isBitOp(Token op) { return (Token::BitOr <= op && op <= Token::BitAnd) || op == Token::BitNot; }
 	constexpr bool isBooleanOp(Token op) { return (Token::Or <= op && op <= Token::And) || op == Token::Not; }
-	constexpr bool isUnaryOp(Token op) { return (Token::Not <= op && op <= Token::Delete) || op == Token::Add || op == Token::Sub; }
+	constexpr bool isUnaryOp(Token op) { return (Token::Not <= op && op <= Token::Delete) || op == Token::Sub; }
 	constexpr bool isCountOp(Token op) { return op == Token::Inc || op == Token::Dec; }
 	constexpr bool isShiftOp(Token op) { return (Token::SHL <= op) && (op <= Token::SHR); }
 	constexpr bool isVariableVisibilitySpecifier(Token op) {
@@ -355,6 +365,7 @@ namespace TokenTraits
 		return op == Token::Pure || op == Token::View || op == Token::Payable;
 	}
 
+	// TODO RENAME
 	constexpr bool isTonSubdenomination(Token op) { return (Token::SubNano <= op && op <= Token::SubGEver); }
 	constexpr bool isTimeSubdenomination(Token op) { return op == Token::SubSecond || op == Token::SubMinute || op == Token::SubHour || op == Token::SubDay || op == Token::SubWeek || op == Token::SubYear; }
 	constexpr bool isReservedKeyword(Token op) { return (Token::After <= op && op <= Token::Var); }
@@ -366,6 +377,48 @@ namespace TokenTraits
 			tok == Token::TrueLiteral || tok == Token::FalseLiteral || tok == Token::HexStringLiteral || tok == Token::Hex;
 	}
 
+	constexpr bool isBuiltinTypeClassName(Token _token)
+	{
+		return
+			_token == Token::Integer ||
+			(isBinaryOp(_token) && _token != Token::Comma) ||
+			isCompareOp(_token) ||
+			isUnaryOp(_token) ||
+			(isAssignmentOp(_token) && _token != Token::Assign);
+	}
+
+	constexpr bool isExperimentalSolidityKeyword(Token token)
+	{
+		return
+			token == Token::Assembly ||
+			token == Token::Contract ||
+			token == Token::External ||
+			token == Token::Fallback ||
+			token == Token::Pragma ||
+			token == Token::Import ||
+			token == Token::As ||
+			token == Token::Function ||
+			token == Token::Let ||
+			token == Token::Return ||
+			token == Token::Type ||
+			token == Token::If ||
+			token == Token::Else ||
+			token == Token::Do ||
+			token == Token::While ||
+			token == Token::For ||
+			token == Token::Continue ||
+			token == Token::Break ||
+			(token > Token::NonExperimentalEnd && token< Token::ExperimentalEnd);
+	}
+
+	constexpr bool isExperimentalSolidityOnlyKeyword(Token _token)
+	{
+		// TODO: use token > Token::NonExperimentalEnd && token < Token::ExperimentalEnd
+		// as soon as other experimental tokens are added. For now the comparison generates
+		// a warning from clang because it is always false.
+		return _token > Token::NonExperimentalEnd && _token < Token::ExperimentalEnd;
+	}
+
 	bool isYulKeyword(std::string const& _literal);
 
 	Token AssignmentToBinaryOp(Token op);
diff --git a/compiler/liblangutil/UndefMacros.h b/compiler/liblangutil/UndefMacros.h
deleted file mode 100644
index e3dde6d3..00000000
--- a/compiler/liblangutil/UndefMacros.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/** @file UndefMacros.h
- * @author Lefteris  <lefteris@ethdev.com>
- * @date 2015
- *
- * This header should be used to #undef some really evil macros defined by
- * windows.h which result in conflict with our Token.h
- */
-#pragma once
-
-#if defined(_MSC_VER) || defined(__MINGW32__)
-
-#undef DELETE
-#undef IN
-#undef VOID
-#undef THIS
-#undef CONST
-
-// Conflicting define on MinGW in windows.h
-// windows.h(19): #define interface struct
-#ifdef interface
-#undef interface
-#endif
-
-#elif defined(DELETE) || defined(IN) || defined(VOID) || defined(THIS) || defined(CONST) || defined(interface)
-
-#error "The preceding macros in this header file are reserved for V8's "\
-"TOKEN_LIST. Please add a platform specific define above to undefine "\
-"overlapping macros."
-
-#endif
diff --git a/compiler/liblangutil/UniqueErrorReporter.h b/compiler/liblangutil/UniqueErrorReporter.h
index ebcb8d97..902068b8 100644
--- a/compiler/liblangutil/UniqueErrorReporter.h
+++ b/compiler/liblangutil/UniqueErrorReporter.h
@@ -33,6 +33,11 @@ class UniqueErrorReporter
 public:
 	UniqueErrorReporter(): m_errorReporter(m_uniqueErrors) {}
 
+	void append(UniqueErrorReporter const& _other)
+	{
+		m_errorReporter.append(_other.m_errorReporter.errors());
+	}
+
 	void warning(ErrorId _error, SourceLocation const& _location, std::string const& _description)
 	{
 		if (!seen(_error, _location, _description))
diff --git a/compiler/libsmtutil/CHCSmtLib2Interface.cpp b/compiler/libsmtutil/CHCSmtLib2Interface.cpp
index c9b5f605..ef7c56ac 100644
--- a/compiler/libsmtutil/CHCSmtLib2Interface.cpp
+++ b/compiler/libsmtutil/CHCSmtLib2Interface.cpp
@@ -31,21 +31,22 @@
 #include <memory>
 #include <stdexcept>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::frontend;
 using namespace solidity::smtutil;
 
 CHCSmtLib2Interface::CHCSmtLib2Interface(
-	map<h256, string> const& _queryResponses,
+	std::map<h256, std::string> const& _queryResponses,
 	ReadCallback::Callback _smtCallback,
-	optional<unsigned> _queryTimeout
+	SMTSolverChoice _enabledSolvers,
+	std::optional<unsigned> _queryTimeout
 ):
 	CHCSolverInterface(_queryTimeout),
-	m_smtlib2(make_unique<SMTLib2Interface>(_queryResponses, _smtCallback, m_queryTimeout)),
+	m_smtlib2(std::make_unique<SMTLib2Interface>(_queryResponses, _smtCallback, m_queryTimeout)),
 	m_queryResponses(std::move(_queryResponses)),
-	m_smtCallback(_smtCallback)
+	m_smtCallback(_smtCallback),
+	m_enabledSolvers(_enabledSolvers)
 {
 	reset();
 }
@@ -64,8 +65,8 @@ void CHCSmtLib2Interface::registerRelation(Expression const& _expr)
 	smtAssert(_expr.sort->kind == Kind::Function);
 	if (!m_variables.count(_expr.name))
 	{
-		auto fSort = dynamic_pointer_cast<FunctionSort>(_expr.sort);
-		string domain = toSmtLibSort(fSort->domain);
+		auto fSort = std::dynamic_pointer_cast<FunctionSort>(_expr.sort);
+		std::string domain = toSmtLibSort(fSort->domain);
 		// Relations are predicates which have implicit codomain Bool.
 		m_variables.insert(_expr.name);
 		write(
@@ -87,25 +88,10 @@ void CHCSmtLib2Interface::addRule(Expression const& _expr, std::string const& /*
 	);
 }
 
-tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> CHCSmtLib2Interface::query(Expression const& _block)
+std::tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> CHCSmtLib2Interface::query(Expression const& _block)
 {
-	string accumulated{};
-	swap(m_accumulatedOutput, accumulated);
-	solAssert(m_smtlib2, "");
-	writeHeader();
-	for (auto const& decl: m_smtlib2->userSorts() | ranges::views::values)
-		write(decl);
-	m_accumulatedOutput += accumulated;
-
-	string queryRule = "(assert\n(forall " + forall() + "\n" +
-		"(=> " + _block.name + " false)"
-		"))";
-	string response = querySolver(
-		m_accumulatedOutput +
-		queryRule +
-		"\n(check-sat)"
-	);
-	swap(m_accumulatedOutput, accumulated);
+	std::string query = dumpQuery(_block);
+	std::string response = querySolver(query);
 
 	CheckResult result;
 	// TODO proper parsing
@@ -121,7 +107,7 @@ tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> CHCSmtLib2Interface
 	return {result, Expression(true), {}};
 }
 
-void CHCSmtLib2Interface::declareVariable(string const& _name, SortPointer const& _sort)
+void CHCSmtLib2Interface::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort);
 	if (_sort->kind == Kind::Function)
@@ -133,32 +119,25 @@ void CHCSmtLib2Interface::declareVariable(string const& _name, SortPointer const
 	}
 }
 
-string CHCSmtLib2Interface::toSmtLibSort(Sort const& _sort)
+std::string CHCSmtLib2Interface::toSmtLibSort(Sort const& _sort)
 {
 	if (!m_sortNames.count(&_sort))
 		m_sortNames[&_sort] = m_smtlib2->toSmtLibSort(_sort);
 	return m_sortNames.at(&_sort);
 }
 
-string CHCSmtLib2Interface::toSmtLibSort(vector<SortPointer> const& _sorts)
+std::string CHCSmtLib2Interface::toSmtLibSort(std::vector<SortPointer> const& _sorts)
 {
-	string ssort("(");
+	std::string ssort("(");
 	for (auto const& sort: _sorts)
 		ssort += toSmtLibSort(*sort) + " ";
 	ssort += ")";
 	return ssort;
 }
 
-void CHCSmtLib2Interface::writeHeader()
-{
-	if (m_queryTimeout)
-		write("(set-option :timeout " + to_string(*m_queryTimeout) + ")");
-	write("(set-logic HORN)\n");
-}
-
-string CHCSmtLib2Interface::forall()
+std::string CHCSmtLib2Interface::forall()
 {
-	string vars("(");
+	std::string vars("(");
 	for (auto const& [name, sort]: m_smtlib2->variables())
 	{
 		solAssert(sort, "");
@@ -169,17 +148,17 @@ string CHCSmtLib2Interface::forall()
 	return vars;
 }
 
-void CHCSmtLib2Interface::declareFunction(string const& _name, SortPointer const& _sort)
+void CHCSmtLib2Interface::declareFunction(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort);
 	smtAssert(_sort->kind == Kind::Function);
 	// TODO Use domain and codomain as key as well
 	if (!m_variables.count(_name))
 	{
-		auto fSort = dynamic_pointer_cast<FunctionSort>(_sort);
+		auto fSort = std::dynamic_pointer_cast<FunctionSort>(_sort);
 		smtAssert(fSort->codomain);
-		string domain = toSmtLibSort(fSort->domain);
-		string codomain = toSmtLibSort(*fSort->codomain);
+		std::string domain = toSmtLibSort(fSort->domain);
+		std::string codomain = toSmtLibSort(*fSort->codomain);
 		m_variables.insert(_name);
 		write(
 			"(declare-fun |" +
@@ -193,22 +172,54 @@ void CHCSmtLib2Interface::declareFunction(string const& _name, SortPointer const
 	}
 }
 
-void CHCSmtLib2Interface::write(string _data)
+void CHCSmtLib2Interface::write(std::string _data)
 {
 	m_accumulatedOutput += std::move(_data) + "\n";
 }
 
-string CHCSmtLib2Interface::querySolver(string const& _input)
+std::string CHCSmtLib2Interface::querySolver(std::string const& _input)
 {
 	util::h256 inputHash = util::keccak256(_input);
 	if (m_queryResponses.count(inputHash))
 		return m_queryResponses.at(inputHash);
+
+	smtAssert(m_enabledSolvers.smtlib2 || m_enabledSolvers.eld);
 	if (m_smtCallback)
 	{
 		auto result = m_smtCallback(ReadCallback::kindString(ReadCallback::Kind::SMTQuery), _input);
 		if (result.success)
 			return result.responseOrErrorMessage;
 	}
+
 	m_unhandledQueries.push_back(_input);
 	return "unknown\n";
 }
+
+std::string CHCSmtLib2Interface::dumpQuery(Expression const& _expr)
+{
+	std::stringstream s;
+
+	s
+		<< createHeaderAndDeclarations()
+		<< m_accumulatedOutput << std::endl
+		<< createQueryAssertion(_expr.name) << std::endl
+		<< "(check-sat)" << std::endl;
+
+	return s.str();
+}
+
+std::string CHCSmtLib2Interface::createHeaderAndDeclarations() {
+	std::stringstream s;
+	if (m_queryTimeout)
+		s << "(set-option :timeout " + std::to_string(*m_queryTimeout) + ")\n";
+	s << "(set-logic HORN)" << std::endl;
+
+	for (auto const& decl: m_smtlib2->userSorts() | ranges::views::values)
+		s << decl << std::endl;
+
+	return s.str();
+}
+
+std::string CHCSmtLib2Interface::createQueryAssertion(std::string name) {
+	return "(assert\n(forall " + forall() + "\n" +	"(=> " + name + " false)))";
+}
diff --git a/compiler/libsmtutil/CHCSmtLib2Interface.h b/compiler/libsmtutil/CHCSmtLib2Interface.h
index a7dfb769..0f3a68ee 100644
--- a/compiler/libsmtutil/CHCSmtLib2Interface.h
+++ b/compiler/libsmtutil/CHCSmtLib2Interface.h
@@ -35,6 +35,7 @@ class CHCSmtLib2Interface: public CHCSolverInterface
 	explicit CHCSmtLib2Interface(
 		std::map<util::h256, std::string> const& _queryResponses = {},
 		frontend::ReadCallback::Callback _smtCallback = {},
+		SMTSolverChoice _enabledSolvers = SMTSolverChoice::All(),
 		std::optional<unsigned> _queryTimeout = {}
 	);
 
@@ -50,6 +51,8 @@ class CHCSmtLib2Interface: public CHCSolverInterface
 
 	void declareVariable(std::string const& _name, SortPointer const& _sort) override;
 
+	std::string dumpQuery(Expression const& _expr);
+
 	std::vector<std::string> unhandledQueries() const { return m_unhandledQueries; }
 
 	SMTLib2Interface* smtlib2Interface() const { return m_smtlib2.get(); }
@@ -65,6 +68,9 @@ class CHCSmtLib2Interface: public CHCSolverInterface
 
 	void write(std::string _data);
 
+	std::string createQueryAssertion(std::string name);
+	std::string createHeaderAndDeclarations();
+
 	/// Communicates with the solver via the callback. Throws SMTSolverError on error.
 	std::string querySolver(std::string const& _input);
 
@@ -78,6 +84,7 @@ class CHCSmtLib2Interface: public CHCSolverInterface
 	std::vector<std::string> m_unhandledQueries;
 
 	frontend::ReadCallback::Callback m_smtCallback;
+	SMTSolverChoice m_enabledSolvers;
 
 	std::map<Sort const*, std::string> m_sortNames;
 };
diff --git a/compiler/libsmtutil/CVC4Interface.cpp b/compiler/libsmtutil/CVC4Interface.cpp
index ff356c02..f53c92ab 100644
--- a/compiler/libsmtutil/CVC4Interface.cpp
+++ b/compiler/libsmtutil/CVC4Interface.cpp
@@ -23,12 +23,11 @@
 
 #include <cvc4/util/bitvector.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::smtutil;
 
-CVC4Interface::CVC4Interface(optional<unsigned> _queryTimeout):
+CVC4Interface::CVC4Interface(std::optional<unsigned> _queryTimeout):
 	SolverInterface(_queryTimeout),
 	m_solver(&m_context)
 {
@@ -56,7 +55,7 @@ void CVC4Interface::pop()
 	m_solver.pop();
 }
 
-void CVC4Interface::declareVariable(string const& _name, SortPointer const& _sort)
+void CVC4Interface::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	m_variables[_name] = m_context.mkVar(_name.c_str(), cvc4Sort(*_sort));
@@ -86,10 +85,10 @@ void CVC4Interface::addAssertion(Expression const& _expr)
 	}
 }
 
-pair<CheckResult, vector<string>> CVC4Interface::check(vector<Expression> const& _expressionsToEvaluate)
+std::pair<CheckResult, std::vector<std::string>> CVC4Interface::check(std::vector<Expression> const& _expressionsToEvaluate)
 {
 	CheckResult result;
-	vector<string> values;
+	std::vector<std::string> values;
 	try
 	{
 		switch (m_solver.checkSat().isSat())
@@ -119,7 +118,7 @@ pair<CheckResult, vector<string>> CVC4Interface::check(vector<Expression> const&
 		values.clear();
 	}
 
-	return make_pair(result, values);
+	return std::make_pair(result, values);
 }
 
 CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
@@ -128,13 +127,13 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 	if (_expr.arguments.empty() && m_variables.count(_expr.name))
 		return m_variables.at(_expr.name);
 
-	vector<CVC4::Expr> arguments;
+	std::vector<CVC4::Expr> arguments;
 	for (auto const& arg: _expr.arguments)
 		arguments.push_back(toCVC4Expr(arg));
 
 	try
 	{
-		string const& n = _expr.name;
+		std::string const& n = _expr.name;
 		// Function application
 		if (!arguments.empty() && m_variables.count(_expr.name))
 			return m_context.mkExpr(CVC4::kind::APPLY_UF, m_variables.at(n), arguments);
@@ -145,7 +144,7 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 				return m_context.mkConst(true);
 			else if (n == "false")
 				return m_context.mkConst(false);
-			else if (auto sortSort = dynamic_pointer_cast<SortSort>(_expr.sort))
+			else if (auto sortSort = std::dynamic_pointer_cast<SortSort>(_expr.sort))
 				return m_context.mkVar(n, cvc4Sort(*sortSort->inner));
 			else
 				try
@@ -224,7 +223,7 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 		}
 		else if (n == "bv2int")
 		{
-			auto intSort = dynamic_pointer_cast<IntSort>(_expr.sort);
+			auto intSort = std::dynamic_pointer_cast<IntSort>(_expr.sort);
 			smtAssert(intSort, "");
 			auto nat = m_context.mkExpr(CVC4::kind::BITVECTOR_TO_NAT, arguments[0]);
 			if (!intSort->isSigned)
@@ -239,7 +238,7 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 				m_context.mkExpr(
 					CVC4::kind::EQUAL,
 					m_context.mkExpr(CVC4::kind::BITVECTOR_EXTRACT, extractOp, arguments[0]),
-					m_context.mkConst(CVC4::BitVector(1, size_t(0)))
+					m_context.mkConst(CVC4::BitVector(1, uint64_t{0}))
 				),
 				nat,
 				m_context.mkExpr(
@@ -254,13 +253,13 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 			return m_context.mkExpr(CVC4::kind::STORE, arguments[0], arguments[1], arguments[2]);
 		else if (n == "const_array")
 		{
-			shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
+			std::shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
 			smtAssert(sortSort, "");
 			return m_context.mkConst(CVC4::ArrayStoreAll(cvc4Sort(*sortSort->inner), arguments[1]));
 		}
 		else if (n == "tuple_get")
 		{
-			shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.arguments[0].sort);
+			std::shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.arguments[0].sort);
 			smtAssert(tupleSort, "");
 			CVC4::DatatypeType tt = m_context.mkTupleType(cvc4Sort(tupleSort->components));
 			CVC4::Datatype const& dt = tt.getDatatype();
@@ -270,7 +269,7 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 		}
 		else if (n == "tuple_constructor")
 		{
-			shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.sort);
+			std::shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.sort);
 			smtAssert(tupleSort, "");
 			CVC4::DatatypeType tt = m_context.mkTupleType(cvc4Sort(tupleSort->components));
 			CVC4::Datatype const& dt = tt.getDatatype();
@@ -328,9 +327,9 @@ CVC4::Type CVC4Interface::cvc4Sort(Sort const& _sort)
 	return m_context.integerType();
 }
 
-vector<CVC4::Type> CVC4Interface::cvc4Sort(vector<SortPointer> const& _sorts)
+std::vector<CVC4::Type> CVC4Interface::cvc4Sort(std::vector<SortPointer> const& _sorts)
 {
-	vector<CVC4::Type> cvc4Sorts;
+	std::vector<CVC4::Type> cvc4Sorts;
 	for (auto const& _sort: _sorts)
 		cvc4Sorts.push_back(cvc4Sort(*_sort));
 	return cvc4Sorts;
diff --git a/compiler/libsmtutil/SMTLib2Interface.cpp b/compiler/libsmtutil/SMTLib2Interface.cpp
index 3e117913..ac5645bf 100644
--- a/compiler/libsmtutil/SMTLib2Interface.cpp
+++ b/compiler/libsmtutil/SMTLib2Interface.cpp
@@ -33,16 +33,15 @@
 #include <string>
 #include <utility>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::frontend;
 using namespace solidity::smtutil;
 
 SMTLib2Interface::SMTLib2Interface(
-	map<h256, string> _queryResponses,
+	std::map<h256, std::string> _queryResponses,
 	ReadCallback::Callback _smtCallback,
-	optional<unsigned> _queryTimeout
+	std::optional<unsigned> _queryTimeout
 ):
 	SolverInterface(_queryTimeout),
 	m_queryResponses(std::move(_queryResponses)),
@@ -59,7 +58,7 @@ void SMTLib2Interface::reset()
 	m_userSorts.clear();
 	write("(set-option :produce-models true)");
 	if (m_queryTimeout)
-		write("(set-option :timeout " + to_string(*m_queryTimeout) + ")");
+		write("(set-option :timeout " + std::to_string(*m_queryTimeout) + ")");
 	write("(set-logic ALL)");
 }
 
@@ -74,7 +73,7 @@ void SMTLib2Interface::pop()
 	m_accumulatedOutput.pop_back();
 }
 
-void SMTLib2Interface::declareVariable(string const& _name, SortPointer const& _sort)
+void SMTLib2Interface::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	if (_sort->kind == Kind::Function)
@@ -86,16 +85,16 @@ void SMTLib2Interface::declareVariable(string const& _name, SortPointer const& _
 	}
 }
 
-void SMTLib2Interface::declareFunction(string const& _name, SortPointer const& _sort)
+void SMTLib2Interface::declareFunction(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	smtAssert(_sort->kind == Kind::Function, "");
 	// TODO Use domain and codomain as key as well
 	if (!m_variables.count(_name))
 	{
-		auto const& fSort = dynamic_pointer_cast<FunctionSort>(_sort);
-		string domain = toSmtLibSort(fSort->domain);
-		string codomain = toSmtLibSort(*fSort->codomain);
+		auto const& fSort = std::dynamic_pointer_cast<FunctionSort>(_sort);
+		std::string domain = toSmtLibSort(fSort->domain);
+		std::string codomain = toSmtLibSort(*fSort->codomain);
 		m_variables.emplace(_name, _sort);
 		write(
 			"(declare-fun |" +
@@ -114,9 +113,9 @@ void SMTLib2Interface::addAssertion(Expression const& _expr)
 	write("(assert " + toSExpr(_expr) + ")");
 }
 
-pair<CheckResult, vector<string>> SMTLib2Interface::check(vector<Expression> const& _expressionsToEvaluate)
+std::pair<CheckResult, std::vector<std::string>> SMTLib2Interface::check(std::vector<Expression> const& _expressionsToEvaluate)
 {
-	string response = querySolver(
+	std::string response = querySolver(
 		boost::algorithm::join(m_accumulatedOutput, "\n") +
 		checkSatAndGetValuesCommand(_expressionsToEvaluate)
 	);
@@ -132,13 +131,13 @@ pair<CheckResult, vector<string>> SMTLib2Interface::check(vector<Expression> con
 	else
 		result = CheckResult::ERROR;
 
-	vector<string> values;
+	std::vector<std::string> values;
 	if (result == CheckResult::SATISFIABLE && !_expressionsToEvaluate.empty())
 		values = parseValues(find(response.cbegin(), response.cend(), '\n'), response.cend());
-	return make_pair(result, values);
+	return std::make_pair(result, values);
 }
 
-string SMTLib2Interface::toSExpr(Expression const& _expr)
+std::string SMTLib2Interface::toSExpr(Expression const& _expr)
 {
 	if (_expr.arguments.empty())
 		return _expr.name;
@@ -148,16 +147,16 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 	{
 		size_t size = std::stoul(_expr.arguments[1].name);
 		auto arg = toSExpr(_expr.arguments.front());
-		auto int2bv = "(_ int2bv " + to_string(size) + ")";
+		auto int2bv = "(_ int2bv " + std::to_string(size) + ")";
 		// Some solvers treat all BVs as unsigned, so we need to manually apply 2's complement if needed.
-		sexpr += string("ite ") +
+		sexpr += std::string("ite ") +
 			"(>= " + arg + " 0) " +
 			"(" + int2bv + " " + arg + ") " +
 			"(bvneg (" + int2bv + " (- " + arg + ")))";
 	}
 	else if (_expr.name == "bv2int")
 	{
-		auto intSort = dynamic_pointer_cast<IntSort>(_expr.sort);
+		auto intSort = std::dynamic_pointer_cast<IntSort>(_expr.sort);
 		smtAssert(intSort, "");
 
 		auto arg = toSExpr(_expr.arguments.front());
@@ -166,13 +165,13 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 		if (!intSort->isSigned)
 			return nat;
 
-		auto bvSort = dynamic_pointer_cast<BitVectorSort>(_expr.arguments.front().sort);
+		auto bvSort = std::dynamic_pointer_cast<BitVectorSort>(_expr.arguments.front().sort);
 		smtAssert(bvSort, "");
-		auto size = to_string(bvSort->size);
-		auto pos = to_string(bvSort->size - 1);
+		auto size = std::to_string(bvSort->size);
+		auto pos = std::to_string(bvSort->size - 1);
 
 		// Some solvers treat all BVs as unsigned, so we need to manually apply 2's complement if needed.
-		sexpr += string("ite ") +
+		sexpr += std::string("ite ") +
 			"(= ((_ extract " + pos + " " + pos + ")" + arg + ") #b0) " +
 			nat + " " +
 			"(- (bv2nat (bvneg " + arg + ")))";
@@ -182,7 +181,7 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 		smtAssert(_expr.arguments.size() == 2, "");
 		auto sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments.at(0).sort);
 		smtAssert(sortSort, "");
-		auto arraySort = dynamic_pointer_cast<ArraySort>(sortSort->inner);
+		auto arraySort = std::dynamic_pointer_cast<ArraySort>(sortSort->inner);
 		smtAssert(arraySort, "");
 		sexpr += "(as const " + toSmtLibSort(*arraySort) + ") ";
 		sexpr += toSExpr(_expr.arguments.at(1));
@@ -190,14 +189,14 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 	else if (_expr.name == "tuple_get")
 	{
 		smtAssert(_expr.arguments.size() == 2, "");
-		auto tupleSort = dynamic_pointer_cast<TupleSort>(_expr.arguments.at(0).sort);
+		auto tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.arguments.at(0).sort);
 		size_t index = std::stoul(_expr.arguments.at(1).name);
 		smtAssert(index < tupleSort->members.size(), "");
 		sexpr += "|" + tupleSort->members.at(index) + "| " + toSExpr(_expr.arguments.at(0));
 	}
 	else if (_expr.name == "tuple_constructor")
 	{
-		auto tupleSort = dynamic_pointer_cast<TupleSort>(_expr.sort);
+		auto tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.sort);
 		smtAssert(tupleSort, "");
 		sexpr += "|" + tupleSort->name + "|";
 		for (auto const& arg: _expr.arguments)
@@ -213,7 +212,7 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 	return sexpr;
 }
 
-string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
+std::string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 {
 	switch (_sort.kind)
 	{
@@ -222,7 +221,7 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 	case Kind::Bool:
 		return "Bool";
 	case Kind::BitVector:
-		return "(_ BitVec " + to_string(dynamic_cast<BitVectorSort const&>(_sort).size) + ")";
+		return "(_ BitVec " + std::to_string(dynamic_cast<BitVectorSort const&>(_sort).size) + ")";
 	case Kind::Array:
 	{
 		auto const& arraySort = dynamic_cast<ArraySort const&>(_sort);
@@ -232,11 +231,11 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 	case Kind::Tuple:
 	{
 		auto const& tupleSort = dynamic_cast<TupleSort const&>(_sort);
-		string tupleName = "|" + tupleSort.name + "|";
+		std::string tupleName = "|" + tupleSort.name + "|";
 		auto isName = [&](auto entry) { return entry.first == tupleName; };
 		if (ranges::find_if(m_userSorts, isName) == m_userSorts.end())
 		{
-			string decl("(declare-datatypes ((" + tupleName + " 0)) (((" + tupleName);
+			std::string decl("(declare-datatypes ((" + tupleName + " 0)) (((" + tupleName);
 			smtAssert(tupleSort.members.size() == tupleSort.components.size(), "");
 			for (unsigned i = 0; i < tupleSort.members.size(); ++i)
 				decl += " (|" + tupleSort.members.at(i) + "| " + toSmtLibSort(*tupleSort.components.at(i)) + ")";
@@ -252,24 +251,24 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 	}
 }
 
-string SMTLib2Interface::toSmtLibSort(vector<SortPointer> const& _sorts)
+std::string SMTLib2Interface::toSmtLibSort(std::vector<SortPointer> const& _sorts)
 {
-	string ssort("(");
+	std::string ssort("(");
 	for (auto const& sort: _sorts)
 		ssort += toSmtLibSort(*sort) + " ";
 	ssort += ")";
 	return ssort;
 }
 
-void SMTLib2Interface::write(string _data)
+void SMTLib2Interface::write(std::string _data)
 {
 	smtAssert(!m_accumulatedOutput.empty(), "");
 	m_accumulatedOutput.back() += std::move(_data) + "\n";
 }
 
-string SMTLib2Interface::checkSatAndGetValuesCommand(vector<Expression> const& _expressionsToEvaluate)
+std::string SMTLib2Interface::checkSatAndGetValuesCommand(std::vector<Expression> const& _expressionsToEvaluate)
 {
-	string command;
+	std::string command;
 	if (_expressionsToEvaluate.empty())
 		command = "(check-sat)\n";
 	else
@@ -279,22 +278,22 @@ string SMTLib2Interface::checkSatAndGetValuesCommand(vector<Expression> const& _
 		{
 			auto const& e = _expressionsToEvaluate.at(i);
 			smtAssert(e.sort->kind == Kind::Int || e.sort->kind == Kind::Bool, "Invalid sort for expression to evaluate.");
-			command += "(declare-const |EVALEXPR_" + to_string(i) + "| " + (e.sort->kind == Kind::Int ? "Int" : "Bool") + ")\n";
-			command += "(assert (= |EVALEXPR_" + to_string(i) + "| " + toSExpr(e) + "))\n";
+			command += "(declare-const |EVALEXPR_" + std::to_string(i) + "| " + (e.sort->kind == Kind::Int ? "Int" : "Bool") + ")\n";
+			command += "(assert (= |EVALEXPR_" + std::to_string(i) + "| " + toSExpr(e) + "))\n";
 		}
 		command += "(check-sat)\n";
 		command += "(get-value (";
 		for (size_t i = 0; i < _expressionsToEvaluate.size(); i++)
-			command += "|EVALEXPR_" + to_string(i) + "| ";
+			command += "|EVALEXPR_" + std::to_string(i) + "| ";
 		command += "))\n";
 	}
 
 	return command;
 }
 
-vector<string> SMTLib2Interface::parseValues(string::const_iterator _start, string::const_iterator _end)
+std::vector<std::string> SMTLib2Interface::parseValues(std::string::const_iterator _start, std::string::const_iterator _end)
 {
-	vector<string> values;
+	std::vector<std::string> values;
 	while (_start < _end)
 	{
 		auto valStart = find(_start, _end, ' ');
@@ -308,7 +307,7 @@ vector<string> SMTLib2Interface::parseValues(string::const_iterator _start, stri
 	return values;
 }
 
-string SMTLib2Interface::querySolver(string const& _input)
+std::string SMTLib2Interface::querySolver(std::string const& _input)
 {
 	h256 inputHash = keccak256(_input);
 	if (m_queryResponses.count(inputHash))
@@ -322,3 +321,9 @@ string SMTLib2Interface::querySolver(string const& _input)
 	m_unhandledQueries.push_back(_input);
 	return "unknown\n";
 }
+
+std::string SMTLib2Interface::dumpQuery(std::vector<Expression> const& _expressionsToEvaluate)
+{
+	return boost::algorithm::join(m_accumulatedOutput, "\n") +
+		checkSatAndGetValuesCommand(_expressionsToEvaluate);
+}
diff --git a/compiler/libsmtutil/SMTLib2Interface.h b/compiler/libsmtutil/SMTLib2Interface.h
index 9454d551..9ef8e94a 100644
--- a/compiler/libsmtutil/SMTLib2Interface.h
+++ b/compiler/libsmtutil/SMTLib2Interface.h
@@ -68,6 +68,8 @@ class SMTLib2Interface: public SolverInterface
 
 	std::vector<std::pair<std::string, std::string>> const& userSorts() const { return m_userSorts; }
 
+	std::string dumpQuery(std::vector<Expression> const& _expressionsToEvaluate);
+
 private:
 	void declareFunction(std::string const& _name, SortPointer const& _sort);
 
diff --git a/compiler/libsmtutil/SMTPortfolio.cpp b/compiler/libsmtutil/SMTPortfolio.cpp
index 77a404a4..76c69d01 100644
--- a/compiler/libsmtutil/SMTPortfolio.cpp
+++ b/compiler/libsmtutil/SMTPortfolio.cpp
@@ -26,29 +26,30 @@
 #endif
 #include <libsmtutil/SMTLib2Interface.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::frontend;
 using namespace solidity::smtutil;
 
 SMTPortfolio::SMTPortfolio(
-	map<h256, string> _smtlib2Responses,
+	std::map<h256, std::string> _smtlib2Responses,
 	frontend::ReadCallback::Callback _smtCallback,
 	[[maybe_unused]] SMTSolverChoice _enabledSolvers,
-	optional<unsigned> _queryTimeout
+	std::optional<unsigned> _queryTimeout,
+	bool _printQuery
 ):
 	SolverInterface(_queryTimeout)
 {
+	solAssert(!_printQuery || _enabledSolvers == smtutil::SMTSolverChoice::SMTLIB2(), "Only SMTLib2 solver can be enabled to print queries");
 	if (_enabledSolvers.smtlib2)
-		m_solvers.emplace_back(make_unique<SMTLib2Interface>(std::move(_smtlib2Responses), std::move(_smtCallback), m_queryTimeout));
+		m_solvers.emplace_back(std::make_unique<SMTLib2Interface>(std::move(_smtlib2Responses), std::move(_smtCallback), m_queryTimeout));
 #ifdef HAVE_Z3
 	if (_enabledSolvers.z3 && Z3Interface::available())
-		m_solvers.emplace_back(make_unique<Z3Interface>(m_queryTimeout));
+		m_solvers.emplace_back(std::make_unique<Z3Interface>(m_queryTimeout));
 #endif
 #ifdef HAVE_CVC4
 	if (_enabledSolvers.cvc4)
-		m_solvers.emplace_back(make_unique<CVC4Interface>(m_queryTimeout));
+		m_solvers.emplace_back(std::make_unique<CVC4Interface>(m_queryTimeout));
 #endif
 }
 
@@ -70,7 +71,7 @@ void SMTPortfolio::pop()
 		s->pop();
 }
 
-void SMTPortfolio::declareVariable(string const& _name, SortPointer const& _sort)
+void SMTPortfolio::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	for (auto const& s: m_solvers)
@@ -113,14 +114,14 @@ void SMTPortfolio::addAssertion(Expression const& _expr)
  *
  *   If all solvers return ERROR, the result is ERROR.
 */
-pair<CheckResult, vector<string>> SMTPortfolio::check(vector<Expression> const& _expressionsToEvaluate)
+std::pair<CheckResult, std::vector<std::string>> SMTPortfolio::check(std::vector<Expression> const& _expressionsToEvaluate)
 {
 	CheckResult lastResult = CheckResult::ERROR;
-	vector<string> finalValues;
+	std::vector<std::string> finalValues;
 	for (auto const& s: m_solvers)
 	{
 		CheckResult result;
-		vector<string> values;
+		std::vector<std::string> values;
 		tie(result, values) = s->check(_expressionsToEvaluate);
 		if (solverAnswered(result))
 		{
@@ -138,10 +139,10 @@ pair<CheckResult, vector<string>> SMTPortfolio::check(vector<Expression> const&
 		else if (result == CheckResult::UNKNOWN && lastResult == CheckResult::ERROR)
 			lastResult = result;
 	}
-	return make_pair(lastResult, finalValues);
+	return std::make_pair(lastResult, finalValues);
 }
 
-vector<string> SMTPortfolio::unhandledQueries()
+std::vector<std::string> SMTPortfolio::unhandledQueries()
 {
 	// This code assumes that the constructor guarantees that
 	// SmtLib2Interface is in position 0, if enabled.
@@ -155,3 +156,12 @@ bool SMTPortfolio::solverAnswered(CheckResult result)
 {
 	return result == CheckResult::SATISFIABLE || result == CheckResult::UNSATISFIABLE;
 }
+
+std::string SMTPortfolio::dumpQuery(std::vector<Expression> const& _expressionsToEvaluate)
+{
+	// This code assumes that the constructor guarantees that
+	// SmtLib2Interface is in position 0, if enabled.
+	auto smtlib2 = dynamic_cast<SMTLib2Interface*>(m_solvers.front().get());
+	solAssert(smtlib2, "Must use SMTLib2 solver to dump queries");
+	return smtlib2->dumpQuery(_expressionsToEvaluate);
+}
diff --git a/compiler/libsmtutil/SMTPortfolio.h b/compiler/libsmtutil/SMTPortfolio.h
index 3d82756c..cdb33368 100644
--- a/compiler/libsmtutil/SMTPortfolio.h
+++ b/compiler/libsmtutil/SMTPortfolio.h
@@ -46,7 +46,8 @@ class SMTPortfolio: public SolverInterface
 		std::map<util::h256, std::string> _smtlib2Responses = {},
 		frontend::ReadCallback::Callback _smtCallback = {},
 		SMTSolverChoice _enabledSolvers = SMTSolverChoice::All(),
-		std::optional<unsigned> _queryTimeout = {}
+		std::optional<unsigned> _queryTimeout = {},
+		bool _printQuery = false
 	);
 
 	void reset() override;
@@ -62,6 +63,9 @@ class SMTPortfolio: public SolverInterface
 
 	std::vector<std::string> unhandledQueries() override;
 	size_t solvers() override { return m_solvers.size(); }
+
+	std::string dumpQuery(std::vector<Expression> const& _expressionsToEvaluate);
+
 private:
 	static bool solverAnswered(CheckResult result);
 
diff --git a/compiler/libsmtutil/SolverInterface.h b/compiler/libsmtutil/SolverInterface.h
index ca4c497d..4a21f184 100644
--- a/compiler/libsmtutil/SolverInterface.h
+++ b/compiler/libsmtutil/SolverInterface.h
@@ -42,28 +42,23 @@ namespace solidity::smtutil
 struct SMTSolverChoice
 {
 	bool cvc4 = false;
+	bool eld = false;
 	bool smtlib2 = false;
 	bool z3 = false;
 
-	static constexpr SMTSolverChoice All() noexcept { return {true, true, true}; }
-	static constexpr SMTSolverChoice CVC4() noexcept { return {true, false, false}; }
-	static constexpr SMTSolverChoice SMTLIB2() noexcept { return {false, true, false}; }
-	static constexpr SMTSolverChoice Z3() noexcept { return {false, false, true}; }
-	static constexpr SMTSolverChoice None() noexcept { return {false, false, false}; }
+	static constexpr SMTSolverChoice All() noexcept { return {true, true, true, true}; }
+	static constexpr SMTSolverChoice CVC4() noexcept { return {true, false, false, false}; }
+	static constexpr SMTSolverChoice ELD() noexcept { return {false, true, false, false}; }
+	static constexpr SMTSolverChoice SMTLIB2() noexcept { return {false, false, true, false}; }
+	static constexpr SMTSolverChoice Z3() noexcept { return {false, false, false, true}; }
+	static constexpr SMTSolverChoice None() noexcept { return {false, false, false, false}; }
 
 	static std::optional<SMTSolverChoice> fromString(std::string const& _solvers)
 	{
 		SMTSolverChoice solvers;
-		if (_solvers == "all")
-		{
-			smtAssert(solvers.setSolver("cvc4"), "");
-			smtAssert(solvers.setSolver("smtlib2"), "");
-			smtAssert(solvers.setSolver("z3"), "");
-		}
-		else
-			for (auto&& s: _solvers | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
-				if (!solvers.setSolver(s))
-					return {};
+		for (auto&& s: _solvers | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
+			if (!solvers.setSolver(s))
+				return {};
 
 		return solvers;
 	}
@@ -71,6 +66,7 @@ struct SMTSolverChoice
 	SMTSolverChoice& operator&=(SMTSolverChoice const& _other)
 	{
 		cvc4 &= _other.cvc4;
+		eld &= _other.eld;
 		smtlib2 &= _other.smtlib2;
 		z3 &= _other.z3;
 		return *this;
@@ -87,17 +83,20 @@ struct SMTSolverChoice
 	bool operator==(SMTSolverChoice const& _other) const noexcept
 	{
 		return cvc4 == _other.cvc4 &&
+			eld == _other.eld &&
 			smtlib2 == _other.smtlib2 &&
 			z3 == _other.z3;
 	}
 
 	bool setSolver(std::string const& _solver)
 	{
-		static std::set<std::string> const solvers{"cvc4", "smtlib2", "z3"};
+		static std::set<std::string> const solvers{"cvc4", "eld", "smtlib2", "z3"};
 		if (!solvers.count(_solver))
 			return false;
 		if (_solver == "cvc4")
 			cvc4 = true;
+		if (_solver == "eld")
+			eld = true;
 		else if (_solver == "smtlib2")
 			smtlib2 = true;
 		else if (_solver == "z3")
@@ -106,8 +105,8 @@ struct SMTSolverChoice
 	}
 
 	bool none() const noexcept { return !some(); }
-	bool some() const noexcept { return cvc4 || smtlib2 || z3; }
-	bool all() const noexcept { return cvc4 && smtlib2 && z3; }
+	bool some() const noexcept { return cvc4 || eld || smtlib2 || z3; }
+	bool all() const noexcept { return cvc4 && eld && smtlib2 && z3; }
 };
 
 enum class CheckResult
@@ -124,7 +123,7 @@ class Expression
 	explicit Expression(std::shared_ptr<SortSort> _sort, std::string _name = ""): Expression(std::move(_name), {}, _sort) {}
 	explicit Expression(std::string _name, std::vector<Expression> _arguments, SortPointer _sort):
 		name(std::move(_name)), arguments(std::move(_arguments)), sort(std::move(_sort)) {}
-	Expression(size_t _number): Expression(std::to_string(_number), {}, SortProvider::sintSort) {}
+	Expression(size_t _number): Expression(std::to_string(_number), {}, SortProvider::uintSort) {}
 	Expression(u256 const& _number): Expression(_number.str(), {}, SortProvider::sintSort) {}
 	Expression(s256 const& _number): Expression(
 		_number >= 0 ? _number.str() : "-",
@@ -190,7 +189,10 @@ class Expression
 
 	static Expression ite(Expression _condition, Expression _trueValue, Expression _falseValue)
 	{
-		smtAssert(*_trueValue.sort == *_falseValue.sort, "");
+		if (_trueValue.sort->kind == Kind::Int)
+			smtAssert(_trueValue.sort->kind == _falseValue.sort->kind, "");
+		else
+			smtAssert(*_trueValue.sort == *_falseValue.sort, "");
 		SortPointer sort = _trueValue.sort;
 		return Expression("ite", std::vector<Expression>{
 			std::move(_condition), std::move(_trueValue), std::move(_falseValue)
@@ -214,7 +216,10 @@ class Expression
 		std::shared_ptr<ArraySort> arraySort = std::dynamic_pointer_cast<ArraySort>(_array.sort);
 		smtAssert(arraySort, "");
 		smtAssert(_index.sort, "");
-		smtAssert(*arraySort->domain == *_index.sort, "");
+		if (arraySort->domain->kind == Kind::Int)
+			smtAssert(arraySort->domain->kind == _index.sort->kind, "");
+		else
+			smtAssert(*arraySort->domain == *_index.sort, "");
 		return Expression(
 			"select",
 			std::vector<Expression>{std::move(_array), std::move(_index)},
@@ -231,7 +236,10 @@ class Expression
 		smtAssert(_index.sort, "");
 		smtAssert(_element.sort, "");
 		smtAssert(*arraySort->domain == *_index.sort, "");
-		smtAssert(*arraySort->range == *_element.sort, "");
+		if (arraySort->domain->kind == Kind::Int)
+			smtAssert(arraySort->range->kind == _element.sort->kind, "");
+		else
+			smtAssert(*arraySort->range == *_element.sort, "");
 		return Expression(
 			"store",
 			std::vector<Expression>{std::move(_array), std::move(_index), std::move(_element)},
@@ -246,7 +254,10 @@ class Expression
 		auto arraySort = std::dynamic_pointer_cast<ArraySort>(sortSort->inner);
 		smtAssert(sortSort && arraySort, "");
 		smtAssert(_value.sort, "");
-		smtAssert(*arraySort->range == *_value.sort, "");
+		if (arraySort->domain->kind == Kind::Int)
+			smtAssert(arraySort->range->kind == _value.sort->kind, "");
+		else
+			smtAssert(*arraySort->range == *_value.sort, "");
 		return Expression(
 			"const_array",
 			std::vector<Expression>{std::move(_sort), std::move(_value)},
diff --git a/compiler/libsmtutil/Sorts.cpp b/compiler/libsmtutil/Sorts.cpp
index 543c7ba0..b45bb303 100644
--- a/compiler/libsmtutil/Sorts.cpp
+++ b/compiler/libsmtutil/Sorts.cpp
@@ -19,22 +19,20 @@
 
 #include <libsmtutil/Sorts.h>
 
-using namespace std;
-
 namespace solidity::smtutil
 {
 
-shared_ptr<Sort> const SortProvider::boolSort{make_shared<Sort>(Kind::Bool)};
-shared_ptr<IntSort> const SortProvider::uintSort{make_shared<IntSort>(false)};
-shared_ptr<IntSort> const SortProvider::sintSort{make_shared<IntSort>(true)};
+std::shared_ptr<Sort> const SortProvider::boolSort{std::make_shared<Sort>(Kind::Bool)};
+std::shared_ptr<IntSort> const SortProvider::uintSort{std::make_shared<IntSort>(false)};
+std::shared_ptr<IntSort> const SortProvider::sintSort{std::make_shared<IntSort>(true)};
 
-shared_ptr<IntSort> SortProvider::intSort(bool _signed)
+std::shared_ptr<IntSort> SortProvider::intSort(bool _signed)
 {
 	if (_signed)
 		return sintSort;
 	return uintSort;
 }
 
-shared_ptr<BitVectorSort> const SortProvider::bitVectorSort{make_shared<BitVectorSort>(256)};
+std::shared_ptr<BitVectorSort> const SortProvider::bitVectorSort{std::make_shared<BitVectorSort>(256)};
 
 }
diff --git a/compiler/libsmtutil/Sorts.h b/compiler/libsmtutil/Sorts.h
index 107dc1f2..419ee9dc 100644
--- a/compiler/libsmtutil/Sorts.h
+++ b/compiler/libsmtutil/Sorts.h
@@ -57,9 +57,14 @@ struct IntSort: public Sort
 		isSigned(_signed)
 	{}
 
-	bool operator==(IntSort const& _other) const
+	bool operator==(Sort const& _other) const override
 	{
-		return Sort::operator==(_other) && isSigned == _other.isSigned;
+		if (!Sort::operator==(_other))
+			return false;
+
+		auto otherIntSort = dynamic_cast<IntSort const*>(&_other);
+		smtAssert(otherIntSort);
+		return isSigned == otherIntSort->isSigned;
 	}
 
 	bool isSigned;
@@ -72,9 +77,14 @@ struct BitVectorSort: public Sort
 		size(_size)
 	{}
 
-	bool operator==(BitVectorSort const& _other) const
+	bool operator==(Sort const& _other) const override
 	{
-		return Sort::operator==(_other) && size == _other.size;
+		if (!Sort::operator==(_other))
+			return false;
+
+		auto otherBitVectorSort = dynamic_cast<BitVectorSort const*>(&_other);
+		smtAssert(otherBitVectorSort);
+		return size == otherBitVectorSort->size;
 	}
 
 	unsigned size;
diff --git a/compiler/libsmtutil/Z3CHCInterface.cpp b/compiler/libsmtutil/Z3CHCInterface.cpp
index bfbc9841..a25890e8 100644
--- a/compiler/libsmtutil/Z3CHCInterface.cpp
+++ b/compiler/libsmtutil/Z3CHCInterface.cpp
@@ -23,21 +23,20 @@
 #include <set>
 #include <stack>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::smtutil;
 
-Z3CHCInterface::Z3CHCInterface(optional<unsigned> _queryTimeout):
+Z3CHCInterface::Z3CHCInterface(std::optional<unsigned> _queryTimeout):
 	CHCSolverInterface(_queryTimeout),
-	m_z3Interface(make_unique<Z3Interface>(m_queryTimeout)),
+	m_z3Interface(std::make_unique<Z3Interface>(m_queryTimeout)),
 	m_context(m_z3Interface->context()),
 	m_solver(*m_context)
 {
 	Z3_get_version(
-		&get<0>(m_version),
-		&get<1>(m_version),
-		&get<2>(m_version),
-		&get<3>(m_version)
+		&std::get<0>(m_version),
+		&std::get<1>(m_version),
+		&std::get<2>(m_version),
+		&std::get<3>(m_version)
 	);
 
 	// These need to be set globally.
@@ -51,7 +50,7 @@ Z3CHCInterface::Z3CHCInterface(optional<unsigned> _queryTimeout):
 	setSpacerOptions();
 }
 
-void Z3CHCInterface::declareVariable(string const& _name, SortPointer const& _sort)
+void Z3CHCInterface::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	m_z3Interface->declareVariable(_name, _sort);
@@ -62,7 +61,7 @@ void Z3CHCInterface::registerRelation(Expression const& _expr)
 	m_solver.register_relation(m_z3Interface->functions().at(_expr.name));
 }
 
-void Z3CHCInterface::addRule(Expression const& _expr, string const& _name)
+void Z3CHCInterface::addRule(Expression const& _expr, std::string const& _name)
 {
 	z3::expr rule = m_z3Interface->toZ3Expr(_expr);
 	if (m_z3Interface->constants().empty())
@@ -77,7 +76,7 @@ void Z3CHCInterface::addRule(Expression const& _expr, string const& _name)
 	}
 }
 
-tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> Z3CHCInterface::query(Expression const& _expr)
+std::tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> Z3CHCInterface::query(Expression const& _expr)
 {
 	CheckResult result;
 	try
@@ -90,7 +89,7 @@ tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> Z3CHCInterface::que
 			result = CheckResult::SATISFIABLE;
 			// z3 version 4.8.8 modified Spacer to also return
 			// proofs containing nonlinear clauses.
-			if (m_version >= tuple(4, 8, 8, 0))
+			if (m_version >= std::tuple(4, 8, 8, 0))
 			{
 				auto proof = m_solver.get_answer();
 				return {result, Expression(true), cexGraph(proof)};
@@ -113,7 +112,7 @@ tuple<CheckResult, Expression, CHCSolverInterface::CexGraph> Z3CHCInterface::que
 	}
 	catch (z3::exception const& _err)
 	{
-		set<string> msgs{
+		std::set<std::string> msgs{
 			/// Resource limit (rlimit) exhausted.
 			"max. resource limit exceeded",
 			/// User given timeout exhausted.
@@ -178,13 +177,13 @@ CHCSolverInterface::CexGraph Z3CHCInterface::cexGraph(z3::expr const& _proof)
 
 	CexGraph graph;
 
-	stack<z3::expr> proofStack;
+	std::stack<z3::expr> proofStack;
 	proofStack.push(_proof.arg(0));
 
 	auto const& root = proofStack.top();
 	graph.nodes.emplace(root.id(), m_z3Interface->fromZ3Expr(fact(root)));
 
-	set<unsigned> visited;
+	std::set<unsigned> visited;
 	visited.insert(root.id());
 
 	while (!proofStack.empty())
@@ -227,16 +226,16 @@ z3::expr Z3CHCInterface::fact(z3::expr const& _node)
 	return _node.arg(_node.num_args() - 1);
 }
 
-string Z3CHCInterface::name(z3::expr const& _predicate)
+std::string Z3CHCInterface::name(z3::expr const& _predicate)
 {
 	smtAssert(_predicate.is_app(), "");
 	return _predicate.decl().name().str();
 }
 
-vector<string> Z3CHCInterface::arguments(z3::expr const& _predicate)
+std::vector<std::string> Z3CHCInterface::arguments(z3::expr const& _predicate)
 {
 	smtAssert(_predicate.is_app(), "");
-	vector<string> args;
+	std::vector<std::string> args;
 	for (unsigned i = 0; i < _predicate.num_args(); ++i)
 		args.emplace_back(_predicate.arg(i).to_string());
 	return args;
diff --git a/compiler/libsmtutil/Z3Interface.cpp b/compiler/libsmtutil/Z3Interface.cpp
index 4abeffa1..a16e7566 100644
--- a/compiler/libsmtutil/Z3Interface.cpp
+++ b/compiler/libsmtutil/Z3Interface.cpp
@@ -26,7 +26,6 @@
 #include <libsmtutil/Z3Loader.h>
 #endif
 
-using namespace std;
 using namespace solidity::smtutil;
 using namespace solidity::util;
 
@@ -69,7 +68,7 @@ void Z3Interface::pop()
 	m_solver.pop();
 }
 
-void Z3Interface::declareVariable(string const& _name, SortPointer const& _sort)
+void Z3Interface::declareVariable(std::string const& _name, SortPointer const& _sort)
 {
 	smtAssert(_sort, "");
 	if (_sort->kind == Kind::Function)
@@ -80,7 +79,7 @@ void Z3Interface::declareVariable(string const& _name, SortPointer const& _sort)
 		m_constants.emplace(_name, m_context.constant(_name.c_str(), z3Sort(*_sort)));
 }
 
-void Z3Interface::declareFunction(string const& _name, Sort const& _sort)
+void Z3Interface::declareFunction(std::string const& _name, Sort const& _sort)
 {
 	smtAssert(_sort.kind == Kind::Function, "");
 	FunctionSort fSort = dynamic_cast<FunctionSort const&>(_sort);
@@ -95,10 +94,10 @@ void Z3Interface::addAssertion(Expression const& _expr)
 	m_solver.add(toZ3Expr(_expr));
 }
 
-pair<CheckResult, vector<string>> Z3Interface::check(vector<Expression> const& _expressionsToEvaluate)
+std::pair<CheckResult, std::vector<std::string>> Z3Interface::check(std::vector<Expression> const& _expressionsToEvaluate)
 {
 	CheckResult result;
-	vector<string> values;
+	std::vector<std::string> values;
 	try
 	{
 		switch (m_solver.check())
@@ -123,7 +122,7 @@ pair<CheckResult, vector<string>> Z3Interface::check(vector<Expression> const& _
 	}
 	catch (z3::exception const& _err)
 	{
-		set<string> msgs{
+		std::set<std::string> msgs{
 			/// Resource limit (rlimit) exhausted.
 			"max. resource limit exceeded",
 			/// User given timeout exhausted.
@@ -137,7 +136,7 @@ pair<CheckResult, vector<string>> Z3Interface::check(vector<Expression> const& _
 		values.clear();
 	}
 
-	return make_pair(result, values);
+	return std::make_pair(result, values);
 }
 
 z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
@@ -150,7 +149,7 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 
 	try
 	{
-		string const& n = _expr.name;
+		std::string const& n = _expr.name;
 		if (m_functions.count(n))
 			return m_functions.at(n)(arguments);
 		else if (m_constants.count(n))
@@ -166,7 +165,7 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 				return m_context.bool_val(false);
 			else if (_expr.sort->kind == Kind::Sort)
 			{
-				auto sortSort = dynamic_pointer_cast<SortSort>(_expr.sort);
+				auto sortSort = std::dynamic_pointer_cast<SortSort>(_expr.sort);
 				smtAssert(sortSort, "");
 				return m_context.constant(n.c_str(), z3Sort(*sortSort->inner));
 			}
@@ -233,7 +232,7 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 		}
 		else if (n == "bv2int")
 		{
-			auto intSort = dynamic_pointer_cast<IntSort>(_expr.sort);
+			auto intSort = std::dynamic_pointer_cast<IntSort>(_expr.sort);
 			smtAssert(intSort, "");
 			return z3::bv2int(arguments[0], intSort->isSigned);
 		}
@@ -243,9 +242,9 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 			return z3::store(arguments[0], arguments[1], arguments[2]);
 		else if (n == "const_array")
 		{
-			shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
+			std::shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
 			smtAssert(sortSort, "");
-			auto arraySort = dynamic_pointer_cast<ArraySort>(sortSort->inner);
+			auto arraySort = std::dynamic_pointer_cast<ArraySort>(sortSort->inner);
 			smtAssert(arraySort && arraySort->domain, "");
 			return z3::const_array(z3Sort(*arraySort->domain), arguments[1]);
 		}
@@ -285,7 +284,7 @@ Expression Z3Interface::fromZ3Expr(z3::expr const& _expr)
 
 	if (_expr.is_quantifier())
 	{
-		string quantifierName;
+		std::string quantifierName;
 		if (_expr.is_exists())
 			quantifierName = "exists";
 		else if (_expr.is_forall())
@@ -297,7 +296,7 @@ Expression Z3Interface::fromZ3Expr(z3::expr const& _expr)
 		return Expression(quantifierName, {fromZ3Expr(_expr.body())}, sort);
 	}
 	smtAssert(_expr.is_app(), "");
-	vector<Expression> arguments;
+	std::vector<Expression> arguments;
 	for (unsigned i = 0; i < _expr.num_args(); ++i)
 		arguments.push_back(fromZ3Expr(_expr.arg(i)));
 
@@ -344,6 +343,12 @@ Expression Z3Interface::fromZ3Expr(z3::expr const& _expr)
 		return arguments[0] % arguments[1];
 	else if (kind == Z3_OP_XOR)
 		return arguments[0] ^ arguments[1];
+	else if (kind == Z3_OP_BOR)
+		return arguments[0] | arguments[1];
+	else if (kind == Z3_OP_BAND)
+		return arguments[0] & arguments[1];
+	else if (kind == Z3_OP_BXOR)
+		return arguments[0] ^ arguments[1];
 	else if (kind == Z3_OP_BNOT)
 		return !arguments[0];
 	else if (kind == Z3_OP_BSHL)
@@ -364,12 +369,12 @@ Expression Z3Interface::fromZ3Expr(z3::expr const& _expr)
 		return Expression::store(arguments[0], arguments[1], arguments[2]);
 	else if (kind == Z3_OP_CONST_ARRAY)
 	{
-		auto sortSort = make_shared<SortSort>(fromZ3Sort(_expr.get_sort()));
+		auto sortSort = std::make_shared<SortSort>(fromZ3Sort(_expr.get_sort()));
 		return Expression::const_array(Expression(sortSort), arguments[0]);
 	}
 	else if (kind == Z3_OP_DT_CONSTRUCTOR)
 	{
-		auto sortSort = make_shared<SortSort>(fromZ3Sort(_expr.get_sort()));
+		auto sortSort = std::make_shared<SortSort>(fromZ3Sort(_expr.get_sort()));
 		return Expression::tuple_constructor(Expression(sortSort), arguments);
 	}
 	else if (kind == Z3_OP_DT_ACCESSOR)
@@ -406,12 +411,12 @@ z3::sort Z3Interface::z3Sort(Sort const& _sort)
 	case Kind::Tuple:
 	{
 		auto const& tupleSort = dynamic_cast<TupleSort const&>(_sort);
-		vector<char const*> cMembers;
+		std::vector<char const*> cMembers;
 		for (auto const& member: tupleSort.members)
 			cMembers.emplace_back(member.c_str());
 		/// Using this instead of the function below because with that one
 		/// we can't use `&sorts[0]` here.
-		vector<z3::sort> sorts;
+		std::vector<z3::sort> sorts;
 		for (auto const& sort: tupleSort.components)
 			sorts.push_back(z3Sort(*sort));
 		z3::func_decl_vector projs(m_context);
@@ -433,7 +438,7 @@ z3::sort Z3Interface::z3Sort(Sort const& _sort)
 	return m_context.int_sort();
 }
 
-z3::sort_vector Z3Interface::z3Sort(vector<SortPointer> const& _sorts)
+z3::sort_vector Z3Interface::z3Sort(std::vector<SortPointer> const& _sorts)
 {
 	z3::sort_vector z3Sorts(m_context);
 	for (auto const& _sort: _sorts)
@@ -448,27 +453,27 @@ SortPointer Z3Interface::fromZ3Sort(z3::sort const& _sort)
 	if (_sort.is_int())
 		return SortProvider::sintSort;
 	if (_sort.is_bv())
-		return make_shared<BitVectorSort>(_sort.bv_size());
+		return std::make_shared<BitVectorSort>(_sort.bv_size());
 	if (_sort.is_array())
-		return make_shared<ArraySort>(fromZ3Sort(_sort.array_domain()), fromZ3Sort(_sort.array_range()));
+		return std::make_shared<ArraySort>(fromZ3Sort(_sort.array_domain()), fromZ3Sort(_sort.array_range()));
 	if (_sort.is_datatype())
 	{
 		auto name = _sort.name().str();
 		auto constructor = z3::func_decl(m_context, Z3_get_tuple_sort_mk_decl(m_context, _sort));
-		vector<string> memberNames;
-		vector<SortPointer> memberSorts;
+		std::vector<std::string> memberNames;
+		std::vector<SortPointer> memberSorts;
 		for (unsigned i = 0; i < constructor.arity(); ++i)
 		{
 			auto accessor = z3::func_decl(m_context, Z3_get_tuple_sort_field_decl(m_context, _sort, i));
 			memberNames.push_back(accessor.name().str());
 			memberSorts.push_back(fromZ3Sort(accessor.range()));
 		}
-		return make_shared<TupleSort>(name, memberNames, memberSorts);
+		return std::make_shared<TupleSort>(name, memberNames, memberSorts);
 	}
 	smtAssert(false, "");
 }
 
-vector<SortPointer> Z3Interface::fromZ3Sort(z3::sort_vector const& _sorts)
+std::vector<SortPointer> Z3Interface::fromZ3Sort(z3::sort_vector const& _sorts)
 {
 	return applyMap(_sorts, [this](auto const& sort) { return fromZ3Sort(sort); });
 }
diff --git a/compiler/libsmtutil/Z3Loader.cpp b/compiler/libsmtutil/Z3Loader.cpp
index 86b17aa0..0211f600 100644
--- a/compiler/libsmtutil/Z3Loader.cpp
+++ b/compiler/libsmtutil/Z3Loader.cpp
@@ -27,7 +27,6 @@
 #endif
 #include <dlfcn.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::smtutil;
 
@@ -41,7 +40,7 @@ void* Z3Loader::loadSymbol(char const* _name) const
 {
 	smtAssert(m_handle, "Attempted to use dynamically loaded Z3, even though it is not available.");
 	void* sym = dlsym(m_handle, _name);
-	smtAssert(sym, string("Symbol \"") + _name + "\" not found in libz3.so");
+	smtAssert(sym, std::string("Symbol \"") + _name + "\" not found in libz3.so");
 	return sym;
 }
 
@@ -59,7 +58,7 @@ bool Z3Loader::available() const
 
 Z3Loader::Z3Loader()
 {
-	string libname{"libz3.so." + to_string(Z3_MAJOR_VERSION) + "." + to_string(Z3_MINOR_VERSION)};
+	std::string libname{"libz3.so." + std::to_string(Z3_MAJOR_VERSION) + "." + std::to_string(Z3_MINOR_VERSION)};
 	m_handle = dlmopen(LM_ID_NEWLM, libname.c_str(), RTLD_NOW);
 }
 
diff --git a/compiler/libsolc/libsolc.cpp b/compiler/libsolc/libsolc.cpp
index db589a52..b6b1763d 100644
--- a/compiler/libsolc/libsolc.cpp
+++ b/compiler/libsolc/libsolc.cpp
@@ -32,7 +32,6 @@
 
 #include "license.h"
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 
@@ -43,21 +42,21 @@ using solidity::frontend::StandardCompiler;
 namespace
 {
 
-// The strings in this list must not be resized after they have been added here (via solidity_alloc()), because
+// The std::strings in this list must not be resized after they have been added here (via solidity_alloc()), because
 // this may potentially change the pointer that was passed to the caller from solidity_alloc().
-static list<string> solidityAllocations;
+static std::list<std::string> solidityAllocations;
 
 /// Find the equivalent to @p _data in the list of allocations of solidity_alloc(),
 /// removes it from the list and returns its value.
 ///
 /// If any invalid argument is being passed, it is considered a programming error
 /// on the caller-side and hence, will call abort() then.
-string takeOverAllocation(char const* _data)
+std::string takeOverAllocation(char const* _data)
 {
 	for (auto iter = begin(solidityAllocations); iter != end(solidityAllocations); ++iter)
 		if (iter->data() == _data)
 		{
-			string chunk = std::move(*iter);
+			std::string chunk = std::move(*iter);
 			solidityAllocations.erase(iter);
 			return chunk;
 		}
@@ -65,11 +64,11 @@ string takeOverAllocation(char const* _data)
 	abort();
 }
 
-/// Resizes a std::string to the proper length based on the occurrence of a zero terminator.
-void truncateCString(string& _data)
+/// Resizes a std::std::string to the proper length based on the occurrence of a zero terminator.
+void truncateCString(std::string& _data)
 {
 	size_t pos = _data.find('\0');
-	if (pos != string::npos)
+	if (pos != std::string::npos)
 		_data.resize(pos);
 }
 
@@ -78,7 +77,7 @@ ReadCallback::Callback wrapReadCallback(CStyleReadFileCallback _readCallback, vo
 	ReadCallback::Callback readCallback;
 	if (_readCallback)
 	{
-		readCallback = [=](string const& _kind, string const& _data)
+		readCallback = [=](std::string const& _kind, std::string const& _data)
 		{
 			char* contents_c = nullptr;
 			char* error_c = nullptr;
@@ -107,7 +106,7 @@ ReadCallback::Callback wrapReadCallback(CStyleReadFileCallback _readCallback, vo
 	return readCallback;
 }
 
-string compile(string _input, CStyleReadFileCallback _readCallback, void* _readContext)
+std::string compile(std::string _input, CStyleReadFileCallback _readCallback, void* _readContext)
 {
 	StandardCompiler compiler(wrapReadCallback(_readCallback, _readContext));
 	return compiler.compile(std::move(_input));
@@ -119,7 +118,7 @@ extern "C"
 {
 extern char const* solidity_license() noexcept
 {
-	static string fullLicenseText = otherLicenses + licenseText;
+	static std::string fullLicenseText = otherLicenses + licenseText;
 	return fullLicenseText.c_str();
 }
 
@@ -202,7 +201,7 @@ extern void file_reader_add_or_update_file(void *p, const char* path, const char
 extern char* file_reader_source_unit_name(void *p, const char* path) noexcept
 {
 	FileReader *fileReader = (FileReader *)p;
-	string name = fileReader->cliPathToSourceUnitName(boost::filesystem::path(path));
+	std::string name = fileReader->cliPathToSourceUnitName(boost::filesystem::path(path));
 #ifdef FILE_READER_DEBUG
 	cout << "file_reader_source_unit_name " << path << " " << name << endl;
 #endif
diff --git a/compiler/libsolidity/CMakeLists.txt b/compiler/libsolidity/CMakeLists.txt
index 3f433b62..2c79fed0 100644
--- a/compiler/libsolidity/CMakeLists.txt
+++ b/compiler/libsolidity/CMakeLists.txt
@@ -63,6 +63,7 @@ set(sources
 	ast/CallGraph.cpp
 	ast/CallGraph.h
 	ast/ExperimentalFeatures.h
+	ast/UserDefinableOperators.h
 	ast/Types.cpp
 	ast/Types.h
 	ast/TypeProvider.cpp
@@ -78,10 +79,14 @@ set(sources
 	interface/Natspec.h
 	interface/OptimiserSettings.h
 	interface/ReadFile.h
+	interface/SMTSolverCommand.cpp
+	interface/SMTSolverCommand.h
 	interface/StandardCompiler.cpp
 	interface/StandardCompiler.h
 	interface/Version.cpp
 	interface/Version.h
+	lsp/DocumentHoverHandler.cpp
+	lsp/DocumentHoverHandler.h
 	lsp/FileRepository.cpp
 	lsp/FileRepository.h
 	lsp/GotoDefinition.cpp
@@ -103,7 +108,27 @@ set(sources
 	parsing/Parser.cpp
 	parsing/Parser.h
 	parsing/Token.h
-
+	experimental/analysis/Analysis.cpp
+	experimental/analysis/Analysis.h
+	experimental/analysis/DebugWarner.cpp
+	experimental/analysis/DebugWarner.h
+	experimental/analysis/FunctionDependencyAnalysis.cpp
+	experimental/analysis/FunctionDependencyAnalysis.h
+	experimental/analysis/TypeClassRegistration.cpp
+	experimental/analysis/TypeClassRegistration.h
+	experimental/analysis/TypeInference.cpp
+	experimental/analysis/TypeInference.h
+	experimental/analysis/TypeRegistration.cpp
+	experimental/analysis/TypeRegistration.h
+	experimental/analysis/SyntaxRestrictor.cpp
+	experimental/analysis/SyntaxRestrictor.h
+	experimental/ast/FunctionCallGraph.h
+	experimental/ast/Type.cpp
+	experimental/ast/Type.h
+	experimental/ast/TypeSystem.cpp
+	experimental/ast/TypeSystem.h
+	experimental/ast/TypeSystemHelper.cpp
+	experimental/ast/TypeSystemHelper.h
 
 	codegen/DictOperations.cpp
 	codegen/DictOperations.hpp
@@ -151,4 +176,4 @@ set(sources
 )
 
 add_library(solidity ${sources})
-target_link_libraries(solidity PUBLIC langutil solutil Boost::boost Boost::filesystem Boost::system fmt::fmt-header-only)
+target_link_libraries(solidity PUBLIC langutil solutil Boost::boost Boost::filesystem Boost::system fmt::fmt-header-only Threads::Threads)
diff --git a/compiler/libsolidity/analysis/ConstantEvaluator.cpp b/compiler/libsolidity/analysis/ConstantEvaluator.cpp
index 7fde36ec..8e18183a 100644
--- a/compiler/libsolidity/analysis/ConstantEvaluator.cpp
+++ b/compiler/libsolidity/analysis/ConstantEvaluator.cpp
@@ -29,7 +29,6 @@
 
 #include <limits>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 using namespace solidity::langutil;
@@ -47,9 +46,9 @@ bool fitsPrecisionExp(bigint const& _base, bigint const& _exp)
 
 	solAssert(_base > 0, "");
 
-	size_t const bitsMax = 4096;
+	std::size_t const bitsMax = 4096;
 
-	size_t mostSignificantBaseBit = static_cast<size_t>(boost::multiprecision::msb(_base));
+	std::size_t mostSignificantBaseBit = static_cast<std::size_t>(boost::multiprecision::msb(_base));
 	if (mostSignificantBaseBit == 0) // _base == 1
 		return true;
 	if (mostSignificantBaseBit > bitsMax) // _base >= 2 ^ 4096
@@ -68,7 +67,7 @@ bool fitsPrecisionBase2(bigint const& _mantissa, uint32_t _expBase2)
 
 }
 
-optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, rational const& _left, rational const& _right)
+std::optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, rational const& _left, rational const& _right)
 {
 	bool fractional = _left.denominator() != 1 || _right.denominator() != 1;
 	switch (_operator)
@@ -76,17 +75,17 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 	//bit operations will only be enabled for integers and fixed types that resemble integers
 	case Token::BitOr:
 		if (fractional)
-			return nullopt;
+			return std::nullopt;
 		else
 			return _left.numerator() | _right.numerator();
 	case Token::BitXor:
 		if (fractional)
-			return nullopt;
+			return std::nullopt;
 		else
 			return _left.numerator() ^ _right.numerator();
 	case Token::BitAnd:
 		if (fractional)
-			return nullopt;
+			return std::nullopt;
 		else
 			return _left.numerator() & _right.numerator();
 	case Token::Add: return _left + _right;
@@ -94,12 +93,12 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 	case Token::Mul: return _left * _right;
 	case Token::Div:
 		if (_right == rational(0))
-			return nullopt;
+			return std::nullopt;
 		else
 			return _left / _right;
 	case Token::Mod:
 		if (_right == rational(0))
-			return nullopt;
+			return std::nullopt;
 		else if (fractional)
 		{
 			rational tempValue = _left / _right;
@@ -111,7 +110,7 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 	case Token::Exp:
 	{
 		if (_right.denominator() != 1)
-			return nullopt;
+			return std::nullopt;
 		bigint const& exp = _right.numerator();
 
 		// x ** 0 = 1
@@ -127,13 +126,13 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 		}
 		else
 		{
-			if (abs(exp) > numeric_limits<uint32_t>::max())
-				return nullopt; // This will need too much memory to represent.
+			if (abs(exp) > std::numeric_limits<uint32_t>::max())
+				return std::nullopt; // This will need too much memory to represent.
 
 			uint32_t absExp = bigint(abs(exp)).convert_to<uint32_t>();
 
 			if (!fitsPrecisionExp(abs(_left.numerator()), absExp) || !fitsPrecisionExp(abs(_left.denominator()), absExp))
-				return nullopt;
+				return std::nullopt;
 
 			static auto const optimizedPow = [](bigint const& _base, uint32_t _exponent) -> bigint {
 				if (_base == 1)
@@ -158,18 +157,18 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 	case Token::SHL:
 	{
 		if (fractional)
-			return nullopt;
+			return std::nullopt;
 		else if (_right < 0)
-			return nullopt;
-		else if (_right > numeric_limits<uint32_t>::max())
-			return nullopt;
+			return std::nullopt;
+		else if (_right > std::numeric_limits<uint32_t>::max())
+			return std::nullopt;
 		if (_left.numerator() == 0)
 			return 0;
 		else
 		{
 			uint32_t exponent = _right.numerator().convert_to<uint32_t>();
 			if (!fitsPrecisionBase2(abs(_left.numerator()), exponent))
-				return nullopt;
+				return std::nullopt;
 			return _left.numerator() * boost::multiprecision::pow(bigint(2), exponent);
 		}
 		break;
@@ -179,11 +178,11 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 	case Token::SAR:
 	{
 		if (fractional)
-			return nullopt;
+			return std::nullopt;
 		else if (_right < 0)
-			return nullopt;
-		else if (_right > numeric_limits<uint32_t>::max())
-			return nullopt;
+			return std::nullopt;
+		else if (_right > std::numeric_limits<uint32_t>::max())
+			return std::nullopt;
 		if (_left.numerator() == 0)
 			return 0;
 		else
@@ -209,60 +208,60 @@ optional<rational> ConstantEvaluator::evaluateBinaryOperator(Token _operator, ra
 		break;
 	}
 	default:
-		return nullopt;
+		return std::nullopt;
 	}
 }
 
-optional<rational> ConstantEvaluator::evaluateUnaryOperator(Token _operator, rational const& _input)
+std::optional<rational> ConstantEvaluator::evaluateUnaryOperator(Token _operator, rational const& _input)
 {
 	switch (_operator)
 	{
 	case Token::BitNot:
 		if (_input.denominator() != 1)
-			return nullopt;
+			return std::nullopt;
 		else
 			return ~_input.numerator();
 	case Token::Sub:
 		return -_input;
 	default:
-		return nullopt;
+		return std::nullopt;
 	}
 }
 
 namespace
 {
 
-optional<TypedRational> convertType(rational const& _value, Type const& _type)
+std::optional<TypedRational> convertType(rational const& _value, Type const& _type)
 {
 	if (_type.category() == Type::Category::RationalNumber)
 		return TypedRational{TypeProvider::rationalNumber(_value), _value};
 	else if (auto const* integerType = dynamic_cast<IntegerType const*>(&_type))
 	{
 		if (_value > integerType->maxValue() || _value < integerType->minValue())
-			return nullopt;
+			return std::nullopt;
 		else
 			return TypedRational{&_type, _value.numerator() / _value.denominator()};
 	}
 	else
-		return nullopt;
+		return std::nullopt;
 }
 
-optional<TypedRational> convertType(optional<TypedRational> const& _value, Type const& _type)
+std::optional<TypedRational> convertType(std::optional<TypedRational> const& _value, Type const& _type)
 {
-	return _value ? convertType(_value->value, _type) : nullopt;
+	return _value ? convertType(_value->value, _type) : std::nullopt;
 }
 
-optional<TypedRational> constantToTypedValue(Type const& _type)
+std::optional<TypedRational> constantToTypedValue(Type const& _type)
 {
 	if (_type.category() == Type::Category::RationalNumber)
 		return TypedRational{&_type, dynamic_cast<RationalNumberType const&>(_type).value()};
 	else
-		return nullopt;
+		return std::nullopt;
 }
 
 }
 
-optional<TypedRational> ConstantEvaluator::evaluate(
+std::optional<TypedRational> ConstantEvaluator::evaluate(
 	langutil::ErrorReporter& _errorReporter,
 	Expression const& _expr
 )
@@ -271,7 +270,7 @@ optional<TypedRational> ConstantEvaluator::evaluate(
 }
 
 
-optional<TypedRational> ConstantEvaluator::evaluate(ASTNode const& _node)
+std::optional<TypedRational> ConstantEvaluator::evaluate(ASTNode const& _node)
 {
 	if (!m_values.count(&_node))
 	{
@@ -280,7 +279,7 @@ optional<TypedRational> ConstantEvaluator::evaluate(ASTNode const& _node)
 			solAssert(varDecl->isConstant(), "");
 			// In some circumstances, we do not yet have a type for the variable.
 			if (!varDecl->value() || !varDecl->type())
-				m_values[&_node] = nullopt;
+				m_values[&_node] = std::nullopt;
 			else
 			{
 				m_depth++;
@@ -298,7 +297,7 @@ optional<TypedRational> ConstantEvaluator::evaluate(ASTNode const& _node)
 		{
 			expression->accept(*this);
 			if (!m_values.count(&_node))
-				m_values[&_node] = nullopt;
+				m_values[&_node] = std::nullopt;
 		}
 	}
 	return m_values.at(&_node);
@@ -306,7 +305,7 @@ optional<TypedRational> ConstantEvaluator::evaluate(ASTNode const& _node)
 
 void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
 {
-	optional<TypedRational> value = evaluate(_operation.subExpression());
+	std::optional<TypedRational> value = evaluate(_operation.subExpression());
 	if (!value)
 		return;
 
@@ -317,9 +316,9 @@ void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
 	if (!value)
 		return;
 
-	if (optional<rational> result = evaluateUnaryOperator(_operation.getOperator(), value->value))
+	if (std::optional<rational> result = evaluateUnaryOperator(_operation.getOperator(), value->value))
 	{
-		optional<TypedRational> convertedValue = convertType(*result, *resultType);
+		std::optional<TypedRational> convertedValue = convertType(*result, *resultType);
 		if (!convertedValue)
 			m_errorReporter.fatalTypeError(
 				3667_error,
@@ -332,8 +331,8 @@ void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
 
 void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
 {
-	optional<TypedRational> left = evaluate(_operation.leftExpression());
-	optional<TypedRational> right = evaluate(_operation.rightExpression());
+	std::optional<TypedRational> left = evaluate(_operation.leftExpression());
+	std::optional<TypedRational> right = evaluate(_operation.rightExpression());
 	if (!left || !right)
 		return;
 
@@ -349,7 +348,7 @@ void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
 			6020_error,
 			_operation.location(),
 			"Operator " +
-			string(TokenTraits::toString(_operation.getOperator())) +
+			std::string(TokenTraits::toString(_operation.getOperator())) +
 			" not compatible with types " +
 			left->type->toString() +
 			" and " +
@@ -363,9 +362,9 @@ void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
 	if (!left || !right)
 		return;
 
-	if (optional<rational> value = evaluateBinaryOperator(_operation.getOperator(), left->value, right->value))
+	if (std::optional<rational> value = evaluateBinaryOperator(_operation.getOperator(), left->value, right->value))
 	{
-		optional<TypedRational> convertedValue = convertType(*value, *resultType);
+		std::optional<TypedRational> convertedValue = convertType(*value, *resultType);
 		if (!convertedValue)
 			m_errorReporter.fatalTypeError(
 				2643_error,
diff --git a/compiler/libsolidity/analysis/ContractLevelChecker.cpp b/compiler/libsolidity/analysis/ContractLevelChecker.cpp
index 0883e7ee..048193d2 100644
--- a/compiler/libsolidity/analysis/ContractLevelChecker.cpp
+++ b/compiler/libsolidity/analysis/ContractLevelChecker.cpp
@@ -28,9 +28,10 @@
 #include <libsolutil/FunctionSelector.h>
 #include <liblangutil/ErrorReporter.h>
 
+#include <fmt/format.h>
+
 #include <range/v3/view/reverse.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -47,10 +48,10 @@ bool hasEqualExternalCallableParameters(T const& _a, B const& _b)
 }
 
 template<typename T>
-map<ASTString, vector<T const*>> filterDeclarations(
-	map<ASTString, vector<Declaration const*>> const& _declarations)
+std::map<ASTString, std::vector<T const*>> filterDeclarations(
+	std::map<ASTString, std::vector<Declaration const*>> const& _declarations)
 {
-	map<ASTString, vector<T const*>> filteredDeclarations;
+	std::map<ASTString, std::vector<T const*>> filteredDeclarations;
 	for (auto const& [name, overloads]: _declarations)
 		for (auto const* declaration: overloads)
 			if (auto typedDeclaration = dynamic_cast<T const*>(declaration))
@@ -102,7 +103,7 @@ void ContractLevelChecker::checkDuplicateFunctions(ContractDefinition const& _co
 {
 	/// Checks that two functions with the same name defined in this contract have different
 	/// argument types and that there is at most one constructor.
-	map<string, vector<FunctionDefinition const*>> functions;
+	std::map<std::string, std::vector<FunctionDefinition const*>> functions;
 	FunctionDefinition const* constructor = nullptr;
 	FunctionDefinition const* fallback = nullptr;
 	FunctionDefinition const* receive = nullptr;
@@ -178,7 +179,7 @@ void ContractLevelChecker::checkDuplicateEvents(ContractDefinition const& _contr
 {
 	/// Checks that two events with the same name defined in this contract have different
 	/// argument types
-	map<string, vector<EventDefinition const*>> events;
+	std::map<std::string, std::vector<EventDefinition const*>> events;
 	for (auto const* contract: _contract.annotation().linearizedBaseContracts)
 		for (EventDefinition const* event: contract->events())
 			events[event->name()].push_back(event);
@@ -208,12 +209,12 @@ void ContractLevelChecker::checkReceiveFunction(ContractDefinition const& _contr
 }
 
 template <class T>
-void ContractLevelChecker::findDuplicateDefinitions(map<string, vector<T>> const& _definitions)
+void ContractLevelChecker::findDuplicateDefinitions(std::map<std::string, std::vector<T>> const& _definitions)
 {
 	for (auto const& it: _definitions)
 	{
-		vector<T> const& overloads = it.second;
-		set<size_t> reported;
+		std::vector<T> const& overloads = it.second;
+		std::set<size_t> reported;
 		for (size_t i = 0; i < overloads.size() && !reported.count(i); ++i)
 		{
 			SecondarySourceLocation ssl;
@@ -241,15 +242,15 @@ void ContractLevelChecker::findDuplicateDefinitions(map<string, vector<T>> const
 			if (ssl.infos.size() > 0)
 			{
 				ErrorId error;
-				string message;
-				if constexpr (is_same_v<T, FunctionDefinition const*>)
+				std::string message;
+				if constexpr (std::is_same_v<T, FunctionDefinition const*>)
 				{
 					error = 1686_error;
 					message = "Function with same name and parameter types defined twice.";
 				}
 				else
 				{
-					static_assert(is_same_v<T, EventDefinition const*>, "Expected \"FunctionDefinition const*\" or \"EventDefinition const*\"");
+					static_assert(std::is_same_v<T, EventDefinition const*>, "Expected \"FunctionDefinition const*\" or \"EventDefinition const*\"");
 					error = 5883_error;
 					message = "Event with same name and parameter types defined twice.";
 				}
@@ -271,7 +272,7 @@ void ContractLevelChecker::checkAbstractDefinitions(ContractDefinition const& _c
 {
 	// Collects functions, static variable getters and modifiers. If they
 	// override (unimplemented) base class ones, they are replaced.
-	set<OverrideProxy, OverrideProxy::CompareBySignature> proxies;
+	std::set<OverrideProxy, OverrideProxy::CompareBySignature> proxies;
 
 	auto registerProxy = [&proxies](OverrideProxy const& _overrideProxy)
 	{
@@ -299,9 +300,6 @@ void ContractLevelChecker::checkAbstractDefinitions(ContractDefinition const& _c
 	}
 
 	// Set to not fully implemented if at least one flag is false.
-	// Note that `_contract.annotation().unimplementedDeclarations` has already been
-	// pre-filled by `checkBaseConstructorArguments`.
-	//
 	for (auto const& proxy: proxies)
 		if (proxy.unimplemented())
 			_contract.annotation().unimplementedDeclarations->push_back(proxy.declaration());
@@ -339,7 +337,7 @@ void ContractLevelChecker::checkAbstractDefinitions(ContractDefinition const& _c
 
 void ContractLevelChecker::checkBaseConstructorArguments(ContractDefinition const& _contract)
 {
-	vector<ContractDefinition const*> const& bases = _contract.annotation().linearizedBaseContracts;
+	std::vector<ContractDefinition const*> const& bases = _contract.annotation().linearizedBaseContracts;
 
 	// Determine the arguments that are used for the base constructors.
 	for (ContractDefinition const* contract: bases)
@@ -377,11 +375,27 @@ void ContractLevelChecker::checkBaseConstructorArguments(ContractDefinition cons
 
 	// check that we get arguments for all base constructors that need it.
 	// If not mark the contract as abstract (not fully implemented)
-	for (ContractDefinition const* contract: bases)
-		if (FunctionDefinition const* constructor = contract->constructor())
-			if (contract != &_contract && !constructor->parameters().empty())
-				if (!_contract.annotation().baseConstructorArguments.count(constructor))
-					_contract.annotation().unimplementedDeclarations->push_back(constructor);
+	if (_contract.contractKind() == ContractKind::Contract && !_contract.abstract())
+		for (ContractDefinition const* baseContract: bases)
+			if (FunctionDefinition const* baseConstructor = baseContract->constructor())
+				if (
+					baseContract != &_contract &&
+					!baseConstructor->parameters().empty() &&
+					_contract.annotation().baseConstructorArguments.count(baseConstructor) == 0
+				)
+					m_errorReporter.typeError(
+						3415_error,
+						_contract.location(),
+						SecondarySourceLocation{}.append(
+							"Base constructor parameters:",
+							baseConstructor->parameterList().location()
+						),
+						fmt::format(
+							"No arguments passed to the base constructor. "
+							"Specify the arguments or mark \"{}\" as abstract.",
+							*_contract.annotation().canonicalName
+						)
+					);
 }
 
 void ContractLevelChecker::annotateBaseConstructorArguments(
@@ -430,7 +444,7 @@ void ContractLevelChecker::annotateBaseConstructorArguments(
 
 void ContractLevelChecker::checkExternalTypeClashes(ContractDefinition const& _contract)
 {
-	map<string, vector<pair<Declaration const*, FunctionTypePointer>>> externalDeclarations;
+	std::map<std::string, std::vector<std::pair<Declaration const*, FunctionTypePointer>>> externalDeclarations;
 	for (ContractDefinition const* contract: _contract.annotation().linearizedBaseContracts)
 	{
 		for (FunctionDefinition const* f: contract->definedFunctions())
@@ -467,7 +481,7 @@ void ContractLevelChecker::checkExternalTypeClashes(ContractDefinition const& _c
 
 void ContractLevelChecker::checkHashCollisions(ContractDefinition const& _contract)
 {
-	set<util::FixedHash<4>> hashes;
+	std::set<util::FixedHash<4>> hashes;
 	for (auto const& it: _contract.interfaceFunctionList())
 	{
 		util::FixedHash<4> const& hash = it.first;
@@ -475,7 +489,7 @@ void ContractLevelChecker::checkHashCollisions(ContractDefinition const& _contra
 			m_errorReporter.fatalTypeError(
 				1860_error,
 				_contract.location(),
-				string("Function signature hash collision for ") + it.second->externalSignature()
+				std::string("Function signature hash collision for ") + it.second->externalSignature()
 			);
 		hashes.insert(hash);
 	}
diff --git a/compiler/libsolidity/analysis/ControlFlowAnalyzer.cpp b/compiler/libsolidity/analysis/ControlFlowAnalyzer.cpp
index 557be380..f4e9d33a 100644
--- a/compiler/libsolidity/analysis/ControlFlowAnalyzer.cpp
+++ b/compiler/libsolidity/analysis/ControlFlowAnalyzer.cpp
@@ -25,7 +25,6 @@
 
 #include <functional>
 
-using namespace std;
 using namespace std::placeholders;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -44,7 +43,7 @@ void ControlFlowAnalyzer::analyze(FunctionDefinition const& _function, ContractD
 	if (!_function.isImplemented())
 		return;
 
-	optional<string> mostDerivedContractName;
+	std::optional<std::string> mostDerivedContractName;
 
 	// The name of the most derived contract only required if it differs from
 	// the functions contract
@@ -61,13 +60,13 @@ void ControlFlowAnalyzer::analyze(FunctionDefinition const& _function, ContractD
 }
 
 
-void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNode const* _exit, bool _emptyBody, optional<string> _contractName)
+void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNode const* _exit, bool _emptyBody, std::optional<std::string> _contractName)
 {
 	struct NodeInfo
 	{
-		set<VariableDeclaration const*> unassignedVariablesAtEntry;
-		set<VariableDeclaration const*> unassignedVariablesAtExit;
-		set<VariableOccurrence const*> uninitializedVariableAccesses;
+		std::set<VariableDeclaration const*> unassignedVariablesAtEntry;
+		std::set<VariableDeclaration const*> unassignedVariablesAtExit;
+		std::set<VariableOccurrence const*> uninitializedVariableAccesses;
 		/// Propagate the information from another node to this node.
 		/// To be used to propagate information from a node to its exit nodes.
 		/// Returns true, if new variables were added and thus the current node has
@@ -84,8 +83,8 @@ void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNod
 			;
 		}
 	};
-	map<CFGNode const*, NodeInfo> nodeInfos;
-	set<CFGNode const*> nodesToTraverse;
+	std::map<CFGNode const*, NodeInfo> nodeInfos;
+	std::set<CFGNode const*> nodesToTraverse;
 	nodesToTraverse.insert(_entry);
 
 	// Walk all paths starting from the nodes in ``nodesToTraverse`` until ``NodeInfo::propagateFrom``
@@ -105,10 +104,6 @@ void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNod
 				case VariableOccurrence::Kind::Assignment:
 					unassignedVariables.erase(&variableOccurrence.declaration());
 					break;
-				case VariableOccurrence::Kind::InlineAssembly:
-					// We consider all variables referenced in inline assembly as accessed.
-					// So far any reference is enough, but we might want to actually analyze
-					// the control flow in the assembly at some point.
 				case VariableOccurrence::Kind::Access:
 				case VariableOccurrence::Kind::Return:
 					break;
@@ -131,7 +126,7 @@ void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNod
 	auto const& exitInfo = nodeInfos[_exit];
 	if (!exitInfo.uninitializedVariableAccesses.empty())
 	{
-		vector<VariableOccurrence const*> uninitializedAccessesOrdered(
+		std::vector<VariableOccurrence const*> uninitializedAccessesOrdered(
 			exitInfo.uninitializedVariableAccesses.begin(),
 			exitInfo.uninitializedVariableAccesses.end()
 		);
diff --git a/compiler/libsolidity/analysis/ControlFlowBuilder.cpp b/compiler/libsolidity/analysis/ControlFlowBuilder.cpp
index a8179e5b..9665e71c 100644
--- a/compiler/libsolidity/analysis/ControlFlowBuilder.cpp
+++ b/compiler/libsolidity/analysis/ControlFlowBuilder.cpp
@@ -19,10 +19,8 @@
 #include <libsolidity/analysis/ControlFlowBuilder.h>
 #include <libsolidity/ast/ASTUtils.h>
 
-using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
-using namespace std;
 
 ControlFlowBuilder::ControlFlowBuilder(CFG::NodeContainer& _nodeContainer, FunctionFlow const& _functionFlow, ContractDefinition const* _contract):
 	m_nodeContainer(_nodeContainer),
@@ -34,13 +32,13 @@ ControlFlowBuilder::ControlFlowBuilder(CFG::NodeContainer& _nodeContainer, Funct
 }
 
 
-unique_ptr<FunctionFlow> ControlFlowBuilder::createFunctionFlow(
+std::unique_ptr<FunctionFlow> ControlFlowBuilder::createFunctionFlow(
 	CFG::NodeContainer& _nodeContainer,
 	FunctionDefinition const& _function,
 	ContractDefinition const* _contract
 )
 {
-	auto functionFlow = make_unique<FunctionFlow>();
+	auto functionFlow = std::make_unique<FunctionFlow>();
 	functionFlow->entry = _nodeContainer.newNode();
 	functionFlow->exit = _nodeContainer.newNode();
 	functionFlow->revert = _nodeContainer.newNode();
@@ -61,17 +59,53 @@ bool ControlFlowBuilder::visit(BinaryOperation const& _operation)
 		case Token::And:
 		{
 			visitNode(_operation);
+			solAssert(*_operation.annotation().userDefinedFunction == nullptr);
 			appendControlFlow(_operation.leftExpression());
 
 			auto nodes = splitFlow<2>();
 			nodes[0] = createFlow(nodes[0], _operation.rightExpression());
 			mergeFlow(nodes, nodes[1]);
-
 			return false;
 		}
 		default:
-			return ASTConstVisitor::visit(_operation);
+		{
+			if (*_operation.annotation().userDefinedFunction != nullptr)
+			{
+				visitNode(_operation);
+				_operation.leftExpression().accept(*this);
+				_operation.rightExpression().accept(*this);
+
+				m_currentNode->functionDefinition = *_operation.annotation().userDefinedFunction;
+
+				auto nextNode = newLabel();
+
+				connect(m_currentNode, nextNode);
+				m_currentNode = nextNode;
+				return false;
+			}
+		}
+	}
+	return ASTConstVisitor::visit(_operation);
+}
+
+bool ControlFlowBuilder::visit(UnaryOperation const& _operation)
+{
+	solAssert(!!m_currentNode);
+
+	if (*_operation.annotation().userDefinedFunction != nullptr)
+	{
+		visitNode(_operation);
+		_operation.subExpression().accept(*this);
+		m_currentNode->functionDefinition = *_operation.annotation().userDefinedFunction;
+
+		auto nextNode = newLabel();
+
+		connect(m_currentNode, nextNode);
+		m_currentNode = nextNode;
+		return false;
 	}
+
+	return ASTConstVisitor::visit(_operation);
 }
 
 bool ControlFlowBuilder::visit(Conditional const& _conditional)
@@ -333,8 +367,7 @@ bool ControlFlowBuilder::visit(FunctionCall const& _functionCall)
 				_functionCall.expression().accept(*this);
 				ASTNode::listAccept(_functionCall.arguments(), *this);
 
-				solAssert(!m_currentNode->functionCall);
-				m_currentNode->functionCall = &_functionCall;
+				m_currentNode->functionDefinition = ASTNode::resolveFunctionCall(_functionCall, m_contract);
 
 				auto nextNode = newLabel();
 
@@ -351,6 +384,8 @@ bool ControlFlowBuilder::visit(FunctionCall const& _functionCall)
 
 bool ControlFlowBuilder::visit(ModifierInvocation const& _modifierInvocation)
 {
+	solAssert(m_contract, "Free functions cannot have modifiers");
+
 	if (auto arguments = _modifierInvocation.arguments())
 		for (auto& argument: *arguments)
 			appendControlFlow(*argument);
@@ -444,12 +479,6 @@ bool ControlFlowBuilder::visit(FunctionTypeName const& _functionTypeName)
 	return false;
 }
 
-bool ControlFlowBuilder::visit(InlineAssembly const& /*_inlineAssembly*/)
-{
-	solAssert(!!m_currentNode, "");
-	return true;
-}
-
 bool ControlFlowBuilder::visit(VariableDeclaration const& _variableDeclaration)
 {
 	solAssert(!!m_currentNode, "");
diff --git a/compiler/libsolidity/analysis/ControlFlowBuilder.h b/compiler/libsolidity/analysis/ControlFlowBuilder.h
index 10e8e636..44e7a973 100644
--- a/compiler/libsolidity/analysis/ControlFlowBuilder.h
+++ b/compiler/libsolidity/analysis/ControlFlowBuilder.h
@@ -37,18 +37,19 @@ class ControlFlowBuilder: private ASTConstVisitor
 	static std::unique_ptr<FunctionFlow> createFunctionFlow(
 		CFG::NodeContainer& _nodeContainer,
 		FunctionDefinition const& _function,
-		ContractDefinition const* _contract = nullptr
+		ContractDefinition const* _contract
 	);
 
 private:
 	explicit ControlFlowBuilder(
 		CFG::NodeContainer& _nodeContainer,
 		FunctionFlow const& _functionFlow,
-		ContractDefinition const* _contract = nullptr
+		ContractDefinition const* _contract
 	);
 
 	// Visits for constructing the control flow.
 	bool visit(BinaryOperation const& _operation) override;
+	bool visit(UnaryOperation const& _operation) override;
 	bool visit(Conditional const& _conditional) override;
 	bool visit(TryStatement const& _tryStatement) override;
 	bool visit(IfStatement const& _ifStatement) override;
@@ -69,7 +70,6 @@ class ControlFlowBuilder: private ASTConstVisitor
 
 	// Visits for filling variable occurrences.
 	bool visit(FunctionTypeName const& _functionTypeName) override;
-	bool visit(InlineAssembly const& _inlineAssembly) override;
 	bool visit(VariableDeclaration const& _variableDeclaration) override;
 	bool visit(VariableDeclarationStatement const& _variableDeclarationStatement) override;
 	bool visit(Identifier const& _identifier) override;
diff --git a/compiler/libsolidity/analysis/ControlFlowGraph.cpp b/compiler/libsolidity/analysis/ControlFlowGraph.cpp
index ca36b421..518743ef 100644
--- a/compiler/libsolidity/analysis/ControlFlowGraph.cpp
+++ b/compiler/libsolidity/analysis/ControlFlowGraph.cpp
@@ -20,7 +20,6 @@
 
 #include <libsolidity/analysis/ControlFlowBuilder.h>
 
-using namespace std;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
 
@@ -34,7 +33,11 @@ bool CFG::constructFlow(ASTNode const& _astRoot)
 bool CFG::visit(FunctionDefinition const& _function)
 {
 	if (_function.isImplemented() && _function.isFree())
-		m_functionControlFlow[{nullptr, &_function}] = ControlFlowBuilder::createFunctionFlow(m_nodeContainer, _function);
+		m_functionControlFlow[{nullptr, &_function}] = ControlFlowBuilder::createFunctionFlow(
+			m_nodeContainer,
+			_function,
+			nullptr /* _contract */
+		);
 	return false;
 }
 
diff --git a/compiler/libsolidity/analysis/ControlFlowGraph.h b/compiler/libsolidity/analysis/ControlFlowGraph.h
index 7383783f..7e519205 100644
--- a/compiler/libsolidity/analysis/ControlFlowGraph.h
+++ b/compiler/libsolidity/analysis/ControlFlowGraph.h
@@ -48,7 +48,6 @@ class VariableOccurrence
 		Access,
 		Return,
 		Assignment,
-		InlineAssembly
 	};
 	VariableOccurrence(VariableDeclaration const& _declaration, Kind _kind, std::optional<langutil::SourceLocation>  _occurrence = {}):
 		m_declaration(_declaration), m_occurrenceKind(_kind), m_occurrence(std::move(_occurrence))
@@ -98,9 +97,8 @@ struct CFGNode
 	std::vector<CFGNode*> entries;
 	/// Exit nodes. All CFG nodes to which control flow may continue after this node.
 	std::vector<CFGNode*> exits;
-	/// Function call done by this node
-	FunctionCall const* functionCall = nullptr;
-
+	/// Resolved definition of the function called by this node
+	FunctionDefinition const* functionDefinition = nullptr;
 	/// Variable occurrences in the node.
 	std::vector<VariableOccurrence> variableOccurrences;
 	// Source location of this control flow block.
diff --git a/compiler/libsolidity/analysis/ControlFlowRevertPruner.cpp b/compiler/libsolidity/analysis/ControlFlowRevertPruner.cpp
index ae9c18a1..c96ad2b0 100644
--- a/compiler/libsolidity/analysis/ControlFlowRevertPruner.cpp
+++ b/compiler/libsolidity/analysis/ControlFlowRevertPruner.cpp
@@ -81,27 +81,23 @@ void ControlFlowRevertPruner::findRevertStates()
 				if (_node == functionFlow.exit)
 					foundExit = true;
 
-				if (auto const* functionCall = _node->functionCall)
+				auto const* resolvedFunction = _node->functionDefinition;
+				if (resolvedFunction && resolvedFunction->isImplemented())
 				{
-					auto const* resolvedFunction = ASTNode::resolveFunctionCall(*functionCall, item.contract);
-
-					if (resolvedFunction && resolvedFunction->isImplemented())
+					CFG::FunctionContractTuple calledFunctionTuple{
+						findScopeContract(*resolvedFunction, item.contract),
+						resolvedFunction
+					};
+					switch (m_functions.at(calledFunctionTuple))
 					{
-						CFG::FunctionContractTuple calledFunctionTuple{
-							findScopeContract(*resolvedFunction, item.contract),
-							resolvedFunction
-						};
-						switch (m_functions.at(calledFunctionTuple))
-						{
-							case RevertState::Unknown:
-								wakeUp[calledFunctionTuple].insert(item);
-								foundUnknown = true;
-								return;
-							case RevertState::AllPathsRevert:
-								return;
-							case RevertState::HasNonRevertingPath:
-								break;
-						}
+						case RevertState::Unknown:
+							wakeUp[calledFunctionTuple].insert(item);
+							foundUnknown = true;
+							return;
+						case RevertState::AllPathsRevert:
+							return;
+						case RevertState::HasNonRevertingPath:
+							break;
 					}
 				}
 
@@ -135,30 +131,26 @@ void ControlFlowRevertPruner::modifyFunctionFlows()
 		FunctionFlow const& functionFlow = m_cfg.functionFlow(*item.first.function, item.first.contract);
 		solidity::util::BreadthFirstSearch<CFGNode*>{{functionFlow.entry}}.run(
 			[&](CFGNode* _node, auto&& _addChild) {
-				if (auto const* functionCall = _node->functionCall)
-				{
-					auto const* resolvedFunction = ASTNode::resolveFunctionCall(*functionCall, item.first.contract);
-
-					if (resolvedFunction && resolvedFunction->isImplemented())
-						switch (m_functions.at({findScopeContract(*resolvedFunction, item.first.contract), resolvedFunction}))
-						{
-							case RevertState::Unknown:
-								[[fallthrough]];
-							case RevertState::AllPathsRevert:
-								// If the revert states of the functions do not
-								// change anymore, we treat all "unknown" states as
-								// "reverting", since they can only be caused by
-								// recursion.
-								for (CFGNode * node: _node->exits)
-									ranges::remove(node->entries, _node);
-
-								_node->exits = {functionFlow.revert};
-								functionFlow.revert->entries.push_back(_node);
-								return;
-							default:
-								break;
-						}
-				}
+				auto const* resolvedFunction = _node->functionDefinition;
+				if (resolvedFunction && resolvedFunction->isImplemented())
+					switch (m_functions.at({findScopeContract(*resolvedFunction, item.first.contract), resolvedFunction}))
+					{
+						case RevertState::Unknown:
+							[[fallthrough]];
+						case RevertState::AllPathsRevert:
+							// If the revert states of the functions do not
+							// change anymore, we treat all "unknown" states as
+							// "reverting", since they can only be caused by
+							// recursion.
+							for (CFGNode * node: _node->exits)
+								ranges::remove(node->entries, _node);
+
+							_node->exits = {functionFlow.revert};
+							functionFlow.revert->entries.push_back(_node);
+							return;
+						default:
+							break;
+					}
 
 				for (CFGNode* exit: _node->exits)
 					_addChild(exit);
diff --git a/compiler/libsolidity/analysis/DeclarationContainer.cpp b/compiler/libsolidity/analysis/DeclarationContainer.cpp
index b6cd3eef..df6e664b 100644
--- a/compiler/libsolidity/analysis/DeclarationContainer.cpp
+++ b/compiler/libsolidity/analysis/DeclarationContainer.cpp
@@ -29,7 +29,6 @@
 #include <range/v3/view/filter.hpp>
 #include <range/v3/range/conversion.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
@@ -41,7 +40,7 @@ Declaration const* DeclarationContainer::conflictingDeclaration(
 	if (!_name)
 		_name = &_declaration.name();
 	solAssert(!_name->empty(), "");
-	vector<Declaration const*> declarations;
+	std::vector<Declaration const*> declarations;
 	if (m_declarations.count(*_name))
 		declarations += m_declarations.at(*_name);
 	if (m_invisibleDeclarations.count(*_name))
@@ -127,7 +126,7 @@ bool DeclarationContainer::registerDeclaration(
 			m_homonymCandidates.emplace_back(*_name, _location ? _location : &_declaration.location());
 	}
 
-	vector<Declaration const*>& decls = _invisible ? m_invisibleDeclarations[*_name] : m_declarations[*_name];
+	std::vector<Declaration const*>& decls = _invisible ? m_invisibleDeclarations[*_name] : m_declarations[*_name];
 	if (!util::contains(decls, &_declaration))
 		decls.push_back(&_declaration);
 	return true;
@@ -142,13 +141,13 @@ bool DeclarationContainer::registerDeclaration(
 	return registerDeclaration(_declaration, nullptr, nullptr, _invisible, _update);
 }
 
-vector<Declaration const*> DeclarationContainer::resolveName(
+std::vector<Declaration const*> DeclarationContainer::resolveName(
 	ASTString const& _name,
 	ResolvingSettings _settings
 ) const
 {
 	solAssert(!_name.empty(), "Attempt to resolve empty name.");
-	vector<Declaration const*> result;
+	std::vector<Declaration const*> result;
 
 	if (m_declarations.count(_name))
 	{
@@ -172,24 +171,24 @@ vector<Declaration const*> DeclarationContainer::resolveName(
 	return result;
 }
 
-vector<ASTString> DeclarationContainer::similarNames(ASTString const& _name) const
+std::vector<ASTString> DeclarationContainer::similarNames(ASTString const& _name) const
 {
 
 	// because the function below has quadratic runtime - it will not magically improve once a better algorithm is discovered ;)
 	// since 80 is the suggested line length limit, we use 80^2 as length threshold
 	static size_t const MAXIMUM_LENGTH_THRESHOLD = 80 * 80;
 
-	vector<ASTString> similar;
+	std::vector<ASTString> similar;
 	size_t maximumEditDistance = _name.size() > 3 ? 2 : _name.size() / 2;
 	for (auto const& declaration: m_declarations)
 	{
-		string const& declarationName = declaration.first;
+		std::string const& declarationName = declaration.first;
 		if (util::stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
 			similar.push_back(declarationName);
 	}
 	for (auto const& declaration: m_invisibleDeclarations)
 	{
-		string const& declarationName = declaration.first;
+		std::string const& declarationName = declaration.first;
 		if (util::stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
 			similar.push_back(declarationName);
 	}
@@ -200,7 +199,7 @@ vector<ASTString> DeclarationContainer::similarNames(ASTString const& _name) con
 	return similar;
 }
 
-void DeclarationContainer::populateHomonyms(back_insert_iterator<Homonyms> _it) const
+void DeclarationContainer::populateHomonyms(std::back_insert_iterator<Homonyms> _it) const
 {
 	for (DeclarationContainer const* innerContainer: m_innerContainers)
 		innerContainer->populateHomonyms(_it);
@@ -210,7 +209,7 @@ void DeclarationContainer::populateHomonyms(back_insert_iterator<Homonyms> _it)
 		ResolvingSettings settings;
 		settings.recursive = true;
 		settings.alsoInvisible = true;
-		vector<Declaration const*> const& declarations = m_enclosingContainer->resolveName(name, std::move(settings));
+		std::vector<Declaration const*> const& declarations = m_enclosingContainer->resolveName(name, std::move(settings));
 		if (!declarations.empty())
 			_it = make_pair(location, declarations);
 	}
diff --git a/compiler/libsolidity/analysis/DeclarationTypeChecker.cpp b/compiler/libsolidity/analysis/DeclarationTypeChecker.cpp
index be37cf61..ca4319cd 100644
--- a/compiler/libsolidity/analysis/DeclarationTypeChecker.cpp
+++ b/compiler/libsolidity/analysis/DeclarationTypeChecker.cpp
@@ -29,7 +29,6 @@
 
 #include <range/v3/view/transform.hpp>
 
-using namespace std;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
 
@@ -169,7 +168,7 @@ void DeclarationTypeChecker::endVisit(UserDefinedTypeName const& _typeName)
 		m_errorReporter.fatalTypeError(
 			5172_error,
 			_typeName.location(),
-			"Name has to refer to a struct, enum or contract."
+			"Name has to refer to a user-defined type."
 		);
 	}
 }
@@ -221,14 +220,54 @@ void DeclarationTypeChecker::endVisit(Mapping const& _mapping)
 	// key type is checked in TVMTypeChecker::visit(const Mapping &_mapping)
 
 	Type const* keyType = _mapping.keyType().annotation().type;
+	ASTString keyName = _mapping.keyName();
+
 	Type const* valueType = _mapping.valueType().annotation().type;
+	ASTString valueName = _mapping.valueName();
 
-	// Convert key type to memory.
-	keyType = TypeProvider::withLocationIfReference(keyType);
+	_mapping.annotation().type = TypeProvider::mapping(keyType, keyName, valueType, valueName);
 
-	// Convert value type to storage reference.
-	valueType = TypeProvider::withLocationIfReference(valueType);
-	_mapping.annotation().type = TypeProvider::mapping(keyType, valueType);
+	// Check if parameter names are conflicting.
+	if (!keyName.empty())
+	{
+		auto childMappingType = dynamic_cast<MappingType const*>(valueType);
+		ASTString currentValueName = valueName;
+		bool loop = true;
+		while (loop)
+		{
+			bool isError = false;
+			// Value type is a mapping.
+			if (childMappingType)
+			{
+				// Compare top mapping's key name with child mapping's key name.
+				ASTString childKeyName = childMappingType->keyName();
+				if (keyName == childKeyName)
+					isError = true;
+
+				auto valueType = childMappingType->valueType();
+				currentValueName = childMappingType->valueName();
+				childMappingType = dynamic_cast<MappingType const*>(valueType);
+			}
+			else
+			{
+				// Compare top mapping's key name with the value name.
+				if (keyName == currentValueName)
+					isError = true;
+
+				loop = false; // We arrived at the end of mapping recursion.
+			}
+
+			// Report error.
+			if (isError)
+			{
+				m_errorReporter.declarationError(
+					1809_error,
+					_mapping.location(),
+					"Conflicting parameter name \"" + keyName + "\" in mapping."
+				);
+			}
+		}
+	}
 }
 
 void DeclarationTypeChecker::endVisit(Optional const& _optional)
@@ -272,10 +311,10 @@ void DeclarationTypeChecker::endVisit(ArrayTypeName const& _typeName)
 
 	if (Expression const* length = _typeName.length())
 	{
-		optional<rational> lengthValue;
+		std::optional<rational> lengthValue;
 		if (length->annotation().type && length->annotation().type->category() == Type::Category::RationalNumber)
 			lengthValue = dynamic_cast<RationalNumberType const&>(*length->annotation().type).value();
-		else if (optional<ConstantEvaluator::TypedRational> value = ConstantEvaluator::evaluate(m_errorReporter, *length))
+		else if (std::optional<ConstantEvaluator::TypedRational> value = ConstantEvaluator::evaluate(m_errorReporter, *length))
 			lengthValue = value->value;
 
 		if (!lengthValue)
@@ -331,12 +370,6 @@ void DeclarationTypeChecker::endVisit(VariableDeclaration const& _variable)
 		);
 
 	Type const* type = _variable.typeName().annotation().type;
-	if (auto ref = dynamic_cast<ReferenceType const*>(type))
-	{
-		bool isPointer = !_variable.isStateVariable();
-		type = TypeProvider::withLocation(ref, isPointer);
-	}
-
 	_variable.annotation().type = type;
 }
 
@@ -354,7 +387,7 @@ bool DeclarationTypeChecker::visit(UsingForDirective const& _usingFor)
 					m_errorReporter.typeError(
 						4167_error,
 						function->location(),
-						"Only file-level functions and library functions can be bound to a type in a \"using\" statement"
+						"Only file-level functions and library functions can be attached to a type in a \"using\" statement"
 					);
 			}
 			else
diff --git a/compiler/libsolidity/analysis/DocStringAnalyser.cpp b/compiler/libsolidity/analysis/DocStringAnalyser.cpp
index 5cff34f2..d4afadf2 100644
--- a/compiler/libsolidity/analysis/DocStringAnalyser.cpp
+++ b/compiler/libsolidity/analysis/DocStringAnalyser.cpp
@@ -30,7 +30,6 @@
 
 #include <boost/algorithm/string.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -38,7 +37,7 @@ using namespace solidity::frontend;
 namespace
 {
 
-void copyMissingTags(set<CallableDeclaration const*> const& _baseFunctions, StructurallyDocumentedAnnotation& _target, FunctionType const* _functionType = nullptr)
+void copyMissingTags(std::set<CallableDeclaration const*> const& _baseFunctions, StructurallyDocumentedAnnotation& _target, FunctionType const* _functionType = nullptr)
 {
 	// Only copy if there is exactly one direct base function.
 	if (_baseFunctions.size() != 1)
@@ -50,7 +49,7 @@ void copyMissingTags(set<CallableDeclaration const*> const& _baseFunctions, Stru
 
 	for (auto it = sourceDoc.docTags.begin(); it != sourceDoc.docTags.end();)
 	{
-		string const& tag = it->first;
+		std::string const& tag = it->first;
 		// Don't copy tag "inheritdoc", custom tags or already existing tags
 		if (tag == "inheritdoc" || _target.docTags.count(tag) || boost::starts_with(tag, "custom"))
 		{
@@ -68,7 +67,7 @@ void copyMissingTags(set<CallableDeclaration const*> const& _baseFunctions, Stru
 			if (_functionType && tag == "return")
 			{
 				size_t docParaNameEndPos = content.content.find_first_of(" \t");
-				string const docParameterName = content.content.substr(0, docParaNameEndPos);
+				std::string const docParameterName = content.content.substr(0, docParaNameEndPos);
 
 				if (
 					_functionType->returnParameterNames().size() > n &&
@@ -80,10 +79,10 @@ void copyMissingTags(set<CallableDeclaration const*> const& _baseFunctions, Stru
 						baseFunction.returnParameters().size() > n &&
 						baseFunction.returnParameters().at(n)->name().empty();
 
-					string paramName = _functionType->returnParameterNames().at(n);
+					std::string paramName = _functionType->returnParameterNames().at(n);
 					content.content =
 						(paramName.empty() ? "" : std::move(paramName) + " ") + (
-							string::npos == docParaNameEndPos || baseHasNoName ?
+							std::string::npos == docParaNameEndPos || baseHasNoName ?
 							content.content :
 							content.content.substr(docParaNameEndPos + 1)
 						);
@@ -95,7 +94,7 @@ void copyMissingTags(set<CallableDeclaration const*> const& _baseFunctions, Stru
 	}
 }
 
-CallableDeclaration const* findBaseCallable(set<CallableDeclaration const*> const& _baseFunctions, int64_t _contractId)
+CallableDeclaration const* findBaseCallable(std::set<CallableDeclaration const*> const& _baseFunctions, int64_t _contractId)
 {
 	for (CallableDeclaration const* baseFuncCandidate: _baseFunctions)
 		if (baseFuncCandidate->annotation().contract->id() == _contractId)
@@ -181,7 +180,7 @@ void DocStringAnalyser::handleCallable(
 }
 
 CallableDeclaration const* DocStringAnalyser::resolveInheritDoc(
-	set<CallableDeclaration const*> const& _baseFuncs,
+	std::set<CallableDeclaration const*> const& _baseFuncs,
 	StructurallyDocumented const& _node,
 	StructurallyDocumentedAnnotation& _annotation
 )
diff --git a/compiler/libsolidity/analysis/DocStringTagParser.cpp b/compiler/libsolidity/analysis/DocStringTagParser.cpp
index 1dc2711e..5127b779 100644
--- a/compiler/libsolidity/analysis/DocStringTagParser.cpp
+++ b/compiler/libsolidity/analysis/DocStringTagParser.cpp
@@ -37,7 +37,6 @@
 #include <regex>
 #include <string_view>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -67,7 +66,7 @@ bool DocStringTagParser::validateDocStringsUsingTypes(SourceUnit const& _sourceU
 					if (tagName == "return")
 					{
 						returnTagsVisited++;
-						vector<string> returnParameterNames;
+						std::vector<std::string> returnParameterNames;
 
 						if (auto const* varDecl = dynamic_cast<VariableDeclaration const*>(&_node))
 						{
@@ -82,8 +81,8 @@ bool DocStringTagParser::validateDocStringsUsingTypes(SourceUnit const& _sourceU
 						else
 							continue;
 
-						string content = tagValue.content;
-						string firstWord = content.substr(0, content.find_first_of(" \t"));
+						std::string content = tagValue.content;
+						std::string firstWord = content.substr(0, content.find_first_of(" \t"));
 
 						if (returnTagsVisited > returnParameterNames.size())
 							m_errorReporter.docstringParsingError(
@@ -94,7 +93,7 @@ bool DocStringTagParser::validateDocStringsUsingTypes(SourceUnit const& _sourceU
 							);
 						else
 						{
-							string const& parameter = returnParameterNames.at(returnTagsVisited - 1);
+							std::string const& parameter = returnParameterNames.at(returnTagsVisited - 1);
 							if (!parameter.empty() && parameter != firstWord)
 								m_errorReporter.docstringParsingError(
 									5856_error,
@@ -113,7 +112,7 @@ bool DocStringTagParser::validateDocStringsUsingTypes(SourceUnit const& _sourceU
 
 bool DocStringTagParser::visit(ContractDefinition const& _contract)
 {
-	static set<string> const validTags = set<string>{"author", "title", "dev", "notice"};
+	static std::set<std::string> const validTags = std::set<std::string>{"author", "title", "dev", "notice"};
 	parseDocStrings(_contract, _contract.annotation(), validTags, "contracts");
 
 	return true;
@@ -163,88 +162,13 @@ bool DocStringTagParser::visit(ErrorDefinition const& _error)
 	return true;
 }
 
-bool DocStringTagParser::visit(InlineAssembly const& _assembly)
-{
-	if (!_assembly.documentation())
-		return true;
-	StructuredDocumentation documentation{-1, _assembly.location(), _assembly.documentation()};
-	ErrorList errors;
-	ErrorReporter errorReporter{errors};
-	auto docTags = DocStringParser{documentation, errorReporter}.parse();
-
-	if (!errors.empty())
-	{
-		SecondarySourceLocation ssl;
-		for (auto const& error: errors)
-			if (error->comment())
-				ssl.append(
-					*error->comment(),
-					_assembly.location()
-				);
-		m_errorReporter.warning(
-			7828_error,
-			_assembly.location(),
-			"Inline assembly has invalid NatSpec documentation.",
-			ssl
-		);
-	}
-
-	for (auto const& [tagName, tagValue]: docTags)
-	{
-		if (tagName == "solidity")
-		{
-			vector<string> values;
-			boost::split(values, tagValue.content, isWhiteSpace);
-
-			set<string> valuesSeen;
-			set<string> duplicates;
-			for (auto const& value: values | ranges::views::filter(not_fn(&string::empty)))
-				if (valuesSeen.insert(value).second)
-				{
-					if (value == "memory-safe-assembly")
-					{
-						if (_assembly.annotation().markedMemorySafe)
-							m_errorReporter.warning(
-								8544_error,
-								_assembly.location(),
-								"Inline assembly marked as memory safe using both a NatSpec tag and an assembly flag. "
-								"If you are not concerned with backwards compatibility, only use the assembly flag, "
-								"otherwise only use the NatSpec tag."
-							);
-						_assembly.annotation().markedMemorySafe = true;
-					}
-					else
-						m_errorReporter.warning(
-							8787_error,
-							_assembly.location(),
-							"Unexpected value for @solidity tag in inline assembly: " + value
-						);
-				}
-				else if (duplicates.insert(value).second)
-					m_errorReporter.warning(
-						4377_error,
-						_assembly.location(),
-						"Value for @solidity tag in inline assembly specified multiple times: " + value
-					);
-		}
-		else
-			m_errorReporter.warning(
-				6269_error,
-				_assembly.location(),
-				"Unexpected NatSpec tag \"" + tagName + "\" with value \"" + tagValue.content + "\" in inline assembly."
-			);
-	}
-
-	return true;
-}
-
 void DocStringTagParser::checkParameters(
 	CallableDeclaration const& _callable,
 	StructurallyDocumented const& _node,
 	StructurallyDocumentedAnnotation& _annotation
 )
 {
-	set<string> validParams;
+	std::set<std::string> validParams;
 	for (auto const& p: _callable.parameters())
 		validParams.insert(p->name());
 	if (_callable.returnParameterList())
@@ -268,7 +192,7 @@ void DocStringTagParser::handleConstructor(
 	StructurallyDocumentedAnnotation& _annotation
 )
 {
-	static set<string> const validTags = set<string>{"author", "dev", "notice", "param"};
+	static std::set<std::string> const validTags = std::set<std::string>{"author", "dev", "notice", "param"};
 	parseDocStrings(_node, _annotation, validTags, "constructor");
 	checkParameters(_callable, _node, _annotation);
 }
@@ -279,10 +203,10 @@ void DocStringTagParser::handleCallable(
 	StructurallyDocumentedAnnotation& _annotation
 )
 {
-	static set<string> const validEventTags = set<string>{"dev", "notice", "return", "param"};
-	static set<string> const validErrorTags = set<string>{"dev", "notice", "param"};
-	static set<string> const validModifierTags = set<string>{"dev", "notice", "param", "inheritdoc"};
-	static set<string> const validTags = set<string>{"dev", "notice", "return", "param", "inheritdoc"};
+	static std::set<std::string> const validEventTags = std::set<std::string>{"dev", "notice", "return", "param"};
+	static std::set<std::string> const validErrorTags = std::set<std::string>{"dev", "notice", "param"};
+	static std::set<std::string> const validModifierTags = std::set<std::string>{"dev", "notice", "param", "inheritdoc"};
+	static std::set<std::string> const validTags = std::set<std::string>{"dev", "notice", "return", "param", "inheritdoc"};
 
 	if (dynamic_cast<EventDefinition const*>(&_callable))
 		parseDocStrings(_node, _annotation, validEventTags, "events");
@@ -299,8 +223,8 @@ void DocStringTagParser::handleCallable(
 void DocStringTagParser::parseDocStrings(
 	StructurallyDocumented const& _node,
 	StructurallyDocumentedAnnotation& _annotation,
-	set<string> const& _validTags,
-	string const& _nodeName
+	std::set<std::string> const& _validTags,
+	std::string const& _nodeName
 )
 {
 	if (!_node.documentation())
@@ -310,7 +234,7 @@ void DocStringTagParser::parseDocStrings(
 
 	for (auto const& [tagName, tagValue]: _annotation.docTags)
 	{
-		string_view static constexpr customPrefix("custom:");
+		std::string_view static constexpr customPrefix("custom:");
 		if (tagName == "custom" || tagName == "custom:")
 			m_errorReporter.docstringParsingError(
 				6564_error,
@@ -319,7 +243,7 @@ void DocStringTagParser::parseDocStrings(
 			);
 		else if (boost::starts_with(tagName, customPrefix) && tagName.size() > customPrefix.size())
 		{
-			regex static const customRegex("^custom:[a-z][a-z-]*$");
+			std::regex static const customRegex("^custom:[a-z][a-z-]*$");
 			if (!regex_match(tagName, customRegex))
 				m_errorReporter.docstringParsingError(
 					2968_error,
diff --git a/compiler/libsolidity/analysis/DocStringTagParser.h b/compiler/libsolidity/analysis/DocStringTagParser.h
index 248befcb..84fde6c6 100644
--- a/compiler/libsolidity/analysis/DocStringTagParser.h
+++ b/compiler/libsolidity/analysis/DocStringTagParser.h
@@ -48,7 +48,6 @@ class DocStringTagParser: private ASTConstVisitor
 	bool visit(ModifierDefinition const& _modifier) override;
 	bool visit(EventDefinition const& _event) override;
 	bool visit(ErrorDefinition const& _error) override;
-	bool visit(InlineAssembly const& _assembly) override;
 
 	void checkParameters(
 		CallableDeclaration const& _callable,
diff --git a/compiler/libsolidity/analysis/FunctionCallGraph.cpp b/compiler/libsolidity/analysis/FunctionCallGraph.cpp
index e941c99c..1d01f1a6 100644
--- a/compiler/libsolidity/analysis/FunctionCallGraph.cpp
+++ b/compiler/libsolidity/analysis/FunctionCallGraph.cpp
@@ -24,7 +24,6 @@
 #include <range/v3/view/reverse.hpp>
 #include <range/v3/view/transform.hpp>
 
-using namespace std;
 using namespace solidity::frontend;
 using namespace solidity::util;
 
@@ -72,7 +71,7 @@ CallGraph FunctionCallGraphBuilder::buildDeployedGraph(
 	FunctionCallGraphBuilder builder(_contract);
 	solAssert(builder.m_currentNode == CallGraph::Node(CallGraph::SpecialNode::Entry), "");
 
-	auto getSecondElement = [](auto const& _tuple){ return get<1>(_tuple); };
+	auto getSecondElement = [](auto const& _tuple){ return std::get<1>(_tuple); };
 
 	// Create graph for all publicly reachable functions
 	for (FunctionTypePointer functionType: _contract.interfaceFunctionList() | ranges::views::transform(getSecondElement))
@@ -96,14 +95,14 @@ CallGraph FunctionCallGraphBuilder::buildDeployedGraph(
 	// All functions present in internal dispatch at creation time could potentially be pointers
 	// assigned to state variables and as such may be reachable after deployment as well.
 	builder.m_currentNode = CallGraph::SpecialNode::InternalDispatch;
-	set<CallGraph::Node, CallGraph::CompareByID> defaultNode;
+	std::set<CallGraph::Node, CallGraph::CompareByID> defaultNode;
 	for (CallGraph::Node const& dispatchTarget: util::valueOrDefault(_creationGraph.edges, CallGraph::SpecialNode::InternalDispatch, defaultNode))
 	{
-		solAssert(!holds_alternative<CallGraph::SpecialNode>(dispatchTarget), "");
-		solAssert(get<CallableDeclaration const*>(dispatchTarget) != nullptr, "");
+		solAssert(!std::holds_alternative<CallGraph::SpecialNode>(dispatchTarget), "");
+		solAssert(std::get<CallableDeclaration const*>(dispatchTarget) != nullptr, "");
 
 		// Visit the callable to add not only it but also everything it calls too
-		builder.functionReferenced(*get<CallableDeclaration const*>(dispatchTarget), false);
+		builder.functionReferenced(*std::get<CallableDeclaration const*>(dispatchTarget), false);
 	}
 
 	builder.m_currentNode = CallGraph::SpecialNode::Entry;
@@ -204,6 +203,20 @@ bool FunctionCallGraphBuilder::visit(MemberAccess const& _memberAccess)
 	return true;
 }
 
+bool FunctionCallGraphBuilder::visit(BinaryOperation const& _binaryOperation)
+{
+	if (*_binaryOperation.annotation().userDefinedFunction != nullptr)
+		functionReferenced(**_binaryOperation.annotation().userDefinedFunction, true /* called directly */);
+	return true;
+}
+
+bool FunctionCallGraphBuilder::visit(UnaryOperation const& _unaryOperation)
+{
+	if (*_unaryOperation.annotation().userDefinedFunction != nullptr)
+		functionReferenced(**_unaryOperation.annotation().userDefinedFunction, true /* called directly */);
+	return true;
+}
+
 bool FunctionCallGraphBuilder::visit(ModifierInvocation const& _modifierInvocation)
 {
 	if (auto const* modifier = dynamic_cast<ModifierDefinition const*>(_modifierInvocation.name().annotation().referencedDeclaration))
@@ -248,10 +261,10 @@ void FunctionCallGraphBuilder::processQueue()
 	while (!m_visitQueue.empty())
 	{
 		m_currentNode = m_visitQueue.front();
-		solAssert(holds_alternative<CallableDeclaration const*>(m_currentNode), "");
+		solAssert(std::holds_alternative<CallableDeclaration const*>(m_currentNode), "");
 
 		m_visitQueue.pop_front();
-		get<CallableDeclaration const*>(m_currentNode)->accept(*this);
+		std::get<CallableDeclaration const*>(m_currentNode)->accept(*this);
 	}
 
 	m_currentNode = CallGraph::SpecialNode::Entry;
@@ -267,7 +280,7 @@ void FunctionCallGraphBuilder::functionReferenced(CallableDeclaration const& _ca
 	if (_calledDirectly)
 	{
 		solAssert(
-			holds_alternative<CallGraph::SpecialNode>(m_currentNode) || m_graph.edges.count(m_currentNode) > 0,
+			std::holds_alternative<CallGraph::SpecialNode>(m_currentNode) || m_graph.edges.count(m_currentNode) > 0,
 			"Adding an edge from a node that has not been visited yet."
 		);
 
@@ -279,10 +292,10 @@ void FunctionCallGraphBuilder::functionReferenced(CallableDeclaration const& _ca
 	enqueueCallable(_callable);
 }
 
-ostream& solidity::frontend::operator<<(ostream& _out, CallGraph::Node const& _node)
+std::ostream& solidity::frontend::operator<<(std::ostream& _out, CallGraph::Node const& _node)
 {
-	if (holds_alternative<CallGraph::SpecialNode>(_node))
-		switch (get<CallGraph::SpecialNode>(_node))
+	if (std::holds_alternative<CallGraph::SpecialNode>(_node))
+		switch (std::get<CallGraph::SpecialNode>(_node))
 		{
 		case CallGraph::SpecialNode::InternalDispatch:
 			_out << "InternalDispatch";
@@ -295,19 +308,19 @@ ostream& solidity::frontend::operator<<(ostream& _out, CallGraph::Node const& _n
 		}
 	else
 	{
-		solAssert(holds_alternative<CallableDeclaration const*>(_node), "");
+		solAssert(std::holds_alternative<CallableDeclaration const*>(_node), "");
 
-		auto const* callableDeclaration = get<CallableDeclaration const*>(_node);
+		auto const* callableDeclaration = std::get<CallableDeclaration const*>(_node);
 		solAssert(callableDeclaration, "");
 
 		auto const* function = dynamic_cast<FunctionDefinition const *>(callableDeclaration);
 		auto const* event = dynamic_cast<EventDefinition const *>(callableDeclaration);
 		auto const* modifier = dynamic_cast<ModifierDefinition const *>(callableDeclaration);
 
-		auto typeToString = [](auto const& _var) -> string { return _var->type()->toString(true); };
-		vector<string> parameters = callableDeclaration->parameters() | ranges::views::transform(typeToString) | ranges::to<vector<string>>();
+		auto typeToString = [](auto const& _var) -> std::string { return _var->type()->toString(true); };
+		std::vector<std::string> parameters = callableDeclaration->parameters() | ranges::views::transform(typeToString) | ranges::to<std::vector<std::string>>();
 
-		string scopeName;
+		std::string scopeName;
 		if (!function || !function->isFree())
 		{
 			solAssert(callableDeclaration->annotation().scope, "");
diff --git a/compiler/libsolidity/analysis/FunctionCallGraph.h b/compiler/libsolidity/analysis/FunctionCallGraph.h
index 3ea1f5b9..a4e5787a 100644
--- a/compiler/libsolidity/analysis/FunctionCallGraph.h
+++ b/compiler/libsolidity/analysis/FunctionCallGraph.h
@@ -72,6 +72,8 @@ class FunctionCallGraphBuilder: private ASTConstVisitor
 	bool visit(EmitStatement const& _emitStatement) override;
 	bool visit(Identifier const& _identifier) override;
 	bool visit(MemberAccess const& _memberAccess) override;
+	bool visit(BinaryOperation const& _binaryOperation) override;
+	bool visit(UnaryOperation const& _unaryOperation) override;
 	bool visit(ModifierInvocation const& _modifierInvocation) override;
 	bool visit(NewExpression const& _newExpression) override;
 
diff --git a/compiler/libsolidity/analysis/GlobalContext.cpp b/compiler/libsolidity/analysis/GlobalContext.cpp
index 51a75292..1976525e 100644
--- a/compiler/libsolidity/analysis/GlobalContext.cpp
+++ b/compiler/libsolidity/analysis/GlobalContext.cpp
@@ -29,8 +29,6 @@
 #include <libsolidity/ast/Types.h>
 #include <memory>
 
-using namespace std;
-
 namespace solidity::frontend
 {
 
@@ -67,6 +65,7 @@ int magicVariableToID(std::string const& _name)
 	else if (_name == "tx") return -26;
 	else if (_name == "type") return -27;
 	else if (_name == "this") return -28;
+	else if (_name == "blobhash") return -29;
 	else if (_name == "gasToValue") return -60;
 	else if (_name == "valueToGas") return -61;
 	else if (_name == "bitSize") return -62;
@@ -75,13 +74,13 @@ int magicVariableToID(std::string const& _name)
 		solAssert(false, "Unknown magic variable: \"" + _name + "\".");
 }
 
-inline vector<shared_ptr<MagicVariableDeclaration const>> constructMagicVariables()
+inline std::vector<std::shared_ptr<MagicVariableDeclaration const>> constructMagicVariables(langutil::EVMVersion _evmVersion)
 {
-	static auto const magicVarDecl = [](string const& _name, Type const* _type) {
-		return make_shared<MagicVariableDeclaration>(magicVariableToID(_name), _name, _type);
+	static auto const magicVarDecl = [](std::string const& _name, Type const* _type) {
+		return std::make_shared<MagicVariableDeclaration>(magicVariableToID(_name), _name, _type);
 	};
 
-	return {
+	std::vector<std::shared_ptr<MagicVariableDeclaration const>> magicVariableDeclarations = {
 		magicVarDecl("abi", TypeProvider::magic(MagicType::Kind::ABI)),
 		magicVarDecl("addmod", TypeProvider::function(strings{"uint256", "uint256", "uint256"}, strings{"uint256"}, FunctionType::Kind::AddMod, StateMutability::Pure)),
 		magicVarDecl("assert", TypeProvider::function(strings{"bool"}, strings{}, FunctionType::Kind::Assert, StateMutability::Pure)),
@@ -103,8 +102,8 @@ inline vector<shared_ptr<MagicVariableDeclaration const>> constructMagicVariable
 		magicVarDecl("stoi", TypeProvider::function(
 				TypePointers{TypeProvider::stringStorage()},
 				TypePointers{TypeProvider::optional(TypeProvider::integer(256, IntegerType::Modifier::Signed))},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::Stoi,
 				StateMutability::Pure)
 				),
@@ -126,11 +125,19 @@ inline vector<shared_ptr<MagicVariableDeclaration const>> constructMagicVariable
 		magicVarDecl("bitSize", TypeProvider::function({"int"}, {"uint16"}, FunctionType::Kind::BitSize, StateMutability::Pure)),
 		magicVarDecl("uBitSize", TypeProvider::function({"uint"}, {"uint16"}, FunctionType::Kind::UBitSize, StateMutability::Pure)),
 	};
+
+	if (_evmVersion >= langutil::EVMVersion::cancun())
+		magicVariableDeclarations.push_back(
+			magicVarDecl("blobhash", TypeProvider::function(strings{"uint256"}, strings{"bytes32"}, FunctionType::Kind::BlobHash, StateMutability::View))
+		);
+
+	return magicVariableDeclarations;
 }
 
 }
 
-GlobalContext::GlobalContext(): m_magicVariables{constructMagicVariables()}
+GlobalContext::GlobalContext(langutil::EVMVersion _evmVersion):
+	m_magicVariables{constructMagicVariables(_evmVersion)}
 {
 }
 
@@ -139,9 +146,9 @@ void GlobalContext::setCurrentContract(ContractDefinition const& _contract)
 	m_currentContract = &_contract;
 }
 
-vector<Declaration const*> GlobalContext::declarations() const
+std::vector<Declaration const*> GlobalContext::declarations() const
 {
-	vector<Declaration const*> declarations;
+	std::vector<Declaration const*> declarations;
 	declarations.reserve(m_magicVariables.size());
 	for (ASTPointer<MagicVariableDeclaration const> const& variable: m_magicVariables)
 		declarations.push_back(variable.get());
@@ -156,7 +163,7 @@ MagicVariableDeclaration const* GlobalContext::currentThis() const
 		if (m_currentContract)
 			type = TypeProvider::contract(*m_currentContract);
 		m_thisPointer[m_currentContract] =
-			make_shared<MagicVariableDeclaration>(magicVariableToID("this"), "this", type);
+			std::make_shared<MagicVariableDeclaration>(magicVariableToID("this"), "this", type);
 	}
 	return m_thisPointer[m_currentContract].get();
 }
@@ -169,7 +176,7 @@ MagicVariableDeclaration const* GlobalContext::currentSuper() const
 		if (m_currentContract)
 			type = TypeProvider::typeType(TypeProvider::contract(*m_currentContract, true));
 		m_superPointer[m_currentContract] =
-			make_shared<MagicVariableDeclaration>(magicVariableToID("super"), "super", type);
+			std::make_shared<MagicVariableDeclaration>(magicVariableToID("super"), "super", type);
 	}
 	return m_superPointer[m_currentContract].get();
 }
diff --git a/compiler/libsolidity/analysis/GlobalContext.h b/compiler/libsolidity/analysis/GlobalContext.h
index 69344537..3aa5e76e 100644
--- a/compiler/libsolidity/analysis/GlobalContext.h
+++ b/compiler/libsolidity/analysis/GlobalContext.h
@@ -23,6 +23,7 @@
 
 #pragma once
 
+#include <liblangutil/EVMVersion.h>
 #include <libsolidity/ast/ASTForward.h>
 #include <map>
 #include <memory>
@@ -47,7 +48,7 @@ class GlobalContext
 	GlobalContext(GlobalContext const&) = delete;
 	GlobalContext& operator=(GlobalContext const&) = delete;
 
-	GlobalContext();
+	GlobalContext(langutil::EVMVersion _evmVersion);
 	void setCurrentContract(ContractDefinition const& _contract);
 	void resetCurrentContract() { m_currentContract = nullptr; }
 	MagicVariableDeclaration const* currentThis() const;
diff --git a/compiler/libsolidity/analysis/ImmutableValidator.cpp b/compiler/libsolidity/analysis/ImmutableValidator.cpp
index 485aa3fa..0f5a2ee2 100644
--- a/compiler/libsolidity/analysis/ImmutableValidator.cpp
+++ b/compiler/libsolidity/analysis/ImmutableValidator.cpp
@@ -18,8 +18,6 @@
 
 #include <libsolidity/analysis/ImmutableValidator.h>
 
-#include <libsolutil/CommonData.h>
-
 #include <range/v3/view/reverse.hpp>
 
 using namespace solidity::frontend;
@@ -27,256 +25,44 @@ using namespace solidity::langutil;
 
 void ImmutableValidator::analyze()
 {
-	m_inCreationContext = true;
-
 	auto linearizedContracts = m_mostDerivedContract.annotation().linearizedBaseContracts | ranges::views::reverse;
 
-	for (ContractDefinition const* contract: linearizedContracts)
-		for (VariableDeclaration const* stateVar: contract->stateVariables())
-			if (stateVar->value())
-				stateVar->value()->accept(*this);
-
-	for (ContractDefinition const* contract: linearizedContracts)
-		for (std::shared_ptr<InheritanceSpecifier> const& inheritSpec: contract->baseContracts())
-			if (auto args = inheritSpec->arguments())
-				ASTNode::listAccept(*args, *this);
-
 	for (ContractDefinition const* contract: linearizedContracts)
 	{
-		for (VariableDeclaration const* stateVar: contract->stateVariables())
-			if (stateVar->value())
-				m_initializedStateVariables.emplace(stateVar);
+		for (FunctionDefinition const* function: contract->definedFunctions())
+			function->accept(*this);
 
-		if (contract->constructor())
-			visitCallableIfNew(*contract->constructor());
+		for (ModifierDefinition const* modifier: contract->functionModifiers())
+			modifier->accept(*this);
 	}
-
-	m_inCreationContext = false;
-
-	for (ContractDefinition const* contract: linearizedContracts)
-	{
-		for (auto funcDef: contract->definedFunctions())
-			visitCallableIfNew(*funcDef);
-
-		for (auto modDef: contract->functionModifiers())
-			visitCallableIfNew(*modDef);
-	}
-
-	checkAllVariablesInitialized(m_mostDerivedContract.location());
 }
 
-bool ImmutableValidator::visit(Assignment const& _assignment)
-{
-	// Need to visit values first (rhs) as they might access other immutables.
-	_assignment.rightHandSide().accept(*this);
-	_assignment.leftHandSide().accept(*this);
-	return false;
-}
-
-
 bool ImmutableValidator::visit(FunctionDefinition const& _functionDefinition)
 {
-	return analyseCallable(_functionDefinition);
-}
-
-bool ImmutableValidator::visit(ModifierDefinition const& _modifierDefinition)
-{
-	return analyseCallable(_modifierDefinition);
-}
-
-bool ImmutableValidator::visit(MemberAccess const& _memberAccess)
-{
-	_memberAccess.expression().accept(*this);
-
-	if (auto contractType = dynamic_cast<ContractType const*>(_memberAccess.expression().annotation().type))
-		if (!contractType->isSuper())
-			// external access, no analysis needed.
-			return false;
-
-	if (auto varDecl = dynamic_cast<VariableDeclaration const*>(_memberAccess.annotation().referencedDeclaration))
-		analyseVariableReference(*varDecl, _memberAccess);
-	else if (auto funcType = dynamic_cast<FunctionType const*>(_memberAccess.annotation().type))
-		if (funcType->kind() == FunctionType::Kind::Internal && funcType->hasDeclaration())
-			visitCallableIfNew(funcType->declaration());
-
-	return false;
-}
-
-bool ImmutableValidator::visit(IfStatement const& _ifStatement)
-{
-	bool prevInBranch = m_inBranch;
-
-	_ifStatement.condition().accept(*this);
-
-	m_inBranch = true;
-	_ifStatement.trueStatement().accept(*this);
-
-	if (auto falseStatement = _ifStatement.falseStatement())
-		falseStatement->accept(*this);
-
-	m_inBranch = prevInBranch;
-
-	return false;
-}
-
-bool ImmutableValidator::visit(WhileStatement const& _whileStatement)
-{
-	bool prevInLoop = m_inLoop;
-	m_inLoop = true;
-
-	_whileStatement.condition().accept(*this);
-	_whileStatement.body().accept(*this);
-
-	m_inLoop = prevInLoop;
-
-	return false;
+	return !_functionDefinition.isConstructor();
 }
 
-void ImmutableValidator::endVisit(IdentifierPath const& _identifierPath)
+void ImmutableValidator::endVisit(MemberAccess const& _memberAccess)
 {
-	if (auto const callableDef = dynamic_cast<CallableDeclaration const*>(_identifierPath.annotation().referencedDeclaration))
-		visitCallableIfNew(
-			*_identifierPath.annotation().requiredLookup == VirtualLookup::Virtual ?
-			callableDef->resolveVirtual(m_mostDerivedContract) :
-			*callableDef
-		);
-
-	solAssert(!dynamic_cast<VariableDeclaration const*>(_identifierPath.annotation().referencedDeclaration), "");
+	analyseVariableReference(_memberAccess.annotation().referencedDeclaration, _memberAccess);
 }
 
 void ImmutableValidator::endVisit(Identifier const& _identifier)
 {
-	if (auto const callableDef = dynamic_cast<CallableDeclaration const*>(_identifier.annotation().referencedDeclaration))
-		visitCallableIfNew(*_identifier.annotation().requiredLookup == VirtualLookup::Virtual ? callableDef->resolveVirtual(m_mostDerivedContract) : *callableDef);
-	if (auto const varDecl = dynamic_cast<VariableDeclaration const*>(_identifier.annotation().referencedDeclaration))
-		analyseVariableReference(*varDecl, _identifier);
+	analyseVariableReference(_identifier.annotation().referencedDeclaration, _identifier);
 }
 
-void ImmutableValidator::endVisit(Return const& _return)
+void ImmutableValidator::analyseVariableReference(Declaration const* _reference, Expression const& _expression)
 {
-	if (m_currentConstructor != nullptr)
-		checkAllVariablesInitialized(_return.location());
-}
-
-bool ImmutableValidator::analyseCallable(CallableDeclaration const& _callableDeclaration)
-{
-	ScopedSaveAndRestore constructorGuard{m_currentConstructor, {}};
-	ScopedSaveAndRestore constructorContractGuard{m_currentConstructorContract, {}};
-
-	if (FunctionDefinition const* funcDef = dynamic_cast<decltype(funcDef)>(&_callableDeclaration))
-	{
-		ASTNode::listAccept(funcDef->modifiers(), *this);
-
-		if (funcDef->isConstructor())
-		{
-			m_currentConstructorContract = funcDef->annotation().contract;
-			m_currentConstructor = funcDef;
-		}
-
-		if (funcDef->isImplemented())
-			funcDef->body().accept(*this);
-	}
-	else if (ModifierDefinition const* modDef = dynamic_cast<decltype(modDef)>(&_callableDeclaration))
-		if (modDef->isImplemented())
-			modDef->body().accept(*this);
-
-	return false;
-}
-
-void ImmutableValidator::analyseVariableReference(VariableDeclaration const& _variableReference, Expression const& _expression)
-{
-	if (!_variableReference.isStateVariable() || !_variableReference.immutable())
+	auto const* variable = dynamic_cast<VariableDeclaration const*>(_reference);
+	if (!variable || !variable->isStateVariable() || !variable->immutable())
 		return;
 
 	// If this is not an ordinary assignment, we write and read at the same time.
-	bool write = _expression.annotation().willBeWrittenTo;
-	bool read = !_expression.annotation().willBeWrittenTo || !_expression.annotation().lValueOfOrdinaryAssignment;
-	if (write)
-	{
-		if (!m_currentConstructor)
-			m_errorReporter.typeError(
-				1581_error,
-				_expression.location(),
-				"Cannot write to immutable here: Immutable variables can only be initialized inline or assigned directly in the constructor."
-			);
-		else if (m_currentConstructor->annotation().contract->id() != _variableReference.annotation().contract->id())
-			m_errorReporter.typeError(
-				7484_error,
-				_expression.location(),
-				"Cannot write to immutable here: Immutable variables must be initialized in the constructor of the contract they are defined in."
-			);
-		else if (m_inLoop)
-			m_errorReporter.typeError(
-				6672_error,
-				_expression.location(),
-				"Cannot write to immutable here: Immutable variables cannot be initialized inside a loop."
-			);
-		else if (m_inBranch)
-			m_errorReporter.typeError(
-				4599_error,
-				_expression.location(),
-				"Cannot write to immutable here: Immutable variables cannot be initialized inside an if statement."
-			);
-		else if (m_initializedStateVariables.count(&_variableReference))
-		{
-			if (!read)
-				m_errorReporter.typeError(
-					1574_error,
-					_expression.location(),
-					"Immutable state variable already initialized."
-				);
-			else
-				m_errorReporter.typeError(
-					2718_error,
-					_expression.location(),
-					"Immutable variables cannot be modified after initialization."
-				);
-		}
-		else if (read)
-			m_errorReporter.typeError(
-				3969_error,
-				_expression.location(),
-				"Immutable variables must be initialized using an assignment."
-			);
-		m_initializedStateVariables.emplace(&_variableReference);
-	}
-	if (
-		read &&
-		m_inCreationContext &&
-		!m_initializedStateVariables.count(&_variableReference)
-	)
+	if (_expression.annotation().willBeWrittenTo)
 		m_errorReporter.typeError(
-			7733_error,
+			1581_error,
 			_expression.location(),
-			"Immutable variables cannot be read before they are initialized."
+			"Cannot write to immutable here: Immutable variables can only be initialized inline or assigned directly in the constructor."
 		);
 }
-
-void ImmutableValidator::checkAllVariablesInitialized(solidity::langutil::SourceLocation const& _location)
-{
-	for (ContractDefinition const* contract: m_mostDerivedContract.annotation().linearizedBaseContracts | ranges::views::reverse)
-	{
-		for (VariableDeclaration const* varDecl: contract->stateVariables())
-			if (varDecl->immutable())
-				if (!util::contains(m_initializedStateVariables, varDecl))
-					m_errorReporter.typeError(
-						2658_error,
-						_location,
-						solidity::langutil::SecondarySourceLocation().append("Not initialized: ", varDecl->location()),
-						"Construction control flow ends without initializing all immutable state variables."
-					);
-
-		// Don't check further than the current c'tors contract
-		if (contract == m_currentConstructorContract)
-			break;
-	}
-}
-
-void ImmutableValidator::visitCallableIfNew(Declaration const& _declaration)
-{
-	CallableDeclaration const* _callable = dynamic_cast<CallableDeclaration const*>(&_declaration);
-	solAssert(_callable != nullptr, "");
-
-	if (m_visitedCallables.emplace(_callable).second)
-		_declaration.accept(*this);
-}
diff --git a/compiler/libsolidity/analysis/ImmutableValidator.h b/compiler/libsolidity/analysis/ImmutableValidator.h
index 452e91d7..78d85a61 100644
--- a/compiler/libsolidity/analysis/ImmutableValidator.h
+++ b/compiler/libsolidity/analysis/ImmutableValidator.h
@@ -21,25 +21,15 @@
 #include <libsolidity/ast/ASTVisitor.h>
 #include <liblangutil/ErrorReporter.h>
 
-#include <memory>
-
 namespace solidity::frontend
 {
 
 /**
  * Validates access and initialization of immutable variables:
- * must be directly initialized in their respective c'tor or inline
- * cannot be read before being initialized
- * cannot be read when initializing state variables inline
- * must be initialized outside loops (only one initialization)
- * must be initialized outside ifs (must be initialized unconditionally)
- * must be initialized exactly once (no multiple statements)
- * must be initialized exactly once (no early return to skip initialization)
+ * must be directly initialized in a c'tor or inline
 */
 class ImmutableValidator: private ASTConstVisitor
 {
-	using CallableDeclarationSet = std::set<CallableDeclaration const*, ASTNode::CompareByID>;
-
 public:
 	ImmutableValidator(langutil::ErrorReporter& _errorReporter, ContractDefinition const& _contractDefinition):
 		m_mostDerivedContract(_contractDefinition),
@@ -49,35 +39,15 @@ class ImmutableValidator: private ASTConstVisitor
 	void analyze();
 
 private:
-	bool visit(Assignment const& _assignment);
 	bool visit(FunctionDefinition const& _functionDefinition);
-	bool visit(ModifierDefinition const& _modifierDefinition);
-	bool visit(MemberAccess const& _memberAccess);
-	bool visit(IfStatement const& _ifStatement);
-	bool visit(WhileStatement const& _whileStatement);
-	void endVisit(IdentifierPath const& _identifierPath);
+	void endVisit(MemberAccess const& _memberAccess);
 	void endVisit(Identifier const& _identifier);
-	void endVisit(Return const& _return);
-
-	bool analyseCallable(CallableDeclaration const& _callableDeclaration);
-	void analyseVariableReference(VariableDeclaration const& _variableReference, Expression const& _expression);
 
-	void checkAllVariablesInitialized(langutil::SourceLocation const& _location);
-
-	void visitCallableIfNew(Declaration const& _declaration);
+	void analyseVariableReference(Declaration const* _variableReference, Expression const& _expression);
 
 	ContractDefinition const& m_mostDerivedContract;
 
-	CallableDeclarationSet m_visitedCallables;
-
-	std::set<VariableDeclaration const*, ASTNode::CompareByID> m_initializedStateVariables;
 	langutil::ErrorReporter& m_errorReporter;
-
-	FunctionDefinition const* m_currentConstructor = nullptr;
-	ContractDefinition const* m_currentConstructorContract = nullptr;
-	bool m_inLoop = false;
-	bool m_inBranch = false;
-	bool m_inCreationContext = true;
 };
 
 }
diff --git a/compiler/libsolidity/analysis/NameAndTypeResolver.cpp b/compiler/libsolidity/analysis/NameAndTypeResolver.cpp
index df657365..767e2707 100644
--- a/compiler/libsolidity/analysis/NameAndTypeResolver.cpp
+++ b/compiler/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -30,7 +30,6 @@
 #include <boost/algorithm/string.hpp>
 #include <unordered_set>
 
-using namespace std;
 using namespace solidity::langutil;
 
 namespace solidity::frontend
@@ -39,13 +38,15 @@ namespace solidity::frontend
 NameAndTypeResolver::NameAndTypeResolver(
 	GlobalContext& _globalContext,
 	langutil::EVMVersion _evmVersion,
-	ErrorReporter& _errorReporter
+	ErrorReporter& _errorReporter,
+	bool _experimentalSolidity
 ):
 	m_evmVersion(_evmVersion),
 	m_errorReporter(_errorReporter),
-	m_globalContext(_globalContext)
+	m_globalContext(_globalContext),
+	m_experimentalSolidity(_experimentalSolidity)
 {
-	m_scopes[nullptr] = make_shared<DeclarationContainer>();
+	m_scopes[nullptr] = std::make_shared<DeclarationContainer>();
 	for (Declaration const* declaration: _globalContext.declarations())
 	{
 		solAssert(m_scopes[nullptr]->registerDeclaration(*declaration, false, false), "Unable to register global declaration.");
@@ -68,14 +69,14 @@ bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit, ASTNode
 	return true;
 }
 
-bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, SourceUnit const*> const& _sourceUnits)
+bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, std::map<std::string, SourceUnit const*> const& _sourceUnits)
 {
 	DeclarationContainer& target = *m_scopes.at(&_sourceUnit);
 	bool error = false;
 	for (auto const& node: _sourceUnit.nodes())
 		if (auto imp = dynamic_cast<ImportDirective const*>(node.get()))
 		{
-			string const& path = *imp->annotation().absolutePath;
+			std::string const& path = *imp->annotation().absolutePath;
 			// The import resolution in CompilerStack enforces this.
 			solAssert(_sourceUnits.count(path), "");
 			auto scope = m_scopes.find(_sourceUnits.at(path));
@@ -127,7 +128,7 @@ bool NameAndTypeResolver::resolveNamesAndTypes(SourceUnit& _source)
 {
 	try
 	{
-		for (shared_ptr<ASTNode> const& node: _source.nodes())
+		for (std::shared_ptr<ASTNode> const& node: _source.nodes())
 		{
 			setScope(&_source);
 			if (!resolveNamesAndTypesInternal(*node, true))
@@ -159,7 +160,7 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
 	return true;
 }
 
-void NameAndTypeResolver::activateVariable(string const& _name)
+void NameAndTypeResolver::activateVariable(std::string const& _name)
 {
 	solAssert(m_currentScope, "");
 	// Scoped local variables are invisible before activation.
@@ -171,15 +172,15 @@ void NameAndTypeResolver::activateVariable(string const& _name)
 		m_currentScope->activateVariable(_name);
 }
 
-vector<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, ASTNode const* _scope) const
+std::vector<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, ASTNode const* _scope) const
 {
 	auto iterator = m_scopes.find(_scope);
 	if (iterator == end(m_scopes))
-		return vector<Declaration const*>({});
+		return std::vector<Declaration const*>({});
 	return iterator->second->resolveName(_name);
 }
 
-vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString const& _name, bool _includeInvisibles) const
+std::vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString const& _name, bool _includeInvisibles) const
 {
 	ResolvingSettings settings;
 	settings.recursive = true;
@@ -187,7 +188,7 @@ vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString c
 	return m_currentScope->resolveName(_name, std::move(settings));
 }
 
-Declaration const* NameAndTypeResolver::pathFromCurrentScope(vector<ASTString> const& _path) const
+Declaration const* NameAndTypeResolver::pathFromCurrentScope(std::vector<ASTString> const& _path) const
 {
 	if (auto declarations = pathFromCurrentScopeWithAllDeclarations(_path); !declarations.empty())
 		return declarations.back();
@@ -195,16 +196,23 @@ Declaration const* NameAndTypeResolver::pathFromCurrentScope(vector<ASTString> c
 	return nullptr;
 }
 
-std::vector<Declaration const*> NameAndTypeResolver::pathFromCurrentScopeWithAllDeclarations(std::vector<ASTString> const& _path) const
+std::vector<Declaration const*> NameAndTypeResolver::pathFromCurrentScopeWithAllDeclarations(
+	std::vector<ASTString> const& _path,
+	bool _includeInvisibles
+) const
 {
 	solAssert(!_path.empty(), "");
-	vector<Declaration const*> pathDeclarations;
+	std::vector<Declaration const*> pathDeclarations;
 
 	ResolvingSettings settings;
 	settings.recursive = true;
-	settings.alsoInvisible = false;
+	settings.alsoInvisible = _includeInvisibles;
 	settings.onlyVisibleAsUnqualifiedNames = true;
-	vector<Declaration const*> candidates = m_currentScope->resolveName(_path.front(), std::move(settings));
+	std::vector<Declaration const*> candidates = m_currentScope->resolveName(_path.front(), settings);
+
+	// inside the loop, use default settings, except for alsoInvisible
+	settings.recursive = false;
+	settings.onlyVisibleAsUnqualifiedNames = false;
 
 	for (size_t i = 1; i < _path.size() && candidates.size() == 1; i++)
 	{
@@ -213,7 +221,7 @@ std::vector<Declaration const*> NameAndTypeResolver::pathFromCurrentScopeWithAll
 
 		pathDeclarations.push_back(candidates.front());
 
-		candidates = m_scopes.at(candidates.front())->resolveName(_path[i]);
+		candidates = m_scopes.at(candidates.front())->resolveName(_path[i], settings);
 	}
 	if (candidates.size() == 1)
 	{
@@ -298,7 +306,7 @@ bool NameAndTypeResolver::resolveNamesAndTypesInternal(ASTNode& _node, bool _res
 		if (success)
 		{
 			linearizeBaseContracts(*contract);
-			vector<ContractDefinition const*> properBases(
+			std::vector<ContractDefinition const*> properBases(
 				++contract->annotation().linearizedBaseContracts.begin(),
 				contract->annotation().linearizedBaseContracts.end()
 			);
@@ -398,7 +406,7 @@ void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract)
 {
 	// order in the lists is from derived to base
 	// list of lists to linearize, the last element is the list of direct bases
-	list<list<ContractDefinition const*>> input(1, list<ContractDefinition const*>{});
+	std::list<std::list<ContractDefinition const*>> input(1, std::list<ContractDefinition const*>{});
 	for (ASTPointer<InheritanceSpecifier> const& baseSpecifier: _contract.baseContracts())
 	{
 		IdentifierPath const& baseName = baseSpecifier->name();
@@ -408,25 +416,25 @@ void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract)
 		// "push_front" has the effect that bases mentioned later can overwrite members of bases
 		// mentioned earlier
 		input.back().push_front(base);
-		vector<ContractDefinition const*> const& basesBases = base->annotation().linearizedBaseContracts;
+		std::vector<ContractDefinition const*> const& basesBases = base->annotation().linearizedBaseContracts;
 		if (basesBases.empty())
 			m_errorReporter.fatalTypeError(2449_error, baseName.location(), "Definition of base has to precede definition of derived contract");
-		input.push_front(list<ContractDefinition const*>(basesBases.begin(), basesBases.end()));
+		input.push_front(std::list<ContractDefinition const*>(basesBases.begin(), basesBases.end()));
 	}
 	input.back().push_front(&_contract);
-	vector<ContractDefinition const*> result = cThreeMerge(input);
+	std::vector<ContractDefinition const*> result = cThreeMerge(input);
 	if (result.empty())
 		m_errorReporter.fatalTypeError(5005_error, _contract.location(), "Linearization of inheritance graph impossible");
 	_contract.annotation().linearizedBaseContracts = result;
 }
 
 template <class T>
-vector<T const*> NameAndTypeResolver::cThreeMerge(list<list<T const*>>& _toMerge)
+std::vector<T const*> NameAndTypeResolver::cThreeMerge(std::list<std::list<T const*>>& _toMerge)
 {
 	// returns true iff _candidate appears only as last element of the lists
 	auto appearsOnlyAtHead = [&](T const* _candidate) -> bool
 	{
-		for (list<T const*> const& bases: _toMerge)
+		for (std::list<T const*> const& bases: _toMerge)
 		{
 			solAssert(!bases.empty(), "");
 			if (find(++bases.begin(), bases.end(), _candidate) != bases.end())
@@ -437,7 +445,7 @@ vector<T const*> NameAndTypeResolver::cThreeMerge(list<list<T const*>>& _toMerge
 	// returns the next candidate to append to the linearized list or nullptr on failure
 	auto nextCandidate = [&]() -> T const*
 	{
-		for (list<T const*> const& bases: _toMerge)
+		for (std::list<T const*> const& bases: _toMerge)
 		{
 			solAssert(!bases.empty(), "");
 			if (appearsOnlyAtHead(bases.front()))
@@ -458,26 +466,26 @@ vector<T const*> NameAndTypeResolver::cThreeMerge(list<list<T const*>>& _toMerge
 		}
 	};
 
-	_toMerge.remove_if([](list<T const*> const& _bases) { return _bases.empty(); });
-	vector<T const*> result;
+	_toMerge.remove_if([](std::list<T const*> const& _bases) { return _bases.empty(); });
+	std::vector<T const*> result;
 	while (!_toMerge.empty())
 	{
 		T const* candidate = nextCandidate();
 		if (!candidate)
-			return vector<T const*>();
+			return std::vector<T const*>();
 		result.push_back(candidate);
 		removeCandidate(candidate);
 	}
 	return result;
 }
 
-string NameAndTypeResolver::similarNameSuggestions(ASTString const& _name) const
+	std::string NameAndTypeResolver::similarNameSuggestions(ASTString const& _name) const
 {
 	return util::quotedAlternativesList(m_currentScope->similarNames(_name));
 }
 
 DeclarationRegistrationHelper::DeclarationRegistrationHelper(
-	map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
+	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& _scopes,
 	ASTNode& _astRoot,
 	ErrorReporter& _errorReporter,
 	GlobalContext& _globalContext,
@@ -495,7 +503,7 @@ DeclarationRegistrationHelper::DeclarationRegistrationHelper(
 bool DeclarationRegistrationHelper::registerDeclaration(
 	DeclarationContainer& _container,
 	Declaration const& _declaration,
-	string const* _name,
+	std::string const* _name,
 	SourceLocation const* _errorLocation,
 	bool _inactive,
 	ErrorReporter& _errorReporter
@@ -504,13 +512,13 @@ bool DeclarationRegistrationHelper::registerDeclaration(
 	if (!_errorLocation)
 		_errorLocation = &_declaration.location();
 
-	string name = _name ? *_name : _declaration.name();
+	std::string name = _name ? *_name : _declaration.name();
 
 	// We use "invisible" for both inactive variables in blocks and for members invisible in contracts.
 	// They cannot both be true at the same time.
 	solAssert(!(_inactive && !_declaration.isVisibleInContract()), "");
 
-	static set<string> illegalNames{"_", "super", "this"};
+	static std::set<std::string> illegalNames{"_", "super", "this"};
 
 	if (illegalNames.count(name))
 	{
@@ -573,7 +581,7 @@ bool DeclarationRegistrationHelper::visit(SourceUnit& _sourceUnit)
 {
 	if (!m_scopes[&_sourceUnit])
 		// By importing, it is possible that the container already exists.
-		m_scopes[&_sourceUnit] = make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get());
+		m_scopes[&_sourceUnit] = std::make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get());
 	return ASTVisitor::visit(_sourceUnit);
 }
 
@@ -587,7 +595,7 @@ bool DeclarationRegistrationHelper::visit(ImportDirective& _import)
 	SourceUnit const* importee = _import.annotation().sourceUnit;
 	solAssert(!!importee, "");
 	if (!m_scopes[importee])
-		m_scopes[importee] = make_shared<DeclarationContainer>(nullptr, m_scopes[nullptr].get());
+		m_scopes[importee] = std::make_shared<DeclarationContainer>(nullptr, m_scopes[nullptr].get());
 	m_scopes[&_import] = m_scopes[importee];
 	ASTVisitor::visit(_import);
 	return false; // Do not recurse into child nodes (Identifier for symbolAliases)
@@ -634,7 +642,7 @@ bool DeclarationRegistrationHelper::visitNode(ASTNode& _node)
 
 	if (auto* annotation = dynamic_cast<TypeDeclarationAnnotation*>(&_node.annotation()))
 	{
-		string canonicalName = dynamic_cast<Declaration const&>(_node).name();
+		std::string canonicalName = dynamic_cast<Declaration const&>(_node).name();
 		solAssert(!canonicalName.empty(), "");
 
 		for (
@@ -677,7 +685,7 @@ void DeclarationRegistrationHelper::enterNewSubScope(ASTNode& _subScope)
 	{
 		bool newlyAdded = m_scopes.emplace(
 			&_subScope,
-			make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get())
+			std::make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get())
 		).second;
 		solAssert(newlyAdded, "Unable to add new scope.");
 	}
diff --git a/compiler/libsolidity/analysis/NameAndTypeResolver.h b/compiler/libsolidity/analysis/NameAndTypeResolver.h
index c5bf11b5..52c0c6dd 100644
--- a/compiler/libsolidity/analysis/NameAndTypeResolver.h
+++ b/compiler/libsolidity/analysis/NameAndTypeResolver.h
@@ -59,7 +59,8 @@ class NameAndTypeResolver
 	NameAndTypeResolver(
 		GlobalContext& _globalContext,
 		langutil::EVMVersion _evmVersion,
-		langutil::ErrorReporter& _errorReporter
+		langutil::ErrorReporter& _errorReporter,
+		bool _experimentalSolidity
 	);
 	/// Registers all declarations found in the AST node, usually a source unit.
 	/// @returns false in case of error.
@@ -96,7 +97,7 @@ class NameAndTypeResolver
 	/// Resolves a path starting from the "current" scope, but also searches parent scopes.
 	/// Should only be called during the initial resolving phase.
 	/// @note Returns an empty vector if any component in the path was non-unique or not found. Otherwise, all declarations along the path are returned.
-	std::vector<Declaration const*> pathFromCurrentScopeWithAllDeclarations(std::vector<ASTString> const& _path) const;
+	std::vector<Declaration const*> pathFromCurrentScopeWithAllDeclarations(std::vector<ASTString> const& _path, bool _includeInvisibles = false) const;
 
 	/// Generate and store warnings about declarations with the same name.
 	void warnHomonymDeclarations() const;
@@ -107,6 +108,7 @@ class NameAndTypeResolver
 	/// Sets the current scope.
 	void setScope(ASTNode const* _node);
 
+	bool experimentalSolidity() const { return m_experimentalSolidity; }
 private:
 	/// Internal version of @a resolveNamesAndTypes (called from there) throws exceptions on fatal errors.
 	bool resolveNamesAndTypesInternal(ASTNode& _node, bool _resolveInsideCode = true);
@@ -132,6 +134,7 @@ class NameAndTypeResolver
 	DeclarationContainer* m_currentScope = nullptr;
 	langutil::ErrorReporter& m_errorReporter;
 	GlobalContext& m_globalContext;
+	bool m_experimentalSolidity = false;
 };
 
 /**
diff --git a/compiler/libsolidity/analysis/OverrideChecker.cpp b/compiler/libsolidity/analysis/OverrideChecker.cpp
index acfe7c81..b457a1bc 100644
--- a/compiler/libsolidity/analysis/OverrideChecker.cpp
+++ b/compiler/libsolidity/analysis/OverrideChecker.cpp
@@ -31,7 +31,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 using namespace solidity::langutil;
@@ -46,7 +45,7 @@ namespace
 // Helper struct to do a search by name
 struct MatchByName
 {
-	string const& m_name;
+	std::string const& m_name;
 	bool operator()(OverrideProxy const& _item)
 	{
 		return _item.name() == m_name;
@@ -61,7 +60,7 @@ struct MatchByName
  */
 struct OverrideGraph
 {
-	OverrideGraph(set<OverrideProxy> const& _baseCallables)
+	OverrideGraph(std::set<OverrideProxy> const& _baseCallables)
 	{
 		for (auto const& baseFunction: _baseCallables)
 			addEdge(0, visit(baseFunction));
@@ -131,17 +130,17 @@ struct CutVertexFinder
 				run(vInd, _depth + 1);
 				if (m_low[vInd] >= m_depths[_u] && m_parent[_u] != -1)
 					m_cutVertices.insert(m_graph.nodeInv.at(static_cast<int>(_u)));
-				m_low[_u] = min(m_low[_u], m_low[vInd]);
+				m_low[_u] = std::min(m_low[_u], m_low[vInd]);
 			}
 			else if (v != m_parent[_u])
-				m_low[_u] = min(m_low[_u], m_depths[vInd]);
+				m_low[_u] = std::min(m_low[_u], m_depths[vInd]);
 		}
 	}
 };
 
-vector<ContractDefinition const*> resolveDirectBaseContracts(ContractDefinition const& _contract)
+std::vector<ContractDefinition const*> resolveDirectBaseContracts(ContractDefinition const& _contract)
 {
-	vector<ContractDefinition const*> resolvedContracts;
+	std::vector<ContractDefinition const*> resolvedContracts;
 
 	for (ASTPointer<InheritanceSpecifier> const& specifier: _contract.baseContracts())
 	{
@@ -155,7 +154,7 @@ vector<ContractDefinition const*> resolveDirectBaseContracts(ContractDefinition
 	return resolvedContracts;
 }
 
-vector<ASTPointer<IdentifierPath>> sortByContract(vector<ASTPointer<IdentifierPath>> const& _list)
+std::vector<ASTPointer<IdentifierPath>> sortByContract(std::vector<ASTPointer<IdentifierPath>> const& _list)
 {
 	auto sorted = _list;
 
@@ -197,17 +196,17 @@ bool OverrideProxy::operator<(OverrideProxy const& _other) const
 
 bool OverrideProxy::isVariable() const
 {
-	return holds_alternative<VariableDeclaration const*>(m_item);
+	return std::holds_alternative<VariableDeclaration const*>(m_item);
 }
 
 bool OverrideProxy::isFunction() const
 {
-	return holds_alternative<FunctionDefinition const*>(m_item);
+	return std::holds_alternative<FunctionDefinition const*>(m_item);
 }
 
 bool OverrideProxy::isModifier() const
 {
-	return holds_alternative<ModifierDefinition const*>(m_item);
+	return std::holds_alternative<ModifierDefinition const*>(m_item);
 }
 
 bool OverrideProxy::CompareBySignature::operator()(OverrideProxy const& _a, OverrideProxy const& _b) const
@@ -222,18 +221,18 @@ size_t OverrideProxy::id() const
 	}, m_item);
 }
 
-shared_ptr<OverrideSpecifier> OverrideProxy::overrides() const
+std::shared_ptr<OverrideSpecifier> OverrideProxy::overrides() const
 {
 	return std::visit(GenericVisitor{
 		[&](auto const* _item) { return _item->overrides(); }
 	}, m_item);
 }
 
-set<OverrideProxy> OverrideProxy::baseFunctions() const
+std::set<OverrideProxy> OverrideProxy::baseFunctions() const
 {
 	return std::visit(GenericVisitor{
-		[&](auto const* _item) -> set<OverrideProxy> {
-			set<OverrideProxy> ret;
+		[&](auto const* _item) -> std::set<OverrideProxy> {
+			std::set<OverrideProxy> ret;
 			for (auto const* f: _item->annotation().baseFunctions)
 				ret.insert(makeOverrideProxy(*f));
 			return ret;
@@ -256,10 +255,10 @@ void OverrideProxy::storeBaseFunction(OverrideProxy const& _base) const
 	}, m_item);
 }
 
-string const& OverrideProxy::name() const
+std::string const& OverrideProxy::name() const
 {
 	return std::visit(GenericVisitor{
-		[&](auto const* _item) -> string const& { return _item->name(); }
+		[&](auto const* _item) -> std::string const& { return _item->name(); }
 	}, m_item);
 }
 
@@ -272,7 +271,7 @@ ContractDefinition const& OverrideProxy::contract() const
 	}, m_item);
 }
 
-string const& OverrideProxy::contractName() const
+std::string const& OverrideProxy::contractName() const
 {
 	return contract().name();
 }
@@ -357,7 +356,7 @@ SourceLocation const& OverrideProxy::location() const
 	}, m_item);
 }
 
-string OverrideProxy::astNodeName() const
+std::string OverrideProxy::astNodeName() const
 {
 	return std::visit(GenericVisitor{
 		[&](FunctionDefinition const*) { return "function"; },
@@ -366,7 +365,7 @@ string OverrideProxy::astNodeName() const
 	}, m_item);
 }
 
-string OverrideProxy::astNodeNameCapitalized() const
+std::string OverrideProxy::astNodeNameCapitalized() const
 {
 	return std::visit(GenericVisitor{
 		[&](FunctionDefinition const*) { return "Function"; },
@@ -375,7 +374,7 @@ string OverrideProxy::astNodeNameCapitalized() const
 	}, m_item);
 }
 
-string OverrideProxy::distinguishingProperty() const
+std::string OverrideProxy::distinguishingProperty() const
 {
 	return std::visit(GenericVisitor{
 		[&](FunctionDefinition const*) { return "name and parameter types"; },
@@ -418,10 +417,10 @@ OverrideProxy::OverrideComparator const& OverrideProxy::overrideComparator() con
 {
 	if (!m_comparator)
 	{
-		m_comparator = make_shared<OverrideComparator>(std::visit(GenericVisitor{
+		m_comparator = std::make_shared<OverrideComparator>(std::visit(GenericVisitor{
 			[&](FunctionDefinition const* _function)
 			{
-				vector<string> paramTypes;
+				std::vector<std::string> paramTypes;
 				for (Type const* t: externalFunctionType()->parameterTypes())
 					paramTypes.emplace_back(t->richIdentifier());
 				return OverrideComparator{
@@ -432,7 +431,7 @@ OverrideProxy::OverrideComparator const& OverrideProxy::overrideComparator() con
 			},
 			[&](VariableDeclaration const* _var)
 			{
-				vector<string> paramTypes;
+				std::vector<std::string> paramTypes;
 				for (Type const* t: externalFunctionType()->parameterTypes())
 					paramTypes.emplace_back(t->richIdentifier());
 				return OverrideComparator{
@@ -671,21 +670,21 @@ void OverrideChecker::checkOverride(OverrideProxy const& _overriding, OverridePr
 
 void OverrideChecker::overrideListError(
 	OverrideProxy const& _item,
-	set<ContractDefinition const*, CompareByID> _secondary,
+	std::set<ContractDefinition const*, CompareByID> _secondary,
 	ErrorId _error,
-	string const& _message1,
-	string const& _message2
+	std::string const& _message1,
+	std::string const& _message2
 )
 {
 	// Using a set rather than a vector so the order is always the same
-	set<string> names;
+	std::set<std::string> names;
 	SecondarySourceLocation ssl;
 	for (Declaration const* c: _secondary)
 	{
 		ssl.append("This contract: ", c->location());
 		names.insert("\"" + c->name() + "\"");
 	}
-	string contractSingularPlural = "contract ";
+	std::string contractSingularPlural = "contract ";
 	if (_secondary.size() > 1)
 		contractSingularPlural = "contracts ";
 
@@ -705,8 +704,8 @@ void OverrideChecker::overrideError(
 	OverrideProxy const& _overriding,
 	OverrideProxy const& _super,
 	ErrorId _error,
-	string const& _message,
-	optional<string> const& _secondaryMsg
+	std::string const& _message,
+	std::optional<std::string> const& _secondaryMsg
 )
 {
 	m_errorReporter.typeError(
@@ -763,7 +762,7 @@ void OverrideChecker::checkAmbiguousOverrides(ContractDefinition const& _contrac
 	}
 }
 
-void OverrideChecker::checkAmbiguousOverridesInternal(set<OverrideProxy> _baseCallables, SourceLocation const& _location) const
+void OverrideChecker::checkAmbiguousOverridesInternal(std::set<OverrideProxy> _baseCallables, SourceLocation const& _location) const
 {
 	if (_baseCallables.size() <= 1)
 		return;
@@ -796,17 +795,17 @@ void OverrideChecker::checkAmbiguousOverridesInternal(set<OverrideProxy> _baseCa
 	for (OverrideProxy const& baseFunction: _baseCallables)
 		ssl.append("Definition in \"" + baseFunction.contractName() + "\": ", baseFunction.location());
 
-	string callableName = _baseCallables.begin()->astNodeName();
+	std::string callableName = _baseCallables.begin()->astNodeName();
 	if (_baseCallables.begin()->isVariable())
 		callableName = "function";
-	string distinguishigProperty = _baseCallables.begin()->distinguishingProperty();
+	std::string distinguishigProperty = _baseCallables.begin()->distinguishingProperty();
 
 	bool foundVariable = false;
 	for (auto const& base: _baseCallables)
 		if (base.isVariable())
 			foundVariable = true;
 
-	string message =
+	std::string message =
 		"Derived contract must override " + callableName + " \"" +
 		_baseCallables.begin()->name() +
 		"\". Two or more base classes define " + callableName + " with same " + distinguishigProperty + ".";
@@ -819,9 +818,9 @@ void OverrideChecker::checkAmbiguousOverridesInternal(set<OverrideProxy> _baseCa
 	m_errorReporter.typeError(6480_error, _location, ssl, message);
 }
 
-set<ContractDefinition const*, OverrideChecker::CompareByID> OverrideChecker::resolveOverrideList(OverrideSpecifier const& _overrides) const
+std::set<ContractDefinition const*, OverrideChecker::CompareByID> OverrideChecker::resolveOverrideList(OverrideSpecifier const& _overrides) const
 {
-	set<ContractDefinition const*, CompareByID> resolved;
+	std::set<ContractDefinition const*, CompareByID> resolved;
 
 	for (ASTPointer<IdentifierPath> const& override: _overrides.overrides())
 	{
@@ -839,7 +838,7 @@ set<ContractDefinition const*, OverrideChecker::CompareByID> OverrideChecker::re
 
 void OverrideChecker::checkOverrideList(OverrideProxy _item, OverrideProxyBySignatureMultiSet const& _inherited)
 {
-	set<ContractDefinition const*, CompareByID> specifiedContracts =
+	std::set<ContractDefinition const*, CompareByID> specifiedContracts =
 		_item.overrides() ?
 		resolveOverrideList(*_item.overrides()) :
 		decltype(specifiedContracts){};
@@ -848,7 +847,7 @@ void OverrideChecker::checkOverrideList(OverrideProxy _item, OverrideProxyBySign
 	if (_item.overrides() && specifiedContracts.size() != _item.overrides()->overrides().size())
 	{
 		// Sort by contract id to find duplicate for error reporting
-		vector<ASTPointer<IdentifierPath>> list =
+		std::vector<ASTPointer<IdentifierPath>> list =
 			sortByContract(_item.overrides()->overrides());
 
 		// Find duplicates and output error
@@ -877,7 +876,7 @@ void OverrideChecker::checkOverrideList(OverrideProxy _item, OverrideProxyBySign
 		}
 	}
 
-	set<ContractDefinition const*, CompareByID> expectedContracts;
+	std::set<ContractDefinition const*, CompareByID> expectedContracts;
 
 	// Build list of expected contracts
 	for (auto [begin, end] = _inherited.equal_range(_item); begin != end; begin++)
@@ -895,7 +894,7 @@ void OverrideChecker::checkOverrideList(OverrideProxy _item, OverrideProxyBySign
 			_item.astNodeNameCapitalized() + " has override specified but does not override anything."
 		);
 
-	set<ContractDefinition const*, CompareByID> missingContracts;
+	std::set<ContractDefinition const*, CompareByID> missingContracts;
 	// If we expect only one contract, no contract needs to be specified
 	if (expectedContracts.size() > 1)
 		missingContracts = expectedContracts - specifiedContracts;
@@ -928,7 +927,7 @@ OverrideChecker::OverrideProxyBySignatureMultiSet const& OverrideChecker::inheri
 
 		for (auto const* base: resolveDirectBaseContracts(_contract))
 		{
-			set<OverrideProxy, OverrideProxy::CompareBySignature> functionsInBase;
+			std::set<OverrideProxy, OverrideProxy::CompareBySignature> functionsInBase;
 			for (FunctionDefinition const* fun: base->definedFunctions())
 				if (!fun->isConstructor())
 					functionsInBase.emplace(OverrideProxy{fun});
@@ -957,7 +956,7 @@ OverrideChecker::OverrideProxyBySignatureMultiSet const& OverrideChecker::inheri
 
 		for (auto const* base: resolveDirectBaseContracts(_contract))
 		{
-			set<OverrideProxy, OverrideProxy::CompareBySignature> modifiersInBase;
+			std::set<OverrideProxy, OverrideProxy::CompareBySignature> modifiersInBase;
 			for (ModifierDefinition const* mod: base->functionModifiers())
 				modifiersInBase.emplace(OverrideProxy{mod});
 
diff --git a/compiler/libsolidity/analysis/PostTypeChecker.cpp b/compiler/libsolidity/analysis/PostTypeChecker.cpp
index b5b973aa..303635da 100644
--- a/compiler/libsolidity/analysis/PostTypeChecker.cpp
+++ b/compiler/libsolidity/analysis/PostTypeChecker.cpp
@@ -25,9 +25,10 @@
 #include <libsolutil/Algorithms.h>
 #include <libsolutil/FunctionSelector.h>
 
+#include <range/v3/algorithm/any_of.hpp>
+
 #include <memory>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -130,6 +131,17 @@ void PostTypeChecker::endVisit(ModifierInvocation const& _modifierInvocation)
 	callEndVisit(_modifierInvocation);
 }
 
+
+bool PostTypeChecker::visit(ForStatement const& _forStatement)
+{
+	return callVisit(_forStatement);
+}
+
+void PostTypeChecker::endVisit(ForStatement const& _forStatement)
+{
+	callEndVisit(_forStatement);
+}
+
 namespace
 {
 struct ConstStateVarCircularReferenceChecker: public PostTypeChecker::Checker
@@ -204,7 +216,7 @@ struct ConstStateVarCircularReferenceChecker: public PostTypeChecker::Checker
 			// Iterating through the dependencies needs to be deterministic and thus cannot
 			// depend on the memory layout.
 			// Because of that, we sort by AST node id.
-			vector<VariableDeclaration const*> dependencies(
+			std::vector<VariableDeclaration const*> dependencies(
 				m_constVariableDependencies[&_variable].begin(),
 				m_constVariableDependencies[&_variable].end()
 			);
@@ -411,7 +423,7 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker
 			);
 		else
 		{
-			uint32_t selector = util::selectorFromSignature32(_error.functionType(true)->externalSignature());
+			uint32_t selector = util::selectorFromSignatureU32(_error.functionType(true)->externalSignature());
 			if (selector == 0 || ~selector == 0)
 				m_errorReporter.syntaxError(
 					2855_error,
@@ -422,15 +434,95 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker
 	}
 };
 
+class LValueChecker: public ASTConstVisitor
+{
+public:
+	LValueChecker(Identifier const& _identifier):
+		m_declaration(_identifier.annotation().referencedDeclaration)
+	{}
+	bool willBeWrittenTo() const { return m_willBeWrittenTo; }
+	void endVisit(Identifier const& _identifier) override
+	{
+		if (m_willBeWrittenTo)
+			return;
+
+		solAssert(_identifier.annotation().referencedDeclaration);
+		if (
+			*_identifier.annotation().referencedDeclaration == *m_declaration &&
+			_identifier.annotation().willBeWrittenTo
+		)
+			m_willBeWrittenTo = true;
+	}
+private:
+	Declaration const* m_declaration{};
+	bool m_willBeWrittenTo = false;
+};
+
+struct SimpleCounterForLoopChecker: public PostTypeChecker::Checker
+{
+	SimpleCounterForLoopChecker(ErrorReporter& _errorReporter): Checker(_errorReporter) {}
+	bool visit(ForStatement const& _forStatement) override
+	{
+		_forStatement.annotation().isSimpleCounterLoop = isSimpleCounterLoop(_forStatement);
+		return true;
+	}
+	bool isSimpleCounterLoop(ForStatement const& _forStatement) const
+	{
+		auto const* simpleCondition = dynamic_cast<BinaryOperation const*>(_forStatement.condition());
+		if (!simpleCondition || simpleCondition->getOperator() != Token::LessThan || simpleCondition->userDefinedFunctionType())
+			return false;
+		if (!_forStatement.loopExpression())
+			return false;
+
+		auto const* simplePostExpression = dynamic_cast<UnaryOperation const*>(&_forStatement.loopExpression()->expression());
+		// This matches both operators ++i and i++
+		if (!simplePostExpression || simplePostExpression->getOperator() != Token::Inc || simplePostExpression->userDefinedFunctionType())
+			return false;
+
+		auto const* lhsIdentifier = dynamic_cast<Identifier const*>(&simpleCondition->leftExpression());
+		auto const* lhsIntegerType = dynamic_cast<IntegerType const*>(simpleCondition->leftExpression().annotation().type);
+		auto const* commonIntegerType = dynamic_cast<IntegerType const*>(simpleCondition->annotation().commonType);
+
+		if (!lhsIdentifier || !lhsIntegerType || !commonIntegerType || *lhsIntegerType != *commonIntegerType)
+			return false;
+
+		auto const* incExpressionIdentifier = dynamic_cast<Identifier const*>(&simplePostExpression->subExpression());
+		if (
+			!incExpressionIdentifier ||
+			incExpressionIdentifier->annotation().referencedDeclaration != lhsIdentifier->annotation().referencedDeclaration
+		)
+			return false;
+
+		solAssert(incExpressionIdentifier->annotation().referencedDeclaration);
+		if (
+			auto const* incVariableDeclaration = dynamic_cast<VariableDeclaration const*>(
+				incExpressionIdentifier->annotation().referencedDeclaration
+			);
+			incVariableDeclaration &&
+			!incVariableDeclaration->isLocalVariable()
+		)
+			return false;
+
+		solAssert(lhsIdentifier);
+		LValueChecker lValueChecker{*lhsIdentifier};
+		simpleCondition->rightExpression().accept(lValueChecker);
+		if (!lValueChecker.willBeWrittenTo())
+			_forStatement.body().accept(lValueChecker);
+
+		return !lValueChecker.willBeWrittenTo();
+	}
+};
+
 }
 
 
 PostTypeChecker::PostTypeChecker(langutil::ErrorReporter& _errorReporter): m_errorReporter(_errorReporter)
 {
-	m_checkers.push_back(make_shared<ConstStateVarCircularReferenceChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<OverrideSpecifierChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<ModifierContextChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<EventOutsideEmitErrorOutsideRevertChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<NoVariablesInInterfaceChecker>(_errorReporter));
-	m_checkers.push_back(make_shared<ReservedErrorSelector>(_errorReporter));
+	m_checkers.push_back(std::make_shared<ConstStateVarCircularReferenceChecker>(_errorReporter));
+	m_checkers.push_back(std::make_shared<OverrideSpecifierChecker>(_errorReporter));
+	m_checkers.push_back(std::make_shared<ModifierContextChecker>(_errorReporter));
+	m_checkers.push_back(std::make_shared<EventOutsideEmitErrorOutsideRevertChecker>(_errorReporter));
+	m_checkers.push_back(std::make_shared<NoVariablesInInterfaceChecker>(_errorReporter));
+	m_checkers.push_back(std::make_shared<ReservedErrorSelector>(_errorReporter));
+	m_checkers.push_back(std::make_shared<SimpleCounterForLoopChecker>(_errorReporter));
 }
diff --git a/compiler/libsolidity/analysis/PostTypeChecker.h b/compiler/libsolidity/analysis/PostTypeChecker.h
index 04b4fbe7..178130a3 100644
--- a/compiler/libsolidity/analysis/PostTypeChecker.h
+++ b/compiler/libsolidity/analysis/PostTypeChecker.h
@@ -97,6 +97,9 @@ class PostTypeChecker: private ASTConstVisitor
 	bool visit(ModifierInvocation const& _modifierInvocation) override;
 	void endVisit(ModifierInvocation const& _modifierInvocation) override;
 
+	bool visit(ForStatement const& _forStatement) override;
+	void endVisit(ForStatement const& _forStatement) override;
+
 	template <class T>
 	bool callVisit(T const& _node)
 	{
diff --git a/compiler/libsolidity/analysis/PostTypeContractLevelChecker.cpp b/compiler/libsolidity/analysis/PostTypeContractLevelChecker.cpp
index 38a192c2..6d8dc416 100644
--- a/compiler/libsolidity/analysis/PostTypeContractLevelChecker.cpp
+++ b/compiler/libsolidity/analysis/PostTypeContractLevelChecker.cpp
@@ -26,7 +26,6 @@
 #include <libsolutil/FunctionSelector.h>
 #include <liblangutil/ErrorReporter.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -48,11 +47,11 @@ bool PostTypeContractLevelChecker::check(ContractDefinition const& _contract)
 		""
 	);
 
-	map<uint32_t, map<string, SourceLocation>> errorHashes;
+	std::map<uint32_t, std::map<std::string, SourceLocation>> errorHashes;
 	for (ErrorDefinition const* error: _contract.interfaceErrors())
 	{
-		string signature = error->functionType(true)->externalSignature();
-		uint32_t hash = util::selectorFromSignature32(signature);
+		std::string signature = error->functionType(true)->externalSignature();
+		uint32_t hash = util::selectorFromSignatureU32(signature);
 		// Fail if there is a different signature for the same hash.
 		if (!errorHashes[hash].empty() && !errorHashes[hash].count(signature))
 		{
diff --git a/compiler/libsolidity/analysis/ReferencesResolver.cpp b/compiler/libsolidity/analysis/ReferencesResolver.cpp
index 74e0b367..d5d2f568 100644
--- a/compiler/libsolidity/analysis/ReferencesResolver.cpp
+++ b/compiler/libsolidity/analysis/ReferencesResolver.cpp
@@ -34,7 +34,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/split.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -123,6 +122,21 @@ bool ReferencesResolver::visit(VariableDeclaration const& _varDecl)
 	if (_varDecl.documentation())
 		resolveInheritDoc(*_varDecl.documentation(), _varDecl.annotation());
 
+	if (m_resolver.experimentalSolidity())
+	{
+		solAssert(!_varDecl.hasTypeName());
+		if (_varDecl.typeExpression())
+		{
+			ScopedSaveAndRestore typeContext{m_typeContext, true};
+			_varDecl.typeExpression()->accept(*this);
+		}
+		if (_varDecl.overrides())
+			_varDecl.overrides()->accept(*this);
+		if (_varDecl.value())
+			_varDecl.value()->accept(*this);
+		return false;
+	}
+
 	return true;
 }
 
@@ -131,8 +145,10 @@ bool ReferencesResolver::visit(Identifier const& _identifier)
 	auto declarations = m_resolver.nameFromCurrentScope(_identifier.name());
 	if (declarations.empty())
 	{
-		string suggestions = m_resolver.similarNameSuggestions(_identifier.name());
-		string errorMessage = "Undeclared identifier.";
+		if (m_resolver.experimentalSolidity() && m_typeContext)
+			return false;
+		std::string suggestions = m_resolver.similarNameSuggestions(_identifier.name());
+		std::string errorMessage = "Undeclared identifier.";
 		if (!suggestions.empty())
 		{
 			if ("\"" + _identifier.name() + "\"" == suggestions)
@@ -151,7 +167,7 @@ bool ReferencesResolver::visit(Identifier const& _identifier)
 
 bool ReferencesResolver::visit(FunctionDefinition const& _functionDefinition)
 {
-	m_returnParameters.push_back(_functionDefinition.returnParameterList().get());
+	m_functionDefinitions.push_back(&_functionDefinition);
 
 	if (_functionDefinition.documentation())
 		resolveInheritDoc(*_functionDefinition.documentation(), _functionDefinition.annotation());
@@ -161,13 +177,13 @@ bool ReferencesResolver::visit(FunctionDefinition const& _functionDefinition)
 
 void ReferencesResolver::endVisit(FunctionDefinition const&)
 {
-	solAssert(!m_returnParameters.empty(), "");
-	m_returnParameters.pop_back();
+	solAssert(!m_functionDefinitions.empty(), "");
+	m_functionDefinitions.pop_back();
 }
 
 bool ReferencesResolver::visit(ModifierDefinition const& _modifierDefinition)
 {
-	m_returnParameters.push_back(nullptr);
+	m_functionDefinitions.push_back(nullptr);
 
 	if (_modifierDefinition.documentation())
 		resolveInheritDoc(*_modifierDefinition.documentation(), _modifierDefinition.annotation());
@@ -177,12 +193,13 @@ bool ReferencesResolver::visit(ModifierDefinition const& _modifierDefinition)
 
 void ReferencesResolver::endVisit(ModifierDefinition const&)
 {
-	solAssert(!m_returnParameters.empty(), "");
-	m_returnParameters.pop_back();
+	solAssert(!m_functionDefinitions.empty(), "");
+	m_functionDefinitions.pop_back();
 }
 
 void ReferencesResolver::endVisit(IdentifierPath const& _path)
 {
+	// Note that library/functions names in "using {} for" directive are resolved separately in visit(UsingForDirective)
 	std::vector<Declaration const*> declarations = m_resolver.pathFromCurrentScopeWithAllDeclarations(_path.path());
 	if (declarations.empty())
 	{
@@ -194,18 +211,64 @@ void ReferencesResolver::endVisit(IdentifierPath const& _path)
 	_path.annotation().pathDeclarations = std::move(declarations);
 }
 
-bool ReferencesResolver::visit(InlineAssembly const& /*_inlineAssembly*/)
+bool ReferencesResolver::visit(UsingForDirective const& _usingFor)
 {
+	for (ASTPointer<IdentifierPath> const& path: _usingFor.functionsOrLibrary())
+	{
+		// _includeInvisibles is enabled here because external library functions are marked invisible.
+		// As unintended side-effects other invisible names (eg.: super, this) may be returned as well.
+		// DeclarationTypeChecker should detect and report such situations.
+		std::vector<Declaration const*> declarations = m_resolver.pathFromCurrentScopeWithAllDeclarations(path->path(), true /* _includeInvisibles */);
+		if (declarations.empty())
+		{
+			std::string libraryOrFunctionNameErrorMessage =
+				_usingFor.usesBraces() ?
+				"Identifier is not a function name or not unique." :
+				"Identifier is not a library name.";
+			m_errorReporter.fatalDeclarationError(
+				9589_error,
+				path->location(),
+				libraryOrFunctionNameErrorMessage
+			);
+			break;
+		}
+
+		path->annotation().referencedDeclaration = declarations.back();
+		path->annotation().pathDeclarations = std::move(declarations);
+	}
+
+	if (_usingFor.typeName())
+		_usingFor.typeName()->accept(*this);
+
 	return false;
 }
 
 bool ReferencesResolver::visit(Return const& _return)
 {
-	solAssert(!m_returnParameters.empty(), "");
-	_return.annotation().functionReturnParameters = m_returnParameters.back();
+	solAssert(!m_functionDefinitions.empty(), "");
+	_return.annotation().function = m_functionDefinitions.back();
+	_return.annotation().functionReturnParameters = m_functionDefinitions.back() ? m_functionDefinitions.back()->returnParameterList().get() : nullptr;
 	return true;
 }
 
+bool ReferencesResolver::visit(BinaryOperation const& _binaryOperation)
+{
+	if (m_resolver.experimentalSolidity())
+	{
+		_binaryOperation.leftExpression().accept(*this);
+		if (_binaryOperation.getOperator() == Token::Colon)
+		{
+			ScopedSaveAndRestore typeContext(m_typeContext, !m_typeContext);
+			_binaryOperation.rightExpression().accept(*this);
+		}
+		else
+			_binaryOperation.rightExpression().accept(*this);
+		return false;
+	}
+	else
+		return ASTConstVisitor::visit(_binaryOperation);
+}
+
 void ReferencesResolver::resolveInheritDoc(StructuredDocumentation const& _documentation, StructurallyDocumentedAnnotation& _annotation)
 {
 	switch (_annotation.docTags.count("inheritdoc"))
@@ -214,7 +277,7 @@ void ReferencesResolver::resolveInheritDoc(StructuredDocumentation const& _docum
 		break;
 	case 1:
 	{
-		string const& name = _annotation.docTags.find("inheritdoc")->second.content;
+		std::string const& name = _annotation.docTags.find("inheritdoc")->second.content;
 		if (name.empty())
 		{
 			m_errorReporter.docstringParsingError(
@@ -225,7 +288,7 @@ void ReferencesResolver::resolveInheritDoc(StructuredDocumentation const& _docum
 			return;
 		}
 
-		vector<string> path;
+		std::vector<std::string> path;
 		boost::split(path, name, boost::is_any_of("."));
 		if (any_of(path.begin(), path.end(), [](auto& _str) { return _str.empty(); }))
 		{
diff --git a/compiler/libsolidity/analysis/ReferencesResolver.h b/compiler/libsolidity/analysis/ReferencesResolver.h
index c6e4a9cd..97b7efe1 100644
--- a/compiler/libsolidity/analysis/ReferencesResolver.h
+++ b/compiler/libsolidity/analysis/ReferencesResolver.h
@@ -80,17 +80,20 @@ class ReferencesResolver: private ASTConstVisitor
 	bool visit(ModifierDefinition const& _modifierDefinition) override;
 	void endVisit(ModifierDefinition const& _modifierDefinition) override;
 	void endVisit(IdentifierPath const& _path) override;
-	bool visit(InlineAssembly const& _inlineAssembly) override;
 	bool visit(Return const& _return) override;
+	bool visit(UsingForDirective const& _usingFor) override;
+	bool visit(BinaryOperation const& _binaryOperation) override;
 
 	void resolveInheritDoc(StructuredDocumentation const& _documentation, StructurallyDocumentedAnnotation& _annotation);
 
 	langutil::ErrorReporter& m_errorReporter;
 	NameAndTypeResolver& m_resolver;
 	langutil::EVMVersion m_evmVersion;
-	/// Stack of return parameters.
-	std::vector<ParameterList const*> m_returnParameters;
+	/// Stack of function definitions.
+	std::vector<FunctionDefinition const*> m_functionDefinitions;
 	bool const m_resolveInsideCode;
+
+	bool m_typeContext = false;
 };
 
 }
diff --git a/compiler/libsolidity/analysis/Scoper.cpp b/compiler/libsolidity/analysis/Scoper.cpp
index 98716cf0..a14ca455 100644
--- a/compiler/libsolidity/analysis/Scoper.cpp
+++ b/compiler/libsolidity/analysis/Scoper.cpp
@@ -20,7 +20,6 @@
 
 #include <libsolidity/ast/AST.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
diff --git a/compiler/libsolidity/analysis/StaticAnalyzer.cpp b/compiler/libsolidity/analysis/StaticAnalyzer.cpp
index daad4564..07190cf3 100644
--- a/compiler/libsolidity/analysis/StaticAnalyzer.cpp
+++ b/compiler/libsolidity/analysis/StaticAnalyzer.cpp
@@ -28,7 +28,6 @@
 #include <liblangutil/ErrorReporter.h>
 #include <memory>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -36,43 +35,6 @@ using namespace solidity::frontend;
 /**
  * Helper class that determines whether a contract's constructor uses inline assembly.
  */
-class solidity::frontend::ConstructorUsesAssembly
-{
-public:
-	/// @returns true if and only if the contract's or any of its bases' constructors
-	/// use inline assembly.
-	bool check(ContractDefinition const& _contract)
-	{
-		for (auto const* base: _contract.annotation().linearizedBaseContracts)
-			if (checkInternal(*base))
-				return true;
-		return false;
-	}
-
-
-private:
-	class Checker: public ASTConstVisitor
-	{
-	public:
-		Checker(FunctionDefinition const& _f) { _f.accept(*this); }
-		bool visit(InlineAssembly const&) override { assemblySeen = true; return false; }
-		bool assemblySeen = false;
-	};
-
-	bool checkInternal(ContractDefinition const& _contract)
-	{
-		if (!m_usesAssembly.count(&_contract))
-		{
-			bool usesAssembly = false;
-			if (_contract.constructor())
-				usesAssembly = Checker{*_contract.constructor()}.assemblySeen;
-			m_usesAssembly[&_contract] = usesAssembly;
-		}
-		return m_usesAssembly[&_contract];
-	}
-
-	map<ContractDefinition const*, bool> m_usesAssembly;
-};
 
 StaticAnalyzer::StaticAnalyzer(ErrorReporter& _errorReporter):
 	m_errorReporter(_errorReporter)
@@ -125,7 +87,7 @@ void StaticAnalyzer::endVisit(FunctionDefinition const& _funDefinition)
 							5667_error,
 							var.first.second->location(),
 							"Unused " +
-							string(var.first.second->isTryCatchParameter() ? "try/catch" : "function") +
+							std::string(var.first.second->isTryCatchParameter() ? "try/catch" : "function") +
 							" parameter. Remove or comment out the variable name to silence this warning."
 						);
 					}
@@ -145,7 +107,7 @@ bool StaticAnalyzer::visit(Identifier const& _identifier)
 		{
 			solAssert(!var->name().empty(), "");
 			if (var->isLocalVariable())
-				m_localVarUseCount[make_pair(var->id(), var)] += 1;
+				m_localVarUseCount[std::make_pair(var->id(), var)] += 1;
 		}
 	return true;
 }
@@ -157,7 +119,7 @@ bool StaticAnalyzer::visit(VariableDeclaration const& _variable)
 		solAssert(_variable.isLocalVariable(), "");
 		if (_variable.name() != "")
 			// This is not a no-op, the entry might pre-exist.
-			m_localVarUseCount[make_pair(_variable.id(), &_variable)] += 0;
+			m_localVarUseCount[std::make_pair(_variable.id(), &_variable)] += 0;
 	}
 
 	return true;
@@ -170,7 +132,7 @@ bool StaticAnalyzer::visit(Return const& _return)
 	if (m_currentFunction && _return.expression())
 		for (auto const& var: m_currentFunction->returnParameters())
 			if (!var->name().empty())
-				m_localVarUseCount[make_pair(var->id(), var.get())] += 1;
+				m_localVarUseCount[std::make_pair(var->id(), var.get())] += 1;
 	return true;
 }
 
@@ -202,19 +164,6 @@ bool StaticAnalyzer::visit(MemberAccess const& _memberAccess)
 				_memberAccess.location(),
 				"\"block.blockhash()\" has been deprecated in favor of \"blockhash()\""
 			);
-		else if (type->kind() == MagicType::Kind::MetaType && _memberAccess.memberName() == "runtimeCode")
-		{
-			if (!m_constructorUsesAssembly)
-				m_constructorUsesAssembly = make_unique<ConstructorUsesAssembly>();
-			ContractType const& contract = dynamic_cast<ContractType const&>(*type->typeArgument());
-			if (m_constructorUsesAssembly->check(contract.contractDefinition()))
-				m_errorReporter.warning(
-					6417_error,
-					_memberAccess.location(),
-					"The constructor of the contract (or its base) uses inline assembly. "
-					"Because of that, it might be that the deployed bytecode is different from type(...).runtimeCode."
-				);
-		}
 	}
 
 	if (_memberAccess.memberName() == "callcode")
@@ -246,11 +195,6 @@ bool StaticAnalyzer::visit(MemberAccess const& _memberAccess)
 	return true;
 }
 
-bool StaticAnalyzer::visit(InlineAssembly const& /*_inlineAssembly*/)
-{
-	return true;
-}
-
 bool StaticAnalyzer::visit(BinaryOperation const& _operation)
 {
 	if (
diff --git a/compiler/libsolidity/analysis/StaticAnalyzer.h b/compiler/libsolidity/analysis/StaticAnalyzer.h
index dc6263d7..d07e9960 100644
--- a/compiler/libsolidity/analysis/StaticAnalyzer.h
+++ b/compiler/libsolidity/analysis/StaticAnalyzer.h
@@ -37,9 +37,6 @@ class ErrorReporter;
 namespace solidity::frontend
 {
 
-class ConstructorUsesAssembly;
-
-
 /**
  * The module that performs static analysis on the AST.
  * In this context, static analysis is anything that can produce warnings which can help
@@ -70,7 +67,6 @@ class StaticAnalyzer: private ASTConstVisitor
 	bool visit(Identifier const& _identifier) override;
 	bool visit(Return const& _return) override;
 	bool visit(MemberAccess const& _memberAccess) override;
-	bool visit(InlineAssembly const& _inlineAssembly) override;
 	bool visit(BinaryOperation const& _operation) override;
 	bool visit(FunctionCall const& _functionCall) override;
 
@@ -84,10 +80,6 @@ class StaticAnalyzer: private ASTConstVisitor
 	/// when traversing.
 	std::map<std::pair<size_t, VariableDeclaration const*>, int> m_localVarUseCount;
 
-	/// Cache that holds information about whether a contract's constructor
-	/// uses inline assembly.
-	std::unique_ptr<ConstructorUsesAssembly> m_constructorUsesAssembly;
-
 	FunctionDefinition const* m_currentFunction = nullptr;
 
 	/// Flag that indicates a constructor.
diff --git a/compiler/libsolidity/analysis/SyntaxChecker.cpp b/compiler/libsolidity/analysis/SyntaxChecker.cpp
index 99418d33..96f47219 100644
--- a/compiler/libsolidity/analysis/SyntaxChecker.cpp
+++ b/compiler/libsolidity/analysis/SyntaxChecker.cpp
@@ -29,7 +29,6 @@
 
 #include <string>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -52,17 +51,17 @@ void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit)
 {
 	if (!m_versionPragma.has_value())
 	{
-		string errorString("Source file does not specify required compiler version!");
-		SemVerVersion recommendedVersion{string(VersionString)};
+		std::string errorString("Source file does not specify required compiler version!");
+		SemVerVersion recommendedVersion{std::string(VersionString)};
 		if (!recommendedVersion.isPrerelease())
 			errorString +=
 				" Consider adding \"pragma ever-solidity ^" +
-				to_string(recommendedVersion.major()) +
-				string(".") +
-				to_string(recommendedVersion.minor()) +
-				string(".") +
-				to_string(recommendedVersion.patch()) +
-				string(";\"");
+				std::to_string(recommendedVersion.major()) +
+				std::string(".") +
+				std::to_string(recommendedVersion.minor()) +
+				std::string(".") +
+				std::to_string(recommendedVersion.patch()) +
+				std::string(";\"");
 
 		// when reporting the warning, print the source name only
 		m_errorReporter.warning(3420_error, {-1, -1, _sourceUnit.location().sourceName}, errorString);
@@ -86,12 +85,8 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 	else if (_pragma.literals()[0] == "experimental")
 	{
 		solAssert(m_sourceUnit, "");
-
-		if (_pragma.literals().size() >= 2) {
-			m_errorReporter.warning(9089_error, _pragma.location(), "Has no effect. Delete this.");
-		}
-
-		vector<string> literals(_pragma.literals().begin() + 1, _pragma.literals().end());
+		std::vector<std::string> literals(_pragma.literals().begin() + 1, _pragma.literals().end());
+		m_errorReporter.warning(9089_error, _pragma.location(), "\"pragma experimental\" is not supported. Delete this.");
 		if (literals.empty())
 			m_errorReporter.syntaxError(
 				9679_error,
@@ -106,7 +101,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 			);
 		else
 		{
-			string const literal = literals[0];
+			std::string const literal = literals[0];
 			if (literal.empty())
 				m_errorReporter.syntaxError(3250_error, _pragma.location(), "Empty experimental feature name is invalid.");
 			else if (!ExperimentalFeatureNames.count(literal))
@@ -125,7 +120,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 		solAssert(m_sourceUnit, "");
 		if (
 			_pragma.literals().size() != 2 ||
-			!set<string>{"v1", "v2"}.count(_pragma.literals()[1])
+			!std::set<std::string>{"v1", "v2"}.count(_pragma.literals()[1])
 		)
 			m_errorReporter.syntaxError(
 				2745_error,
@@ -143,16 +138,16 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 	}
 	else if (_pragma.literals()[0] == "solidity")
 	{
-		SemVerVersion recommendedVersion{string(VersionString)};
+		SemVerVersion recommendedVersion{std::string(VersionString)};
 		std::string errorString =
 				"It's deprecated."
 				" Consider adding \"pragma ever-solidity ^" +
-				to_string(recommendedVersion.major()) +
-				string(".") +
-				to_string(recommendedVersion.minor()) +
-				string(".") +
-				to_string(recommendedVersion.patch()) +
-				string(";\"") +
+				std::to_string(recommendedVersion.major()) +
+				std::string(".") +
+				std::to_string(recommendedVersion.minor()) +
+				std::string(".") +
+				std::to_string(recommendedVersion.patch()) +
+				std::string(";\"") +
 				" to set a version of the compiler.";
 		m_errorReporter.warning(6413_error, _pragma.location(), errorString);
 	}
@@ -163,23 +158,23 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 				8884_error,
 				_pragma.location(),
 				SecondarySourceLocation().append("Previous definition:", *m_versionPragma.value()),
-			   "Compiler version is defined more than once.");
+				"Compiler version is defined more than once.");
+		}
+		try
+		{
+			std::vector<Token> tokens(_pragma.tokens().begin() + 3, _pragma.tokens().end());
+			std::vector<std::string> literals(_pragma.literals().begin() + 3, _pragma.literals().end());
+			SemVerMatchExpressionParser parser(tokens, literals);
+			SemVerMatchExpression matchExpression = parser.parse();
+			static SemVerVersion const currentVersion{std::string(VersionString)};
+			solAssert(matchExpression.matches(currentVersion));
+			m_versionPragma = &_pragma.location();
+		}
+		catch (SemVerError const&)
+		{
+			// An unparsable version pragma is an unrecoverable fatal error in the parser.
+			solAssert(false);
 		}
-		vector<Token> tokens(_pragma.tokens().begin() + 3, _pragma.tokens().end());
-		vector<string> literals(_pragma.literals().begin() + 3, _pragma.literals().end());
-		SemVerMatchExpressionParser parser(tokens, literals);
-		auto matchExpression = parser.parse();
-		// An unparsable version pragma is an unrecoverable fatal error in the parser.
-		solAssert(matchExpression.has_value(), "");
-		static SemVerVersion const currentVersion{string(VersionString)};
-		if (!matchExpression->matches(currentVersion))
-			m_errorReporter.syntaxError(
-				3997_error,
-				_pragma.location(),
-				"Source file requires different compiler version (current compiler is " +
-				string(VersionString) + ")"
-			);
-		m_versionPragma = &_pragma.location();
 	}
 	else if (_pragma.literals()[0] == "AbiHeader")
 	{
@@ -399,17 +394,10 @@ bool SyntaxChecker::visit(Literal const& _literal)
 
 bool SyntaxChecker::visit(UnaryOperation const& _operation)
 {
-	if (_operation.getOperator() == Token::Add)
-		m_errorReporter.syntaxError(9636_error, _operation.location(), "Use of unary + is disallowed.");
-
+	solAssert(_operation.getOperator() != Token::Add);
 	return true;
 }
 
-bool SyntaxChecker::visit(InlineAssembly const& /*_inlineAssembly*/)
-{
-	return false;
-}
-
 bool SyntaxChecker::visit(PlaceholderStatement const& _placeholder)
 {
 	if (m_uncheckedArithmetic)
@@ -446,6 +434,12 @@ void SyntaxChecker::endVisit(ContractDefinition const&)
 
 bool SyntaxChecker::visit(UsingForDirective const& _usingFor)
 {
+	if (!_usingFor.usesBraces())
+		solAssert(
+			_usingFor.functionsAndOperators().size() == 1 &&
+			!std::get<1>(_usingFor.functionsAndOperators().front())
+		);
+
 	if (!m_currentContractKind && !_usingFor.typeName())
 		m_errorReporter.syntaxError(
 			8118_error,
@@ -462,7 +456,7 @@ bool SyntaxChecker::visit(UsingForDirective const& _usingFor)
 		m_errorReporter.syntaxError(
 			2854_error,
 			_usingFor.location(),
-			"Can only globally bind functions to specific types."
+			"Can only globally attach functions to specific types."
 		);
 	if (_usingFor.global() && m_currentContractKind)
 		m_errorReporter.syntaxError(
@@ -482,11 +476,13 @@ bool SyntaxChecker::visit(UsingForDirective const& _usingFor)
 
 bool SyntaxChecker::visit(FunctionDefinition const& _function)
 {
-	solAssert(_function.isFree() == (m_currentContractKind == std::nullopt), "");
+	if (m_sourceUnit && m_sourceUnit->experimentalSolidity())
+		// Handled in experimental::SyntaxRestrictor instead.
+		return true;
 
 	if (!_function.isFree() && !_function.isConstructor() && _function.noVisibilitySpecified())
 	{
-		string suggestedVisibility =
+		std::string suggestedVisibility =
 			_function.isFallback() ||
 			_function.isReceive() ||
 			m_currentContractKind == ContractKind::Interface
@@ -537,3 +533,13 @@ bool SyntaxChecker::visit(StructDefinition const& _struct)
 
 	return true;
 }
+
+bool SyntaxChecker::visitNode(ASTNode const& _node)
+{
+	if (_node.experimentalSolidityOnly())
+	{
+		solAssert(m_sourceUnit);
+		solAssert(m_sourceUnit->experimentalSolidity());
+	}
+	return ASTConstVisitor::visitNode(_node);
+}
diff --git a/compiler/libsolidity/analysis/SyntaxChecker.h b/compiler/libsolidity/analysis/SyntaxChecker.h
index 557acf8c..967417a8 100644
--- a/compiler/libsolidity/analysis/SyntaxChecker.h
+++ b/compiler/libsolidity/analysis/SyntaxChecker.h
@@ -83,8 +83,6 @@ class SyntaxChecker: private ASTConstVisitor
 
 	bool visit(UnaryOperation const& _operation) override;
 
-	bool visit(InlineAssembly const& _inlineAssembly) override;
-
 	bool visit(PlaceholderStatement const& _placeholderStatement) override;
 
 	bool visit(ContractDefinition const& _contract) override;
@@ -98,6 +96,8 @@ class SyntaxChecker: private ASTConstVisitor
 	bool visit(StructDefinition const& _struct) override;
 	bool visit(Literal const& _literal) override;
 
+	bool visitNode(ASTNode const&) override;
+
 	langutil::ErrorReporter& m_errorReporter;
 
 	/// Flag that indicates whether a function modifier actually contains '_'.
diff --git a/compiler/libsolidity/analysis/TypeChecker.cpp b/compiler/libsolidity/analysis/TypeChecker.cpp
index b2a1383d..24d85434 100644
--- a/compiler/libsolidity/analysis/TypeChecker.cpp
+++ b/compiler/libsolidity/analysis/TypeChecker.cpp
@@ -24,6 +24,7 @@
 #include <libsolidity/analysis/TypeChecker.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/ASTUtils.h>
+#include <libsolidity/ast/UserDefinableOperators.h>
 #include <libsolidity/ast/TypeProvider.h>
 
 #include <liblangutil/ErrorReporter.h>
@@ -35,6 +36,9 @@
 
 #include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/predicate.hpp>
+#include  <boost/core/ignore_unused.hpp>
+
+#include <fmt/format.h>
 
 #include <range/v3/algorithm/count_if.hpp>
 #include <range/v3/view/drop_exactly.hpp>
@@ -44,11 +48,9 @@
 #include <memory>
 #include <vector>
 
-#include "../codegen/TVMCommons.hpp"
-#include "../codegen/TVMConstants.hpp"
-
+#include <libsolidity/codegen/TVMCommons.hpp>
+#include <libsolidity/codegen/TVMConstants.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::langutil;
@@ -129,7 +131,7 @@ void TypeChecker::checkDoubleStorageAssignment(Assignment const& _assignment)
 
 TypePointers TypeChecker::getReturnTypesForTVMConfig(FunctionCall const& _functionCall)
 {
-	vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
 	if (arguments.size() != 1)
 		m_errorReporter.typeError(
 			7750_error,
@@ -139,7 +141,7 @@ TypePointers TypeChecker::getReturnTypesForTVMConfig(FunctionCall const& _functi
 			" were provided."
 		);
 
-	set<std::string> availableParams {"1","15","17","34"};
+	std::set<std::string> availableParams {"1","15","17","34"};
 	auto paramNumberLiteral = dynamic_cast<const Literal *>(arguments[0].get());
 
 	if (!paramNumberLiteral)
@@ -189,8 +191,8 @@ TypePointers TypeChecker::getReturnTypesForTVMConfig(FunctionCall const& _functi
 									  TypeProvider::integer(16, IntegerType::Modifier::Unsigned),
 									  TypeProvider::integer(16, IntegerType::Modifier::Unsigned),
 									  TypeProvider::integer(64, IntegerType::Modifier::Unsigned),
-									  TypeProvider::mapping(TypeProvider::integer(16, IntegerType::Modifier::Unsigned),
-																TypeProvider::tvmslice()),
+									  TypeProvider::mapping(TypeProvider::integer(16, IntegerType::Modifier::Unsigned), "",
+																TypeProvider::tvmslice(), ""),
 									  TypeProvider::boolean()};
 		return ret;
 	}
@@ -199,7 +201,7 @@ TypePointers TypeChecker::getReturnTypesForTVMConfig(FunctionCall const& _functi
 
 TypePointers TypeChecker::typeCheckABIDecodeAndRetrieveReturnType(FunctionCall const& _functionCall, bool _abiEncoderV2)
 {
-	vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
 	if (arguments.size() != 2)
 		m_errorReporter.typeError(
 			5782_error,
@@ -250,7 +252,6 @@ TypePointers TypeChecker::typeCheckABIDecodeAndRetrieveReturnType(FunctionCall c
 			// We force memory because the parser currently cannot handle
 			// data locations. Furthermore, storage can be a little dangerous and
 			// calldata is not really implemented anyway.
-			actualType = TypeProvider::withLocationIfReference(actualType);
 			if (!actualType->fullEncodingType(false, _abiEncoderV2, false))
 				m_errorReporter.typeError(
 					9611_error,
@@ -269,19 +270,19 @@ TypePointers TypeChecker::typeCheckABIDecodeAndRetrieveReturnType(FunctionCall c
 	return components;
 }
 
-void TypeChecker::typeCheckTVMBuildStateInit(
+void TypeChecker::typeCheckABIEncodeStateInit(
 	FunctionCall const& _functionCall,
 	const std::function<bool(const std::string&)>& hasName,
 	const std::function<int(const std::string&)>& findName
 ) {
 	bool hasNames = !_functionCall.names().empty();
-	const vector<ASTPointer<const Expression>> &args = _functionCall.arguments();
+	const std::vector<ASTPointer<const Expression>> &args = _functionCall.arguments();
 	size_t argCnt = args.size();
 	if (!hasNames && argCnt != 3 && argCnt != 2)
 		m_errorReporter.typeError(
 				6303_error,
 				_functionCall.location(),
-				string("If parameters are set without names, only 2 or 3 arguments can be specified.")
+				std::string("If parameters are set without names, only 2 or 3 arguments can be specified.")
 		);
 
 	if (hasNames) {
@@ -291,98 +292,79 @@ void TypeChecker::typeCheckTVMBuildStateInit(
 		bool hasPubkey = hasName("pubkey");
 		bool hasContr = hasName("contr");
 
-		if (!hasCode) {
+		if (!hasCode)
 			m_errorReporter.typeError(
-					6128_error,
-					_functionCall.location(),
-					string("Parameter \"code\" must be set.")
+				6128_error,
+				_functionCall.location(),
+				std::string("Parameter \"code\" must be set.")
 			);
-		}
-		if (hasData && (hasVarInit || hasPubkey)) {
+		if (hasData && (hasVarInit || hasPubkey))
 			m_errorReporter.typeError(
-					6578_error,
-					_functionCall.location(),
-					string(R"(Parameter "data" can't be specified with "pubkey" or "varInit".)")
+				6578_error,
+				_functionCall.location(),
+				std::string(R"(Parameter "data" can't be specified with "pubkey" or "varInit".)")
 			);
-		}
-		if (hasVarInit != hasContr) {
+		if (!hasContr && !hasData)
 			m_errorReporter.typeError(
-					1476_error,
-					_functionCall.location(),
-					string(R"(Parameter "varInit" requires parameter "contr" and there is no need in "contr" without "varInit".)")
+				8123_error,
+				_functionCall.location(),
+				std::string(R"(Expected parameter "contr" or "data".)")
 			);
-		}
-
 		if (hasContr) {
 			int contrInd = findName("contr");
 			const ASTPointer<Expression const>& contrArg = args.at(contrInd);
 			ContractType const* ct = getContractType(contrArg.get());
 			if (ct == nullptr) {
 				m_errorReporter.typeError(
-						8286_error,
-						contrArg->location(),
-						"Expected contract type."
+					8286_error,
+					contrArg->location(),
+					"Expected contract type."
 				);
-				return;
+				return ;
 			}
+			InitializerList const * list{};
 			int varInitInd = findName("varInit");
-			if (varInitInd == -1) {
-				return;
-			}
-			auto list = dynamic_cast<InitializerList const *>(args.at(varInitInd).get());
-			if (!list) {
-				// It's checked in typeCheckFunctionCall function
-				return;
-			}
-			checkInitList(list, ct);
+			if (varInitInd != -1)
+				list = dynamic_cast<InitializerList const *>(args.at(varInitInd).get());
+			checkInitList(list, *ct, _functionCall.location());
 		}
 	}
 }
 
-void TypeChecker::typeCheckTVMBuildDataInit(
+void TypeChecker::typeCheckABIEncodeData(
 	FunctionCall const& _functionCall,
 	const std::function<bool(const std::string&)>& hasName,
 	const std::function<int(const std::string&)>& findName
 ) {
-	bool hasNames = !_functionCall.names().empty();
-	const vector<ASTPointer<const Expression>> &args = _functionCall.arguments();
+	const std::vector<ASTPointer<const Expression>> &args = _functionCall.arguments();
 
-	if (hasNames) {
-		bool hasVarInit = hasName("varInit");
-		bool hasContr = hasName("contr");
+	if (!hasName("contr")) {
+		m_errorReporter.typeError(
+			2957_error,
+			_functionCall.location(),
+			std::string(R"(Expected parameter "contr".)")
+		);
+		return ;
+	}
 
-		if (hasVarInit != hasContr) {
-			m_errorReporter.typeError(
-					2957_error,
-					_functionCall.location(),
-					string(R"(Parameter "varInit" requires parameter "contr" and there is no need in "contr" without "varInit".)")
-			);
-		}
+	int contrInd = findName("contr");
+	const ASTPointer<Expression const>& contrArg = args.at(contrInd);
+	ContractType const* ct = getContractType(contrArg.get());
+	if (ct == nullptr) {
+		m_errorReporter.typeError(
+			9417_error,
+			contrArg->location(),
+			"Expected contract type."
+		);
+		return;
+	}
 
-		if (hasContr) {
-			int contrInd = findName("contr");
-			const ASTPointer<Expression const>& contrArg = args.at(contrInd);
-			ContractType const* ct = getContractType(contrArg.get());
-			if (ct == nullptr) {
-				m_errorReporter.typeError(
-						9417_error,
-						contrArg->location(),
-						"Expected contract type."
-				);
-				return;
-			}
-			int varInitInd = findName("varInit");
-			if (varInitInd == -1) {
-				return;
-			}
-			auto list = dynamic_cast<InitializerList const *>(args.at(varInitInd).get());
-			if (!list) {
-				// It's checked in typeCheckFunctionCall function
-				return;
-			}
-			checkInitList(list, ct);
-		}
+	InitializerList const * list{};
+	int varInitInd = findName("varInit");
+	if (varInitInd != -1) {
+		list = dynamic_cast<InitializerList const *>(args.at(varInitInd).get());
 	}
+	checkInitList(list, *ct, _functionCall.location());
 }
 
 void TypeChecker::typeCheckCallBack(FunctionType const* remoteFunction, Expression const& option) {
@@ -502,7 +484,7 @@ TypePointers TypeChecker::checkSliceDecodeQ(std::vector<ASTPointer<Expression co
 
 TypePointers TypeChecker::typeCheckMetaTypeFunctionAndRetrieveReturnType(FunctionCall const& _functionCall)
 {
-	vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
 	if (arguments.size() != 1)
 		m_errorReporter.fatalTypeError(
 			8885_error,
@@ -573,7 +555,7 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 				toString(arguments->size()) +
 				" arguments given but expected " +
 				toString(parameterTypes.size()) +
-				". Remove parentheses if you do not want to provide arguments here."
+				(arguments->size() == 0 ? ". Remove parentheses if you do not want to provide arguments here." : "")
 			);
 		}
 		for (size_t i = 0; i < std::min(arguments->size(), parameterTypes.size()); ++i)
@@ -776,12 +758,59 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 		}
 	}
 
-	vector<VariableDeclaration const*> internalParametersInConstructor;
+	std::vector<VariableDeclaration const*> internalParametersInConstructor;
+
+	auto checkArgumentAndReturnParameter = [&](VariableDeclaration const& _var) {
+		bool functionIsExternallyVisible =
+			(!_function.isConstructor() && _function.isPublic()) ||
+			(_function.isConstructor() && !m_currentContract->abstract());
+		if (functionIsExternallyVisible)
+		{
+			auto iType = type(_var)->interfaceType(_function.libraryFunction());
 
-	set<Declaration const*> modifiers;
+			if (!iType)
+			{
+				std::string message = iType.message();
+				solAssert(!message.empty(), "Expected detailed error message!");
+				if (_function.isConstructor())
+					message += " You can make the contract abstract to avoid this problem.";
+				m_errorReporter.fatalTypeError(4103_error, _var.location(), message);
+			}
+			else if (
+				!useABICoderV2() &&
+				!typeSupportedByOldABIEncoder(*type(_var), _function.libraryFunction())
+			)
+			{
+				std::string message =
+					"This type is only supported in ABI coder v2. "
+					"Use \"pragma abicoder v2;\" to enable the feature.";
+				if (_function.isConstructor())
+					message +=
+						" Alternatively, make the contract abstract and supply the "
+						"constructor arguments from a derived contract.";
+				m_errorReporter.typeError(
+					4957_error,
+					_var.location(),
+					message
+				);
+			}
+		}
+	};
+	for (ASTPointer<VariableDeclaration> const& var: _function.parameters())
+	{
+		checkArgumentAndReturnParameter(*var);
+		var->accept(*this);
+	}
+	for (ASTPointer<VariableDeclaration> const& var: _function.returnParameters())
+	{
+		checkArgumentAndReturnParameter(*var);
+		var->accept(*this);
+	}
+
+	std::set<Declaration const*> modifiers;
 	for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers())
 	{
-		vector<ContractDefinition const*> baseContracts;
+		std::vector<ContractDefinition const*> baseContracts;
 		if (auto contract = dynamic_cast<ContractDefinition const*>(_function.scope()))
 		{
 			baseContracts = contract->annotation().linearizedBaseContracts;
@@ -791,7 +820,7 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 
 		visitManually(
 			*modifier,
-			_function.isConstructor() ? baseContracts : vector<ContractDefinition const*>()
+			_function.isConstructor() ? baseContracts : std::vector<ContractDefinition const*>()
 		);
 		Declaration const* decl = &dereference(modifier->name());
 		if (modifiers.count(decl))
@@ -854,7 +883,7 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 			for (ASTPointer<VariableDeclaration> const &var : params) {
 				std::set<StructDefinition const *> usedStructs;
 				isBadAbiType(var.get()->location(), var->type(), var.get()->location(), usedStructs, true);
-				var->accept(*this);
+//				var->accept(*this);
 			}
 		}
 	}
@@ -921,7 +950,7 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 		FunctionType getter(_variable);
 		if (!useABICoderV2())
 		{
-			vector<string> unsupportedTypes;
+			std::vector<std::string> unsupportedTypes;
 			for (auto const& param: getter.parameterTypes() + getter.returnParameterTypes())
 				if (!typeSupportedByOldABIEncoder(*param, false /* isLibrary */))
 					unsupportedTypes.emplace_back(param->humanReadableName());
@@ -1017,7 +1046,7 @@ void TypeChecker::endVisit(StructDefinition const& _struct)
 
 void TypeChecker::visitManually(
 	ModifierInvocation const& _modifier,
-	vector<ContractDefinition const*> const& _bases
+	std::vector<ContractDefinition const*> const& _bases
 )
 {
 	std::vector<ASTPointer<Expression>> const& arguments =
@@ -1028,8 +1057,8 @@ void TypeChecker::visitManually(
 	_modifier.name().accept(*this);
 
 	auto const* declaration = &dereference(_modifier.name());
-	vector<ASTPointer<VariableDeclaration>> emptyParameterList;
-	vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
+	std::vector<ASTPointer<VariableDeclaration>> emptyParameterList;
+	std::vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
 	if (auto modifierDecl = dynamic_cast<ModifierDefinition const*>(declaration))
 	{
 		parameters = &modifierDecl->parameters();
@@ -1138,11 +1167,6 @@ void TypeChecker::endVisit(FunctionTypeName const& _funType)
 	}
 }
 
-bool TypeChecker::visit(InlineAssembly const& /*_inlineAssembly*/)
-{
-	return true;
-}
-
 bool TypeChecker::visit(IfStatement const& _ifStatement)
 {
 	expectType(_ifStatement.condition(), *TypeProvider::boolean());
@@ -1185,7 +1209,7 @@ bool TypeChecker::visit(WhileStatement const& _whileStatement)
 			expectType(_whileStatement.condition(), *TypeProvider::boolean());
 			break;
 		case WhileStatement::LoopType::REPEAT:
-			expectType(_whileStatement.condition(), *TypeProvider::uint256());
+			expectType(_whileStatement.condition(), *TypeProvider::integer(31, IntegerType::Modifier::Unsigned));
 			break;
 	}
 
@@ -1289,7 +1313,7 @@ void TypeChecker::endVisit(Return const& _return)
 		for (size_t i = 0; i < _return.names().size(); ++i) {
 			const std::string &name = *_return.names().at(i);
 			const std::map<std::string, Type const *> nameToType = {
-					{"value",      TypeProvider::uint(128)},
+					{"value",      TypeProvider::coins()},
 					{"currencies", TypeProvider::extraCurrencyCollection()},
 					{"bounce",     TypeProvider::boolean()},
 					{"flag",       TypeProvider::uint(16)},
@@ -1435,15 +1459,14 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 	// the variable declaration(s).
 
 	_statement.initialValue()->accept(*this);
-	vector<ASTPointer<VariableDeclaration>> const& variables = _statement.declarations();
+	std::vector<ASTPointer<VariableDeclaration>> const& variables = _statement.declarations();
 	TypePointers valueTypes;
 	if (auto tupleType = dynamic_cast<TupleType const*>(type(*_statement.initialValue()))) {
 		valueTypes = tupleType->components();
 		if (valueTypes.size() != variables.size())
 			valueTypes = TypePointers{tupleType};
-	} else {
+	} else
 		valueTypes = TypePointers{type(*_statement.initialValue())};
-	}
 
 	if (variables.empty())
 		// We already have an error for this in the SyntaxChecker.
@@ -1459,7 +1482,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 			")."
 		);
 
-	for (size_t i = 0; i < min(variables.size(), valueTypes.size()); ++i)
+	for (size_t i = 0; i < std::min(variables.size(), valueTypes.size()); ++i)
 	{
 		if (!variables[i])
 			continue;
@@ -1616,14 +1639,14 @@ void TypeChecker::checkExpressionAssignment(Type const& _type, Expression const&
 			m_errorReporter.typeError(5547_error, _expression.location(), "Empty tuple on the left hand side.");
 
 		auto const* tupleType = dynamic_cast<TupleType const*>(&_type);
-		auto const& types = tupleType && tupleExpression->components().size() != 1 ? tupleType->components() : vector<Type const*> { &_type };
+		auto const& types = tupleType && tupleExpression->components().size() != 1 ? tupleType->components() : std::vector<Type const*> { &_type };
 
 		solAssert(
 			tupleExpression->components().size() == types.size() || m_errorReporter.hasErrors(),
 			"Array sizes don't match and no errors generated."
 		);
 
-		for (size_t i = 0; i < min(tupleExpression->components().size(), types.size()); i++)
+		for (size_t i = 0; i < std::min(tupleExpression->components().size(), types.size()); i++)
 			if (types[i])
 			{
 				solAssert(!!tupleExpression->components()[i], "");
@@ -1678,7 +1701,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
 				7366_error,
 				_assignment.location(),
 				"Operator " +
-				string(TokenTraits::toString(_assignment.assignmentOperator())) +
+				std::string(TokenTraits::friendlyName(_assignment.assignmentOperator())) +
 				" not compatible with types " +
 				t->humanReadableName() +
 				" and " +
@@ -1692,7 +1715,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
 bool TypeChecker::visit(TupleExpression const& _tuple)
 {
 	_tuple.annotation().isConstant = false;
-	vector<ASTPointer<Expression>> const& components = _tuple.components();
+	std::vector<ASTPointer<Expression>> const& components = _tuple.components();
 	TypePointers types;
 
 	if (_tuple.annotation().willBeWrittenTo)
@@ -1801,23 +1824,66 @@ bool TypeChecker::visit(UnaryOperation const& _operation)
 		requireLValue(_operation.subExpression(), false);
 	else
 		_operation.subExpression().accept(*this);
-	Type const* subExprType = type(_operation.subExpression());
-	TypeResult result = type(_operation.subExpression())->unaryOperatorResult(op);
-	if (!result)
+	Type const* operandType = type(_operation.subExpression());
+
+	// Check if the operator is built-in or user-defined.
+	TypeResult builtinResult = operandType->unaryOperatorResult(op);
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> matchingDefinitions = operandType->operatorDefinitions(
+		op,
+		*currentDefinitionScope(),
+		true // _unary
+	);
+
+	// Operator can't be both user-defined and built-in at the same time.
+	solAssert(!builtinResult || matchingDefinitions.empty());
+
+	// By default use the type we'd expect from correct code. This way we can continue analysis
+	// of other expressions in a sensible way in case of a non-fatal error.
+	Type const* resultType = operandType;
+
+	FunctionDefinition const* operatorDefinition = nullptr;
+	if (builtinResult)
+		resultType = builtinResult;
+	else if (!matchingDefinitions.empty())
+	{
+		// This is checked along with `using for` directive but the error is not fatal.
+		if (matchingDefinitions.size() != 1)
+			solAssert(m_errorReporter.hasErrors());
+
+		operatorDefinition = *matchingDefinitions.begin();
+	}
+	else
 	{
-		string description = "Unary operator " + string(TokenTraits::toString(op)) + " cannot be applied to type " + subExprType->humanReadableName() + "." + (!result.message().empty() ? " " + result.message() : "");
+		std::string description = fmt::format(
+			"Built-in unary operator {} cannot be applied to type {}.",
+			TokenTraits::friendlyName(op),
+			operandType->humanReadableName()
+		);
+		if (!builtinResult.message().empty())
+			description += " " + builtinResult.message();
+		if (operandType->typeDefinition() && util::contains(userDefinableOperators, op))
+			description += " No matching user-defined operator found.";
+
 		if (modifying)
 			// Cannot just report the error, ignore the unary operator, and continue,
 			// because the sub-expression was already processed with requireLValue()
 			m_errorReporter.fatalTypeError(9767_error, _operation.location(), description);
 		else
 			m_errorReporter.typeError(4907_error, _operation.location(), description);
-		_operation.annotation().type = subExprType;
 	}
-	else
-		_operation.annotation().type = result.get();
+
+	_operation.annotation().userDefinedFunction = operatorDefinition;
+
+	if (operatorDefinition && !_operation.userDefinedFunctionType()->returnParameterTypes().empty())
+		// Use the actual result type from operator definition. Ignore all values but the
+		// first one - in valid code there will be only one anyway.
+		resultType = _operation.userDefinedFunctionType()->returnParameterTypes()[0];
+	_operation.annotation().type = resultType;
 	_operation.annotation().isConstant = false;
-	_operation.annotation().isPure = !modifying && *_operation.subExpression().annotation().isPure;
+	_operation.annotation().isPure =
+		!modifying &&
+		*_operation.subExpression().annotation().isPure &&
+		(!_operation.userDefinedFunctionType() || _operation.userDefinedFunctionType()->isPure());
 	_operation.annotation().isLValue = false;
 
 	return false;
@@ -1827,37 +1893,122 @@ void TypeChecker::endVisit(BinaryOperation const& _operation)
 {
 	Type const* leftType = type(_operation.leftExpression());
 	Type const* rightType = type(_operation.rightExpression());
-	TypeResult result = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
-	Type const* commonType = result.get();
-	if (!commonType)
+
+	// Check if the operator is built-in or user-defined.
+	TypeResult builtinResult = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> matchingDefinitions = leftType->operatorDefinitions(
+		_operation.getOperator(),
+		*currentDefinitionScope(),
+		false // _unary
+	);
+
+	// Operator can't be both user-defined and built-in at the same time.
+	solAssert(!builtinResult || matchingDefinitions.empty());
+
+	Type const* commonType = nullptr;
+	FunctionDefinition const* operatorDefinition = nullptr;
+	if (builtinResult)
+		commonType = builtinResult.get();
+	else if (!matchingDefinitions.empty())
 	{
-		m_errorReporter.typeError(
-			2271_error,
-			_operation.location(),
-			"Operator " +
-			string(TokenTraits::toString(_operation.getOperator())) +
-			" not compatible with types " +
-			leftType->humanReadableName() +
-			" and " +
-			rightType->humanReadableName() + "." +
-			(!result.message().empty() ? " " + result.message() : "")
+		// This is checked along with `using for` directive but the error is not fatal.
+		if (matchingDefinitions.size() != 1)
+			solAssert(m_errorReporter.hasErrors());
+
+		operatorDefinition = *matchingDefinitions.begin();
+
+		// Set common type to the type used in the `using for` directive.
+		commonType = leftType;
+	}
+	else
+	{
+		std::string description = fmt::format(
+			"Built-in binary operator {} cannot be applied to types {} and {}.",
+			TokenTraits::friendlyName(_operation.getOperator()),
+			leftType->humanReadableName(),
+			rightType->humanReadableName()
 		);
+		if (!builtinResult.message().empty())
+			description += " " + builtinResult.message();
+		if (leftType->typeDefinition() && util::contains(userDefinableOperators, _operation.getOperator()))
+			description += " No matching user-defined operator found.";
+
+		m_errorReporter.typeError(2271_error, _operation.location(), description);
+
+		// Set common type to something we'd expect from correct code just so that we can continue analysis.
 		commonType = leftType;
 	}
+
 	_operation.annotation().commonType = commonType;
-	_operation.annotation().type =
+	_operation.annotation().userDefinedFunction = operatorDefinition;
+	FunctionType const* userDefinedFunctionType = _operation.userDefinedFunctionType();
+
+	// By default use the type we'd expect from correct code. This way we can continue analysis
+	// of other expressions in a sensible way in case of a non-fatal error.
+	Type const* resultType =
 		TokenTraits::isCompareOp(_operation.getOperator()) ?
 		TypeProvider::boolean() :
 		commonType;
+
+	if (operatorDefinition)
+	{
+		TypePointers const& parameterTypes = userDefinedFunctionType->parameterTypes();
+		TypePointers const& returnParameterTypes = userDefinedFunctionType->returnParameterTypes();
+
+		// operatorDefinitions() filters out definitions with non-matching first argument.
+		solAssert(parameterTypes.size() == 2);
+		solAssert(parameterTypes[0] && *leftType == *parameterTypes[0]);
+
+		if (*rightType != *parameterTypes[0])
+			m_errorReporter.typeError(
+				5653_error,
+				_operation.location(),
+				fmt::format(
+					"The type of the second operand of this user-defined binary operator {} "
+					"does not match the type of the first operand, which is {}.",
+					TokenTraits::friendlyName(_operation.getOperator()),
+					parameterTypes[0]->humanReadableName()
+				)
+			);
+
+		if (!returnParameterTypes.empty())
+			// Use the actual result type from operator definition. Ignore all values but the
+			// first one - in valid code there will be only one anyway.
+			resultType = returnParameterTypes[0];
+	}
+
+	_operation.annotation().type = resultType;
 	_operation.annotation().isPure =
 		*_operation.leftExpression().annotation().isPure &&
-		*_operation.rightExpression().annotation().isPure;
+		*_operation.rightExpression().annotation().isPure &&
+		(!userDefinedFunctionType || userDefinedFunctionType->isPure());
 	_operation.annotation().isLValue = false;
 	_operation.annotation().isConstant = false;
 
+	if (_operation.getOperator() == Token::Equal || _operation.getOperator() == Token::NotEqual)
+	{
+		auto const* leftFunction = dynamic_cast<FunctionType const*>(leftType);
+		auto const* rightFunction = dynamic_cast<FunctionType const*>(rightType);
+		if (
+			leftFunction &&
+			rightFunction &&
+			leftFunction->kind() == FunctionType::Kind::Internal &&
+			rightFunction->kind() == FunctionType::Kind::Internal
+		)
+		{
+			m_errorReporter.warning(
+				3075_error,
+				_operation.location(),
+				"Comparison of internal function pointers can yield unexpected results "
+				"in the legacy pipeline with the optimizer enabled, and will be disallowed entirely "
+				"in the next breaking release."
+			);
+		}
+	}
+
 	if (_operation.getOperator() == Token::Exp || _operation.getOperator() == Token::SHL)
 	{
-		string operation = _operation.getOperator() == Token::Exp ? "exponentiation" : "shift";
+		std::string operation = _operation.getOperator() == Token::Exp ? "exponentiation" : "shift";
 		if (
 			leftType->category() == Type::Category::RationalNumber &&
 			rightType->category() != Type::Category::RationalNumber
@@ -1878,14 +2029,14 @@ void TypeChecker::endVisit(BinaryOperation const& _operation)
 			m_errorReporter.warning(
 				3149_error,
 				_operation.location(),
-				"The result type of the " +
-				operation +
-				" operation is equal to the type of the first operand (" +
-				commonType->humanReadableName() +
-				") ignoring the (larger) type of the second operand (" +
-				rightType->humanReadableName() +
-				") which might be unexpected. Silence this warning by either converting "
-				"the first or the second operand to the type of the other."
+				fmt::format(
+					"The result type of the {} operation is equal to the type of the first operand ({}) "
+					"ignoring the (larger) type of the second operand ({}) which might be unexpected. "
+					"Silence this warning by either converting the first or the second operand to the type of the other.",
+					operation,
+					commonType->humanReadableName(),
+					rightType->humanReadableName()
+				)
 			);
 	}
 }
@@ -1897,12 +2048,14 @@ Type const* TypeChecker::typeCheckTypeConversionAndRetrieveReturnType(
 	solAssert(*_functionCall.annotation().kind == FunctionCallKind::TypeConversion, "");
 	Type const* expressionType = type(_functionCall.expression());
 
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
 	bool const isPositionalCall = _functionCall.names().empty();
 
 	Type const* resultType = dynamic_cast<TypeType const&>(*expressionType).actualType();
-	if (arguments.empty() && resultType->category() == Type::Category::TvmCell)
-	{
+	if (arguments.empty() &&
+			(resultType->category() == Type::Category::TvmCell ||
+			 resultType->category() == Type::Category::TvmBuilder)
+	) {
 		// all right
 	}
 	else if (arguments.size() != 1)
@@ -1923,8 +2076,6 @@ Type const* TypeChecker::typeCheckTypeConversionAndRetrieveReturnType(
 		// Resulting data location is memory unless we are converting from a reference
 		// type with a different data location.
 		// (data location cannot yet be specified for type conversions)
-		if (auto type = dynamic_cast<ReferenceType const*>(resultType))
-			resultType = TypeProvider::withLocation(type, type->isPointer());
 		BoolResult result = argType->isExplicitlyConvertibleTo(*resultType);
 		if (result)
 		{
@@ -2127,7 +2278,7 @@ void TypeChecker::checkNeedCallback(FunctionType const* callee, ASTNode const& n
 			m_errorReporter.typeError(
 					9205_error,
 					node.location(),
-					SecondarySourceLocation().append("Declaration is here:", funcDef->location()),
+					SecondarySourceLocation().append("The declaration is here:", funcDef->location()),
 					R"("callback" option must be set because callee function is marked as responsible.)"
 			);
 		}
@@ -2175,7 +2326,7 @@ void TypeChecker::typeCheckTvmEncodeArg(Type const* type, Expression const& node
 }
 
 void TypeChecker::typeCheckTvmEncodeFunctions(FunctionCall const& _functionCall) {
-	vector<ASTPointer<Expression const>> const &arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> const &arguments = _functionCall.arguments();
 	for (const auto & argument : arguments) {
 		auto const &argType = type(*argument);
 		typeCheckTvmEncodeArg(argType, *argument);
@@ -2225,7 +2376,7 @@ void TypeChecker::typeCheckABIEncodeFunctions(
 	}
 
 	// Check additional arguments for variadic functions
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
 	for (size_t i = 0; i < arguments.size(); ++i)
 	{
 		auto const& argType = type(*arguments[i]);
@@ -2324,7 +2475,7 @@ ContractType const* TypeChecker::getContractType(Expression const* expr) {
 
 void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCall)
 {
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
 
 	// Expecting first argument to be the function pointer and second to be a tuple.
 	if (arguments.size() != 2)
@@ -2361,7 +2512,7 @@ void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCa
 		externalFunctionType->kind() != FunctionType::Kind::Declaration
 	)
 	{
-		string msg = "Expected regular external function type, or external view on public function.";
+		std::string msg = "Expected regular external function type, or external view on public function.";
 
 		switch (externalFunctionType->kind())
 		{
@@ -2410,7 +2561,7 @@ void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCa
 	}
 	solAssert(!externalFunctionType->takesArbitraryParameters(), "Function must have fixed parameters.");
 	// Tuples with only one component become that component
-	vector<ASTPointer<Expression const>> callArguments;
+	std::vector<ASTPointer<Expression const>> callArguments;
 
 	auto const* tupleType = dynamic_cast<TupleType const*>(type(*arguments[1]));
 	if (tupleType)
@@ -2437,9 +2588,9 @@ void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCa
 				7788_error,
 				_functionCall.location(),
 				"Expected " +
-				to_string(externalFunctionType->parameterTypes().size()) +
+				std::to_string(externalFunctionType->parameterTypes().size()) +
 				" instead of " +
-				to_string(callArguments.size()) +
+				std::to_string(callArguments.size()) +
 				" components for the tuple parameter."
 			);
 		else
@@ -2447,13 +2598,13 @@ void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCa
 				7515_error,
 				_functionCall.location(),
 				"Expected a tuple with " +
-				to_string(externalFunctionType->parameterTypes().size()) +
+				std::to_string(externalFunctionType->parameterTypes().size()) +
 				" components instead of a single non-tuple parameter."
 			);
 	}
 
 	// Use min() to check as much as we can before failing fatally
-	size_t const numParameters = min(callArguments.size(), externalFunctionType->parameterTypes().size());
+	size_t const numParameters = std::min(callArguments.size(), externalFunctionType->parameterTypes().size());
 
 	for (size_t i = 0; i < numParameters; i++)
 	{
@@ -2464,7 +2615,7 @@ void TypeChecker::typeCheckABIEncodeCallFunction(FunctionCall const& _functionCa
 				5407_error,
 				callArguments[i]->location(),
 				"Cannot implicitly convert component at position " +
-				to_string(i) +
+				std::to_string(i) +
 				" from \"" +
 				argType.humanReadableName() +
 				"\" to \"" +
@@ -2487,7 +2638,7 @@ void TypeChecker::typeCheckStringConcatFunction(
 
 	typeCheckFunctionGeneralChecks(_functionCall, _functionType);
 
-	for (shared_ptr<Expression const> const& argument: _functionCall.arguments())
+	for (std::shared_ptr<Expression const> const& argument: _functionCall.arguments())
 	{
 		Type const* argumentType = type(*argument);
 		bool notConvertibleToString = !argumentType->isImplicitlyConvertibleTo(*TypeProvider::stringMemory());
@@ -2514,7 +2665,7 @@ void TypeChecker::typeCheckBytesConcatFunction(
 
 	typeCheckFunctionGeneralChecks(_functionCall, _functionType);
 
-	for (shared_ptr<Expression const> const& argument: _functionCall.arguments())
+	for (std::shared_ptr<Expression const> const& argument: _functionCall.arguments())
 	{
 		Type const* argumentType = type(*argument);
 		bool notConvertibleToBytes =
@@ -2555,8 +2706,8 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 	);
 
 	TypePointers const& parameterTypes = _functionType->parameterTypes();
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
-	vector<ASTPointer<ASTString>> const& argumentNames = _functionCall.names();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<ASTString>> const& argumentNames = _functionCall.names();
 	bool isFunctionWithDefaultValues = false;
 	{
 		auto ma = dynamic_cast<MemberAccess const*>(&_functionCall.expression());
@@ -2564,9 +2715,14 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 			isFunctionWithDefaultValues = true;
 		}
 		if (ma && dynamic_cast<MagicType const *>(ma->expression().annotation().type)) {
-			if (ma->memberName() == "buildStateInit" ||
+			if (ma->memberName() == "encodeStateInit" ||
+				ma->memberName() == "buildStateInit" ||
 				ma->memberName() == "buildDataInit" ||
+				ma->memberName() == "encodeData" ||
+				ma->memberName() == "encodeOldDataInit" ||
 				ma->memberName() == "buildExtMsg" ||
+				ma->memberName() == "encodeExtMsg" ||
+				ma->memberName() == "encodeIntMsg" ||
 				ma->memberName() == "buildIntMsg")
 			isFunctionWithDefaultValues = true;
 		}
@@ -2580,22 +2736,22 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 		bool const isStructConstructorCall =
 			functionCallKind == FunctionCallKind::StructConstructorCall;
 
-		auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
-			string msg = isVariadic ?
+		auto [errorId, description] = [&]() -> std::tuple<ErrorId, std::string> {
+			std::string msg = isVariadic ?
 				"Need at least " +
 				toString(parameterTypes.size()) +
 				" arguments for " +
-				string(isStructConstructorCall ? "struct constructor" : "function call") +
+				std::string(isStructConstructorCall ? "struct constructor" : "function call") +
 				", but provided only " +
 				toString(arguments.size()) +
 				"."
 				:
 				"Wrong argument count for " +
-				string(isStructConstructorCall ? "struct constructor" : "function call") +
+				std::string(isStructConstructorCall ? "struct constructor" : "function call") +
 				": " +
 				toString(arguments.size()) +
 				" arguments given but " +
-				string(isVariadic ? "need at least " : "expected ") +
+				std::string(isVariadic ? "need at least " : "expected ") +
 				toString(parameterTypes.size()) +
 				".";
 
@@ -2701,8 +2857,8 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 				{
 					if (j < paramArgMap.size())
 						paramArgMap[j] = nullptr;
-					if ((_functionType->kind() == FunctionType::Kind::TVMBuildStateInit ||
-							_functionType->kind() == FunctionType::Kind::TVMBuildDataInit)
+					if ((_functionType->kind() == FunctionType::Kind::ABIEncodeStateInit ||
+							_functionType->kind() == FunctionType::Kind::ABIEncodeData)
 							&& *argumentNames.at(i) == "contr")
 					{
 						// Do nothing.
@@ -2755,12 +2911,12 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 			continue;
 		}
 		solAssert(!!paramArgMap[i], "unmapped parameter");
-		vector<string> const &parameterNames = _functionType->parameterNames();
+		std::vector<std::string> const &parameterNames = _functionType->parameterNames();
 		if (i >= parameterNames.size()) {
 			m_errorReporter.fatalTypeError(3774_error, paramArgMap[i]->location(), "Too many arguments.");
 		}
 		if (!parameterNames.empty()) {
-			string const &argName = parameterNames.at(i);
+			std::string const &argName = parameterNames.at(i);
 			if (_ignoreOptions.count(argName)) {
 				continue;
 			}
@@ -2768,8 +2924,8 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 		BoolResult result = type(*paramArgMap[i])->isImplicitlyConvertibleTo(*parameterTypes[i]);
 		if (!result)
 		{
-			auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
-				string msg =
+			auto [errorId, description] = [&]() -> std::tuple<ErrorId, std::string> {
+				std::string msg =
 					"Invalid type for argument in function call. "
 					"Invalid implicit conversion from " +
 					type(*paramArgMap[i])->humanReadableName() +
@@ -2884,9 +3040,9 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 		}
 
 		auto names = functionCallOpt->names();
-		const vector<ASTPointer<const Expression>> &options = functionCallOpt->options();
+		const std::vector<ASTPointer<const Expression>> &options = functionCallOpt->options();
 		for (size_t i = 0; i < names.size(); ++i) {
-			string const &name = *(names[i]);
+			std::string const &name = *(names[i]);
 			if (std::find(arr.begin(), arr.end(), name) == arr.end()) {
 				m_errorReporter.typeError(
 						4187_error,
@@ -2902,7 +3058,7 @@ void TypeChecker::typeCheckFunctionGeneralChecks(
 					expectType(*options[i], *TypeProvider::uint256());
 			}
 		}
-		auto getId = [&](string const & param) {
+		auto getId = [&](std::string const & param) {
 			auto it = find_if(names.begin(), names.end(), [&](auto el){
 				return *el == param;
 			});
@@ -2946,7 +3102,7 @@ TypeChecker::checkPubFunctionAndGetDefinition(Expression const& arg, bool printE
 			m_errorReporter.fatalTypeError(
 					6273_error,
 					arg.location(),
-					SecondarySourceLocation().append("Declaration is here:", funcDef->location()),
+					SecondarySourceLocation().append("The declaration is here:", funcDef->location()),
 					"Public/external function or contract type required, but \"" +
 					Declaration::visibilityToString(funcDef->visibility()) +
 					"\" function is provided."
@@ -2984,22 +3140,58 @@ TypeChecker::checkPubFunctionOrContractTypeAndGetDefinition(Expression const& ar
 	return constructorDef;
 }
 
-void TypeChecker::checkInitList(InitializerList const *list, ContractType const *ct) {
-	vector<tuple<VariableDeclaration const*, u256, unsigned>> vars = ct->stateVariables();
+void TypeChecker::checkInitList(InitializerList const* list, ContractType const& ct,
+								langutil::SourceLocation const& _functionCallLocation
+) {
+	std::vector<VariableDeclaration const*> stateVariables;
+	for (auto const &[v, _, ___] : ct.stateVariables()) {
+		boost::ignore_unused(_);
+		boost::ignore_unused(___);
+		stateVariables.push_back(v);
+	}
+
+	if (list == nullptr) {
+		for (VariableDeclaration const* v : stateVariables) {
+			if (v->isStatic()) {
+				m_errorReporter.typeError(
+					8332_error,
+					_functionCallLocation,
+					SecondarySourceLocation()
+						.append("The declaration of state static variable is here:", v->location()),
+					"Expected \"varInit\" option. All static state variables should be defined."
+				);
+				break;
+			}
+		}
+		return ;
+	}
+
+	std::map<std::string, size_t> usedNamedParams;
 	for (size_t i = 0; i < list->names().size(); ++i) {
 		const std::string name = *list->names().at(i);
+		if (usedNamedParams.count(name) != 0) {
+			size_t prevIndex = usedNamedParams.at(name);
+			m_errorReporter.typeError(
+				4019_error,
+				list->nameLocations().at(i),
+				SecondarySourceLocation()
+						.append("Previous named argument is here:", list->nameLocations().at(prevIndex)),
+				"Duplicate named argument \"" + name + "\"."
+			);
+		}
+		usedNamedParams[name] = i;
 		Type const* exprType = list->options().at(i)->annotation().type;
 		size_t j;
-		for (j = 0; j < vars.size(); ++j) {
-			VariableDeclaration const* v = std::get<0>(vars.at(j));
+		for (j = 0; j < stateVariables.size(); ++j) {
+			VariableDeclaration const* v = stateVariables.at(j);
 			if (name == v->name()) {
 				if (!v->isStatic()) {
 					m_errorReporter.typeError(
-							6626_error,
-							list->options().at(i)->location(),
-							SecondarySourceLocation()
-									.append("Declaration is here:", v->location()),
-							"Initialization of a non-static variable."
+						6626_error,
+						list->nameLocations().at(i),
+						SecondarySourceLocation()
+								.append("The declaration is here:", v->location()),
+						"Initialization of a non-static variable."
 					);
 				} else if (!exprType->isImplicitlyConvertibleTo(*v->type())) {
 					m_errorReporter.typeError(
@@ -3012,20 +3204,32 @@ void TypeChecker::checkInitList(InitializerList const *list, ContractType const
 				break;
 			}
 		}
-		if (j == vars.size()) {
+		if (j == stateVariables.size()) {
 			m_errorReporter.typeError(
 				6711_error,
-				list->options().at(i)->location(),
+				list->nameLocations().at(i),
 				SecondarySourceLocation()
-						.append("Contract is here:", ct->contractDefinition().location()),
+						.append("The contract is here:", ct.contractDefinition().location()),
 				"Unknown state variable \"" + name + "\"."
 			);
 		}
 	}
+
+	for (VariableDeclaration const* v : stateVariables) {
+		if (v->isStatic() && usedNamedParams.count(v->name()) == 0) {
+			m_errorReporter.typeError(
+				6515_error,
+				list->location(),
+				SecondarySourceLocation()
+						.append("The declaration of state static variable is here:", v->location()),
+				"Expected named argument \"" + v->name() + "\" in the list. All static state variables should be defined."
+			);
+		}
+	}
 }
 
 void TypeChecker::checkCallList(
-	vector<Expression const *> const& arguments,
+	std::vector<Expression const *> const& arguments,
 	FunctionCall const& _functionCall,
 	bool ignoreCallBack // for ext msg we set callbackFunctionId==0
 ) {
@@ -3050,7 +3254,7 @@ void TypeChecker::checkCallList(
 					5424_error,
 					_functionCall.location(),
 					SecondarySourceLocation()
-							.append("Declaration is here:", functionDeclaration->location()),
+							.append("The declaration is here:", functionDeclaration->location()),
 					"Wrong arguments count: " +
 					toString(arguments.size()) +
 					" arguments given but expected " +
@@ -3076,7 +3280,7 @@ void TypeChecker::checkCallList(
 			m_errorReporter.fatalTypeError(
 					2182_error,
 					_functionCall.location(),
-					SecondarySourceLocation().append("Declaration is here:",
+					SecondarySourceLocation().append("The declaration is here:",
 													 contractDefinition.location()),
 					"Wrong arguments count: " +
 					toString(arguments.size()) +
@@ -3087,8 +3291,8 @@ void TypeChecker::checkCallList(
 }
 
 void TypeChecker::checkBuildExtMsg(FunctionCall const& _functionCall) {
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
-	vector<ASTPointer<ASTString>> const &argumentNames = _functionCall.names();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<ASTString>> const &argumentNames = _functionCall.names();
 	auto findName = [&](const ASTString& optName) {
 		auto it = std::find_if(argumentNames.begin(), argumentNames.end(),
 							   [&](const ASTPointer<ASTString> &name) {
@@ -3243,8 +3447,8 @@ void TypeChecker::checkOnErrorId(FunctionDefinition const* errorFunction, langut
 
 bool TypeChecker::visit(FunctionCall const& _functionCall)
 {
-	vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
-	vector<ASTPointer<ASTString>> const &argumentNames = _functionCall.names();
+	std::vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
+	std::vector<ASTPointer<ASTString>> const &argumentNames = _functionCall.names();
 	bool argumentsArePure = true;
 
 	// We need to check arguments' type first as they will be needed for overload resolution.
@@ -3278,6 +3482,20 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 
 	bool isLValue = false;
 
+	for (auto const& argument : arguments)
+	{
+		auto const& argType = type(*argument);
+		if (argType->category() == Type::Category::RationalNumber && !argType->mobileType())
+		{
+			m_errorReporter.fatalTypeError(
+				8009_error,
+				argument->location(),
+				"Invalid rational number (too large or division by zero)."
+				// See also TypeChecker::typeCheckABIEncodeFunctions
+			);
+		}
+	}
+
 	// Determine and assign function call kind, lvalue, purity and function type for this FunctionCall node
 	switch (expressionType->category())
 	{
@@ -3338,7 +3556,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 	}
 
 	default:
-		m_errorReporter.fatalTypeError(5704_error, _functionCall.location(), "Type is not callable");
+		m_errorReporter.fatalTypeError(5704_error, _functionCall.location(), "This expression is not callable.");
 		// Unreachable, because fatalTypeError throws. We don't set kind, but that's okay because the switch below
 		// is never reached. And, even if it was, SetOnce would trigger an assertion violation and not UB.
 		funcCallAnno.isPure = argumentsArePure;
@@ -3348,7 +3566,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 	funcCallAnno.isLValue = isLValue;
 
 	auto checkArgNumAndIsInteger = [&](
-		vector<ASTPointer<Expression const>> const& arguments,
+		std::vector<ASTPointer<Expression const>> const& arguments,
 		size_t arguments_cnt,
 		const std::function<bool(size_t, size_t)>& cmpOperator,
 		const std::string& errorMsg
@@ -3362,7 +3580,8 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 
 		for (const auto & arg : arguments) {
-			Type::Category cat = arg->annotation().type->mobileType()->category();
+			auto t = arg->annotation().type;
+			Type::Category cat = t->mobileType()->category();
 			if (cat != Type::Category::Integer && cat != Type::Category::VarInteger) {
 				m_errorReporter.fatalTypeError(
 					4283_error,
@@ -3373,8 +3592,8 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 	};
 
-	auto checkArgNumAndIsIntegerOrFixedPoint = [&](
-		vector<ASTPointer<Expression const>> const& arguments,
+	auto checkArgQtyAndIsIntOrVarIntOrFixedPoint = [&](
+		std::vector<ASTPointer<Expression const>> const& arguments,
 		size_t arguments_cnt,
 		const std::function<bool(size_t, size_t)>& cmpOperator,
 		const std::string& errorMsg
@@ -3391,7 +3610,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			Type::Category cat = arg->annotation().type->mobileType()->category();
 			if (cat != Type::Category::Integer && cat != Type::Category::FixedPoint && cat != Type::Category::VarInteger) {
 				m_errorReporter.fatalTypeError(
-					6033_error,
+					5943_error,
 					arg->location(),
 					"Expected integer, variable integer or fixed point type."
 				);
@@ -3399,7 +3618,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 	};
 
-	auto checkAllAreNotFractions = [&] (vector<ASTPointer<Expression const>> const& arguments) {
+	auto checkAllAreNotFractions = [&] (std::vector<ASTPointer<Expression const>> const& arguments) {
 		bool areAllConstants = true;
 		bool haveAnyFraction = false;
 		SourceLocation loc = getSmallestCovering(arguments);
@@ -3417,7 +3636,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 	};
 
-	auto getCommonType = [&](vector<ASTPointer<Expression const>> const& arguments){
+	auto getCommonType = [&](std::vector<ASTPointer<Expression const>> const& arguments){
 		Type const* result = arguments.at(0)->annotation().type;
 		for (std::size_t i = 1; i < arguments.size(); ++i) {
 			Type const* rightType = arguments.at(i)->annotation().type;
@@ -3445,12 +3664,12 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		return findName(optName) != -1;
 	};
 
-	auto checkHaveNamedParams = [&]() {
+	auto checkHasNamedParams = [&]() {
 		if (argumentNames.empty())
 			m_errorReporter.fatalTypeError(
-					8461_error,
-					_functionCall.location(),
-					string("Function parameters should be specified with names.")
+				8461_error,
+				_functionCall.location(),
+				std::string("Function call arguments should be given by name.")
 			);
 	};
 
@@ -3492,16 +3711,16 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			}
 			expectType(*arguments.at(0), *TypeProvider::tvmcell(), false);
 			ASTPointer<Expression const> arg1 = arguments.at(1);
-			ASTPointer<TupleExpression const> te = dynamic_pointer_cast<TupleExpression const>(arg1);
-			std::vector<ASTPointer<Expression const>> arguments;
+			ASTPointer<TupleExpression const> te = std::dynamic_pointer_cast<TupleExpression const>(arg1);
+			std::vector<ASTPointer<Expression const>> args;
 			if (te) {
 				for (const ASTPointer<Expression>& e : te->components()) {
-					arguments.emplace_back(e);
+					args.emplace_back(e);
 				}
 			} else {
-				arguments.emplace_back(arg1);
+				args.emplace_back(arg1);
 			}
-			returnTypes = checkSliceDecode(arguments);
+			returnTypes = checkSliceDecode(args);
 			break;
 		}
 		case FunctionType::Kind::TVMSliceLoad:
@@ -3527,13 +3746,34 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			returnTypes = getReturnTypesForTVMConfig(_functionCall);
 			break;
 		}
+		case FunctionType::Kind::ABIDecodeFunctionParams: {
+			if (arguments.size() != 2) {
+				m_errorReporter.fatalTypeError(
+					1782_error,
+					_functionCall.location(),
+					std::string("Expected two arguments.")
+				);
+			}
+			FunctionDefinition const* functionDeclaration = checkPubFunctionOrContractTypeAndGetDefinition(*arguments.front().get());
+			if (functionDeclaration != nullptr) { // if nullptr => default constructor
+				if (functionDeclaration->isResponsible()) {
+					returnTypes.push_back(TypeProvider::uint(32)); // callback function
+				}
+				for (const ASTPointer<VariableDeclaration> &vd : functionDeclaration->parameters()) {
+					returnTypes.push_back(vd->type());
+				}
+			}
+			paramTypes.emplace_back(arguments.at(0)->annotation().type);
+			paramTypes.emplace_back(arguments.at(1)->annotation().type);
+			break;
+		}
 		case FunctionType::Kind::TVMSliceLoadFunctionParams:
 		{
 			if (arguments.size() != 1) {
 				m_errorReporter.fatalTypeError(
 					7016_error,
 					_functionCall.location(),
-					string("Expected one argument.")
+					std::string("Expected one argument.")
 				);
 			}
 			FunctionDefinition const* functionDeclaration = checkPubFunctionOrContractTypeAndGetDefinition(*arguments.front().get());
@@ -3578,13 +3818,42 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			returnTypes = functionType->returnParameterTypes();
 			break;
 		}
+		case FunctionType::Kind::ABIDecodeData:
+		{
+			if (arguments.size() != 2) {
+				m_errorReporter.fatalTypeError(
+					3017_error,
+					_functionCall.location(),
+					std::string("Expected two arguments.")
+				);
+			}
+			ContractType const* ct = getContractType(arguments.front().get());
+			if (ct == nullptr) {
+				m_errorReporter.fatalTypeError(
+					8880_error,
+					arguments.front()->location(),
+					"Expected contract type."
+				);
+			}
+
+			std::vector<VariableDeclaration const *> stateVars = ::stateVariables(&ct->contractDefinition(), false);
+			returnTypes.push_back(TypeProvider::uint256()); // pubkey
+			returnTypes.push_back(TypeProvider::uint(64)); // timestamp
+			returnTypes.push_back(TypeProvider::boolean()); // constructor flag
+			for (VariableDeclaration const * v : stateVars) {
+				returnTypes.push_back(v->type());
+			}
+			paramTypes.emplace_back(arguments.at(0)->annotation().type);
+			paramTypes.emplace_back(arguments.at(1)->annotation().type);
+			break;
+		}
 		case FunctionType::Kind::TVMSliceLoadStateVars:
 		{
 			if (arguments.size() != 1) {
 				m_errorReporter.fatalTypeError(
 						5457_error,
 						_functionCall.location(),
-						string("Expected one argument.")
+						std::string("Expected one argument.")
 				);
 			}
 			ContractType const* ct = getContractType(arguments.front().get());
@@ -3596,7 +3865,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				);
 			}
 
-			std::vector<VariableDeclaration const *> stateVars = ::notConstantStateVariables(&ct->contractDefinition());
+			std::vector<VariableDeclaration const *> stateVars = ::stateVariables(&ct->contractDefinition(), false);
 			returnTypes.push_back(TypeProvider::uint256()); // pubkey
 			returnTypes.push_back(TypeProvider::uint(64)); // timestamp
 			returnTypes.push_back(TypeProvider::boolean()); // constructor flag
@@ -3620,7 +3889,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		case FunctionType::Kind::MathMin:
 		case FunctionType::Kind::MathMax:
 		{
-			checkArgNumAndIsIntegerOrFixedPoint(arguments, 2, std::greater_equal<>(), "Expected at least two arguments.");
+			checkArgQtyAndIsIntOrVarIntOrFixedPoint(arguments, 2, std::greater_equal<>(), "Expected at least two arguments.");
 			Type const* result = getCommonType(arguments);
 			paramTypes = TypePointers(arguments.size(), result);
 			returnTypes.push_back(result);
@@ -3628,7 +3897,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 		case FunctionType::Kind::MathMinMax:
 		{
-			checkArgNumAndIsIntegerOrFixedPoint(arguments, 2, std::equal_to<>(), "Expected two arguments.");
+			checkArgQtyAndIsIntOrVarIntOrFixedPoint(arguments, 2, std::equal_to<>(), "Expected two arguments.");
 			Type const* result = getCommonType(arguments);
 			paramTypes = TypePointers(arguments.size(), result);
 			returnTypes.push_back(result);
@@ -3638,7 +3907,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		case FunctionType::Kind::MathDivR:
 		case FunctionType::Kind::MathDivC:
 		{
-			checkArgNumAndIsIntegerOrFixedPoint(arguments, 2, std::equal_to<>(), "Expected two arguments.");
+			checkArgQtyAndIsIntOrVarIntOrFixedPoint(arguments, 2, std::equal_to<>(), "Expected two arguments.");
 			checkAllAreNotFractions(arguments);
 			Type const* result = getCommonType(arguments);
 			paramTypes = TypePointers(arguments.size(), result);
@@ -3671,10 +3940,46 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		}
 		case FunctionType::Kind::MathAbs:
 		{
-			checkArgNumAndIsIntegerOrFixedPoint(arguments, 1, std::equal_to<>(), "Expected one argument.");
-			Type const* type = arguments[0]->annotation().type->mobileType();
-			paramTypes.push_back(type);
-			returnTypes.push_back(type->mobileType());
+			checkArgQtyAndIsIntOrVarIntOrFixedPoint(arguments, 1, std::equal_to<>(), "Expected one argument.");
+			Type const* argType = arguments.at(0)->annotation().type->mobileType();
+			Type::Category cat = argType->category();
+			paramTypes.push_back(argType);
+
+			if (cat == Type::Category::Integer || cat == Type::Category::VarInteger) {
+				IntegerType const* intType;
+				if (cat == Type::Category::Integer)
+					intType = dynamic_cast<IntegerType const*>(argType);
+				else if (cat == Type::Category::VarInteger)
+					intType = &dynamic_cast<VarIntegerType const*>(argType)->asIntegerType();
+				else
+					solUnimplemented("");
+				if (!intType->isSigned())
+					m_errorReporter.fatalTypeError(
+						7695_error,
+						arguments.at(0)->location(),
+						"Expected signed integer type."
+					);
+				if (intType->numBits() == 1)
+					m_errorReporter.fatalTypeError(
+						7695_error,
+						arguments.at(0)->location(),
+						"Too low type."
+					);
+				returnTypes.push_back(TypeProvider::integer(intType->numBits() - 1, IntegerType::Modifier::Unsigned));
+			} else if (cat == Type::Category::FixedPoint) {
+				auto fixed = dynamic_cast<FixedPointType const*>(argType);
+				if (!fixed->isSigned())
+					m_errorReporter.fatalTypeError(
+						7030_error,
+						arguments.at(0)->location(),
+						"Expected signed fixed-point type."
+					);
+				returnTypes.push_back(TypeProvider::fixedPoint(
+					std::max<unsigned>(8, fixed->numBits() - 1),
+					fixed->fractionalDigits(),
+					FixedPointType::Modifier::Unsigned
+				));
+			}
 			break;
 		}
 		case FunctionType::Kind::MathModpow2:
@@ -3747,7 +4052,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				m_errorReporter.fatalTypeError(
 						1878_error,
 						arguments[0]->location(),
-						string("Expected string literal.")
+						std::string("Expected string literal.")
 				);
 			}
 			auto lit = dynamic_cast<const Literal *>(arguments[0].get());
@@ -3755,7 +4060,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				m_errorReporter.fatalTypeError(
 					4336_error,
 					arguments[0]->location(),
-					string("Expected string literal.")
+					std::string("Expected string literal.")
 				);
 			}
 			std::string format = lit->value();
@@ -3771,15 +4076,15 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				m_errorReporter.fatalTypeError(
 					2689_error,
 					_functionCall.location(),
-					string("Number of arguments is not equal to the number of placeholders!")
+					std::string("Number of arguments is not equal to the number of placeholders!")
 				);
 			}
 			typeCheckFunctionCall(_functionCall, functionType);
 			returnTypes = functionType->returnParameterTypes();
 			break;
 		}
-		case FunctionType::Kind::TVMBuildIntMsg: {
-			checkHaveNamedParams();
+		case FunctionType::Kind::ABIBuildIntMsg: {
+			checkHasNamedParams();
 
 			for (const std::string name : {"dest", "call", "value"}) {
 				int index = findName(name);
@@ -3787,7 +4092,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 					m_errorReporter.typeError(
 						3252_error,
 						_functionCall.location(),
-						string("Parameter \"" + name + "\" must be set.")
+						std::string("Parameter \"" + name + "\" must be set.")
 					);
 				}
 			}
@@ -3814,29 +4119,30 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			returnTypes = functionType->returnParameterTypes();
 			break;
 		}
-		case FunctionType::Kind::TVMBuildExtMsg: {
-			checkHaveNamedParams();
+		case FunctionType::Kind::ABIBuildExtMsg: {
+			checkHasNamedParams();
 			checkBuildExtMsg(_functionCall);
 
 			typeCheckFunctionCall(_functionCall, functionType, {"callbackId", "onErrorId"});
 			returnTypes = functionType->returnParameterTypes();
 			break;
 		}
-		case FunctionType::Kind::TVMBuildStateInit: {
+		case FunctionType::Kind::ABIEncodeStateInit: {
 			typeCheckFunctionCall(_functionCall, functionType);
 			returnTypes = m_evmVersion.supportsReturndata() ?
 						  functionType->returnParameterTypes() :
 						  functionType->returnParameterTypesWithoutDynamicTypes();
 
-			typeCheckTVMBuildStateInit(_functionCall, hasName, findName);
+			typeCheckABIEncodeStateInit(_functionCall, hasName, findName);
 			break;
 		}
-		case FunctionType::Kind::TVMBuildDataInit: {
+		case FunctionType::Kind::ABIEncodeData: {
+			checkHasNamedParams();
 			typeCheckFunctionCall(_functionCall, functionType);
 			returnTypes = m_evmVersion.supportsReturndata() ?
 						  functionType->returnParameterTypes() :
 						  functionType->returnParameterTypesWithoutDynamicTypes();
-			typeCheckTVMBuildDataInit(_functionCall, hasName, findName);
+			typeCheckABIEncodeData(_functionCall, hasName, findName);
 			break;
 		}
 		case FunctionType::Kind::AddressTransfer: {
@@ -3853,7 +4159,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				m_errorReporter.fatalTypeError(
 					3221_error,
 					_functionCall.location(),
-					string("Parameter \"value\" must be set.")
+					std::string("Parameter \"value\" must be set.")
 				);
 			}
 			// parameter names are checked in function below
@@ -3863,7 +4169,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 						  functionType->returnParameterTypesWithoutDynamicTypes();
 			break;
 		}
-		case FunctionType::Kind::TVMFunctionId: {
+		case FunctionType::Kind::ABIFunctionId: {
 			if (arguments.size() != 1) {
 				m_errorReporter.fatalTypeError(
 					7354_error,
@@ -3876,7 +4182,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			returnTypes = functionType->returnParameterTypes();
 			break;
 		}
-		case FunctionType::Kind::TVMEncodeBody:
+		case FunctionType::Kind::ABIEncodeBody:
 		{
 			std::vector<Expression const*> params;
 			for (const ASTPointer<Expression const>& p : arguments) {
@@ -3995,6 +4301,26 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			returnTypes.push_back(TypeProvider::uint256());
 			break;
 		}
+		case FunctionType::Kind::IntCast: {
+			if (arguments.size() != 1)
+				m_errorReporter.fatalTypeError(5461_error, _functionCall.location(), "Expected one argument.");
+			auto typeType = dynamic_cast<TypeType const*>(arguments.at(0)->annotation().type);
+			auto actualType = typeType == nullptr ? nullptr : typeType->actualType();
+			if (actualType == nullptr || actualType->category() != Type::Category::Integer)
+				m_errorReporter.fatalTypeError(5974_error, arguments.at(0)->location(), "Expected integer type name.");
+			auto const targetType = dynamic_cast<IntegerType const*>(actualType);
+			auto ma = dynamic_cast<MemberAccess const*>(&_functionCall.expression());
+			auto const fromType = dynamic_cast<IntegerType const*>(ma->expression().annotation().type);
+			if (fromType->isSigned() != targetType->isSigned() && fromType->numBits() != targetType->numBits()) {
+				m_errorReporter.typeError(
+					7427_error,
+					_functionCall.location(),
+					"Type of integer and target type must have same sign or bit-size."
+				);
+			}
+			returnTypes.push_back(actualType);
+			break;
+		}
 		default:
 		{
 			typeCheckFunctionCall(_functionCall, functionType);
@@ -4056,7 +4382,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 
 bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 {
-	const vector<ASTPointer<const Expression>> &options = _functionCallOptions.options();
+	const std::vector<ASTPointer<const Expression>> &options = _functionCallOptions.options();
 	solAssert(options.size() == _functionCallOptions.names().size(), "Lengths of name & value arrays differ!");
 
 	_functionCallOptions.expression().annotation().arguments = _functionCallOptions.annotation().arguments;
@@ -4121,7 +4447,7 @@ bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 		return false;
 	}
 
-	auto setCheckOption = [&](int& _option, string const&& _name, int index)
+	auto setCheckOption = [&](int& _option, std::string const&& _name, int index)
 	{
 		if (_option != -1)
 			m_errorReporter.typeError(
@@ -4133,6 +4459,7 @@ bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 		_option = index;
 	};
 
+
 	const bool isNewExpression = dynamic_cast<const NewExpression *>(&_functionCallOptions.expression()) != nullptr;
 	auto names = _functionCallOptions.names();
 	std::vector<std::string> arr;
@@ -4152,7 +4479,7 @@ bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 		return s;
 	};
 	for (size_t i = 0; i < names.size(); ++i) {
-		string const &name = *(names[i]);
+		std::string const &name = *(names[i]);
 
 		if (std::find(arr.begin(), arr.end(), name) == arr.end()) {
 			m_errorReporter.typeError(
@@ -4242,7 +4569,7 @@ bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 			expectType(*options[i], *TypeProvider::initializerList());
 			setCheckOption(setVarInit, "varInit", i);
 		} else if (name == "value") {
-			expectType(*options[i], *TypeProvider::uint(128));
+			expectType(*options[i], *TypeProvider::coins());
 			setCheckOption(setValue, "value", i);
 		} else if (name == "splitDepth") {
 			expectType(*options[i], *TypeProvider::uint(8));
@@ -4276,15 +4603,16 @@ bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
 				R"(Option "varInit" is not compatible with option "stateInit". Only with option "code".)"
 			);
 		}
-		if (setValue == -1) {
+		if (setValue == -1)
 			m_errorReporter.typeError(4337_error, _functionCallOptions.location(), R"(Option "value" must be set.)");
-		}
-		if (setVarInit != -1) {
+		if (setStateInit == -1) {
 			auto newExpr = to<NewExpression>(&_functionCallOptions.expression());
 			Type const* type = newExpr->typeName().annotation().type;
 			auto ct = to<ContractType>(type);
-			auto list = dynamic_cast<InitializerList const*>(options.at(setVarInit).get());
-			checkInitList(list, ct);
+			InitializerList const* list{};
+			if (setVarInit != -1)
+				list = dynamic_cast<InitializerList const*>(options.at(setVarInit).get());
+			checkInitList(list, *ct, _functionCallOptions.location());
 		}
 	}
 
@@ -4322,7 +4650,6 @@ void TypeChecker::endVisit(NewExpression const& _newExpression)
 				_newExpression.typeName().location(),
 				"Length has to be placed in parentheses after the array type for new expression."
 			);
-		type = TypeProvider::withLocationIfReference(type);
 		_newExpression.annotation().type = TypeProvider::function(
 			TypePointers{TypeProvider::uint256()},
 			TypePointers{type},
@@ -4374,16 +4701,14 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 				m_errorReporter.fatalTypeError(
 					9836_error,
 					_memberAccess.location(),
-					string("\".value()\" and \".flag()\" functionality is ") +
+					std::string("\".value()\" and \".flag()\" functionality is ") +
 					"deprecated, use call options in {} instead."
 				);
 
 		if (initialMemberCount == 0 && !dynamic_cast<ArraySliceType const*>(exprType))
 		{
 			// Try to see if the member was removed because it is only available for storage types.
-			auto storageType = TypeProvider::withLocationIfReference(
-				exprType
-			);
+			auto storageType = exprType;
 			if (!storageType->members(currentDefinitionScope()).membersByName(memberName).empty())
 				m_errorReporter.fatalTypeError(
 					4994_error,
@@ -4394,8 +4719,8 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 				);
 		}
 
-		auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
-			string errorMsg = "Member \"" + memberName + "\" not found or not visible "
+		auto [errorId, description] = [&]() -> std::tuple<ErrorId, std::string> {
+			std::string errorMsg = "Member \"" + memberName + "\" not found or not visible "
 				"after argument-dependent lookup in " + exprType->humanReadableName() + ".";
 
 			if (auto const* funType = dynamic_cast<FunctionType const*>(exprType))
@@ -4452,7 +4777,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 	if (auto funType = dynamic_cast<FunctionType const*>(annotation.type))
 	{
 		solAssert(
-			!funType->bound() || exprType->isImplicitlyConvertibleTo(*funType->selfType()),
+			!funType->hasBoundFirstArgument() || exprType->isImplicitlyConvertibleTo(*funType->selfType()),
 			"Function \"" + memberName + "\" cannot be called on an object of type " +
 			exprType->humanReadableName() + " (expected " + funType->selfType()->humanReadableName() + ")."
 		);
@@ -4468,7 +4793,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 				"Using \"." + memberName + "(...)\" is deprecated. Use \"{" + memberName + ": ...}\" instead."
 			);
 
-		if (!funType->bound())
+		if (!funType->hasBoundFirstArgument())
 			if (auto typeType = dynamic_cast<TypeType const*>(exprType))
 			{
 				auto contractType = dynamic_cast<ContractType const*>(typeType->actualType());
@@ -4518,7 +4843,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 		)
 			annotation.isPure = true;
 		else if (tt->actualType()->category() == Type::Category::Address) {
-			if (memberName == "makeAddrStd" || memberName == "makeAddrNone") {
+			if (memberName == "makeAddrStd" || memberName == "addrNone" || memberName == "makeAddrExtern") {
 				annotation.isPure = true;
 			}
 		}
@@ -4577,18 +4902,39 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 			(memberName == "min" ||	memberName == "max")
 		)
 			annotation.isPure = true;
-		else if (magicType->kind() == MagicType::Kind::Block && memberName == "chainid" && !m_evmVersion.hasChainID())
-			m_errorReporter.typeError(
-				3081_error,
-				_memberAccess.location(),
-				"\"chainid\" is not supported by the VM version."
-			);
-		else if (magicType->kind() == MagicType::Kind::Block && memberName == "basefee" && !m_evmVersion.hasBaseFee())
-			m_errorReporter.typeError(
-				5921_error,
-				_memberAccess.location(),
-				"\"basefee\" is not supported by the VM version."
-			);
+		else if (magicType->kind() == MagicType::Kind::Block)
+		{
+			if (memberName == "chainid" && !m_evmVersion.hasChainID())
+				m_errorReporter.typeError(
+					3081_error,
+					_memberAccess.location(),
+					"\"chainid\" is not supported by the VM version."
+				);
+			else if (memberName == "basefee" && !m_evmVersion.hasBaseFee())
+				m_errorReporter.typeError(
+					5921_error,
+					_memberAccess.location(),
+					"\"basefee\" is not supported by the VM version."
+				);
+			else if (memberName == "blobbasefee" && !m_evmVersion.hasBlobBaseFee())
+				m_errorReporter.typeError(
+					1006_error,
+					_memberAccess.location(),
+					"\"blobbasefee\" is not supported by the VM version."
+				);
+			else if (memberName == "prevrandao" && !m_evmVersion.hasPrevRandao())
+				m_errorReporter.warning(
+					9432_error,
+					_memberAccess.location(),
+					"\"prevrandao\" is not supported by the VM version and will be treated as \"difficulty\"."
+				);
+			else if (memberName == "difficulty" && m_evmVersion.hasPrevRandao())
+				m_errorReporter.warning(
+					8417_error,
+					_memberAccess.location(),
+					"Since the VM version paris, \"difficulty\" was replaced by \"prevrandao\", which now returns a random number based on the beacon chain."
+				);
+		}
 	}
 
 	if (
@@ -4781,13 +5127,13 @@ bool TypeChecker::visit(IndexRangeAccess const& _access)
 	return false;
 }
 
-vector<Declaration const*> TypeChecker::cleanOverloadedDeclarations(
+std::vector<Declaration const*> TypeChecker::cleanOverloadedDeclarations(
 	Identifier const& _identifier,
-	vector<Declaration const*> const& _candidates
+	std::vector<Declaration const*> const& _candidates
 )
 {
 	solAssert(_candidates.size() > 1, "");
-	vector<Declaration const*> uniqueDeclarations;
+	std::vector<Declaration const*> uniqueDeclarations;
 
 	for (Declaration const* declaration: _candidates)
 	{
@@ -4840,7 +5186,7 @@ bool TypeChecker::visit(Identifier const& _identifier)
 		else if (!annotation.arguments)
 		{
 			// The identifier should be a public state variable shadowing other functions
-			vector<Declaration const*> candidates;
+			std::vector<Declaration const*> candidates;
 
 			for (Declaration const* declaration: annotation.overloadedDeclarations)
 			{
@@ -4856,7 +5202,7 @@ bool TypeChecker::visit(Identifier const& _identifier)
 		}
 		else
 		{
-			vector<Declaration const*> candidates;
+			std::vector<Declaration const*> candidates;
 
 			for (Declaration const* declaration: annotation.overloadedDeclarations)
 			{
@@ -4875,7 +5221,7 @@ bool TypeChecker::visit(Identifier const& _identifier)
 					if (!declaration->location().isValid())
 					{
 						// Try to re-construct function definition
-						string description;
+						std::string description;
 						for (auto const& param: declaration->functionType(true)->parameterTypes())
 							description += (description.empty() ? "" : ", ") + param->humanReadableName();
 						description = "function " + _identifier.name() + "(" + description + ")";
@@ -4973,9 +5319,11 @@ void TypeChecker::endVisit(ElementaryTypeNameExpression const& _expr)
 void TypeChecker::endVisit(MappingNameExpression const& _expr)
 {
 	_expr.annotation().type = TypeProvider::typeType(TypeProvider::mapping(
-			_expr.type().keyType().annotation().type,
-			_expr.type().valueType().annotation().type
-			));
+		_expr.type().keyType().annotation().type,
+		"",
+		_expr.type().valueType().annotation().type,
+		""
+	));
 	_expr.annotation().isPure = true;
 }
 
@@ -5060,8 +5408,9 @@ void TypeChecker::endVisit(UsingForDirective const& _usingFor)
 			solAssert(m_errorReporter.hasErrors());
 			return;
 		}
-		solAssert(_usingFor.typeName()->annotation().type);
-		if (Declaration const* typeDefinition = _usingFor.typeName()->annotation().type->typeDefinition())
+		Type const* usingForType = _usingFor.typeName()->annotation().type;
+		solAssert(usingForType);
+		if (Declaration const* typeDefinition = usingForType->typeDefinition())
 		{
 			if (typeDefinition->scope() != m_currentSourceUnit)
 				m_errorReporter.typeError(
@@ -5095,54 +5444,226 @@ void TypeChecker::endVisit(UsingForDirective const& _usingFor)
 		return;
 	}
 
-	solAssert(_usingFor.typeName()->annotation().type);
-	Type const* normalizedType = TypeProvider::withLocationIfReference(
-		_usingFor.typeName()->annotation().type
-	);
+	Type const* usingForType = _usingFor.typeName()->annotation().type;
+	solAssert(usingForType);
+
+	Type const* normalizedType = usingForType;
 	solAssert(normalizedType);
 
-	for (ASTPointer<IdentifierPath> const& path: _usingFor.functionsOrLibrary())
+	for (auto const& [path, operator_]: _usingFor.functionsAndOperators())
 	{
 		solAssert(path->annotation().referencedDeclaration);
 		FunctionDefinition const& functionDefinition =
 			dynamic_cast<FunctionDefinition const&>(*path->annotation().referencedDeclaration);
 
-		solAssert(functionDefinition.type());
+		FunctionType const* functionType = dynamic_cast<FunctionType const*>(
+			functionDefinition.libraryFunction() ?
+				functionDefinition.typeViaContractName() :
+				functionDefinition.type()
+			);
+
+		solAssert(functionType);
 
 		if (functionDefinition.parameters().empty())
 			m_errorReporter.fatalTypeError(
 				4731_error,
 				path->location(),
-				"The function \"" + joinHumanReadable(path->path(), ".") + "\" " +
-				"does not have any parameters, and therefore cannot be bound to the type \"" +
-				(normalizedType ? normalizedType->humanReadableName() : "*") + "\"."
+				SecondarySourceLocation().append(
+					"Function defined here:",
+					functionDefinition.location()
+				),
+				fmt::format(
+					"The function \"{}\" does not have any parameters, and therefore cannot be attached to the type \"{}\".",
+					joinHumanReadable(path->path(), "."),
+					normalizedType ? normalizedType->toString(true /* withoutDataLocation */) : "*"
+				)
+			);
+
+		if (
+			functionDefinition.visibility() == Visibility::Private &&
+			functionDefinition.scope() != m_currentContract
+		)
+		{
+			solAssert(functionDefinition.libraryFunction());
+			m_errorReporter.typeError(
+				6772_error,
+				path->location(),
+				SecondarySourceLocation().append(
+					"Function defined here:",
+					functionDefinition.location()
+				),
+				fmt::format(
+					"Function \"{}\" is private and therefore cannot be attached"
+					" to a type outside of the library where it is defined.",
+					joinHumanReadable(path->path(), ".")
+				)
 			);
+		}
 
-		FunctionType const* functionType = dynamic_cast<FunctionType const&>(*functionDefinition.type()).asBoundFunction();
-		solAssert(functionType && functionType->selfType(), "");
+		FunctionType const* functionTypeWithBoundFirstArgument = functionType->withBoundFirstArgument();
+		solAssert(functionTypeWithBoundFirstArgument && functionTypeWithBoundFirstArgument->selfType(), "");
 		BoolResult result = normalizedType->isImplicitlyConvertibleTo(
-			*TypeProvider::withLocationIfReference(functionType->selfType())
+			*functionTypeWithBoundFirstArgument->selfType()
 		);
-		if (!result)
+		if (!result && !operator_)
 			m_errorReporter.typeError(
 				3100_error,
 				path->location(),
-				"The function \"" + joinHumanReadable(path->path(), ".") + "\" "+
-				"cannot be bound to the type \"" + _usingFor.typeName()->annotation().type->humanReadableName() +
-				"\" because the type cannot be implicitly converted to the first argument" +
-				" of the function (\"" + functionType->selfType()->humanReadableName() + "\")" +
-				(
-					result.message().empty() ?
-					"." :
-					": " +  result.message()
+				SecondarySourceLocation().append(
+					"Function defined here:",
+					functionDefinition.location()
+				),
+				fmt::format(
+					"The function \"{}\" cannot be attached to the type \"{}\" because the type cannot "
+					"be implicitly converted to the first argument of the function (\"{}\"){}",
+					joinHumanReadable(path->path(), "."),
+					usingForType->toString(true /* withoutDataLocation */),
+					functionTypeWithBoundFirstArgument->selfType()->humanReadableName(),
+					result.message().empty() ? "." : ": " +  result.message()
 				)
 			);
+		else if (operator_.has_value())
+		{
+			if (!_usingFor.global())
+				m_errorReporter.typeError(
+					3320_error,
+					path->location(),
+					"Operators can only be defined in a global 'using for' directive."
+				);
+
+			if (
+				functionType->stateMutability() != StateMutability::Pure ||
+				!functionDefinition.isFree()
+			)
+				m_errorReporter.typeError(
+					7775_error,
+					path->location(),
+					SecondarySourceLocation().append(
+						"Function defined as non-pure here:",
+						functionDefinition.location()
+					),
+					"Only pure free functions can be used to define operators."
+				);
+
+			solAssert(!functionType->hasBoundFirstArgument());
+			TypePointers const& parameterTypes = functionType->parameterTypes();
+			size_t const parameterCount = parameterTypes.size();
+			if (usingForType->category() != Type::Category::UserDefinedValueType)
+			{
+				m_errorReporter.typeError(
+					5332_error,
+					path->location(),
+					"Operators can only be implemented for user-defined value types."
+				);
+				continue;
+			}
+			solAssert(usingForType->typeDefinition());
+
+			bool identicalFirstTwoParameters = (parameterCount < 2 || *parameterTypes.at(0) == *parameterTypes.at(1));
+			bool isUnaryOnlyOperator = (!TokenTraits::isBinaryOp(operator_.value()) && TokenTraits::isUnaryOp(operator_.value()));
+			bool isBinaryOnlyOperator = (TokenTraits::isBinaryOp(operator_.value()) && !TokenTraits::isUnaryOp(operator_.value()));
+			bool firstParameterMatchesUsingFor = parameterCount == 0 || *usingForType == *parameterTypes.front();
+
+			std::optional<std::string> wrongParametersMessage;
+			if (isBinaryOnlyOperator && (parameterCount != 2 || !identicalFirstTwoParameters))
+				wrongParametersMessage = fmt::format("two parameters of type {} and the same data location", usingForType->canonicalName());
+			else if (isUnaryOnlyOperator && (parameterCount != 1 || !firstParameterMatchesUsingFor))
+				wrongParametersMessage = fmt::format("exactly one parameter of type {}", usingForType->canonicalName());
+			else if (parameterCount >= 3 || !firstParameterMatchesUsingFor || !identicalFirstTwoParameters)
+				wrongParametersMessage = fmt::format("one or two parameters of type {} and the same data location", usingForType->canonicalName());
+
+			if (wrongParametersMessage.has_value())
+				m_errorReporter.typeError(
+					1884_error,
+					functionDefinition.parameterList().location(),
+					SecondarySourceLocation().append(
+						"Function was used to implement an operator here:",
+						path->location()
+					),
+					fmt::format(
+						"Wrong parameters in operator definition. "
+						"The function \"{}\" needs to have {} to be used for the operator {}.",
+						joinHumanReadable(path->path(), "."),
+						wrongParametersMessage.value(),
+						TokenTraits::friendlyName(operator_.value())
+					)
+				);
+
+			// This case is separately validated for all attached functions and is a fatal error
+			solAssert(parameterCount != 0);
+
+			TypePointers const& returnParameterTypes = functionType->returnParameterTypes();
+			size_t const returnParameterCount = returnParameterTypes.size();
+
+			std::optional<std::string> wrongReturnParametersMessage;
+			if (!TokenTraits::isCompareOp(operator_.value()) && operator_.value() != Token::Not)
+			{
+				if (returnParameterCount != 1 || *usingForType != *returnParameterTypes.front())
+					wrongReturnParametersMessage = "exactly one value of type " + usingForType->canonicalName();
+				else if (*returnParameterTypes.front() != *parameterTypes.front())
+					wrongReturnParametersMessage = "a value of the same type and data location as its parameters";
+			}
+			else if (returnParameterCount != 1 || *returnParameterTypes.front() != *TypeProvider::boolean())
+				wrongReturnParametersMessage = "exactly one value of type bool";
+
+			solAssert(functionDefinition.returnParameterList());
+			if (wrongReturnParametersMessage.has_value())
+				m_errorReporter.typeError(
+					7743_error,
+					functionDefinition.returnParameterList()->location(),
+					SecondarySourceLocation().append(
+						"Function was used to implement an operator here:",
+						path->location()
+					),
+					fmt::format(
+						"Wrong return parameters in operator definition. "
+						"The function \"{}\" needs to return {} to be used for the operator {}.",
+						joinHumanReadable(path->path(), "."),
+						wrongReturnParametersMessage.value(),
+						TokenTraits::friendlyName(operator_.value())
+					)
+				);
+
+			if (parameterCount != 1 && parameterCount != 2)
+				solAssert(m_errorReporter.hasErrors());
+			else
+			{
+				// TODO: This is pretty inefficient. For every operator binding we find, we're
+				// traversing all bindings in all `using for` directives in the current scope.
+				std::set<FunctionDefinition const*, ASTNode::CompareByID> matchingDefinitions = usingForType->operatorDefinitions(
+					operator_.value(),
+					*currentDefinitionScope(),
+					parameterCount == 1 // _unary
+				);
+
+				if (matchingDefinitions.size() >= 2)
+				{
+					// TODO: We should point at other places that bind the operator rather than at
+					// the definitions they bind.
+					SecondarySourceLocation secondaryLocation;
+					for (FunctionDefinition const* definition: matchingDefinitions)
+						if (functionDefinition != *definition)
+						secondaryLocation.append("Conflicting definition:", definition->location());
+
+					m_errorReporter.typeError(
+						4705_error,
+						path->location(),
+						secondaryLocation,
+						fmt::format(
+							"User-defined {} operator {} has more than one definition matching the operand type visible in the current scope.",
+							parameterCount == 1 ? "unary" : "binary",
+							TokenTraits::friendlyName(operator_.value())
+						)
+					);
+				}
+			}
+		}
 	}
 }
 
 void TypeChecker::checkErrorAndEventParameters(CallableDeclaration const& _callable)
 {
-	string kind = dynamic_cast<EventDefinition const*>(&_callable) ? "event" : "error";
+	std::string kind = dynamic_cast<EventDefinition const*>(&_callable) ? "event" : "error";
 	for (ASTPointer<VariableDeclaration> const& var: _callable.parameters())
 	{
 		if (!type(*var)->interfaceType(false))
@@ -5227,7 +5748,7 @@ void TypeChecker::requireLValue(Expression const& _expression, bool _ordinaryAss
 	if (*_expression.annotation().isLValue)
 		return;
 
-	auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
+	auto [errorId, description] = [&]() -> std::tuple<ErrorId, std::string> {
 		if (*_expression.annotation().isConstant)
 			return { 6520_error, "Cannot assign to a constant variable." };
 
@@ -5247,11 +5768,6 @@ void TypeChecker::requireLValue(Expression const& _expression, bool _ordinaryAss
 					return { 7567_error, "Member \"length\" is read-only and cannot be used to resize arrays." };
 		}
 
-		if (auto identifier = dynamic_cast<Identifier const*>(&_expression))
-			if (auto varDecl = dynamic_cast<VariableDeclaration const*>(identifier->annotation().referencedDeclaration))
-				if (varDecl->isExternalCallableParameter() && dynamic_cast<ReferenceType const*>(identifier->annotation().type))
-					return { 7128_error, "External function arguments of reference type are read-only." };
-
 		return { 4247_error, "Expression has to be an lvalue." };
 	}();
 
diff --git a/compiler/libsolidity/analysis/TypeChecker.h b/compiler/libsolidity/analysis/TypeChecker.h
index e224f632..b66063a5 100644
--- a/compiler/libsolidity/analysis/TypeChecker.h
+++ b/compiler/libsolidity/analysis/TypeChecker.h
@@ -87,12 +87,12 @@ class TypeChecker: private ASTConstVisitor
 		bool _abiEncoderV2
 	);
 
-	void typeCheckTVMBuildStateInit(
+	void typeCheckABIEncodeStateInit(
 		FunctionCall const& _functionCall,
 		const std::function<bool(const std::string&)>& hasName,
 		const std::function<int(const std::string&)>& findName
 	);
-	void typeCheckTVMBuildDataInit(
+	void typeCheckABIEncodeData(
 		FunctionCall const& _functionCall,
 		const std::function<bool(const std::string&)>& hasName,
 		const std::function<int(const std::string&)>& findName
@@ -141,7 +141,8 @@ class TypeChecker: private ASTConstVisitor
 	static ContractType const* getContractType(Expression const* expr);
 	FunctionDefinition const* checkPubFunctionAndGetDefinition(Expression const& arg, bool printError = false);
 	FunctionDefinition const* checkPubFunctionOrContractTypeAndGetDefinition(Expression const& arg);
-	void checkInitList(InitializerList const *list, ContractType const *ct);
+	void checkInitList(InitializerList const* list, ContractType const& ct,
+					   langutil::SourceLocation const& _functionCallLocation);
 	void checkCallList(
 		std::vector<Expression const*> const& arguments,
 		FunctionCall const& _functionCall,
@@ -195,7 +196,6 @@ class TypeChecker: private ASTConstVisitor
 	bool visit(EventDefinition const& _eventDef) override;
 	bool visit(ErrorDefinition const& _errorDef) override;
 	void endVisit(FunctionTypeName const& _funType) override;
-	bool visit(InlineAssembly const& _inlineAssembly) override;
 	bool visit(IfStatement const& _ifStatement) override;
 	void endVisit(TryStatement const& _tryStatement) override;
 	bool visit(WhileStatement const& _whileStatement) override;
diff --git a/compiler/libsolidity/analysis/ViewPureChecker.cpp b/compiler/libsolidity/analysis/ViewPureChecker.cpp
index bdd40fcf..d7918116 100644
--- a/compiler/libsolidity/analysis/ViewPureChecker.cpp
+++ b/compiler/libsolidity/analysis/ViewPureChecker.cpp
@@ -24,7 +24,6 @@
 #include <utility>
 #include <variant>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -53,9 +52,9 @@ bool ViewPureChecker::visit(FunctionDefinition const& _funDef)
 									"Library functions must have default mutability. Delete keyword view or pure.");
 		}
 	}
-	if (_funDef.isFree() && !_funDef.isInlineAssembly() && _funDef.stateMutability() != StateMutability::NonPayable) {
+	if (_funDef.isFree() && !_funDef.isInlineAssembly() && _funDef.stateMutability() != StateMutability::Pure) {
 		m_errorReporter.warning(4029_error, _funDef.location(),
-								"Free functions must have default mutability. Delete keyword view or pure.");
+								"Free function must have pure mutability.");
 	}
 	return true;
 }
@@ -144,10 +143,6 @@ void ViewPureChecker::endVisit(Identifier const& _identifier)
 	reportMutability(mutability, _identifier.location());
 }
 
-void ViewPureChecker::endVisit(InlineAssembly const& /*_inlineAssembly*/)
-{
-}
-
 void ViewPureChecker::reportMutability(
 	StateMutability _mutability,
 	SourceLocation const& _location,
@@ -214,17 +209,34 @@ ViewPureChecker::MutabilityAndLocation const& ViewPureChecker::modifierMutabilit
 	{
 		MutabilityAndLocation bestMutabilityAndLocation{};
 		FunctionDefinition const* currentFunction = nullptr;
-		swap(bestMutabilityAndLocation, m_bestMutabilityAndLocation);
-		swap(currentFunction, m_currentFunction);
+		std::swap(bestMutabilityAndLocation, m_bestMutabilityAndLocation);
+		std::swap(currentFunction, m_currentFunction);
 
 		_modifier.accept(*this);
 
-		swap(bestMutabilityAndLocation, m_bestMutabilityAndLocation);
-		swap(currentFunction, m_currentFunction);
+		std::swap(bestMutabilityAndLocation, m_bestMutabilityAndLocation);
+		std::swap(currentFunction, m_currentFunction);
 	}
 	return m_inferredMutability.at(&_modifier);
 }
 
+void ViewPureChecker::reportFunctionCallMutability(StateMutability _mutability, langutil::SourceLocation const& _location)
+{
+	reportMutability(_mutability, _location);
+}
+
+void ViewPureChecker::endVisit(BinaryOperation const& _binaryOperation)
+{
+	if (*_binaryOperation.annotation().userDefinedFunction != nullptr)
+		reportFunctionCallMutability((*_binaryOperation.annotation().userDefinedFunction)->stateMutability(), _binaryOperation.location());
+}
+
+void ViewPureChecker::endVisit(UnaryOperation const& _unaryOperation)
+{
+	if (*_unaryOperation.annotation().userDefinedFunction != nullptr)
+		reportFunctionCallMutability((*_unaryOperation.annotation().userDefinedFunction)->stateMutability(), _unaryOperation.location());
+}
+
 void ViewPureChecker::endVisit(FunctionCall const& _functionCall)
 {
 	if (*_functionCall.annotation().kind != FunctionCallKind::FunctionCall)
@@ -329,14 +341,25 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
 		break;
 	case Type::Category::Magic:
 	{
-		using MagicMember = pair<MagicType::Kind, string>;
-		set<MagicMember> static const pureMembers{
+		using MagicMember = std::pair<MagicType::Kind, std::string>;
+		std::set<MagicMember> static const pureMembers{
+			{MagicType::Kind::ABI, "codeSalt"},
 			{MagicType::Kind::ABI, "decode"},
+			{MagicType::Kind::ABI, "decodeData"},
 			{MagicType::Kind::ABI, "encode"},
+			{MagicType::Kind::ABI, "encodeBody"},
 			{MagicType::Kind::ABI, "encodeCall"},
+			{MagicType::Kind::ABI, "encodeData"},
+			{MagicType::Kind::ABI, "encodeExtMsg"},
+			{MagicType::Kind::ABI, "encodeIntMsg"},
+			{MagicType::Kind::ABI, "encodeOldDataInit"},
 			{MagicType::Kind::ABI, "encodePacked"},
+			{MagicType::Kind::ABI, "encodeStateInit"},
 			{MagicType::Kind::ABI, "encodeWithSelector"},
 			{MagicType::Kind::ABI, "encodeWithSignature"},
+			{MagicType::Kind::ABI, "functionId"},
+			{MagicType::Kind::ABI, "setCodeSalt"},
+			{MagicType::Kind::ABI, "stateInitHash"},
 			{MagicType::Kind::Block, "blockhash"},
 			{MagicType::Kind::Block, "logicaltime"},
 			{MagicType::Kind::Block, "timestamp"},
@@ -366,12 +389,12 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
 			{MagicType::Kind::Math, "muldivr"},
 			{MagicType::Kind::Math, "sign"},
 			{MagicType::Kind::Message, "body"},
-			{MagicType::Kind::Message, "forwardFee"},
-			{MagicType::Kind::Message, "importFee"},
 			{MagicType::Kind::Message, "createdAt"},
 			{MagicType::Kind::Message, "currencies"},
 			{MagicType::Kind::Message, "data"},
+			{MagicType::Kind::Message, "forwardFee"},
 			{MagicType::Kind::Message, "hasStateInit"},
+			{MagicType::Kind::Message, "importFee"},
 			{MagicType::Kind::Message, "isExternal"},
 			{MagicType::Kind::Message, "isInternal"},
 			{MagicType::Kind::Message, "isTickTock"},
@@ -407,7 +430,6 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
 			{MagicType::Kind::TVM, "hash"},
 			{MagicType::Kind::TVM, "hexdump"},
 			{MagicType::Kind::TVM, "initCodeHash"},
-			{MagicType::Kind::TVM, "insertPubkey"},
 			{MagicType::Kind::TVM, "log"},
 			{MagicType::Kind::TVM, "rawConfigParam"},
 			{MagicType::Kind::TVM, "rawReserve"},
@@ -421,7 +443,7 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
 			{MagicType::Kind::Transaction, "storageFee"},
 			{MagicType::Kind::Transaction, "timestamp"},
 		};
-		set<MagicMember> static const nonpayableMembers{
+		std::set<MagicMember> static const nonpayableMembers{
 			{MagicType::Kind::TVM, "commit"},
 			{MagicType::Kind::TVM, "rawCommit"},
 			{MagicType::Kind::TVM, "setData"},
diff --git a/compiler/libsolidity/analysis/ViewPureChecker.h b/compiler/libsolidity/analysis/ViewPureChecker.h
index 6698c104..24cc8ffc 100644
--- a/compiler/libsolidity/analysis/ViewPureChecker.h
+++ b/compiler/libsolidity/analysis/ViewPureChecker.h
@@ -54,6 +54,8 @@ class ViewPureChecker: private ASTConstVisitor
 
 	bool visit(FunctionDefinition const& _funDef) override;
 	void endVisit(FunctionDefinition const& _funDef) override;
+	void endVisit(BinaryOperation const& _binaryOperation) override;
+	void endVisit(UnaryOperation const& _unaryOperation) override;
 	bool visit(ModifierDefinition const& _modifierDef) override;
 	void endVisit(ModifierDefinition const& _modifierDef) override;
 	void endVisit(Identifier const& _identifier) override;
@@ -63,7 +65,6 @@ class ViewPureChecker: private ASTConstVisitor
 	void endVisit(IndexRangeAccess const& _indexAccess) override;
 	void endVisit(ModifierInvocation const& _modifier) override;
 	void endVisit(FunctionCall const& _functionCall) override;
-	void endVisit(InlineAssembly const& _inlineAssembly) override;
 
 	/// Called when an element of mutability @a _mutability is encountered.
 	/// Creates appropriate warnings and errors and sets @a m_currentBestMutability.
@@ -74,6 +75,7 @@ class ViewPureChecker: private ASTConstVisitor
 	);
 
 	bool isStateVariable(Expression const&  expression) const;
+	void reportFunctionCallMutability(StateMutability _mutability, langutil::SourceLocation const& _location);
 	/// Determines the mutability of modifier if not already cached.
 	MutabilityAndLocation const& modifierMutability(ModifierDefinition const& _modifier);
 
diff --git a/compiler/libsolidity/ast/AST.cpp b/compiler/libsolidity/ast/AST.cpp
index 1390ff0b..9e71380f 100644
--- a/compiler/libsolidity/ast/AST.cpp
+++ b/compiler/libsolidity/ast/AST.cpp
@@ -27,16 +27,18 @@
 #include <libsolidity/ast/ASTVisitor.h>
 #include <libsolidity/ast/AST_accept.h>
 #include <libsolidity/ast/TypeProvider.h>
+#include <libsolutil/FunctionSelector.h>
 #include <libsolutil/Keccak256.h>
 
+#include <range/v3/range/conversion.hpp>
 #include <range/v3/view/tail.hpp>
+#include <range/v3/view/zip.hpp>
 
 #include <boost/algorithm/string.hpp>
 
 #include <functional>
 #include <utility>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
@@ -105,7 +107,7 @@ FunctionDefinition const* ASTNode::resolveFunctionCall(FunctionCall const& _func
 ASTAnnotation& ASTNode::annotation() const
 {
 	if (!m_annotation)
-		m_annotation = make_unique<ASTAnnotation>();
+		m_annotation = std::make_unique<ASTAnnotation>();
 	return *m_annotation;
 }
 
@@ -114,9 +116,9 @@ SourceUnitAnnotation& SourceUnit::annotation() const
 	return initAnnotation<SourceUnitAnnotation>();
 }
 
-set<SourceUnit const*> SourceUnit::referencedSourceUnits(bool _recurse, set<SourceUnit const*> _skipList) const
+std::set<SourceUnit const*> SourceUnit::referencedSourceUnits(bool _recurse, std::set<SourceUnit const*> _skipList) const
 {
-	set<SourceUnit const*> sourceUnits;
+	std::set<SourceUnit const*> sourceUnits;
 	for (ImportDirective const* importDirective: filteredNodes<ImportDirective>(nodes()))
 	{
 		auto const& sourceUnit = importDirective->annotation().sourceUnit;
@@ -147,11 +149,11 @@ bool ContractDefinition::derivesFrom(ContractDefinition const& _base) const
 	return util::contains(annotation().linearizedBaseContracts, &_base);
 }
 
-map<util::FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions(bool _includeInheritedFunctions) const
+std::map<util::FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions(bool _includeInheritedFunctions) const
 {
 	auto exportedFunctionList = interfaceFunctionList(_includeInheritedFunctions);
 
-	map<util::FixedHash<4>, FunctionTypePointer> exportedFunctions;
+	std::map<util::FixedHash<4>, FunctionTypePointer> exportedFunctions;
 	for (auto const& it: exportedFunctionList)
 		exportedFunctions.insert(it);
 
@@ -204,11 +206,11 @@ FunctionDefinition const* ContractDefinition::onBounceFunction() const
 	return nullptr;
 }
 
-vector<EventDefinition const*> const& ContractDefinition::definedInterfaceEvents() const
+std::vector<EventDefinition const*> const& ContractDefinition::definedInterfaceEvents() const
 {
 	return m_interfaceEvents.init([&]{
-		set<string> eventsSeen;
-		vector<EventDefinition const*> interfaceEvents;
+		std::set<std::string> eventsSeen;
+		std::vector<EventDefinition const*> interfaceEvents;
 
 		for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
 			for (EventDefinition const* e: contract->events())
@@ -216,9 +218,9 @@ vector<EventDefinition const*> const& ContractDefinition::definedInterfaceEvents
 				/// NOTE: this requires the "internal" version of an Event,
 				///       though here internal strictly refers to visibility,
 				///       and not to function encoding (jump vs. call)
-				auto const& function = e->functionType(true);
-				solAssert(function, "");
-				string eventSignature = function->externalSignature();
+				FunctionType const* functionType = e->functionType(true);
+				solAssert(functionType, "");
+				std::string eventSignature = functionType->externalSignature();
 				if (eventsSeen.count(eventSignature) == 0)
 				{
 					eventsSeen.insert(eventSignature);
@@ -229,7 +231,7 @@ vector<EventDefinition const*> const& ContractDefinition::definedInterfaceEvents
 	});
 }
 
-vector<EventDefinition const*> const ContractDefinition::usedInterfaceEvents() const
+std::vector<EventDefinition const*> const ContractDefinition::usedInterfaceEvents() const
 {
 	solAssert(annotation().creationCallGraph.set(), "");
 
@@ -239,9 +241,24 @@ vector<EventDefinition const*> const ContractDefinition::usedInterfaceEvents() c
 	);
 }
 
-vector<ErrorDefinition const*> ContractDefinition::interfaceErrors(bool _requireCallGraph) const
+std::vector<EventDefinition const*> ContractDefinition::interfaceEvents(bool _requireCallGraph) const
 {
-	set<ErrorDefinition const*, CompareByID> result;
+	std::set<EventDefinition const*, CompareByID> result;
+	for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
+		result += contract->events();
+	solAssert(annotation().creationCallGraph.set() == annotation().deployedCallGraph.set());
+	if (_requireCallGraph)
+		solAssert(annotation().creationCallGraph.set());
+	if (annotation().creationCallGraph.set())
+		result += usedInterfaceEvents();
+	// We could filter out all events that do not have an external interface
+	// if _requireCallGraph is false.
+	return util::convertContainer<std::vector<EventDefinition const*>>(std::move(result));
+}
+
+std::vector<ErrorDefinition const*> ContractDefinition::interfaceErrors(bool _requireCallGraph) const
+{
+	std::set<ErrorDefinition const*, CompareByID> result;
 	for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
 		result += filteredNodes<ErrorDefinition>(contract->m_subNodes);
 	solAssert(annotation().creationCallGraph.set() == annotation().deployedCallGraph.set(), "");
@@ -251,20 +268,20 @@ vector<ErrorDefinition const*> ContractDefinition::interfaceErrors(bool _require
 		result +=
 			(*annotation().creationCallGraph)->usedErrors +
 			(*annotation().deployedCallGraph)->usedErrors;
-	return util::convertContainer<vector<ErrorDefinition const*>>(std::move(result));
+	return util::convertContainer<std::vector<ErrorDefinition const*>>(std::move(result));
 }
 
-vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::interfaceFunctionList(bool _includeInheritedFunctions) const
+std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::interfaceFunctionList(bool _includeInheritedFunctions) const
 {
 	return m_interfaceFunctionList[_includeInheritedFunctions].init([&]{
-		set<string> signaturesSeen;
-		vector<pair<util::FixedHash<4>, FunctionTypePointer>> interfaceFunctionList;
+		std::set<std::string> signaturesSeen;
+		std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>> interfaceFunctionList;
 
 		for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
 		{
 			if (_includeInheritedFunctions == false && contract != this)
 				continue;
-			vector<FunctionTypePointer> functions;
+			std::vector<FunctionTypePointer> functions;
 			for (FunctionDefinition const* f: contract->definedFunctions())
 				if (f->isPartOfExternalInterface())
 					functions.push_back(TypeProvider::function(*f, FunctionType::Kind::External));
@@ -276,12 +293,11 @@ vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition:
 				if (!fun->interfaceFunctionType())
 					// Fails hopefully because we already registered the error
 					continue;
-				string functionSignature = fun->externalSignature();
+				std::string functionSignature = fun->externalSignature();
 				if (signaturesSeen.count(functionSignature) == 0)
 				{
 					signaturesSeen.insert(functionSignature);
-					util::FixedHash<4> hash(util::keccak256(functionSignature));
-					interfaceFunctionList.emplace_back(hash, fun);
+					interfaceFunctionList.emplace_back(util::selectorFromSignatureH32(functionSignature), fun);
 				}
 			}
 		}
@@ -339,7 +355,7 @@ FunctionDefinition const* ContractDefinition::nextConstructor(ContractDefinition
 	return nullptr;
 }
 
-multimap<std::string, FunctionDefinition const*> const& ContractDefinition::definedFunctionsByName() const
+std::multimap<std::string, FunctionDefinition const*> const& ContractDefinition::definedFunctionsByName() const
 {
 	return m_definedFunctionsByName.init([&]{
 		std::multimap<std::string, FunctionDefinition const*> result;
@@ -366,6 +382,11 @@ TypeDeclarationAnnotation& UserDefinedValueTypeDefinition::annotation() const
 	return initAnnotation<TypeDeclarationAnnotation>();
 }
 
+std::vector<std::pair<ASTPointer<IdentifierPath>, std::optional<Token>>> UsingForDirective::functionsAndOperators() const
+{
+	return ranges::zip_view(m_functionsOrLibrary, m_operators) | ranges::to<std::vector>;
+}
+
 Type const* StructDefinition::type() const
 {
 	solAssert(annotation().recursive.has_value(), "Requested struct type before DeclarationTypeChecker.");
@@ -461,12 +482,12 @@ Type const* FunctionDefinition::typeViaContractName() const
 		return TypeProvider::function(*this, FunctionType::Kind::Declaration);
 }
 
-string FunctionDefinition::externalSignature() const
+std::string FunctionDefinition::externalSignature() const
 {
 	return TypeProvider::function(*this)->externalSignature();
 }
 
-string FunctionDefinition::externalIdentifierHex() const
+std::string FunctionDefinition::externalIdentifierHex() const
 {
 	return TypeProvider::function(*this)->externalIdentifierHex();
 }
@@ -616,7 +637,7 @@ CallableDeclaration const* Scopable::functionOrModifierDefinition() const
 	return nullptr;
 }
 
-string Scopable::sourceUnitName() const
+std::string Scopable::sourceUnitName() const
 {
 	return *sourceUnit().annotation().path;
 }
@@ -679,7 +700,7 @@ bool VariableDeclaration::isCallableOrCatchParameter() const
 	if (isReturnParameter() || isTryCatchParameter())
 		return true;
 
-	vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
+	std::vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
 
 	if (auto const* funTypeName = dynamic_cast<FunctionTypeName const*>(scope()))
 		parameters = &funTypeName->parameterTypes();
@@ -700,7 +721,7 @@ bool VariableDeclaration::isLocalOrReturn() const
 
 bool VariableDeclaration::isReturnParameter() const
 {
-	vector<ASTPointer<VariableDeclaration>> const* returnParameters = nullptr;
+	std::vector<ASTPointer<VariableDeclaration>> const* returnParameters = nullptr;
 
 	if (auto const* funTypeName = dynamic_cast<FunctionTypeName const*>(scope()))
 		returnParameters = &funTypeName->returnParameterTypes();
@@ -778,7 +799,7 @@ bool VariableDeclaration::hasReferenceOrMappingType() const
 {
 	solAssert(typeName().annotation().type, "Can only be called after reference resolution");
 	Type const* type = typeName().annotation().type;
-	return type->category() == Type::Category::Mapping || dynamic_cast<ReferenceType const*>(type);
+	return type->category() == Type::Category::Mapping;
 }
 
 bool VariableDeclaration::isStateVariable() const
@@ -791,7 +812,7 @@ bool VariableDeclaration::isFileLevelVariable() const
 	return dynamic_cast<SourceUnit const*>(scope());
 }
 
-string VariableDeclaration::externalIdentifierHex() const
+std::string VariableDeclaration::externalIdentifierHex() const
 {
 	solAssert(isStateVariable() && isPublic(), "Can only be called for public state variables");
 	return TypeProvider::function(*this)->externalIdentifierHex();
@@ -837,11 +858,6 @@ StatementAnnotation& FreeInlineAssembly::annotation() const
 	return initAnnotation<StatementAnnotation>();
 }
 
-InlineAssemblyAnnotation& InlineAssembly::annotation() const
-{
-	return initAnnotation<InlineAssemblyAnnotation>();
-}
-
 BlockAnnotation& Block::annotation() const
 {
 	return initAnnotation<BlockAnnotation>();
@@ -877,6 +893,37 @@ MemberAccessAnnotation& MemberAccess::annotation() const
 	return initAnnotation<MemberAccessAnnotation>();
 }
 
+OperationAnnotation& UnaryOperation::annotation() const
+{
+	return initAnnotation<OperationAnnotation>();
+}
+
+FunctionType const* UnaryOperation::userDefinedFunctionType() const
+{
+	if (*annotation().userDefinedFunction == nullptr)
+		return nullptr;
+
+	FunctionDefinition const* userDefinedFunction = *annotation().userDefinedFunction;
+	return dynamic_cast<FunctionType const*>(
+		userDefinedFunction->libraryFunction() ?
+		userDefinedFunction->typeViaContractName() :
+		userDefinedFunction->type()
+	);
+}
+
+FunctionType const* BinaryOperation::userDefinedFunctionType() const
+{
+	if (*annotation().userDefinedFunction == nullptr)
+		return nullptr;
+
+	FunctionDefinition const* userDefinedFunction = *annotation().userDefinedFunction;
+	return dynamic_cast<FunctionType const*>(
+		userDefinedFunction->libraryFunction() ?
+		userDefinedFunction->typeViaContractName() :
+		userDefinedFunction->type()
+	);
+}
+
 BinaryOperationAnnotation& BinaryOperation::annotation() const
 {
 	return initAnnotation<BinaryOperationAnnotation>();
@@ -887,7 +934,7 @@ FunctionCallAnnotation& FunctionCall::annotation() const
 	return initAnnotation<FunctionCallAnnotation>();
 }
 
-vector<ASTPointer<Expression const>> FunctionCall::sortedArguments() const
+std::vector<ASTPointer<Expression const>> FunctionCall::sortedArguments() const
 {
 	// normal arguments
 	if (m_names.empty())
@@ -904,7 +951,7 @@ vector<ASTPointer<Expression const>> FunctionCall::sortedArguments() const
 	else
 		functionType = dynamic_cast<FunctionType const*>(m_expression->annotation().type);
 
-	vector<ASTPointer<Expression const>> sorted;
+	std::vector<ASTPointer<Expression const>> sorted;
 	for (auto const& parameterName: functionType->parameterNames())
 	{
 		bool found = false;
@@ -959,13 +1006,25 @@ bool Literal::passesAddressChecksum() const
 	return util::passesAddressChecksum(valueWithoutUnderscores(), true);
 }
 
-string Literal::getChecksummedAddress() const
+std::string Literal::getChecksummedAddress() const
 {
 	solAssert(isHexNumber(), "Expected hex number");
 	/// Pad literal to be a proper hex address.
-	string address = valueWithoutUnderscores().substr(2);
+	std::string address = valueWithoutUnderscores().substr(2);
 	if (address.length() > 40)
-		return string();
+		return std::string();
 	address.insert(address.begin(), 40 - address.size(), '0');
 	return util::getChecksummedAddress(address);
 }
+
+/// Experimental Solidity nodes
+/// @{
+TypeClassDefinitionAnnotation& TypeClassDefinition::annotation() const
+{
+	return initAnnotation<TypeClassDefinitionAnnotation>();
+}
+TypeDeclarationAnnotation& TypeDefinition::annotation() const
+{
+	return initAnnotation<TypeDeclarationAnnotation>();
+}
+/// @}
diff --git a/compiler/libsolidity/ast/AST.h b/compiler/libsolidity/ast/AST.h
index 8d727af7..6b490609 100644
--- a/compiler/libsolidity/ast/AST.h
+++ b/compiler/libsolidity/ast/AST.h
@@ -86,15 +86,19 @@ class ASTNode
 	static void listAccept(std::vector<T> const& _list, ASTVisitor& _visitor)
 	{
 		for (T const& element: _list)
-			if (element)
-				element->accept(_visitor);
+		{
+			solAssert(element);
+			element->accept(_visitor);
+		}
 	}
 	template <class T>
 	static void listAccept(std::vector<T> const& _list, ASTConstVisitor& _visitor)
 	{
 		for (T const& element: _list)
-			if (element)
-				element->accept(_visitor);
+		{
+			solAssert(element);
+			element->accept(_visitor);
+		}
 	}
 
 	/// @returns a copy of the vector containing only the nodes which derive from T.
@@ -120,6 +124,8 @@ class ASTNode
 	bool operator!=(ASTNode const& _other) const { return !operator==(_other); }
 	///@}
 
+	virtual bool experimentalSolidityOnly() const { return false; }
+
 protected:
 	size_t const m_id = 0;
 
@@ -166,9 +172,14 @@ class SourceUnit: public ASTNode, public ScopeOpener
 		int64_t _id,
 		SourceLocation const& _location,
 		std::optional<std::string> _licenseString,
-		std::vector<ASTPointer<ASTNode>> _nodes
+		std::vector<ASTPointer<ASTNode>> _nodes,
+		bool _experimentalSolidity
 	):
-		ASTNode(_id, _location), m_licenseString(std::move(_licenseString)), m_nodes(std::move(_nodes)) {}
+		ASTNode(_id, _location),
+		m_licenseString(std::move(_licenseString)),
+		m_nodes(std::move(_nodes)),
+		m_experimentalSolidity(_experimentalSolidity)
+	{}
 
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
@@ -179,10 +190,12 @@ class SourceUnit: public ASTNode, public ScopeOpener
 
 	/// @returns a set of referenced SourceUnits. Recursively if @a _recurse is true.
 	std::set<SourceUnit const*> referencedSourceUnits(bool _recurse = false, std::set<SourceUnit const*> _skipList = std::set<SourceUnit const*>()) const;
+	bool experimentalSolidity() const { return m_experimentalSolidity; }
 
 private:
 	std::optional<std::string> m_licenseString;
 	std::vector<ASTPointer<ASTNode>> m_nodes;
+	bool m_experimentalSolidity = false;
 };
 
 /**
@@ -526,6 +539,10 @@ class ContractDefinition: public Declaration, public StructurallyDocumented, pub
 	std::vector<EventDefinition const*> events() const { return filteredNodes<EventDefinition>(m_subNodes); }
 	std::vector<EventDefinition const*> const& definedInterfaceEvents() const;
 	std::vector<EventDefinition const*> const usedInterfaceEvents() const;
+	/// @return all events defined in this contract and its base contracts and all events
+	/// that are emitted during the execution of the contract.
+	/// @param _requireCallGraph if false, do not fail if the call graph has not been computed yet.
+	std::vector<EventDefinition const*> interfaceEvents(bool _requireCallGraph = true) const;
 	/// @returns all errors defined in this contract or any base contract
 	/// and all errors referenced during execution.
 	/// @param _requireCallGraph if false, do not fail if the call graph has not been computed yet.
@@ -651,15 +668,20 @@ class InheritanceSpecifier: public ASTNode
 /**
  * Using for directive:
  *
- * 1. `using LibraryName for T` attaches all functions from the library `LibraryName` to the type `T`
+ * 1. `using LibraryName for T` attaches all functions from the library `LibraryName` to the type `T`.
  * 2. `using LibraryName for *` attaches to all types.
- * 3. `using {f1, f2, ..., fn} for T` attaches the functions `f1`, `f2`, ...,
- *     `fn`, respectively to `T`.
+ * 3. `using {f1, f2, ..., fn} for T` attaches the functions `f1`, `f2`, ..., `fn`, respectively to `T`.
+ * 4. `using {f1 as op1, f2 as op2, ..., fn as opn} for T` implements operator `opn` for type `T` with function `fn`.
  *
  * For version 3, T has to be implicitly convertible to the first parameter type of
  * all functions, and this is checked at the point of the using statement. For versions 1 and
  * 2, this check is only done when a function is called.
  *
+ * For version 4, T has to be user-defined value type and the function must be pure.
+ * All parameters and return value of all the functions have to be of type T.
+ * This version can be combined with version 3 - a single directive may attach functions to the
+ * type and define operators on it at the same time.
+ *
  * Finally, `using {f1, f2, ..., fn} for T global` is also valid at file level, as long as T is
  * a user-defined type defined in the same file at file level. In this case, the methods are
  * attached to all objects of that type regardless of scope.
@@ -670,17 +692,20 @@ class UsingForDirective: public ASTNode
 	UsingForDirective(
 		int64_t _id,
 		SourceLocation const& _location,
-		std::vector<ASTPointer<IdentifierPath>> _functions,
+		std::vector<ASTPointer<IdentifierPath>> _functionsOrLibrary,
+		std::vector<std::optional<Token>> _operators,
 		bool _usesBraces,
 		ASTPointer<TypeName> _typeName,
 		bool _global
 	):
 		ASTNode(_id, _location),
-		m_functions(_functions),
+		m_functionsOrLibrary(std::move(_functionsOrLibrary)),
+		m_operators(std::move(_operators)),
 		m_usesBraces(_usesBraces),
 		m_typeName(std::move(_typeName)),
 		m_global{_global}
 	{
+		solAssert(m_functionsOrLibrary.size() == m_operators.size());
 	}
 
 	void accept(ASTVisitor& _visitor) override;
@@ -690,19 +715,25 @@ class UsingForDirective: public ASTNode
 	TypeName const* typeName() const { return m_typeName.get(); }
 
 	/// @returns a list of functions or the single library.
-	std::vector<ASTPointer<IdentifierPath>> const& functionsOrLibrary() const { return m_functions; }
+	std::vector<ASTPointer<IdentifierPath>> const& functionsOrLibrary() const { return m_functionsOrLibrary; }
+	std::vector<std::pair<ASTPointer<IdentifierPath>, std::optional<Token>>> functionsAndOperators() const;
 	bool usesBraces() const { return m_usesBraces; }
 	bool global() const { return m_global; }
 
 private:
 	/// Either the single library or a list of functions.
-	std::vector<ASTPointer<IdentifierPath>> m_functions;
+	std::vector<ASTPointer<IdentifierPath>> m_functionsOrLibrary;
+	/// Operators, the functions from @a m_functionsOrLibrary implement.
+	/// A token if the corresponding element in m_functionsOrLibrary
+	/// defines an operator, nullptr otherwise.
+	/// Note that this vector size must be equal to m_functionsOrLibrary size.
+	std::vector<std::optional<Token>> m_operators;
 	bool m_usesBraces;
 	ASTPointer<TypeName> m_typeName;
 	bool m_global = false;
 };
 
-class StructDefinition: public Declaration, public ScopeOpener
+class StructDefinition: public Declaration, public StructurallyDocumented, public ScopeOpener
 {
 public:
 	StructDefinition(
@@ -710,9 +741,13 @@ class StructDefinition: public Declaration, public ScopeOpener
 		SourceLocation const& _location,
 		ASTPointer<ASTString> const& _name,
 		SourceLocation _nameLocation,
-		std::vector<ASTPointer<VariableDeclaration>> _members
+		std::vector<ASTPointer<VariableDeclaration>> _members,
+		ASTPointer<StructuredDocumentation> _documentation
 	):
-		Declaration(_id, _location, _name, std::move(_nameLocation)), m_members(std::move(_members)) {}
+		Declaration(_id, _location, _name, std::move(_nameLocation)),
+		StructurallyDocumented(std::move(_documentation)),
+		m_members(std::move(_members))
+	{}
 
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
@@ -730,7 +765,7 @@ class StructDefinition: public Declaration, public ScopeOpener
 	std::vector<ASTPointer<VariableDeclaration>> m_members;
 };
 
-class EnumDefinition: public Declaration, public ScopeOpener
+class EnumDefinition: public Declaration, public StructurallyDocumented, public ScopeOpener
 {
 public:
 	EnumDefinition(
@@ -738,9 +773,14 @@ class EnumDefinition: public Declaration, public ScopeOpener
 		SourceLocation const& _location,
 		ASTPointer<ASTString> const& _name,
 		SourceLocation _nameLocation,
-		std::vector<ASTPointer<EnumValue>> _members
+		std::vector<ASTPointer<EnumValue>> _members,
+		ASTPointer<StructuredDocumentation> _documentation
 	):
-		Declaration(_id, _location, _name, std::move(_nameLocation)), m_members(std::move(_members)) {}
+		Declaration(_id, _location, _name, std::move(_nameLocation)),
+		StructurallyDocumented(std::move(_documentation)),
+		m_members(std::move(_members))
+	{}
+
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
 
@@ -935,9 +975,10 @@ class FunctionDefinition: public CallableDeclaration, public StructurallyDocumen
 		bool _responsible,
 		bool _externalMsg,
 		bool _internalMsg,
-		bool _freeInlineAssembly
+		bool _freeInlineAssembly,
+		ASTPointer<Expression> const& _experimentalReturnExpression = {}
 	):
-		CallableDeclaration(_id, _location, _name, std::move(_nameLocation), _visibility, _parameters, _isVirtual, _overrides, _returnParameters),
+		CallableDeclaration(_id, _location, _name, _nameLocation, _visibility, _parameters, _isVirtual, _overrides, _returnParameters),
 		StructurallyDocumented(_documentation),
 		ImplementationOptional(_body != nullptr),
 		m_stateMutability(_stateMutability),
@@ -950,13 +991,15 @@ class FunctionDefinition: public CallableDeclaration, public StructurallyDocumen
 		m_responsible{_responsible},
 		m_externalMsg{_externalMsg},
 		m_internalMsg{_internalMsg},
-		m_inlineAssembly{_freeInlineAssembly}
+		m_inlineAssembly{_freeInlineAssembly},
+		m_experimentalReturnExpression(_experimentalReturnExpression)
 	{
 		solAssert(_kind == Token::Constructor || _kind == Token::Function ||
 			  _kind == Token::Fallback || _kind == Token::Receive || _kind == Token::onBounce ||
 			  _kind == Token::onTickTock
 		  , "");
 		solAssert(isOrdinary() == !name().empty(), "");
+		// TODO: assert _returnParameters implies non-experimental _experimentalReturnExpression implies experimental
 	}
 
 	void accept(ASTVisitor& _visitor) override;
@@ -1027,6 +1070,8 @@ class FunctionDefinition: public CallableDeclaration, public StructurallyDocumen
 		ContractDefinition const* _searchStart = nullptr
 	) const override;
 
+	Expression const* experimentalReturnExpression() const { return m_experimentalReturnExpression.get(); }
+
 private:
 	StateMutability m_stateMutability;
 	bool m_free;
@@ -1039,6 +1084,7 @@ class FunctionDefinition: public CallableDeclaration, public StructurallyDocumen
 	bool m_externalMsg{};
 	bool m_internalMsg{};
 	bool m_inlineAssembly{};
+	ASTPointer<Expression> m_experimentalReturnExpression;
 };
 
 /**
@@ -1072,7 +1118,9 @@ class VariableDeclaration: public Declaration, public StructurallyDocumented
 		bool _isIndexed = false,
 		Mutability _mutability = Mutability::Mutable,
 		ASTPointer<OverrideSpecifier> _overrides = nullptr,
-		bool isStatic = false
+		bool isStatic = false,
+		bool _noStorage = false,
+		ASTPointer<Expression> _typeExpression = {}
 	):
 		Declaration(_id, _location, _name, std::move(_nameLocation), _visibility),
 		StructurallyDocumented(std::move(_documentation)),
@@ -1081,15 +1129,19 @@ class VariableDeclaration: public Declaration, public StructurallyDocumented
 		m_isIndexed(_isIndexed),
 		m_mutability(_mutability),
 		m_overrides(std::move(_overrides)),
-		m_isStatic(isStatic)
+		m_isStatic(isStatic),
+		m_noStorage(_noStorage),
+		m_typeExpression(std::move(_typeExpression))
 	{
-		solAssert(m_typeName, "");
+		// TODO: consider still asserting unless we are in experimental solidity.
+		// solAssert(m_typeName, ""); solAssert(!m_typeExpression, "");
 	}
 
 
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
 
+	bool hasTypeName() const { return m_typeName != nullptr; }
 	TypeName const& typeName() const { return *m_typeName; }
 	ASTPointer<Expression> const& value() const { return m_value; }
 
@@ -1131,6 +1183,7 @@ class VariableDeclaration: public Declaration, public StructurallyDocumented
 	bool isConstant() const { return m_mutability == Mutability::Constant; }
 	bool immutable() const { return m_mutability == Mutability::Immutable; }
 	bool isStatic() const { return m_isStatic; }
+	bool isNoStorage() const { return m_noStorage; }
 	ASTPointer<OverrideSpecifier> const& overrides() const { return m_overrides; }
 
 	/// @returns the external identifier of this variable (the hash of the signature) as a hex string (works only for public state variables).
@@ -1142,6 +1195,7 @@ class VariableDeclaration: public Declaration, public StructurallyDocumented
 	/// @returns null when it is not accessible as a function.
 	FunctionTypePointer functionType(bool /*_internal*/) const override;
 
+	ASTPointer<Expression> const& typeExpression() const { return m_typeExpression; }
 	VariableDeclarationAnnotation& annotation() const override;
 
 protected:
@@ -1156,8 +1210,9 @@ class VariableDeclaration: public Declaration, public StructurallyDocumented
 	/// Whether the variable is "constant", "immutable" or non-marked (mutable).
 	Mutability m_mutability = Mutability::Mutable;
 	ASTPointer<OverrideSpecifier> m_overrides; ///< Contains the override specifier node
-	ASTPointer<ASTString> m_attribute; ///< Attribute for variable.
 	bool m_isStatic = false;
+	bool m_noStorage = false;
+	ASTPointer<Expression> m_typeExpression;
 };
 
 /**
@@ -1266,7 +1321,7 @@ class EventDefinition: public CallableDeclaration, public StructurallyDocumented
 	FunctionTypePointer functionType(bool /*_internal*/) const override;
 
 	bool isVisibleInDerivedContracts() const override { return true; }
-	bool isVisibleViaContractTypeAccess() const override { return false; /* TODO */ }
+	bool isVisibleViaContractTypeAccess() const override { return true; }
 
 	EventDefinitionAnnotation& annotation() const override;
 
@@ -1461,18 +1516,37 @@ class Mapping: public TypeName
 		int64_t _id,
 		SourceLocation const& _location,
 		ASTPointer<TypeName> _keyType,
-		ASTPointer<TypeName> _valueType
+		ASTPointer<ASTString> _keyName,
+		SourceLocation _keyNameLocation,
+		ASTPointer<TypeName> _valueType,
+		ASTPointer<ASTString> _valueName,
+		SourceLocation _valueNameLocation
 	):
-		TypeName(_id, _location), m_keyType(std::move(_keyType)), m_valueType(std::move(_valueType)) {}
+		TypeName(_id, _location),
+		m_keyType(std::move(_keyType)),
+		m_keyName(std::move(_keyName)),
+		m_keyNameLocation(std::move(_keyNameLocation)),
+		m_valueType(std::move(_valueType)),
+		m_valueName(std::move(_valueName)),
+		m_valueNameLocation(std::move(_valueNameLocation))
+	{}
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
 
 	TypeName const& keyType() const { return *m_keyType; }
+	ASTString keyName() const { return *m_keyName; }
+	SourceLocation keyNameLocation() const { return m_keyNameLocation; }
 	TypeName const& valueType() const { return *m_valueType; }
+	ASTString valueName() const { return *m_valueName; }
+	SourceLocation valueNameLocation() const { return m_valueNameLocation; }
 
 private:
 	ASTPointer<TypeName> m_keyType;
+	ASTPointer<ASTString> m_keyName;
+	SourceLocation m_keyNameLocation;
 	ASTPointer<TypeName> m_valueType;
+	ASTPointer<ASTString> m_valueName;
+	SourceLocation m_valueNameLocation;
 };
 
 /**
@@ -1579,24 +1653,6 @@ class FreeInlineAssembly: public Statement
 	std::vector<ASTPointer<Expression>> m_lines;
 };
 
-/**
- * Inline assembly.
- */
-class InlineAssembly: public Statement
-{
-public:
-	InlineAssembly(
-		int64_t _id,
-		SourceLocation const& _location,
-		ASTPointer<ASTString> const& _docString
-	):
-		Statement(_id, _location, _docString) {}
-	void accept(ASTVisitor& _visitor) override;
-	void accept(ASTConstVisitor& _visitor) const override;
-
-	InlineAssemblyAnnotation& annotation() const override;
-};
-
 /**
  * Brace-enclosed block containing zero or more statements.
  */
@@ -1910,16 +1966,17 @@ class Return: public Statement
 		SourceLocation const& _location,
 		ASTPointer<ASTString> const& _docString,
 		ASTPointer<Expression> _expression,
-		std::vector<ASTPointer<Expression>> options,
-		std::vector<ASTPointer<ASTString>> names
+		std::vector<ASTPointer<Expression>> _options,
+		std::vector<ASTPointer<ASTString>> _names,
+		std::vector<langutil::SourceLocation> _nameLocations
 	): Statement(_id, _location, _docString), m_expression(std::move(_expression)),
-		   m_options(std::move(options)), m_names(std::move(names)) {}
+		   m_options(std::move(_options)), m_names(std::move(_names)), m_nameLocations(std::move(_nameLocations)) {}
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
-
 	Expression const* expression() const { return m_expression.get(); }
 	const std::vector<ASTPointer<Expression>>& options() const { return m_options; }
 	const std::vector<ASTPointer<ASTString>>& names() const { return m_names; }
+	const std::vector<langutil::SourceLocation>& nameLocations() const { return m_nameLocations; }
 
 	ReturnAnnotation& annotation() const override;
 
@@ -1927,6 +1984,7 @@ class Return: public Statement
 	ASTPointer<Expression> m_expression; ///< value to return, optional
 	std::vector<ASTPointer<Expression>> m_options;
 	std::vector<ASTPointer<ASTString>> m_names;
+	std::vector<langutil::SourceLocation> m_nameLocations;
 };
 
 /**
@@ -2197,6 +2255,10 @@ class UnaryOperation: public Expression
 	bool isPrefixOperation() const { return m_isPrefix; }
 	Expression const& subExpression() const { return *m_subExpression; }
 
+	FunctionType const* userDefinedFunctionType() const;
+
+	OperationAnnotation& annotation() const override;
+
 private:
 	Token m_operator;
 	ASTPointer<Expression> m_subExpression;
@@ -2219,7 +2281,8 @@ class BinaryOperation: public Expression
 	):
 		Expression(_id, _location), m_left(std::move(_left)), m_operator(_operator), m_right(std::move(_right))
 	{
-		solAssert(TokenTraits::isBinaryOp(_operator) || TokenTraits::isCompareOp(_operator), "");
+		// TODO: assert against colon for non-experimental solidity
+		solAssert(TokenTraits::isBinaryOp(_operator) || TokenTraits::isCompareOp(_operator) || _operator == Token::Colon || _operator == Token::RightArrow, "");
 	}
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
@@ -2228,6 +2291,8 @@ class BinaryOperation: public Expression
 	Expression const& rightExpression() const { return *m_right; }
 	Token getOperator() const { return m_operator; }
 
+	FunctionType const* userDefinedFunctionType() const;
+
 	BinaryOperationAnnotation& annotation() const override;
 
 private:
@@ -2298,19 +2363,23 @@ class InitializerList: public Expression {
 	InitializerList(
 		int64_t _id,
 		SourceLocation const& _location,
-		std::vector<ASTPointer<Expression>> const& _options,
-		std::vector<ASTPointer<ASTString>> const& _names
+		std::vector<ASTPointer<Expression>> _options,
+		std::vector<ASTPointer<ASTString>> _names,
+		std::vector<langutil::SourceLocation> _nameLocations
 	):
-	Expression(_id, _location), m_options(_options), m_names(_names) {}
+	Expression(_id, _location), m_options(std::move(_options)), m_names(std::move(_names)),
+		m_nameLocations(std::move(_nameLocations)) {}
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
 
 	std::vector<ASTPointer<Expression const>> options() const { return {m_options.begin(), m_options.end()}; }
 	std::vector<ASTPointer<ASTString>> const& names() const { return m_names; }
+	std::vector<langutil::SourceLocation> const& nameLocations() const { return m_nameLocations; }
 
 private:
 	std::vector<ASTPointer<Expression>> m_options;
 	std::vector<ASTPointer<ASTString>> m_names;
+	std::vector<langutil::SourceLocation> m_nameLocations;
 };
 
 
@@ -2665,4 +2734,167 @@ class Literal: public PrimaryExpression
 
 /// @}
 
+/// Experimental Solidity nodes
+/// @{
+class TypeClassDefinition: public Declaration, public StructurallyDocumented, public ScopeOpener
+{
+public:
+	TypeClassDefinition(
+		int64_t _id,
+		SourceLocation const& _location,
+		ASTPointer<VariableDeclaration> _typeVariable,
+		ASTPointer<ASTString> const& _name,
+		SourceLocation _nameLocation,
+		ASTPointer<StructuredDocumentation> const& _documentation,
+		std::vector<ASTPointer<ASTNode>> _subNodes
+	):
+		Declaration(_id, _location, _name, std::move(_nameLocation)),
+		StructurallyDocumented(_documentation),
+		m_typeVariable(std::move(_typeVariable)),
+		m_subNodes(std::move(_subNodes))
+	{}
+
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	VariableDeclaration const& typeVariable() const { return *m_typeVariable; }
+	std::vector<ASTPointer<ASTNode>> const& subNodes() const { return m_subNodes; }
+
+	TypeClassDefinitionAnnotation& annotation() const override;
+
+	Type const* type() const override { solAssert(false, "Requested type of experimental solidity node."); }
+
+	bool experimentalSolidityOnly() const override { return true; }
+
+private:
+	ASTPointer<VariableDeclaration> m_typeVariable;
+	std::vector<ASTPointer<ASTNode>> m_subNodes;
+};
+
+class TypeClassInstantiation: public ASTNode, public ScopeOpener
+{
+public:
+	TypeClassInstantiation(
+		int64_t _id,
+		SourceLocation const& _location,
+		ASTPointer<TypeName> _typeConstructor,
+		ASTPointer<ParameterList> _argumentSorts,
+		ASTPointer<TypeClassName> _class,
+		std::vector<ASTPointer<ASTNode>> _subNodes
+	):
+		ASTNode(_id, _location),
+		m_typeConstructor(std::move(_typeConstructor)),
+		m_argumentSorts(std::move(_argumentSorts)),
+		m_class(std::move(_class)),
+		m_subNodes(std::move(_subNodes))
+	{}
+
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	TypeName const& typeConstructor() const { return *m_typeConstructor; }
+	ParameterList const* argumentSorts() const { return m_argumentSorts.get(); }
+	TypeClassName const& typeClass() const { return *m_class; }
+	std::vector<ASTPointer<ASTNode>> const& subNodes() const { return m_subNodes; }
+
+	bool experimentalSolidityOnly() const override { return true; }
+
+private:
+	ASTPointer<TypeName> m_typeConstructor;
+	ASTPointer<ParameterList> m_argumentSorts;
+	ASTPointer<TypeClassName> m_class;
+	std::vector<ASTPointer<ASTNode>> m_subNodes;
+};
+
+class TypeDefinition: public Declaration, public ScopeOpener
+{
+public:
+	TypeDefinition(
+		int64_t _id,
+		SourceLocation const& _location,
+		ASTPointer<ASTString> _name,
+		SourceLocation _nameLocation,
+		ASTPointer<ParameterList> _arguments,
+		ASTPointer<Expression> _typeExpression
+	):
+		Declaration(_id, _location, _name, std::move(_nameLocation), Visibility::Default),
+		m_arguments(std::move(_arguments)),
+		m_typeExpression(std::move(_typeExpression))
+	{
+	}
+
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	Type const* type() const override { return nullptr; }
+
+	TypeDeclarationAnnotation& annotation() const override;
+
+	ParameterList const* arguments() const { return m_arguments.get(); }
+	Expression const* typeExpression() const { return m_typeExpression.get(); }
+
+	bool experimentalSolidityOnly() const override { return true; }
+
+private:
+	ASTPointer<ParameterList> m_arguments;
+	ASTPointer<Expression> m_typeExpression;
+};
+
+class TypeClassName: public ASTNode
+{
+public:
+	TypeClassName(
+		int64_t _id,
+		SourceLocation const& _location,
+		std::variant<Token, ASTPointer<IdentifierPath>> _name
+	):
+		ASTNode(_id, _location),
+		m_name(std::move(_name))
+	{
+		if (Token const* token = std::get_if<Token>(&_name))
+			solAssert(TokenTraits::isBuiltinTypeClassName(*token));
+	}
+
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	bool experimentalSolidityOnly() const override { return true; }
+
+	std::variant<Token, ASTPointer<IdentifierPath>> name() const { return m_name; }
+
+private:
+	std::variant<Token, ASTPointer<IdentifierPath>> m_name;
+};
+
+class Builtin: public Expression
+{
+public:
+	Builtin(
+		int64_t _id,
+		SourceLocation _location,
+		ASTPointer<ASTString> _nameParameter,
+		SourceLocation _nameParameterLocation
+	):
+		Expression(_id, std::move(_location)),
+		m_nameParameter(std::move(_nameParameter)),
+		m_nameParameterLocation(std::move(_nameParameterLocation))
+	{
+		solAssert(m_nameParameter);
+	}
+
+	void accept(ASTVisitor& _visitor) override;
+	void accept(ASTConstVisitor& _visitor) const override;
+
+	bool experimentalSolidityOnly() const override { return true; }
+
+	ASTString const& nameParameter() const { return *m_nameParameter; }
+	SourceLocation const& nameParameterLocation() const { return m_nameParameterLocation; }
+
+private:
+	ASTPointer<ASTString> m_nameParameter;
+	SourceLocation m_nameParameterLocation;
+};
+
+/// @}
+
 }
diff --git a/compiler/libsolidity/ast/ASTAnnotations.cpp b/compiler/libsolidity/ast/ASTAnnotations.cpp
index 3556041d..84d49fa2 100644
--- a/compiler/libsolidity/ast/ASTAnnotations.cpp
+++ b/compiler/libsolidity/ast/ASTAnnotations.cpp
@@ -23,7 +23,6 @@
 
 #include <libsolidity/ast/ASTAnnotations.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
diff --git a/compiler/libsolidity/ast/ASTAnnotations.h b/compiler/libsolidity/ast/ASTAnnotations.h
index 00fff99e..102c1e23 100644
--- a/compiler/libsolidity/ast/ASTAnnotations.h
+++ b/compiler/libsolidity/ast/ASTAnnotations.h
@@ -162,6 +162,9 @@ struct ContractDefinitionAnnotation: TypeDeclarationAnnotation, StructurallyDocu
 	/// List of contracts whose bytecode is referenced by this contract, e.g. through "new".
 	/// The Value represents the ast node that referenced the contract.
 	std::map<ContractDefinition const*, ASTNode const*, ASTCompareByID<ContractDefinition>> contractDependencies;
+
+	// Per-contract map from function AST IDs to internal dispatch function IDs.
+	std::map<FunctionDefinition const*, uint64_t> internalFunctionIDs;
 };
 
 struct CallableDeclarationAnnotation: DeclarationAnnotation
@@ -225,6 +228,7 @@ struct TryCatchClauseAnnotation: ASTAnnotation, ScopableAnnotation
 
 struct ForStatementAnnotation: StatementAnnotation, ScopableAnnotation
 {
+	util::SetOnce<bool> isSimpleCounterLoop;
 };
 
 
@@ -236,6 +240,8 @@ struct ReturnAnnotation: StatementAnnotation
 {
 	/// Reference to the return parameters of the function.
 	ParameterList const* functionReturnParameters = nullptr;
+	/// Reference to the function containing the return statement.
+	FunctionDefinition const* function = nullptr;
 };
 
 struct TypeNameAnnotation: ASTAnnotation
@@ -307,7 +313,12 @@ struct MemberAccessAnnotation: ExpressionAnnotation
 	util::SetOnce<VirtualLookup> requiredLookup;
 };
 
-struct BinaryOperationAnnotation: ExpressionAnnotation
+struct OperationAnnotation: ExpressionAnnotation
+{
+	util::SetOnce<FunctionDefinition const*> userDefinedFunction;
+};
+
+struct BinaryOperationAnnotation: OperationAnnotation
 {
 	/// The common type that is used for the operation, not necessarily the result type (which
 	/// e.g. for comparisons is bool).
@@ -328,4 +339,12 @@ struct FunctionCallAnnotation: ExpressionAnnotation
 	bool tryCall = false;
 };
 
+/// Experimental Solidity annotations.
+/// Used to integrate with name and type resolution.
+/// @{
+struct TypeClassDefinitionAnnotation: TypeDeclarationAnnotation, StructurallyDocumentedAnnotation
+{
+};
+/// @}
+
 }
diff --git a/compiler/libsolidity/ast/ASTForward.h b/compiler/libsolidity/ast/ASTForward.h
index c9826307..3f8afea1 100644
--- a/compiler/libsolidity/ast/ASTForward.h
+++ b/compiler/libsolidity/ast/ASTForward.h
@@ -68,7 +68,6 @@ class Mapping;
 class Optional;
 class TvmVector;
 class ArrayTypeName;
-class InlineAssembly;
 class Statement;
 class Block;
 class PlaceholderStatement;
@@ -101,6 +100,15 @@ class ElementaryTypeNameExpression;
 class Literal;
 class StructuredDocumentation;
 
+/// Experimental Solidity nodes
+/// @{
+class TypeClassDefinition;
+class TypeClassInstantiation;
+class TypeClassName;
+class TypeDefinition;
+class Builtin;
+/// @}
+
 class VariableScope;
 
 template <class T>
diff --git a/compiler/libsolidity/ast/ASTJsonExporter.cpp b/compiler/libsolidity/ast/ASTJsonExporter.cpp
index 64ad29af..cf5e1364 100644
--- a/compiler/libsolidity/ast/ASTJsonExporter.cpp
+++ b/compiler/libsolidity/ast/ASTJsonExporter.cpp
@@ -40,21 +40,21 @@
 #include <type_traits>
 #include <range/v3/view/map.hpp>
 
-using namespace std;
+using namespace std::string_literals;
 using namespace solidity::langutil;
 
 namespace
 {
 
 template<typename V, template<typename> typename C>
-void addIfSet(std::vector<pair<string, Json::Value>>& _attributes, string const& _name, C<V> const& _value)
+void addIfSet(std::vector<std::pair<std::string, Json::Value>>& _attributes, std::string const& _name, C<V> const& _value)
 {
 	if constexpr (std::is_same_v<C<V>, solidity::util::SetOnce<V>>)
 	{
 		if (!_value.set())
 			return;
 	}
-	else if constexpr (std::is_same_v<C<V>, optional<V>>)
+	else if constexpr (std::is_same_v<C<V>, std::optional<V>>)
 	{
 		if (!_value.has_value())
 			return;
@@ -68,7 +68,7 @@ void addIfSet(std::vector<pair<string, Json::Value>>& _attributes, string const&
 namespace solidity::frontend
 {
 
-ASTJsonExporter::ASTJsonExporter(CompilerStack::State _stackState, map<string, unsigned> _sourceIndices):
+ASTJsonExporter::ASTJsonExporter(CompilerStack::State _stackState, std::map<std::string, unsigned> _sourceIndices):
 	m_stackState(_stackState),
 	m_sourceIndices(std::move(_sourceIndices))
 {
@@ -77,21 +77,21 @@ ASTJsonExporter::ASTJsonExporter(CompilerStack::State _stackState, map<string, u
 
 void ASTJsonExporter::setJsonNode(
 	ASTNode const& _node,
-	string const& _nodeName,
-	initializer_list<pair<string, Json::Value>>&& _attributes
+	std::string const& _nodeName,
+	std::initializer_list<std::pair<std::string, Json::Value>>&& _attributes
 )
 {
 	ASTJsonExporter::setJsonNode(
 		_node,
 		_nodeName,
-		std::vector<pair<string, Json::Value>>(std::move(_attributes))
+		std::vector<std::pair<std::string, Json::Value>>(std::move(_attributes))
 	);
 }
 
 void ASTJsonExporter::setJsonNode(
 	ASTNode const& _node,
-	string const& _nodeType,
-	std::vector<pair<string, Json::Value>>&& _attributes
+	std::string const& _nodeType,
+	std::vector<std::pair<std::string, Json::Value>>&& _attributes
 )
 {
 	m_currentValue = Json::objectValue;
@@ -105,24 +105,24 @@ void ASTJsonExporter::setJsonNode(
 		m_currentValue[e.first] = std::move(e.second);
 }
 
-optional<size_t> ASTJsonExporter::sourceIndexFromLocation(SourceLocation const& _location) const
+std::optional<size_t> ASTJsonExporter::sourceIndexFromLocation(SourceLocation const& _location) const
 {
 	if (_location.sourceName && m_sourceIndices.count(*_location.sourceName))
 		return m_sourceIndices.at(*_location.sourceName);
 	else
-		return nullopt;
+		return std::nullopt;
 }
 
-string ASTJsonExporter::sourceLocationToString(SourceLocation const& _location) const
+std::string ASTJsonExporter::sourceLocationToString(SourceLocation const& _location) const
 {
-	optional<size_t> sourceIndexOpt = sourceIndexFromLocation(_location);
+	std::optional<size_t> sourceIndexOpt = sourceIndexFromLocation(_location);
 	int length = -1;
 	if (_location.start >= 0 && _location.end >= 0)
 		length = _location.end - _location.start;
-	return to_string(_location.start) + ":" + to_string(length) + ":" + (sourceIndexOpt.has_value() ? to_string(sourceIndexOpt.value()) : "-1");
+	return std::to_string(_location.start) + ":" + std::to_string(length) + ":" + (sourceIndexOpt.has_value() ? std::to_string(sourceIndexOpt.value()) : "-1");
 }
 
-Json::Value ASTJsonExporter::sourceLocationsToJson(vector<SourceLocation> const& _sourceLocations) const
+Json::Value ASTJsonExporter::sourceLocationsToJson(std::vector<SourceLocation> const& _sourceLocations) const
 {
 	Json::Value locations = Json::arrayValue;
 
@@ -132,9 +132,9 @@ Json::Value ASTJsonExporter::sourceLocationsToJson(vector<SourceLocation> const&
 	return locations;
 }
 
-string ASTJsonExporter::namePathToString(std::vector<ASTString> const& _namePath)
+std::string ASTJsonExporter::namePathToString(std::vector<ASTString> const& _namePath)
 {
-	return boost::algorithm::join(_namePath, ".");
+	return boost::algorithm::join(_namePath, "."s);
 }
 
 Json::Value ASTJsonExporter::typePointerToJson(Type const* _tp, bool _withoutDataLocation)
@@ -159,13 +159,13 @@ Json::Value ASTJsonExporter::typePointerToJson(std::optional<FuncCallArguments>
 }
 
 void ASTJsonExporter::appendExpressionAttributes(
-	std::vector<pair<string, Json::Value>>& _attributes,
+	std::vector<std::pair<std::string, Json::Value>>& _attributes,
 	ExpressionAnnotation const& _annotation
 )
 {
-	std::vector<pair<string, Json::Value>> exprAttributes = {
-		make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
-		make_pair("argumentTypes", typePointerToJson(_annotation.arguments))
+	std::vector<std::pair<std::string, Json::Value>> exprAttributes = {
+		std::make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
+		std::make_pair("argumentTypes", typePointerToJson(_annotation.arguments))
 	};
 
 	addIfSet(exprAttributes, "isLValue", _annotation.isLValue);
@@ -178,7 +178,7 @@ void ASTJsonExporter::appendExpressionAttributes(
 	_attributes += exprAttributes;
 }
 
-void ASTJsonExporter::print(ostream& _stream, ASTNode const& _node, util::JsonFormat const& _format)
+void ASTJsonExporter::print(std::ostream& _stream, ASTNode const& _node, util::JsonFormat const& _format)
 {
 	_stream << util::jsonPrint(toJson(_node), _format);
 }
@@ -191,11 +191,14 @@ Json::Value ASTJsonExporter::toJson(ASTNode const& _node)
 
 bool ASTJsonExporter::visit(SourceUnit const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("license", _node.licenseString() ? Json::Value(*_node.licenseString()) : Json::nullValue),
-		make_pair("nodes", toJson(_node.nodes()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("license", _node.licenseString() ? Json::Value(*_node.licenseString()) : Json::nullValue),
+		std::make_pair("nodes", toJson(_node.nodes())),
 	};
 
+	if (_node.experimentalSolidity())
+		attributes.emplace_back("experimentalSolidity", Json::Value(_node.experimentalSolidity()));
+
 	if (_node.annotation().exportedSymbols.set())
 	{
 		Json::Value exportedSymbols = Json::objectValue;
@@ -222,17 +225,17 @@ bool ASTJsonExporter::visit(PragmaDirective const& _node)
 	for (auto const& literal: _node.literals())
 		literals.append(literal);
 	setJsonNode(_node, "PragmaDirective", {
-		make_pair("literals", std::move(literals))
+		std::make_pair("literals", std::move(literals))
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(ImportDirective const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("file", _node.path()),
-		make_pair("sourceUnit", idOrNull(_node.annotation().sourceUnit)),
-		make_pair("scope", idOrNull(_node.scope()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("file", _node.path()),
+		std::make_pair("sourceUnit", idOrNull(_node.annotation().sourceUnit)),
+		std::make_pair("scope", idOrNull(_node.scope()))
 	};
 
 	addIfSet(attributes, "absolutePath", _node.annotation().absolutePath);
@@ -257,17 +260,19 @@ bool ASTJsonExporter::visit(ImportDirective const& _node)
 
 bool ASTJsonExporter::visit(ContractDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
-		make_pair("contractKind", contractKind(_node.contractKind())),
-		make_pair("abstract", _node.abstract()),
-		make_pair("baseContracts", toJson(_node.baseContracts())),
-		make_pair("contractDependencies", getContainerIds(_node.annotation().contractDependencies | ranges::views::keys)),
-		make_pair("usedErrors", getContainerIds(_node.interfaceErrors(false))),
-		make_pair("nodes", toJson(_node.subNodes())),
-		make_pair("scope", idOrNull(_node.scope()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("contractKind", contractKind(_node.contractKind())),
+		std::make_pair("abstract", _node.abstract()),
+		std::make_pair("baseContracts", toJson(_node.baseContracts())),
+		std::make_pair("contractDependencies", getContainerIds(_node.annotation().contractDependencies | ranges::views::keys)),
+		// Do not require call graph because the AST is also created for incorrect sources.
+		std::make_pair("usedEvents", getContainerIds(_node.interfaceEvents(false))),
+		std::make_pair("usedErrors", getContainerIds(_node.interfaceErrors(false))),
+		std::make_pair("nodes", toJson(_node.subNodes())),
+		std::make_pair("scope", idOrNull(_node.scope()))
 	};
 	addIfSet(attributes, "canonicalName", _node.annotation().canonicalName);
 
@@ -276,6 +281,14 @@ bool ASTJsonExporter::visit(ContractDefinition const& _node)
 	if (!_node.annotation().linearizedBaseContracts.empty())
 		attributes.emplace_back("linearizedBaseContracts", getContainerIds(_node.annotation().linearizedBaseContracts));
 
+	if (!_node.annotation().internalFunctionIDs.empty())
+	{
+		Json::Value internalFunctionIDs(Json::objectValue);
+		for (auto const& [functionDefinition, internalFunctionID]: _node.annotation().internalFunctionIDs)
+			internalFunctionIDs[std::to_string(functionDefinition->id())] = internalFunctionID;
+		attributes.emplace_back("internalFunctionIDs", std::move(internalFunctionIDs));
+	}
+
 	setJsonNode(_node, "ContractDefinition", std::move(attributes));
 	return false;
 }
@@ -288,9 +301,9 @@ bool ASTJsonExporter::visit(IdentifierPath const& _node)
 		nameLocations.append(sourceLocationToString(location));
 
 	setJsonNode(_node, "IdentifierPath", {
-		make_pair("name", namePathToString(_node.path())),
-		make_pair("nameLocations", nameLocations),
-		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration))
+		std::make_pair("name", namePathToString(_node.path())),
+		std::make_pair("nameLocations", nameLocations),
+		std::make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration))
 	});
 	return false;
 }
@@ -298,30 +311,42 @@ bool ASTJsonExporter::visit(IdentifierPath const& _node)
 bool ASTJsonExporter::visit(InheritanceSpecifier const& _node)
 {
 	setJsonNode(_node, "InheritanceSpecifier", {
-		make_pair("baseName", toJson(_node.name())),
-		make_pair("arguments", _node.arguments() ? toJson(*_node.arguments()) : Json::nullValue)
+		std::make_pair("baseName", toJson(_node.name())),
+		std::make_pair("arguments", _node.arguments() ? toJson(*_node.arguments()) : Json::nullValue)
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(UsingForDirective const& _node)
 {
-	vector<pair<string, Json::Value>> attributes = {
-		make_pair("typeName", _node.typeName() ? toJson(*_node.typeName()) : Json::nullValue)
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("typeName", _node.typeName() ? toJson(*_node.typeName()) : Json::nullValue)
 	};
+
 	if (_node.usesBraces())
 	{
 		Json::Value functionList;
-		for (auto const& function: _node.functionsOrLibrary())
+		for (auto&& [function, op]: _node.functionsAndOperators())
 		{
 			Json::Value functionNode;
-			functionNode["function"] = toJson(*function);
+			if (!op.has_value())
+				functionNode["function"] = toJson(*function);
+			else
+			{
+				functionNode["definition"] = toJson(*function);
+				functionNode["operator"] = std::string(TokenTraits::toString(*op));
+			}
 			functionList.append(std::move(functionNode));
 		}
 		attributes.emplace_back("functionList", std::move(functionList));
 	}
 	else
-		attributes.emplace_back("libraryName", toJson(*_node.functionsOrLibrary().front()));
+	{
+		auto const& functionAndOperators = _node.functionsAndOperators();
+		solAssert(_node.functionsAndOperators().size() == 1);
+		solAssert(!functionAndOperators.front().second.has_value());
+		attributes.emplace_back("libraryName", toJson(*(functionAndOperators.front().first)));
+	}
 	attributes.emplace_back("global", _node.global());
 
 	setJsonNode(_node, "UsingForDirective", std::move(attributes));
@@ -331,12 +356,13 @@ bool ASTJsonExporter::visit(UsingForDirective const& _node)
 
 bool ASTJsonExporter::visit(StructDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
-		make_pair("members", toJson(_node.members())),
-		make_pair("scope", idOrNull(_node.scope()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
+		std::make_pair("members", toJson(_node.members())),
+		std::make_pair("scope", idOrNull(_node.scope()))
 	};
 
 	addIfSet(attributes,"canonicalName", _node.annotation().canonicalName);
@@ -348,10 +374,11 @@ bool ASTJsonExporter::visit(StructDefinition const& _node)
 
 bool ASTJsonExporter::visit(EnumDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("members", toJson(_node.members()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("members", toJson(_node.members()))
 	};
 
 	addIfSet(attributes,"canonicalName", _node.annotation().canonicalName);
@@ -364,8 +391,8 @@ bool ASTJsonExporter::visit(EnumDefinition const& _node)
 bool ASTJsonExporter::visit(EnumValue const& _node)
 {
 	setJsonNode(_node, "EnumValue", {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
 	});
 	return false;
 }
@@ -373,10 +400,10 @@ bool ASTJsonExporter::visit(EnumValue const& _node)
 bool ASTJsonExporter::visit(UserDefinedValueTypeDefinition const& _node)
 {
 	solAssert(_node.underlyingType(), "");
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("underlyingType", toJson(*_node.underlyingType()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("underlyingType", toJson(*_node.underlyingType()))
 	};
 	addIfSet(attributes, "canonicalName", _node.annotation().canonicalName);
 
@@ -388,7 +415,7 @@ bool ASTJsonExporter::visit(UserDefinedValueTypeDefinition const& _node)
 bool ASTJsonExporter::visit(ParameterList const& _node)
 {
 	setJsonNode(_node, "ParameterList", {
-		make_pair("parameters", toJson(_node.parameters()))
+		std::make_pair("parameters", toJson(_node.parameters()))
 	});
 	return false;
 }
@@ -396,30 +423,30 @@ bool ASTJsonExporter::visit(ParameterList const& _node)
 bool ASTJsonExporter::visit(OverrideSpecifier const& _node)
 {
 	setJsonNode(_node, "OverrideSpecifier", {
-		make_pair("overrides", toJson(_node.overrides()))
+		std::make_pair("overrides", toJson(_node.overrides()))
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(FunctionDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
-		make_pair("kind", _node.isFree() ? "freeFunction" : TokenTraits::toString(_node.kind())),
-		make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())),
-		make_pair("virtual", _node.markedVirtual()),
-		make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
-		make_pair("parameters", toJson(_node.parameterList())),
-		make_pair("returnParameters", toJson(*_node.returnParameterList())),
-		make_pair("modifiers", toJson(_node.modifiers())),
-		make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue),
-		make_pair("implemented", _node.isImplemented()),
-		make_pair("scope", idOrNull(_node.scope()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("kind", _node.isFree() ? "freeFunction" : TokenTraits::toString(_node.kind())),
+		std::make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())),
+		std::make_pair("virtual", _node.markedVirtual()),
+		std::make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
+		std::make_pair("parameters", toJson(_node.parameterList())),
+		std::make_pair("returnParameters", toJson(*_node.returnParameterList())),
+		std::make_pair("modifiers", toJson(_node.modifiers())),
+		std::make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue),
+		std::make_pair("implemented", _node.isImplemented()),
+		std::make_pair("scope", idOrNull(_node.scope()))
 	};
 
-	optional<Visibility> visibility;
+	std::optional<Visibility> visibility;
 	if (_node.isConstructor())
 	{
 		if (_node.annotation().contract)
@@ -432,25 +459,26 @@ bool ASTJsonExporter::visit(FunctionDefinition const& _node)
 		attributes.emplace_back("visibility", Declaration::visibilityToString(*visibility));
 
 	if (!_node.annotation().baseFunctions.empty())
-		attributes.emplace_back(make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true)));
+		attributes.emplace_back(std::make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true)));
+
 	setJsonNode(_node, "FunctionDefinition", std::move(attributes));
 	return false;
 }
 
 bool ASTJsonExporter::visit(VariableDeclaration const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("typeName", toJson(_node.typeName())),
-		make_pair("constant", _node.isConstant()),
-		make_pair("mutability", VariableDeclaration::mutabilityToString(_node.mutability())),
-		make_pair("stateVariable", _node.isStateVariable()),
-		make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
-		make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
-		make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
-		make_pair("scope", idOrNull(_node.scope())),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("typeName", toJson(_node.typeName())),
+		std::make_pair("constant", _node.isConstant()),
+		std::make_pair("mutability", VariableDeclaration::mutabilityToString(_node.mutability())),
+		std::make_pair("stateVariable", _node.isStateVariable()),
+		std::make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
+		std::make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
+		std::make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
+		std::make_pair("scope", idOrNull(_node.scope())),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	};
 	if (_node.isStateVariable() && _node.isPublic())
 		attributes.emplace_back("functionSelector", _node.externalIdentifierHex());
@@ -459,34 +487,34 @@ bool ASTJsonExporter::visit(VariableDeclaration const& _node)
 	if (m_inEvent)
 		attributes.emplace_back("indexed", _node.isIndexed());
 	if (!_node.annotation().baseFunctions.empty())
-		attributes.emplace_back(make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true)));
+		attributes.emplace_back(std::make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true)));
 	setJsonNode(_node, "VariableDeclaration", std::move(attributes));
 	return false;
 }
 
 bool ASTJsonExporter::visit(ModifierDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
-		make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
-		make_pair("parameters", toJson(_node.parameterList())),
-		make_pair("virtual", _node.markedVirtual()),
-		make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
-		make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue)
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
+		std::make_pair("parameters", toJson(_node.parameterList())),
+		std::make_pair("virtual", _node.markedVirtual()),
+		std::make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
+		std::make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue)
 	};
 	if (!_node.annotation().baseFunctions.empty())
-		attributes.emplace_back(make_pair("baseModifiers", getContainerIds(_node.annotation().baseFunctions, true)));
+		attributes.emplace_back(std::make_pair("baseModifiers", getContainerIds(_node.annotation().baseFunctions, true)));
 	setJsonNode(_node, "ModifierDefinition", std::move(attributes));
 	return false;
 }
 
 bool ASTJsonExporter::visit(ModifierInvocation const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes{
-		make_pair("modifierName", toJson(_node.name())),
-		make_pair("arguments", _node.arguments() ? toJson(*_node.arguments()) : Json::nullValue)
+	std::vector<std::pair<std::string, Json::Value>> attributes{
+		std::make_pair("modifierName", toJson(_node.name())),
+		std::make_pair("arguments", _node.arguments() ? toJson(*_node.arguments()) : Json::nullValue)
 	};
 	if (Declaration const* declaration = _node.name().annotation().referencedDeclaration)
 	{
@@ -502,16 +530,16 @@ bool ASTJsonExporter::visit(ModifierInvocation const& _node)
 bool ASTJsonExporter::visit(EventDefinition const& _node)
 {
 	m_inEvent = true;
-	std::vector<pair<string, Json::Value>> _attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
-		make_pair("parameters", toJson(_node.parameterList())),
-		make_pair("anonymous", _node.isAnonymous())
+	std::vector<std::pair<std::string, Json::Value>> _attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("parameters", toJson(_node.parameterList())),
+		std::make_pair("anonymous", _node.isAnonymous())
 	};
-	if (m_stackState >= CompilerStack::State::AnalysisPerformed)
+	if (m_stackState >= CompilerStack::State::AnalysisSuccessful)
 			_attributes.emplace_back(
-				make_pair(
+				std::make_pair(
 					"eventSelector",
 					toHex(u256(util::h256::Arith(util::keccak256(_node.functionType(true)->externalSignature()))))
 				));
@@ -522,14 +550,14 @@ bool ASTJsonExporter::visit(EventDefinition const& _node)
 
 bool ASTJsonExporter::visit(ErrorDefinition const& _node)
 {
-	std::vector<pair<string, Json::Value>> _attributes = {
-		make_pair("name", _node.name()),
-		make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
-		make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
-		make_pair("parameters", toJson(_node.parameterList()))
+	std::vector<std::pair<std::string, Json::Value>> _attributes = {
+		std::make_pair("name", _node.name()),
+		std::make_pair("nameLocation", sourceLocationToString(_node.nameLocation())),
+		std::make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
+		std::make_pair("parameters", toJson(_node.parameterList()))
 	};
-	if (m_stackState >= CompilerStack::State::AnalysisPerformed)
-		_attributes.emplace_back(make_pair("errorSelector", _node.functionType(true)->externalIdentifierHex()));
+	if (m_stackState >= CompilerStack::State::AnalysisSuccessful)
+		_attributes.emplace_back(std::make_pair("errorSelector", _node.functionType(true)->externalIdentifierHex()));
 
 	setJsonNode(_node, "ErrorDefinition", std::move(_attributes));
 	return false;
@@ -537,10 +565,11 @@ bool ASTJsonExporter::visit(ErrorDefinition const& _node)
 
 bool ASTJsonExporter::visit(ElementaryTypeName const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-			make_pair("name", _node.typeName().toString()),
-			make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("name", _node.typeName().toString()),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	};
+
 	setJsonNode(_node, "ElementaryTypeName", std::move(attributes));
 	return false;
 }
@@ -548,9 +577,9 @@ bool ASTJsonExporter::visit(ElementaryTypeName const& _node)
 bool ASTJsonExporter::visit(UserDefinedTypeName const& _node)
 {
 	setJsonNode(_node, "UserDefinedTypeName", {
-		make_pair("pathNode", toJson(_node.pathNode())),
-		make_pair("referencedDeclaration", idOrNull(_node.pathNode().annotation().referencedDeclaration)),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+		std::make_pair("pathNode", toJson(_node.pathNode())),
+		std::make_pair("referencedDeclaration", idOrNull(_node.pathNode().annotation().referencedDeclaration)),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	});
 	return false;
 }
@@ -558,11 +587,11 @@ bool ASTJsonExporter::visit(UserDefinedTypeName const& _node)
 bool ASTJsonExporter::visit(FunctionTypeName const& _node)
 {
 	setJsonNode(_node, "FunctionTypeName", {
-		make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
-		make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())),
-		make_pair("parameterTypes", toJson(*_node.parameterTypeList())),
-		make_pair("returnParameterTypes", toJson(*_node.returnParameterTypeList())),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+		std::make_pair("visibility", Declaration::visibilityToString(_node.visibility())),
+		std::make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())),
+		std::make_pair("parameterTypes", toJson(*_node.parameterTypeList())),
+		std::make_pair("returnParameterTypes", toJson(*_node.returnParameterTypeList())),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	});
 	return false;
 }
@@ -570,23 +599,27 @@ bool ASTJsonExporter::visit(FunctionTypeName const& _node)
 bool ASTJsonExporter::visit(Mapping const& _node)
 {
 	setJsonNode(_node, "Mapping", {
-		make_pair("keyType", toJson(_node.keyType())),
-		make_pair("valueType", toJson(_node.valueType())),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+		std::make_pair("keyType", toJson(_node.keyType())),
+		std::make_pair("keyName", _node.keyName()),
+		std::make_pair("keyNameLocation", sourceLocationToString(_node.keyNameLocation())),
+		std::make_pair("valueType", toJson(_node.valueType())),
+		std::make_pair("valueName", _node.valueName()),
+		std::make_pair("valueNameLocation", sourceLocationToString(_node.valueNameLocation())),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(Optional const& _node) {
 	setJsonNode(_node, "Optional", {
-		make_pair("maybeTypes", toJson(_node.maybeTypes())),
+		std::make_pair("maybeTypes", toJson(_node.maybeTypes())),
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(TvmVector const& _node) {
 	setJsonNode(_node, "vector", {
-		make_pair("type", toJson(_node.type())),
+		std::make_pair("type", toJson(_node.type())),
 	});
 	return false;
 }
@@ -594,9 +627,9 @@ bool ASTJsonExporter::visit(TvmVector const& _node) {
 bool ASTJsonExporter::visit(ArrayTypeName const& _node)
 {
 	setJsonNode(_node, "ArrayTypeName", {
-		make_pair("baseType", toJson(_node.baseType())),
-		make_pair("length", toJsonOrNull(_node.length())),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
+		std::make_pair("baseType", toJson(_node.baseType())),
+		std::make_pair("length", toJsonOrNull(_node.length())),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type, true))
 	});
 	return false;
 }
@@ -604,20 +637,15 @@ bool ASTJsonExporter::visit(ArrayTypeName const& _node)
 bool ASTJsonExporter::visit(FreeInlineAssembly const& _node)
 {
 	setJsonNode(_node, "FreeInlineAssembly", {
-		make_pair("body", toJson(_node.lines()))
+		std::make_pair("body", toJson(_node.lines()))
 	});
 	return false;
 }
 
-bool ASTJsonExporter::visit(InlineAssembly const& /*_node*/)
-{
-	return false;
-}
-
 bool ASTJsonExporter::visit(Block const& _node)
 {
 	setJsonNode(_node, _node.unchecked() ? "UncheckedBlock" : "Block", {
-		make_pair("statements", toJson(_node.statements()))
+		std::make_pair("statements", toJson(_node.statements()))
 	});
 	return false;
 }
@@ -631,9 +659,9 @@ bool ASTJsonExporter::visit(PlaceholderStatement const& _node)
 bool ASTJsonExporter::visit(IfStatement const& _node)
 {
 	setJsonNode(_node, "IfStatement", {
-		make_pair("condition", toJson(_node.condition())),
-		make_pair("trueBody", toJson(_node.trueStatement())),
-		make_pair("falseBody", toJsonOrNull(_node.falseStatement()))
+		std::make_pair("condition", toJson(_node.condition())),
+		std::make_pair("trueBody", toJson(_node.trueStatement())),
+		std::make_pair("falseBody", toJsonOrNull(_node.falseStatement()))
 	});
 	return false;
 }
@@ -641,9 +669,9 @@ bool ASTJsonExporter::visit(IfStatement const& _node)
 bool ASTJsonExporter::visit(TryCatchClause const& _node)
 {
 	setJsonNode(_node, "TryCatchClause", {
-		make_pair("errorName", _node.errorName()),
-		make_pair("parameters", toJsonOrNull(_node.parameters())),
-		make_pair("block", toJson(_node.block()))
+		std::make_pair("errorName", _node.errorName()),
+		std::make_pair("parameters", toJsonOrNull(_node.parameters())),
+		std::make_pair("block", toJson(_node.block()))
 	});
 	return false;
 }
@@ -651,8 +679,8 @@ bool ASTJsonExporter::visit(TryCatchClause const& _node)
 bool ASTJsonExporter::visit(TryStatement const& _node)
 {
 	setJsonNode(_node, "TryStatement", {
-		make_pair("body", toJson(_node.body())),
-		make_pair("clause", toJson(_node.clause()))
+		std::make_pair("body", toJson(_node.body())),
+		std::make_pair("clause", toJson(_node.clause()))
 	});
 	return false;
 }
@@ -675,8 +703,8 @@ bool ASTJsonExporter::visit(WhileStatement const& _node)
 		_node,
 		name,
 		{
-			make_pair("condition", toJson(_node.condition())),
-			make_pair("body", toJson(_node.body()))
+			std::make_pair("condition", toJson(_node.condition())),
+			std::make_pair("body", toJson(_node.body()))
 		}
 	);
 	return false;
@@ -684,20 +712,26 @@ bool ASTJsonExporter::visit(WhileStatement const& _node)
 
 bool ASTJsonExporter::visit(ForStatement const& _node)
 {
-	setJsonNode(_node, "ForStatement", {
-		make_pair("initializationExpression", toJsonOrNull(_node.initializationExpression())),
-		make_pair("condition", toJsonOrNull(_node.condition())),
-		make_pair("loopExpression", toJsonOrNull(_node.loopExpression())),
-		make_pair("body", toJson(_node.body()))
-	});
+
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("initializationExpression", toJsonOrNull(_node.initializationExpression())),
+		std::make_pair("condition", toJsonOrNull(_node.condition())),
+		std::make_pair("loopExpression", toJsonOrNull(_node.loopExpression())),
+		std::make_pair("body", toJson(_node.body()))
+	};
+
+	if (_node.annotation().isSimpleCounterLoop.set())
+		attributes.emplace_back("isSimpleCounterLoop", *_node.annotation().isSimpleCounterLoop);
+
+	setJsonNode(_node, "ForStatement", std::move(attributes));
 	return false;
 }
 
 bool ASTJsonExporter::visit(ForEachStatement const& _node) {
 	setJsonNode(_node, "ForEachStatement", {
-		make_pair("rangeDeclaration", toJsonOrNull(_node.rangeDeclaration())),
-		make_pair("rangeExpression", toJsonOrNull(_node.rangeExpression())),
-		make_pair("body", toJson(_node.body()))
+		std::make_pair("rangeDeclaration", toJsonOrNull(_node.rangeDeclaration())),
+		std::make_pair("rangeExpression", toJsonOrNull(_node.rangeExpression())),
+		std::make_pair("body", toJson(_node.body()))
 	});
 	return false;
 }
@@ -717,9 +751,9 @@ bool ASTJsonExporter::visit(Break const& _node)
 bool ASTJsonExporter::visit(Return const& _node)
 {
 	setJsonNode(_node, "Return", {
-		make_pair("expression", toJsonOrNull(_node.expression())),
-		make_pair("functionReturnParameters", idOrNull(_node.annotation().functionReturnParameters)),
-		make_pair("options", toJson(_node.options())),
+		std::make_pair("expression", toJsonOrNull(_node.expression())),
+		std::make_pair("functionReturnParameters", idOrNull(_node.annotation().functionReturnParameters)),
+		std::make_pair("options", toJson(_node.options())),
 	});
 	return false;
 }
@@ -736,10 +770,10 @@ bool ASTJsonExporter::visit(EmitStatement const& _node)
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
 
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("names", std::move(names)),
-		make_pair("options", toJson(_node.options())),
-		make_pair("eventCall", toJson(_node.eventCall()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("names", std::move(names)),
+		std::make_pair("options", toJson(_node.options())),
+		std::make_pair("eventCall", toJson(_node.eventCall()))
 	};
 
 	setJsonNode(_node, "EmitStatement", std::move(attributes));
@@ -749,7 +783,7 @@ bool ASTJsonExporter::visit(EmitStatement const& _node)
 bool ASTJsonExporter::visit(RevertStatement const& _node)
 {
 	setJsonNode(_node, "RevertStatement", {
-		make_pair("errorCall", toJson(_node.errorCall()))
+		std::make_pair("errorCall", toJson(_node.errorCall()))
 	});
 	return false;
 }
@@ -760,9 +794,9 @@ bool ASTJsonExporter::visit(VariableDeclarationStatement const& _node)
 	for (auto const& v: _node.declarations())
 		appendMove(varDecs, idOrNull(v.get()));
 	setJsonNode(_node, "VariableDeclarationStatement", {
-		make_pair("assignments", std::move(varDecs)),
-		make_pair("declarations", toJson(_node.declarations())),
-		make_pair("initialValue", toJsonOrNull(_node.initialValue()))
+		std::make_pair("assignments", std::move(varDecs)),
+		std::make_pair("declarations", toJson(_node.declarations())),
+		std::make_pair("initialValue", toJsonOrNull(_node.initialValue()))
 	});
 	return false;
 }
@@ -770,17 +804,17 @@ bool ASTJsonExporter::visit(VariableDeclarationStatement const& _node)
 bool ASTJsonExporter::visit(ExpressionStatement const& _node)
 {
 	setJsonNode(_node, "ExpressionStatement", {
-		make_pair("expression", toJson(_node.expression()))
+		std::make_pair("expression", toJson(_node.expression()))
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(Conditional const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("condition", toJson(_node.condition())),
-		make_pair("trueExpression", toJson(_node.trueExpression())),
-		make_pair("falseExpression", toJson(_node.falseExpression()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("condition", toJson(_node.condition())),
+		std::make_pair("trueExpression", toJson(_node.trueExpression())),
+		std::make_pair("falseExpression", toJson(_node.falseExpression()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "Conditional", std::move(attributes));
@@ -789,10 +823,10 @@ bool ASTJsonExporter::visit(Conditional const& _node)
 
 bool ASTJsonExporter::visit(Assignment const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("operator", TokenTraits::toString(_node.assignmentOperator())),
-		make_pair("leftHandSide", toJson(_node.leftHandSide())),
-		make_pair("rightHandSide", toJson(_node.rightHandSide()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("operator", TokenTraits::toString(_node.assignmentOperator())),
+		std::make_pair("leftHandSide", toJson(_node.leftHandSide())),
+		std::make_pair("rightHandSide", toJson(_node.rightHandSide()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "Assignment", std::move(attributes));
@@ -801,9 +835,9 @@ bool ASTJsonExporter::visit(Assignment const& _node)
 
 bool ASTJsonExporter::visit(TupleExpression const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("isInlineArray", Json::Value(_node.isInlineArray())),
-		make_pair("components", toJson(_node.components())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("isInlineArray", Json::Value(_node.isInlineArray())),
+		std::make_pair("components", toJson(_node.components())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "TupleExpression", std::move(attributes));
@@ -812,11 +846,14 @@ bool ASTJsonExporter::visit(TupleExpression const& _node)
 
 bool ASTJsonExporter::visit(UnaryOperation const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("prefix", _node.isPrefixOperation()),
-		make_pair("operator", TokenTraits::toString(_node.getOperator())),
-		make_pair("subExpression", toJson(_node.subExpression()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("prefix", _node.isPrefixOperation()),
+		std::make_pair("operator", TokenTraits::toString(_node.getOperator())),
+		std::make_pair("subExpression", toJson(_node.subExpression()))
 	};
+	// NOTE: This annotation is guaranteed to be set but only if we didn't stop at the parsing stage.
+	if (_node.annotation().userDefinedFunction.set() && *_node.annotation().userDefinedFunction != nullptr)
+		attributes.emplace_back("function", nodeId(**_node.annotation().userDefinedFunction));
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "UnaryOperation", std::move(attributes));
 	return false;
@@ -824,12 +861,15 @@ bool ASTJsonExporter::visit(UnaryOperation const& _node)
 
 bool ASTJsonExporter::visit(BinaryOperation const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("operator", TokenTraits::toString(_node.getOperator())),
-		make_pair("leftExpression", toJson(_node.leftExpression())),
-		make_pair("rightExpression", toJson(_node.rightExpression())),
-		make_pair("commonType", typePointerToJson(_node.annotation().commonType)),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("operator", TokenTraits::toString(_node.getOperator())),
+		std::make_pair("leftExpression", toJson(_node.leftExpression())),
+		std::make_pair("rightExpression", toJson(_node.rightExpression())),
+		std::make_pair("commonType", typePointerToJson(_node.annotation().commonType)),
 	};
+	// NOTE: This annotation is guaranteed to be set but only if we didn't stop at the parsing stage.
+	if (_node.annotation().userDefinedFunction.set() && *_node.annotation().userDefinedFunction != nullptr)
+		attributes.emplace_back("function", nodeId(**_node.annotation().userDefinedFunction));
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "BinaryOperation", std::move(attributes));
 	return false;
@@ -840,12 +880,12 @@ bool ASTJsonExporter::visit(FunctionCall const& _node)
 	Json::Value names(Json::arrayValue);
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("expression", toJson(_node.expression())),
-		make_pair("names", std::move(names)),
-		make_pair("nameLocations", sourceLocationsToJson(_node.nameLocations())),
-		make_pair("arguments", toJson(_node.arguments())),
-		make_pair("tryCall", _node.annotation().tryCall)
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("expression", toJson(_node.expression())),
+		std::make_pair("names", std::move(names)),
+		std::make_pair("nameLocations", sourceLocationsToJson(_node.nameLocations())),
+		std::make_pair("arguments", toJson(_node.arguments())),
+		std::make_pair("tryCall", _node.annotation().tryCall)
 	};
 
 	if (_node.annotation().kind.set())
@@ -865,10 +905,10 @@ bool ASTJsonExporter::visit(FunctionCallOptions const& _node)
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
 
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("expression", toJson(_node.expression())),
-		make_pair("names", std::move(names)),
-		make_pair("options", toJson(_node.options())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("expression", toJson(_node.expression())),
+		std::make_pair("names", std::move(names)),
+		std::make_pair("options", toJson(_node.options())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 
@@ -882,9 +922,9 @@ bool ASTJsonExporter::visit(InitializerList const& _node)
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
 
-	std::vector<pair<string, Json::Value>> attributes = {
-			make_pair("names", std::move(names)),
-			make_pair("options", toJson(_node.options())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+			std::make_pair("names", std::move(names)),
+			std::make_pair("options", toJson(_node.options())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 
@@ -894,9 +934,9 @@ bool ASTJsonExporter::visit(InitializerList const& _node)
 
 bool ASTJsonExporter::visit(CallList const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("expression", toJson(*_node.function())),
-		make_pair("arguments", toJson(_node.arguments())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("expression", toJson(*_node.function())),
+		std::make_pair("arguments", toJson(_node.arguments())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 
@@ -906,8 +946,8 @@ bool ASTJsonExporter::visit(CallList const& _node)
 
 bool ASTJsonExporter::visit(NewExpression const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("typeName", toJson(_node.typeName()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("typeName", toJson(_node.typeName()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "NewExpression", std::move(attributes));
@@ -916,11 +956,11 @@ bool ASTJsonExporter::visit(NewExpression const& _node)
 
 bool ASTJsonExporter::visit(MemberAccess const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("memberName", _node.memberName()),
-		make_pair("memberLocation", Json::Value(sourceLocationToString(_node.memberLocation()))),
-		make_pair("expression", toJson(_node.expression())),
-		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("memberName", _node.memberName()),
+		std::make_pair("memberLocation", Json::Value(sourceLocationToString(_node.memberLocation()))),
+		std::make_pair("expression", toJson(_node.expression())),
+		std::make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "MemberAccess", std::move(attributes));
@@ -929,9 +969,9 @@ bool ASTJsonExporter::visit(MemberAccess const& _node)
 
 bool ASTJsonExporter::visit(IndexAccess const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("baseExpression", toJson(_node.baseExpression())),
-		make_pair("indexExpression", toJsonOrNull(_node.indexExpression())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("baseExpression", toJson(_node.baseExpression())),
+		std::make_pair("indexExpression", toJsonOrNull(_node.indexExpression())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "IndexAccess", std::move(attributes));
@@ -940,10 +980,10 @@ bool ASTJsonExporter::visit(IndexAccess const& _node)
 
 bool ASTJsonExporter::visit(IndexRangeAccess const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("baseExpression", toJson(_node.baseExpression())),
-		make_pair("startExpression", toJsonOrNull(_node.startExpression())),
-		make_pair("endExpression", toJsonOrNull(_node.endExpression())),
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("baseExpression", toJson(_node.baseExpression())),
+		std::make_pair("startExpression", toJsonOrNull(_node.startExpression())),
+		std::make_pair("endExpression", toJsonOrNull(_node.endExpression())),
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "IndexRangeAccess", std::move(attributes));
@@ -956,19 +996,19 @@ bool ASTJsonExporter::visit(Identifier const& _node)
 	for (auto const& dec: _node.annotation().overloadedDeclarations)
 		overloads.append(nodeId(*dec));
 	setJsonNode(_node, "Identifier", {
-		make_pair("name", _node.name()),
-		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
-		make_pair("overloadedDeclarations", overloads),
-		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type)),
-		make_pair("argumentTypes", typePointerToJson(_node.annotation().arguments))
+		std::make_pair("name", _node.name()),
+		std::make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
+		std::make_pair("overloadedDeclarations", overloads),
+		std::make_pair("typeDescriptions", typePointerToJson(_node.annotation().type)),
+		std::make_pair("argumentTypes", typePointerToJson(_node.annotation().arguments))
 	});
 	return false;
 }
 
 bool ASTJsonExporter::visit(ElementaryTypeNameExpression const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("typeName", toJson(_node.type()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("typeName", toJson(_node.type()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "ElementaryTypeNameExpression", std::move(attributes));
@@ -977,8 +1017,8 @@ bool ASTJsonExporter::visit(ElementaryTypeNameExpression const& _node)
 
 bool ASTJsonExporter::visit(MappingNameExpression const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("typeName", toJson(_node.type()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("typeName", toJson(_node.type()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "MappingNameExpression", std::move(attributes));
@@ -987,8 +1027,8 @@ bool ASTJsonExporter::visit(MappingNameExpression const& _node)
 
 bool ASTJsonExporter::visit(OptionalNameExpression const& _node)
 {
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("typeName", toJson(_node.type()))
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("typeName", toJson(_node.type()))
 	};
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "OptionalNameExpression", std::move(attributes));
@@ -1001,11 +1041,11 @@ bool ASTJsonExporter::visit(Literal const& _node)
 	if (!util::validateUTF8(_node.value()))
 		value = Json::nullValue;
 	Token subdenomination = Token(_node.subDenomination());
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("kind", literalTokenKind(_node.token())),
-		make_pair("value", value),
-		make_pair("hexValue", util::toHex(util::asBytes(_node.value()))),
-		make_pair(
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("kind", literalTokenKind(_node.token())),
+		std::make_pair("value", value),
+		std::make_pair("hexValue", util::toHex(util::asBytes(_node.value()))),
+		std::make_pair(
 			"subdenomination",
 			subdenomination == Token::Illegal ?
 			Json::nullValue :
@@ -1020,8 +1060,8 @@ bool ASTJsonExporter::visit(Literal const& _node)
 bool ASTJsonExporter::visit(StructuredDocumentation const& _node)
 {
 	Json::Value text{*_node.text()};
-	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("text", text)
+	std::vector<std::pair<std::string, Json::Value>> attributes = {
+		std::make_pair("text", text)
 	};
 	setJsonNode(_node, "StructuredDocumentation", std::move(attributes));
 	return false;
@@ -1032,7 +1072,16 @@ void ASTJsonExporter::endVisit(EventDefinition const&)
 	m_inEvent = false;
 }
 
-string ASTJsonExporter::contractKind(ContractKind _kind)
+bool ASTJsonExporter::visitNode(ASTNode const& _node)
+{
+	solAssert(false, _node.experimentalSolidityOnly() ?
+		"Attempt to export an AST of experimental solidity." :
+		"Attempt to export an AST that contains unexpected nodes."
+	);
+	return false;
+}
+
+std::string ASTJsonExporter::contractKind(ContractKind _kind)
 {
 	switch (_kind)
 	{
@@ -1048,7 +1097,7 @@ string ASTJsonExporter::contractKind(ContractKind _kind)
 	return {};
 }
 
-string ASTJsonExporter::functionCallKind(FunctionCallKind _kind)
+std::string ASTJsonExporter::functionCallKind(FunctionCallKind _kind)
 {
 	switch (_kind)
 	{
@@ -1063,7 +1112,7 @@ string ASTJsonExporter::functionCallKind(FunctionCallKind _kind)
 	}
 }
 
-string ASTJsonExporter::literalTokenKind(Token _token)
+std::string ASTJsonExporter::literalTokenKind(Token _token)
 {
 	switch (_token)
 	{
@@ -1087,12 +1136,12 @@ string ASTJsonExporter::literalTokenKind(Token _token)
 	}
 }
 
-string ASTJsonExporter::type(Expression const& _expression)
+std::string ASTJsonExporter::type(Expression const& _expression)
 {
 	return _expression.annotation().type ? _expression.annotation().type->toString() : "Unknown";
 }
 
-string ASTJsonExporter::type(VariableDeclaration const& _varDecl)
+std::string ASTJsonExporter::type(VariableDeclaration const& _varDecl)
 {
 	return _varDecl.annotation().type ? _varDecl.annotation().type->toString() : "Unknown";
 }
diff --git a/compiler/libsolidity/ast/ASTJsonExporter.h b/compiler/libsolidity/ast/ASTJsonExporter.h
index 9b0f7085..151b2e12 100644
--- a/compiler/libsolidity/ast/ASTJsonExporter.h
+++ b/compiler/libsolidity/ast/ASTJsonExporter.h
@@ -99,7 +99,6 @@ class ASTJsonExporter: public ASTConstVisitor
 	bool visit(TvmVector const& _node) override;
 	bool visit(ArrayTypeName const& _node) override;
 	bool visit(FreeInlineAssembly const& _node) override;
-	bool visit(InlineAssembly const& _node) override;
 	bool visit(Block const& _node) override;
 	bool visit(PlaceholderStatement const& _node) override;
 	bool visit(IfStatement const& _node) override;
@@ -139,7 +138,7 @@ class ASTJsonExporter: public ASTConstVisitor
 	void endVisit(EventDefinition const&) override;
 
 protected:
-	bool visitNode(ASTNode const&) override { solUnimplemented(""); }
+	bool visitNode(ASTNode const&) override;
 
 private:
 	void setJsonNode(
diff --git a/compiler/libsolidity/ast/ASTJsonImporter.cpp b/compiler/libsolidity/ast/ASTJsonImporter.cpp
index f618005f..8a56e357 100644
--- a/compiler/libsolidity/ast/ASTJsonImporter.cpp
+++ b/compiler/libsolidity/ast/ASTJsonImporter.cpp
@@ -22,6 +22,9 @@
  */
 
 #include <libsolidity/ast/ASTJsonImporter.h>
+
+#include <libsolidity/ast/UserDefinableOperators.h>
+
 #include <liblangutil/Exceptions.h>
 #include <liblangutil/Scanner.h>
 #include <liblangutil/SourceLocation.h>
@@ -30,8 +33,6 @@
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string.hpp>
 
-using namespace std;
-
 namespace solidity::frontend
 {
 
@@ -43,16 +44,16 @@ ASTPointer<T> ASTJsonImporter::nullOrCast(Json::Value const& _json)
 	if (_json.isNull())
 		return nullptr;
 	else
-		return dynamic_pointer_cast<T>(convertJsonToASTNode(_json));
+		return std::dynamic_pointer_cast<T>(convertJsonToASTNode(_json));
 }
 
 
 // ============ public ===========================
 
-map<string, ASTPointer<SourceUnit>> ASTJsonImporter::jsonToSourceUnit(map<string, Json::Value> const& _sourceList)
+std::map<std::string, ASTPointer<SourceUnit>> ASTJsonImporter::jsonToSourceUnit(std::map<std::string, Json::Value> const& _sourceList)
 {
 	for (auto const& src: _sourceList)
-		m_sourceNames.emplace_back(make_shared<string const>(src.first));
+		m_sourceNames.emplace_back(std::make_shared<std::string const>(src.first));
 	for (auto const& srcPair: _sourceList)
 	{
 		astAssert(!srcPair.second.isNull());
@@ -74,7 +75,7 @@ ASTPointer<T> ASTJsonImporter::createASTNode(Json::Value const& _node, Args&&...
 
 	astAssert(m_usedIDs.insert(id).second, "Found duplicate node ID!");
 
-	auto n = make_shared<T>(
+	auto n = std::make_shared<T>(
 		id,
 		createSourceLocation(_node),
 		std::forward<Args>(_args)...
@@ -89,9 +90,9 @@ SourceLocation const ASTJsonImporter::createSourceLocation(Json::Value const& _n
 	return solidity::langutil::parseSourceLocation(_node["src"].asString(), m_sourceNames);
 }
 
-optional<vector<SourceLocation>> ASTJsonImporter::createSourceLocations(Json::Value const& _node) const
+std::optional<std::vector<SourceLocation>> ASTJsonImporter::createSourceLocations(Json::Value const& _node) const
 {
-	vector<SourceLocation> locations;
+	std::vector<SourceLocation> locations;
 
 	if (_node.isMember("nameLocations") && _node["nameLocations"].isArray())
 	{
@@ -100,7 +101,7 @@ optional<vector<SourceLocation>> ASTJsonImporter::createSourceLocations(Json::Va
 		return locations;
 	}
 
-	return nullopt;
+	return std::nullopt;
 }
 
 SourceLocation ASTJsonImporter::createNameSourceLocation(Json::Value const& _node)
@@ -110,10 +111,24 @@ SourceLocation ASTJsonImporter::createNameSourceLocation(Json::Value const& _nod
 	return solidity::langutil::parseSourceLocation(_node["nameLocation"].asString(), m_sourceNames);
 }
 
+SourceLocation ASTJsonImporter::createKeyNameSourceLocation(Json::Value const& _node)
+{
+	astAssert(member(_node, "keyNameLocation").isString(), "'keyNameLocation' must be a string");
+
+	return solidity::langutil::parseSourceLocation(_node["keyNameLocation"].asString(), m_sourceNames);
+}
+
+SourceLocation ASTJsonImporter::createValueNameSourceLocation(Json::Value const& _node)
+{
+	astAssert(member(_node, "valueNameLocation").isString(), "'valueNameLocation' must be a string");
+
+	return solidity::langutil::parseSourceLocation(_node["valueNameLocation"].asString(), m_sourceNames);
+}
+
 template<class T>
 ASTPointer<T> ASTJsonImporter::convertJsonToASTNode(Json::Value const& _node)
 {
-	ASTPointer<T> ret = dynamic_pointer_cast<T>(convertJsonToASTNode(_node));
+	ASTPointer<T> ret = std::dynamic_pointer_cast<T>(convertJsonToASTNode(_node));
 	astAssert(ret, "cast of converted json-node must not be nullptr");
 	return ret;
 }
@@ -122,7 +137,7 @@ ASTPointer<T> ASTJsonImporter::convertJsonToASTNode(Json::Value const& _node)
 ASTPointer<ASTNode> ASTJsonImporter::convertJsonToASTNode(Json::Value const& _json)
 {
 	astAssert(_json["nodeType"].isString() && _json.isMember("id"), "JSON-Node needs to have 'nodeType' and 'id' fields.");
-	string nodeType = _json["nodeType"].asString();
+	std::string nodeType = _json["nodeType"].asString();
 	if (nodeType == "PragmaDirective")
 		return createPragmaDirective(_json);
 	if (nodeType == "ImportDirective")
@@ -169,8 +184,6 @@ ASTPointer<ASTNode> ASTJsonImporter::convertJsonToASTNode(Json::Value const& _js
 		return createMapping(_json);
 	if (nodeType == "ArrayTypeName")
 		return createArrayTypeName(_json);
-	if (nodeType == "InlineAssembly")
-		return createInlineAssembly(_json);
 	if (nodeType == "Block")
 		return createBlock(_json, false);
 	if (nodeType == "UncheckedBlock")
@@ -246,28 +259,32 @@ ASTPointer<ASTNode> ASTJsonImporter::convertJsonToASTNode(Json::Value const& _js
 
 // ============ functions to instantiate the AST-Nodes from Json-Nodes ==============
 
-ASTPointer<SourceUnit> ASTJsonImporter::createSourceUnit(Json::Value const& _node, string const& _srcName)
+ASTPointer<SourceUnit> ASTJsonImporter::createSourceUnit(Json::Value const& _node, std::string const& _srcName)
 {
-	optional<string> license;
+	std::optional<std::string> license;
 	if (_node.isMember("license") && !_node["license"].isNull())
 		license = _node["license"].asString();
 
-	vector<ASTPointer<ASTNode>> nodes;
+	bool experimentalSolidity = false;
+	if (_node.isMember("experimentalSolidity") && !_node["experimentalSolidity"].isNull())
+		experimentalSolidity = _node["experimentalSolidity"].asBool();
+
+	std::vector<ASTPointer<ASTNode>> nodes;
 	for (auto& child: member(_node, "nodes"))
 		nodes.emplace_back(convertJsonToASTNode(child));
 
-	ASTPointer<SourceUnit> tmp = createASTNode<SourceUnit>(_node, license, nodes);
+	ASTPointer<SourceUnit> tmp = createASTNode<SourceUnit>(_node, license, nodes, experimentalSolidity);
 	tmp->annotation().path = _srcName;
 	return tmp;
 }
 
 ASTPointer<PragmaDirective> ASTJsonImporter::createPragmaDirective(Json::Value const& _node)
 {
-	vector<Token> tokens;
-	vector<ASTString> literals;
+	std::vector<Token> tokens;
+	std::vector<ASTString> literals;
 	for (auto const& lit: member(_node, "literals"))
 	{
-		string l = lit.asString();
+		std::string l = lit.asString();
 		literals.push_back(l);
 		tokens.push_back(scanSingleToken(l));
 	}
@@ -286,7 +303,7 @@ ASTPointer<ImportDirective> ASTJsonImporter::createImportDirective(Json::Value c
 
 		symbolAliases.push_back({
 			createIdentifier(tuple["foreign"]),
-			tuple["local"].isNull() ? nullptr : make_shared<ASTString>(tuple["local"].asString()),
+			tuple["local"].isNull() ? nullptr : std::make_shared<ASTString>(tuple["local"].asString()),
 			createSourceLocation(tuple["foreign"])}
 		);
 	}
@@ -320,7 +337,7 @@ ASTPointer<ContractDefinition> ASTJsonImporter::createContractDefinition(Json::V
 
 	return createASTNode<ContractDefinition>(
 		_node,
-		make_shared<ASTString>(_node["name"].asString()),
+		std::make_shared<ASTString>(_node["name"].asString()),
 		createNameSourceLocation(_node),
 		_node["documentation"].isNull() ? nullptr : createDocumentation(member(_node, "documentation")),
 		baseContracts,
@@ -334,13 +351,13 @@ ASTPointer<IdentifierPath> ASTJsonImporter::createIdentifierPath(Json::Value con
 {
 	astAssert(_node["name"].isString(), "Expected 'name' to be a string!");
 
-	vector<ASTString> namePath;
-	vector<SourceLocation> namePathLocations;
-	vector<string> strs;
-	string nameString = member(_node, "name").asString();
+	std::vector<ASTString> namePath;
+	std::vector<SourceLocation> namePathLocations;
+	std::vector<std::string> strs;
+	std::string nameString = member(_node, "name").asString();
 	boost::algorithm::split(strs, nameString, boost::is_any_of("."));
 	astAssert(!strs.empty(), "Expected at least one element in IdentifierPath.");
-	for (string s: strs)
+	for (std::string s: strs)
 	{
 		astAssert(!s.empty(), "Expected non-empty string for IdentifierPath element.");
 		namePath.emplace_back(s);
@@ -372,22 +389,49 @@ ASTPointer<InheritanceSpecifier> ASTJsonImporter::createInheritanceSpecifier(Jso
 	return createASTNode<InheritanceSpecifier>(
 		_node,
 		createIdentifierPath(member(_node, "baseName")),
-		member(_node, "arguments").isNull() ? nullptr : make_unique<std::vector<ASTPointer<Expression>>>(arguments)
+		member(_node, "arguments").isNull() ? nullptr : std::make_unique<std::vector<ASTPointer<Expression>>>(arguments)
 	);
 }
 
 ASTPointer<UsingForDirective> ASTJsonImporter::createUsingForDirective(Json::Value const& _node)
 {
-	vector<ASTPointer<IdentifierPath>> functions;
+	std::vector<ASTPointer<IdentifierPath>> functions;
+	std::vector<std::optional<Token>> operators;
 	if (_node.isMember("libraryName"))
+	{
+		astAssert(!_node["libraryName"].isArray());
+		astAssert(!_node["libraryName"]["operator"]);
 		functions.emplace_back(createIdentifierPath(_node["libraryName"]));
+		operators.emplace_back(std::nullopt);
+	}
 	else if (_node.isMember("functionList"))
 		for (Json::Value const& function: _node["functionList"])
-			functions.emplace_back(createIdentifierPath(function["function"]));
+		{
+			if (function.isMember("function"))
+			{
+				astAssert(!function.isMember("operator"));
+				astAssert(!function.isMember("definition"));
+
+				functions.emplace_back(createIdentifierPath(function["function"]));
+				operators.emplace_back(std::nullopt);
+			}
+			else
+			{
+				astAssert(function.isMember("operator"));
+				astAssert(function.isMember("definition"));
+
+				Token const operatorName = scanSingleToken(function["operator"]);
+				astAssert(util::contains(frontend::userDefinableOperators, operatorName));
+
+				functions.emplace_back(createIdentifierPath(function["definition"]));
+				operators.emplace_back(operatorName);
+			}
+		}
 
 	return createASTNode<UsingForDirective>(
 		_node,
 		std::move(functions),
+		std::move(operators),
 		!_node.isMember("libraryName"),
 		_node["typeName"].isNull() ? nullptr  : convertJsonToASTNode<TypeName>(_node["typeName"]),
 		memberAsBool(_node, "global")
@@ -403,7 +447,8 @@ ASTPointer<ASTNode> ASTJsonImporter::createStructDefinition(Json::Value const& _
 		_node,
 		memberAsASTString(_node, "name"),
 		createNameSourceLocation(_node),
-		members
+		members,
+		_node["documentation"].isNull() ? nullptr : createDocumentation(member(_node, "documentation"))
 	);
 }
 
@@ -416,7 +461,8 @@ ASTPointer<EnumDefinition> ASTJsonImporter::createEnumDefinition(Json::Value con
 		_node,
 		memberAsASTString(_node, "name"),
 		createNameSourceLocation(_node),
-		members
+		members,
+		_node["documentation"].isNull() ? nullptr : createDocumentation(member(_node, "documentation"))
 	);
 }
 
@@ -468,7 +514,7 @@ ASTPointer<FunctionDefinition> ASTJsonImporter::createFunctionDefinition(Json::V
 
 	Token kind;
 	bool freeFunction = false;
-	string kindStr = member(_node, "kind").asString();
+	std::string kindStr = member(_node, "kind").asString();
 
 	if (kindStr == "constructor")
 		kind = Token::Constructor;
@@ -511,7 +557,7 @@ ASTPointer<FunctionDefinition> ASTJsonImporter::createFunctionDefinition(Json::V
 		modifiers,
 		createParameterList(member(_node, "returnParameters")),
 		memberAsBool(_node, "implemented") ? createBlock(member(_node, "body"), false) : nullptr,
-		nullopt,
+		std::nullopt,
 		false,
 		false,
 		false,
@@ -526,7 +572,7 @@ ASTPointer<VariableDeclaration> ASTJsonImporter::createVariableDeclaration(Json:
 
 	VariableDeclaration::Mutability mutability{};
 	astAssert(member(_node, "mutability").isString(), "'mutability' expected to be string.");
-	string const mutabilityStr = member(_node, "mutability").asString();
+	std::string const mutabilityStr = member(_node, "mutability").asString();
 	if (mutabilityStr == "constant")
 	{
 		mutability = VariableDeclaration::Mutability::Constant;
@@ -546,7 +592,7 @@ ASTPointer<VariableDeclaration> ASTJsonImporter::createVariableDeclaration(Json:
 	return createASTNode<VariableDeclaration>(
 		_node,
 		nullOrCast<TypeName>(member(_node, "typeName")),
-		make_shared<ASTString>(member(_node, "name").asString()),
+		std::make_shared<ASTString>(member(_node, "name").asString()),
 		createNameSourceLocation(_node),
 		nullOrCast<Expression>(member(_node, "value")),
 		visibility(_node),
@@ -579,7 +625,7 @@ ASTPointer<ModifierInvocation> ASTJsonImporter::createModifierInvocation(Json::V
 	return createASTNode<ModifierInvocation>(
 		_node,
 		createIdentifierPath(member(_node, "modifierName")),
-		member(_node, "arguments").isNull() ? nullptr : make_unique<std::vector<ASTPointer<Expression>>>(arguments)
+		member(_node, "arguments").isNull() ? nullptr : std::make_unique<std::vector<ASTPointer<Expression>>>(arguments)
 	);
 }
 
@@ -613,9 +659,9 @@ ASTPointer<ElementaryTypeName> ASTJsonImporter::createElementaryTypeName(Json::V
 
 	astAssert(_node["name"].isString(), "Expected 'name' to be a string!");
 
-	string name = member(_node, "name").asString();
+	std::string name = member(_node, "name").asString();
 	Token token;
-	tie(token, firstNum, secondNum) = TokenTraits::fromIdentifierOrKeyword(name);
+	std::tie(token, firstNum, secondNum) = TokenTraits::fromIdentifierOrKeyword(name);
 	ElementaryTypeNameToken elem(token, firstNum,  secondNum);
 
 	std::optional<StateMutability> mutability = {};
@@ -649,7 +695,11 @@ ASTPointer<Mapping> ASTJsonImporter::createMapping(Json::Value const&  _node)
 	return createASTNode<Mapping>(
 		_node,
 		convertJsonToASTNode<TypeName>(member(_node, "keyType")),
-		convertJsonToASTNode<TypeName>(member(_node, "valueType"))
+		memberAsASTString(_node, "keyName"),
+		createKeyNameSourceLocation(_node),
+		convertJsonToASTNode<TypeName>(member(_node, "valueType")),
+		memberAsASTString(_node, "valueName"),
+		createValueNameSourceLocation(_node)
 	);
 }
 
@@ -662,19 +712,6 @@ ASTPointer<ArrayTypeName> ASTJsonImporter::createArrayTypeName(Json::Value const
 	);
 }
 
-ASTPointer<InlineAssembly> ASTJsonImporter::createInlineAssembly(Json::Value const& _node)
-{
-	astAssert(_node["evmVersion"].isString(), "Expected evmVersion to be a string!");
-	auto evmVersion = langutil::EVMVersion::fromString(_node["evmVersion"].asString());
-	astAssert(evmVersion.has_value(), "Invalid EVM version!");
-	astAssert(m_evmVersion == evmVersion, "Imported tree evm version differs from configured evm version!");
-
-	return createASTNode<InlineAssembly>(
-		_node,
-		nullOrASTString(_node, "documentation")
-	);
-}
-
 ASTPointer<Block> ASTJsonImporter::createBlock(Json::Value const& _node, bool _unchecked)
 {
 	std::vector<ASTPointer<Statement>> statements;
@@ -721,7 +758,6 @@ ASTPointer<TryStatement> ASTJsonImporter::createTryStatement(Json::Value const&
 {
     ASTPointer<Block> body = createBlock(_node["block"], false);
 	ASTPointer<TryCatchClause> clause = createTryCatchClause(_node["clause"]);
-
 	return createASTNode<TryStatement>(
 		_node,
 		nullOrASTString(_node, "documentation"),
@@ -774,6 +810,7 @@ ASTPointer<Break> ASTJsonImporter::createBreak(Json::Value const&  _node)
 
 ASTPointer<Return> ASTJsonImporter::createReturn(Json::Value const&  _node)
 {
+	solUnimplemented("");
 	std::vector<ASTPointer<Expression>> options;
 	for (auto& option: member(_node, "options"))
 		options.push_back(convertJsonToASTNode<Expression>(option));
@@ -781,15 +818,17 @@ ASTPointer<Return> ASTJsonImporter::createReturn(Json::Value const&  _node)
 	for (auto& name: member(_node, "names"))
 	{
 		astAssert(name.isString(), "Expected 'names' members to be strings!");
-		names.push_back(make_shared<ASTString>(name.asString()));
+		names.push_back(std::make_shared<ASTString>(name.asString()));
 	}
+	std::optional<std::vector<SourceLocation>> sourceLocations = createSourceLocations(_node);
 
 	return createASTNode<Return>(
 		_node,
 		nullOrASTString(_node, "documentation"),
 		nullOrCast<Expression>(member(_node, "expression")),
 		options,
-		names
+		names,
+		sourceLocations.value()
 	);
 }
 
@@ -895,33 +934,9 @@ ASTPointer<BinaryOperation> ASTJsonImporter::createBinaryOperation(Json::Value c
 	);
 }
 
-ASTPointer<FunctionCall> ASTJsonImporter::createFunctionCall(Json::Value const&  _node)
+ASTPointer<FunctionCall> ASTJsonImporter::createFunctionCall(Json::Value const&  /*_node*/)
 {
-	// TODO DELETE
 	solUnimplemented("TODO");
-
-	std::vector<ASTPointer<Expression>> arguments;
-	for (auto& arg: member(_node, "arguments"))
-		arguments.push_back(convertJsonToASTNode<Expression>(arg));
-	std::vector<ASTPointer<ASTString>> names;
-	for (auto& name: member(_node, "names"))
-	{
-		astAssert(name.isString(), "Expected 'names' members to be strings!");
-		names.push_back(make_shared<ASTString>(name.asString()));
-	}
-
-	optional<vector<SourceLocation>> sourceLocations = createSourceLocations(_node);
-
-	return createASTNode<FunctionCall>(
-		_node,
-		convertJsonToASTNode<Expression>(member(_node, "expression")),
-		arguments,
-		names,
-		sourceLocations ?
-			*sourceLocations :
-			vector<SourceLocation>(names.size()),
-		FunctionCall::Kind::Usual
-	);
 }
 
 ASTPointer<FunctionCallOptions> ASTJsonImporter::createFunctionCallOptions(Json::Value const&  _node)
@@ -933,7 +948,7 @@ ASTPointer<FunctionCallOptions> ASTJsonImporter::createFunctionCallOptions(Json:
 	for (auto& name: member(_node, "names"))
 	{
 		astAssert(name.isString(), "Expected 'names' members to be strings!");
-		names.push_back(make_shared<ASTString>(name.asString()));
+		names.push_back(std::make_shared<ASTString>(name.asString()));
 	}
 
 	return createASTNode<FunctionCallOptions>(
@@ -1000,14 +1015,14 @@ ASTPointer<ElementaryTypeNameExpression> ASTJsonImporter::createElementaryTypeNa
 
 ASTPointer<ASTNode> ASTJsonImporter::createLiteral(Json::Value const&  _node)
 {
-	static string const valStr = "value";
-	static string const hexValStr = "hexValue";
+	static std::string const valStr = "value";
+	static std::string const hexValStr = "hexValue";
 
 	astAssert(member(_node, valStr).isString() || member(_node, hexValStr).isString(), "Literal-value is unset.");
 
 	ASTPointer<ASTString> value = _node.isMember(hexValStr) ?
-		make_shared<ASTString>(util::asString(util::fromHex(_node[hexValStr].asString()))) :
-		make_shared<ASTString>(_node[valStr].asString());
+		std::make_shared<ASTString>(util::asString(util::fromHex(_node[hexValStr].asString()))) :
+		std::make_shared<ASTString>(_node[valStr].asString());
 
 	return createASTNode<Literal>(
 		_node,
@@ -1019,19 +1034,19 @@ ASTPointer<ASTNode> ASTJsonImporter::createLiteral(Json::Value const&  _node)
 
 ASTPointer<StructuredDocumentation> ASTJsonImporter::createDocumentation(Json::Value const&  _node)
 {
-	static string const textString = "text";
+	static std::string const textString = "text";
 
 	astAssert(member(_node, textString).isString(), "'text' must be a string");
 
 	return createASTNode<StructuredDocumentation>(
 		_node,
-		make_shared<ASTString>(_node[textString].asString())
+		std::make_shared<ASTString>(_node[textString].asString())
 	);
 }
 
 // ===== helper functions ==========
 
-Json::Value ASTJsonImporter::member(Json::Value const& _node, string const& _name)
+Json::Value ASTJsonImporter::member(Json::Value const& _node, std::string const& _name)
 {
 	if (!_node.isMember(_name))
 		return Json::nullValue;
@@ -1046,19 +1061,19 @@ Token ASTJsonImporter::scanSingleToken(Json::Value const& _node)
 	return scanner.currentToken();
 }
 
-ASTPointer<ASTString> ASTJsonImporter::nullOrASTString(Json::Value const& _json, string const& _name)
+ASTPointer<ASTString> ASTJsonImporter::nullOrASTString(Json::Value const& _json, std::string const& _name)
 {
 	return _json[_name].isString() ? memberAsASTString(_json, _name) : nullptr;
 }
 
-ASTPointer<ASTString> ASTJsonImporter::memberAsASTString(Json::Value const& _node, string const& _name)
+ASTPointer<ASTString> ASTJsonImporter::memberAsASTString(Json::Value const& _node, std::string const& _name)
 {
 	Json::Value value = member(_node, _name);
 	astAssert(value.isString(), "field " + _name + " must be of type string.");
-	return make_shared<ASTString>(_node[_name].asString());
+	return std::make_shared<ASTString>(_node[_name].asString());
 }
 
-bool ASTJsonImporter::memberAsBool(Json::Value const& _node, string const& _name)
+bool ASTJsonImporter::memberAsBool(Json::Value const& _node, std::string const& _name)
 {
 	Json::Value value = member(_node, _name);
 	astAssert(value.isBool(), "field " + _name + " must be of type boolean.");
@@ -1107,7 +1122,7 @@ Visibility ASTJsonImporter::visibility(Json::Value const& _node)
 	Json::Value visibility = member(_node, "visibility");
 	astAssert(visibility.isString(), "'visibility' expected to be a string.");
 
-	string const visibilityStr = visibility.asString();
+	std::string const visibilityStr = visibility.asString();
 
 	if (visibilityStr == "default")
 		return Visibility::Default;
@@ -1135,7 +1150,7 @@ Literal::SubDenomination ASTJsonImporter::subdenomination(Json::Value const& _no
 
 	astAssert(subDen.isString(), "'subDenomination' expected to be string.");
 
-	string const subDenStr = subDen.asString();
+	std::string const subDenStr = subDen.asString();
 
 	if (subDenStr == "seconds")
 		return Literal::SubDenomination::Second;
@@ -1159,7 +1174,7 @@ Literal::SubDenomination ASTJsonImporter::subdenomination(Json::Value const& _no
 StateMutability ASTJsonImporter::stateMutability(Json::Value const& _node)
 {
 	astAssert(member(_node, "stateMutability").isString(), "StateMutability' expected to be string.");
-	string const mutabilityStr = member(_node, "stateMutability").asString();
+	std::string const mutabilityStr = member(_node, "stateMutability").asString();
 
 	if (mutabilityStr == "pure")
 		return StateMutability::Pure;
diff --git a/compiler/libsolidity/ast/ASTJsonImporter.h b/compiler/libsolidity/ast/ASTJsonImporter.h
index d54adc7d..628f280a 100644
--- a/compiler/libsolidity/ast/ASTJsonImporter.h
+++ b/compiler/libsolidity/ast/ASTJsonImporter.h
@@ -69,6 +69,10 @@ class ASTJsonImporter
 	ASTPointer<T> convertJsonToASTNode(Json::Value const& _node);
 
 	langutil::SourceLocation createNameSourceLocation(Json::Value const& _node);
+	/// @returns source location of a mapping key name
+	langutil::SourceLocation createKeyNameSourceLocation(Json::Value const& _node);
+	/// @returns source location of a mapping value name
+	langutil::SourceLocation createValueNameSourceLocation(Json::Value const& _node);
 
 	/// \defgroup nodeCreators JSON to AST-Nodes
 	///@{
@@ -96,7 +100,6 @@ class ASTJsonImporter
 	ASTPointer<FunctionTypeName> createFunctionTypeName(Json::Value const& _node);
 	ASTPointer<Mapping> createMapping(Json::Value const& _node);
 	ASTPointer<ArrayTypeName> createArrayTypeName(Json::Value const& _node);
-	ASTPointer<InlineAssembly> createInlineAssembly(Json::Value const& _node);
 	ASTPointer<Block> createBlock(Json::Value const& _node, bool _unchecked);
 	ASTPointer<PlaceholderStatement> createPlaceholderStatement(Json::Value const& _node);
 	ASTPointer<IfStatement> createIfStatement(Json::Value const& _node);
diff --git a/compiler/libsolidity/ast/ASTVisitor.h b/compiler/libsolidity/ast/ASTVisitor.h
index 8de5358c..d841ac2a 100644
--- a/compiler/libsolidity/ast/ASTVisitor.h
+++ b/compiler/libsolidity/ast/ASTVisitor.h
@@ -81,7 +81,6 @@ class ASTVisitor
 	virtual bool visit(TvmVector& _node) { return visitNode(_node); }
 	virtual bool visit(ArrayTypeName& _node) { return visitNode(_node); }
 	virtual bool visit(FreeInlineAssembly& _node) { return visitNode(_node); }
-	virtual bool visit(InlineAssembly& _node) { return visitNode(_node); }
 	virtual bool visit(Block& _node) { return visitNode(_node); }
 	virtual bool visit(PlaceholderStatement& _node) { return visitNode(_node); }
 	virtual bool visit(IfStatement& _node) { return visitNode(_node); }
@@ -117,6 +116,14 @@ class ASTVisitor
 	virtual bool visit(StructuredDocumentation& _node) { return visitNode(_node); }
 	virtual bool visit(MappingNameExpression& _node) { return visitNode(_node); }
 	virtual bool visit(OptionalNameExpression& _node) { return visitNode(_node); }
+	/// Experimental Solidity nodes
+	/// @{
+	virtual bool visit(TypeClassDefinition& _node) { return visitNode(_node); }
+	virtual bool visit(TypeClassInstantiation& _node) { return visitNode(_node); }
+	virtual bool visit(TypeDefinition& _node) { return visitNode(_node); }
+	virtual bool visit(TypeClassName& _node) { return visitNode(_node); }
+	virtual bool visit(Builtin& _node) { return visitNode(_node); }
+	///  @}
 
 	virtual void endVisit(SourceUnit& _node) { endVisitNode(_node); }
 	virtual void endVisit(PragmaDirective& _node) { endVisitNode(_node); }
@@ -145,7 +152,6 @@ class ASTVisitor
 	virtual void endVisit(TvmVector& _node) { endVisitNode(_node); }
 	virtual void endVisit(ArrayTypeName& _node) { endVisitNode(_node); }
 	virtual void endVisit(FreeInlineAssembly& _node) { endVisitNode(_node); }
-	virtual void endVisit(InlineAssembly& _node) { endVisitNode(_node); }
 	virtual void endVisit(Block& _node) { endVisitNode(_node); }
 	virtual void endVisit(PlaceholderStatement& _node) { endVisitNode(_node); }
 	virtual void endVisit(IfStatement& _node) { endVisitNode(_node); }
@@ -181,6 +187,14 @@ class ASTVisitor
 	virtual void endVisit(StructuredDocumentation& _node) { endVisitNode(_node); }
 	virtual void endVisit(MappingNameExpression& _node) { endVisitNode(_node); }
 	virtual void endVisit(OptionalNameExpression& _node) { endVisitNode(_node); }
+	/// Experimental Solidity nodes
+	/// @{
+	virtual void endVisit(TypeClassDefinition& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeClassInstantiation& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeDefinition& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeClassName& _node) { endVisitNode(_node); }
+	virtual void endVisit(Builtin& _node) { endVisitNode(_node); }
+	///  @}
 
 protected:
 	/// Generic function called by default for each node, to be overridden by derived classes
@@ -240,7 +254,6 @@ class ASTConstVisitor
 	virtual bool visit(ForEachStatement const& _node) { return visitNode(_node); }
 	virtual bool visit(Continue const& _node) { return visitNode(_node); }
 	virtual bool visit(FreeInlineAssembly const& _node) { return visitNode(_node); }
-	virtual bool visit(InlineAssembly const& _node) { return visitNode(_node); }
 	virtual bool visit(Break const& _node) { return visitNode(_node); }
 	virtual bool visit(Return const& _node) { return visitNode(_node); }
 	virtual bool visit(Throw const& _node) { return visitNode(_node); }
@@ -267,6 +280,14 @@ class ASTConstVisitor
 	virtual bool visit(StructuredDocumentation const& _node) { return visitNode(_node); }
 	virtual bool visit(MappingNameExpression const& _node) { return visitNode(_node); }
 	virtual bool visit(OptionalNameExpression const& _node) { return visitNode(_node); }
+	/// Experimental Solidity nodes
+	/// @{
+	virtual bool visit(TypeClassDefinition const& _node) { return visitNode(_node); }
+	virtual bool visit(TypeClassInstantiation const& _node) { return visitNode(_node); }
+	virtual bool visit(TypeDefinition const& _node) { return visitNode(_node); }
+	virtual bool visit(TypeClassName const& _node) { return visitNode(_node); }
+	virtual bool visit(Builtin const& _node) { return visitNode(_node); }
+	///  @}
 
 	virtual void endVisit(SourceUnit const& _node) { endVisitNode(_node); }
 	virtual void endVisit(PragmaDirective const& _node) { endVisitNode(_node); }
@@ -304,7 +325,6 @@ class ASTConstVisitor
 	virtual void endVisit(ForEachStatement const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Continue const& _node) { endVisitNode(_node); }
 	virtual void endVisit(FreeInlineAssembly const& _node) { endVisitNode(_node); }
-	virtual void endVisit(InlineAssembly const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Break const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Return const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Throw const& _node) { endVisitNode(_node); }
@@ -331,6 +351,14 @@ class ASTConstVisitor
 	virtual void endVisit(StructuredDocumentation const& _node) { endVisitNode(_node); }
 	virtual void endVisit(MappingNameExpression const& _node) { endVisitNode(_node); }
 	virtual void endVisit(OptionalNameExpression const& _node) { endVisitNode(_node); }
+	/// Experimental Solidity nodes
+	/// @{
+	virtual void endVisit(TypeClassDefinition const& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeClassInstantiation const& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeDefinition const& _node) { endVisitNode(_node); }
+	virtual void endVisit(TypeClassName const& _node) { endVisitNode(_node); }
+	virtual void endVisit(Builtin const& _node) { endVisitNode(_node); }
+	///  @}
 
 protected:
 	/// Generic function called by default for each node, to be overridden by derived classes
diff --git a/compiler/libsolidity/ast/AST_accept.h b/compiler/libsolidity/ast/AST_accept.h
index ec0fd7e6..aad41ed3 100644
--- a/compiler/libsolidity/ast/AST_accept.h
+++ b/compiler/libsolidity/ast/AST_accept.h
@@ -196,7 +196,7 @@ void UsingForDirective::accept(ASTVisitor& _visitor)
 {
 	if (_visitor.visit(*this))
 	{
-		listAccept(functionsOrLibrary(), _visitor);
+		listAccept(m_functionsOrLibrary, _visitor);
 		if (m_typeName)
 			m_typeName->accept(_visitor);
 	}
@@ -207,7 +207,7 @@ void UsingForDirective::accept(ASTConstVisitor& _visitor) const
 {
 	if (_visitor.visit(*this))
 	{
-		listAccept(functionsOrLibrary(), _visitor);
+		listAccept(m_functionsOrLibrary, _visitor);
 		if (m_typeName)
 			m_typeName->accept(_visitor);
 	}
@@ -267,6 +267,8 @@ void FunctionDefinition::accept(ASTVisitor& _visitor)
 		m_parameters->accept(_visitor);
 		if (m_returnParameters)
 			m_returnParameters->accept(_visitor);
+		if (m_experimentalReturnExpression)
+			m_experimentalReturnExpression->accept(_visitor);
 		listAccept(m_functionModifiers, _visitor);
 		if (m_body)
 			m_body->accept(_visitor);
@@ -285,6 +287,8 @@ void FunctionDefinition::accept(ASTConstVisitor& _visitor) const
 		m_parameters->accept(_visitor);
 		if (m_returnParameters)
 			m_returnParameters->accept(_visitor);
+		if (m_experimentalReturnExpression)
+			m_experimentalReturnExpression->accept(_visitor);
 		listAccept(m_functionModifiers, _visitor);
 		if (m_body)
 			m_body->accept(_visitor);
@@ -298,6 +302,8 @@ void VariableDeclaration::accept(ASTVisitor& _visitor)
 	{
 		if (m_typeName)
 			m_typeName->accept(_visitor);
+		if (m_typeExpression)
+			m_typeExpression->accept(_visitor);
 		if (m_overrides)
 			m_overrides->accept(_visitor);
 		if (m_value)
@@ -310,9 +316,10 @@ void VariableDeclaration::accept(ASTConstVisitor& _visitor) const
 {
 	if (_visitor.visit(*this))
 	{
-		if (m_typeName) {
+		if (m_typeName)
 			m_typeName->accept(_visitor);
-		}
+		if (m_typeExpression)
+			m_typeExpression->accept(_visitor);
 		if (m_overrides)
 			m_overrides->accept(_visitor);
 		if (m_value)
@@ -555,18 +562,6 @@ void FreeInlineAssembly::accept(ASTConstVisitor& _visitor) const
 	_visitor.endVisit(*this);
 }
 
-void InlineAssembly::accept(ASTVisitor& _visitor)
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
-void InlineAssembly::accept(ASTConstVisitor& _visitor) const
-{
-	_visitor.visit(*this);
-	_visitor.endVisit(*this);
-}
-
 void Block::accept(ASTVisitor& _visitor)
 {
 	if (_visitor.visit(*this))
@@ -1183,4 +1178,114 @@ void Literal::accept(ASTConstVisitor& _visitor) const
 	_visitor.endVisit(*this);
 }
 
+/// Experimental Solidity nodes
+/// @{
+void TypeClassDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_typeVariable->accept(_visitor);
+		if (m_documentation)
+			m_documentation->accept(_visitor);
+		listAccept(m_subNodes, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeClassDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_typeVariable->accept(_visitor);
+		if (m_documentation)
+			m_documentation->accept(_visitor);
+		listAccept(m_subNodes, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeClassInstantiation::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_typeConstructor->accept(_visitor);
+		if (m_argumentSorts)
+			m_argumentSorts->accept(_visitor);
+		m_class->accept(_visitor);
+		listAccept(m_subNodes, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeClassInstantiation::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_typeConstructor->accept(_visitor);
+		if (m_argumentSorts)
+			m_argumentSorts->accept(_visitor);
+		m_class->accept(_visitor);
+		listAccept(m_subNodes, _visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeDefinition::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		if (m_arguments)
+			m_arguments->accept(_visitor);
+		if (m_typeExpression)
+			m_typeExpression->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeDefinition::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		if (m_arguments)
+			m_arguments->accept(_visitor);
+		if (m_typeExpression)
+			m_typeExpression->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+
+void TypeClassName::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		if (auto* path = std::get_if<ASTPointer<IdentifierPath>>(&m_name))
+			(*path)->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void TypeClassName::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		if (auto* path = std::get_if<ASTPointer<IdentifierPath>>(&m_name))
+			(*path)->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void Builtin::accept(ASTVisitor& _visitor)
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+
+void Builtin::accept(ASTConstVisitor& _visitor) const
+{
+	_visitor.visit(*this);
+	_visitor.endVisit(*this);
+}
+/// @}
+
 }
diff --git a/compiler/libsolidity/ast/CallGraph.cpp b/compiler/libsolidity/ast/CallGraph.cpp
index bf37b226..04275c37 100644
--- a/compiler/libsolidity/ast/CallGraph.cpp
+++ b/compiler/libsolidity/ast/CallGraph.cpp
@@ -18,7 +18,6 @@
 
 #include <libsolidity/ast/CallGraph.h>
 
-using namespace std;
 using namespace solidity::frontend;
 
 bool CallGraph::CompareByID::operator()(Node const& _lhs, Node const& _rhs) const
@@ -26,21 +25,21 @@ bool CallGraph::CompareByID::operator()(Node const& _lhs, Node const& _rhs) cons
 	if (_lhs.index() != _rhs.index())
 		return _lhs.index() < _rhs.index();
 
-	if (holds_alternative<SpecialNode>(_lhs))
-		return get<SpecialNode>(_lhs) < get<SpecialNode>(_rhs);
-	return get<CallableDeclaration const*>(_lhs)->id() < get<CallableDeclaration const*>(_rhs)->id();
+	if (std::holds_alternative<SpecialNode>(_lhs))
+		return std::get<SpecialNode>(_lhs) < std::get<SpecialNode>(_rhs);
+	return std::get<CallableDeclaration const*>(_lhs)->id() < std::get<CallableDeclaration const*>(_rhs)->id();
 }
 
 bool CallGraph::CompareByID::operator()(Node const& _lhs, int64_t _rhs) const
 {
-	solAssert(!holds_alternative<SpecialNode>(_lhs), "");
+	solAssert(!std::holds_alternative<SpecialNode>(_lhs), "");
 
-	return get<CallableDeclaration const*>(_lhs)->id() < _rhs;
+	return std::get<CallableDeclaration const*>(_lhs)->id() < _rhs;
 }
 
 bool CallGraph::CompareByID::operator()(int64_t _lhs, Node const& _rhs) const
 {
-	solAssert(!holds_alternative<SpecialNode>(_rhs), "");
+	solAssert(!std::holds_alternative<SpecialNode>(_rhs), "");
 
-	return _lhs < get<CallableDeclaration const*>(_rhs)->id();
+	return _lhs < std::get<CallableDeclaration const*>(_rhs)->id();
 }
diff --git a/compiler/libsolidity/ast/ExperimentalFeatures.h b/compiler/libsolidity/ast/ExperimentalFeatures.h
index 772bc4e0..ae2cb14c 100644
--- a/compiler/libsolidity/ast/ExperimentalFeatures.h
+++ b/compiler/libsolidity/ast/ExperimentalFeatures.h
@@ -32,7 +32,8 @@ enum class ExperimentalFeature
 	ABIEncoderV2, // new ABI encoder that makes use of Yul
 	SMTChecker,
 	Test,
-	TestOnlyAnalysis
+	TestOnlyAnalysis,
+	Solidity
 };
 
 static std::set<ExperimentalFeature> const ExperimentalFeatureWithoutWarning =
@@ -48,6 +49,7 @@ static std::map<std::string, ExperimentalFeature> const ExperimentalFeatureNames
 	{ "SMTChecker", ExperimentalFeature::SMTChecker },
 	{ "__test", ExperimentalFeature::Test },
 	{ "__testOnlyAnalysis", ExperimentalFeature::TestOnlyAnalysis },
+	{ "solidity", ExperimentalFeature::Solidity }
 };
 
 }
diff --git a/compiler/libsolidity/ast/TypeProvider.cpp b/compiler/libsolidity/ast/TypeProvider.cpp
index b7c1ad06..da760c8b 100644
--- a/compiler/libsolidity/ast/TypeProvider.cpp
+++ b/compiler/libsolidity/ast/TypeProvider.cpp
@@ -21,7 +21,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/split.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 using namespace solidity::util;
@@ -37,586 +36,585 @@ InaccessibleDynamicType const TypeProvider::m_inaccessibleDynamic{};
 
 /// The string and bytes unique_ptrs are initialized when they are first used because
 /// they rely on `byte` being available which we cannot guarantee in the static init context.
-unique_ptr<ArrayType> TypeProvider::m_bytesStorage;
-unique_ptr<ArrayType> TypeProvider::m_bytesMemory;
-unique_ptr<ArrayType> TypeProvider::m_bytesCalldata;
-unique_ptr<ArrayType> TypeProvider::m_stringStorage;
-unique_ptr<Variant> TypeProvider::m_variant;
-unique_ptr<ArrayType> TypeProvider::m_stringMemory;
+std::unique_ptr<ArrayType> TypeProvider::m_bytesStorage;
+std::unique_ptr<ArrayType> TypeProvider::m_bytesMemory;
+std::unique_ptr<ArrayType> TypeProvider::m_bytesCalldata;
+std::unique_ptr<ArrayType> TypeProvider::m_stringStorage;
+std::unique_ptr<ArrayType> TypeProvider::m_stringMemory;
+std::unique_ptr<Variant> TypeProvider::m_variant;
 
 TupleType const TypeProvider::m_emptyTuple{};
 AddressType const TypeProvider::m_address{};
 InitializerListType const TypeProvider::m_initializerList{};
 CallListType const TypeProvider::m_callList{};
 
-std::unique_ptr<IntegerType> const TypeProvider::m_int257 = make_unique<IntegerType>(257, IntegerType::Modifier::Signed);
-
-//for i in range(1, 257):
-//	print("{{make_unique<IntegerType>({}, IntegerType::Modifier::Signed)}},".format(i))
-array<unique_ptr<IntegerType>, 256> const TypeProvider::m_intM{{
-	{make_unique<IntegerType>(1, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(2, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(3, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(4, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(5, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(6, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(7, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(8, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(9, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(10, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(11, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(12, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(13, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(14, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(15, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(16, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(17, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(18, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(19, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(20, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(21, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(22, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(23, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(24, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(25, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(26, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(27, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(28, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(29, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(30, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(31, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(32, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(33, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(34, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(35, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(36, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(37, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(38, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(39, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(40, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(41, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(42, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(43, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(44, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(45, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(46, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(47, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(48, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(49, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(50, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(51, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(52, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(53, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(54, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(55, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(56, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(57, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(58, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(59, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(60, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(61, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(62, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(63, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(64, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(65, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(66, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(67, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(68, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(69, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(70, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(71, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(72, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(73, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(74, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(75, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(76, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(77, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(78, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(79, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(80, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(81, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(82, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(83, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(84, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(85, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(86, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(87, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(88, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(89, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(90, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(91, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(92, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(93, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(94, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(95, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(96, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(97, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(98, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(99, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(100, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(101, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(102, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(103, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(104, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(105, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(106, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(107, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(108, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(109, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(110, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(111, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(112, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(113, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(114, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(115, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(116, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(117, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(118, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(119, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(120, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(121, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(122, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(123, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(124, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(125, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(126, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(127, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(128, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(129, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(130, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(131, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(132, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(133, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(134, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(135, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(136, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(137, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(138, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(139, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(140, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(141, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(142, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(143, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(144, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(145, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(146, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(147, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(148, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(149, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(150, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(151, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(152, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(153, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(154, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(155, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(156, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(157, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(158, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(159, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(160, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(161, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(162, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(163, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(164, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(165, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(166, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(167, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(168, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(169, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(170, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(171, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(172, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(173, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(174, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(175, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(176, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(177, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(178, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(179, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(180, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(181, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(182, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(183, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(184, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(185, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(186, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(187, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(188, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(189, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(190, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(191, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(192, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(193, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(194, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(195, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(196, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(197, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(198, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(199, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(200, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(201, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(202, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(203, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(204, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(205, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(206, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(207, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(208, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(209, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(210, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(211, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(212, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(213, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(214, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(215, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(216, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(217, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(218, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(219, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(220, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(221, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(222, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(223, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(224, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(225, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(226, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(227, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(228, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(229, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(230, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(231, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(232, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(233, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(234, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(235, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(236, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(237, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(238, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(239, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(240, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(241, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(242, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(243, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(244, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(245, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(246, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(247, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(248, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(249, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(250, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(251, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(252, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(253, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(254, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(255, IntegerType::Modifier::Signed)},
-	{make_unique<IntegerType>(256, IntegerType::Modifier::Signed)},
+//for i in range(1, 258):
+//	print("{{std::make_unique<IntegerType>({}, IntegerType::Modifier::Signed)}},".format(i))
+std::array<std::unique_ptr<IntegerType>, 257> const TypeProvider::m_intM{{
+	{std::make_unique<IntegerType>(1, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(2, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(3, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(4, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(5, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(6, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(7, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(8, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(9, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(10, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(11, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(12, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(13, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(14, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(15, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(16, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(17, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(18, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(19, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(20, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(21, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(22, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(23, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(24, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(25, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(26, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(27, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(28, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(29, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(30, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(31, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(32, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(33, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(34, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(35, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(36, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(37, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(38, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(39, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(40, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(41, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(42, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(43, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(44, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(45, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(46, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(47, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(48, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(49, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(50, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(51, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(52, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(53, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(54, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(55, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(56, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(57, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(58, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(59, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(60, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(61, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(62, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(63, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(64, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(65, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(66, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(67, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(68, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(69, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(70, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(71, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(72, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(73, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(74, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(75, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(76, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(77, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(78, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(79, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(80, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(81, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(82, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(83, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(84, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(85, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(86, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(87, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(88, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(89, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(90, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(91, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(92, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(93, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(94, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(95, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(96, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(97, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(98, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(99, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(100, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(101, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(102, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(103, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(104, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(105, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(106, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(107, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(108, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(109, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(110, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(111, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(112, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(113, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(114, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(115, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(116, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(117, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(118, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(119, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(120, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(121, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(122, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(123, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(124, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(125, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(126, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(127, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(128, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(129, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(130, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(131, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(132, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(133, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(134, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(135, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(136, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(137, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(138, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(139, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(140, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(141, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(142, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(143, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(144, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(145, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(146, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(147, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(148, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(149, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(150, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(151, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(152, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(153, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(154, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(155, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(156, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(157, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(158, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(159, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(160, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(161, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(162, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(163, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(164, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(165, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(166, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(167, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(168, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(169, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(170, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(171, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(172, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(173, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(174, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(175, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(176, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(177, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(178, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(179, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(180, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(181, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(182, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(183, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(184, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(185, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(186, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(187, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(188, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(189, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(190, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(191, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(192, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(193, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(194, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(195, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(196, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(197, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(198, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(199, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(200, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(201, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(202, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(203, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(204, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(205, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(206, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(207, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(208, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(209, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(210, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(211, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(212, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(213, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(214, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(215, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(216, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(217, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(218, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(219, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(220, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(221, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(222, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(223, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(224, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(225, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(226, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(227, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(228, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(229, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(230, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(231, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(232, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(233, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(234, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(235, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(236, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(237, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(238, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(239, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(240, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(241, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(242, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(243, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(244, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(245, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(246, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(247, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(248, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(249, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(250, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(251, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(252, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(253, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(254, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(255, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(256, IntegerType::Modifier::Signed)},
+	{std::make_unique<IntegerType>(257, IntegerType::Modifier::Signed)},
 }};
 
 //for i in range(1, 257):
-//	print("{{make_unique<IntegerType>({}, IntegerType::Modifier::Unsigned)}},".format(i))
-array<unique_ptr<IntegerType>, 256> const TypeProvider::m_uintM{{
-	{make_unique<IntegerType>(1, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(2, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(3, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(4, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(5, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(6, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(7, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(8, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(9, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(10, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(11, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(12, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(13, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(14, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(15, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(16, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(17, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(18, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(19, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(20, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(21, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(22, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(23, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(24, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(25, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(26, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(27, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(28, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(29, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(30, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(31, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(32, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(33, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(34, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(35, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(36, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(37, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(38, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(39, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(40, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(41, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(42, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(43, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(44, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(45, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(46, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(47, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(48, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(49, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(50, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(51, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(52, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(53, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(54, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(55, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(56, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(57, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(58, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(59, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(60, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(61, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(62, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(63, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(64, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(65, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(66, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(67, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(68, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(69, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(70, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(71, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(72, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(73, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(74, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(75, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(76, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(77, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(78, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(79, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(80, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(81, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(82, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(83, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(84, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(85, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(86, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(87, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(88, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(89, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(90, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(91, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(92, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(93, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(94, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(95, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(96, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(97, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(98, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(99, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(100, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(101, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(102, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(103, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(104, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(105, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(106, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(107, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(108, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(109, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(110, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(111, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(112, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(113, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(114, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(115, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(116, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(117, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(118, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(119, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(120, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(121, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(122, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(123, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(124, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(125, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(126, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(127, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(128, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(129, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(130, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(131, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(132, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(133, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(134, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(135, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(136, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(137, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(138, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(139, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(140, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(141, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(142, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(143, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(144, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(145, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(146, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(147, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(148, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(149, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(150, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(151, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(152, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(153, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(154, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(155, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(156, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(157, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(158, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(159, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(160, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(161, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(162, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(163, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(164, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(165, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(166, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(167, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(168, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(169, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(170, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(171, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(172, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(173, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(174, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(175, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(176, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(177, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(178, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(179, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(180, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(181, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(182, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(183, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(184, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(185, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(186, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(187, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(188, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(189, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(190, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(191, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(192, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(193, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(194, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(195, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(196, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(197, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(198, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(199, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(200, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(201, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(202, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(203, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(204, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(205, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(206, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(207, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(208, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(209, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(210, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(211, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(212, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(213, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(214, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(215, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(216, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(217, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(218, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(219, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(220, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(221, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(222, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(223, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(224, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(225, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(226, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(227, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(228, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(229, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(230, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(231, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(232, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(233, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(234, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(235, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(236, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(237, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(238, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(239, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(240, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(241, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(242, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(243, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(244, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(245, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(246, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(247, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(248, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(249, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(250, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(251, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(252, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(253, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(254, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(255, IntegerType::Modifier::Unsigned)},
-	{make_unique<IntegerType>(256, IntegerType::Modifier::Unsigned)},
+//	print("{{std::make_unique<IntegerType>({}, IntegerType::Modifier::Unsigned)}},".format(i))
+std::array<std::unique_ptr<IntegerType>, 256> const TypeProvider::m_uintM{{
+	{std::make_unique<IntegerType>(1, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(2, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(3, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(4, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(5, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(6, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(7, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(8, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(9, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(10, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(11, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(12, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(13, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(14, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(15, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(16, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(17, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(18, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(19, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(20, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(21, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(22, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(23, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(24, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(25, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(26, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(27, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(28, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(29, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(30, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(31, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(32, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(33, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(34, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(35, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(36, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(37, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(38, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(39, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(40, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(41, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(42, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(43, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(44, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(45, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(46, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(47, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(48, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(49, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(50, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(51, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(52, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(53, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(54, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(55, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(56, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(57, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(58, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(59, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(60, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(61, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(62, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(63, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(64, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(65, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(66, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(67, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(68, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(69, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(70, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(71, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(72, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(73, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(74, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(75, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(76, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(77, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(78, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(79, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(80, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(81, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(82, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(83, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(84, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(85, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(86, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(87, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(88, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(89, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(90, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(91, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(92, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(93, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(94, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(95, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(96, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(97, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(98, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(99, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(100, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(101, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(102, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(103, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(104, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(105, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(106, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(107, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(108, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(109, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(110, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(111, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(112, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(113, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(114, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(115, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(116, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(117, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(118, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(119, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(120, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(121, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(122, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(123, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(124, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(125, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(126, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(127, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(128, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(129, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(130, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(131, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(132, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(133, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(134, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(135, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(136, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(137, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(138, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(139, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(140, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(141, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(142, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(143, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(144, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(145, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(146, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(147, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(148, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(149, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(150, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(151, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(152, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(153, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(154, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(155, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(156, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(157, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(158, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(159, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(160, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(161, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(162, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(163, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(164, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(165, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(166, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(167, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(168, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(169, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(170, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(171, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(172, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(173, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(174, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(175, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(176, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(177, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(178, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(179, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(180, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(181, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(182, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(183, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(184, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(185, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(186, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(187, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(188, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(189, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(190, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(191, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(192, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(193, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(194, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(195, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(196, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(197, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(198, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(199, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(200, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(201, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(202, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(203, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(204, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(205, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(206, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(207, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(208, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(209, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(210, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(211, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(212, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(213, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(214, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(215, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(216, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(217, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(218, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(219, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(220, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(221, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(222, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(223, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(224, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(225, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(226, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(227, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(228, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(229, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(230, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(231, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(232, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(233, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(234, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(235, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(236, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(237, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(238, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(239, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(240, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(241, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(242, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(243, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(244, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(245, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(246, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(247, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(248, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(249, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(250, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(251, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(252, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(253, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(254, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(255, IntegerType::Modifier::Unsigned)},
+	{std::make_unique<IntegerType>(256, IntegerType::Modifier::Unsigned)},
 }};
 
-array<unique_ptr<FixedBytesType>, 32> const TypeProvider::m_bytesM{{
-	{make_unique<FixedBytesType>(1)},
-	{make_unique<FixedBytesType>(2)},
-	{make_unique<FixedBytesType>(3)},
-	{make_unique<FixedBytesType>(4)},
-	{make_unique<FixedBytesType>(5)},
-	{make_unique<FixedBytesType>(6)},
-	{make_unique<FixedBytesType>(7)},
-	{make_unique<FixedBytesType>(8)},
-	{make_unique<FixedBytesType>(9)},
-	{make_unique<FixedBytesType>(10)},
-	{make_unique<FixedBytesType>(11)},
-	{make_unique<FixedBytesType>(12)},
-	{make_unique<FixedBytesType>(13)},
-	{make_unique<FixedBytesType>(14)},
-	{make_unique<FixedBytesType>(15)},
-	{make_unique<FixedBytesType>(16)},
-	{make_unique<FixedBytesType>(17)},
-	{make_unique<FixedBytesType>(18)},
-	{make_unique<FixedBytesType>(19)},
-	{make_unique<FixedBytesType>(20)},
-	{make_unique<FixedBytesType>(21)},
-	{make_unique<FixedBytesType>(22)},
-	{make_unique<FixedBytesType>(23)},
-	{make_unique<FixedBytesType>(24)},
-	{make_unique<FixedBytesType>(25)},
-	{make_unique<FixedBytesType>(26)},
-	{make_unique<FixedBytesType>(27)},
-	{make_unique<FixedBytesType>(28)},
-	{make_unique<FixedBytesType>(29)},
-	{make_unique<FixedBytesType>(30)},
-	{make_unique<FixedBytesType>(31)},
-	{make_unique<FixedBytesType>(32)}
+std::array<std::unique_ptr<FixedBytesType>, 32> const TypeProvider::m_bytesM{{
+	{std::make_unique<FixedBytesType>(1)},
+	{std::make_unique<FixedBytesType>(2)},
+	{std::make_unique<FixedBytesType>(3)},
+	{std::make_unique<FixedBytesType>(4)},
+	{std::make_unique<FixedBytesType>(5)},
+	{std::make_unique<FixedBytesType>(6)},
+	{std::make_unique<FixedBytesType>(7)},
+	{std::make_unique<FixedBytesType>(8)},
+	{std::make_unique<FixedBytesType>(9)},
+	{std::make_unique<FixedBytesType>(10)},
+	{std::make_unique<FixedBytesType>(11)},
+	{std::make_unique<FixedBytesType>(12)},
+	{std::make_unique<FixedBytesType>(13)},
+	{std::make_unique<FixedBytesType>(14)},
+	{std::make_unique<FixedBytesType>(15)},
+	{std::make_unique<FixedBytesType>(16)},
+	{std::make_unique<FixedBytesType>(17)},
+	{std::make_unique<FixedBytesType>(18)},
+	{std::make_unique<FixedBytesType>(19)},
+	{std::make_unique<FixedBytesType>(20)},
+	{std::make_unique<FixedBytesType>(21)},
+	{std::make_unique<FixedBytesType>(22)},
+	{std::make_unique<FixedBytesType>(23)},
+	{std::make_unique<FixedBytesType>(24)},
+	{std::make_unique<FixedBytesType>(25)},
+	{std::make_unique<FixedBytesType>(26)},
+	{std::make_unique<FixedBytesType>(27)},
+	{std::make_unique<FixedBytesType>(28)},
+	{std::make_unique<FixedBytesType>(29)},
+	{std::make_unique<FixedBytesType>(30)},
+	{std::make_unique<FixedBytesType>(31)},
+	{std::make_unique<FixedBytesType>(32)}
 }};
 
-array<unique_ptr<MagicType>, 8> const TypeProvider::m_magics{{
-	{make_unique<MagicType>(MagicType::Kind::Block)},
-	{make_unique<MagicType>(MagicType::Kind::Message)},
-	{make_unique<MagicType>(MagicType::Kind::Transaction)},
-	{make_unique<MagicType>(MagicType::Kind::ABI)},
-	{make_unique<MagicType>(MagicType::Kind::TVM)},
-	{make_unique<MagicType>(MagicType::Kind::Math)},
-	{make_unique<MagicType>(MagicType::Kind::Rnd)},
-	{make_unique<MagicType>(MagicType::Kind::Gosh)}
+std::array<std::unique_ptr<MagicType>, 8> const TypeProvider::m_magics{{
+	{std::make_unique<MagicType>(MagicType::Kind::Block)},
+	{std::make_unique<MagicType>(MagicType::Kind::Message)},
+	{std::make_unique<MagicType>(MagicType::Kind::Transaction)},
+	{std::make_unique<MagicType>(MagicType::Kind::ABI)},
+	{std::make_unique<MagicType>(MagicType::Kind::TVM)},
+	{std::make_unique<MagicType>(MagicType::Kind::Math)},
+	{std::make_unique<MagicType>(MagicType::Kind::Rnd)},
+	{std::make_unique<MagicType>(MagicType::Kind::Gosh)}
 	// MetaType is stored separately
 }};
 
@@ -626,7 +624,7 @@ inline void clearCache(Type const& type)
 }
 
 template <typename T>
-inline void clearCache(unique_ptr<T> const& type)
+inline void clearCache(std::unique_ptr<T> const& type)
 {
 	// Some lazy-initialized types might not exist yet.
 	if (type)
@@ -667,7 +665,7 @@ void TypeProvider::reset()
 template <typename T, typename... Args>
 inline T const* TypeProvider::createAndGet(Args&& ... _args)
 {
-	instance().m_generalTypes.emplace_back(make_unique<T>(std::forward<Args>(_args)...));
+	instance().m_generalTypes.emplace_back(std::make_unique<T>(std::forward<Args>(_args)...));
 	return static_cast<T const*>(instance().m_generalTypes.back().get());
 }
 
@@ -687,6 +685,8 @@ Type const* TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken const&
 		return varInteger(32, IntegerType::Modifier::Unsigned);
 	case Token::VarUintM:
 		return varInteger(m, IntegerType::Modifier::Unsigned);
+	case Token::coins:
+		return coins();
 	case Token::VarInt:
 		return varInteger(32, IntegerType::Modifier::Signed);
 	case Token::VarIntM:
@@ -735,20 +735,20 @@ Type const* TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken const&
 	}
 }
 
-Type const* TypeProvider::fromElementaryTypeName(string const& _name)
+Type const* TypeProvider::fromElementaryTypeName(std::string const& _name)
 {
-	vector<string> nameParts;
+	std::vector<std::string> nameParts;
 	boost::split(nameParts, _name, boost::is_any_of(" "));
 	solAssert(nameParts.size() == 1 || nameParts.size() == 2, "Cannot parse elementary type: " + _name);
 
 	Token token;
 	unsigned short firstNum, secondNum;
-	tie(token, firstNum, secondNum) = TokenTraits::fromIdentifierOrKeyword(nameParts[0]);
+	std::tie(token, firstNum, secondNum) = TokenTraits::fromIdentifierOrKeyword(nameParts[0]);
 
 	auto t = fromElementaryTypeName(ElementaryTypeNameToken(token, firstNum, secondNum));
-	if (auto* ref = dynamic_cast<ReferenceType const*>(t))
+	if (auto* ref = dynamic_cast<CompositeType const*>(t))
 	{
-		return withLocation(ref, true);
+		return ref;
 	}
 	else if (t->category() == Type::Category::Address)
 	{
@@ -771,42 +771,42 @@ Type const* TypeProvider::fromElementaryTypeName(string const& _name)
 ArrayType const* TypeProvider::bytesStorage()
 {
 	if (!m_bytesStorage)
-		m_bytesStorage = make_unique<ArrayType>(false);
+		m_bytesStorage = std::make_unique<ArrayType>(false);
 	return m_bytesStorage.get();
 }
 
 ArrayType const* TypeProvider::bytesMemory()
 {
 	if (!m_bytesMemory)
-		m_bytesMemory = make_unique<ArrayType>(false);
+		m_bytesMemory = std::make_unique<ArrayType>(false);
 	return m_bytesMemory.get();
 }
 
 ArrayType const* TypeProvider::bytesCalldata()
 {
 	if (!m_bytesCalldata)
-		m_bytesCalldata = make_unique<ArrayType>(false);
+		m_bytesCalldata = std::make_unique<ArrayType>(false);
 	return m_bytesCalldata.get();
 }
 
 ArrayType const* TypeProvider::stringStorage()
 {
 	if (!m_stringStorage)
-		m_stringStorage = make_unique<ArrayType>(true);
+		m_stringStorage = std::make_unique<ArrayType>(true);
 	return m_stringStorage.get();
 }
 
 Variant const* TypeProvider::variant()
 {
     if (!m_variant)
-        m_variant = make_unique<Variant>();
+        m_variant = std::make_unique<Variant>();
     return m_variant.get();
 }
 
 ArrayType const* TypeProvider::stringMemory()
 {
 	if (!m_stringMemory)
-		m_stringMemory = make_unique<ArrayType>(true);
+		m_stringMemory = std::make_unique<ArrayType>(true);
 	return m_stringMemory.get();
 }
 
@@ -851,43 +851,47 @@ RationalNumberType const* TypeProvider::rationalNumber(Literal const& _literal)
 	return nullptr;
 }
 
-StringLiteralType const* TypeProvider::stringLiteral(string const& literal)
+StringLiteralType const* TypeProvider::stringLiteral(std::string const& literal)
 {
 	auto i = instance().m_stringLiteralTypes.find(literal);
 	if (i != instance().m_stringLiteralTypes.end())
 		return i->second.get();
 	else
-		return instance().m_stringLiteralTypes.emplace(literal, make_unique<StringLiteralType>(literal)).first->second.get();
+		return instance().m_stringLiteralTypes.emplace(literal, std::make_unique<StringLiteralType>(literal)).first->second.get();
 }
 
 VarIntegerType const* TypeProvider::varInteger(unsigned m, IntegerType::Modifier _modifier) {
 	auto& map = instance().m_varInterger;
-	auto i = map.find(make_pair(m, _modifier));
+	auto i = map.find(std::make_pair(m, _modifier));
 	if (i != map.end())
 		return i->second.get();
 
 	return map.emplace(
-			make_pair(m, _modifier),
-			make_unique<VarIntegerType>(m, _modifier)
+			std::make_pair(m, _modifier),
+			std::make_unique<VarIntegerType>(m, _modifier)
 	).first->second.get();
 
 }
 
+VarIntegerType const* TypeProvider::coins() {
+	return TypeProvider::varInteger(16, IntegerType::Modifier::Unsigned);
+}
+
 FixedPointType const* TypeProvider::fixedPoint(unsigned m, unsigned n, FixedPointType::Modifier _modifier)
 {
 	auto& map = _modifier == FixedPointType::Modifier::Unsigned ? instance().m_ufixedMxN : instance().m_fixedMxN;
 
-	auto i = map.find(make_pair(m, n));
+	auto i = map.find(std::make_pair(m, n));
 	if (i != map.end())
 		return i->second.get();
 
 	return map.emplace(
-		make_pair(m, n),
-		make_unique<FixedPointType>(m, n, _modifier)
+		std::make_pair(m, n),
+		std::make_unique<FixedPointType>(m, n, _modifier)
 	).first->second.get();
 }
 
-TupleType const* TypeProvider::tuple(vector<Type const*> members)
+TupleType const* TypeProvider::tuple(std::vector<Type const*> members)
 {
 	if (members.empty())
 		return &m_emptyTuple;
@@ -895,15 +899,6 @@ TupleType const* TypeProvider::tuple(vector<Type const*> members)
 	return createAndGet<TupleType>(std::move(members));
 }
 
-ReferenceType const* TypeProvider::withLocation(ReferenceType const* _type, bool _isPointer)
-{
-	if (_type->isPointer() == _isPointer)
-		return _type;
-
-	instance().m_generalTypes.emplace_back(_type->copyForLocation(_isPointer));
-	return static_cast<ReferenceType const*>(instance().m_generalTypes.back().get());
-}
-
 FunctionType const* TypeProvider::function(FunctionDefinition const& _function, FunctionType::Kind _kind)
 {
 	return createAndGet<FunctionType>(_function, _kind);
@@ -938,7 +933,7 @@ FunctionType const* TypeProvider::function(
 )
 {
 	// Can only use this constructor for "arbitraryParameters".
-	solAssert(!_options.valueSet && !_options.gasSet && !_options.saltSet && !_options.bound);
+	solAssert(!_options.valueSet && !_options.gasSet && !_options.saltSet && !_options.hasBoundFirstArgument);
 	return createAndGet<FunctionType>(
 		_parameterTypes,
 		_returnParameterTypes,
@@ -1046,16 +1041,16 @@ MagicType const* TypeProvider::meta(Type const* _type)
 	return createAndGet<MagicType>(_type);
 }
 
-MappingType const* TypeProvider::mapping(Type const* _keyType, Type const* _valueType)
+MappingType const* TypeProvider::mapping(Type const* _keyType, ASTString _keyName, Type const* _valueType, ASTString _valueName)
 {
-	return createAndGet<MappingType>(_keyType, _valueType);
+	return createAndGet<MappingType>(_keyType, _keyName, _valueType, _valueName);
 }
 
 MappingType const *TypeProvider::extraCurrencyCollection()
 {
 	auto keyType = TypeProvider::uint(32);
 	auto valueType = TypeProvider::varInteger(32, IntegerType::Modifier::Unsigned);
-	return createAndGet<MappingType>(keyType, valueType);
+	return createAndGet<MappingType>(keyType, "", valueType, "");
 }
 
 OptionalType const* TypeProvider::optional(Type const* _type)
diff --git a/compiler/libsolidity/ast/TypeProvider.h b/compiler/libsolidity/ast/TypeProvider.h
index f39e73a5..20e6bf62 100644
--- a/compiler/libsolidity/ast/TypeProvider.h
+++ b/compiler/libsolidity/ast/TypeProvider.h
@@ -93,10 +93,6 @@ class TypeProvider
 
 	static IntegerType const* integer(unsigned _bits, IntegerType::Modifier _modifier)
 	{
-		if (_bits == 257 && _modifier == IntegerType::Modifier::Signed) {
-			return m_int257.get();
-		}
-
 		if (_modifier == IntegerType::Modifier::Unsigned)
 			return m_uintM.at(_bits - 1).get();
 		else
@@ -109,7 +105,9 @@ class TypeProvider
 	static IntegerType const* uint256() { return uint(256); }
 	static IntegerType const* int256() { return integer(256, IntegerType::Modifier::Signed); }
 
+	static VarIntegerType const* coins();
 	static VarIntegerType const* varInteger(unsigned m, IntegerType::Modifier _modifier);
+
 	static FixedPointType const* fixedPoint(unsigned m, unsigned n, FixedPointType::Modifier _modifier);
 
 	static StringLiteralType const* stringLiteral(std::string const& literal);
@@ -120,19 +118,6 @@ class TypeProvider
 
 	static TupleType const* emptyTuple() noexcept { return &m_emptyTuple; }
 
-	static ReferenceType const* withLocation(ReferenceType const* _type, bool _isPointer);
-
-	/// @returns a copy of @a _type having the same location as this (and is not a pointer type)
-	///          if _type is a reference type and an unmodified copy of _type otherwise.
-	///          This function is mostly useful to modify inner types appropriately.
-	static Type const* withLocationIfReference(Type const* _type, bool _isPointer = false)
-	{
-		if (auto refType = dynamic_cast<ReferenceType const*>(_type))
-			return withLocation(refType, _isPointer);
-
-		return _type;
-	}
-
 	/// @returns the internally-facing or externally-facing type of a function or the type of a function declaration.
 	static FunctionType const* function(FunctionDefinition const& _function, FunctionType::Kind _kind = FunctionType::Kind::Declaration);
 
@@ -197,7 +182,7 @@ class TypeProvider
 
 	static MagicType const* meta(Type const* _type);
 
-	static MappingType const* mapping(Type const* _keyType, Type const* _valueType);
+	static MappingType const* mapping(Type const* _keyType, ASTString _keyName, Type const* _valueType, ASTString _valueName);
 
 	static MappingType const* extraCurrencyCollection();
 
@@ -239,8 +224,7 @@ class TypeProvider
 	static AddressType const m_address;
 	static InitializerListType const m_initializerList;
 	static CallListType const m_callList;
-	static std::unique_ptr<IntegerType> const m_int257;
-	static std::array<std::unique_ptr<IntegerType>, 256> const m_intM;
+	static std::array<std::unique_ptr<IntegerType>, 257> const m_intM;
 	static std::array<std::unique_ptr<IntegerType>, 256> const m_uintM;
 	static std::array<std::unique_ptr<FixedBytesType>, 32> const m_bytesM;
 	static std::array<std::unique_ptr<MagicType>, 8> const m_magics;        ///< MagicType's except MetaType
diff --git a/compiler/libsolidity/ast/Types.cpp b/compiler/libsolidity/ast/Types.cpp
index 8fe60ed6..dbc43bd3 100644
--- a/compiler/libsolidity/ast/Types.cpp
+++ b/compiler/libsolidity/ast/Types.cpp
@@ -48,12 +48,12 @@
 #include <range/v3/view/reverse.hpp>
 #include <range/v3/view/tail.hpp>
 #include <range/v3/view/transform.hpp>
+#include <range/v3/view/filter.hpp>
 
 #include <limits>
 #include <unordered_set>
 #include <utility>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -117,7 +117,7 @@ util::Result<TypePointers> transformParametersToExternal(TypePointers const& _pa
 	return transformed;
 }
 
-string toStringInParentheses(TypePointers const& _types, bool _withoutDataLocation)
+std::string toStringInParentheses(TypePointers const& _types, bool _withoutDataLocation)
 {
 	return '(' + util::joinHumanReadable(
 		_types | ranges::views::transform([&](auto const* _type) { return _type->toString(_withoutDataLocation); }),
@@ -131,7 +131,7 @@ MemberList::Member::Member(Declaration const* _declaration, Type const* _type):
 	Member(_declaration, _type, _declaration->name())
 {}
 
-MemberList::Member::Member(Declaration const* _declaration, Type const* _type, string _name):
+MemberList::Member::Member(Declaration const* _declaration, Type const* _type, std::string _name):
 	name(std::move(_name)),
 	type(_type),
 	declaration(_declaration)
@@ -159,7 +159,7 @@ void StorageOffsets::computeOffsets(TypePointers const& _types)
 {
 	bigint slotOffset = 0;
 	unsigned byteOffset = 0;
-	map<size_t, pair<u256, unsigned>> offsets;
+	std::map<size_t, std::pair<u256, unsigned>> offsets;
 	for (size_t i = 0; i < _types.size(); ++i)
 	{
 		Type const* type = _types[i];
@@ -172,7 +172,7 @@ void StorageOffsets::computeOffsets(TypePointers const& _types)
 			byteOffset = 0;
 		}
 		solAssert(slotOffset < bigint(1) << 256 ,"Object too large for storage.");
-		offsets[i] = make_pair(u256(slotOffset), byteOffset);
+		offsets[i] = std::make_pair(u256(slotOffset), byteOffset);
 		solAssert(type->storageSize() >= 1, "Invalid storage size.");
 		if (type->storageSize() == 1 && byteOffset + type->storageBytes() <= 32)
 			byteOffset += type->storageBytes();
@@ -189,7 +189,7 @@ void StorageOffsets::computeOffsets(TypePointers const& _types)
 	swap(m_offsets, offsets);
 }
 
-pair<u256, unsigned> const* StorageOffsets::offset(size_t _index) const
+std::pair<u256, unsigned> const* StorageOffsets::offset(size_t _index) const
 {
 	if (m_offsets.count(_index))
 		return &m_offsets.at(_index);
@@ -202,7 +202,7 @@ void MemberList::combine(MemberList const & _other)
 	m_memberTypes += _other.m_memberTypes;
 }
 
-pair<u256, unsigned> const* MemberList::memberStorageOffset(string const& _name) const
+std::pair<u256, unsigned> const* MemberList::memberStorageOffset(std::string const& _name) const
 {
 	StorageOffsets const& offsets = storageOffsets();
 
@@ -235,33 +235,33 @@ StorageOffsets const& MemberList::storageOffsets() const {
 namespace
 {
 
-string parenthesizeIdentifier(string const& _internal)
+std::string parenthesizeIdentifier(std::string const& _internal)
 {
 	return "(" + _internal + ")";
 }
 
 template <class Range>
-string identifierList(Range const&& _list)
+std::string identifierList(Range const&& _list)
 {
 	return parenthesizeIdentifier(boost::algorithm::join(_list, ","));
 }
 
-string richIdentifier(Type const* _type)
+std::string richIdentifier(Type const* _type)
 {
 	return _type ? _type->richIdentifier() : "";
 }
 
-string identifierList(vector<Type const*> const& _list)
+std::string identifierList(std::vector<Type const*> const& _list)
 {
 	return identifierList(_list | ranges::views::transform(richIdentifier));
 }
 
-string identifierList(Type const* _type)
+std::string identifierList(Type const* _type)
 {
 	return parenthesizeIdentifier(richIdentifier(_type));
 }
 
-string identifierList(Type const* _type1, Type const* _type2)
+std::string identifierList(Type const* _type1, Type const* _type2)
 {
 	TypePointers list;
 	list.push_back(_type1);
@@ -269,16 +269,16 @@ string identifierList(Type const* _type1, Type const* _type2)
 	return identifierList(list);
 }
 
-string parenthesizeUserIdentifier(string const& _internal)
+std::string parenthesizeUserIdentifier(std::string const& _internal)
 {
 	return parenthesizeIdentifier(_internal);
 }
 
 }
 
-string Type::escapeIdentifier(string const& _identifier)
+std::string Type::escapeIdentifier(std::string const& _identifier)
 {
-	string ret = _identifier;
+	std::string ret = _identifier;
 	// FIXME: should be _$$$_
 	boost::algorithm::replace_all(ret, "$", "$$$");
 	boost::algorithm::replace_all(ret, ",", "_$_");
@@ -287,12 +287,12 @@ string Type::escapeIdentifier(string const& _identifier)
 	return ret;
 }
 
-string Type::identifier() const
+std::string Type::identifier() const
 {
-	string ret = escapeIdentifier(richIdentifier());
+	std::string ret = escapeIdentifier(richIdentifier());
 	solAssert(ret.find_first_of("0123456789") != 0, "Identifier cannot start with a number.");
 	solAssert(
-		ret.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMONPQRSTUVWXYZ_$") == string::npos,
+		ret.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMONPQRSTUVWXYZ_$") == std::string::npos,
 		"Identifier contains invalid characters."
 	);
 	return ret;
@@ -321,8 +321,8 @@ MemberList const& Type::members(ASTNode const* _currentScope) const
 		"");
 		MemberList::MemberMap members = nativeMembers(_currentScope);
 		if (_currentScope)
-			members += boundFunctions(*this, *_currentScope);
-		m_members[_currentScope] = make_unique<MemberList>(std::move(members));
+			members += attachedFunctions(*this, *_currentScope);
+		m_members[_currentScope] = std::make_unique<MemberList>(std::move(members));
 	}
 	return *m_members[_currentScope];
 }
@@ -352,9 +352,12 @@ Type const* Type::fullEncodingType(bool _inLibraryCall, bool _encoderV2, bool) c
 	return encodingType;
 }
 
-MemberList::MemberMap Type::boundFunctions(Type const& _type, ASTNode const& _scope)
+namespace
+{
+
+std::vector<UsingForDirective const*> usingForDirectivesForType(Type const& _type, ASTNode const& _scope)
 {
-	vector<UsingForDirective const*> usingForDirectives;
+	std::vector<UsingForDirective const*> usingForDirectives;
 	SourceUnit const* sourceUnit = dynamic_cast<SourceUnit const*>(&_scope);
 	if (auto const* contract = dynamic_cast<ContractDefinition const*>(&_scope))
 	{
@@ -373,45 +376,82 @@ MemberList::MemberMap Type::boundFunctions(Type const& _type, ASTNode const& _sc
 					usingForDirectives.emplace_back(usingFor);
 
 	// Normalise data location of type.
+
+	return usingForDirectives | ranges::views::filter([&](UsingForDirective const* _directive) -> bool {
+		// Convert both types to pointers for comparison to see if the `using for` directive applies.
+		// Note that at this point we don't yet know if the functions are actually usable with the type.
+		// `_type` may not be convertible to the function parameter type.
+		return
+			!_directive->typeName() ||
+			_type == *_directive->typeName()->annotation().type;
+	}) | ranges::to<std::vector<UsingForDirective const*>>;
+}
+
+}
+
+std::set<FunctionDefinition const*, ASTNode::CompareByID> Type::operatorDefinitions(
+	Token _token,
+	ASTNode const& _scope,
+	bool _unary
+) const
+{
+	if (!typeDefinition())
+		return {};
+
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> matchingDefinitions;
+	for (UsingForDirective const* directive: usingForDirectivesForType(*this, _scope))
+		for (auto const& [identifierPath, operator_]: directive->functionsAndOperators())
+		{
+			if (operator_ != _token)
+				continue;
+
+			auto const& functionDefinition = dynamic_cast<FunctionDefinition const&>(
+				*identifierPath->annotation().referencedDeclaration
+			);
+			auto const* functionType = dynamic_cast<FunctionType const*>(
+				functionDefinition.libraryFunction() ? functionDefinition.typeViaContractName() : functionDefinition.type()
+			);
+			solAssert(functionType && !functionType->parameterTypes().empty());
+
+			size_t parameterCount = functionDefinition.parameterList().parameters().size();
+			if (*this == *functionType->parameterTypes().front() && (_unary ? parameterCount == 1 : parameterCount == 2))
+				matchingDefinitions.insert(&functionDefinition);
+		}
+
+	return matchingDefinitions;
+}
+
+MemberList::MemberMap Type::attachedFunctions(Type const& _type, ASTNode const& _scope)
+{
 	MemberList::MemberMap members;
 
-	set<pair<string, Declaration const*>> seenFunctions;
-	auto addFunction = [&](FunctionDefinition const& _function, optional<string> _name = {})
+	std::set<std::pair<std::string, Declaration const*>> seenFunctions;
+	auto addFunction = [&](FunctionDefinition const& _function, std::optional<std::string> _name = {})
 	{
 		if (!_name)
 			_name = _function.name();
 		Type const* functionType =
 			_function.libraryFunction() ? _function.typeViaContractName() : _function.type();
 		solAssert(functionType, "");
-		FunctionType const* asBoundFunction =
-			dynamic_cast<FunctionType const&>(*functionType).asBoundFunction();
-		solAssert(asBoundFunction, "");
+		FunctionType const* withBoundFirstArgument =
+			dynamic_cast<FunctionType const&>(*functionType).withBoundFirstArgument();
+		solAssert(withBoundFirstArgument, "");
 
-		if (_type.isImplicitlyConvertibleTo(*asBoundFunction->selfType()))
-			if (seenFunctions.insert(make_pair(*_name, &_function)).second)
-				members.emplace_back(&_function, asBoundFunction, *_name);
+		if (_type.isImplicitlyConvertibleTo(*withBoundFirstArgument->selfType()))
+			if (seenFunctions.insert(std::make_pair(*_name, &_function)).second)
+				members.emplace_back(&_function, withBoundFirstArgument, *_name);
 	};
 
-	for (UsingForDirective const* ufd: usingForDirectives)
-	{
-		// Convert both types to pointers for comparison to see if the `using for`
-		// directive applies.
-		// Further down, we check more detailed for each function if `_type` is
-		// convertible to the function parameter type.
-		if (
-			ufd->typeName() &&
-			*TypeProvider::withLocationIfReference(&_type, true) !=
-			*TypeProvider::withLocationIfReference(
-				ufd->typeName()->annotation().type,
-				true
-			)
-		)
-			continue;
-
-		for (auto const& pathPointer: ufd->functionsOrLibrary())
+	for (UsingForDirective const* ufd: usingForDirectivesForType(_type, _scope))
+		for (auto const& [identifierPath, operator_]: ufd->functionsAndOperators())
 		{
-			solAssert(pathPointer);
-			Declaration const* declaration = pathPointer->annotation().referencedDeclaration;
+			if (operator_.has_value())
+				// Functions used to define operators are not automatically attached to the type.
+				// I.e. `using {f, f as +} for T` allows `T x; x.f()` but `using {f as +} for T` does not.
+				continue;
+
+			solAssert(identifierPath);
+			Declaration const* declaration = identifierPath->annotation().referencedDeclaration;
 			solAssert(declaration);
 
 			if (ContractDefinition const* library = dynamic_cast<ContractDefinition const*>(declaration))
@@ -427,15 +467,14 @@ MemberList::MemberMap Type::boundFunctions(Type const& _type, ASTNode const& _sc
 			else
 				addFunction(
 					dynamic_cast<FunctionDefinition const&>(*declaration),
-					pathPointer->path().back()
+					identifierPath->path().back()
 				);
 		}
-	}
 
 	return members;
 }
 
-string AddressType::richIdentifier() const
+std::string AddressType::richIdentifier() const
 {
 	return "t_address";
 }
@@ -459,12 +498,12 @@ BoolResult AddressType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 	return false;
 }
 
-string AddressType::toString(bool) const
+std::string AddressType::toString(bool) const
 {
 	return "address";
 }
 
-string AddressType::canonicalName() const
+std::string AddressType::canonicalName() const
 {
 	return "address";
 }
@@ -498,7 +537,7 @@ bool AddressType::operator==(Type const& _other) const
 MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const
 {
 	MemberList::MemberMap members = {
-		{"balance", TypeProvider::uint(128)},
+		{"balance", TypeProvider::coins()},
 		{"currencies", TypeProvider::extraCurrencyCollection()},
 		{"wid", TypeProvider::integer(8, IntegerType::Modifier::Signed)},
 		{"value", TypeProvider::uint256()},
@@ -510,7 +549,7 @@ MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const
 			TypePointers{},
 			TypePointers{TypeProvider::integer(32, IntegerType::Modifier::Signed), TypeProvider::uint256()},
 			strings{},
-			strings{string(), string()},
+			strings{std::string(), std::string()},
 			FunctionType::Kind::AddressUnpack,
 			StateMutability::Pure
 	));
@@ -518,7 +557,7 @@ MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const
 			TypePointers{},
 			TypePointers{TypeProvider::uint(8)},
 			strings{},
-			strings{string()},
+			strings{std::string()},
 			FunctionType::Kind::AddressType,
 			StateMutability::Pure
 	));
@@ -526,13 +565,13 @@ MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const
 			TypePointers{},
 			TypePointers{TypeProvider::boolean()},
 			strings{},
-			strings{string()},
+			strings{std::string()},
 			FunctionType::Kind::AddressIsStdAddrWithoutAnyCast,
 			StateMutability::Pure
 	));
 	members.emplace_back("transfer", TypeProvider::function(
 			{
-				TypeProvider::uint(128),
+				TypeProvider::coins(),
 				TypeProvider::boolean(),
 				TypeProvider::uint(16),
 				TypeProvider::tvmcell(),
@@ -581,38 +620,25 @@ IntegerType::IntegerType(unsigned _bits, IntegerType::Modifier _modifier):
 	}
 }
 
-string IntegerType::richIdentifier() const
+std::string IntegerType::richIdentifier() const
 {
-	return "t_" + string(isSigned() ? "" : "u") + "int" + to_string(numBits());
+	return "t_" + std::string(isSigned() ? "" : "u") + "int" + std::to_string(numBits());
 }
 
 BoolResult IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 {
-	if (Type::isImplicitlyConvertibleTo(_convertTo)) {
+	if (Type::isImplicitlyConvertibleTo(_convertTo))
 		return true;
-	}
 
 	if (_convertTo.category() == Category::VarInteger)
 	{
 		IntegerType const& convertTo = dynamic_cast<VarIntegerType const&>(_convertTo).asIntegerType();
-		// disallowing unsigned to signed conversion of different bits
-		if (isSigned() != convertTo.isSigned())
-			return false;
-		else if (convertTo.m_bits < m_bits)
-			return false;
-		else
-			return true;
+		return maxValue() <= convertTo.maxValue() && minValue() >= convertTo.minValue();
 	}
 	else if (_convertTo.category() == category())
 	{
 		IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
-		// disallowing unsigned to signed conversion of different bits
-		if (isSigned() != convertTo.isSigned())
-			return false;
-		else if (convertTo.m_bits < m_bits)
-			return false;
-		else
-			return true;
+		return maxValue() <= convertTo.maxValue() && minValue() >= convertTo.minValue();
 	}
 	else if (_convertTo.category() == Category::FixedPoint)
 	{
@@ -635,18 +661,18 @@ BoolResult IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
 	if (isImplicitlyConvertibleTo(_convertTo))
 		return true;
-	else if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))
-		return (numBits() == integerType->numBits()) || (isSigned() == integerType->isSigned());
-	else if (auto varIntegerType = dynamic_cast<VarIntegerType const*>(&_convertTo))
-		return (numBits() == varIntegerType->asIntegerType().numBits()) || (isSigned() == varIntegerType->asIntegerType().isSigned());
+
+	Type::Category const category = _convertTo.category();
+	if (category == Type::Category::Integer ||
+		category == Type::Category::VarInteger ||
+		category == Type::Category::Enum ||
+		category == Type::Category::FixedPoint
+	)
+		return true;
 	else if (dynamic_cast<AddressType const*>(&_convertTo) || dynamic_cast<ContractType const*>(&_convertTo))
 		return !isSigned();
 	else if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(&_convertTo))
 		return (!isSigned() && (numBits() == fixedBytesType->numBytes() * 8));
-	else if (dynamic_cast<EnumType const*>(&_convertTo))
-		return true;
-	else if (auto fixedPointType = dynamic_cast<FixedPointType const*>(&_convertTo))
-		return (isSigned() == fixedPointType->isSigned()) && (numBits() == fixedPointType->numBits());
 
 	return false;
 }
@@ -673,12 +699,27 @@ bool IntegerType::operator==(Type const& _other) const
 	return other.m_bits == m_bits && other.m_modifier == m_modifier;
 }
 
-string IntegerType::toString(bool) const
+std::string IntegerType::toString(bool) const
 {
-	string prefix = isSigned() ? "int" : "uint";
+	std::string prefix = isSigned() ? "int" : "uint";
 	return prefix + util::toString(m_bits);
 }
 
+MemberList::MemberMap IntegerType::nativeMembers(ASTNode const*) const {
+	MemberList::MemberMap members = {
+		{"cast", TypeProvider::function(
+			TypePointers{},
+			TypePointers{},
+			strings{},
+			strings{},
+			FunctionType::Kind::IntCast,
+			StateMutability::Pure,
+			nullptr, FunctionType::Options::withArbitraryParameters()
+		)}
+	};
+	return members;
+}
+
 u256 IntegerType::min() const
 {
 	if (isSigned())
@@ -765,15 +806,15 @@ FixedPointType::FixedPointType(unsigned _totalBits, unsigned _fractionalDigits,
 	m_totalBits(_totalBits), m_fractionalDigits(_fractionalDigits), m_modifier(_modifier)
 {
 	solAssert(
-		8 <= m_totalBits && m_totalBits <= 256 && m_totalBits % 8 == 0 && m_fractionalDigits <= 80,
+		8 <= m_totalBits && m_totalBits <= 256 && m_fractionalDigits <= 80,
 		"Invalid bit number(s) for fixed type: " +
 		util::toString(_totalBits) + "x" + util::toString(_fractionalDigits)
 	);
 }
 
-string FixedPointType::richIdentifier() const
+std::string FixedPointType::richIdentifier() const
 {
-	return "t_" + string(isSigned() ? "" : "u") + "fixed" + to_string(m_totalBits) + "x" + to_string(m_fractionalDigits);
+	return "t_" + std::string(isSigned() ? "" : "u") + "fixed" + std::to_string(m_totalBits) + "x" + std::to_string(m_fractionalDigits);
 }
 
 BoolResult FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const
@@ -804,16 +845,17 @@ BoolResult FixedPointType::isExplicitlyConvertibleTo(Type const& _convertTo) con
 
 TypeResult FixedPointType::unaryOperatorResult(Token _operator) const
 {
+	solAssert(_operator != Token::Add);
+
 	switch (_operator)
 	{
 	case Token::Delete:
 		// "delete" is ok for all fixed types
 		return TypeResult{TypeProvider::emptyTuple()};
-	case Token::Add:
 	case Token::Sub:
 	case Token::Inc:
 	case Token::Dec:
-		// for fixed, we allow +, -, ++ and --
+		// for fixed, we allow -, ++ and --
 		return this;
 	default:
 		return nullptr;
@@ -828,9 +870,9 @@ bool FixedPointType::operator==(Type const& _other) const
 	return other.m_totalBits == m_totalBits && other.m_fractionalDigits == m_fractionalDigits && other.m_modifier == m_modifier;
 }
 
-string FixedPointType::toString(bool) const
+std::string FixedPointType::toString(bool) const
 {
-	string prefix = isSigned() ? "fixed" : "ufixed";
+	std::string prefix = isSigned() ? "fixed" : "ufixed";
 	return prefix + util::toString(m_totalBits) + "x" + util::toString(m_fractionalDigits);
 }
 
@@ -871,7 +913,7 @@ IntegerType const* FixedPointType::asIntegerType() const
 	return TypeProvider::integer(numBits(), isSigned() ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned);
 }
 
-tuple<bool, rational> RationalNumberType::parseRational(string const& _value)
+std::tuple<bool, rational> RationalNumberType::parseRational(std::string const& _value)
 {
 	rational value;
 	try
@@ -884,7 +926,7 @@ tuple<bool, rational> RationalNumberType::parseRational(string const& _value)
 				!all_of(radixPoint + 1, _value.end(), util::isDigit) ||
 				!all_of(_value.begin(), radixPoint, util::isDigit)
 			)
-				return make_tuple(false, rational(0));
+				return std::make_tuple(false, rational(0));
 
 			// Only decimal notation allowed here, leading zeros would switch to octal.
 			auto fractionalBegin = find_if_not(
@@ -896,25 +938,25 @@ tuple<bool, rational> RationalNumberType::parseRational(string const& _value)
 			rational numerator;
 			rational denominator(1);
 
-			denominator = bigint(string(fractionalBegin, _value.end()));
+			denominator = bigint(std::string(fractionalBegin, _value.end()));
 			denominator /= boost::multiprecision::pow(
 				bigint(10),
 				static_cast<unsigned>(distance(radixPoint + 1, _value.end()))
 			);
-			numerator = bigint(string(_value.begin(), radixPoint));
+			numerator = bigint(std::string(_value.begin(), radixPoint));
 			value = numerator + denominator;
 		}
 		else
 			value = bigint(_value);
-		return make_tuple(true, value);
+		return std::make_tuple(true, value);
 	}
 	catch (...)
 	{
-		return make_tuple(false, rational(0));
+		return std::make_tuple(false, rational(0));
 	}
 }
 
-tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)
+std::tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)
 {
 	rational value;
 	try
@@ -933,27 +975,27 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
 		else if (expPoint != valueString.end())
 		{
 			// Parse mantissa and exponent. Checks numeric limit.
-			tuple<bool, rational> mantissa = parseRational(string(valueString.begin(), expPoint));
+			std::tuple<bool, rational> mantissa = parseRational(std::string(valueString.begin(), expPoint));
 
-			if (!get<0>(mantissa))
-				return make_tuple(false, rational(0));
-			value = get<1>(mantissa);
+			if (!std::get<0>(mantissa))
+				return std::make_tuple(false, rational(0));
+			value = std::get<1>(mantissa);
 
 			// 0E... is always zero.
 			if (value == 0)
-				return make_tuple(true, rational(0));
+				return std::make_tuple(true, rational(0));
 
-			bigint exp = bigint(string(expPoint + 1, valueString.end()));
+			bigint exp = bigint(std::string(expPoint + 1, valueString.end()));
 
-			if (exp > numeric_limits<int32_t>::max() || exp < numeric_limits<int32_t>::min())
-				return make_tuple(false, rational(0));
+			if (exp > std::numeric_limits<int32_t>::max() || exp < std::numeric_limits<int32_t>::min())
+				return std::make_tuple(false, rational(0));
 
 			uint32_t expAbs = bigint(abs(exp)).convert_to<uint32_t>();
 
 			if (exp < 0)
 			{
 				if (!fitsPrecisionBase10(abs(value.denominator()), expAbs))
-					return make_tuple(false, rational(0));
+					return std::make_tuple(false, rational(0));
 				value /= boost::multiprecision::pow(
 					bigint(10),
 					expAbs
@@ -962,7 +1004,7 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
 			else if (exp > 0)
 			{
 				if (!fitsPrecisionBase10(abs(value.numerator()), expAbs))
-					return make_tuple(false, rational(0));
+					return std::make_tuple(false, rational(0));
 				value *= boost::multiprecision::pow(
 					bigint(10),
 					expAbs
@@ -972,15 +1014,15 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
 		else
 		{
 			// parse as rational number
-			tuple<bool, rational> tmp = parseRational(valueString);
-			if (!get<0>(tmp))
+			std::tuple<bool, rational> tmp = parseRational(valueString);
+			if (!std::get<0>(tmp))
 				return tmp;
-			value = get<1>(tmp);
+			value = std::get<1>(tmp);
 		}
 	}
 	catch (...)
 	{
-		return make_tuple(false, rational(0));
+		return std::make_tuple(false, rational(0));
 	}
 	switch (_literal.subDenomination())
 	{
@@ -1043,7 +1085,7 @@ tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal
 	}
 
 
-	return make_tuple(true, value);
+	return std::make_tuple(true, value);
 }
 
 BoolResult RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo) const
@@ -1115,7 +1157,7 @@ BoolResult RationalNumberType::isExplicitlyConvertibleTo(Type const& _convertTo)
 
 TypeResult RationalNumberType::unaryOperatorResult(Token _operator) const
 {
-	if (optional<rational> value = ConstantEvaluator::evaluateUnaryOperator(_operator, m_value))
+	if (std::optional<rational> value = ConstantEvaluator::evaluateUnaryOperator(_operator, m_value))
 		return TypeResult{TypeProvider::rationalNumber(*value)};
 	else
 		return nullptr;
@@ -1173,10 +1215,10 @@ TypeResult RationalNumberType::binaryOperatorResult(Token _operator, Type const*
 			return nullptr;
 		return thisMobile->binaryOperatorResult(_operator, otherMobile);
 	}
-	else if (optional<rational> value = ConstantEvaluator::evaluateBinaryOperator(_operator, m_value, other.m_value))
+	else if (std::optional<rational> value = ConstantEvaluator::evaluateBinaryOperator(_operator, m_value, other.m_value))
 	{
 		// verify that numerator and denominator fit into 4096 bit after every operation
-		if (value->numerator() != 0 && max(boost::multiprecision::msb(abs(value->numerator())), boost::multiprecision::msb(abs(value->denominator()))) > 4096)
+		if (value->numerator() != 0 && std::max(boost::multiprecision::msb(abs(value->numerator())), boost::multiprecision::msb(abs(value->denominator()))) > 4096)
 			return TypeResult::err("Precision of rational constants is limited to 4096 bits.");
 
 		return TypeResult{TypeProvider::rationalNumber(*value)};
@@ -1185,7 +1227,7 @@ TypeResult RationalNumberType::binaryOperatorResult(Token _operator, Type const*
 		return nullptr;
 }
 
-string RationalNumberType::richIdentifier() const
+std::string RationalNumberType::richIdentifier() const
 {
 	// rational seemingly will put the sign always on the numerator,
 	// but let just make it deterministic here.
@@ -1205,24 +1247,24 @@ bool RationalNumberType::operator==(Type const& _other) const
 	return m_value == other.m_value;
 }
 
-string RationalNumberType::bigintToReadableString(bigint const& _num)
+std::string RationalNumberType::bigintToReadableString(bigint const& _num)
 {
-	string str = _num.str();
+	std::string str = _num.str();
 	if (str.size() > 32)
 	{
 		size_t omitted = str.size() - 8;
-		str = str.substr(0, 4) + "...(" + to_string(omitted) + " digits omitted)..." + str.substr(str.size() - 4, 4);
+		str = str.substr(0, 4) + "...(" + std::to_string(omitted) + " digits omitted)..." + str.substr(str.size() - 4, 4);
 	}
 	return str;
 }
 
-string RationalNumberType::toString(bool) const
+std::string RationalNumberType::toString(bool) const
 {
 	if (!isFractional())
 		return "int_const " + bigintToReadableString(m_value.numerator());
 
-	string numerator = bigintToReadableString(m_value.numerator());
-	string denominator = bigintToReadableString(m_value.denominator());
+	std::string numerator = bigintToReadableString(m_value.numerator());
+	std::string denominator = bigintToReadableString(m_value.denominator());
 	return "rational_const " + numerator + " / " + denominator;
 }
 
@@ -1290,7 +1332,7 @@ IntegerType const* RationalNumberType::integerType() const
 		return nullptr;
 	else
 		return TypeProvider::integer(
-			max(numberEncodingSize(value), 1u) * 8,
+			std::max(numberEncodingSize(value), 1u) * 8,
 			negative ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned
 		);
 }
@@ -1324,7 +1366,7 @@ FixedPointType const* RationalNumberType::fixedPointType() const
 	if (v > u256(-1))
 		return nullptr;
 
-	unsigned totalBits = max(numberEncodingSize(v), 1u) * 8;
+	unsigned totalBits = std::max(numberEncodingSize(v), 1u) * 8;
 	solAssert(totalBits <= 256, "");
 
 	return TypeProvider::fixedPoint(
@@ -1338,7 +1380,7 @@ StringLiteralType::StringLiteralType(Literal const& _literal):
 {
 }
 
-StringLiteralType::StringLiteralType(string _value):
+StringLiteralType::StringLiteralType(std::string _value):
 	m_value{std::move(_value)}
 {
 }
@@ -1371,9 +1413,9 @@ BoolResult StringLiteralType::isImplicitlyConvertibleTo(Type const& _convertTo)
 		return false;
 }
 
-string StringLiteralType::richIdentifier() const
+std::string StringLiteralType::richIdentifier() const
 {
-	// Since we have to return a valid identifier and the string itself may contain
+	// Since we have to return a valid identifier and the std::string itself may contain
 	// anything, we hash it.
 	return "t_stringliteral_" + util::toHex(util::keccak256(m_value).asBytes());
 }
@@ -1387,7 +1429,7 @@ bool StringLiteralType::operator==(Type const& _other) const
 
 std::string StringLiteralType::toString(bool) const
 {
-	auto isPrintableASCII = [](string const& s)
+	auto isPrintableASCII = [](std::string const& s)
 	{
 		for (auto c: s)
 		{
@@ -1451,8 +1493,6 @@ BoolResult FixedBytesType::isExplicitlyConvertibleTo(Type const& _convertTo) con
 		return (!integerType->isSigned() && integerType->numBits() == numBytes() * 8);
 	else if (dynamic_cast<AddressType const*>(&_convertTo))
 		return numBytes() == 32;
-	else if (auto fixedPointType = dynamic_cast<FixedPointType const*>(&_convertTo))
-		return fixedPointType->numBits() == numBytes() * 8;
 
 	return false;
 }
@@ -1499,9 +1539,9 @@ MemberList::MemberMap FixedBytesType::nativeMembers(ASTNode const*) const
 	return MemberList::MemberMap{MemberList::Member{"length", TypeProvider::uint(8)}};
 }
 
-string FixedBytesType::richIdentifier() const
+std::string FixedBytesType::richIdentifier() const
 {
-	return "t_bytes" + to_string(m_bytes);
+	return "t_bytes" + std::to_string(m_bytes);
 }
 
 bool FixedBytesType::operator==(Type const& _other) const
@@ -1601,10 +1641,10 @@ TypeResult ContractType::unaryOperatorResult(Token _operator) const
 		return nullptr;
 }
 
-vector<Type const*> CompositeType::fullDecomposition() const
+std::vector<Type const*> CompositeType::fullDecomposition() const
 {
-	vector<Type const*> res = {this};
-	unordered_set<string> seen = {richIdentifier()};
+	std::vector<Type const*> res = {this};
+	std::unordered_set<std::string> seen = {richIdentifier()};
 	for (size_t k = 0; k < res.size(); ++k)
 		if (auto composite = dynamic_cast<CompositeType const*>(res[k]))
 			for (Type const* next: composite->decomposition())
@@ -1616,38 +1656,15 @@ vector<Type const*> CompositeType::fullDecomposition() const
 	return res;
 }
 
-Type const* ReferenceType::withLocation(bool _isPointer) const
-{
-	return TypeProvider::withLocation(this, _isPointer);
-}
-
-TypeResult ReferenceType::unaryOperatorResult(Token _operator) const
-{
+TypeResult CompositeType::unaryOperatorResult(Token _operator) const {
 	if (_operator != Token::Delete)
 		return nullptr;
 	return TypeProvider::emptyTuple();
-}
 
-bool ReferenceType::isPointer() const
-{
-	return m_isPointer;
-}
-
-Type const* ReferenceType::copyForLocationIfReference(Type const* _type) const
-{
-	return TypeProvider::withLocationIfReference(_type);
-}
-
-string ReferenceType::identifierLocationSuffix() const
-{
-	string id;
-	if (isPointer())
-		id += "_ptr";
-	return id;
 }
 
 ArrayType::ArrayType(bool _isString):
-	ReferenceType(),
+	CompositeType(),
 	m_arrayKind(_isString ? ArrayKind::String : ArrayKind::Bytes),
 	m_baseType{TypeProvider::byte()}
 {
@@ -1711,7 +1728,7 @@ BoolResult ArrayType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 	if (isByteArray() && _convertTo.category() == Category::FixedBytes)
 		return true;
 
-	// allow conversion bytes <-> string and bytes -> bytesNN
+	// allow conversion bytes <-> std::string and bytes -> bytesNN
 	if (_convertTo.category() != category())
 		return isByteArrayOrString() && _convertTo.category() == Type::Category::FixedBytes;
 	auto& convertTo = dynamic_cast<ArrayType const&>(_convertTo);
@@ -1720,9 +1737,9 @@ BoolResult ArrayType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 	return true;
 }
 
-string ArrayType::richIdentifier() const
+std::string ArrayType::richIdentifier() const
 {
-	string id;
+	std::string id;
 	if (isString())
 		id = "t_string";
 	else if (isByteArrayOrString())
@@ -1736,7 +1753,6 @@ string ArrayType::richIdentifier() const
 		else
 			id += length().str();
 	}
-	id += identifierLocationSuffix();
 
 	return id;
 }
@@ -1747,7 +1763,6 @@ bool ArrayType::operator==(Type const& _other) const
 		return false;
 	ArrayType const& other = dynamic_cast<ArrayType const&>(_other);
 	if (
-		!ReferenceType::operator==(other) ||
 		other.isByteArray() != isByteArray() ||
 		other.isString() != isString() ||
 		other.isDynamicallySized() != isDynamicallySized()
@@ -1771,7 +1786,7 @@ unsigned ArrayType::calldataEncodedSize(bool _padded) const
 {
 	solAssert(!isDynamicallyEncoded(), "");
 	bigint size = unlimitedStaticCalldataSize(_padded);
-	solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
+	solAssert(size <= std::numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
 	return unsigned(size);
 }
 
@@ -1783,7 +1798,7 @@ unsigned ArrayType::calldataEncodedTailSize() const
 		// length must still be present.
 		return 32;
 	bigint size = unlimitedStaticCalldataSize(false);
-	solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
+	solAssert(size <= std::numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
 	return unsigned(size);
 }
 
@@ -1817,17 +1832,17 @@ u256 ArrayType::storageSize() const
 	else
 		size = bigint(length()) * baseType()->storageSize();
 	solAssert(size < bigint(1) << 256, "Array too large for storage.");
-	return max<u256>(1, u256(size));
+	return std::max<u256>(1, u256(size));
 }
 
-vector<tuple<string, Type const*>> ArrayType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> ArrayType::makeStackItems() const
 {
 	return {std::make_tuple("slot", TypeProvider::uint256())};
 }
 
-string ArrayType::toString(bool _withoutDataLocation) const
+std::string ArrayType::toString(bool _withoutDataLocation) const
 {
-	string ret;
+	std::string ret;
 	if (isString())
 		ret = "string";
 	else if (isByteArrayOrString())
@@ -1842,9 +1857,9 @@ string ArrayType::toString(bool _withoutDataLocation) const
 	return ret;
 }
 
-string ArrayType::humanReadableName() const
+std::string ArrayType::humanReadableName() const
 {
-	string ret;
+	std::string ret;
 	if (isString())
 		ret = "string";
 	else if (isByteArrayOrString())
@@ -1859,9 +1874,9 @@ string ArrayType::humanReadableName() const
 	return ret;
 }
 
-string ArrayType::canonicalName() const
+std::string ArrayType::canonicalName() const
 {
-	string ret;
+	std::string ret;
 	if (isString())
 		ret = "string";
 	else if (isByteArrayOrString())
@@ -1876,7 +1891,7 @@ string ArrayType::canonicalName() const
 	return ret;
 }
 
-string ArrayType::signatureInExternalFunction(bool _structsByName) const
+std::string ArrayType::signatureInExternalFunction(bool _structsByName) const
 {
 	if (isByteArrayOrString())
 		return canonicalName();
@@ -1943,7 +1958,7 @@ MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
 		members.emplace_back("append", TypeProvider::function(
 				TypePointers{isString() ? TypeProvider::stringMemory() : TypeProvider::bytesMemory()},
 				TypePointers{},
-				strings{string("tail")},
+				strings{std::string("tail")},
 				strings{},
 				FunctionType::Kind::StringMethod,
 				StateMutability::Pure
@@ -1964,7 +1979,7 @@ MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
 		members.emplace_back("push", TypeProvider::function(
 			TypePointers{baseType()},
 			TypePointers{},
-			strings{string()},
+			strings{std::string()},
 			strings{},
 			isByteArray() ? FunctionType::Kind::ByteArrayPush : FunctionType::Kind::ArrayPush,
 			StateMutability::Pure
@@ -1977,20 +1992,42 @@ MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
 			FunctionType::Kind::ArrayPop,
 			StateMutability::Pure
 		));
+		// TODO DELETE UNCOMMENT?
+//		members.emplace_back("push", TypeProvider::function(
+//			TypePointers{thisAsPointer},
+//			TypePointers{baseType()},
+//			strings{std::string()},
+//			strings{std::string()},
+//			FunctionType::Kind::ArrayPush
+//		)->withBoundFirstArgument());
+//		members.emplace_back("push", TypeProvider::function(
+//			TypePointers{thisAsPointer, baseType()},
+//			TypePointers{},
+//			strings{std::string(),std::string()},
+//			strings{},
+//			FunctionType::Kind::ArrayPush
+//		)->withBoundFirstArgument());
+//		members.emplace_back("pop", TypeProvider::function(
+//			TypePointers{thisAsPointer},
+//			TypePointers{},
+//			strings{std::string()},
+//			strings{},
+//			FunctionType::Kind::ArrayPop
+//		)->withBoundFirstArgument());
 	} else {
 		members.emplace_back("substr", TypeProvider::function(
 			TypePointers{TypeProvider::uint256()},
 			TypePointers{TypeProvider::stringMemory()},
-			strings{string("from")},
-			strings{string("substr")},
+			strings{std::string("from")},
+			strings{std::string("substr")},
 			FunctionType::Kind::StringSubstr,
 			StateMutability::Pure
 		));
 		members.emplace_back("substr", TypeProvider::function(
 			TypePointers{TypeProvider::uint256(), TypeProvider::uint256()},
 			TypePointers{TypeProvider::stringMemory()},
-			strings{string("from"), "to"},
-			strings{string("substr")},
+			strings{std::string("from"), "to"},
+			strings{std::string("substr")},
 			FunctionType::Kind::StringSubstr,
 			StateMutability::Pure
 		));
@@ -1998,7 +2035,7 @@ MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
 			TypePointers{},
 			TypePointers{TypeProvider::uint(32)},
 			strings{},
-			strings{string("byteLength")},
+			strings{std::string("byteLength")},
 			FunctionType::Kind::StringMethod,
 			StateMutability::Pure
 		));
@@ -2006,42 +2043,17 @@ MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
 			members.emplace_back(name.c_str(), TypeProvider::function(
 				TypePointers{TypeProvider::fixedBytes(1)},
 				TypePointers{TypeProvider::optional(TypeProvider::uint(32))},
-				strings{string("symbol")},
-				strings{string("pos")},
+				strings{std::string("symbol")},
+				strings{std::string("pos")},
 				FunctionType::Kind::StringMethod,
 				StateMutability::Pure
 			));
-			// TODO DELETE OR SUPPORT
-//		if (isDynamicallySized() && location() == DataLocation::Storage)
-//		{
-//			Type const* thisAsPointer = TypeProvider::withLocation(this, location(), true);
-//			members.emplace_back("push", TypeProvider::function(
-//				TypePointers{thisAsPointer},
-//				TypePointers{baseType()},
-//				strings{string()},
-//				strings{string()},
-//				FunctionType::Kind::ArrayPush
-//			)->asBoundFunction());
-//			members.emplace_back("push", TypeProvider::function(
-//				TypePointers{thisAsPointer, baseType()},
-//				TypePointers{},
-//				strings{string(),string()},
-//				strings{},
-//				FunctionType::Kind::ArrayPush
-//			)->asBoundFunction());
-//			members.emplace_back("pop", TypeProvider::function(
-//				TypePointers{thisAsPointer},
-//				TypePointers{},
-//				strings{string()},
-//				strings{},
-//				FunctionType::Kind::ArrayPop
-//			)->asBoundFunction());
 		}
 		members.emplace_back("find", TypeProvider::function(
 			TypePointers{TypeProvider::stringMemory()},
 			TypePointers{TypeProvider::optional(TypeProvider::uint(32))},
-			strings{string("substr")},
-			strings{string("pos")},
+			strings{std::string("substr")},
+			strings{std::string("pos")},
 			FunctionType::Kind::StringMethod,
 			StateMutability::Pure
 		));
@@ -2126,8 +2138,8 @@ static void appendMapMethods(MemberList::MemberMap& members, Type const* keyType
 			TypeProvider::function(
 				TypePointers{keyType},
 				TypePointers{TypeProvider::optional(valueType)},
-				strings{string{}},
-				strings{string{}},
+				strings{std::string{}},
+				strings{std::string{}},
 				FunctionType::Kind::MappingFetch,
 				StateMutability::Pure
 			)
@@ -2136,8 +2148,8 @@ static void appendMapMethods(MemberList::MemberMap& members, Type const* keyType
 	members.emplace_back("exists", TypeProvider::function(
 			TypePointers{keyType},
 			TypePointers{TypeProvider::boolean()},
-			strings{string()},
-			strings{string()},
+			strings{std::string()},
+			strings{std::string()},
 			FunctionType::Kind::MappingExists,
 			StateMutability::Pure
 	));
@@ -2145,7 +2157,7 @@ static void appendMapMethods(MemberList::MemberMap& members, Type const* keyType
 			TypePointers{},
 			TypePointers{TypeProvider::boolean()},
 			strings{},
-			strings{string()},
+			strings{std::string()},
 			FunctionType::Kind::MappingEmpty,
 			StateMutability::Pure
 	));
@@ -2153,8 +2165,8 @@ static void appendMapMethods(MemberList::MemberMap& members, Type const* keyType
 		members.emplace_back(name.c_str(), TypeProvider::function(
 				TypePointers{keyType, valueType},
 				TypePointers{TypeProvider::boolean()},
-				strings{string(), string()},
-				strings{string()},
+				strings{std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::MappingReplaceOrAdd,
 				StateMutability::Pure
 		));
@@ -2163,8 +2175,8 @@ static void appendMapMethods(MemberList::MemberMap& members, Type const* keyType
 		members.emplace_back(name.c_str(), TypeProvider::function(
 				TypePointers{keyType, valueType},
 				TypePointers{TypeProvider::optional(valueType)},
-				strings{string(), string()},
-				strings{string()},
+				strings{std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::MappingGetSet,
 				StateMutability::Pure
 		));
@@ -2180,7 +2192,7 @@ MemberList::MemberMap MappingType::nativeMembers(ASTNode const*) const
 
 Type const* ArrayType::encodingType() const
 {
-	return TypeProvider::withLocation(this, true);
+	return this;
 }
 
 Type const* ArrayType::decodingType() const
@@ -2199,7 +2211,7 @@ TypeResult ArrayType::interfaceType(bool) const
 		result = baseInterfaceType;
 	}
 	else if (m_arrayKind != ArrayKind::Ordinary)
-		result = TypeProvider::withLocation(this, true);
+		result = this;
 	else if (isDynamicallySized())
 		result = TypeProvider::array(baseInterfaceType);
 	else
@@ -2229,21 +2241,10 @@ u256 ArrayType::memoryDataSize() const
 	solAssert(!isDynamicallySized(), "");
 	solAssert(!isByteArrayOrString(), "");
 	bigint size = bigint(m_length) * m_baseType->memoryHeadSize();
-	solAssert(size <= numeric_limits<u256>::max(), "Array size does not fit u256.");
+	solAssert(size <= std::numeric_limits<u256>::max(), "Array size does not fit u256.");
 	return u256(size);
 }
 
-std::unique_ptr<ReferenceType> ArrayType::copyForLocation(bool _isPointer) const
-{
-	auto copy = make_unique<ArrayType>();
-	copy->m_isPointer = _isPointer;
-	copy->m_arrayKind = m_arrayKind;
-	copy->m_baseType = copy->copyForLocationIfReference(m_baseType);
-	copy->m_hasDynamicLength = m_hasDynamicLength;
-	copy->m_length = m_length;
-	return copy;
-}
-
 BoolResult ArraySliceType::isImplicitlyConvertibleTo(Type const& _other) const
 {
 	if (Type::isImplicitlyConvertibleTo(_other)) {
@@ -2262,7 +2263,7 @@ BoolResult ArraySliceType::isExplicitlyConvertibleTo(Type const& _convertTo) con
 		m_arrayType.isExplicitlyConvertibleTo(_convertTo);
 }
 
-string ArraySliceType::richIdentifier() const
+std::string ArraySliceType::richIdentifier() const
 {
 	return m_arrayType.richIdentifier() + "_slice";
 }
@@ -2274,12 +2275,12 @@ bool ArraySliceType::operator==(Type const& _other) const
 	return false;
 }
 
-string ArraySliceType::toString(bool _withoutDataLocation) const
+std::string ArraySliceType::toString(bool _withoutDataLocation) const
 {
 	return m_arrayType.toString(_withoutDataLocation) + " slice";
 }
 
-string ArraySliceType::humanReadableName() const
+std::string ArraySliceType::humanReadableName() const
 {
 	return m_arrayType.humanReadableName() + " slice";
 }
@@ -2301,9 +2302,9 @@ std::vector<std::tuple<std::string, Type const*>> ArraySliceType::makeStackItems
 	return {{"offset", TypeProvider::uint256()}, {"length", TypeProvider::uint256()}};
 }
 
-string ContractType::richIdentifier() const
+std::string ContractType::richIdentifier() const
 {
-	return (m_super ? "t_super" : "t_contract") + parenthesizeUserIdentifier(m_contract.name()) + to_string(m_contract.id());
+	return (m_super ? "t_super" : "t_contract") + parenthesizeUserIdentifier(m_contract.name()) + std::to_string(m_contract.id());
 }
 
 bool ContractType::operator==(Type const& _other) const
@@ -2314,15 +2315,15 @@ bool ContractType::operator==(Type const& _other) const
 	return other.m_contract == m_contract && other.m_super == m_super;
 }
 
-string ContractType::toString(bool) const
+std::string ContractType::toString(bool) const
 {
 	return
-		string(m_contract.isLibrary() ? "library " : "contract ") +
-		string(m_super ? "super " : "") +
+		std::string(m_contract.isLibrary() ? "library " : "contract ") +
+		std::string(m_super ? "super " : "") +
 		m_contract.name();
 }
 
-string ContractType::canonicalName() const
+std::string ContractType::canonicalName() const
 {
 	return *m_contract.annotation().canonicalName;
 }
@@ -2348,9 +2349,9 @@ FunctionType const* ContractType::newExpressionType() const
 	return m_constructorType;
 }
 
-vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVariables() const
+std::vector<std::tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVariables() const
 {
-	vector<VariableDeclaration const*> variables;
+	std::vector<VariableDeclaration const*> variables;
 	for (ContractDefinition const* contract: m_contract.annotation().linearizedBaseContracts | ranges::views::reverse)
 		for (VariableDeclaration const* variable: contract->stateVariables())
 			if (!(variable->isConstant() || variable->immutable()))
@@ -2361,16 +2362,16 @@ vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVar
 	StorageOffsets offsets;
 	offsets.computeOffsets(types);
 
-	vector<tuple<VariableDeclaration const*, u256, unsigned>> variablesAndOffsets;
+	std::vector<std::tuple<VariableDeclaration const*, u256, unsigned>> variablesAndOffsets;
 	for (size_t index = 0; index < variables.size(); ++index)
 		if (auto const* offset = offsets.offset(index))
 			variablesAndOffsets.emplace_back(variables[index], offset->first, offset->second);
 	return variablesAndOffsets;
 }
 
-vector<VariableDeclaration const*> ContractType::immutableVariables() const
+std::vector<VariableDeclaration const*> ContractType::immutableVariables() const
 {
-	vector<VariableDeclaration const*> variables;
+	std::vector<VariableDeclaration const*> variables;
 	for (ContractDefinition const* contract: m_contract.annotation().linearizedBaseContracts | ranges::views::reverse)
 		for (VariableDeclaration const* variable: contract->stateVariables())
 			if (variable->immutable())
@@ -2378,12 +2379,12 @@ vector<VariableDeclaration const*> ContractType::immutableVariables() const
 	return variables;
 }
 
-vector<tuple<string, Type const*>> ContractType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> ContractType::makeStackItems() const
 {
 	if (m_super)
 		return {};
 	else
-		return {make_tuple("address", TypeProvider::address())};
+		return {std::make_tuple("address", TypeProvider::address())};
 }
 
 void StructType::clearCache() const
@@ -2411,9 +2412,9 @@ BoolResult StructType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 	return this->m_struct == convertTo.m_struct;
 }
 
-string StructType::richIdentifier() const
+std::string StructType::richIdentifier() const
 {
-	return "t_struct" + parenthesizeUserIdentifier(m_struct.name()) + to_string(m_struct.id()) + identifierLocationSuffix();
+	return "t_struct" + parenthesizeUserIdentifier(m_struct.name()) + std::to_string(m_struct.id());
 }
 
 bool StructType::operator==(Type const& _other) const
@@ -2501,7 +2502,7 @@ bigint StructType::storageSizeUpperBound() const
 
 u256 StructType::storageSize() const
 {
-	return max<u256>(1, members(nullptr).storageSize());
+	return std::max<u256>(1, members(nullptr).storageSize());
 }
 
 bool StructType::containsNestedMapping() const
@@ -2540,9 +2541,9 @@ bool StructType::containsNestedMapping() const
 	return m_struct.annotation().containsNestedMapping.value();
 }
 
-string StructType::toString(bool /*_withoutDataLocation*/) const
+std::string StructType::toString(bool /*_withoutDataLocation*/) const
 {
-	string ret = "struct " + *m_struct.annotation().canonicalName;
+	std::string ret = "struct " + *m_struct.annotation().canonicalName;
 	return ret;
 }
 
@@ -2557,7 +2558,7 @@ MemberList::MemberMap StructType::onlyMembers() const
 		types.push_back(type);
 		members.emplace_back(
 			variable.get(),
-			copyForLocationIfReference(type)
+			type
 		);
 	}
 	return members;
@@ -2575,7 +2576,7 @@ MemberList::MemberMap StructType::nativeMembers(ASTNode const*) const
 		types.push_back(type);
 		members.emplace_back(
 			variable.get(),
-			copyForLocationIfReference(type)
+			type
 		);
 	}
 	members.emplace_back("unpack", TypeProvider::function(
@@ -2600,21 +2601,14 @@ bool StructType::recursive() const
 	return *m_struct.annotation().recursive;
 }
 
-std::unique_ptr<ReferenceType> StructType::copyForLocation(bool _isPointer) const
-{
-	auto copy = make_unique<StructType>(m_struct);
-	copy->m_isPointer = _isPointer;
-	return copy;
-}
-
-string StructType::signatureInExternalFunction(bool _structsByName) const
+std::string StructType::signatureInExternalFunction(bool _structsByName) const
 {
 	if (_structsByName)
 		return canonicalName();
 	else
 	{
 		TypePointers memberTypes = memoryMemberTypes();
-		auto memberTypeStrings = memberTypes | ranges::views::transform([&](Type const* _t) -> string
+		auto memberTypeStrings = memberTypes | ranges::views::transform([&](Type const* _t) -> std::string
 		{
 			solAssert(_t, "Parameter should have external type.");
 			auto t = _t->interfaceType(_structsByName);
@@ -2625,7 +2619,7 @@ string StructType::signatureInExternalFunction(bool _structsByName) const
 	}
 }
 
-string StructType::canonicalName() const
+std::string StructType::canonicalName() const
 {
 	return *m_struct.annotation().canonicalName;
 }
@@ -2637,25 +2631,25 @@ FunctionTypePointer StructType::constructorType() const
 	for (auto const& member: onlyMembers())
 	{
 		paramNames.push_back(member.name);
-		paramTypes.push_back(TypeProvider::withLocationIfReference(member.type));
+		paramTypes.push_back(member.type);
 	}
 	return TypeProvider::function(
 		paramTypes,
-		TypePointers{TypeProvider::withLocation(this, false)},
+		TypePointers{this},
 		paramNames,
 		strings(1, ""),
 		FunctionType::Kind::Internal
 	);
 }
 
-pair<u256, unsigned> const& StructType::storageOffsetsOfMember(string const& _name) const
+std::pair<u256, unsigned> const& StructType::storageOffsetsOfMember(std::string const& _name) const
 {
 	auto const* offsets = members(nullptr).memberStorageOffset(_name);
 	solAssert(offsets, "Storage offset of non-existing member requested.");
 	return *offsets;
 }
 
-u256 StructType::memoryOffsetOfMember(string const& _name) const
+u256 StructType::memoryOffsetOfMember(std::string const& _name) const
 {
 	u256 offset;
 	for (auto const& member: members(nullptr))
@@ -2672,19 +2666,19 @@ TypePointers StructType::memoryMemberTypes() const
 	solAssert(!containsNestedMapping(), "");
 	TypePointers types;
 	for (ASTPointer<VariableDeclaration> const& variable: m_struct.members())
-		types.push_back(TypeProvider::withLocationIfReference(variable->annotation().type));
+		types.push_back(variable->annotation().type);
 
 	return types;
 }
 
-vector<tuple<string, Type const*>> StructType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> StructType::makeStackItems() const
 {
 	return {std::make_tuple("slot", TypeProvider::uint256())};
 }
 
-vector<Type const*> StructType::decomposition() const
+std::vector<Type const*> StructType::decomposition() const
 {
-	vector<Type const*> res;
+	std::vector<Type const*> res;
 	for (MemberList::Member const& member: members(nullptr))
 		res.push_back(member.type);
 	return res;
@@ -2706,9 +2700,9 @@ TypeResult EnumType::unaryOperatorResult(Token _operator) const
 	return _operator == Token::Delete ? TypeProvider::emptyTuple() : nullptr;
 }
 
-string EnumType::richIdentifier() const
+std::string EnumType::richIdentifier() const
 {
-	return "t_enum" + parenthesizeUserIdentifier(m_enum.name()) + to_string(m_enum.id());
+	return "t_enum" + parenthesizeUserIdentifier(m_enum.name()) + std::to_string(m_enum.id());
 }
 
 bool EnumType::operator==(Type const& _other) const
@@ -2725,12 +2719,12 @@ unsigned EnumType::storageBytes() const
 	return 1;
 }
 
-string EnumType::toString(bool) const
+std::string EnumType::toString(bool) const
 {
-	return string("enum ") + *m_enum.annotation().canonicalName;
+	return std::string("enum ") + *m_enum.annotation().canonicalName;
 }
 
-string EnumType::canonicalName() const
+std::string EnumType::canonicalName() const
 {
 	return *m_enum.annotation().canonicalName;
 }
@@ -2774,9 +2768,9 @@ Declaration const* UserDefinedValueType::typeDefinition() const
 	return &m_definition;
 }
 
-string UserDefinedValueType::richIdentifier() const
+std::string UserDefinedValueType::richIdentifier() const
 {
-	return "t_userDefinedValueType" + parenthesizeIdentifier(m_definition.name()) + to_string(m_definition.id());
+	return "t_userDefinedValueType" + parenthesizeIdentifier(m_definition.name()) + std::to_string(m_definition.id());
 }
 
 bool UserDefinedValueType::operator==(Type const& _other) const
@@ -2787,17 +2781,17 @@ bool UserDefinedValueType::operator==(Type const& _other) const
 	return other.definition() == definition();
 }
 
-string UserDefinedValueType::toString(bool /* _withoutDataLocation */) const
+std::string UserDefinedValueType::toString(bool /* _withoutDataLocation */) const
 {
 	return *definition().annotation().canonicalName;
 }
 
-string UserDefinedValueType::canonicalName() const
+std::string UserDefinedValueType::canonicalName() const
 {
 	return *definition().annotation().canonicalName;
 }
 
-vector<tuple<string, Type const*>> UserDefinedValueType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> UserDefinedValueType::makeStackItems() const
 {
 	return underlyingType().stackItems();
 }
@@ -2826,7 +2820,7 @@ BoolResult TupleType::isImplicitlyConvertibleTo(Type const& _other) const
 		return false;
 }
 
-string TupleType::richIdentifier() const
+std::string TupleType::richIdentifier() const
 {
 	return "t_tuple" + identifierList(components());
 }
@@ -2846,22 +2840,22 @@ bool TupleType::operator==(Type const& _other) const
 	return false;
 }
 
-string TupleType::toString(bool _withoutDataLocation) const
+std::string TupleType::toString(bool _withoutDataLocation) const
 {
 	if (components().empty())
 		return "tuple()";
-	string str = "tuple(";
+	std::string str = "tuple(";
 	for (auto const& t: components())
 		str += (t ? t->toString(_withoutDataLocation) : "") + ",";
 	str.pop_back();
 	return str + ")";
 }
 
-string TupleType::humanReadableName() const
+std::string TupleType::humanReadableName() const
 {
 	if (components().empty())
 		return "tuple()";
-	string str = "tuple(";
+	std::string str = "tuple(";
 	for (auto const& t: components())
 		str += (t ? t->humanReadableName() : "") + ",";
 	str.pop_back();
@@ -2873,9 +2867,9 @@ u256 TupleType::storageSize() const
 	solAssert(false, "Storage size of non-storable tuple type requested.");
 }
 
-vector<tuple<string, Type const*>> TupleType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> TupleType::makeStackItems() const
 {
-	vector<tuple<string, Type const*>> slots;
+	std::vector<std::tuple<std::string, Type const*>> slots;
 	unsigned i = 1;
 	for (auto const& t: components())
 	{
@@ -2946,14 +2940,16 @@ FunctionType::FunctionType(VariableDeclaration const& _varDecl):
 	m_declaration(&_varDecl)
 {
 	auto returnType = _varDecl.annotation().type;
+	ASTString returnName;
 
 	while (true)
 	{
 		if (auto mappingType = dynamic_cast<MappingType const*>(returnType))
 		{
 			m_parameterTypes.push_back(mappingType->keyType());
-			m_parameterNames.emplace_back("");
+			m_parameterNames.push_back(mappingType->keyName());
 			returnType = mappingType->valueType();
+			returnName = mappingType->valueName();
 		}
 		else if (auto arrayType = dynamic_cast<ArrayType const*>(returnType))
 		{
@@ -2978,19 +2974,15 @@ FunctionType::FunctionType(VariableDeclaration const& _varDecl):
 				if (auto arrayType = dynamic_cast<ArrayType const*>(member.type))
 					if (!arrayType->isByteArrayOrString())
 						continue;
-				m_returnParameterTypes.push_back(TypeProvider::withLocationIfReference(
-					member.type
-				));
+				m_returnParameterTypes.push_back(member.type);
 				m_returnParameterNames.push_back(member.name);
 			}
 		}
 	}
 	else
 	{
-		m_returnParameterTypes.push_back(TypeProvider::withLocationIfReference(
-			returnType
-		));
-		m_returnParameterNames.emplace_back("");
+		m_returnParameterTypes.push_back(returnType);
+		m_returnParameterNames.emplace_back(returnName);
 	}
 
 	solAssert(
@@ -3102,11 +3094,11 @@ FunctionTypePointer FunctionType::newExpressionType(ContractDefinition const& _c
 	);
 }
 
-vector<string> FunctionType::parameterNames() const
+std::vector<std::string> FunctionType::parameterNames() const
 {
-	if (!bound())
+	if (!hasBoundFirstArgument())
 		return m_parameterNames;
-	return vector<string>(m_parameterNames.cbegin() + 1, m_parameterNames.cend());
+	return std::vector<std::string>(m_parameterNames.cbegin() + 1, m_parameterNames.cend());
 }
 
 TypePointers FunctionType::returnParameterTypesWithoutDynamicTypes() const
@@ -3133,7 +3125,7 @@ TypePointers FunctionType::returnParameterTypesWithoutDynamicTypes() const
 
 TypePointers FunctionType::parameterTypes() const
 {
-	if (!bound())
+	if (!hasBoundFirstArgument())
 		return m_parameterTypes;
 	return TypePointers(m_parameterTypes.cbegin() + 1, m_parameterTypes.cend());
 }
@@ -3143,11 +3135,13 @@ TypePointers const& FunctionType::parameterTypesIncludingSelf() const
 	return m_parameterTypes;
 }
 
-string FunctionType::richIdentifier() const
+std::string FunctionType::richIdentifier() const
 {
-	string id = "t_function_";
+	std::string id = "t_function_";
 	switch (m_kind)
 	{
+	case Kind::IntCast: id += "integercast"; break;
+
 	case Kind::StructUnpack: id += "structunpack"; break;
 
 	case Kind::OptionalGet: id += "optionalmethod"; break;
@@ -3173,7 +3167,10 @@ string FunctionType::richIdentifier() const
 	case Kind::TVMSliceLoadIntQ: id += "tvmsliceloadintq"; break;
 	case Kind::TVMSliceLoadLE: id += "tvmsliceloadle"; break;
 	case Kind::TVMSliceLoadQ: id += "tvmsliceloadq"; break;
+	case Kind::TVMSliceLoadRef: id += "tvmloadref"; break;
+	case Kind::TVMSliceLoadSlice: id += "tvmloadslice"; break;
 	case Kind::TVMSliceLoadStateVars: id += "tvmslicedecodestatevars"; break;
+	case Kind::TVMSliceLoadTons: id += "tvmsliceloadtons"; break;
 	case Kind::TVMSliceLoadUint: id += "tvmsliceloaduint"; break;
 	case Kind::TVMSliceLoadUintQ: id += "tvmsliceloaduintq"; break;
 	case Kind::TVMSlicePreLoadInt: id += "tvmslicepreloadint"; break;
@@ -3196,14 +3193,23 @@ string FunctionType::richIdentifier() const
 	case Kind::Stoi: id += "stoi"; break;
 	case Kind::LogTVM: id += "logtvm"; break;
 	case Kind::TVMAccept: id += "tvmaccept"; break;
-	case Kind::TVMBuildExtMsg: id += "tvmbuildextmsg"; break;
-	case Kind::TVMBuildIntMsg: id += "tvmbuildintmsg"; break;
-	case Kind::TVMBuildStateInit: id += "tvmbuildstateinit"; break;
-	case Kind::TVMBuildDataInit: id += "tvmbuilddatainit"; break;
+
+	case Kind::ABIBuildExtMsg: id += "abibuildextmsg"; break;
+	case Kind::ABIBuildIntMsg: id += "abibuildintmsg"; break;
+	case Kind::ABICodeSalt: id += "abicodesalt"; break;
+	case Kind::ABIDecodeFunctionParams: id += "abidecodefunctionparams"; break;
+	case Kind::ABIDecodeData: id += "abidecodestatevars"; break;
+	case Kind::ABIEncodeBody: id += "abiencodebody"; break;
+	case Kind::ABIEncodeData: id += "abibuilddatainit"; break;
+	case Kind::ABIEncodeStateInit: id += "abiencodestateinit"; break;
+	case Kind::ABIFunctionId: id += "abifunctionid"; break;
+	case Kind::ABISetCodeSalt: id += "abisetcodesalt"; break;
+	case Kind::ABIStateInitHash: id += "abistateinithash"; break;
 
 	case Kind::TVMBuilderMethods: id += "tvmbuildermethods"; break;
 	case Kind::TVMBuilderStore: id += "tvmbuilderstore"; break;
 	case Kind::TVMBuilderStoreInt: id += "tvmbuilderstoreint"; break;
+	case Kind::TVMBuilderStoreTons: id += "tvmbuilderstoretons"; break;
 	case Kind::TVMBuilderStoreUint: id += "tvmbuilderstoreuint"; break;
 
 	case Kind::TVMTuplePush: id += "tvmtuplepush"; break;
@@ -3214,32 +3220,25 @@ string FunctionType::richIdentifier() const
 	case Kind::TVMBuyGas: id += "tvmbuygas"; break;
 	case Kind::TVMChecksign: id += "tvmchecksign"; break;
 	case Kind::TVMCode: id += "tvmcode"; break;
-	case Kind::TVMCodeSalt: id += "tvmcodesalt"; break;
 	case Kind::TVMCommit: id += "tvmcommit"; break;
 	case Kind::TVMConfigParam: id += "tvmconfigparam"; break;
 	case Kind::TVMDeploy: id += "tvmdeploy"; break;
 	case Kind::TVMDump: id += "tvmxxxdump"; break;
-	case Kind::TVMEncodeBody: id += "tvmencodebody"; break;
 	case Kind::TVMExit1: id += "tvmexit1"; break;
 	case Kind::TVMExit: id += "tvmexit"; break;
-	case Kind::TVMFunctionId: id += "tvmfunctionid"; break;
 	case Kind::TVMHash: id += "tvmhash"; break;
 	case Kind::TVMInitCodeHash: id += "tvminitcodehash"; break;
-	case Kind::TVMSliceLoadRef: id += "tvmloadref"; break;
-	case Kind::TVMSliceLoadSlice: id += "tvmloadslice"; break;
 	case Kind::TVMPubkey: id += "tvmpubkey"; break;
 	case Kind::TVMRawConfigParam: id += "tvmrawconfigparam"; break;
 	case Kind::TVMReplayProtInterval: id += "tvmreplayprotinterval"; break;
 	case Kind::TVMReplayProtTime: id += "tvmreplayprottime"; break;
 	case Kind::TVMResetStorage: id += "tvmresetstorage"; break;
 	case Kind::TVMSendMsg: id += "tvmsendmsg"; break;
-	case Kind::TVMSetCodeSalt: id += "tvmsetcodesalt"; break;
 	case Kind::TVMSetGasLimit: id += "tvmsetgaslimit"; break;
 	case Kind::TVMSetPubkey: id += "tvmsetpubkey"; break;
 	case Kind::TVMSetReplayProtTime: id += "tvmsetreplayprottime"; break;
 	case Kind::TVMSetcode: id += "tvmsetcode"; break;
 
-
 	case Kind::AddressTransfer: id += "tvmtransfer"; break;
 
 	case Kind::TXtimestamp: id += "txtimestamp"; break;
@@ -3254,7 +3253,6 @@ string FunctionType::richIdentifier() const
 	case Kind::AddressType: id += "addresstype"; break;
 	case Kind::AddressIsStdAddrWithoutAnyCast: id += "addressisstdaddrwithoutanycast"; break;
 	case Kind::AddressMakeAddrExtern: id += "addressmakeaddrextern"; break;
-	case Kind::AddressMakeAddrNone: id += "addressmakeaddrnone"; break;
 	case Kind::AddressMakeAddrStd: id += "addressmakeaddrstd"; break;
 
 	case Kind::MathAbs: id += "mathabs"; break;
@@ -3335,6 +3333,7 @@ string FunctionType::richIdentifier() const
 	case Kind::ABIEncodeCall: id += "abiencodecall"; break;
 	case Kind::ABIEncodeWithSignature: id += "abiencodewithsignature"; break;
 	case Kind::ABIDecode: id += "abidecode"; break;
+	case Kind::BlobHash: id += "blobhash"; break;
 	case Kind::MetaType: id += "metatype"; break;
 
 	case Kind::RndGetSeed: id += "rndgetseed"; break;
@@ -3357,9 +3356,14 @@ string FunctionType::richIdentifier() const
 	}
 	id += "_" + stateMutabilityToString(m_stateMutability);
 	id += identifierList(m_parameterTypes) + "returns" + identifierList(m_returnParameterTypes);
-
-	if (bound())
-		id += "bound_to" + identifierList(selfType());
+	if (gasSet())
+		id += "gas";
+	if (valueSet())
+		id += "value";
+	if (saltSet())
+		id += "salt";
+	if (hasBoundFirstArgument())
+		id += "attached_to" + identifierList(selfType());
 	return id;
 }
 
@@ -3397,11 +3401,17 @@ BoolResult FunctionType::isImplicitlyConvertibleTo(Type const& _convertTo) const
 	FunctionType const& convertTo = dynamic_cast<FunctionType const&>(_convertTo);
 
 	// These two checks are duplicated in equalExcludingStateMutability, but are added here for error reporting.
-	if (convertTo.bound() != bound())
-		return BoolResult::err("Bound functions can not be converted to non-bound functions.");
+	if (convertTo.hasBoundFirstArgument() != hasBoundFirstArgument())
+		return BoolResult::err("Attached functions cannot be converted into unattached functions.");
 
 	if (convertTo.kind() != kind())
-		return BoolResult::err("Special functions can not be converted to function types.");
+		return BoolResult::err("Special functions cannot be converted to function types.");
+
+	if (
+		kind() == FunctionType::Kind::Declaration &&
+		m_declaration != convertTo.m_declaration
+	)
+		return BoolResult::err("Function declaration types referring to different functions cannot be converted to each other.");
 
 	if (!equalExcludingStateMutability(convertTo))
 		return false;
@@ -3430,22 +3440,22 @@ TypeResult FunctionType::binaryOperatorResult(Token _operator, Type const* _othe
 	else if (
 		kind() == Kind::External &&
 		sizeOnStack() == 2 &&
-		!bound() &&
+		!hasBoundFirstArgument() &&
 		other.kind() == Kind::External &&
 		other.sizeOnStack() == 2 &&
-		!other.bound()
+		!other.hasBoundFirstArgument()
 	)
 		return commonType(this, _other);
 
 	return nullptr;
 }
 
-string FunctionType::canonicalName() const
+std::string FunctionType::canonicalName() const
 {
 	return "function";
 }
 
-string FunctionType::humanReadableName() const
+std::string FunctionType::humanReadableName() const
 {
 	switch (m_kind)
 	{
@@ -3458,9 +3468,9 @@ string FunctionType::humanReadableName() const
 	}
 }
 
-string FunctionType::toString(bool _withoutDataLocation) const
+std::string FunctionType::toString(bool _withoutDataLocation) const
 {
-	string name = "function ";
+	std::string name = "function ";
 	if (m_kind == Kind::Declaration)
 	{
 		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration);
@@ -3517,16 +3527,16 @@ bool FunctionType::nameable() const
 {
 	return
 		(m_kind == Kind::Internal || m_kind == Kind::External) &&
-		!bound() &&
+		!hasBoundFirstArgument() &&
 		!takesArbitraryParameters() &&
 		!gasSet() &&
 		!valueSet() &&
 		!saltSet();
 }
 
-vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> FunctionType::makeStackItems() const
 {
-	vector<tuple<string, Type const*>> slots;
+	std::vector<std::tuple<std::string, Type const*>> slots;
 	Kind kind = m_kind;
 	if (m_kind == Kind::SetGas || m_kind == Kind::SetValue)
 	{
@@ -3539,8 +3549,8 @@ vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
 	case Kind::External:
 	case Kind::DelegateCall:
 		slots = {
-			make_tuple("address", TypeProvider::address()),
-			make_tuple("functionSelector", TypeProvider::uint(32))
+			std::make_tuple("address", TypeProvider::address()),
+			std::make_tuple("functionSelector", TypeProvider::uint(32))
 		};
 		break;
 	case Kind::BareCall:
@@ -3549,21 +3559,27 @@ vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
 	case Kind::BareStaticCall:
 	case Kind::Transfer:
 	case Kind::Send:
-		slots = {make_tuple("address", TypeProvider::address())};
+		slots = {std::make_tuple("address", TypeProvider::address())};
 		break;
 	case Kind::Internal:
-		slots = {make_tuple("functionIdentifier", TypeProvider::uint256())};
+		slots = {std::make_tuple("functionIdentifier", TypeProvider::uint256())};
 		break;
 	case Kind::ArrayPush:
 	case Kind::ArrayPop:
-		solAssert(bound(), "");
+		solAssert(hasBoundFirstArgument(), "");
 		slots = {};
 		break;
 	default:
 		break;
 	}
 
-	if (bound())
+	if (gasSet())
+		slots.emplace_back("gas", TypeProvider::uint256());
+	if (valueSet())
+		slots.emplace_back("value", TypeProvider::uint256());
+	if (saltSet())
+		slots.emplace_back("salt", TypeProvider::fixedBytes(32));
+	if (hasBoundFirstArgument())
 		slots.emplace_back("self", m_parameterTypes.front());
 	return slots;
 }
@@ -3647,12 +3663,10 @@ MemberList::MemberMap FunctionType::nativeMembers(ASTNode const* _scope) const
 	}
 	case Kind::DelegateCall:
 	{
-		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration);
-		solAssert(functionDefinition, "");
-		solAssert(functionDefinition->visibility() != Visibility::Private, "");
-		if (functionDefinition->visibility() != Visibility::Internal)
+		if (auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration))
 		{
-			auto const* contract = dynamic_cast<ContractDefinition const*>(m_declaration->scope());
+			solAssert(functionDefinition->visibility() > Visibility::Internal, "");
+			auto const *contract = dynamic_cast<ContractDefinition const*>(m_declaration->scope());
 			solAssert(contract, "");
 			solAssert(contract->isLibrary(), "");
 			return {{"selector", TypeProvider::fixedBytes(4)}};
@@ -3690,10 +3704,14 @@ TypeResult FunctionType::interfaceType(bool /*_inLibrary*/) const
 
 Type const* FunctionType::mobileType() const
 {
-	if (valueSet() || gasSet() || saltSet() || bound())
+	if (valueSet() || gasSet() || saltSet() || hasBoundFirstArgument())
 		return nullptr;
 
-	// return function without parameter names
+	// Special function types do not get a mobile type, such that they cannot be used in complex expressions.
+	if (m_kind != FunctionType::Kind::Internal && m_kind != FunctionType::Kind::External && m_kind != FunctionType::Kind::DelegateCall)
+		return nullptr;
+
+	// return function without parameter names and without declaration
 	return TypeProvider::function(
 		m_parameterTypes,
 		m_returnParameterTypes,
@@ -3701,7 +3719,7 @@ Type const* FunctionType::mobileType() const
 		strings(m_returnParameterNames.size()),
 		m_kind,
 		m_stateMutability,
-		m_declaration,
+		nullptr,
 		Options::fromFunctionType(*this)
 	);
 }
@@ -3711,8 +3729,8 @@ bool FunctionType::canTakeArguments(
 	Type const* _selfType
 ) const
 {
-	solAssert(!bound() || _selfType, "");
-	if (bound() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
+	solAssert(!hasBoundFirstArgument() || _selfType, "");
+	if (hasBoundFirstArgument() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
 		return false;
 	TypePointers paramTypes = parameterTypes();
 	std::vector<std::string> const paramNames = parameterNames();
@@ -3787,10 +3805,14 @@ bool FunctionType::equalExcludingStateMutability(FunctionType const& _other) con
 	if (!hasEqualParameterTypes(_other) || !hasEqualReturnTypes(_other))
 		return false;
 
-	if (bound() != _other.bound())
+	//@todo this is ugly, but cannot be prevented right now
+	if (gasSet() != _other.gasSet() || valueSet() != _other.valueSet() || saltSet() != _other.saltSet())
+		return false;
+
+	if (hasBoundFirstArgument() != _other.hasBoundFirstArgument())
 		return false;
 
-	solAssert(!bound() || *selfType() == *_other.selfType(), "");
+	solAssert(!hasBoundFirstArgument() || *selfType() == *_other.selfType(), "");
 
 	return true;
 }
@@ -3812,7 +3834,7 @@ bool FunctionType::isBareCall() const
 	}
 }
 
-string FunctionType::externalSignature() const
+std::string FunctionType::externalSignature() const
 {
 	solAssert(m_declaration != nullptr, "External signature of function needs declaration");
 	solAssert(!m_declaration->name().empty(), "Fallback function has no signature.");
@@ -3839,9 +3861,9 @@ string FunctionType::externalSignature() const
 
 	solAssert(extParams.message().empty(), extParams.message());
 
-	auto typeStrings = extParams.get() | ranges::views::transform([&](Type const* _t) -> string
+	auto typeStrings = extParams.get() | ranges::views::transform([&](Type const* _t) -> std::string
 	{
-		string typeName = _t->signatureInExternalFunction(true);
+		std::string typeName = _t->signatureInExternalFunction(true);
 		return typeName;
 	});
 	return m_declaration->name() + "(" + boost::algorithm::join(typeStrings, ",") + ")";
@@ -3849,12 +3871,12 @@ string FunctionType::externalSignature() const
 
 u256 FunctionType::externalIdentifier() const
 {
-	return util::selectorFromSignature32(externalSignature());
+	return util::selectorFromSignatureU32(externalSignature());
 }
 
-string FunctionType::externalIdentifierHex() const
+std::string FunctionType::externalIdentifierHex() const
 {
-	return util::FixedHash<4>(util::keccak256(externalSignature())).hex();
+	return util::selectorFromSignatureH32(externalSignature()).hex();
 }
 
 bool FunctionType::isPure() const
@@ -3877,8 +3899,8 @@ bool FunctionType::isPure() const
 		m_kind == Kind::ABIDecode ||
 		m_kind == Kind::MetaType ||
 
+		m_kind == Kind::AddressMakeAddrExtern ||
 		m_kind == Kind::AddressMakeAddrStd ||
-		m_kind == Kind::AddressMakeAddrNone ||
 
 		m_kind == Kind::Wrap ||
 		m_kind == Kind::Unwrap;
@@ -3888,7 +3910,7 @@ TypePointers FunctionType::parseElementaryTypeVector(strings const& _types)
 {
 	TypePointers pointers;
 	pointers.reserve(_types.size());
-	for (string const& type: _types)
+	for (std::string const& type: _types)
 		pointers.push_back(TypeProvider::fromElementaryTypeName(type));
 	return pointers;
 }
@@ -3912,14 +3934,14 @@ Type const* FunctionType::copyAndSetCallOptions(bool _setGas, bool _setValue, bo
 	);
 }
 
-FunctionTypePointer FunctionType::asBoundFunction() const
+FunctionTypePointer FunctionType::withBoundFirstArgument() const
 {
 	solAssert(!m_parameterTypes.empty(), "");
 	solAssert(!gasSet(), "");
 	solAssert(!valueSet(), "");
 	solAssert(!saltSet(), "");
 	Options options = Options::fromFunctionType(*this);
-	options.bound = true;
+	options.hasBoundFirstArgument = true;
 	return TypeProvider::function(
 		m_parameterTypes,
 		m_returnParameterTypes,
@@ -3936,11 +3958,7 @@ FunctionTypePointer FunctionType::asExternallyCallableFunction(bool _inLibrary)
 {
 	TypePointers parameterTypes;
 	for (auto const& t: m_parameterTypes) {
-		auto refType = dynamic_cast<ReferenceType const*>(t);
-		if (refType)
-			parameterTypes.push_back(TypeProvider::withLocation(refType, true));
-		else
-			parameterTypes.push_back(t);
+		parameterTypes.push_back(t);
 	}
 
 	TypePointers returnParameterTypes;
@@ -3969,7 +3987,7 @@ FunctionTypePointer FunctionType::asExternallyCallableFunction(bool _inLibrary)
 
 Type const* FunctionType::selfType() const
 {
-	solAssert(bound(), "Function is not bound.");
+	solAssert(hasBoundFirstArgument(), "Function is not attached to a type.");
 	solAssert(m_parameterTypes.size() > 0, "Function has no self type.");
 	return m_parameterTypes.at(0);
 }
@@ -4047,12 +4065,12 @@ BoolResult OptionalType::isImplicitlyConvertibleTo(Type const& _other) const
 	return r;
 }
 
-string MappingType::richIdentifier() const
+std::string MappingType::richIdentifier() const
 {
 	return "t_mapping" + identifierList(m_keyType, m_valueType);
 }
 
-string OptionalType::richIdentifier() const
+std::string OptionalType::richIdentifier() const
 {
 	return "t_optional_" + m_type->richIdentifier();
 }
@@ -4074,22 +4092,22 @@ bool OptionalType::operator==(Type const& _other) const
 	return *other.m_type == *m_type;
 }
 
-string MappingType::toString(bool _withoutDataLocation) const
+std::string MappingType::toString(bool _withoutDataLocation) const
 {
 	return "mapping(" + keyType()->toString(_withoutDataLocation) + " => " + valueType()->toString(_withoutDataLocation) + ")";
 }
 
-string OptionalType::toString(bool _short) const
+std::string OptionalType::toString(bool _short) const
 {
 	return "optional(" + valueType()->toString(_short) + ")";
 }
 
-string MappingType::canonicalName() const
+std::string MappingType::canonicalName() const
 {
 	return "mapping(" + keyType()->canonicalName() + " => " + valueType()->canonicalName() + ")";
 }
 
-string OptionalType::canonicalName() const
+std::string OptionalType::canonicalName() const
 {
 	return "optional(" + valueType()->canonicalName() + ")";
 }
@@ -4149,7 +4167,7 @@ std::vector<std::tuple<std::string, Type const*>> MappingType::makeStackItems()
 	return {std::make_tuple("slot", TypeProvider::uint256())};
 }
 
-string TypeType::richIdentifier() const
+std::string TypeType::richIdentifier() const
 {
 	return "t_type" + identifierList(actualType());
 }
@@ -4167,13 +4185,13 @@ u256 TypeType::storageSize() const
 	solAssert(false, "Storage size of non-storable type type requested.");
 }
 
-vector<tuple<string, Type const*>> TypeType::makeStackItems() const
+std::vector<std::tuple<std::string, Type const*>> TypeType::makeStackItems() const
 {
 	if (auto contractType = dynamic_cast<ContractType const*>(m_actualType))
 		if (contractType->contractDefinition().isLibrary())
 		{
 			solAssert(!contractType->isSuper(), "");
-			return {make_tuple("address", TypeProvider::address())};
+			return {std::make_tuple("address", TypeProvider::address())};
 		}
 
 	return {};
@@ -4256,24 +4274,17 @@ MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) cons
 		members.emplace_back("makeAddrExtern", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint256()},
 				TypePointers{TypeProvider::address()},
-				strings{string(), string()},
-				strings{string()},
+				strings{std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::AddressMakeAddrExtern,
 				StateMutability::Pure
 		));
-		members.emplace_back("makeAddrNone", TypeProvider::function(
-				TypePointers{},
-				TypePointers{TypeProvider::address()},
-				strings{},
-				strings{string()},
-				FunctionType::Kind::AddressMakeAddrNone,
-				StateMutability::Pure
-		));
+		members.emplace_back("addrNone", TypeProvider::address());
 		members.emplace_back("makeAddrStd", TypeProvider::function(
 				TypePointers{TypeProvider::integer(8, IntegerType::Modifier::Signed), TypeProvider::uint256()},
 				TypePointers{TypeProvider::address()},
-				strings{string(), string()},
-				strings{string()},
+				strings{std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::AddressMakeAddrStd,
 				StateMutability::Pure
 		));
@@ -4286,8 +4297,8 @@ MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) cons
 			TypeProvider::function(
 				TypePointers{&userDefined.underlyingType()},
 				TypePointers{&userDefined},
-				strings{string{}},
-				strings{string{}},
+				strings{std::string{}},
+				strings{std::string{}},
 				FunctionType::Kind::Wrap,
 				StateMutability::Pure
 			)
@@ -4297,8 +4308,8 @@ MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) cons
 			TypeProvider::function(
 				TypePointers{&userDefined},
 				TypePointers{&userDefined.underlyingType()},
-				strings{string{}},
-				strings{string{}},
+				strings{std::string{}},
+				strings{std::string{}},
 				FunctionType::Kind::Unwrap,
 				StateMutability::Pure
 			)
@@ -4312,7 +4323,7 @@ MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) cons
 			TypePointers{},
 			TypePointers{arrayType->isString() ? TypeProvider::stringMemory() : TypeProvider::bytesMemory()},
 			strings{},
-			strings{string{}},
+			strings{std::string{}},
 			arrayType->isString() ? FunctionType::Kind::StringConcat : FunctionType::Kind::BytesConcat,
 			StateMutability::Pure,
 			nullptr,
@@ -4343,7 +4354,7 @@ u256 ModifierType::storageSize() const
 	solAssert(false, "Storage size of non-storable type type requested.");
 }
 
-string ModifierType::richIdentifier() const
+std::string ModifierType::richIdentifier() const
 {
 	return "t_modifier" + identifierList(m_parameterTypes);
 }
@@ -4368,17 +4379,17 @@ bool ModifierType::operator==(Type const& _other) const
 	return true;
 }
 
-string ModifierType::toString(bool _withoutDataLocation) const
+std::string ModifierType::toString(bool _withoutDataLocation) const
 {
-	string name = "modifier (";
+	std::string name = "modifier (";
 	for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
 		name += (*it)->toString(_withoutDataLocation) + (it + 1 == m_parameterTypes.end() ? "" : ",");
 	return name + ")";
 }
 
-string ModuleType::richIdentifier() const
+std::string ModuleType::richIdentifier() const
 {
-	return "t_module_" + to_string(m_sourceUnit.id());
+	return "t_module_" + std::to_string(m_sourceUnit.id());
 }
 
 bool ModuleType::operator==(Type const& _other) const
@@ -4397,12 +4408,12 @@ MemberList::MemberMap ModuleType::nativeMembers(ASTNode const*) const
 	return symbols;
 }
 
-string ModuleType::toString(bool) const
+std::string ModuleType::toString(bool) const
 {
-	return string("module \"") + *m_sourceUnit.annotation().path + string("\"");
+	return std::string("module \"") + *m_sourceUnit.annotation().path + std::string("\"");
 }
 
-string MagicType::richIdentifier() const
+std::string MagicType::richIdentifier() const
 {
 	switch (m_kind)
 	{
@@ -4446,10 +4457,12 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			{"logicaltime", TypeProvider::uint(64)},
 			{"timestamp", TypeProvider::uint(32)},
 			{"difficulty", TypeProvider::uint256()},
+			{"prevrandao", TypeProvider::uint256()},
 			{"number", TypeProvider::uint256()},
 			{"gaslimit", TypeProvider::uint256()},
 			{"chainid", TypeProvider::uint256()},
-			{"basefee", TypeProvider::uint256()}
+			{"basefee", TypeProvider::uint256()},
+			{"blobbasefee", TypeProvider::uint256()}
 		});
 	case Kind::Message:
 		return MemberList::MemberMap({
@@ -4458,7 +4471,7 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			{"createdAt", TypeProvider::uint(32)},
 			{"hasStateInit", TypeProvider::boolean()},
 			{"gas", TypeProvider::uint256()},
-			{"value", TypeProvider::uint(128)},
+			{"value", TypeProvider::coins()},
 			{"data", TypeProvider::tvmcell()},
 			{"sig", TypeProvider::fixedBytes(4)},
 			{"currencies", TypeProvider::extraCurrencyCollection()},
@@ -4466,14 +4479,14 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			{"isInternal", TypeProvider::boolean()},
 			{"isTickTock", TypeProvider::boolean()},
 			{"body", TypeProvider::tvmslice()},
-			{"forwardFee", TypeProvider::varInteger(16, IntegerType::Modifier::Unsigned)},
-			{"importFee", TypeProvider::varInteger(16, IntegerType::Modifier::Unsigned)},
+			{"forwardFee", TypeProvider::coins()},
+			{"importFee", TypeProvider::coins()},
 		});
 	case Kind::TVM: {
 		MemberList::MemberMap members = {
 			{"code", TypeProvider::function({}, {TypeProvider::tvmcell()}, {}, {{}}, FunctionType::Kind::TVMCode, StateMutability::Pure)},
-			{"codeSalt", TypeProvider::function({TypeProvider::tvmcell()}, {TypeProvider::optional(TypeProvider::tvmcell())}, {{}}, {{}}, FunctionType::Kind::TVMCodeSalt, StateMutability::Pure)},
-			{"setCodeSalt", TypeProvider::function({TypeProvider::tvmcell(), TypeProvider::tvmcell()}, {TypeProvider::tvmcell()}, {{}, {}}, {{}}, FunctionType::Kind::TVMSetCodeSalt, StateMutability::Pure)},
+			{"codeSalt", TypeProvider::function({TypeProvider::tvmcell()}, {TypeProvider::optional(TypeProvider::tvmcell())}, {{}}, {{}}, FunctionType::Kind::ABICodeSalt, StateMutability::Pure)},
+			{"setCodeSalt", TypeProvider::function({TypeProvider::tvmcell(), TypeProvider::tvmcell()}, {TypeProvider::tvmcell()}, {{}, {}}, {{}}, FunctionType::Kind::ABISetCodeSalt, StateMutability::Pure)},
 			{"pubkey", TypeProvider::function(strings(), strings{"uint"}, FunctionType::Kind::TVMPubkey, StateMutability::Pure)},
 			{"setPubkey", TypeProvider::function({"uint"}, {}, FunctionType::Kind::TVMSetPubkey, StateMutability::NonPayable)},
 			{"accept", TypeProvider::function(strings(), strings(), FunctionType::Kind::TVMAccept, StateMutability::Pure)},
@@ -4493,48 +4506,48 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			{"replayProtTime", TypeProvider::function({}, {"uint64"}, FunctionType::Kind::TVMReplayProtTime, StateMutability::Pure)},
 			{"setReplayProtTime", TypeProvider::function({"uint64"}, {}, FunctionType::Kind::TVMSetReplayProtTime, StateMutability::Pure)},
 			{"replayProtInterval", TypeProvider::function({}, {"uint64"}, FunctionType::Kind::TVMReplayProtInterval, StateMutability::Pure)},
-		};
-		members.emplace_back("rawReserve", TypeProvider::function(
+
+			{"rawReserve", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::extraCurrencyCollection(),  TypeProvider::uint256()},
 				TypePointers{},
-				strings{string{}, string{}, string{}},
+				strings{std::string{}, std::string{}, std::string{}},
 				strings{},
 				FunctionType::Kind::TVMSetcode,
 				StateMutability::Pure
-		));
-		members.emplace_back("rawReserve", TypeProvider::function(
+			)},
+			{"rawReserve", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint256()},
 				TypePointers{},
-				strings{string{}, string{}},
+				strings{std::string{}, std::string{}},
 				strings{},
 				FunctionType::Kind::TVMSetcode,
 				StateMutability::Pure
-		));
-		members.emplace_back("setcode", TypeProvider::function(
+			)},
+			{"setcode", TypeProvider::function(
 				TypePointers{TypeProvider::tvmcell()},
 				TypePointers{},
-				strings{string()},
+				strings{std::string()},
 				strings{},
 				FunctionType::Kind::TVMSetcode,
 				StateMutability::Pure
-		));
-		members.emplace_back("setCurrentCode", TypeProvider::function(
+			)},
+			{"setCurrentCode", TypeProvider::function(
 				TypePointers{TypeProvider::tvmcell()},
 				TypePointers{},
-				strings{string()},
+				strings{std::string()},
 				strings{},
 				FunctionType::Kind::TVMSetcode,
 				StateMutability::Pure
-		));
-		members.emplace_back("bindump", TypeProvider::function(
+			)},
+			{"bindump", TypeProvider::function(
 				TypePointers{},
 				TypePointers{},
 				strings{},
 				strings{},
 				FunctionType::Kind::TVMDump,
 				StateMutability::Pure
-		));
-		members.emplace_back("hexdump", TypeProvider::function(
+			)},
+			{"hexdump", TypeProvider::function(
 				TypePointers{},
 				TypePointers{},
 				strings{},
@@ -4543,8 +4556,8 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
-		));
-		members.emplace_back("hash", TypeProvider::function(
+			)},
+			{"hash", TypeProvider::function(
 				TypePointers{},
 				TypePointers{},
 				strings{},
@@ -4553,41 +4566,40 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
-		));
-		members.emplace_back("checkSign", TypeProvider::function(
+			)},
+			{"checkSign", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint256(), TypeProvider::uint256(), TypeProvider::uint256()},
 				TypePointers{TypeProvider::boolean()},
-				strings{string(), string(), string(), string()},
-				strings{string()},
+				strings{std::string(), std::string(), std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMChecksign,
 				StateMutability::Pure
-		));
-		members.emplace_back("checkSign", TypeProvider::function(
+			)},
+			{"checkSign", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::tvmslice(), TypeProvider::uint256()},
 				TypePointers{TypeProvider::boolean()},
-				strings{string(), string(), string()},
-				strings{string()},
+				strings{std::string(), std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMChecksign,
 				StateMutability::Pure
-		));
-		members.emplace_back("checkSign", TypeProvider::function(
+			)},
+			{"checkSign", TypeProvider::function(
 				TypePointers{TypeProvider::tvmslice(), TypeProvider::tvmslice(), TypeProvider::uint256()},
 				TypePointers{TypeProvider::boolean()},
-				strings{string(), string(), string()},
-				strings{string()},
+				strings{std::string(), std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMChecksign,
 				StateMutability::Pure
-		));
-		members.emplace_back("sendrawmsg", TypeProvider::function(
+			)},
+			{"sendrawmsg", TypeProvider::function(
 				TypePointers{TypeProvider::tvmcell(), TypeProvider::uint(8)},
 				TypePointers{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				strings{},
 				FunctionType::Kind::TVMSendMsg,
 				StateMutability::Pure
-		));
-
-		members.emplace_back("configParam", TypeProvider::function(
+			)},
+			{"configParam", TypeProvider::function(
 				TypePointers{},
 				TypePointers{},
 				strings{},
@@ -4596,18 +4608,16 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
-		));
-
-		members.emplace_back("rawConfigParam", TypeProvider::function(
-			{TypeProvider::integer(32, IntegerType::Modifier::Signed)},
-			{TypeProvider::optional(TypeProvider::tvmcell())},
-			{{}},
-			{{}},
-			FunctionType::Kind::TVMRawConfigParam,
-			StateMutability::Pure
-		));
-
-		members.emplace_back("buildExtMsg", TypeProvider::function(
+			)},
+			{"rawConfigParam", TypeProvider::function(
+				{TypeProvider::integer(32, IntegerType::Modifier::Signed)},
+				{TypeProvider::optional(TypeProvider::tvmcell())},
+				{{}},
+				{{}},
+				FunctionType::Kind::TVMRawConfigParam,
+				StateMutability::Pure
+			)},
+			{"buildExtMsg", TypeProvider::function(
 				TypePointers{TypeProvider::address(),
 							 TypeProvider::callList(),
 							 TypeProvider::uint(32),
@@ -4621,52 +4631,49 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 							 TypeProvider::tvmcell(),
 							 TypeProvider::uint(8)},
 				TypePointers{TypeProvider::tvmcell()},
-				strings{string("dest"),			// mandatory
-						string("call"),			// mandatory
-						string("callbackId"),	// mandatory
-						string("abiVer"),		// can be omitted
-						string("onErrorId"),	    // mandatory
-						string("signBoxHandle"),	// can be omitted
-						string("time"),			// can be omitted
-						string("expire"),		// can be omitted
-						string("pubkey"),		// can be omitted
-						string("sign"),			// can be omitted
-						string("stateInit"),	// can be omitted
-						string("flags")},	// can be omitted
-				strings{string()},
-				FunctionType::Kind::TVMBuildExtMsg,
+				strings{std::string("dest"),			// mandatory
+						std::string("call"),			// mandatory
+						std::string("callbackId"),	// mandatory
+						std::string("abiVer"),		// can be omitted
+						std::string("onErrorId"),	    // mandatory
+						std::string("signBoxHandle"),	// can be omitted
+						std::string("time"),			// can be omitted
+						std::string("expire"),		// can be omitted
+						std::string("pubkey"),		// can be omitted
+						std::string("sign"),			// can be omitted
+						std::string("stateInit"),	// can be omitted
+						std::string("flags")},	// can be omitted
+				strings{std::string()},
+				FunctionType::Kind::ABIBuildExtMsg,
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
-		));
-
-
-		members.emplace_back("buildIntMsg", TypeProvider::function(
-			{
-				TypeProvider::address(),
-				TypeProvider::uint(128),
-				TypeProvider::extraCurrencyCollection(),
-				TypeProvider::boolean(),
-				TypeProvider::callList(),
-				TypeProvider::tvmcell(),
-			},
-			{TypeProvider::tvmcell()},
-			{
-				"dest", // mandatory
-				"value", // mandatory
-				"currencies", // can be omitted
-				"bounce", // can be omitted
-				"call", // mandatory
-				"stateInit", // can be omitted
-			},
-			{{}},
-			FunctionType::Kind::TVMBuildIntMsg,
-			StateMutability::Pure,
-			nullptr,
-			FunctionType::Options::withArbitraryParameters()
-		));
-
-		members.emplace_back("buildStateInit", TypeProvider::function(
+			)},
+			{"buildIntMsg", TypeProvider::function(
+				{
+					TypeProvider::address(),
+					TypeProvider::coins(),
+					TypeProvider::extraCurrencyCollection(),
+					TypeProvider::boolean(),
+					TypeProvider::callList(),
+					TypeProvider::tvmcell(),
+				},
+				{TypeProvider::tvmcell()},
+				{
+					"dest", // mandatory
+					"value", // mandatory
+					"currencies", // can be omitted
+					"bounce", // can be omitted
+					"call", // mandatory
+					"stateInit", // can be omitted
+				},
+				{{}},
+				FunctionType::Kind::ABIBuildIntMsg,
+				StateMutability::Pure,
+				nullptr,
+				FunctionType::Options::withArbitraryParameters()
+			)},
+			{"buildStateInit", TypeProvider::function(
 				TypePointers{TypeProvider::tvmcell(),
 							 TypeProvider::tvmcell(),
 							 TypeProvider::uint(8),
@@ -4676,72 +4683,59 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 							 // but it can be any contract
 							 },
 				TypePointers{TypeProvider::tvmcell()},
-				strings{string("code"),	// mandatory
-						string("data"),	// conflicts with pubkey and varInit
-						string("splitDepth"),	// can be omitted
-						string("varInit"),	// conflicts with data
-						string("pubkey"),	// conflicts with data
+				strings{std::string("code"),	// mandatory
+						std::string("data"),	// conflicts with pubkey and varInit
+						std::string("splitDepth"),	// can be omitted
+						std::string("varInit"),	// conflicts with data
+						std::string("pubkey"),	// conflicts with data
 						//string("contr")
 					},
-				strings{string()},
-				FunctionType::Kind::TVMBuildStateInit,
+				strings{std::string()},
+				FunctionType::Kind::ABIEncodeStateInit,
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
-		));
-
-		members.emplace_back("buildDataInit", TypeProvider::function(
-			{
-				TypeProvider::uint256(),
-				TypeProvider::initializerList(),
-				//TypeProvider::contract(...) it's commented because we should set the concrete contract
-			},
-			{TypeProvider::tvmcell()},
-			{"pubkey", "varInit"},
-			{{}},
-			FunctionType::Kind::TVMBuildDataInit,
-			StateMutability::Pure,
-			nullptr, FunctionType::Options::withArbitraryParameters()
-		));
-
-		members.emplace_back("insertPubkey", TypeProvider::function(
-				TypePointers{TypeProvider::tvmcell(), TypeProvider::uint256()},
-				TypePointers{TypeProvider::tvmcell()},
-				strings{string(), string()},
-				strings{string()},
-				FunctionType::Kind::TVMDeploy,
-				StateMutability::Pure
-		));
-
-		members.emplace_back("stateInitHash", TypeProvider::function(
+			)},
+			{"buildDataInit", TypeProvider::function(
+				{
+					TypeProvider::uint256(),
+					TypeProvider::initializerList(),
+					//TypeProvider::contract(...) it's commented because we should set the concrete contract
+				},
+				{TypeProvider::tvmcell()},
+				{"pubkey", "varInit"},
+				{{}},
+				FunctionType::Kind::ABIEncodeData,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"stateInitHash", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint256(), TypeProvider::uint(16), TypeProvider::uint(16)},
 				TypePointers{TypeProvider::uint256()},
-				strings{string(), string(), string(), string()},
-				strings{string()},
-				FunctionType::Kind::TVMDeploy,
+				strings{std::string(), std::string(), std::string(), std::string()},
+				strings{std::string()},
+				FunctionType::Kind::ABIStateInitHash,
 				StateMutability::Pure
-		));
-
-		members.emplace_back("functionId", TypeProvider::function(
+			)},
+			{"functionId", TypeProvider::function(
 				TypePointers{},
 				TypePointers{TypeProvider::uint(32)},
 				strings{},
-				strings{string()},
-				FunctionType::Kind::TVMFunctionId,
+				strings{std::string()},
+				FunctionType::Kind::ABIFunctionId,
 				StateMutability::Pure,
 				nullptr, FunctionType::Options::withArbitraryParameters()
-		));
-
-		members.emplace_back("encodeBody", TypeProvider::function(
+			)},
+			{"encodeBody", TypeProvider::function(
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell()},
 				strings{},
-				strings{string()},
-				FunctionType::Kind::TVMEncodeBody,
+				strings{std::string()},
+				FunctionType::Kind::ABIEncodeBody,
 				StateMutability::Pure,
 				nullptr, FunctionType::Options::withArbitraryParameters()
-		));
-
+			)}
+		};
 		return members;
 	}
 	case Kind::Rnd: {
@@ -4859,10 +4853,10 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				nullptr, FunctionType::Options::withArbitraryParameters()
 		));
 		members.emplace_back("sign", TypeProvider::function(
-				TypePointers{TypeProvider::integer(256, IntegerType::Modifier::Signed)},
+				TypePointers{TypeProvider::integer(257, IntegerType::Modifier::Signed)},
 				TypePointers{TypeProvider::integer(2, IntegerType::Modifier::Signed)},
-				strings{string("value")},
-				strings{string("sign")},
+				strings{std::string("value")},
+				strings{std::string("sign")},
 				FunctionType::Kind::MathSign,
 				StateMutability::Pure
 		));
@@ -4873,7 +4867,7 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			{"gasprice", TypeProvider::uint256()},
 			{"logicaltime", TypeProvider::uint(64)},
 			{"origin", TypeProvider::address()},
-			{"storageFee", TypeProvider::uint(120)},
+			{"storageFee", TypeProvider::coins()},
 			{"timestamp", TypeProvider::uint(64)},
 		});
 	case Kind::ABI:
@@ -4937,11 +4931,176 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				StateMutability::Pure,
 				nullptr,
 				FunctionType::Options::withArbitraryParameters()
+			)},
+			{"encodeStateInit", TypeProvider::function(
+				TypePointers{TypeProvider::tvmcell(),
+							 TypeProvider::tvmcell(),
+							 TypeProvider::uint(8),
+							 TypeProvider::initializerList(),
+							 TypeProvider::uint256(),
+							//TypeProvider::contract(...) it's commented because we should set the concrete contract
+							// but it can be any contract
+				},
+				TypePointers{TypeProvider::tvmcell()},
+				strings{std::string("code"),	// mandatory
+						std::string("data"),	// conflicts with pubkey and varInit
+						std::string("splitDepth"),	// can be omitted
+						std::string("varInit"),	// conflicts with data
+						std::string("pubkey"),	// conflicts with data
+						//string("contr")
+				},
+				strings{std::string()},
+				FunctionType::Kind::ABIEncodeStateInit,
+				StateMutability::Pure,
+				nullptr,
+				FunctionType::Options::withArbitraryParameters()
+			)},
+			{"stateInitHash", TypeProvider::function(
+				TypePointers{TypeProvider::uint256(), TypeProvider::uint256(), TypeProvider::uint(16), TypeProvider::uint(16)},
+				TypePointers{TypeProvider::uint256()},
+				strings{std::string(), std::string(), std::string(), std::string()},
+				strings{std::string()},
+				FunctionType::Kind::ABIStateInitHash,
+				StateMutability::Pure
+			)},
+			{"encodeData", TypeProvider::function(
+				{
+					TypeProvider::uint256(),
+					TypeProvider::initializerList(),
+					//TypeProvider::contract(...) it's commented because we should set the concrete contract
+				},
+				{TypeProvider::tvmcell()},
+				{"pubkey", "varInit"},
+				{{}},
+				FunctionType::Kind::ABIEncodeData,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"encodeOldDataInit", TypeProvider::function(
+				{
+						TypeProvider::uint256(),
+						TypeProvider::initializerList(),
+						//TypeProvider::contract(...) it's commented because we should set the concrete contract
+				},
+				{TypeProvider::tvmcell()},
+				{"pubkey", "varInit"},
+				{{}},
+				FunctionType::Kind::ABIEncodeData,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"codeSalt", TypeProvider::function(
+				{TypeProvider::tvmcell()},
+				{TypeProvider::optional(TypeProvider::tvmcell())},
+				{{}},
+				{{}},
+				FunctionType::Kind::ABICodeSalt,
+				StateMutability::Pure
+			)},
+			{"setCodeSalt", TypeProvider::function(
+				{TypeProvider::tvmcell(), TypeProvider::tvmcell()},
+				{TypeProvider::tvmcell()},
+				{{}, {}},
+				{{}},
+				FunctionType::Kind::ABISetCodeSalt,
+				StateMutability::Pure
+			)},
+			{"functionId", TypeProvider::function(
+				TypePointers{},
+				TypePointers{TypeProvider::uint(32)},
+				strings{},
+				strings{std::string()},
+				FunctionType::Kind::ABIFunctionId,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"encodeExtMsg", TypeProvider::function(
+				TypePointers{TypeProvider::address(),
+							 TypeProvider::callList(),
+							 TypeProvider::uint(32),
+							 TypeProvider::uint(8),
+							 TypeProvider::uint(32),
+							 TypeProvider::optional(TypeProvider::uint(32)),
+							 TypeProvider::uint(64),
+							 TypeProvider::uint(32),
+							 TypeProvider::optional(TypeProvider::uint256()),
+							 TypeProvider::boolean(),
+							 TypeProvider::tvmcell(),
+							 TypeProvider::uint(8)},
+				TypePointers{TypeProvider::tvmcell()},
+				strings{std::string("dest"),			// mandatory
+						std::string("call"),			// mandatory
+						std::string("callbackId"),	// mandatory
+						std::string("abiVer"),		// can be omitted
+						std::string("onErrorId"),	    // mandatory
+						std::string("signBoxHandle"),	// can be omitted
+						std::string("time"),			// can be omitted
+						std::string("expire"),		// can be omitted
+						std::string("pubkey"),		// can be omitted
+						std::string("sign"),			// can be omitted
+						std::string("stateInit"),	// can be omitted
+						std::string("flags")},	// can be omitted
+				strings{std::string()},
+				FunctionType::Kind::ABIBuildExtMsg,
+				StateMutability::Pure,
+				nullptr,
+				FunctionType::Options::withArbitraryParameters()
+			)},
+			{"encodeIntMsg", TypeProvider::function(
+				{
+					TypeProvider::address(),
+					TypeProvider::coins(),
+					TypeProvider::extraCurrencyCollection(),
+					TypeProvider::boolean(),
+					TypeProvider::callList(),
+					TypeProvider::tvmcell(),
+				},
+				{TypeProvider::tvmcell()},
+				{
+					"dest", // mandatory
+					"value", // mandatory
+					"currencies", // can be omitted
+					"bounce", // can be omitted
+					"call", // mandatory
+					"stateInit", // can be omitted
+				},
+				{{}},
+				FunctionType::Kind::ABIBuildIntMsg,
+				StateMutability::Pure,
+				nullptr,
+				FunctionType::Options::withArbitraryParameters()
+			)},
+			{"decodeData", TypeProvider::function(
+				TypePointers{},
+				TypePointers{},
+				strings{},
+				strings{},
+				FunctionType::Kind::ABIDecodeData,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"encodeBody", TypeProvider::function(
+				TypePointers{},
+				TypePointers{TypeProvider::tvmcell()},
+				strings{},
+				strings{std::string()},
+				FunctionType::Kind::ABIEncodeBody,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
+			)},
+			{"decodeFunctionParams", TypeProvider::function(
+				TypePointers{},
+				TypePointers{},
+				strings{},
+				strings{},
+				FunctionType::Kind::ABIDecodeFunctionParams,
+				StateMutability::Pure,
+				nullptr, FunctionType::Options::withArbitraryParameters()
 			)}
 		});
 	case Kind::Gosh: {
 		MemberList::MemberMap members;
-		for (auto const&[name, type] : std::vector<std::tuple<string, FunctionType::Kind>>{
+		for (auto const&[name, type] : std::vector<std::tuple<std::string, FunctionType::Kind>>{
 				{"diff", FunctionType::Kind::GoshDiff},
 				{"applyPatch", FunctionType::Kind::GoshApplyPatch},
 		}) {
@@ -4957,7 +5116,7 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 			)});
 		}
 
-		for (auto const&[name, type] : std::vector<std::tuple<string, FunctionType::Kind>>{
+		for (auto const&[name, type] : std::vector<std::tuple<std::string, FunctionType::Kind>>{
 				{"applyBinPatch", FunctionType::Kind::GoshApplyBinPatch},
 				{"applyZipBinPatch", FunctionType::Kind::GoshApplyZipBinPatch},
 				{"applyZipPatch", FunctionType::Kind::GoshApplyZipPatch},
@@ -4986,7 +5145,7 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 				nullptr, FunctionType::Options::withArbitraryParameters()
 		)});
 
-		for (auto const&[name, type] : std::vector<std::tuple<string, FunctionType::Kind>>{
+		for (auto const&[name, type] : std::vector<std::tuple<std::string, FunctionType::Kind>>{
 				{"applyZipPatchQ", FunctionType::Kind::GoshApplyZipPatchQ},
 				{"applyBinPatchQ", FunctionType::Kind::GoshApplyBinPatchQ},
 				{"applyZipBinPatchQ", FunctionType::Kind::GoshApplyZipBinPatchQ},
@@ -5084,7 +5243,7 @@ MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
 	return {};
 }
 
-string MagicType::toString(bool _withoutDataLocation) const
+std::string MagicType::toString(bool _withoutDataLocation) const
 {
 	switch (m_kind)
 	{
@@ -5397,8 +5556,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadUnsigned", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::uint256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadUint,
 				StateMutability::Pure
 			)
@@ -5407,8 +5566,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadUint", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::uint256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadUint,
 				StateMutability::Pure
 			)
@@ -5417,8 +5576,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadUintQ", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::optional(TypeProvider::uint256())},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadUintQ,
 				StateMutability::Pure
 			)
@@ -5607,8 +5766,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"preloadUint", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::uint256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSlicePreLoadUint,
 				StateMutability::Pure
 			)
@@ -5617,8 +5776,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"preloadUintQ", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::optional(TypeProvider::uint256())},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSlicePreLoadUintQ,
 				StateMutability::Pure
 			)
@@ -5627,8 +5786,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadSigned", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::int256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadInt,
 				StateMutability::Pure
 			)
@@ -5637,8 +5796,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadInt", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::int256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadInt,
 				StateMutability::Pure
 			)
@@ -5647,8 +5806,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"loadIntQ", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::optional(TypeProvider::int256())},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadIntQ,
 				StateMutability::Pure
 			)
@@ -5657,8 +5816,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"preloadInt", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::int256()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSlicePreLoadInt,
 				StateMutability::Pure
 			)
@@ -5667,8 +5826,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"preloadIntQ", TypeProvider::function(
 				TypePointers{TypeProvider::uint(9)},
 				TypePointers{TypeProvider::optional(TypeProvider::int256())},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSlicePreLoadIntQ,
 				StateMutability::Pure
 			)
@@ -5677,8 +5836,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"hasNBits", TypeProvider::function(
 				TypePointers{TypeProvider::uint(10)},
 				TypePointers{TypeProvider::boolean()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceHas,
 				StateMutability::Pure
 			)
@@ -5687,8 +5846,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"hasNRefs", TypeProvider::function(
 				TypePointers{TypeProvider::uint(2)},
 				TypePointers{TypeProvider::boolean()},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceHas,
 				StateMutability::Pure
 			)
@@ -5697,8 +5856,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"hasNBitsAndRefs", TypeProvider::function(
 				TypePointers{TypeProvider::uint(10), TypeProvider::uint(2)},
 				TypePointers{TypeProvider::boolean()},
-				strings{string(), string()},
-				strings{string()},
+				strings{std::string(), std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceHas,
 				StateMutability::Pure
 			)
@@ -5708,8 +5867,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::uint(128)},
 				strings{},
-				strings{string()},
-				FunctionType::Kind::TVMSliceLoadRef,
+				strings{std::string()},
+				FunctionType::Kind::TVMSliceLoadTons,
 				StateMutability::Pure
 			)
 		},
@@ -5814,7 +5973,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10), TypeProvider::uint(2)},
 				strings{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				FunctionType::Kind::TVMSliceSize,
 				StateMutability::Pure
 			)
@@ -5834,7 +5993,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceSize,
 				StateMutability::Pure
 			)
@@ -5844,7 +6003,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::uint(2)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceSize,
 				StateMutability::Pure
 			)
@@ -5854,7 +6013,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::uint(16)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceSize,
 				StateMutability::Pure
 			)
@@ -5864,7 +6023,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadRef,
 				StateMutability::Pure
 			)
@@ -5894,7 +6053,7 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 				TypePointers{},
 				TypePointers{TypeProvider::tvmslice()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceLoadRef,
 				StateMutability::Pure
 			)
@@ -5903,8 +6062,8 @@ MemberList::MemberMap TvmSliceType::nativeMembers(ASTNode const *) const {
 			"compare", TypeProvider::function(
 				TypePointers{TypeProvider::tvmslice()},
 				TypePointers{TypeProvider::integer(2, IntegerType::Modifier::Signed)},
-				strings{string()},
-				strings{string()},
+				strings{std::string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMSliceCompare,
 				StateMutability::Pure
 			)
@@ -5928,7 +6087,7 @@ MemberList::MemberMap TvmCellType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(16)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMCellDepth,
 				StateMutability::Pure
 			)
@@ -5939,7 +6098,7 @@ MemberList::MemberMap TvmCellType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmslice()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMCellToSlice,
 				StateMutability::Pure
 			)
@@ -5950,7 +6109,7 @@ MemberList::MemberMap TvmCellType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmslice(), TypeProvider::boolean()},
 				strings{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				FunctionType::Kind::TVMCellToSlice,
 				StateMutability::Pure
 			)
@@ -5961,7 +6120,7 @@ MemberList::MemberMap TvmCellType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMCellToSlice,
 				StateMutability::Pure
 			)
@@ -5972,7 +6131,7 @@ MemberList::MemberMap TvmCellType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell(), TypeProvider::boolean()},
 				strings{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				FunctionType::Kind::TVMCellToSlice,
 				StateMutability::Pure
 			)
@@ -6037,7 +6196,7 @@ MemberList::MemberMap TvmVectorType::nativeMembers(const ASTNode *) const
 	members.emplace_back("push", TypeProvider::function(
 			TypePointers{valueType()},
 			TypePointers{},
-			strings{string()},
+			strings{std::string()},
 			strings{},
 			FunctionType::Kind::TVMTuplePush,
 			StateMutability::Pure
@@ -6047,7 +6206,7 @@ MemberList::MemberMap TvmVectorType::nativeMembers(const ASTNode *) const
 			TypePointers{},
 			TypePointers{TypeProvider::uint(8)},
 			strings{},
-			strings{string("length")},
+			strings{std::string("length")},
 			FunctionType::Kind::TVMTupleLength,
 			StateMutability::Pure
 	));
@@ -6056,7 +6215,7 @@ MemberList::MemberMap TvmVectorType::nativeMembers(const ASTNode *) const
 			TypePointers{},
 			TypePointers{valueType()},
 			strings{},
-			strings{string("last")},
+			strings{std::string("last")},
 			FunctionType::Kind::TVMTuplePop,
 			StateMutability::Pure
 	));
@@ -6065,7 +6224,7 @@ MemberList::MemberMap TvmVectorType::nativeMembers(const ASTNode *) const
 			TypePointers{},
 			TypePointers{TypeProvider::boolean()},
 			strings{},
-			strings{string("is_empty")},
+			strings{std::string("is_empty")},
 			FunctionType::Kind::TVMTupleLength,
 			StateMutability::Pure
 	));
@@ -6112,7 +6271,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(16)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6122,7 +6281,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6132,7 +6291,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(2)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6142,7 +6301,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10), TypeProvider::uint(2)},
 				strings{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6152,7 +6311,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6162,7 +6321,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(2)},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6172,7 +6331,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::uint(10), TypeProvider::uint(2)},
 				strings{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6182,7 +6341,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6192,7 +6351,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmcell()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6202,7 +6361,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 				TypePointers{},
 				TypePointers{TypeProvider::tvmslice()},
 				strings{},
-				strings{string()},
+				strings{std::string()},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
 			)
@@ -6211,7 +6370,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeRef", TypeProvider::function(
 				TypePointers{TypeProvider::tvmbuilder()},
 				TypePointers{},
-				strings{string()},
+				strings{std::string()},
 				strings{},
 				FunctionType::Kind::TVMBuilderMethods,
 				StateMutability::Pure
@@ -6272,7 +6431,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeSigned", TypeProvider::function(
 				TypePointers{TypeProvider::int256(), TypeProvider::uint(9)},
 				TypePointers{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				strings{},
 				FunctionType::Kind::TVMBuilderStoreInt,
 				StateMutability::Pure
@@ -6282,7 +6441,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeInt", TypeProvider::function(
 				TypePointers{TypeProvider::int256(), TypeProvider::uint(9)},
 				TypePointers{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				strings{},
 				FunctionType::Kind::TVMBuilderStoreInt,
 				StateMutability::Pure
@@ -6292,7 +6451,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeUnsigned", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint(9)},
 				TypePointers{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				strings{},
 				FunctionType::Kind::TVMBuilderStoreUint,
 				StateMutability::Pure
@@ -6302,7 +6461,7 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeUint", TypeProvider::function(
 				TypePointers{TypeProvider::uint256(), TypeProvider::uint(9)},
 				TypePointers{},
-				strings{string(), string()},
+				strings{std::string(), std::string()},
 				strings{},
 				FunctionType::Kind::TVMBuilderStoreUint,
 				StateMutability::Pure
@@ -6312,9 +6471,9 @@ MemberList::MemberMap TvmBuilderType::nativeMembers(const ASTNode *) const
 			"storeTons", TypeProvider::function(
 				TypePointers{TypeProvider::uint(128)},
 				TypePointers{},
-				strings{string()},
+				strings{std::string()},
 				strings{},
-				FunctionType::Kind::TVMBuilderMethods,
+				FunctionType::Kind::TVMBuilderStoreTons,
 				StateMutability::Pure
 			)
 		},
diff --git a/compiler/libsolidity/ast/Types.h b/compiler/libsolidity/ast/Types.h
index 88ad151e..679fd1ea 100644
--- a/compiler/libsolidity/ast/Types.h
+++ b/compiler/libsolidity/ast/Types.h
@@ -172,10 +172,28 @@ class Type
 
 	enum class Category
 	{
-		Address, Integer, RationalNumber, StringLiteral, Bool, FixedPoint, Array, ArraySlice,
-		FixedBytes, Contract, Struct, Function, Enum, UserDefinedValueType, Tuple,
-		Mapping, TypeType, Modifier, Magic, Module,
-		InaccessibleDynamic, TvmCell, TvmSlice, TvmBuilder, TvmVector, Variant,
+		Address,
+		Integer,
+		RationalNumber,
+		StringLiteral,
+		Bool,
+		FixedPoint,
+		Array,
+		ArraySlice,
+		FixedBytes,
+		Contract,
+		Struct,
+		Function,
+		Enum,
+		UserDefinedValueType,
+		Tuple,
+		Mapping,
+		TypeType,
+		Modifier,
+		Magic,
+		Module,
+		InaccessibleDynamic,
+		TvmCell, TvmSlice, TvmBuilder, TvmVector, Variant,
 		VarInteger,
 		InitializerList, CallList, // <-- variables of that types can't be declared in solidity contract
 		Optional,
@@ -326,7 +344,7 @@ class Type
 	/// Might return a null pointer if there is no fitting type.
 	virtual Type const* mobileType() const { return this; }
 
-	/// Returns the list of all members of this type. Default implementation: no members apart from bound.
+	/// Returns the list of all members of this type. Default implementation: no members apart from attached functions.
 	/// @param _currentScope scope in which the members are accessed.
 	MemberList const& members(ASTNode const* _currentScope) const;
 	/// Convenience method, returns the type of the given named member or an empty pointer if no such member exists.
@@ -377,13 +395,28 @@ class Type
 	/// Clears all internally cached values (if any).
 	virtual void clearCache() const;
 
+	/// Scans all "using for" directives in the @a _scope for functions implementing
+	/// the operator represented by @a _token. Returns the set of all definitions where the type
+	/// of the first argument matches this type object.
+	///
+	/// @note: If the AST has passed analysis without errors,
+	/// the function will find at most one definition for an operator.
+	///
+	/// @param _unary If true, only definitions that accept exactly one argument are included.
+	/// Otherwise only definitions that accept exactly two arguments.
+	std::set<FunctionDefinition const*, ASTCompareByID<ASTNode>> operatorDefinitions(
+		Token _token,
+		ASTNode const& _scope,
+		bool _unary
+	) const;
+
 private:
 	/// @returns a member list containing all members added to this type by `using for` directives.
-	static MemberList::MemberMap boundFunctions(Type const& _type, ASTNode const& _scope);
+	static MemberList::MemberMap attachedFunctions(Type const& _type, ASTNode const& _scope);
 
 protected:
 	/// @returns the members native to this type depending on the given context. This function
-	/// is used (in conjunction with boundFunctions to fill m_members below.
+	/// is used (in conjunction with attachedFunctions to fill m_members below.
 	virtual MemberList::MemberMap nativeMembers(ASTNode const* /*_currentScope*/) const
 	{
 		return MemberList::MemberMap();
@@ -465,7 +498,7 @@ class IntegerType: public Type
 	bool nameable() const override { return true; }
 
 	std::string toString(bool _withoutDataLocation) const override;
-
+	MemberList::MemberMap nativeMembers(ASTNode const*) const override;
 	Type const* encodingType() const override { return this; }
 	TypeResult interfaceType(bool) const override { return this; }
 
@@ -835,7 +868,7 @@ class InitializerListType: public Type
 
 /**
  * Used for call list in external message creation
- * tvm.buildExtMsg({...,call : {Contract.Func, arg1, arg2} ,...})
+ * abi.encodeExtMsg({...,call : {Contract.Func, arg1, arg2} ,...})
  */
 class CallListType: public Type
 {
@@ -866,6 +899,7 @@ class CompositeType: public Type
 	/// elements of decomposition of these elements and so on, up to non-composite types.
 	/// Each type is included only once.
 	std::vector<Type const*> fullDecomposition() const;
+	TypeResult unaryOperatorResult(Token _operator) const override;
 
 protected:
 	/// @returns a list of types that together make up the data part of this type.
@@ -876,59 +910,6 @@ class CompositeType: public Type
 	virtual std::vector<Type const*> decomposition() const = 0;
 };
 
-/**
- * Base class used by types which are not value types and can be stored either in storage, memory
- * or calldata. This is currently used by arrays and structs.
- */
-class ReferenceType: public CompositeType
-{
-protected:
-	explicit ReferenceType() {}
-
-public:
-	TypeResult unaryOperatorResult(Token _operator) const override;
-	TypeResult binaryOperatorResult(Token, Type const*) const override
-	{
-		return nullptr;
-	}
-	unsigned memoryHeadSize() const override { return 32; }
-	u256 memoryDataSize() const override = 0;
-
-	unsigned calldataEncodedSize(bool) const override = 0;
-	unsigned calldataEncodedTailSize() const override = 0;
-
-	/// @returns a copy of this type with location (recursively) changed to @a _location,
-	/// whereas isPointer is only shallowly changed - the deep copy is always a bound reference.
-	virtual std::unique_ptr<ReferenceType> copyForLocation(bool _isPointer) const = 0;
-
-	Type const* mobileType() const override { return withLocation(true); }
-	bool hasSimpleZeroValueInMemory() const override { return false; }
-
-	/// Storage references can be pointers or bound references. In general, local variables are of
-	/// pointer type, state variables are bound references. Assignments to pointers or deleting
-	/// them will not modify storage (that will only change the pointer). Assignment from
-	/// non-storage objects to a variable of storage pointer type is not possible.
-	/// For anything other than storage, this always returns true because assignments
-	/// never change the contents of the original value.
-	bool isPointer() const;
-
-	bool operator==(ReferenceType const& /*_other*/) const
-	{
-		return true;
-	}
-
-	Type const* withLocation(bool _isPointer) const;
-
-protected:
-	Type const* copyForLocationIfReference(Type const* _type) const;
-	/// @returns the suffix computed from the reference part to be used by identifier();
-	std::string identifierLocationSuffix() const;
-
-	// TODO DELETE
-	// it's useless parameter in TVM
-	bool m_isPointer = true;
-};
-
 /**
  * The type of an array. The flavours are byte array (bytes), statically- (<type>[<length>])
  * and dynamically-sized array (<type>[]).
@@ -936,23 +917,23 @@ class ReferenceType: public CompositeType
  * one slot). Dynamically sized arrays (including byte arrays) start with their size as a uint and
  * thus start on their own slot.
  */
-class ArrayType: public ReferenceType
+class ArrayType: public CompositeType
 {
 public:
 	/// Constructor for a byte array ("bytes") and string.
 	explicit ArrayType(bool _isString = false);
 
-	/// Constructor for a dynamically sized array type ("type[]")
+	/// Constructor for a dynamically sized array type ("<type>[]")
 	ArrayType(Type const* _baseType):
-		ReferenceType(),
-		m_baseType(copyForLocationIfReference(_baseType))
+		CompositeType(),
+		m_baseType(_baseType)
 	{
 	}
 
-	/// Constructor for a fixed-size array type ("type[20]")
+	/// Constructor for a fixed-size array type ("<type>[<length>]")
 	ArrayType(Type const* _baseType, u256 _length):
-		ReferenceType(),
-		m_baseType(copyForLocationIfReference(_baseType)),
+		CompositeType(),
+		m_baseType(_baseType),
 		m_hasDynamicLength(true),
 		m_length(std::move(_length))
 	{}
@@ -992,8 +973,6 @@ class ArrayType: public ReferenceType
 	u256 const& length() const { return m_length; }
 	u256 memoryDataSize() const override;
 
-	std::unique_ptr<ReferenceType> copyForLocation(bool _isPointer) const override;
-
 	/// The offset to advance in calldata to move from one array element to the next.
 	unsigned calldataStride() const { return isByteArrayOrString() ? 1 : m_baseType->calldataHeadSize(); }
 	/// The offset to advance in memory to move from one array element to the next.
@@ -1021,10 +1000,10 @@ class ArrayType: public ReferenceType
 	mutable std::optional<TypeResult> m_interfaceType_library;
 };
 
-class ArraySliceType: public ReferenceType
+class ArraySliceType: public CompositeType
 {
 public:
-	explicit ArraySliceType(ArrayType const& _arrayType): ReferenceType(), m_arrayType(_arrayType) {}
+	explicit ArraySliceType(ArrayType const& _arrayType): CompositeType(), m_arrayType(_arrayType) {}
 	Category category() const override { return Category::ArraySlice; }
 
 	BoolResult isImplicitlyConvertibleTo(Type const& _other) const override;
@@ -1042,8 +1021,6 @@ class ArraySliceType: public ReferenceType
 	ArrayType const& arrayType() const { return m_arrayType; }
 	u256 memoryDataSize() const override { solAssert(false, ""); }
 
-	std::unique_ptr<ReferenceType> copyForLocation(bool) const override { solAssert(false, ""); }
-
 protected:
 	std::vector<std::tuple<std::string, Type const*>> makeStackItems() const override;
 	std::vector<Type const*> decomposition() const override { return {m_arrayType.baseType()}; }
@@ -1118,11 +1095,11 @@ class ContractType: public Type
 /**
  * The type of a struct instance, there is one distinct type per struct definition.
  */
-class StructType: public ReferenceType
+class StructType: public CompositeType
 {
 public:
 	explicit StructType(StructDefinition const& _struct):
-		ReferenceType(), m_struct(_struct) {}
+		CompositeType(), m_struct(_struct) {}
 
 	Category category() const override { return Category::Struct; }
 	BoolResult isImplicitlyConvertibleTo(Type const& _convertTo) const override;
@@ -1148,8 +1125,6 @@ class StructType: public ReferenceType
 
 	bool recursive() const;
 
-	std::unique_ptr<ReferenceType> copyForLocation(bool _isPointer) const override;
-
 	std::string canonicalName() const override;
 	std::string signatureInExternalFunction(bool _structsByName) const override;
 
@@ -1354,12 +1329,13 @@ class FunctionType: public Type
 		AddressIsStdAddrWithoutAnyCast, ///< address.isStdAddrWithoutAnyCast  for address
 		AddressIsZero, ///< address.isStdZero() address.isExternZero() for address
 		AddressMakeAddrExtern, ///< address.makeAddrExtern() for address
-		AddressMakeAddrNone, ///< address.makeAddrNone() for address
 		AddressMakeAddrStd, ///< address.makeAddrStd() for address
 		AddressTransfer, ///< address.transfer()
 		AddressType, ///< address.getType() for address
 		AddressUnpack, ///< address.unpack() for address
 
+		IntCast, ///< int a; a.cast(uint8);
+
         VariantIsUint,
         VariantToUint,
 
@@ -1376,13 +1352,14 @@ class FunctionType: public Type
 		TVMSliceLoadFunctionParams, ///< slice.loadFunctionParams(function_name)
 		TVMSliceLoadInt, ///< slice.loadInt()
 		TVMSliceLoadIntQ, ///< slice.loadIntQ()
+		TVMSliceLoadLE, ///< slice.load[U]intLE(4|8)[Q]()
 		TVMSliceLoadQ, ///< slice.loadQ(types...)
 		TVMSliceLoadRef, ///< slice.loadRef()
 		TVMSliceLoadSlice, ///< slice.loadSlice()
 		TVMSliceLoadStateVars, ///< slice.loadStateVars(contract_name)
+		TVMSliceLoadTons, ///< slice.loadTons()
 		TVMSliceLoadUint, ///< slice.loadUint()
 		TVMSliceLoadUintQ, ///< slice.loadUintQ()
-		TVMSliceLoadLE, ///< slice.load[U]intLE(4|8)[Q]()
 		TVMSlicePreLoadInt,  ///< slice.preloadInt()
 		TVMSlicePreLoadIntQ, ///< slice.preloadIntQ()
 		TVMSlicePreLoadSlice, ///< slice.preloadSlice()
@@ -1399,6 +1376,7 @@ class FunctionType: public Type
 		TVMBuilderMethods, ///< builder.*()
 		TVMBuilderStore, ///< builder.store(...)
 		TVMBuilderStoreInt, ///< builder.storeInt()
+		TVMBuilderStoreTons, ///< builder.storeTons()
 		TVMBuilderStoreUint, ///< builder.storeUint()
 
 		TVMTuplePush, ///< tuple.push(...)
@@ -1426,6 +1404,7 @@ class FunctionType: public Type
 		SetFlag, ///< modify the default flag for the function call transfer
 		Stoi, ///< stoi function to convert string to an integer
 		BlockHash, ///< BLOCKHASH
+		BlobHash, ///< BLOBHASH
 		AddMod, ///< ADDMOD
 		MulMod, ///< MULMOD
 
@@ -1448,23 +1427,28 @@ class FunctionType: public Type
 		MathDivMod, ///< math.divmod()
 		MathSign, ///< math.sign()
 
+		ABIBuildExtMsg, ///< abi.encodeExtMsg()
+		ABIBuildIntMsg, ///< abi.encodeIntMsg()
+		ABICodeSalt, ///< abi.codeSalt()
+		ABIDecodeData, ///< abi.decodeData(contract_name, slice)
+		ABIDecodeFunctionParams, ///< abi.decodeFunctionParams()
+		ABIEncodeBody, ///< abi.encodeBody()
+		ABIEncodeData, ///< abi.encodeData()
+		ABIEncodeStateInit, ///< abi.encodeStateInit()
+		ABIFunctionId, ///< abi.functionId(function_name)
+		ABISetCodeSalt, ///< abi.setCodeSalt()
+		ABIStateInitHash, ///< abi.stateInitHash()
+
 		TVMAccept, ///< tvm.accept()
-		TVMBuildDataInit, ///< tvm.buildDataInit()
-		TVMBuildExtMsg, ///< tvm.buildExtMsg()
-		TVMBuildIntMsg, ///< tvm.buildIntMsg()
-		TVMBuildStateInit, ///< tvm.buildStateInit()
 		TVMBuyGas, ///< tvm.buyGas()
 		TVMChecksign, ///< tvm.checkSign()
 		TVMCode, ///< tvm.code()
-		TVMCodeSalt, ///< tvm.codeSalt()
 		TVMCommit, ///< tvm.commit()
 		TVMConfigParam, ///< tvm.configParam()
 		TVMDeploy, ///< functions to deploy contract from contract
 		TVMDump, ///< tvm.xxxdump()
-		TVMEncodeBody, ///< tvm.encodeBody()
 		TVMExit, ///< tvm.exit()
 		TVMExit1, ///< tvm.exit1()
-		TVMFunctionId, ///< tvm.functionId(function_name)
 		TVMHash, ///< tvm.hash()
 		TVMInitCodeHash, ///< tvm.initCodeHash()
 		TVMPubkey, ///< tvm.pubkey()
@@ -1473,7 +1457,6 @@ class FunctionType: public Type
 		TVMReplayProtTime, ///< tvm.replayProtTime()
 		TVMResetStorage, ///< tvm.resetStorage()
 		TVMSendMsg, ///< tvm.sendMsg()
-		TVMSetCodeSalt, ///< tvm.setCodeSalt()
 		TVMSetGasLimit, ///< tvm.setGasLimit()
 		TVMSetPubkey, ///< tvm.setPubkey()
 		TVMSetReplayProtTime, ///< tvm.setReplayProtTime()
@@ -1563,7 +1546,7 @@ class FunctionType: public Type
 		bool saltSet = false;
 		/// true iff the function is called as arg1.fun(arg2, ..., argn).
 		/// This is achieved through the "using for" directive.
-		bool bound = false;
+		bool hasBoundFirstArgument = false;
 
 		static Options withArbitraryParameters()
 		{
@@ -1578,7 +1561,7 @@ class FunctionType: public Type
 			result.gasSet = _type.gasSet();
 			result.valueSet = _type.valueSet();
 			result.saltSet = _type.saltSet();
-			result.bound = _type.bound();
+			result.hasBoundFirstArgument = _type.hasBoundFirstArgument();
 			return result;
 		}
 	};
@@ -1613,7 +1596,7 @@ class FunctionType: public Type
 	)
 	{
 		// In this constructor, only the "arbitrary Parameters" option should be used.
-		solAssert(!bound() && !gasSet() && !valueSet() && !saltSet());
+		solAssert(!hasBoundFirstArgument() && !gasSet() && !valueSet() && !saltSet());
 	}
 
 	/// Detailed constructor, use with care.
@@ -1645,8 +1628,8 @@ class FunctionType: public Type
 			"Return parameter names list must match return parameter types list!"
 		);
 		solAssert(
-			!bound() || !m_parameterTypes.empty(),
-			"Attempted construction of bound function without self type"
+			!hasBoundFirstArgument() || !m_parameterTypes.empty(),
+			"Attempted construction of attached function without self type"
 		);
 	}
 
@@ -1663,7 +1646,7 @@ class FunctionType: public Type
 	/// storage pointers) are replaced by InaccessibleDynamicType instances.
 	TypePointers returnParameterTypesWithoutDynamicTypes() const;
 	std::vector<std::string> const& returnParameterNames() const { return m_returnParameterNames; }
-	/// @returns the "self" parameter type for a bound function
+	/// @returns the "self" parameter type for an attached function
 	Type const* selfType() const;
 
 	std::string richIdentifier() const override;
@@ -1697,8 +1680,8 @@ class FunctionType: public Type
 
 	/// @returns true if this function can take the given arguments (possibly
 	/// after implicit conversion).
-	/// @param _selfType if the function is bound, this has to be supplied and is the type of the
-	/// expression the function is called on.
+	/// @param _selfType if the function is attached as a member function, this has to be supplied
+	/// and is the type of the expression the function is called on.
 	bool canTakeArguments(
 		FuncCallArguments const& _arguments,
 		Type const* _selfType = nullptr
@@ -1761,20 +1744,20 @@ class FunctionType: public Type
 	bool gasSet() const { return m_options.gasSet; }
 	bool valueSet() const { return m_options.valueSet; }
 	bool saltSet() const { return m_options.saltSet; }
-	bool bound() const { return m_options.bound; }
+	bool hasBoundFirstArgument() const { return m_options.hasBoundFirstArgument; }
 
 	/// @returns a copy of this type, where gas or value are set manually. This will never set one
 	/// of the parameters to false.
 	Type const* copyAndSetCallOptions(bool _setGas, bool _setValue, bool _setSalt) const;
 
-	/// @returns a copy of this function type with the `bound` flag set to true.
+	/// @returns a copy of this function type with the `hasBoundFirstArgument` flag set to true.
 	/// Should only be called on library functions.
-	FunctionTypePointer asBoundFunction() const;
+	FunctionTypePointer withBoundFirstArgument() const;
 
 	/// @returns a copy of this function type where the location of reference types is changed
 	/// from CallData to Memory. This is the type that would be used when the function is
 	/// called externally, as opposed to the parameter types that are available inside the function body.
-	/// Also supports variants to be used for library or bound calls.
+	/// Also supports variants to be used for library or attached function calls.
 	/// @param _inLibrary if true, uses DelegateCall as location.
 	FunctionTypePointer asExternallyCallableFunction(bool _inLibrary) const;
 
@@ -1800,8 +1783,8 @@ class FunctionType: public Type
 class MappingType: public CompositeType
 {
 public:
-	MappingType(Type const* _keyType, Type const* _valueType):
-		m_keyType(_keyType), m_valueType(_valueType) {}
+	MappingType(Type const* _keyType, ASTString _keyName, Type const* _valueType, ASTString _valueName):
+		m_keyType(_keyType), m_keyName(_keyName), m_valueType(_valueType), m_valueName(_valueName) {}
 
 	Category category() const override { return Category::Mapping; }
 
@@ -1821,10 +1804,11 @@ class MappingType: public CompositeType
 	std::vector<std::tuple<std::string, Type const*>> makeStackItems() const override;
 
 	Type const* keyType() const { return m_keyType; }
-	Type const* realKeyType() const;
+	ASTString keyName() const { return m_keyName; }
 	Type const* valueType() const { return m_valueType; }
+	ASTString valueName() const { return m_valueName; }
+	Type const* realKeyType() const;
 	MemberList::MemberMap nativeMembers(ASTNode const*) const override;
-
 	TypeResult unaryOperatorResult(Token _operator) const override;
 
 protected:
@@ -1832,7 +1816,9 @@ class MappingType: public CompositeType
 
 private:
 	Type const* m_keyType;
+	ASTString m_keyName;
 	Type const* m_valueType;
+	ASTString m_valueName;
 };
 
 /**
@@ -1913,6 +1899,7 @@ class TypeType: public Type
 	bool hasSimpleZeroValueInMemory() const override { solAssert(false, ""); }
 	std::string toString(bool _withoutDataLocation) const override { return "type(" + m_actualType->toString(_withoutDataLocation) + ")"; }
 	MemberList::MemberMap nativeMembers(ASTNode const* _currentScope) const override;
+	Type const* mobileType() const override { return nullptr; }
 
 	BoolResult isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 protected:
@@ -2013,6 +2000,8 @@ class MagicType: public Type
 
 	Type const* typeArgument() const;
 
+	Type const* mobileType() const override { return nullptr; }
+
 protected:
 	std::vector<std::tuple<std::string, Type const*>> makeStackItems() const override { return {}; }
 private:
diff --git a/compiler/libsolidity/ast/UserDefinableOperators.h b/compiler/libsolidity/ast/UserDefinableOperators.h
new file mode 100644
index 00000000..5b98524f
--- /dev/null
+++ b/compiler/libsolidity/ast/UserDefinableOperators.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <liblangutil/Token.h>
+
+#include <vector>
+
+namespace solidity::frontend
+{
+
+std::vector<langutil::Token> const userDefinableOperators = {
+	// Bitwise
+	langutil::Token::BitOr,
+	langutil::Token::BitAnd,
+	langutil::Token::BitXor,
+	langutil::Token::BitNot,
+	// Arithmetic
+	langutil::Token::Add,
+	langutil::Token::Sub,
+	langutil::Token::Mul,
+	langutil::Token::Div,
+	langutil::Token::Mod,
+	// Comparison
+	langutil::Token::Equal,
+	langutil::Token::NotEqual,
+	langutil::Token::LessThan,
+	langutil::Token::GreaterThan,
+	langutil::Token::LessThanOrEqual,
+	langutil::Token::GreaterThanOrEqual,
+};
+
+}
diff --git a/compiler/libsolidity/codegen/DictOperations.cpp b/compiler/libsolidity/codegen/DictOperations.cpp
index b2a72d76..4bb4fde4 100644
--- a/compiler/libsolidity/codegen/DictOperations.cpp
+++ b/compiler/libsolidity/codegen/DictOperations.cpp
@@ -104,7 +104,7 @@ void GetFromDict::getDict() {
 	// if op == GetSetFromMapping than stack: value key dict keyLength
 	// else                            stack: key dict keyLength
 
-	const int saveStake = pusher.stackSize();
+	const int saveStack = pusher.stackSize();
 	std::string opcode = "DICT" + typeToDictChar(&keyType);
 	int take{};
 	int ret{};
@@ -208,7 +208,7 @@ void GetFromDict::getDict() {
 	}
 	pusher.endOpaque(take, ret);
 
-	pusher.ensureSize(saveStake -take + ret);
+	pusher.ensureSize(saveStack - take + ret);
 }
 
 void GetFromDict::checkExist() {
diff --git a/compiler/libsolidity/codegen/PeepholeOptimizer.cpp b/compiler/libsolidity/codegen/PeepholeOptimizer.cpp
index 301c3790..764ce853 100644
--- a/compiler/libsolidity/codegen/PeepholeOptimizer.cpp
+++ b/compiler/libsolidity/codegen/PeepholeOptimizer.cpp
@@ -16,6 +16,8 @@
 
 #include <boost/format.hpp>
 
+#include <libsolidity/ast/TypeProvider.h>
+
 #include "PeepholeOptimizer.hpp"
 #include "StackOpcodeSquasher.hpp"
 #include "TVM.hpp"
@@ -28,6 +30,8 @@ using namespace solidity::util;
 
 namespace solidity::frontend {
 
+bool PeepholeOptimizer::withBlockPush = false;
+
 struct Result {
 
 	int removeQty{};
@@ -48,16 +52,17 @@ struct Result {
 
 class PrivatePeepholeOptimizer {
 public:
-	explicit PrivatePeepholeOptimizer(std::vector<Pointer<TvmAstNode>> instructions, bool _withUnpackOpaque, bool _optimizeSlice) :
+	explicit PrivatePeepholeOptimizer(std::vector<Pointer<TvmAstNode>> instructions, bool _withUnpackOpaque, bool _optimizeSlice, bool _withTuck) :
 		m_instructions{std::move(instructions)},
 		m_withUnpackOpaque{_withUnpackOpaque},
-		m_optimizeSlice{_optimizeSlice}
+		m_optimizeSlice{_optimizeSlice},
+		m_withTuck{_withTuck}
 	{
 	}
 	vector<Pointer<TvmAstNode>> const &instructions() const { return m_instructions; }
 
 	int nextCommandLine(int idx) const;
-	static int nextCommandLine(int idx, std::vector<Pointer<TvmAstNode>> instructions);
+	static int nextCommandLine(int idx, std::vector<Pointer<TvmAstNode>> const& instructions);
 	Pointer<TvmAstNode> get(int idx) const;
 	bool valid(int idx) const;
 	void remove(int idx);
@@ -65,7 +70,7 @@ class PrivatePeepholeOptimizer {
 	std::optional<Result> optimizeAt(int idx1) const;
 	std::optional<Result> optimizeSlice(int idx1) const;
 	static std::optional<Result> optimizeAt1(Pointer<TvmAstNode> const& cmd1, bool m_withUnpackOpaque);
-	static std::optional<Result> optimizeAt2(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2) ;
+	static std::optional<Result> optimizeAt2(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2, bool _withTuck);
 	static std::optional<Result> optimizeAt3(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2, Pointer<TvmAstNode> const& cmd3, bool m_withUnpackOpaque);
 	static std::optional<Result> optimizeAt4(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2, Pointer<TvmAstNode> const& cmd3,
 					   Pointer<TvmAstNode> const& cmd4);
@@ -82,7 +87,6 @@ class PrivatePeepholeOptimizer {
 	bool optimize(const std::function<std::optional<Result>(int)> &f);
 
 	static std::optional<std::pair<int, int>> isBLKDROP2(Pointer<TvmAstNode>const& node);
-	static std::optional<int> isPUSH(Pointer<TvmAstNode> const& node);
 	static bigint pushintValue(Pointer<TvmAstNode> const& node);
 	static int fetchInt(Pointer<TvmAstNode> const& node);
 	static bool isNIP(Pointer<TvmAstNode> const& node);
@@ -103,13 +107,17 @@ class PrivatePeepholeOptimizer {
 	std::vector<Pointer<TvmAstNode>> m_instructions{};
 	bool m_withUnpackOpaque{};
 	bool m_optimizeSlice{};
+	bool m_withTuck{};
 };
 
 int PrivatePeepholeOptimizer::nextCommandLine(int idx) const {
+	if (idx == -1) {
+		return -1;
+	}
 	return nextCommandLine(idx + 1, m_instructions);
 }
 
-int PrivatePeepholeOptimizer::nextCommandLine(int idx, std::vector<Pointer<TvmAstNode>> instructions) {
+int PrivatePeepholeOptimizer::nextCommandLine(int idx, std::vector<Pointer<TvmAstNode>> const& instructions) {
 	solAssert(0 <= idx, "");
 	int n = instructions.size();
 	while (idx < n) {
@@ -167,8 +175,10 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeSlice(int idx1) const {
 }
 
 std::optional<Result> PrivatePeepholeOptimizer::optimizeAt(const int idx1) const {
+	std::optional<Result> res;
 	if (m_optimizeSlice) {
-		return optimizeSlice(idx1);
+		res = optimizeSlice(idx1);
+		if (res) return res;
 	}
 
 	int idx2 = nextCommandLine(idx1);
@@ -184,8 +194,6 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt(const int idx1) const
 	Pointer<TvmAstNode> const &cmd5 = get(idx5);
 	Pointer<TvmAstNode> const &cmd6 = get(idx6);
 
-	std::optional<Result> res;
-
 	res = optimizeAt1(cmd1, m_withUnpackOpaque);
 	if (res) return res;
 
@@ -193,7 +201,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt(const int idx1) const
 	if (res) return res;
 
 	if (!cmd2) return {};
-	res = optimizeAt2(cmd1, cmd2);
+	res = optimizeAt2(cmd1, cmd2, m_withTuck);
 	if (res) return res;
 
 	if (!cmd3) return {};
@@ -217,7 +225,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt(const int idx1) const
 
 std::optional<Result> PrivatePeepholeOptimizer::optimizeAt1(Pointer<TvmAstNode> const& cmd1, bool m_withUnpackOpaque) {
 	auto cmd1CodeBlock = to<CodeBlock>(cmd1.get());
-	auto cmd1GenOpcode = to<GenOpcode>(cmd1.get());
+	auto cmd1GenOpcode = to<StackOpcode>(cmd1.get());
 	auto cmd1IfElse = to<TvmIfElse>(cmd1.get());
 	auto cmd1Sub = to<SubProgram>(cmd1.get());
 
@@ -417,12 +425,22 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt1(Pointer<TvmAstNode>
 			int fi = nextCommandLine(0, f);
 			Pointer<TvmAstNode> a = t.at(ti);
 			Pointer<TvmAstNode> b = f.at(fi);
-			if (isPureGen01(*a) &&
-				isPureGen01(*b) &&
-				std::dynamic_pointer_cast<GenOpcode>(a) &&
-				std::dynamic_pointer_cast<GenOpcode>(b)
+			if ((isPureGen01(*a) && to<StackOpcode>(a.get())) ||
+				to<Glob>(a.get()) ||
+				to<PushCellOrSlice>(a.get()) ||
+				isPUSH(a)
 			) {
-				return Result{1, a, b, gen("CONDSEL")};
+				Pointer<TvmAstNode> newB;
+				if (to<StackOpcode>(b.get()) ||
+					to<Glob>(b.get()) ||
+					to<PushCellOrSlice>(b.get())
+				) {
+					newB = b;
+				} else if (auto index = isPUSH(b)) {
+					newB = makePUSH(*index + 2); // +2 because flag and value from first branch
+				}
+				if (newB)
+					return Result{1, a, newB, gen("CONDSEL")};
 			}
 		}
 	}
@@ -526,13 +544,13 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt1(Pointer<TvmAstNode>
 	return {};
 }
 
-std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2) {
+std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode> const& cmd1, Pointer<TvmAstNode> const& cmd2, bool _withTuck) {
 	using namespace MathConsts;
-	auto cmd1GenOp = to<GenOpcode>(cmd1.get());
+	auto cmd1GenOp = to<StackOpcode>(cmd1.get());
 	auto cmd1Glob = to<Glob>(cmd1.get());
 
 	auto cmd2Exc = to<TvmException>(cmd2.get());
-	auto cmd2GenOpcode = to<GenOpcode>(cmd2.get());
+	auto cmd2GenOpcode = to<StackOpcode>(cmd2.get());
 	auto cmd2Glob = to<Glob>(cmd2.get());
 	auto cmd2IfElse = to<TvmIfElse>(cmd2.get());
 	auto cmd1Ret = to<TvmReturn>(cmd1.get());
@@ -590,6 +608,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 			return Result{2, makeBLKDROP2(n, 1)};
 		}
 	}
+
 	// SWAP
 	// POP S2
 	//
@@ -597,6 +616,10 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	if (isSWAP(cmd1) && isPOP(cmd2) && isPOP(cmd2).value() == 2) {
 		return Result{2, makeBLKDROP2(1, 2)};
 	}
+	// PUSH Si | gen01
+	// DROP N
+	//
+	// DROP N-1
 	if ((isPUSH(cmd1) || isPureGen01(*cmd1)) && isDrop(cmd2)) {
 		int qty = isDrop(cmd2).value();
 		if (qty == 1) {
@@ -608,7 +631,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 
 	// BLKPUSH N, index / DROP
 	// BLKDROP N
-	if (isBLKPUSH1 && isDrop(cmd2)) {
+	if (PeepholeOptimizer::withBlockPush && isBLKPUSH1 && isDrop(cmd2)) {
 		auto [qty, index] = isBLKPUSH1.value();
 		int diff = qty - isDrop(cmd2).value();
 		if (diff == 0)
@@ -644,6 +667,20 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 		auto [down, up] = _isBLKDROP2.value();
 		return Result{2, makeBLKDROP2(down, up - 1), cmd1};
 	}
+	// PUSH SN
+	// BLKDROP2 down, top
+	// =>
+	// BLKDROP2 down, top-1
+	// PUSH S?
+	if (_withTuck && isPUSH(cmd1) && _isBLKDROP2) {
+		int n = *isPUSH(cmd1);
+		auto [down, top] = _isBLKDROP2.value();
+		if (n < top) {
+			return Result{2, makeBLKDROP2(down, top - 1), cmd1};
+		} else if (n >= down + top - 1) {
+			return Result{2, makeBLKDROP2(down, top - 1), makePUSH(n - down)};
+		}
+	}
 	// BLKPUSH
 	// BLKDROP2
 	// =>
@@ -816,23 +853,51 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	{
 		return Result{2};
 	}
+	// SETGLOB N
+	// GETGLOB N
+	//
+	// DUP
+	// SETGLOB N
 	if (cmd1Glob && cmd1Glob->opcode() == Glob::Opcode::SetOrSetVar &&
 		cmd2Glob && cmd2Glob->opcode() == Glob::Opcode::GetOrGetVar &&
 		cmd1Glob->index() == cmd2Glob->index()
 	) {
 		return Result{2, makePUSH(0), makeSetGlob(cmd1Glob->index())};
 	}
+	// PUSHINT N
+	// ADDCONST ? | INC | DEC
+	//
+	// PUSHINT (N+delta)
+	if (is(cmd1, "PUSHINT") && isConstAdd(cmd2)) {
+		bigint n = pushintValue(cmd1);
+		bigint delta = getAddNum(cmd2);
+		// TODO check overflow
+		return Result{2, gen("PUSHINT " + toString(n + delta))};
+	}
+	// PUSHINT N
+	// UFITS ? | FITS ?
+	//
+	// PUSHINT N
+	if (is(cmd1, "PUSHINT") && (is(cmd2, "UFITS") || is(cmd2, "FITS"))) {
+		bigint n = pushintValue(cmd1);
+		int bits = fetchInt(cmd2);
+		auto type = TypeProvider::integer(bits,
+										  is(cmd2, "UFITS") ? IntegerType::Modifier::Unsigned :
+										  						IntegerType::Modifier::Signed);
+		if (type->minValue() <= n && n <= type->maxValue())
+			return Result{2, gen("PUSHINT " + toString(n))};
+	}
 	if (isConstAdd(cmd1) && isConstAdd(cmd2)) {
 		int final_add = getAddNum(cmd1) + getAddNum(cmd2);
 		if (-128 <= final_add && final_add <= 127)
 			return Result{2, gen("ADDCONST " + std::to_string(final_add))};
 	}
-	if ((is(cmd1, "INDEX_NOEXCEP") || is(cmd1, "INDEX_EXCEP")) && 0 <= strToInt(arg(cmd1)) && strToInt(arg(cmd1)) <= 3 &&
-		(is(cmd2, "INDEX_NOEXCEP") || is(cmd2, "INDEX_EXCEP")) && 0 <= strToInt(arg(cmd2)) && strToInt(arg(cmd2)) <= 3) {
+	if ((is(cmd1, "INDEX_NOEXCEP") || is(cmd1, "INDEX_EXCEP")) && 0 <= fetchInt(cmd1) && fetchInt(cmd1) <= 3 &&
+		(is(cmd2, "INDEX_NOEXCEP") || is(cmd2, "INDEX_EXCEP")) && 0 <= fetchInt(cmd2) && fetchInt(cmd2) <= 3) {
 		return Result{2, gen("INDEX2 " + arg(cmd1) + ", " + arg(cmd2))};
 	}
 	if (is(cmd1, "INDEX2") &&
-		(is(cmd2, "INDEX_NOEXCEP") || is(cmd2, "INDEX_EXCEP")) && 0 <= strToInt(arg(cmd2)) && strToInt(arg(cmd2)) <= 3
+		(is(cmd2, "INDEX_NOEXCEP") || is(cmd2, "INDEX_EXCEP")) && 0 <= fetchInt(cmd2) && fetchInt(cmd2) <= 3
 	) {
 		auto [i, j] = getIndexes(arg(cmd1));
 		if (0 <= i && i <= 3 &&
@@ -940,6 +1005,16 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 		if (is(cmd1, "EQUAL")) return Result{2, gen("NEQ")};
 		if (is(cmd1, "NEQ")) return Result{2, gen("EQUAL")};
 
+		if (is(cmd1, "LESSINT")) {  // !(x < value) => x >= value => x > value-1
+			int value = fetchInt(cmd1);
+			if (-128 <= value - 1 && value - 1 < 128)
+				return Result{2, gen("GTINT " + toString(value - 1))};
+		}
+		if (is(cmd1, "GTINT")) {  // !(x > value) => x <= value => x < value+1
+			int value = fetchInt(cmd1);
+			if (-128 <= value + 1 && value + 1 < 128)
+				return Result{2, gen("LESSINT " + toString(value + 1))};
+		}
 		if (is(cmd1, "EQINT")) return Result{2, gen("NEQINT " + arg(cmd1))};
 		if (is(cmd1, "NEQINT")) return Result{2, gen("EQINT " + arg(cmd1))};
 
@@ -1039,7 +1114,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 			if (lc->type() == LogCircuit::Type::AND && lc->body()->instructions().size() == 2) {
 				auto cmd2_0 = lc->body()->instructions().at(0);
 				auto cmd2_1 = lc->body()->instructions().at(1);
-				auto _true = to<GenOpcode>(cmd2_1.get());
+				auto _true = to<StackOpcode>(cmd2_1.get());
 				if (isDrop(cmd2_0) == 1 && _true && _true->opcode() == "TRUE") {
 					return Result{2};
 				}
@@ -1051,8 +1126,8 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	// AND
 	// =>
 	//
-	auto _true = to<GenOpcode>(cmd1.get());
-	auto _and = to<GenOpcode>(cmd2.get());
+	auto _true = to<StackOpcode>(cmd1.get());
+	auto _and = to<StackOpcode>(cmd2.get());
 	if (_true && _true->opcode() == "TRUE" &&
 		_and && _and->opcode() == "AND") {
 		return Result{2};
@@ -1106,7 +1181,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	// =>
 	// ABS
 	if (is(cmd1, "ABS") &&
-		cmd2GenOpcode->opcode() == "MODPOW2" && cmd2GenOpcode->arg() == "256"
+		cmd2GenOpcode && cmd2GenOpcode->opcode() == "MODPOW2" && cmd2GenOpcode->arg() == "256"
 	) {
 		return Result{2, gen("ABS")};
 	}
@@ -1125,7 +1200,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	// BLKPUSH Q, 0 / DUP
 	// =>
 	// BLKPUSH N+Q, 0
-	if (isBLKPUSH(cmd1) && isBLKPUSH(cmd2)) {
+	if (PeepholeOptimizer::withBlockPush && isBLKPUSH(cmd1) && isBLKPUSH(cmd2)) {
 		auto [qty0, index0] = isBLKPUSH(cmd1).value();
 		auto [qty1, index1] = isBLKPUSH(cmd2).value();
 		if (index0 == 0 && index1 == 0 && qty0 + qty1 <= 15)
@@ -1140,7 +1215,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 	) {
 		// TODO add LD[I|U]LE[4|8]
 		int n = isDrop(cmd2).value();
-		Pointer<GenOpcode> newOpcode = gen("P" + cmd1GenOp->fullOpcode());
+		Pointer<StackOpcode> newOpcode = gen("P" + cmd1GenOp->fullOpcode());
 		if (n == 1) {
 			return Result{2, newOpcode};
 		} else {
@@ -1148,6 +1223,17 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt2(Pointer<TvmAstNode>
 		}
 	}
 
+	// 26 + 118 gas units
+	// PLDREF
+	// CTOS
+	// =>
+	// 118 + 18 gas units
+	// LDREFRTOS
+	// NIP
+	if (is(cmd1, "PLDREF") && is(cmd2, "CTOS")) {
+		return Result{2, gen("LDREFRTOS"), makeBLKDROP2(1, 1)};
+	}
+
 	return {};
 }
 
@@ -1157,7 +1243,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 	auto cmd1PushCellOrSlice = to<PushCellOrSlice>(cmd1.get());
 	auto isPUSH2 = isPUSH(cmd2);
 	auto cmd2PushCellOrSlice = to<PushCellOrSlice>(cmd2.get());
-	auto cmd3GenOpcode = to<GenOpcode>(cmd3.get());
+	auto cmd3GenOpcode = to<StackOpcode>(cmd3.get());
 	auto cmd3SubProgram = to<SubProgram>(cmd3.get());
 
 	// NEW
@@ -1225,16 +1311,33 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 		if (-128 <= val - 1 && val - 1 < 128 && is(cmd3, "LEQ"))
 			return Result{3, newCmd2, gen("GTINT " + toString(val - 1))};
 	}
+	// PUSHINT A
+	// PUSHINT B
+	// ADD | MUL
+	//
+	// PUSHINT A+B | PUSHINT A*B
 	if (is(cmd1, "PUSHINT") &&
 		is(cmd2, "PUSHINT") &&
-		cmd3GenOpcode && cmd3GenOpcode->opcode() == "MUL"
+		cmd3GenOpcode && isIn(cmd3GenOpcode->opcode(), "ADD", "MUL", "MAX")
 	) {
 		bigint a = pushintValue(cmd1);
 		bigint b = pushintValue(cmd2);
-		bigint c = a * b;
+		bigint c;
+		if (cmd3GenOpcode->opcode() == "ADD")
+			c = a + b;
+		else if (cmd3GenOpcode->opcode() == "MUL")
+			c = a * b;
+		else if (cmd3GenOpcode->opcode() == "MAX")
+			c = std::max(a, b);
+		else
+			solUnimplemented("");
 		return Result{3, gen("PUSHINT " + toString(c))};
 	}
-
+	// PUSHINT A
+	// PUSHINT B
+	// DIV
+	//
+	// PUSHINT A/B
 	if (is(cmd1, "PUSHINT") &&
 		is(cmd2, "PUSHINT") &&
 		cmd3GenOpcode && cmd3GenOpcode->opcode() == "DIV"
@@ -1247,6 +1350,35 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 		}
 	}
 
+	// PUSHINT
+	// PUSH SN / gen01
+	// ADD / MUL
+	//
+	// PUSH S(N-1) / gen01
+	// ADDCONST / MULCONST
+	if (is(cmd1, "PUSHINT") &&
+		(is(cmd3, "ADD") || is(cmd3, "MUL"))
+	) {
+		bigint val = pushintValue(cmd1);
+		if (-128 <= val && val <= 127) {
+			if ((isPureGen01(*cmd2) && to<StackOpcode>(cmd2.get())) ||
+				to<Glob>(cmd2.get()) ||
+				isPUSH(cmd2)
+			) {
+				Pointer<TvmAstNode> newCmd;
+				if (to<StackOpcode>(cmd2.get()) ||
+					to<Glob>(cmd2.get())
+				) {
+					newCmd = cmd2;
+				} else if (auto index = isPUSH(cmd2); index.has_value() && *index > 0) {
+					newCmd = makePUSH(*index - 1);
+				}
+				if (newCmd)
+					return Result{3,  newCmd, gen((is(cmd3, "ADD") ? "ADDCONST " : "MULCONST ") + toString(val))};
+			}
+		}
+	}
+
 	// TRUE
 	// NEWC
 	// STI 1
@@ -1281,7 +1413,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 	// =>
 	// gen(0, 1)
 	// BLKPUSH N+1, 0
-	if (
+	if (PeepholeOptimizer::withBlockPush && // ?
 		isPureGen01(*cmd1) &&
 		isBLKPUSH(cmd2) &&
 		isPureGen01(*cmd3) &&
@@ -1316,7 +1448,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 		if (cmd3SubProgram) {
 			std::vector<Pointer<TvmAstNode>> const& instructions = cmd3SubProgram->block()->instructions();
 			if (instructions.size() == 1 &&
-				*instructions.at(0) == *createNode<GenOpcode>(".inline concatenateStrings", 2, 1)) {
+				*instructions.at(0) == *createNode<StackOpcode>(".inline __concatenateStrings", 2, 1)) {
 				string hexStr = cmd1PushCellOrSlice->chainBlob() + cmd2PushCellOrSlice->chainBlob();
 				return Result{3, makePushCellOrSlice(hexStr, false)};
 			}
@@ -1335,7 +1467,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt3(Pointer<TvmAstNode>
 		) {
 			std::vector<Pointer<TvmAstNode>> const &cmds = ifRef->trueBody()->instructions();
 			if (cmds.size() == 1) {
-				if (auto gen = to<GenOpcode>(cmds.at(0).get())) {
+				if (auto gen = to<StackOpcode>(cmds.at(0).get())) {
 					if (isIn(gen->fullOpcode(), ".inline c7_to_c4", ".inline upd_only_time_in_c4")) {
 						return Result{2, cmd2};
 					}
@@ -1356,6 +1488,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt4(Pointer<TvmAstNode>
 			bigint sum = 0;
 			sum += (is(cmd2, "ADD") ? +1 : -1) * pushintValue(cmd1);
 			sum += (is(cmd4, "ADD") ? +1 : -1) * pushintValue(cmd3);
+			// TODO DELETE
 			return Result{4, gen("PUSHINT " + toString(sum)), gen("ADD")};
 		}
 	}
@@ -1371,6 +1504,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt4(Pointer<TvmAstNode>
 						   gen("STSLICE")};
 		}
 	}
+	// TODO if value on the top of the stack < 0
 	// ADDCONST/INC/DEC
 	// UFIT/FIT N
 	// ADDCONST/INC/DEC
@@ -1389,6 +1523,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAt4(Pointer<TvmAstNode>
 			}
 		}
 	}
+
 	if (is(cmd1, "PUSHINT") &&
 		is(cmd2, "NEWC") &&
 		is(cmd3, "STSLICECONST") &&
@@ -1638,6 +1773,11 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAtInf(int idx1) const {
 				bitString += StrUtils::toBitString(num, len);
 				opcodeQty += 2;
 				i = nextCommandLine(j);
+			} else if (c2 && is(c1, "PUSHINT") && is(c2, "STVARUINT16", "STGRAMS")) {
+				bigint num = pushintValue(c1);
+				bitString += StrUtils::tonsToBinaryString(num);
+				opcodeQty += 2;
+				i = nextCommandLine(j);
 			} else if (c2 && is(c1, "PUSHINT") && is(c2, "STZEROES")) {
 				int len = fetchInt(c1);
 				bitString += std::string(len, '0');
@@ -1648,12 +1788,6 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAtInf(int idx1) const {
 				bitString += StrUtils::toBitString(hexSlice);
 				opcodeQty += 2;
 				i = nextCommandLine(j);
-			} else if (c2 && is(c1, "PUSHINT") && is(c2, "STGRAMS")) {
-				bigint arg = pushintValue(c1);
-				bitString += StrUtils::tonsToBinaryString(arg);
-				opcodeQty += 2;
-				i = nextCommandLine(j);
-				break;
 			} else {
 				break;
 			}
@@ -1785,6 +1919,29 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAtInf(int idx1) const {
 		}
 	}
 
+	// BLKSWAP n, 1
+	// POP n+1
+	// ...
+	// POP n+1 // n times
+	// =>
+	// BLKDROP2 n, n+1
+	if (isBLKSWAP(cmd1) && idx2 != -1) {
+		auto [n, up] = isBLKSWAP(cmd1).value();
+		if (up == 1) {
+			int index = idx2;
+			bool ok = true;
+			int i = 0;
+			for (; ok && i < n && index != -1; ++i, index = nextCommandLine(index)) {
+				auto cmd = get(index);
+				ok &= isPOP(cmd).has_value() && isPOP(cmd) == n + 1;
+			}
+			ok &= i == n;
+			if (ok) {
+				return Result{n + 1, makeBLKDROP2(n, n + 1)};
+			}
+		}
+	}
+
 	// ROLL n
 	// ROLL n+1
 	// ROLL n+2
@@ -1816,34 +1973,45 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAtInf(int idx1) const {
 
 	// squash stack opcodes
 	{
-		StackState bestState{};
-		int bestQty{};
+		struct BestResult {
+			StackState bestState;
+			int bestStartStackSize = 0;
+			int bestOpcodeQty = 0;
+		};
+		std::optional<BestResult> bestResult;
+
+		for (int startStackSize = 0; startStackSize <= StackState::MAX_STACK_DEPTH; ++startStackSize)
+		{
+			StackState state{startStackSize};
+			int i = idx1;
+			int gasCost = 0;
+			int opcodeQty = 0;
+			while (true) {
+				if (i == -1)
+					break;
+				auto stack = to<Stack>(get(i).get());
+				if (!stack)
+					break;
+				if (!state.apply(*stack)) {
+					break;
+				}
 
-		StackState state;
-		int i = idx1;
-		int qty = 0;
-		while (true) {
-			if (i == -1)
-				break;
-			auto stack = to<Stack>(get(i).get());
-			if (!stack)
-				break;
-			if (!state.apply(*stack)) {
-				break;
-			}
+				++opcodeQty;
+				gasCost += OpcodeUtils::gasCost(*stack);
+				auto newGasCost = StackOpcodeSquasher::gasCost(startStackSize, state, m_withTuck);
+				if (newGasCost.has_value() && newGasCost < gasCost) {
+					bestResult = BestResult{state, startStackSize, opcodeQty};
+				}
 
-			++qty;
-			int steps = StackOpcodeSquasher::steps(state);
-			if (steps != -1 && steps < qty) {
-				bestState = state;
-				bestQty = qty;
+				i = nextCommandLine(i);
 			}
-
-			i = nextCommandLine(i);
 		}
 
-		if (bestQty != 0) {
-			return Result{bestQty, StackOpcodeSquasher::recover(bestState)};
+		if (bestResult.has_value()) {
+			auto newOpcodes = StackOpcodeSquasher::recover(bestResult.value().bestStartStackSize,
+														   bestResult.value().bestState,
+														   m_withTuck);
+			return Result{bestResult.value().bestOpcodeQty, newOpcodes};
 		}
 	}
 
@@ -1908,6 +2076,7 @@ std::optional<Result> PrivatePeepholeOptimizer::optimizeAtInf(int idx1) const {
 						}
 						break;
 					}
+					// TODO implement another cases
 					default:
 						ok = false;
 						break;
@@ -2000,7 +2169,7 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 	auto cmd1Gen = to<Gen>(cmd1.get());
 	auto cmd1PushCellOrSlice = to<PushCellOrSlice>(cmd1.get());
 
-	if (isPUSH(cmd1) && isPUSH(cmd2)) {
+	if (PeepholeOptimizer::withBlockPush && isPUSH(cmd1) && isPUSH(cmd2)) {
 		int i = idx1, n = 0;
 		while (isPUSH(get(i)) && isPUSH(get(i)).value() == isPUSH(cmd1).value()) {
 			n++;
@@ -2011,7 +2180,7 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 		}
 	}
 
-	if (isPUSH(cmd1) && isPUSH(cmd2) && isPUSH(cmd3)) {
+	if (PeepholeOptimizer::withBlockPush && isPUSH(cmd1) && isPUSH(cmd2) && isPUSH(cmd3)) {
 		const int si = *isPUSH(cmd1);
 		const int sj = *isPUSH(cmd2) - 1 == -1? si : *isPUSH(cmd2) - 1;
 		const int sk = *isPUSH(cmd3) - 2 == -1? si : (
@@ -2021,7 +2190,8 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 			return Result{3, makePUSH3(si, sj, sk)};
 		}
 	}
-	if (isPUSH(cmd1) && isPUSH(cmd2)) {
+
+	if (PeepholeOptimizer::withBlockPush && isPUSH(cmd1) && isPUSH(cmd2)) {
 		const int si = *isPUSH(cmd1);
 		const int sj = *isPUSH(cmd2) - 1 == -1? si : *isPUSH(cmd2) - 1;
 		if (si <= 15 && sj <= 15) {
@@ -2031,7 +2201,7 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 
 	// TODO delete
 	// squash PUSHINT, NEWDICT, NILL, FALSE, TRUE, (PUSHINT 0 NEWDICT PAIR) etc
-	if (isPureGen01(*cmd1)) {
+	if (PeepholeOptimizer::withBlockPush && isPureGen01(*cmd1)) {
 		int i = idx1;
 		int n = 0;
 		while (true) {
@@ -2049,7 +2219,7 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 	}
 
 	// squash PUSHREF/PUSHREFSLICE/CELL
-	if (cmd1PushCellOrSlice) {
+	if (PeepholeOptimizer::withBlockPush && cmd1PushCellOrSlice) {
 		int i = idx1;
 		int n = 0;
 		while (true) {
@@ -2067,42 +2237,34 @@ std::optional<Result> PrivatePeepholeOptimizer::squashPush(const int idx1) const
 		}
 	}
 
-	// SWAP
-	// OVER
-	// =>
-	// TUCK
-	if (isXCHG_S0(cmd1) && isXCHG_S0(cmd1).value() == 1 &&
-		isPUSH(cmd2) && *isPUSH(cmd2) == 1
-	) {
-		return Result{2, makeTUCK()};
-	}
-
-	// PUSH Si
-	// SWAP
-	// =>
-	// PUXC Si, S-1
-	if (isPUSH(cmd1) &&
-		isXCHG_S0(cmd2) && isXCHG_S0(cmd2).value() == 1
-	) {
-		int i = *isPUSH(cmd1);
-		if (0 <= i && i <= 15)
-			return Result{2, makePUXC(i, -1)};
-	}
+	if (m_withTuck) {
+		// PUSH Si
+		// SWAP
+		// =>
+		// PUXC Si, S-1
+		if (isPUSH(cmd1) &&
+			isXCHG_S0(cmd2) && isXCHG_S0(cmd2).value() == 1
+		) {
+			int i = *isPUSH(cmd1);
+			if (0 <= i && i <= 15)
+				return Result{2, makePUXC(i, -1)};
+		}
 
-	// XCHG Si
-	// PUSH Sj
-	// =>
-	// XCPU Si, Sj
-	if (m_optimizeSlice &&
-		isXCHG_S0(cmd1) && cmd2 && isPUSH(cmd2)
-	) {
-		int i = isXCHG_S0(cmd1).value();
-		int j = isPUSH(cmd2).value();
-		if (
-			0 <= i && i <= 15 &&
-			0 <= j && j <= 15
+		// XCHG Si
+		// PUSH Sj
+		// =>
+		// XCPU Si, Sj
+		if (m_optimizeSlice &&
+			isXCHG_S0(cmd1) && cmd2 && isPUSH(cmd2)
 		) {
-			return Result{2, makeXCPU(i, j)};
+			int i = isXCHG_S0(cmd1).value();
+			int j = isPUSH(cmd2).value();
+			if (
+				0 <= i && i <= 15 &&
+				0 <= j && j <= 15
+			) {
+				return Result{2, makeXCPU(i, j)};
+			}
 		}
 	}
 
@@ -2201,26 +2363,14 @@ std::optional<std::pair<int, int>> PrivatePeepholeOptimizer::isBLKDROP2(Pointer<
 	return std::nullopt;
 }
 
-std::optional<int> PrivatePeepholeOptimizer::isPUSH(Pointer<TvmAstNode> const& node) {
-	auto stack = to<Stack>(node.get());
-	if (isStack(node, Stack::Opcode::PUSH_S)) {
-		return stack->i();
-	}
-	if (isStack(node, Stack::Opcode::BLKPUSH)) {
-		if (stack->i() == 1)
-			return stack->j();
-	}
-	return {};
-}
-
 bigint PrivatePeepholeOptimizer::pushintValue(Pointer<TvmAstNode> const& node) {
 	solAssert(is(node, "PUSHINT"), "");
-	auto g = dynamic_pointer_cast<GenOpcode>(node);
+	auto g = dynamic_pointer_cast<StackOpcode>(node);
 	return bigint{g->arg()};
 }
 
 int PrivatePeepholeOptimizer::fetchInt(Pointer<TvmAstNode> const& node) {
-	auto g = dynamic_pointer_cast<GenOpcode>(node);
+	auto g = dynamic_pointer_cast<StackOpcode>(node);
 	return strToInt(g->arg());
 }
 
@@ -2232,14 +2382,14 @@ bool PrivatePeepholeOptimizer::isNIP(Pointer<TvmAstNode> const& node) {
 }
 
 std::string PrivatePeepholeOptimizer::arg(Pointer<TvmAstNode> const& node) {
-	auto g = dynamic_pointer_cast<GenOpcode>(node);
+	auto g = dynamic_pointer_cast<StackOpcode>(node);
 	solAssert(g, "");
 	return g->arg();
 }
 
 template<class ...Args>
 bool PrivatePeepholeOptimizer::is(Pointer<TvmAstNode> const& node, Args&&... cmd) {
-	auto g = to<GenOpcode>(node.get());
+	auto g = to<StackOpcode>(node.get());
 	return g && isIn(g->opcode(), std::forward<Args>(cmd)...);
 }
 
@@ -2256,13 +2406,13 @@ bool PrivatePeepholeOptimizer::isExc(Pointer<TvmAstNode> const& node, Args&&...
 }
 
 bool PrivatePeepholeOptimizer::isConstAdd(Pointer<TvmAstNode> const& node) {
-	auto gen = to<GenOpcode>(node.get());
+	auto gen = to<StackOpcode>(node.get());
 	return gen && isIn(gen->opcode(), "INC", "DEC", "ADDCONST");
 }
 
 int PrivatePeepholeOptimizer::getAddNum(Pointer<TvmAstNode> const& node) {
 	solAssert(isConstAdd(node), "");
-	auto gen = to<GenOpcode>(node.get());
+	auto gen = to<StackOpcode>(node.get());
 	solAssert(gen, "");
 	if (gen->opcode() == "INC") {
 		return +1;
@@ -2283,10 +2433,10 @@ bool PrivatePeepholeOptimizer::isStack(Pointer<TvmAstNode> const& node, Stack::O
 
 
 bool PrivatePeepholeOptimizer::isSimpleCommand(Pointer<TvmAstNode> const& node) {
+	// See also isPureGen01
 	auto gen = to<Gen>(node.get());
-	// TODO add another Gen
 	return gen &&
-		(to<GenOpcode>(gen) || to<PushCellOrSlice>(gen) || to<Glob>(gen) || to<Opaque>(gen) || to<HardCode>(gen)) &&
+		   (to<StackOpcode>(gen) || to<PushCellOrSlice>(gen) || to<Glob>(gen) || to<Opaque>(gen) || to<HardCode>(gen)) &&
 		gen->take() == 0 && gen->ret() == 1;
 }
 
@@ -2295,7 +2445,7 @@ bool PrivatePeepholeOptimizer::isAddOrSub(Pointer<TvmAstNode> const& node) {
 }
 
 bool PrivatePeepholeOptimizer::isCommutative(Pointer<TvmAstNode> const& node) {
-	auto g = dynamic_pointer_cast<GenOpcode>(node);
+	auto g = dynamic_pointer_cast<StackOpcode>(node);
 	return g && isIn(g->fullOpcode(),
 					 "ADD",
 					 "AND",
@@ -2310,7 +2460,23 @@ bool PrivatePeepholeOptimizer::isCommutative(Pointer<TvmAstNode> const& node) {
 	);
 }
 
+bool PeepholeOptimizer::visit(CodeBlock &_node) {
+	optimizeBlock(_node);
+	return true;
+}
+
 void PeepholeOptimizer::endVisit(CodeBlock &_node) {
+	optimizeBlock(_node);
+}
+
+bool PeepholeOptimizer::visit(Function &/*_node*/) {
+	//if (_node.name() == "")
+	//	_node.block()->accept(*this);
+	//return false;
+	return true;
+}
+
+void PeepholeOptimizer::optimizeBlock(CodeBlock &_node) const {
 	{
 		std::optional<Result> r = PrivatePeepholeOptimizer::optimizeAt1(_node.shared_from_this(), m_withUnpackOpaque);
 		if (r && r.value().commands.size() == 1) {
@@ -2322,7 +2488,7 @@ void PeepholeOptimizer::endVisit(CodeBlock &_node) {
 
 	std::vector<Pointer<TvmAstNode>> instructions = _node.instructions();
 
-	PrivatePeepholeOptimizer optimizer{instructions, m_withUnpackOpaque, m_optimizeSlice};
+	PrivatePeepholeOptimizer optimizer{instructions, m_withUnpackOpaque, m_optimizeSlice, m_withTuck};
 	optimizer.optimize([&](int index){
 		return optimizer.unsquash(m_withUnpackOpaque, index);
 	});
diff --git a/compiler/libsolidity/codegen/PeepholeOptimizer.hpp b/compiler/libsolidity/codegen/PeepholeOptimizer.hpp
index da5c4884..46e1facc 100644
--- a/compiler/libsolidity/codegen/PeepholeOptimizer.hpp
+++ b/compiler/libsolidity/codegen/PeepholeOptimizer.hpp
@@ -21,12 +21,19 @@
 namespace solidity::frontend {
 	class PeepholeOptimizer : public TvmAstVisitor {
 	public:
-		explicit PeepholeOptimizer(bool _withUnpackOpaque, bool _optimizeSlice)
-			: m_withUnpackOpaque{_withUnpackOpaque}, m_optimizeSlice{_optimizeSlice} {}
+		explicit PeepholeOptimizer(bool _withUnpackOpaque, bool _optimizeSlice, bool _withTuck)
+			: m_withUnpackOpaque{_withUnpackOpaque}, m_optimizeSlice{_optimizeSlice}, m_withTuck{_withTuck} {}
+		bool visit(Function &_node) override;
+		bool visit(CodeBlock &_node) override;
 		void endVisit(CodeBlock &_node) override;
+	private:
+		void optimizeBlock(CodeBlock &_node) const;
 	private:
 		bool m_withUnpackOpaque{};
 		bool m_optimizeSlice{};
+		bool m_withTuck{};
+	public:
+		static bool withBlockPush;
 	};
 } // end solidity::frontend
 
diff --git a/compiler/libsolidity/codegen/StackOpcodeSquasher.cpp b/compiler/libsolidity/codegen/StackOpcodeSquasher.cpp
index 6c1a45b4..ecd60e68 100644
--- a/compiler/libsolidity/codegen/StackOpcodeSquasher.cpp
+++ b/compiler/libsolidity/codegen/StackOpcodeSquasher.cpp
@@ -17,143 +17,441 @@
 #include "StackOpcodeSquasher.hpp"
 
 using namespace solidity::frontend;
+using namespace std;
 
-StackState::StackState() {
-	m_hash = 0;
-	for (int i = 0; i < maxStackDepth; ++i) {
+StackState::StackState(int _size) {
+	m_size = _size;
+	for (int8_t i = 0; i < m_size; ++i) {
 		m_values[i] = i;
-		m_hash = m_hash * 31 + m_values[i];
 	}
+	updHash();
 }
 
 bool StackState::apply(Stack const &opcode) {
+	auto execPUSHS = [this](int index) -> bool {
+		if (index < m_size && m_size + 1 <= StackState::MAX_STACK_DEPTH) {
+			int8_t val = m_values[index];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 1] = m_values[i];
+			m_values[0] = val;
+			++m_size;
+			return true;
+		}
+		return false;
+	};
+	auto execPUXC = [this](int index, int j) -> bool {
+		if (j + 1 < m_size && index < m_size && m_size + 1 <= StackState::MAX_STACK_DEPTH) {
+			int8_t val = m_values[index];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 1] = m_values[i];
+			m_values[0] = val;
+			std::swap(m_values[0], m_values[1]);
+			std::swap(m_values[0], m_values[j + 1]);
+			++m_size;
+			return true;
+		}
+		return false;
+	};
+
 	bool ok = false;
+	int const index0 = opcode.i();
+	int const index1 = opcode.j();
+	int const index2 = opcode.k();
 	switch (opcode.opcode()) {
-		case Stack::Opcode::BLKSWAP: {
-			int down = opcode.i();
-			int up = opcode.j();
-			if (down + up > maxStackDepth) {
-				break;
-			}
-			ok = true;
-			std::reverse(m_values.begin(), m_values.begin() + up);
-			std::reverse(m_values.begin() + up, m_values.begin() + up + down);
-			std::reverse(m_values.begin(), m_values.begin() + up + down);
+	case Stack::Opcode::BLKSWAP: {
+		int down = opcode.i();
+		int up = opcode.j();
+		if (down + up > m_size) {
 			break;
 		}
-		case Stack::Opcode::REVERSE: {
-			int qty = opcode.i();
-			int index = opcode.j();
-			if (index + qty > maxStackDepth) {
-				break;
-			}
+		ok = true;
+		std::reverse(m_values.begin(), m_values.begin() + up);
+		std::reverse(m_values.begin() + up, m_values.begin() + up + down);
+		std::reverse(m_values.begin(), m_values.begin() + up + down);
+		break;
+	}
+	case Stack::Opcode::REVERSE: {
+		int qty = opcode.i();
+		int index = opcode.j();
+		if (index + qty <= m_size) {
+			// [index..index+qty-1]
 			std::reverse(m_values.begin() + index, m_values.begin() + index + qty);
 			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XCHG: {
+		int i = opcode.i();
+		int j = opcode.j();
+		if (i >= m_size || j >= m_size) {
 			break;
 		}
-		case Stack::Opcode::XCHG: {
-			int i = opcode.i();
-			int j = opcode.j();
-			if (i >= maxStackDepth || j >= maxStackDepth) {
-				break;
+		solAssert(i != -1, "");
+		solAssert(j != -1, "");
+		std::swap(m_values[i], m_values[j]);
+		ok = true;
+		break;
+	}
+	case Stack::Opcode::DROP: {
+		int n = opcode.i();
+		if (n < m_size) {
+			for (int i = n; i < m_size; ++i)
+				m_values[i - n] = m_values[i];
+			m_size -= n;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::BLKDROP2: {
+		int const down = opcode.i();
+		int const top = opcode.j();
+		if (down + top <= m_size) {
+			for (int i = top + down; i < m_size; ++i) {
+				m_values[i - down] = m_values[i];
 			}
-			std::swap(m_values[i], m_values[j]);
+			m_size -= down;
 			ok = true;
-			break;
 		}
-
-		// TODO handle these cases
-		case Stack::Opcode::DROP:
-		case Stack::Opcode::BLKDROP2:
-		case Stack::Opcode::POP_S:
-		case Stack::Opcode::BLKPUSH:
-		case Stack::Opcode::PUSH2_S:
-		case Stack::Opcode::PUSH3_S:
-		case Stack::Opcode::PUSH_S:
-		case Stack::Opcode::TUCK:
-		case Stack::Opcode::PUXC:
-		case Stack::Opcode::XCPU: {
-			ok = false;
-			break;
+		break;
+	}
+	case Stack::Opcode::POP_S: {
+		if (opcode.i() < m_size) {
+			m_values[opcode.i()] = m_values[0];
+			for (int i = 1; i < m_size; ++i)
+				m_values[i - 1] = m_values[i];
+			--m_size;
+			ok = true;
 		}
+		break;
 	}
-	m_hash = 0;
-	for (int i = 0; i < maxStackDepth; ++i) {
-		m_hash = m_hash * 31 + m_values[i];
+	case Stack::Opcode::BLKPUSH: {
+		int const qty = opcode.i();
+		int const index = opcode.j();
+		if (m_size + qty <= StackState::MAX_STACK_DEPTH && index < m_size) {
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + qty] = m_values[i];
+			for (int i = qty - 1, j = index + qty; 0 <= i; --i, --j)
+				m_values[i] = m_values[j];
+			m_size += qty;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::PUSH_S: {
+		int const index = opcode.i();
+		if (execPUSHS(index)) {
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::PUSH2_S: {
+		if (std::max(index0, index1) < m_size && m_size + 2 <= StackState::MAX_STACK_DEPTH) {
+			int8_t val0 = m_values[index0];
+			int8_t val1 = m_values[index1];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 2] = m_values[i];
+			m_values[1] = val0;
+			m_values[0] = val1;
+			m_size += 2;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::PUSH3_S: {
+		if (std::max(std::max(index0, index1), index2) < m_size && m_size + 3 <= StackState::MAX_STACK_DEPTH) {
+			int8_t val0 = m_values[index0];
+			int8_t val1 = m_values[index1];
+			int8_t val2 = m_values[index2];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 3] = m_values[i];
+			m_values[2] = val0;
+			m_values[1] = val1;
+			m_values[0] = val2;
+			m_size += 3;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XC2PU: {
+		if (std::max({index0, index1, index2, 1}) < m_size && m_size + 1 <= StackState::MAX_STACK_DEPTH) {
+			std::swap(m_values[1], m_values[index0]);
+			std::swap(m_values[0], m_values[index1]);
+			int8_t value = m_values[index2];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 1] = m_values[i];
+			m_values[0] = value;
+			++m_size;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XCPU: {
+		if (std::max(index0, index1) < m_size && m_size + 1 <= StackState::MAX_STACK_DEPTH) {
+			std::swap(m_values[0], m_values[index0]);
+			int8_t value = m_values[index1];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 1] = m_values[i];
+			m_values[0] = value;
+			++m_size;
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::PUXC: {
+		int const index = opcode.i();
+		int const j = opcode.j();
+		if (execPUXC(index, j)) {
+			ok = true;
+		}
+		break;
 	}
+	case Stack::Opcode::XCHG2: {
+		int const i = opcode.i();
+		int const j = opcode.j();
+		if (std::max(i, j) < m_size) {
+			std::swap(m_values[1], m_values[i]);
+			std::swap(m_values[0], m_values[j]);
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XCHG3: {
+		int const i = opcode.i();
+		int const j = opcode.j();
+		int const k = opcode.k();
+		if (std::max(std::max(2, i), std::max(j, k)) < m_size) {
+			std::swap(m_values[2], m_values[i]);
+			std::swap(m_values[1], m_values[j]);
+			std::swap(m_values[0], m_values[k]);
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::PU2XC: {
+		if (execPUSHS(index0)) {
+			std::swap(m_values[0], m_values[1]);
+			if (execPUXC(index1 + 1, index2 + 1)) {
+				ok = true;
+			}
+		}
+		break;
+	}
+	case Stack::Opcode::PUXCPU: {
+		if (execPUXC(index0, index1) && execPUSHS(index2 + 1)) {
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XCPUXC: {
+		if (std::max(index0, 1) < m_size) {
+			std::swap(m_values[1], m_values[index0]);
+			if (execPUXC(index1, index2)) {
+				ok = true;
+			}
+		}
+		break;
+	}
+	case Stack::Opcode::PUXC2: {
+		if (std::max(std::max(1, index0), std::max(index1, index2)) < m_size && m_size + 1 <= StackState::MAX_STACK_DEPTH) {
+			int8_t val = m_values[index0];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 1] = m_values[i];
+			m_values[0] = val;
+			++m_size;
+			std::swap(m_values[2], m_values[0]);
+			std::swap(m_values[1], m_values[index1 + 1]);
+			std::swap(m_values[0], m_values[index2 + 1]);
+			ok = true;
+		}
+		break;
+	}
+	case Stack::Opcode::XCPU2: {
+		if (std::max(index0, std::max(index1, index2)) < m_size && m_size + 2 <= StackState::MAX_STACK_DEPTH) {
+			std::swap(m_values[0], m_values[index0]);
+			int8_t val1 = m_values[index1];
+			int8_t val2 = m_values[index2];
+			for (int i = m_size - 1; 0 <= i; --i)
+				m_values[i + 2] = m_values[i];
+			m_values[1] = val1;
+			m_values[0] = val2;
+			m_size += 2;
+			ok = true;
+		}
+		break;
+	}
+	}
+
+	if (ok)
+		updHash();
 	return ok;
 }
 
-int StackOpcodeSquasher::steps(StackState const& _state) {
-	if (m_dp.empty()) {
+void StackState::updHash() {
+	m_hash = m_size;
+	for (int i = 0; i < m_size; ++i) {
+		m_hash = m_hash * 31 + m_values[i];
+	}
+}
+
+std::optional<int> StackOpcodeSquasher::gasCost(int startStackSize, StackState const& _state, bool _withCompoundOpcodes) {
+	if (m_dp[_withCompoundOpcodes][StackState::MAX_STACK_DEPTH].empty()) {
 		init();
 	}
-	auto it = m_dp.find(_state);
-	if (it == m_dp.end()) {
-		return -1;
+	auto it = m_dp[_withCompoundOpcodes][startStackSize].find(_state);
+	if (it == m_dp[_withCompoundOpcodes][startStackSize].end()) {
+		return std::nullopt;
 	}
-	return it->second;
+	return it->second.gasCost;
 }
 
-std::unordered_map<StackState, int8_t> StackOpcodeSquasher::m_dp {};
-std::unordered_map<StackState, std::pair<StackState, Pointer<Stack>>> StackOpcodeSquasher::m_prev {};
+std::array<std::array<std::unordered_map<StackState, StackOpcodeSquasher::DpState>, StackState::MAX_STACK_DEPTH + 1>, 2> StackOpcodeSquasher::m_dp {};
 
 void StackOpcodeSquasher::init() {
-	std::vector<Pointer<Stack>> edges;
-	for (int down = 1; down < StackState::maxStackDepth; ++down) {
-		for (int up = 1; down + up < StackState::maxStackDepth; ++up) {
-			edges.emplace_back(std::make_shared<Stack>(Stack::Opcode::BLKSWAP, down, up));
-		}
-	}
-	for (int i = 0; i < StackState::maxStackDepth; ++i) {
-		for (int j = i + 1; j < StackState::maxStackDepth; ++j) {
-			edges.emplace_back(std::make_shared<Stack>(Stack::Opcode::XCHG, i, j));
-		}
-	}
-	for (int i = 0; i < StackState::maxStackDepth; ++i) {
-		for (int n = 2; i + n <= StackState::maxStackDepth; ++n) {
-			edges.emplace_back(std::make_shared<Stack>(Stack::Opcode::REVERSE, n, i));
-		}
-	}
+	for (int _withCompoundOpcodes = 0; _withCompoundOpcodes <= 1; ++_withCompoundOpcodes) {
+		struct Edge {
+			Pointer<Stack> opcode;
+			int gas{};
+		};
+		std::vector<Edge> edges;
+		auto addEdge = [&](auto const& opcode){
+			edges.emplace_back(Edge{opcode, OpcodeUtils::gasCost(*opcode)});
+		};
 
+		for (int i = 1; i < StackState::MAX_STACK_DEPTH; ++i)
+			addEdge(std::make_shared<Stack>(Stack::Opcode::POP_S, i));
+		for (int down = 1; down <= StackState::MAX_STACK_DEPTH; ++down)
+			for (int up = 1; down + up <= StackState::MAX_STACK_DEPTH; ++up)
+				addEdge(std::make_shared<Stack>(Stack::Opcode::BLKDROP2, down, up));
+		for (int n = 1; n <= StackState::MAX_STACK_DEPTH; ++n)
+			addEdge(std::make_shared<Stack>(Stack::Opcode::DROP, n));
+		for (int down = 1; down < StackState::MAX_STACK_DEPTH; ++down)
+			for (int up = 1; down + up < StackState::MAX_STACK_DEPTH; ++up)
+				addEdge(std::make_shared<Stack>(Stack::Opcode::BLKSWAP, down, up));
+		for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+			for (int j = i + 1; j < StackState::MAX_STACK_DEPTH; ++j)
+				addEdge(std::make_shared<Stack>(Stack::Opcode::XCHG, i, j));
+		for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+			for (int n = 2; i + n <= StackState::MAX_STACK_DEPTH; ++n)
+				addEdge(std::make_shared<Stack>(Stack::Opcode::REVERSE, n, i));
+		for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+			addEdge(std::make_shared<Stack>(Stack::Opcode::PUSH_S, i));
 
-	//std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
-	StackState state;
-	m_dp[state] = 0;
-	std::deque<StackState> q;
-	q.push_back(state);
-	while (!q.empty()) {
-		state = q.front();
-		q.pop_front();
-		int8_t nextDp = m_dp.at(state) + 1;
-		if (nextDp == 4) {
-			break;
+		if (_withCompoundOpcodes)
+		{
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int qty = 2; i + 1 + qty <= StackState::MAX_STACK_DEPTH; ++qty)
+					addEdge(std::make_shared<Stack>(Stack::Opcode::BLKPUSH, qty, i));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					addEdge(std::make_shared<Stack>(Stack::Opcode::PUSH2_S, i, j));
+			for (int i = 1; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					addEdge(std::make_shared<Stack>(Stack::Opcode::XCPU, i, j));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = -1; j < StackState::MAX_STACK_DEPTH; ++j)
+					addEdge(std::make_shared<Stack>(Stack::Opcode::PUXC, i, j));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					addEdge(std::make_shared<Stack>(Stack::Opcode::XCHG2, i, j));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = 0; k < StackState::MAX_STACK_DEPTH; ++k) {
+						addEdge(std::make_shared<Stack>(Stack::Opcode::XC2PU, i, j, k));
+						addEdge(std::make_shared<Stack>(Stack::Opcode::XCPU2, i, j, k));
+						addEdge(std::make_shared<Stack>(Stack::Opcode::XCHG3, i, j, k));
+					}
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = -1; j + 1 < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = -1; k + 1 < StackState::MAX_STACK_DEPTH; ++k)
+						addEdge(std::make_shared<Stack>(Stack::Opcode::PUXC2, i, j, k));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = -1; k + 1 < StackState::MAX_STACK_DEPTH; ++k)
+						addEdge(std::make_shared<Stack>(Stack::Opcode::XCPUXC, i, j, k));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = -1; j + 1 < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = -1; k + 1 < StackState::MAX_STACK_DEPTH; ++k)
+						addEdge(std::make_shared<Stack>(Stack::Opcode::PUXCPU, i, j, k));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = -1; j + 1 < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = -2; k + 2 < StackState::MAX_STACK_DEPTH; ++k)
+						addEdge(std::make_shared<Stack>(Stack::Opcode::PU2XC, i, j, k));
+			for (int i = 0; i < StackState::MAX_STACK_DEPTH; ++i)
+				for (int j = 0; j < StackState::MAX_STACK_DEPTH; ++j)
+					for (int k = 0; k < StackState::MAX_STACK_DEPTH; ++k)
+						addEdge(std::make_shared<Stack>(Stack::Opcode::PUSH3_S, i, j, k));
 		}
-		for (Pointer<Stack> const &e: edges) {
-			StackState nextState = state;
-			nextState.apply(*e.get());
-			auto it = m_dp.find(nextState);
-			if (it == m_dp.end()) {
-				m_dp.emplace_hint(it, nextState, nextDp);
-				m_prev.emplace(nextState, std::make_pair(state, e));
-				q.push_back(nextState);
+
+		std::stable_sort(edges.begin(), edges.end(), [](Edge const &a, Edge const &b){
+			return a.gas < b.gas;
+		});
+
+		int const MAX_DEPTH = _withCompoundOpcodes ? 2 : MAX_NEW_OPCODES;
+		using namespace std::chrono;
+		//auto begin = high_resolution_clock::now();
+		for (int stackSize = 0; stackSize <= StackState::MAX_STACK_DEPTH; ++stackSize) {
+			struct QData {
+				StackState state;
+				int gas{};
+				int8_t opcodeQty{};
+			};
+			std::unordered_map<StackState, DpState> dp;
+			auto comp = [](QData const& x, QData const& y){
+				if (x.gas != y.gas)
+					return x.gas < y.gas;
+				return x.state.getHash() < y.state.getHash();
+			};
+			auto q = std::set<QData, decltype(comp)>(comp);
+			{
+				StackState state{stackSize};
+				dp.emplace(state, DpState{0, StackState{stackSize}, nullptr});
+				q.emplace(QData{state, 0, 0});
+			}
+			while (!q.empty()) {
+				auto front = q.begin();
+				StackState const state = front->state;
+				int8_t const nextOpcodeQty = front->opcodeQty + 1;
+				int const gas = front->gas;
+				q.erase(front);
+				for (Edge const &e: edges) {
+					StackState nextState = state;
+					if (nextState.apply(*e.opcode)) {
+						auto it = dp.find(nextState);
+						int nextGasCost = gas + e.gas;
+						if (it == dp.end()) {
+							dp.emplace(nextState, DpState{nextGasCost, state, e.opcode});
+							if (nextOpcodeQty < MAX_DEPTH)
+								q.emplace(QData{nextState, nextGasCost, nextOpcodeQty});
+						} else if (it->second.gasCost > nextGasCost) {
+							q.erase(QData{nextState, it->second.gasCost});
+							dp.erase(it);
+							dp.emplace(nextState, DpState{nextGasCost, state, e.opcode});
+							if (nextOpcodeQty < MAX_DEPTH) {
+								q.emplace(QData{nextState, nextGasCost, nextOpcodeQty});
+							}
+						}
+					}
+				}
 			}
+			m_dp[_withCompoundOpcodes][stackSize] = dp;
 		}
+		//auto end = high_resolution_clock::now();
+		//auto duration = duration_cast<std::chrono::milliseconds>(end - begin);
+		//std::cerr << "Time difference = " << duration.count() << "[ms]" << std::endl;
+		//double size = m_dp.at(_withCompoundOpcodes).at(StackState::MAX_STACK_DEPTH).size();
+		//std::cerr << "dp.size() = " << size << ": " << (size * 20) / (1024 * 1024) << " MB" << std::endl;
 	}
-	//std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
-	//std::cerr << "Time difference = " << std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count() << "[ms]" << std::endl;
 }
 
-
-std::vector<Pointer<TvmAstNode>> StackOpcodeSquasher::recover(StackState state) {
+std::vector<Pointer<TvmAstNode>> StackOpcodeSquasher::recover(int startStackSize, StackState state, bool _withCompoundOpcodes) {
 	std::vector<Pointer<TvmAstNode>> res;
-	StackState start;
+	StackState start{startStackSize};
+	auto const& prev = m_dp.at(_withCompoundOpcodes).at(startStackSize);
 	while (state != start) {
-		std::pair<StackState, Pointer<Stack>> p = m_prev.at(state);
-		state = p.first;
-		res.push_back(p.second);
+		auto const& it = prev.at(state);
+		state = it.prevState;
+		res.push_back(it.opcode);
 	}
 	std::reverse(res.begin(), res.end());
 	return res;
 }
-
diff --git a/compiler/libsolidity/codegen/StackOpcodeSquasher.hpp b/compiler/libsolidity/codegen/StackOpcodeSquasher.hpp
index a14ee027..d6d530d9 100644
--- a/compiler/libsolidity/codegen/StackOpcodeSquasher.hpp
+++ b/compiler/libsolidity/codegen/StackOpcodeSquasher.hpp
@@ -14,48 +14,68 @@
 #pragma once
 
 #include "TvmAst.hpp"
+#include <map>
 #include <unordered_map>
 
 namespace solidity::frontend {
 
-	class StackState {
-	public:
-		constexpr static int maxStackDepth = 9;
-
-		StackState();
-		bool apply(Stack const& opcode);
-		bool operator==(const StackState &other) const {
-			return m_values == other.m_values;
-		}
-		bool operator!=(const StackState &other) const {
-			return m_values != other.m_values;
-		}
-		std::size_t getHash() const { return m_hash; }
-	private:
-		std::size_t m_hash{};
-		std::array<int8_t, maxStackDepth> m_values{};
-	};
+constexpr static int MAX_NEW_OPCODES = 3;
+
+class StackState {
+public:
+	constexpr static int MAX_STACK_DEPTH = 9;
+
+	explicit StackState(int _size);
+	explicit StackState(int8_t _size, std::array<int8_t, MAX_STACK_DEPTH> _values) : m_size{_size}, m_values{_values} {
+		updHash();
+	}
+	bool apply(Stack const& opcode);
+	bool operator==(const StackState &other) const {
+		if (m_size != other.m_size)
+			return false;
+		for (int i = 0; i < m_size; ++i)
+			if (m_values[i] != other.m_values[i])
+				return false;
+		return true;
+	}
+	bool operator!=(const StackState &other) const {
+		return !operator==(other);
+	}
+	std::size_t getHash() const { return m_hash; }
+	int8_t size() const { return m_size; }
+	std::array<int8_t, MAX_STACK_DEPTH> const& values() const { return m_values; }
+private:
+	void updHash();
+private:
+	std::size_t m_hash{};
+	int8_t m_size;
+	std::array<int8_t, MAX_STACK_DEPTH> m_values{};
+};
 
-	class StackOpcodeSquasher {
-	public:
-		static int steps(StackState const& _state);
-	private:
-		static void init();
-	public:
-		static std::vector<Pointer<TvmAstNode>> recover(StackState state);
-	private:
-		static std::unordered_map<StackState, int8_t> m_dp;
-		static std::unordered_map<StackState, std::pair<StackState, Pointer<Stack>>> m_prev;
+class StackOpcodeSquasher {
+public:
+	static std::optional<int> gasCost(int startStackSize, StackState const& _state, bool _withCompoundOpcodes);
+private:
+	static void init();
+public:
+	static std::vector<Pointer<TvmAstNode>> recover(int startStackSize, StackState state, bool _withCompoundOpcodes);
+	struct DpState {
+		int gasCost;
+		StackState prevState;
+		Pointer<Stack> opcode;
 	};
+private:
+	static std::array<std::array<std::unordered_map<StackState, DpState>, StackState::MAX_STACK_DEPTH + 1>, 2> m_dp;
+};
 } // end solidity::frontend
 
 namespace std {
 
 template <>
 struct hash<solidity::frontend::StackState> {
-	std::size_t operator()(const solidity::frontend::StackState& k) const {
-		return k.getHash();
-	}
+std::size_t operator()(const solidity::frontend::StackState& k) const {
+	return k.getHash();
+}
 };
 
 }
diff --git a/compiler/libsolidity/codegen/StackOptimizer.cpp b/compiler/libsolidity/codegen/StackOptimizer.cpp
index a2f13468..756a7bfe 100644
--- a/compiler/libsolidity/codegen/StackOptimizer.cpp
+++ b/compiler/libsolidity/codegen/StackOptimizer.cpp
@@ -63,7 +63,7 @@ bool StackOptimizer::visit(TvmException &_node) {
 	return false;
 }
 
-bool StackOptimizer::visit(GenOpcode &_node) {
+bool StackOptimizer::visit(StackOpcode &_node) {
 	delta(- _node.take() + _node.ret());
 	return false;
 }
@@ -98,38 +98,39 @@ bool StackOptimizer::visit(Glob &_node) {
 bool StackOptimizer::visit(Stack &_node) {
 	int delta{};
 	switch (_node.opcode()) {
-		case Stack::Opcode::DROP:
-		case Stack::Opcode::BLKDROP2:
-			delta = - _node.i();
-			break;
-
-		case Stack::Opcode::POP_S:
-			delta = -1;
-			break;
-
-		case Stack::Opcode::BLKPUSH:
-			delta = _node.i();
-			break;
-		case Stack::Opcode::PUSH2_S:
-			delta = 2;
-			break;
-		case Stack::Opcode::PUSH3_S:
-			delta = 3;
-			break;
-		case Stack::Opcode::PUSH_S:
-			delta = 1;
-			break;
-
-		case Stack::Opcode::BLKSWAP:
-		case Stack::Opcode::REVERSE:
-		case Stack::Opcode::XCHG:
-			break;
-
-		case Stack::Opcode::TUCK:
-		case Stack::Opcode::PUXC:
-		case Stack::Opcode::XCPU:
-			delta = 1;
-			break;
+	case Stack::Opcode::BLKPUSH:
+		delta = _node.i();
+		break;
+	case Stack::Opcode::DROP:
+	case Stack::Opcode::BLKDROP2:
+		delta = - _node.i();
+		break;
+	case Stack::Opcode::POP_S:
+		delta = -1;
+		break;
+	case Stack::Opcode::BLKSWAP:
+	case Stack::Opcode::REVERSE:
+	case Stack::Opcode::XCHG:
+	case Stack::Opcode::XCHG2:
+	case Stack::Opcode::XCHG3:
+		break;
+	case Stack::Opcode::PUXC:
+	case Stack::Opcode::XCPU:
+	case Stack::Opcode::XC2PU:
+	case Stack::Opcode::PUXC2:
+	case Stack::Opcode::XCPUXC:
+	case Stack::Opcode::PUSH_S:
+		delta = 1;
+		break;
+	case Stack::Opcode::PUSH2_S:
+	case Stack::Opcode::XCPU2:
+	case Stack::Opcode::PUXCPU:
+	case Stack::Opcode::PU2XC:
+		delta = 2;
+		break;
+	case Stack::Opcode::PUSH3_S:
+		delta = 3;
+		break;
 	}
 	this->delta(delta);
 	return false;
@@ -318,8 +319,11 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 	if (to<Loc>(op.get()))
 		return false;
 
+	size_t index2 = index + 1;
+	while (index2 < instructions.size() && isLoc(instructions.at(index2)))
+		++index2;
+
 	auto stack = to<Stack>(op.get());
-	bool cmd1IsPUSH= stack && stack->opcode() == Stack::Opcode::PUSH_S;
 	bool ok = false;
 	std::vector<Pointer<TvmAstNode>> commands;
 
@@ -332,7 +336,7 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 	if (auto gen = to<Gen>(op.get());
 		gen && gen->isPure() && std::make_pair(gen->take(), gen->ret()) == std::make_pair(0, 1)
 	) {
-		Simulator sim{instructions.begin() + index + 1, instructions.end(), 1, 1};
+		Simulator sim{instructions.begin() + index + 1, instructions.end(), 1, 1, false, true};
 		bool good = true;
 		{
 			auto glob = to<Glob>(op.get());
@@ -355,6 +359,129 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 		}
 	}
 
+	// DUP
+	// ...
+	// POP Si
+	// =>
+	// ...
+	// BLKSWAP i-1, 1
+	if (!ok && isPUSH(op) && isPUSH(op).value() == 0) {
+		Simulator sim{instructions.begin() + index + 1, instructions.end(), 2, 1, true};
+		if (sim.wasSet()) {
+			ok = true;
+			commands.insert(commands.end(), sim.commands().begin(), sim.commands().end());
+			auto iter = sim.getIter();
+			auto popSi = isPOP(*iter);
+			solAssert(popSi && *popSi >= 2, "");
+			commands.emplace_back(makeBLKSWAP(*popSi - 1, 1));
+			++iter;
+			for ( ; iter != instructions.end(); ++iter) {
+				commands.emplace_back(*iter);
+			}
+		}
+	}
+
+	// ROLLREV X
+	// ...
+	// POP Si
+	// =>
+	// DROP
+	// ...
+	// BLKSWAP 1, i-1
+	if (!ok && isBLKSWAP(op)) {
+		auto [bottom, top] = isBLKSWAP(op).value();
+		if (top == 1) {
+			Simulator sim{instructions.begin() + index + 1, instructions.end(), bottom + 1, 1, true};
+			if (sim.wasSet()) {
+				ok = true;
+				commands.emplace_back(makeDROP());
+				commands.insert(commands.end(), sim.commands().begin(), sim.commands().end());
+				auto iter = sim.getIter();
+				auto popSi = isPOP(*iter);
+				solAssert(popSi && *popSi >= 2, "");
+				commands.emplace_back(makeBLKSWAP(*popSi - 1, 1));
+				++iter;
+				for ( ; iter != instructions.end(); ++iter) {
+					commands.emplace_back(*iter);
+				}
+			}
+		}
+	}
+
+	// gen01
+	// ...
+	// POP Si
+	// =>
+	// ...
+	// BLKSWAP 1, i-1
+	if (!ok && isPureGen01(*op)) {
+		Simulator sim{instructions.begin() + index + 1, instructions.end(), 1, 1, true};
+		if (sim.wasSet()) {
+			ok = true;
+			commands.insert(commands.end(), sim.commands().begin(), sim.commands().end());
+			auto iter = sim.getIter();
+			auto popSi = isPOP(*iter);
+			solAssert(popSi && *popSi >= 2, "");
+			commands.emplace_back(makeBLKSWAP(*popSi - 1, 1));
+			++iter;
+			for ( ; iter != instructions.end(); ++iter) {
+				commands.emplace_back(*iter);
+			}
+		}
+	}
+
+	// BLKSWAP N, 1
+	// PUSH S[N]
+	// ...
+	// POP S?
+	// =>
+	// ...
+	// BLKSWAP ?, 1
+	if (!ok && isBLKSWAP(op) && isBLKSWAP(op).value().second == 1) {
+		int const n = isBLKSWAP(op).value().first;
+		if (index2 != instructions.size()) {
+			auto pushS = isPUSH(instructions.at(index2));
+			if (pushS && pushS.value() == n) {
+				Simulator sim{instructions.begin() + index2 + 1, instructions.end(), n + 2, 1, true};
+				if (sim.wasSet()) {
+					ok = true;
+					commands.insert(commands.end(), instructions.begin() + index + 1, instructions.begin() + index2);
+					commands.insert(commands.end(), sim.commands().begin(), sim.commands().end());
+					auto iter = sim.getIter();
+					auto popSi = isPOP(*iter);
+					solAssert(popSi && *popSi >= 2, "");
+					commands.emplace_back(makeBLKSWAP(*popSi - 1, 1));
+					++iter;
+					for ( ; iter != instructions.end(); ++iter) {
+						commands.emplace_back(*iter);
+					}
+				}
+			}
+		}
+	}
+
+	// POP S[i]
+	// PUSH S[i-1]
+	// ...
+	// POP S?
+	// =>
+	// ...
+	// POP S?
+	if (!ok && isPOP(op)) {
+		if (index2 != instructions.size()) {
+			auto pushS = isPUSH(instructions.at(index2));
+			if (pushS && *pushS + 1 == *isPOP(op)) {
+				Simulator sim{instructions.begin() + index2 + 1, instructions.end(), *isPOP(op) + 1, 1, true};
+				if (sim.wasSet()) {
+					ok = true;
+					// we take original commands because we don't remove value from stack
+					commands.insert(commands.end(), instructions.begin() + index + 1, instructions.begin() + index2);
+					commands.insert(commands.end(), instructions.begin() + index2 + 1, instructions.end());
+				}
+			}
+		}
+	}
+
 	// POP Si
 	// =>
 	// DROP
@@ -402,10 +529,15 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 		}
 	}
 
-	if (!ok && cmd1IsPUSH) {
+	if (!ok && isPUSH(op)) {
 		int Si = stack->i();
 
-		// try to delete values
+		// PUSH Si
+		// ... S[0..i-1] aren not used anymore
+		// =>
+		// BLKDROP i
+		// PUSH S0
+		// ...
 		if (Si <= scopeSize() && Si > 0) {
 			Simulator sim{instructions.begin() + index + 1, instructions.end(), Si + 1, Si};
 			if (sim.success()) {
@@ -433,6 +565,10 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 		}
 	}
 
+	// gen01
+	// ...
+	// =>
+	// ...
 	if (!ok && isPureGen01(*op)) {
 		int startStackSize = 1;
 		Simulator sim{instructions.begin() + index + 1, instructions.end(), startStackSize, 1};
@@ -442,6 +578,11 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 		}
 	}
 
+	// Delete useless variable from the stack
+	// ...
+	// =>
+	// DROP
+	// ...
 	if (!ok && !isDrop(op)) {
 		bool isPrevFlag{};
 		if (index > 0) {
@@ -458,7 +599,30 @@ bool StackOptimizer::successfullyUpdate(int index, std::vector<Pointer<TvmAstNod
 			}
 		}
 	}
-
+	// TODO : fails for NIP IFRET
+	// Delete useless variable from the stack
+	// ...
+	// =>
+	// NIP
+	// ...
+	//if (!ok && !isPOP(op) && !isDrop(op)) {
+	//	if (scopeSize() >= 2) {
+	//		auto beg = instructions.begin() + index;
+	//		Simulator sim{beg, instructions.end(), 2, 1};
+	//		if (sim.success()) {
+	//			ok = true;
+	//			commands.emplace_back(makeBLKDROP2(1, 1));
+	//			commands.insert(commands.end(), sim.commands().begin(), sim.commands().end());
+	//		}
+	//	}
+	//}
+
+	// Delete useless variable from the stack
+	// DROP N
+	// ...
+	// =>
+	// DROP N+1
+	// ...
 	if (!ok && isDrop(op)) {
 		int n = isDrop(op).value();
 		auto beg = instructions.begin() + index + 1;
diff --git a/compiler/libsolidity/codegen/StackOptimizer.hpp b/compiler/libsolidity/codegen/StackOptimizer.hpp
index 4ccf7fbb..055f024b 100644
--- a/compiler/libsolidity/codegen/StackOptimizer.hpp
+++ b/compiler/libsolidity/codegen/StackOptimizer.hpp
@@ -19,44 +19,44 @@
 #include <libsolidity/codegen/TvmAstVisitor.hpp>
 
 namespace solidity::frontend {
-	class StackOptimizer : public TvmAstVisitor {
-	public:
-		bool visit(DeclRetFlag &_node) override;
-		bool visit(Opaque &_node) override;
-		bool visit(HardCode &_node) override;
-		bool visit(Loc &_node) override;
-		bool visit(TvmReturn &_node) override;
-		bool visit(ReturnOrBreakOrCont &_node) override;
-		bool visit(TvmException &_node) override;
-		bool visit(GenOpcode &_node) override;
-		bool visit(PushCellOrSlice &_node) override;
-		bool visit(Glob &_node) override;
-		bool visit(Stack &_node) override;
-		bool visit(CodeBlock &_node) override;
-		bool visit(SubProgram &_node) override;
-		bool visit(LogCircuit &_node) override;
-		bool visit(TvmIfElse &_node) override;
-		bool visit(TvmRepeat &_node) override;
-		bool visit(TvmUntil &_node) override;
-		bool visit(TryCatch &_node) override;
-		bool visit(While &_node) override;
-		bool visit(Function &_node) override;
-		bool visit(Contract &_node) override;
-		void endVisit(CodeBlock &_node) override;
-	protected:
-		bool visitNode(TvmAstNode const&) override;
-		void endVisitNode(TvmAstNode const&) override;
-	private:
-		bool successfullyUpdate(int index, std::vector<Pointer<TvmAstNode>>& instructions);
-		void initStack(int size);
-		void delta(int delta);
-		int size();
-		int scopeSize();
-		void startScope();
-		void endScope();
-	private:
-		bool m_didSome{};
-		std::vector<int> m_stackSize;
-	};
+class StackOptimizer : public TvmAstVisitor {
+public:
+	bool visit(DeclRetFlag &_node) override;
+	bool visit(Opaque &_node) override;
+	bool visit(HardCode &_node) override;
+	bool visit(Loc &_node) override;
+	bool visit(TvmReturn &_node) override;
+	bool visit(ReturnOrBreakOrCont &_node) override;
+	bool visit(TvmException &_node) override;
+	bool visit(StackOpcode &_node) override;
+	bool visit(PushCellOrSlice &_node) override;
+	bool visit(Glob &_node) override;
+	bool visit(Stack &_node) override;
+	bool visit(CodeBlock &_node) override;
+	bool visit(SubProgram &_node) override;
+	bool visit(LogCircuit &_node) override;
+	bool visit(TvmIfElse &_node) override;
+	bool visit(TvmRepeat &_node) override;
+	bool visit(TvmUntil &_node) override;
+	bool visit(TryCatch &_node) override;
+	bool visit(While &_node) override;
+	bool visit(Function &_node) override;
+	bool visit(Contract &_node) override;
+	void endVisit(CodeBlock &_node) override;
+protected:
+	bool visitNode(TvmAstNode const&) override;
+	void endVisitNode(TvmAstNode const&) override;
+private:
+	bool successfullyUpdate(int index, std::vector<Pointer<TvmAstNode>>& instructions);
+	void initStack(int size);
+	void delta(int delta);
+	int size();
+	int scopeSize();
+	void startScope();
+	void endScope();
+private:
+	bool m_didSome{};
+	std::vector<int> m_stackSize;
+};
 } // end solidity::frontend
 
diff --git a/compiler/libsolidity/codegen/TVMABI.cpp b/compiler/libsolidity/codegen/TVMABI.cpp
index 0b16b212..f05467b0 100644
--- a/compiler/libsolidity/codegen/TVMABI.cpp
+++ b/compiler/libsolidity/codegen/TVMABI.cpp
@@ -13,7 +13,7 @@
 
 #include <boost/algorithm/string.hpp>
 
-#include "libsolutil/picosha2.h"
+#include <libsolutil/picosha2.h>
 #include <libsolidity/ast/TypeProvider.h>
 #include <libsolidity/analysis/TypeChecker.h>
 
@@ -48,7 +48,7 @@ Json::Value TVMABI::generateFunctionIdsJson(
 	if (map.count("constructor") == 0) {
 		map["constructor"] = encoder.calculateConstructorFunctionID();
 	}
-	for (VariableDeclaration const* vd : ctx.notConstantStateVariables()) {
+	for (VariableDeclaration const* vd : ctx.c4StateVariables()) {
 		if (vd->isPublic()) {
 			std::vector<VariableDeclaration const*> outputs = {vd};
 			uint32_t functionId = encoder.calculateFunctionIDWithReason(
@@ -81,10 +81,10 @@ TVMABI::generatePrivateFunctionIdsJson(
 	Json::Value ids{Json::arrayValue};
 	Pointer<Contract> codeContract = TVMContractCompiler::generateContractCode(&contract, _sourceUnits, pragmaHelper);
 	for (Pointer<Function> const& fun : codeContract->functions()) {
+		FunctionDefinition const* def = fun->functionDefinition();
 		if (fun->type() == Function::FunctionType::Fragment && fun->functionId()) {
 			Json::Value func{Json::objectValue};
-			FunctionDefinition const* def = fun->functionDefinition();
-			func["scope"] = def->annotation().contract->name();
+			func["scope"] = def->isFree() ? "" : def->annotation().contract->name();
 			func["sign"] = def->externalSignature();
 			func["id"] = fun->functionId().value();
 			ids.append(func);
@@ -117,7 +117,7 @@ Json::Value TVMABI::generateABIJson(
 
 	Json::Value root(Json::objectValue);
 	root["ABI version"] = 2;
-	root["version"] = "2.3";
+	root["version"] = "2.4";
 
 	// header
 	{
@@ -148,7 +148,7 @@ Json::Value TVMABI::generateABIJson(
 		}
 
 		// add public state variables to functions
-		for (VariableDeclaration const* vd : ctx.notConstantStateVariables()) {
+		for (VariableDeclaration const* vd : ctx.c4StateVariables()) {
 			if (vd->isPublic()) {
 				functions.append(toJson(vd->name(), {}, {vd}));
 			}
@@ -183,17 +183,6 @@ Json::Value TVMABI::generateABIJson(
 		root["events"] = eventAbi;
 	}
 
-	// data
-	{
-		Json::Value data(Json::arrayValue);
-		for (const auto &[v, index] : ctx.getStaticVariables()) {
-			Json::Value cur = setupNameTypeComponents(v->name(), v->type());
-			cur["key"] = index;
-			data.append(cur);
-		}
-		root["data"] = data;
-	}
-
 	// fields
 	{
 		Json::Value fields(Json::arrayValue);
@@ -210,11 +199,26 @@ Json::Value TVMABI::generateABIJson(
 			Json::Value field(Json::objectValue);
 			field["name"] = name;
 			field["type"] = type;
+			field["init"] = name == "_pubkey";
 			fields.append(field);
 		}
 
-		for (VariableDeclaration const* stateVar : ctx.notConstantStateVariables()) {
-			Json::Value cur = setupNameTypeComponents(stateVar->name(), stateVar->type());
+		std::vector<VariableDeclaration const *> stateVars = ctx.c4StateVariables();
+		std::set<std::string> usedNames;
+		std::vector<std::tuple<std::string, Type const*, bool>> namesTypes;
+		for (VariableDeclaration const * var : stateVars | boost::adaptors::reversed) {
+			std::string name = var->name();
+			if (usedNames.count(name) != 0)
+				name = var->annotation().contract->name() + "$" + var->name();
+			solAssert(usedNames.count(name) == 0, "");
+			usedNames.insert(name);
+			namesTypes.emplace_back(name, var->type(), var->isStatic());
+		}
+		std::reverse(namesTypes.begin(), namesTypes.end());
+
+		for (auto const&[name, type, isStatic] : namesTypes) {
+			Json::Value cur = setupNameTypeComponents(name, type);
+			cur["init"] = isStatic;
 			fields.append(cur);
 		}
 		root["fields"] = fields;
@@ -257,10 +261,6 @@ void TVMABI::generateABI(
 	print(root["functions"], out);
 	*out << "\t" << "],\n";
 
-	*out << "\t" << R"("data": [)" << "\n";
-	printData(root["data"], out);
-	*out << "\t" << "],\n";
-
 	*out << "\t" << R"("events": [)" << "\n";
 	print(root["events"], out);
 
@@ -451,6 +451,8 @@ Json::Value TVMABI::setupNameTypeComponents(const string &name, const Type *type
 			auto varInt = to<VarIntegerType>(type);
 			typeName = varInt->toString(false);
 			boost::algorithm::to_lower(typeName);
+		} else if (auto* fixedBytesType = to<FixedBytesType>(type)) {
+			typeName = "fixedbytes" + toString(fixedBytesType->numBytes());
 		} else if (ti.isNumeric) {
 			if (to<BoolType>(type)) {
 				typeName = "bool";
@@ -1038,12 +1040,12 @@ void ChainDataEncoder::createMsgBody(
 }
 
 // arg[n-1], ..., arg[1], arg[0], builder
-// Target: create and append to msgBuilder the message body
+// Target: create and append to `builder` the args
 void ChainDataEncoder::encodeParameters(
 	const std::vector<Type const *> & _types,
 	DecodePositionAbiV2 &position
 ) {
-	// builder must be situated on top stack
+	// builder must be located on the top of stack
 	std::vector<Type const *> typesOnStack{_types.rbegin(), _types.rend()};
 	while (!typesOnStack.empty()) {
 		const int argQty = typesOnStack.size();
@@ -1058,6 +1060,8 @@ void ChainDataEncoder::encodeParameters(
 			for (const ASTPointer<VariableDeclaration>& m : members | boost::adaptors::reversed) {
 				typesOnStack.push_back(m->type());
 			}
+		} else if (auto userDefType = to<UserDefinedValueType>(type)) {
+			typesOnStack.push_back(&userDefType->underlyingType());
 		} else {
 			if (position.loadNextCell(type)) {
 				// arg[n-1], ..., arg[1], arg[0], builder
diff --git a/compiler/libsolidity/codegen/TVMAnalyzer.cpp b/compiler/libsolidity/codegen/TVMAnalyzer.cpp
index 61cfbd60..f2f8854f 100644
--- a/compiler/libsolidity/codegen/TVMAnalyzer.cpp
+++ b/compiler/libsolidity/codegen/TVMAnalyzer.cpp
@@ -36,7 +36,7 @@ bool TVMAnalyzer::analyze(const SourceUnit &_sourceUnit)
 bool TVMAnalyzer::visit(MemberAccess const& _node) {
 	auto funType = to<FunctionType>(_node.annotation().type);
 	if (funType) {
-		if (funType->bound()) {
+		if (funType->hasBoundFirstArgument()) {
 			auto printError = [&]{
 				m_errorReporter.fatalTypeError(
 					5939_error,
diff --git a/compiler/libsolidity/codegen/TVMCommons.cpp b/compiler/libsolidity/codegen/TVMCommons.cpp
index 1f7f0d3d..eb9217ca 100644
--- a/compiler/libsolidity/codegen/TVMCommons.cpp
+++ b/compiler/libsolidity/codegen/TVMCommons.cpp
@@ -220,12 +220,14 @@ vector<ContractDefinition const *> getContractsChain(ContractDefinition const *c
 	return contracts;
 }
 
-std::vector<VariableDeclaration const *> notConstantStateVariables(ContractDefinition const* _contract) {
+std::vector<VariableDeclaration const *> stateVariables(ContractDefinition const* _contract,
+														bool _onlyNoStorage) {
 	std::vector<VariableDeclaration const *> variableDeclarations;
 	std::vector<ContractDefinition const *> mainChain = getContractsChain(_contract);
 	for (ContractDefinition const * contract: mainChain) {
 		for (VariableDeclaration const *variable: contract->stateVariables()) {
-			if (!variable->isConstant()) {
+			if (!variable->isConstant() && (_onlyNoStorage == variable->isNoStorage())
+			) {
 				variableDeclarations.push_back(variable);
 			}
 		}
diff --git a/compiler/libsolidity/codegen/TVMCommons.hpp b/compiler/libsolidity/codegen/TVMCommons.hpp
index 8029df55..4c26e9b3 100644
--- a/compiler/libsolidity/codegen/TVMCommons.hpp
+++ b/compiler/libsolidity/codegen/TVMCommons.hpp
@@ -150,7 +150,7 @@ realDictKeyValue(Type const* type);
 
 
 std::vector<ContractDefinition const*> getContractsChain(ContractDefinition const* contract);
-std::vector<VariableDeclaration const *> notConstantStateVariables(ContractDefinition const* contract);
+std::vector<VariableDeclaration const *> stateVariables(ContractDefinition const* contract, bool _withNoStorage);
 
 std::vector<std::pair<FunctionDefinition const*, ContractDefinition const*>>
 getContractFunctionPairs(ContractDefinition const* contract);
diff --git a/compiler/libsolidity/codegen/TVMConstants.hpp b/compiler/libsolidity/codegen/TVMConstants.hpp
index f6fe0c13..98025223 100644
--- a/compiler/libsolidity/codegen/TVMConstants.hpp
+++ b/compiler/libsolidity/codegen/TVMConstants.hpp
@@ -74,7 +74,6 @@ namespace TvmConst {
 		const int ConstructorIsCalledTwice  = 51;
 		const int ReplayProtection  = 52;
 		const int PopFromEmptyArray = 54;
-		const int InsertPubkeyException = 55;
 		const int MessageIsExpired = 57;
 		const int MessageHasNoSignButHasPubkey = 58;
 		const int NoFallback = 60;
diff --git a/compiler/libsolidity/codegen/TVMContractCompiler.cpp b/compiler/libsolidity/codegen/TVMContractCompiler.cpp
index 5d312114..54932458 100644
--- a/compiler/libsolidity/codegen/TVMContractCompiler.cpp
+++ b/compiler/libsolidity/codegen/TVMContractCompiler.cpp
@@ -36,132 +36,6 @@ using namespace solidity::frontend;
 using namespace std;
 using namespace solidity::util;
 
-TVMConstructorCompiler::TVMConstructorCompiler(StackPusher &pusher) : m_pusher{pusher} {
-
-}
-
-void TVMConstructorCompiler::dfs(ContractDefinition const *c) {
-	if (used[c]) {
-		return;
-	}
-	used[c] = true;
-	dfsOrder.push_back(c);
-	path[c] = dfsOrder;
-	for (const ASTPointer<InheritanceSpecifier>& inherSpec : c->baseContracts()) {
-		auto base = to<ContractDefinition>(inherSpec->name().annotation().referencedDeclaration);
-		ast_vec<Expression> const*  agrs = inherSpec->arguments();
-		if (agrs != nullptr && !agrs->empty()) {
-			m_args[base] = inherSpec->arguments();
-			dfs(base);
-		}
-	}
-	if (c->constructor() != nullptr) {
-		for (const ASTPointer<ModifierInvocation> &modInvoc : c->constructor()->modifiers()) {
-			auto base = to<ContractDefinition>(modInvoc->name().annotation().referencedDeclaration);
-			if (base != nullptr) {
-				if (modInvoc->arguments() != nullptr) {
-					m_args[base] = modInvoc->arguments();
-					dfs(base);
-				}
-			}
-		}
-	}
-	dfsOrder.pop_back();
-}
-
-Pointer<Function> TVMConstructorCompiler::generateConstructors() {
-	FunctionDefinition const* constructor = m_pusher.ctx().getContract()->constructor();
-	m_pusher.ctx().setCurrentFunction(constructor, "constructor");
-
-	{
-		ChainDataEncoder encode{&m_pusher};
-		uint32_t functionId =
-			constructor != nullptr ?
-			encode.calculateFunctionIDWithReason(constructor, ReasonOfOutboundMessage::RemoteCallInternal) :
-			encode.calculateConstructorFunctionID();
-		m_pusher.ctx().addPublicFunction(functionId, "constructor");
-	}
-
-	m_pusher.fixStack(+1); // push encoded params of constructor
-	m_pusher.fixStack(+1); // functionID
-	m_pusher.drop();
-
-	c4ToC7WithMemoryInitAndConstructorProtection();
-
-	std::vector<ContractDefinition const*> linearizedBaseContracts =
-		m_pusher.ctx().getContract()->annotation().linearizedBaseContracts; // from derived to base
-	for (ContractDefinition const* c : linearizedBaseContracts)
-		dfs(c);
-
-	int take{};
-	if (constructor == nullptr) {
-		m_pusher << "ENDS";
-	} else {
-		take = constructor->parameters().size();
-		vector<Type const*> types = getParams(constructor->parameters()).first;
-		ChainDataDecoder{&m_pusher}.decodeFunctionParameters(types, false);
-		m_pusher.getStack().change(-static_cast<int>(constructor->parameters().size()));
-		for (const ASTPointer<VariableDeclaration>& variable: constructor->parameters())
-			m_pusher.getStack().add(variable.get(), true);
-	}
-	solAssert(m_pusher.stackSize() == take, "");
-	std::set<ContractDefinition const*> areParamsOnStack;
-	areParamsOnStack.insert(linearizedBaseContracts.at(0));
-	for (ContractDefinition const* c : linearizedBaseContracts | boost::adaptors::reversed)
-		if (c->constructor() == nullptr || c->constructor()->parameters().empty())
-			areParamsOnStack.insert(c);
-
-	bool haveConstructor = false;
-	for (ContractDefinition const* c : linearizedBaseContracts | boost::adaptors::reversed) {
-		if (c->constructor() == nullptr)
-			continue;
-		haveConstructor = true;
-		for (ContractDefinition const* parent : path[c]) {
-			if (areParamsOnStack.count(parent) == 0) {
-				areParamsOnStack.insert(parent);
-				for (size_t i = 0; i < parent->constructor()->parameters().size(); ++i) {
-					TVMExpressionCompiler(m_pusher).acceptExpr((*m_args[parent])[i].get(), true);
-					m_pusher.getStack().add(parent->constructor()->parameters()[i].get(), false);
-				}
-			}
-		}
-		int take2 = c->constructor()->parameters().size();
-		StackPusher pusher = m_pusher;
-		pusher.clear();
-		pusher.takeLast(take2);
-		TVMFunctionCompiler::generateFunctionWithModifiers(pusher, c->constructor(), false);
-		m_pusher.fixStack(-take2); // fix stack
-		m_pusher.add(pusher);
-	}
-
-	if (!haveConstructor)
-		m_pusher << "ACCEPT";
-
-//	solAssert(m_pusher.stackSize() == 0, "");
-	m_pusher.pushFragmentInCallRef(0, 0, "c7_to_c4");
-	m_pusher._throw("THROW 0");
-
-	m_pusher.ctx().resetCurrentFunction();
-	Pointer<CodeBlock> block = m_pusher.getBlock();
-	// take slice (contains params) and functionID
-	Pointer<Function> f = createNode<Function>(2, 0, "constructor", nullopt, Function::FunctionType::Fragment, block);
-	return f;
-}
-
-void TVMConstructorCompiler::c4ToC7WithMemoryInitAndConstructorProtection() {
-	// copy c4 to c7
-	m_pusher.was_c4_to_c7_called();
-	m_pusher.fixStack(-1); // fix stack
-
-	m_pusher.startContinuation();
-	m_pusher.pushFragment(0, 0, "c4_to_c7_with_init_storage");
-	m_pusher.endContinuationFromRef();
-	m_pusher._if();
-
-	// generate constructor protection
-	m_pusher.getGlob(TvmConst::C7::ConstructorFlag);
-	m_pusher._throw("THROWIF " + toString(TvmConst::RuntimeException::ConstructorIsCalledTwice));
-}
 
 void TVMContractCompiler::printFunctionIds(
 	ContractDefinition const& contract,
@@ -173,7 +47,7 @@ void TVMContractCompiler::printFunctionIds(
 
 void TVMContractCompiler::printPrivateFunctionIds(
 	ContractDefinition const& contract,
-	std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+	std::vector<std::shared_ptr<SourceUnit>> const& _sourceUnits,
 	PragmaDirectiveHelper const& pragmaHelper
 ) {
 	Json::Value functionIds = TVMABI::generatePrivateFunctionIdsJson(contract, _sourceUnits, pragmaHelper);
@@ -202,7 +76,7 @@ void TVMContractCompiler::generateABI(
 void TVMContractCompiler::generateCodeAndSaveToFile(
 	const std::string& fileName,
 	ContractDefinition const& contract,
-	std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+	std::vector<std::shared_ptr<SourceUnit>>const& _sourceUnits,
 	PragmaDirectiveHelper const &pragmaHelper
 ) {
 	Pointer<Contract> codeContract = generateContractCode(&contract, _sourceUnits, pragmaHelper);
@@ -221,7 +95,7 @@ void TVMContractCompiler::generateCodeAndSaveToFile(
 Pointer<Contract>
 TVMContractCompiler::generateContractCode(
 	ContractDefinition const *contract,
-	std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+	std::vector<std::shared_ptr<SourceUnit>>const& _sourceUnits,
 	PragmaDirectiveHelper const &pragmaHelper
 ) {
 	std::vector<Pointer<Function>> functions;
@@ -289,7 +163,7 @@ TVMContractCompiler::generateContractCode(
 
 	if (!ctx.isStdlib()) {
 		functions.emplace_back(TVMFunctionCompiler::generateC4ToC7(ctx));
-		functions.emplace_back(TVMFunctionCompiler::generateC4ToC7WithInitMemory(ctx));
+		functions.emplace_back(TVMFunctionCompiler::generateDefaultC4(ctx));
 		{
 			StackPusher pusher{&ctx};
 			Pointer<Function> f = pusher.generateC7ToC4(false);
@@ -310,7 +184,7 @@ TVMContractCompiler::generateContractCode(
 		}
 	}
 
-	for (VariableDeclaration const* vd : ctx.notConstantStateVariables()) {
+	for (VariableDeclaration const* vd : ctx.c4StateVariables()) {
 		if (vd->isPublic()) {
 			StackPusher pusher{&ctx};
 			Pointer<Function> f = TVMFunctionCompiler::generateGetter(pusher, vd);
@@ -433,22 +307,31 @@ void TVMContractCompiler::optimizeCode(Pointer<Contract>& c) {
 	LogCircuitExpander lce;
 	c->accept(lce);
 
-	StackOptimizer opt;
-	c->accept(opt);
+	{
+		StackOptimizer opt;
+		c->accept(opt);
+	}
+
+	lce = LogCircuitExpander{};
+	c->accept(lce);
 
-	PeepholeOptimizer peepHole{false, false};
-	c->accept(peepHole);
+	for (int i = 0; i < 10; ++i) { // TODO
+		PeepholeOptimizer::withBlockPush = false; // TODO
+		PeepholeOptimizer peepHole{false, false, false};
+		c->accept(peepHole);
+		PeepholeOptimizer::withBlockPush = true;
 
-	opt = StackOptimizer{};
-	c->accept(opt);
+		StackOptimizer opt;
+		c->accept(opt);
+	}
 
-	peepHole = PeepholeOptimizer{false, false};
+	PeepholeOptimizer peepHole = PeepholeOptimizer{false, false, false};
 	c->accept(peepHole);
 
-	peepHole = PeepholeOptimizer{true, false};
+	peepHole = PeepholeOptimizer{true, false, false}; // TODO provide mask with bits
 	c->accept(peepHole);
 
-	peepHole = PeepholeOptimizer{true, true};
+	peepHole = PeepholeOptimizer{true, true, true}; // TODO provide mask with bits
 	c->accept(peepHole);
 
 	LocSquasher sq = LocSquasher{};
diff --git a/compiler/libsolidity/codegen/TVMContractCompiler.hpp b/compiler/libsolidity/codegen/TVMContractCompiler.hpp
index 37d07006..a0d34438 100644
--- a/compiler/libsolidity/codegen/TVMContractCompiler.hpp
+++ b/compiler/libsolidity/codegen/TVMContractCompiler.hpp
@@ -24,27 +24,12 @@ namespace solidity::frontend {
 
 class TVMCompilerContext;
 
-class TVMConstructorCompiler: private boost::noncopyable {
-	StackPusher& m_pusher;
-	std::map<ContractDefinition const*, std::vector<ContractDefinition const*>> path;
-	std::vector<ContractDefinition const*> dfsOrder;
-	std::map<ContractDefinition const*, bool> used;
-	std::map<ContractDefinition const*, std::vector<ASTPointer<Expression>> const*> m_args;
-
-public:
-	explicit TVMConstructorCompiler(StackPusher& pusher);
-	void dfs(ContractDefinition const* c);
-	Pointer<Function> generateConstructors();
-private:
-	void c4ToC7WithMemoryInitAndConstructorProtection();
-};
-
 class TVMContractCompiler: private boost::noncopyable {
 public:
 	static void printFunctionIds(ContractDefinition const& contract, PragmaDirectiveHelper const& pragmaHelper);
 	static void printPrivateFunctionIds(
 		ContractDefinition const& contract,
-		std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+		std::vector<std::shared_ptr<SourceUnit>> const& _sourceUnits,
 		PragmaDirectiveHelper const& pragmaHelper
 	);
 	static void generateABI(
@@ -54,14 +39,14 @@ class TVMContractCompiler: private boost::noncopyable {
 		std::vector<PragmaDirective const *> const& pragmaDirectives
 	);
 	static void generateCodeAndSaveToFile(
-		const std::string& fileName,
+		std::string const& fileName,
 		ContractDefinition const& contract,
-		std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+		std::vector<std::shared_ptr<SourceUnit>> const& _sourceUnits,
 		PragmaDirectiveHelper const &pragmaHelper
 	);
 	static Pointer<Contract> generateContractCode(
 		ContractDefinition const* contract,
-		std::vector<std::shared_ptr<SourceUnit>> _sourceUnits,
+		std::vector<std::shared_ptr<SourceUnit>>const& _sourceUnits,
 		PragmaDirectiveHelper const& pragmaHelper
 	);
 	static void optimizeCode(Pointer<Contract>& c);
diff --git a/compiler/libsolidity/codegen/TVMExpressionCompiler.cpp b/compiler/libsolidity/codegen/TVMExpressionCompiler.cpp
index 1245f0fa..ce718acb 100644
--- a/compiler/libsolidity/codegen/TVMExpressionCompiler.cpp
+++ b/compiler/libsolidity/codegen/TVMExpressionCompiler.cpp
@@ -395,7 +395,7 @@ void TVMExpressionCompiler::compareSlices(Token op) {
 }
 
 void TVMExpressionCompiler::compareStrings(Token op) {
-	m_pusher.pushFragmentInCallRef(2, 1, "compareLongStrings");
+	m_pusher.pushFragmentInCallRef(2, 1, "__compareStrings");
 	switch(op) {
 		case Token::GreaterThan:
 			m_pusher << "ISPOS";
@@ -448,7 +448,7 @@ void TVMExpressionCompiler::visitBinaryOperationForString(
 	if (op == Token::Add) {
 		pushLeft();
 		pushRight();
-		m_pusher.pushFragmentInCallRef(2, 1, "concatenateStrings");
+		m_pusher.pushFragmentInCallRef(2, 1, "__concatenateStrings");
 	} else if (op == Token::Equal || op == Token::NotEqual) {
 		visitBinaryOperationForTvmCell(pushLeft, pushRight, op);
 	} else if (TokenTraits::isCompareOp(op)){
@@ -522,6 +522,14 @@ void TVMExpressionCompiler::visit2(BinaryOperation const &_binaryOperation) {
 		m_pusher.convert(rightTargetType, rt);
 	};
 
+	if (_binaryOperation.userDefinedFunctionType()) {
+		acceptLeft();
+		acceptRight();
+		FunctionDefinition const* functionDef = *_binaryOperation.annotation().userDefinedFunction;
+		m_pusher.pushCallOrCallRef(functionDef, std::nullopt, false);
+		return ;
+	}
+
 	if (isString(commonType)) {
 		visitBinaryOperationForString(acceptLeft, acceptRight, op);
 		return;
@@ -550,11 +558,9 @@ void TVMExpressionCompiler::visit2(BinaryOperation const &_binaryOperation) {
 	if (op == Token::SHR) cast_error(_binaryOperation, "Unsupported operation >>>");
 	if (op == Token::Comma) cast_error(_binaryOperation, "Unsupported operation ,");
 
-	const auto& val = ExprUtils::constValue(_binaryOperation.rightExpression());
-	std::optional<bigint> rightValue;
-	if (val.has_value())
-		rightValue = val;
-	visitMathBinaryOperation(op, commonType, acceptRight, rightValue);
+	const auto& leftValue = ExprUtils::constValue(_binaryOperation.leftExpression());
+	const auto& rightValue = ExprUtils::constValue(_binaryOperation.rightExpression());
+	visitMathBinaryOperation(op, commonType, leftValue, acceptRight, rightValue);
 }
 
 bool TVMExpressionCompiler::isCheckFitUseless(Type const* commonType, Token op) {
@@ -572,6 +578,7 @@ bool TVMExpressionCompiler::isCheckFitUseless(Type const* commonType, Token op)
 void TVMExpressionCompiler::visitMathBinaryOperation(
 	const Token op,
 	Type const* commonType,
+	const std::optional<bigint>& leftValue,
 	const std::function<void()>& pushRight,
 	const std::optional<bigint>& rightValue
 ) {
@@ -595,11 +602,18 @@ void TVMExpressionCompiler::visitMathBinaryOperation(
 				solUnimplemented("");
 			}
 		} else {
-			pushRight();
-			m_pusher.dup2();
-			m_pusher << "OR";
-			m_pusher._throw("THROWIFNOT " + toString(TvmConst::RuntimeException::Exponent00));
-			m_pusher.pushFragmentInCallRef(2, 1, "__exp");
+			if (leftValue.has_value() && leftValue == 2) {
+				m_pusher.drop();
+				pushRight();
+				m_pusher << "POW2";
+			} else {
+				pushRight();
+				m_pusher.pushS(1);
+				m_pusher.pushS(1);
+				m_pusher << "OR";
+				m_pusher._throw("THROWIFNOT " + toString(TvmConst::RuntimeException::Exponent00));
+				m_pusher.pushFragmentInCallRef(2, 1, "__exp");
+			}
 		}
 		checkOverflow = true;
 	} else {
@@ -642,7 +656,12 @@ void TVMExpressionCompiler::visitMathBinaryOperation(
 		else if (op == Token::BitAnd) m_pusher << "AND";
 		else if (op == Token::BitOr) m_pusher << "OR";
 		else if (op == Token::SHL) {
-			m_pusher << "LSHIFT";
+			if (leftValue.has_value() && leftValue == 1) {
+				m_pusher.dropUnder(1, 1);
+				m_pusher << "POW2";
+			} else {
+				m_pusher << "LSHIFT";
+			}
 			checkOverflow = true;
 		}
 		else if (op == Token::SAR) m_pusher << "RSHIFT";
@@ -812,7 +831,7 @@ void TVMExpressionCompiler::visitMagic(MemberAccess const &_memberAccess) {
 	};
 
 	Type const* exprType = _memberAccess.expression().annotation().type;
-	auto magicType = dynamic_cast<MagicType const*>(exprType);
+	auto magicType = to<MagicType>(exprType);
 	ASTString const& member = _memberAccess.memberName();
 
 	switch (magicType->kind()) {
@@ -841,14 +860,14 @@ void TVMExpressionCompiler::visitMagic(MemberAccess const &_memberAccess) {
 	}
 	case MagicType::Kind::MetaType: {
 		if (member == "min" || member == "max") {
-			auto const* arg = dynamic_cast<MagicType const*>(_memberAccess.expression().annotation().type);
+			auto const* arg = to<MagicType>(_memberAccess.expression().annotation().type);
 			string opcode = "PUSHINT ";
 			const Type *argType = arg->typeArgument();
-			if (auto const* integerType = dynamic_cast<IntegerType const*>(argType))
+			if (auto const* integerType = to<IntegerType>(argType))
 				opcode += toString(member == "min" ? integerType->minValue() : integerType->maxValue());
-			else if (auto const* varInt = dynamic_cast<VarIntegerType const*>(argType))
+			else if (auto const* varInt = to<VarIntegerType>(argType))
 				opcode += toString(member == "min" ? varInt->asIntegerType().minValue() : varInt->asIntegerType().maxValue());
-			else if (auto const* enumType = dynamic_cast<EnumType const*>(argType))
+			else if (auto const* enumType = to<EnumType>(argType))
 				opcode += toString(member == "min" ? enumType->minValue() : enumType->maxValue());
 			else
 				solAssert(false, "min/max not available for the given type.");
@@ -892,14 +911,19 @@ void TVMExpressionCompiler::visit2(MemberAccess const &_node) {
 
 	if (category == Type::Category::TypeType) {
 		auto typeType = to<TypeType>(_node.expression().annotation().type);
-		if (auto enumType = dynamic_cast<EnumType const *>(typeType->actualType())) {
-			unsigned int value = enumType->memberValue(_node.memberName());
+		auto actualType = typeType->actualType();
+		if (actualType->category() == Type::Category::Address) {
+			solAssert(memberName == "addrNone", "");
+			m_pusher.pushSlice("x2_");
+			return;
+		}
+		if (auto enumType = to<EnumType>(actualType)) {
+			unsigned int value = enumType->memberValue(memberName);
 			m_pusher << "PUSHINT " + toString(value);
 			return;
 		}
-
-		auto conType = to<ContractType>(typeType->actualType());
-		if (conType->contractDefinition().isLibrary()) {
+		auto conType = to<ContractType>(actualType);
+		if (conType != nullptr && conType->contractDefinition().isLibrary()) {
 			auto funType = to<FunctionType>(_node.annotation().type);
 			if (funType) {
 				auto funDef = to<FunctionDefinition>(&funType->declaration());
@@ -907,11 +931,9 @@ void TVMExpressionCompiler::visit2(MemberAccess const &_node) {
 				return ;
 			}
 		}
-
 		if (fold_constants(&_node)) {
 			return;
 		}
-
 		if (tryPushConstant(_node.annotation().referencedDeclaration)) {
 			return;
 		}
@@ -991,21 +1013,19 @@ void TVMExpressionCompiler::visit2(IndexRangeAccess const &indexRangeAccess) {
 		auto baseArrayType = to<ArrayType>(baseType);
 		if (baseArrayType->isByteArrayOrString()) {
 			acceptExpr(&indexRangeAccess.baseExpression()); // bytes
-			if (indexRangeAccess.startExpression()) {
+			if (indexRangeAccess.startExpression())
 				compileNewExpr(indexRangeAccess.startExpression());
-			}
-			else {
+			else
 				m_pusher.pushInt(0);
-			}
+
 			if (indexRangeAccess.endExpression()) {
 				compileNewExpr(indexRangeAccess.endExpression());
-				m_pusher << "FALSE";
+				m_pusher.pushFragmentInCallRef(3, 1, "__arraySlice");
 			} else {
-				m_pusher.pushInt(0);
+				m_pusher.pushInt(0xFFFF'FFFF);
 				m_pusher << "TRUE";
+				m_pusher.pushFragmentInCallRef(4, 1, "__subCell");
 			}
-
-			m_pusher.pushFragmentInCallRef(4, 1, "bytes_substr");
 			return;
 		}
 	}
@@ -1329,9 +1349,9 @@ bool TVMExpressionCompiler::tryAssignLValue(Assignment const &_assignment) {
 		m_pusher.blockSwap(1, expandedLValueSize + 1); // expanded... l r
 
 		if (isString(commonType)) {
-			m_pusher.pushFragmentInCallRef(2, 1, "concatenateStrings");
+			m_pusher.pushFragmentInCallRef(2, 1, "__concatenateStrings");
 		} else {
-			visitMathBinaryOperation(binOp, commonType, nullptr, nullopt);
+			visitMathBinaryOperation(binOp, commonType, nullopt, nullptr, nullopt);
 		}
 
 		if (isCurrentResultNeeded()) {
diff --git a/compiler/libsolidity/codegen/TVMExpressionCompiler.hpp b/compiler/libsolidity/codegen/TVMExpressionCompiler.hpp
index f0f6f6a1..17680071 100644
--- a/compiler/libsolidity/codegen/TVMExpressionCompiler.hpp
+++ b/compiler/libsolidity/codegen/TVMExpressionCompiler.hpp
@@ -68,6 +68,7 @@ class TVMExpressionCompiler {
 	void visitMathBinaryOperation(
 		Token op,
 		Type const* commonType,
+		const std::optional<bigint>& leftValue,
 		const std::function<void()>& pushRight,
 		const std::optional<bigint>& rightValue
 	);
diff --git a/compiler/libsolidity/codegen/TVMFunctionCall.cpp b/compiler/libsolidity/codegen/TVMFunctionCall.cpp
index ad26d41e..9322524c 100644
--- a/compiler/libsolidity/codegen/TVMFunctionCall.cpp
+++ b/compiler/libsolidity/codegen/TVMFunctionCall.cpp
@@ -40,6 +40,7 @@ FunctionCallCompiler::FunctionCallCompiler(
 	m_pusher{m_pusher},
 	m_exprCompiler{m_pusher},
 	m_functionCall{_functionCall},
+	m_memberAccess{to<MemberAccess>(&m_functionCall.expression())},
 	m_arguments{_functionCall.arguments()},
 	m_funcType{to<FunctionType>(m_functionCall.expression().annotation().type)},
 	m_retType{m_functionCall.annotation().type},
@@ -59,7 +60,6 @@ void FunctionCallCompiler::structConstructorCall() {
 }
 
 void FunctionCallCompiler::compile() {
-	auto _memberAccess = to<MemberAccess>(&m_functionCall.expression());
 	auto reportError = [&](){
 		cast_error(m_functionCall, "Unsupported function call");
 	};
@@ -76,14 +76,14 @@ void FunctionCallCompiler::compile() {
 	}
 
 	if (checkRemoteMethodCall(m_functionCall) ||
-		(_memberAccess != nullptr && libraryCall(*_memberAccess)) ||
+		(m_memberAccess != nullptr && libraryCall(*m_memberAccess)) ||
 		checkForMappingOrCurrenciesMethods() ||
 		checkNewExpression() ||
 		checkAddressThis() ||
 		checkSolidityUnits() ||
 		checkLocalFunctionOrLibCallOrFuncVarCall()) {
 		// do nothing
-	} else if (_memberAccess != nullptr && getType(&_memberAccess->expression())->category() == Type::Category::Struct) {
+	} else if (m_memberAccess != nullptr && getType(&m_memberAccess->expression())->category() == Type::Category::Struct) {
 		if (!structMethodCall()) {
 			reportError();
 		}
@@ -96,63 +96,76 @@ void FunctionCallCompiler::compile() {
 			typeConversion();
 		}
 	} else {
-		if (_memberAccess != nullptr) {
-			auto category = getType(&_memberAccess->expression())->category();
-			auto ident = to<Identifier>(&_memberAccess->expression());
+		if (m_memberAccess != nullptr) {
+			auto category = getType(&m_memberAccess->expression())->category();
+			auto ident = to<Identifier>(&m_memberAccess->expression());
 			if (category == Type::Category::Array) {
-				arrayMethods(*_memberAccess);
+				arrayMethods(*m_memberAccess);
 			} else if (category == Type::Category::TvmSlice) {
-				sliceMethods(*_memberAccess);
+				sliceMethods(*m_memberAccess);
 			} else if (category == Type::Category::TvmBuilder) {
-				builderMethods(*_memberAccess);
+				builderMethods(*m_memberAccess);
 			} else if (
-				checkForTvmVectorMethods(*_memberAccess, category) ||
-				checkForOptionalMethods(*_memberAccess))
+				checkForTvmVectorMethods(*m_memberAccess, category) ||
+				checkForOptionalMethods(*m_memberAccess))
 			{
 				// nothing
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "tvm") {
-				if (m_funcType->kind() == FunctionType::Kind::TVMBuildIntMsg) {
-					tvmBuildIntMsg();
-				} else if (m_funcType->kind() == FunctionType::Kind::TVMBuildDataInit) {
-					tvmBuildDataInit();
-				} else if (m_funcType->kind() == FunctionType::Kind::TVMBuildExtMsg) {
-					tvmBuildMsgMethod();
+				if (m_funcType->kind() == FunctionType::Kind::ABIBuildIntMsg) {
+					abiBuildIntMsg();
+				} else if (m_funcType->kind() == FunctionType::Kind::ABIEncodeData) {
+					abiBuildDataInit();
+				} else if (m_funcType->kind() == FunctionType::Kind::ABIBuildExtMsg) {
+					abiBuildExtMsg();
 				} else if (
-					checkForTvmSendFunction(*_memberAccess) ||
-					checkForTvmConfigParamFunction(*_memberAccess) ||
-					checkForTvmFunction(*_memberAccess) ||
-					checkForTvmDeployMethods(*_memberAccess, category)
+					checkForTvmSendFunction(*m_memberAccess) ||
+					checkForTvmConfigParamFunction(*m_memberAccess) ||
+					checkForTvmFunction(*m_memberAccess) ||
+					checkTvmABIDeployMethods(category)
 				) {
 					// do nothing
 				} else {
 					reportError();
 				}
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "rnd") {
-				rndFunction(*_memberAccess);
+				rndFunction(*m_memberAccess);
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "gosh") {
 				goshFunction();
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "msg") {
-				msgFunction(*_memberAccess);
+				msgFunction(*m_memberAccess);
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "abi") {
-				abiFunction();
+				if (m_funcType->kind() == FunctionType::Kind::ABIDecodeData)
+					abiDecodeData();
+				else if (m_funcType->kind() == FunctionType::Kind::ABIEncodeBody)
+					abiEncodeBody();
+				else if (m_funcType->kind() == FunctionType::Kind::ABIBuildIntMsg)
+					abiBuildIntMsg();
+				else if (m_funcType->kind() == FunctionType::Kind::ABIBuildExtMsg)
+					abiBuildExtMsg();
+				else if (m_funcType->kind() == FunctionType::Kind::ABIEncodeData)
+					abiBuildDataInit();
+				else if (!checkTvmABIDeployMethods(category))
+					abiFunction();
 			} else if (category == Type::Category::Magic && ident != nullptr && ident->name() == "math") {
-				mathFunction(*_memberAccess);
+				mathFunction(*m_memberAccess);
 			} else if (category == Type::Category::Address) {
 				addressMethod();
 			} else if (category == Type::Category::TvmCell) {
-				cellMethods(*_memberAccess);
+				cellMethods(*m_memberAccess);
+			} else if (category == Type::Category::Integer) {
+				integerMethods();
 			} else if (category == Type::Category::Variant) {
-				variantMethods(*_memberAccess);
-			} else if (isSuper(&_memberAccess->expression())) {
-				superFunctionCall(*_memberAccess);
+				variantMethods(*m_memberAccess);
+			} else if (isSuper(&m_memberAccess->expression())) {
+				superFunctionCall(*m_memberAccess);
 			} else if (category == Type::Category::TypeType) {
-				Type const* actualType = to<TypeType>(_memberAccess->expression().annotation().type)->actualType();
-				if (checkBaseContractCall(*_memberAccess)) {
+				Type const* actualType = to<TypeType>(m_memberAccess->expression().annotation().type)->actualType();
+				if (checkBaseContractCall(*m_memberAccess)) {
 					// nothing
 				} else if (to<UserDefinedValueType>(actualType)) {
-					userDefinedValueMethods(*_memberAccess);
+					userDefinedValueMethods(*m_memberAccess);
 				} else if (to<AddressType>(actualType)) {
-					addressMethods(*_memberAccess);
+					addressMethods(*m_memberAccess);
 				} else {
 					reportError();
 				}
@@ -177,12 +190,10 @@ void FunctionCallCompiler::arrayPush(StackPusher& pusher, Type const* arrayBaseT
 }
 
 bool FunctionCallCompiler::checkForMappingOrCurrenciesMethods() {
-	auto expr = &m_functionCall.expression();
-	auto ma = to<MemberAccess>(expr);
-	if (ma == nullptr || !to<MappingType>(ma->expression().annotation().type))
+	if (m_memberAccess == nullptr || !to<MappingType>(m_memberAccess->expression().annotation().type))
 		return false;
 
-	const ASTString &memberName = ma->memberName();
+	const ASTString &memberName = m_memberAccess->memberName();
 	if (isIn(memberName, "delMin", "delMax")) {
 		mappingDelMinOrMax(memberName == std::string{"delMin"});
 	} else  if (isIn(memberName, "at", "fetch", "exists", "replace", "add",
@@ -204,28 +215,24 @@ bool FunctionCallCompiler::checkForMappingOrCurrenciesMethods() {
 }
 
 void FunctionCallCompiler::mappingDelMinOrMax(bool isDelMin) {
-	auto memberAccess = to<MemberAccess>(&m_functionCall.expression());
-
 	Type const* keyType{};
 	Type const* valueType{};
-	std::tie(keyType, valueType) = dictKeyValue(memberAccess->expression().annotation().type);
+	std::tie(keyType, valueType) = dictKeyValue(m_memberAccess->expression().annotation().type);
 
-	DelMinOrMax d{m_pusher, *keyType, *valueType, isDelMin, memberAccess};
+	DelMinOrMax d{m_pusher, *keyType, *valueType, isDelMin, m_memberAccess};
 	d.delMinOrMax();
 }
 
 void FunctionCallCompiler::mappingGetSet() {
-	auto memberAccess = to<MemberAccess>(&m_functionCall.expression());
-
 	Type const* keyType{};
 	Type const* valueType{};
-	std::tie(keyType, valueType) = dictKeyValue(memberAccess->expression().annotation().type);
+	std::tie(keyType, valueType) = dictKeyValue(m_memberAccess->expression().annotation().type);
 
-	const ASTString &memberName = memberAccess->memberName();
+	const ASTString &memberName = m_memberAccess->memberName();
 	if (isIn(memberName, "fetch", "at")) {
 		pushArgs(); // index
 		m_pusher.prepareKeyForDictOperations(keyType, false);
-		acceptExpr(&memberAccess->expression()); // index dict
+		acceptExpr(&m_memberAccess->expression()); // index dict
 		if (memberName == "fetch")
 			m_pusher.getDict(*keyType, *valueType, GetDictOperation::Fetch);
 		else
@@ -233,13 +240,11 @@ void FunctionCallCompiler::mappingGetSet() {
 	} else if (memberName == "exists") {
 		pushArgs(); // index
 		m_pusher.prepareKeyForDictOperations(keyType, false);
-		acceptExpr(&memberAccess->expression()); // index dict
+		acceptExpr(&m_memberAccess->expression()); // index dict
 		m_pusher.getDict(*keyType, *valueType, GetDictOperation::Exist);
 	} else if (isIn(memberName, "getDel")) {
 		const int stackSize = m_pusher.stackSize();
-
-		auto ma = to<MemberAccess>(&m_functionCall.expression());
-		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&ma->expression(), true);
+		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&m_memberAccess->expression(), true);
 
 		pushArgAndConvert(0); // lValue... map key
 		m_pusher.prepareKeyForDictOperations(keyType, false);
@@ -252,8 +257,7 @@ void FunctionCallCompiler::mappingGetSet() {
 		m_exprCompiler.collectLValue(lValueInfo, true, false); // value
 	} else if (isIn(memberName, "replace", "add", "getSet", "getAdd", "getReplace")) {
 		const int stackSize = m_pusher.stackSize();
-		auto ma = to<MemberAccess>(&m_functionCall.expression());
-		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&ma->expression(), true); // lValue... map
+		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&m_memberAccess->expression(), true); // lValue... map
 		pushArgAndConvert(1); // lValue... map value
 		const DataType& dataType = m_pusher.prepareValueForDictOperations(keyType, valueType); // lValue... map value'
 		pushArgAndConvert(0); // mapLValue... map value key
@@ -295,46 +299,40 @@ void FunctionCallCompiler::mappingGetSet() {
 }
 
 void FunctionCallCompiler::mappingMinMaxMethod(bool isMin) {
-	auto expr = &m_functionCall.expression();
-	auto memberAccess = to<MemberAccess>(expr);
-
 	Type const* keyType{};
 	Type const* valueType{};
-	std::tie(keyType, valueType) = dictKeyValue(memberAccess->expression().annotation().type);
+	std::tie(keyType, valueType) = dictKeyValue(m_memberAccess->expression().annotation().type);
 
-	acceptExpr(&memberAccess->expression()); // dict
+	acceptExpr(&m_memberAccess->expression()); // dict
 
 	DictMinMax compiler{m_pusher, *keyType, *valueType, isMin};
 	compiler.minOrMax();
 }
 
 void FunctionCallCompiler::mappingPrevNextMethods() {
-	auto expr = &m_functionCall.expression();
-	auto memberAccess = to<MemberAccess>(expr);
 	Type const* keyType{};
 	Type const* valueType{};
-	std::tie(keyType, valueType) = dictKeyValue(memberAccess->expression().annotation().type);
+	std::tie(keyType, valueType) = dictKeyValue(m_memberAccess->expression().annotation().type);
 
 	pushArgAndConvert(0); // index
 	m_pusher.prepareKeyForDictOperations(keyType, true); // index'
-	acceptExpr(&memberAccess->expression()); // index' dict
+	acceptExpr(&m_memberAccess->expression()); // index' dict
 	m_pusher.pushInt(dictKeyLength(keyType)); // index' dict nbits
 
-	DictPrevNext compiler{m_pusher, *keyType, *valueType, memberAccess->memberName()};
+	DictPrevNext compiler{m_pusher, *keyType, *valueType, m_memberAccess->memberName()};
 	compiler.prevNext();
 }
 
 void FunctionCallCompiler::mappingKeysOrValues(bool areKeys) {
 	m_pusher.pushEmptyArray();
 
-	auto ma = to<MemberAccess>(&m_functionCall.expression());
-	acceptExpr(&ma->expression());
+	acceptExpr(&m_memberAccess->expression());
 	// array map
 	m_pusher.pushS(0);
 	// array map map
 	Type const* mapKeyType{};
 	Type const* mapValueType{};
-	std::tie(mapKeyType, mapValueType) = realDictKeyValue(ma->expression().annotation().type);
+	std::tie(mapKeyType, mapValueType) = realDictKeyValue(m_memberAccess->expression().annotation().type);
 	DictMinMax compiler{m_pusher, *mapKeyType, *mapValueType, true};
 	compiler.minOrMax();
 	// array map minPair
@@ -388,9 +386,7 @@ void FunctionCallCompiler::mappingKeysOrValues(bool areKeys) {
 }
 
 void FunctionCallCompiler::mappingEmpty() {
-	auto expr = &m_functionCall.expression();
-	auto ma = to<MemberAccess>(expr);
-	acceptExpr(&ma->expression());
+	acceptExpr(&m_memberAccess->expression());
 	m_pusher << "DICTEMPTY";
 }
 
@@ -436,8 +432,6 @@ void FunctionCallCompiler::addressMethods(MemberAccess const &_node) {
 			m_pusher << "ENDC";
 			m_pusher << "CTOS"; // extAddress
 		}
-	} else if (_node.memberName() == "makeAddrNone") {
-		m_pusher.pushSlice("x2_");
 	} else if (_node.memberName() == "makeAddrStd") {
 		const auto& wid = ExprUtils::constValue(*m_arguments.at(0));
 		const auto& val = ExprUtils::constValue(*m_arguments.at(1));
@@ -478,10 +472,10 @@ bool FunctionCallCompiler::libraryCall(MemberAccess const& ma) {
 			} else {
 				// using MathLib for uint;
 				// a.add(b);
-				const int stakeSize0 = m_pusher.stackSize();
+				const int stackSize0 = m_pusher.stackSize();
 				const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&ma.expression(), true);
-				const int stakeSize1 = m_pusher.stackSize();
-				const int lValueQty = stakeSize1 - stakeSize0;
+				const int stackSize1 = m_pusher.stackSize();
+				const int lValueQty = stackSize1 - stackSize0;
 
 				pushArgs();
 				m_pusher.pushCallOrCallRef(
@@ -501,55 +495,106 @@ bool FunctionCallCompiler::libraryCall(MemberAccess const& ma) {
 }
 
 std::function<void()> FunctionCallCompiler::generateDataSection(
+	bool data_map_supported,
 	const std::function<void()>& pushKey,
 	Expression const* vars,
 	ContractType const* ct
 ) {
-	return [pushKey, this, vars, ct]() {
-		// creat dict with variable values
-		m_pusher << "NEWDICT";
-		// stake: builder dict
-
-		IntegerType keyType = getKeyTypeOfC4();
-		Type const* valueType = TypeProvider::uint256();
-
-		pushKey();
-		const DataType& dataType = m_pusher.prepareValueForDictOperations(&keyType, valueType);
-		m_pusher.pushInt(0); // index of pubkey
-		// stack: dict value key
-		m_pusher.rot();
-		// stack: value key dict
-		m_pusher.setDict(getKeyTypeOfC4(), *valueType, dataType);
-		// stack: dict'
-		if (vars) {
+	auto getDeclAndIndex =
+		[](std::vector<std::pair<VariableDeclaration const*, int>> staticVars, const std::string& name)
+	{
+		auto pos = find_if(staticVars.begin(), staticVars.end(), [&](auto v) {
+			return v.first->name() == name;
+		});
+		solAssert(pos != staticVars.end(), "");
+		return *pos;
+	};
+
+	if (data_map_supported) {
+		return [pushKey, this, vars, ct, getDeclAndIndex]() {
+			// creat dict with variable values
+			m_pusher << "NEWDICT";
+			// stack: builder dict
+			IntegerType keyType = getKeyTypeOfC4();
+			Type const* valueType = TypeProvider::uint256();
+
+			pushKey();
+			const DataType& dataType = m_pusher.prepareValueForDictOperations(&keyType, valueType);
+			m_pusher.pushInt(0); // index of pubkey
+			// stack: dict value key
+			m_pusher.rot();
+			// stack: value key dict
+			m_pusher.setDict(getKeyTypeOfC4(), *valueType, dataType);
+			// stack: dict'
+			if (vars) {
+				std::vector<PragmaDirective const *> _pragmaDirectives;
+				PragmaDirectiveHelper pragmaHelper{_pragmaDirectives};
+				TVMCompilerContext cc{&ct->contractDefinition(), pragmaHelper};
+				std::vector<std::pair<VariableDeclaration const*, int>> staticVars = cc.getStaticVariables();
+				auto initVars = to<InitializerList>(vars);
+				for (size_t i = 0; i < initVars->names().size(); ++i) {
+					const ASTPointer<ASTString> &name = initVars->names().at(i);
+					const auto &[varDecl, varIndex] = getDeclAndIndex(staticVars, *name);
+					valueType = varDecl->type();
+					pushExprAndConvert(initVars->options().at(i).get(), valueType); // stack: dict value
+					const DataType& dataType2 = m_pusher.prepareValueForDictOperations(&keyType, valueType);
+					m_pusher.pushInt(varIndex);
+					// stack: dict value key
+					m_pusher.rot();
+					// stack: value key dict
+					m_pusher.setDict(getKeyTypeOfC4(), *varDecl->type(), dataType2);
+					// stack: dict'
+				}
+			}
+			m_pusher << "NEWC";
+			m_pusher << "STDICT";
+			m_pusher << "ENDC";
+		};
+	} else {
+		return [pushKey, this, vars, ct, getDeclAndIndex]() {
 			std::vector<PragmaDirective const *> _pragmaDirectives;
 			PragmaDirectiveHelper pragmaHelper{_pragmaDirectives};
-			TVMCompilerContext cc{&ct->contractDefinition(), pragmaHelper};
-			std::vector<std::pair<VariableDeclaration const*, int>> staticVars = cc.getStaticVariables();
-			auto getDeclAndIndex = [&](const std::string& name) {
-				auto pos = find_if(staticVars.begin(), staticVars.end(), [&](auto v) { return v.first->name() == name; });
-				solAssert(pos != staticVars.end(), "");
-				return *pos;
-			};
-			auto initVars = to<InitializerList>(vars);
-			for (size_t i = 0; i < initVars->names().size(); ++i) {
-				const ASTPointer<ASTString> &name = initVars->names().at(i);
-				const auto &[varDecl, varIndex] = getDeclAndIndex(*name);
-				valueType = varDecl->type();
-				pushExprAndConvert(initVars->options().at(i).get(), valueType); // stack: dict value
-				const DataType& dataType2 = m_pusher.prepareValueForDictOperations(&keyType, valueType);
-				m_pusher.pushInt(varIndex);
-				// stack: dict value key
-				m_pusher.rot();
-				// stack: value key dict
-				m_pusher.setDict(getKeyTypeOfC4(), *varDecl->type(), dataType2);
-				// stack: dict'
+			solAssert(ct, "ct == null");
+			TVMCompilerContext ctx{&ct->contractDefinition(), pragmaHelper};
+
+			std::map<VariableDeclaration const*, Expression const*> varValue;
+			if (vars != nullptr) {
+				std::vector<std::pair<VariableDeclaration const*, int>> staticVars = ctx.getStaticVariables();
+				auto initVars = to<InitializerList>(vars);
+				for (size_t i = 0; i < initVars->names().size(); ++i) {
+					const ASTPointer<ASTString> &name = initVars->names().at(i);
+					const auto &[varDecl, varIndex] = getDeclAndIndex(staticVars, *name);
+					varValue[varDecl] = initVars->options().at(i).get();
+				}
 			}
-		}
-		m_pusher << "NEWC";
-		m_pusher << "STDICT";
-		m_pusher << "ENDC";
-	};
+
+			std::vector<VariableDeclaration const *> stateVars = ctx.c4StateVariables();
+			for (VariableDeclaration const* var : stateVars | boost::adaptors::reversed) {
+				if (varValue.count(var) == 0)
+					m_pusher.pushDefaultValue(var->type());
+				else
+					pushExprAndConvert(varValue.at(var), var->type());
+			}
+
+			if (ctx.storeTimestampInC4())
+				m_pusher.pushInt(0);
+			pushKey();
+			m_pusher << "NEWC";
+			m_pusher << "STU 256";
+			if (ctx.storeTimestampInC4())
+				m_pusher << "STU 64";
+			m_pusher << "STZERO"; // constructor flag
+			if (ctx.usage().hasAwaitCall())
+				m_pusher << "STZERO";
+			const std::vector<Type const *>& memberTypes = ctx.c4StateVariableTypes();
+			if (!memberTypes.empty()) {
+				ChainDataEncoder encoder{&m_pusher};
+				DecodePositionAbiV2 position{ctx.getOffsetC4(), ctx.usage().hasAwaitCall() ? 1 : 0, memberTypes};
+				encoder.encodeParameters(memberTypes, position);
+			}
+			m_pusher << "ENDC";
+		};
+	}
 }
 
 bool FunctionCallCompiler::checkRemoteMethodCall(FunctionCall const &_functionCall) {
@@ -1010,7 +1055,7 @@ void FunctionCallCompiler::generateExtInboundMsg(
 	solAssert(stackSize + 1 == m_pusher.stackSize(), "");
 }
 
-void FunctionCallCompiler::tvmBuildIntMsg() {
+void FunctionCallCompiler::abiBuildIntMsg() {
 	const int stackSize = m_pusher.stackSize();
 
 	int destArg = -1;
@@ -1118,7 +1163,7 @@ void FunctionCallCompiler::tvmBuildIntMsg() {
 	solAssert(m_pusher.stackSize() == stackSize + 1, "");
 }
 
-void FunctionCallCompiler::tvmBuildDataInit() {
+void FunctionCallCompiler::abiBuildDataInit() {
 	const int stackSize = m_pusher.stackSize();
 	int keyArg = -1;
 	int varArg = -1;
@@ -1152,13 +1197,16 @@ void FunctionCallCompiler::tvmBuildDataInit() {
 		}
 	};
 	ContractType const* ct{};
-	if (varArg != -1) {
-		Type const* type = m_arguments[contrArg]->annotation().type;
+	if (contrArg != -1) {
+		Type const* type = m_arguments.at(contrArg)->annotation().type;
 		auto tt = dynamic_cast<const TypeType*>(type);
 		type = tt->actualType();
 		ct = to<ContractType>(type);
 	}
+
+	bool data_map_supported = m_memberAccess->memberName() == "encodeOldDataInit";
 	generateDataSection(
+		data_map_supported,
 		pushKey,
 		varArg != -1 ? m_arguments[varArg].get() : nullptr,
 		ct
@@ -1167,7 +1215,7 @@ void FunctionCallCompiler::tvmBuildDataInit() {
 	solAssert(m_pusher.stackSize() == stackSize + 1, "");
 }
 
-void FunctionCallCompiler::tvmBuildMsgMethod() {
+void FunctionCallCompiler::abiBuildExtMsg() {
 	int destArg = -1;
 	int callArg = -1;
 	int timeArg = -1;
@@ -1247,12 +1295,11 @@ void FunctionCallCompiler::tvmBuildMsgMethod() {
 										  functionDefinition, funcCall->arguments());
 }
 
-bool FunctionCallCompiler::checkForTvmDeployMethods(MemberAccess const &_node, Type::Category category) {
-	if (category != Type::Category::Magic || ((m_funcType->kind() != FunctionType::Kind::TVMDeploy)
-			&& m_funcType->kind() != FunctionType::Kind::TVMBuildStateInit))
+bool FunctionCallCompiler::checkTvmABIDeployMethods(Type::Category category) {
+	if (category != Type::Category::Magic)
 		return false;
 
-	if (_node.memberName() == "buildStateInit") {
+	if (m_funcType->kind() == FunctionType::Kind::ABIEncodeStateInit) {
 		int keyArg = -1;
 		int varArg = -1;
 		int contrArg = -1;
@@ -1326,29 +1373,64 @@ bool FunctionCallCompiler::checkForTvmDeployMethods(MemberAccess const &_node, T
 					type = tt->actualType();
 					ct = to<ContractType>(type);
 				}
-				exprs[StateInitMembers::Data] = generateDataSection(pushKey,
+				exprs[StateInitMembers::Data] = generateDataSection(false, pushKey,
 																	hasVars ? m_arguments[varArg].get() : nullptr,
 																	ct);
 			}
 		}
 
-		buildStateInit(exprs);
+		encodeStateInit(exprs);
 		return true;
 	}
 
-	if (_node.memberName() == "insertPubkey") {
+	if (m_funcType->kind() == FunctionType::Kind::ABIStateInitHash) {
 		pushArgs();
-		m_pusher.pushFragmentInCallRef(2, 1, "insert_pubkey");
+		m_pusher.pushFragmentInCallRef(4, 1, "__stateInitHash");
 		return true;
 	}
 
-	if (_node.memberName() == "stateInitHash") {
-		pushArgs();
-		m_pusher.pushFragmentInCallRef(4, 1, "stateInitHash");
-		return true;
+	return false;
+}
+
+void FunctionCallCompiler::abiDecodeData() {
+	pushArgAndConvert(1);
+	decodeData();
+}
+
+int FunctionCallCompiler::decodeData() {
+	std::vector<Type const*> stateVarTypes;
+	auto retTuple = to<TupleType>(m_retType);
+	for (Type const* type : retTuple->components()) {
+		stateVarTypes.push_back(type);
 	}
 
-	return false;
+	// lvalue.. slice
+	ChainDataDecoder decoder{&m_pusher};
+	decoder.decodeData(0, 0, stateVarTypes);
+	// lvalue.. stateVars...
+	return stateVarTypes.size();
+}
+
+int FunctionCallCompiler::decodeFunctionParams() {
+	CallableDeclaration const *functionDefinition = getFunctionDeclarationOrConstructor(
+					m_arguments.at(0).get());
+	if (functionDefinition) {
+		// lvalue.. slice
+		auto fd = to<FunctionDefinition>(functionDefinition);
+		bool isResponsible = fd->isResponsible();
+		if (isResponsible) {
+			m_pusher << "LDU 32";
+		}
+		// lvalue.. callback slice
+		ChainDataDecoder decoder{&m_pusher};
+		vector<Type const *> types = getParams(functionDefinition->parameters()).first;
+		decoder.decodePublicFunctionParameters(types, isResponsible, true);
+
+		return functionDefinition->parameters().size() + (isResponsible ? 1 : 0);
+	}
+
+	m_pusher << "ENDS";
+	return 0;
 }
 
 void FunctionCallCompiler::sliceMethods(MemberAccess const &_node) {
@@ -1426,36 +1508,9 @@ void FunctionCallCompiler::sliceMethods(MemberAccess const &_node) {
 		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&_node.expression(), true);
 		int paramQty = -1;
 		if (isIn(memberName, "loadFunctionParams", "decodeFunctionParams")) {
-			CallableDeclaration const *functionDefinition = getFunctionDeclarationOrConstructor(
-					m_arguments.at(0).get());
-			if (functionDefinition) {
-
-				// lvalue.. slice
-				auto fd = to<FunctionDefinition>(functionDefinition);
-				bool isResponsible = fd->isResponsible();
-				if (isResponsible) {
-					m_pusher << "LDU 32";
-				}
-				// lvalue.. callback slice
-				ChainDataDecoder decoder{&m_pusher};
-				vector<Type const *> types = getParams(functionDefinition->parameters()).first;
-				decoder.decodePublicFunctionParameters(types, isResponsible, true);
-
-				paramQty = functionDefinition->parameters().size() + (isResponsible ? 1 : 0);
-			}
+			paramQty = decodeFunctionParams();
 		} else if (isIn(memberName, "loadStateVars", "decodeStateVars")) {
-			std::vector<Type const*> stateVarTypes;
-			auto retTuple = to<TupleType>(m_retType);
-			for (Type const* type : retTuple->components()) {
-				stateVarTypes.push_back(type);
-			}
-
-			// lvalue.. slice
-			ChainDataDecoder decoder{&m_pusher};
-			decoder.decodeData(0, 0, stateVarTypes);
-			// lvalue.. stateVars...
-
-			paramQty = stateVarTypes.size();
+			paramQty = decodeData();
 		} else {
 			solUnimplemented("");
 		}
@@ -1533,7 +1588,8 @@ void FunctionCallCompiler::sliceMethods(MemberAccess const &_node) {
 			} else if (memberName == "loadTons") {
 				opcode = "LDGRAMS";
 			} else if (memberName == "loadSlice") {
-				if (m_arguments.size() == 1) {
+				const auto& value2 = m_arguments.size() == 2 ? ExprUtils::constValue(*m_arguments[1]) : nullopt;
+				if (m_arguments.size() == 1 || (value2.has_value() && value2.value() == 0)) {
 					if (value.has_value() && 0 < value && value <= 256) {
 						m_pusher << "LDSLICE " + value->str();
 					} else {
@@ -2078,10 +2134,10 @@ void FunctionCallCompiler::arrayMethods(MemberAccess const &_node) {
 		acceptExpr(&_node.expression());
 		pushArgs();
 		if (m_arguments.size() == 1) {
-			m_pusher.pushFragmentInCallRef(2, 1, "__substr_from");
-		} else {
-			m_pusher.pushFragmentInCallRef(3, 1, "__substr_from_count");
+			m_pusher.pushInt(0xFFFF'FFFF);
 		}
+		m_pusher << "TRUE";
+		m_pusher.pushFragmentInCallRef(4, 1, "__subCell");
 	} else if (_node.memberName() == "find") {
 		acceptExpr(&_node.expression());
 		pushArgs();
@@ -2147,7 +2203,7 @@ void FunctionCallCompiler::arrayMethods(MemberAccess const &_node) {
 	} else if (_node.memberName() == "append") {
 		const LValueInfo lValueInfo = m_exprCompiler.expandLValue(&_node.expression(), true);
 		pushArgAndConvert(0);
-		m_pusher.pushFragmentInCallRef(2, 1, "concatenateStrings");
+		m_pusher.pushFragmentInCallRef(2, 1, "__concatenateStrings");
 		m_exprCompiler.collectLValue(lValueInfo, true, false);
 	} else {
 		solUnimplemented("");
@@ -2255,6 +2311,18 @@ void FunctionCallCompiler::cellMethods(MemberAccess const &_node) {
 		solUnimplemented("");
 }
 
+void FunctionCallCompiler::integerMethods() {
+	acceptExpr(&m_memberAccess->expression());
+	switch (m_funcType->kind()) {
+	case FunctionType::Kind::IntCast: {
+		m_pusher.convert(m_retType, m_memberAccess->expression().annotation().type);
+		break;
+	}
+	default:
+		solUnimplemented("");
+	}
+}
+
 void FunctionCallCompiler::variantMethods(MemberAccess const& _node) {
 
 	auto isUint = [&](){
@@ -2289,8 +2357,7 @@ void FunctionCallCompiler::variantMethods(MemberAccess const& _node) {
 }
 
 void FunctionCallCompiler::addressMethod() {
-	auto _node = to<MemberAccess>(&m_functionCall.expression());
-	if (_node->memberName() == "transfer") { // addr.transfer(...)
+	if (m_memberAccess->memberName() == "transfer") { // addr.transfer(...)
 		std::map<int, Expression const *> exprs;
 		std::map<int, std::string> constParams{{TvmConst::int_msg_info::ihr_disabled, "1"}, {TvmConst::int_msg_info::bounce, "1"}};
 		std::function<void(int)> appendBody;
@@ -2327,7 +2394,7 @@ void FunctionCallCompiler::addressMethod() {
 			};
 		};
 
-		exprs[TvmConst::int_msg_info::dest] = &_node->expression();
+		exprs[TvmConst::int_msg_info::dest] = &m_memberAccess->expression();
 
 		int argumentQty = static_cast<int>(m_arguments.size());
 		if (!m_names.empty() || argumentQty == 0) {
@@ -2390,26 +2457,26 @@ void FunctionCallCompiler::addressMethod() {
 			}
 		}
 		m_pusher.sendIntMsg(exprs, constParams, appendBody, pushSendrawmsgFlag, false, 0, appendStateInit);
-	} else if (_node->memberName() == "isStdZero") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "isStdZero") {
+		acceptExpr(&m_memberAccess->expression());
 		m_pusher.pushZeroAddress();
 		m_pusher << "SDEQ";
-	} else if (_node->memberName() == "isExternZero") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "isExternZero") {
+		acceptExpr(&m_memberAccess->expression());
 		m_pusher.pushSlice("x401_");
 		m_pusher << "SDEQ";
-	} else if (_node->memberName() == "isNone") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "isNone") {
+		acceptExpr(&m_memberAccess->expression());
 		m_pusher.pushSlice("x2_");
 		m_pusher << "SDEQ";
-	} else if (_node->memberName() == "unpack") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "unpack") {
+		acceptExpr(&m_memberAccess->expression());
 		m_pusher << "REWRITESTDADDR";
-	} else if (_node->memberName() == "getType") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "getType") {
+		acceptExpr(&m_memberAccess->expression());
 		m_pusher << "PLDU 2";
-	} else if (_node->memberName() == "isStdAddrWithoutAnyCast") {
-		acceptExpr(&_node->expression());
+	} else if (m_memberAccess->memberName() == "isStdAddrWithoutAnyCast") {
+		acceptExpr(&m_memberAccess->expression());
 		// t = (2, u, x, s); check t[0] == 2 and t[1] is null
 		m_pusher << "PARSEMSGADDR";
 		m_pusher.pushS(0);
@@ -2697,164 +2764,7 @@ void FunctionCallCompiler::goshFunction() {
 	m_pusher << opcode;
 }
 
-bool FunctionCallCompiler::checkForTvmFunction(const MemberAccess &_node) {
-	if (_node.memberName() == "pubkey") { // tvm.pubkey
-		m_pusher.getGlob(TvmConst::C7::TvmPubkey);
-	} else if (_node.memberName() == "setPubkey") { // tvm.setPubkey
-		pushArgs();
-		m_pusher.setGlob(TvmConst::C7::TvmPubkey);
-	} else if (_node.memberName() == "accept") { // tvm.accept
-		m_pusher << "ACCEPT";
-	} else if (_node.memberName() == "hash") { // tvm.hash
-		pushArgs();
-		switch (m_arguments.at(0)->annotation().type->category()) {
-			case Type::Category::TvmCell:
-			case Type::Category::Array:
-			case Type::Category::StringLiteral:
-				m_pusher << "HASHCU";
-				break;
-			case Type::Category::TvmSlice:
-				m_pusher << "HASHSU";
-				break;
-			default:
-				solUnimplemented("");
-		}
-	} else if (_node.memberName() == "checkSign") { // tvm.checkSign
-		size_t cnt = m_arguments.size();
-		if (getType(m_arguments[0].get())->category() == Type::Category::TvmSlice) {
-			pushArgs();
-			m_pusher << "CHKSIGNS";
-		} else {
-			pushArgAndConvert(0);
-			if (cnt == 4) {
-				pushArgAndConvert(2);
-				pushArgAndConvert(1);
-				m_pusher << "NEWC";
-				m_pusher << "STU 256";
-				m_pusher << "STU 256";
-				m_pusher << "ENDC";
-				m_pusher << "CTOS";
-			} else {
-				pushArgAndConvert(1);
-			}
-			pushArgAndConvert(cnt - 1);
-			m_pusher << "CHKSIGNU";
-		}
-	} else if (_node.memberName() == "setcode") { // tvm.setcode
-		pushArgs();
-		m_pusher << "SETCODE";
-	} else if (_node.memberName() == "bindump") { // tvm.bindump
-		pushArgs();
-		if (getType(m_arguments[0].get())->category() == Type::Category::TvmCell)
-			m_pusher << "CTOS";
-		m_pusher << "BINDUMP";
-		m_pusher.drop();
-	} else if (_node.memberName() == "hexdump") { // tvm.hexdump
-		pushArgs();
-		if (getType(m_arguments[0].get())->category() == Type::Category::TvmCell)
-		m_pusher << "CTOS";
-		m_pusher << "HEXDUMP";
-		m_pusher.drop();
-	} else if (_node.memberName() == "setCurrentCode") { // tvm.setCurrentCode
-		const int stackSize = m_pusher.stackSize();
-		pushArgs();
-
-		m_pusher << "CTOS";
-		m_pusher.pushS(0);
-		m_pusher.pushSlice("x" + TvmConst::Selector::RootCodeCell());
-		m_pusher << "SDEQ";
-
-		m_pusher.startOpaque();
-		m_pusher.startContinuation();
-		m_pusher << "PLDREFIDX 1";
-		m_pusher << "CTOS";
-		m_pusher.endContinuation();
-		m_pusher._if();
-		m_pusher.endOpaque(2, 1);
-
-		m_pusher << "PLDREF";
-		m_pusher << "CTOS";
-		m_pusher << "BLESS";
-		m_pusher.popC3();
-		solAssert(stackSize == m_pusher.stackSize(), "");
-	} else if (_node.memberName() == "getData") { // tvm.getData
-		m_pusher.pushRoot();
-	} else if (_node.memberName() == "setData") { // tvm.setData
-		pushArgs();
-		m_pusher.popRoot();
-	} else if (_node.memberName() == "rawCommit") { // tvm.rawCommit
-		m_pusher << "COMMIT";
-	} else if (_node.memberName() == "commit") { // tvm.commit
-		m_pusher.pushFragmentInCallRef(0, 0, "c7_to_c4");
-		m_pusher << "COMMIT";
-	} else if (_node.memberName() == "log") { // tvm.log
-		compileLog();
-	} else if (_node.memberName() == "resetStorage") { //tvm.resetStorage
-		m_pusher.resetAllStateVars();
-	} else if (_node.memberName() == "functionId") { // tvm.functionId
-		auto callDef = getFunctionDeclarationOrConstructor(m_arguments.at(0).get());
-		ChainDataEncoder encoder(&m_pusher);
-		uint32_t funcID;
-		if (callDef == nullptr) {
-			funcID = encoder.calculateConstructorFunctionID();
-		} else {
-			bool isManuallyOverridden{};
-			std::tie(funcID, isManuallyOverridden) = encoder.calculateFunctionID(callDef);
-			if (!isManuallyOverridden) {
-				funcID &= 0x7FFFFFFFu;
-			}
-		}
-		m_pusher.pushInt(funcID);
-	} else if (_node.memberName() == "encodeBody") { // tvm.encodeBody
-		CallableDeclaration const* callDef = getFunctionDeclarationOrConstructor(m_arguments.at(0).get());
-		if (callDef == nullptr) { // if no constructor (default constructor)
-			m_pusher << "NEWC";
-			ChainDataEncoder{&m_pusher}.createDefaultConstructorMessage2();
-		} else {
-			auto funcDef = to<FunctionDefinition>(callDef);
-			const bool needCallback = funcDef->isResponsible();
-			const int shift = needCallback ? 1 : 0;
-			std::optional<uint32_t> callbackFunctionId;
-			if (needCallback) {
-				CallableDeclaration const* callback = getFunctionDeclarationOrConstructor(m_arguments.at(1).get());
-				callbackFunctionId = ChainDataEncoder{&m_pusher}.calculateFunctionIDWithReason(callback, ReasonOfOutboundMessage::RemoteCallInternal);
-			}
-			const ast_vec<VariableDeclaration> &parameters = callDef->parameters();
-			std::vector<Type const *> types = getParams(parameters).first;
-			DecodePositionAbiV2 position{32, 0, types};
-			for (int i = m_arguments.size() - 1; i >= 1 + shift; --i) {
-				acceptExpr(m_arguments.at(i).get());
-			}
-			m_pusher << "NEWC";
-			ChainDataEncoder{&m_pusher}.createMsgBody(
-				convertArray(parameters),
-				ChainDataEncoder{&m_pusher}.calculateFunctionIDWithReason(callDef, ReasonOfOutboundMessage::RemoteCallInternal),
-				callbackFunctionId,
-				position
-			);
-		}
-		m_pusher << "ENDC";
-	} else if (_node.memberName() == "rawReserve") {
-		pushArgs();
-		int n = m_arguments.size();
-		solAssert(isIn(n, 2, 3), "");
-		m_pusher << (n == 2 ? "RAWRESERVE" : "RAWRESERVEX");
-	} else if (isIn(_node.memberName(), "exit", "exit1")) {
-		m_pusher.was_c4_to_c7_called();
-		m_pusher.fixStack(-1); // fix stack
-
-		m_pusher.startContinuation();
-		m_pusher.pushFragment(0, 0, "c7_to_c4");
-		m_pusher.endContinuationFromRef();
-		m_pusher.ifNot();
-
-		if (_node.memberName() == "exit")
-			m_pusher._throw("THROW 0");
-		else
-			m_pusher._throw("THROW 1");
-	} else if (_node.memberName() == "code") {
-		m_pusher << "MYCODE";
-	} else if (_node.memberName() == "codeSalt") {
+void FunctionCallCompiler::codeSalt() {
 		pushArgs();
 		string getSaltFromUsualSelector = R"(
 			PLDREF
@@ -2909,8 +2819,10 @@ CALLREF {
 		boost::replace_all(code, "PrivateOpcode1", TvmConst::Selector::PrivateOpcode1());
 		std::vector<string> codeLines = split(code);
 		m_pusher.push(createNode<HardCode>(codeLines, 1, 1, false));
-	} else if (_node.memberName() == "setCodeSalt") {
-		pushArgAndConvert(0);
+}
+
+void FunctionCallCompiler::setCodeSalt() {
+			pushArgAndConvert(0);
 		m_pusher << "CTOS"; // sliceCode
 		pushArgAndConvert(1); // sliceCode salt
 		string insertSaltInUsualSelector = R"(
@@ -2990,6 +2902,177 @@ CALLREF {
 		boost::replace_all(code, "PrivateOpcode1", TvmConst::Selector::PrivateOpcode1());
 		std::vector<string> codeLines = split(code);
 		m_pusher.push(createNode<HardCode>(codeLines, 2, 1, false));
+}
+
+void FunctionCallCompiler::functionId() {
+	auto callDef = getFunctionDeclarationOrConstructor(m_arguments.at(0).get());
+	ChainDataEncoder encoder(&m_pusher);
+	uint32_t funcID;
+	if (callDef == nullptr) {
+		funcID = encoder.calculateConstructorFunctionID();
+	} else {
+		bool isManuallyOverridden{};
+		std::tie(funcID, isManuallyOverridden) = encoder.calculateFunctionID(callDef);
+		if (!isManuallyOverridden) {
+			funcID &= 0x7FFFFFFFu;
+		}
+	}
+	m_pusher.pushInt(funcID);
+}
+
+void FunctionCallCompiler::abiEncodeBody() {
+	CallableDeclaration const* callDef = getFunctionDeclarationOrConstructor(m_arguments.at(0).get());
+	if (callDef == nullptr) { // if no constructor (default constructor)
+		m_pusher << "NEWC";
+		ChainDataEncoder{&m_pusher}.createDefaultConstructorMessage2();
+	} else {
+		auto funcDef = to<FunctionDefinition>(callDef);
+		const bool needCallback = funcDef->isResponsible();
+		const int shift = needCallback ? 1 : 0;
+		std::optional<uint32_t> callbackFunctionId;
+		if (needCallback) {
+			CallableDeclaration const* callback = getFunctionDeclarationOrConstructor(m_arguments.at(1).get());
+			callbackFunctionId = ChainDataEncoder{&m_pusher}.calculateFunctionIDWithReason(callback, ReasonOfOutboundMessage::RemoteCallInternal);
+		}
+		const ast_vec<VariableDeclaration> &parameters = callDef->parameters();
+		std::vector<Type const *> types = getParams(parameters).first;
+		DecodePositionAbiV2 position{32, 0, types};
+		for (int i = m_arguments.size() - 1; i >= 1 + shift; --i) {
+			acceptExpr(m_arguments.at(i).get());
+		}
+		m_pusher << "NEWC";
+		ChainDataEncoder{&m_pusher}.createMsgBody(
+			convertArray(parameters),
+			ChainDataEncoder{&m_pusher}.calculateFunctionIDWithReason(callDef, ReasonOfOutboundMessage::RemoteCallInternal),
+			callbackFunctionId,
+			position
+		);
+	}
+	m_pusher << "ENDC";
+}
+
+bool FunctionCallCompiler::checkForTvmFunction(const MemberAccess &_node) {
+	if (_node.memberName() == "pubkey") { // tvm.pubkey
+		m_pusher.getGlob(TvmConst::C7::TvmPubkey);
+	} else if (_node.memberName() == "setPubkey") { // tvm.setPubkey
+		pushArgs();
+		m_pusher.setGlob(TvmConst::C7::TvmPubkey);
+	} else if (_node.memberName() == "accept") { // tvm.accept
+		m_pusher << "ACCEPT";
+	} else if (_node.memberName() == "hash") { // tvm.hash
+		pushArgs();
+		switch (m_arguments.at(0)->annotation().type->category()) {
+			case Type::Category::TvmCell:
+			case Type::Category::Array:
+			case Type::Category::StringLiteral:
+				m_pusher << "HASHCU";
+				break;
+			case Type::Category::TvmSlice:
+				m_pusher << "HASHSU";
+				break;
+			default:
+				solUnimplemented("");
+		}
+	} else if (_node.memberName() == "checkSign") { // tvm.checkSign
+		size_t cnt = m_arguments.size();
+		if (getType(m_arguments[0].get())->category() == Type::Category::TvmSlice) {
+			pushArgs();
+			m_pusher << "CHKSIGNS";
+		} else {
+			pushArgAndConvert(0);
+			if (cnt == 4) {
+				pushArgAndConvert(2);
+				pushArgAndConvert(1);
+				m_pusher << "NEWC";
+				m_pusher << "STU 256";
+				m_pusher << "STU 256";
+				m_pusher << "ENDC";
+				m_pusher << "CTOS";
+			} else {
+				pushArgAndConvert(1);
+			}
+			pushArgAndConvert(cnt - 1);
+			m_pusher << "CHKSIGNU";
+		}
+	} else if (_node.memberName() == "setcode") { // tvm.setcode
+		pushArgs();
+		m_pusher << "SETCODE";
+	} else if (_node.memberName() == "bindump") { // tvm.bindump
+		pushArgs();
+		if (getType(m_arguments[0].get())->category() == Type::Category::TvmCell)
+			m_pusher << "CTOS";
+		m_pusher << "BINDUMP";
+		m_pusher.drop();
+	} else if (_node.memberName() == "hexdump") { // tvm.hexdump
+		pushArgs();
+		if (getType(m_arguments[0].get())->category() == Type::Category::TvmCell)
+		m_pusher << "CTOS";
+		m_pusher << "HEXDUMP";
+		m_pusher.drop();
+	} else if (_node.memberName() == "setCurrentCode") { // tvm.setCurrentCode
+		const int stackSize = m_pusher.stackSize();
+		pushArgs();
+
+		m_pusher << "CTOS";
+		m_pusher.pushS(0);
+		m_pusher.pushSlice("x" + TvmConst::Selector::RootCodeCell());
+		m_pusher << "SDEQ";
+
+		m_pusher.startOpaque();
+		m_pusher.startContinuation();
+		m_pusher << "PLDREFIDX 1";
+		m_pusher << "CTOS";
+		m_pusher.endContinuation();
+		m_pusher._if();
+		m_pusher.endOpaque(2, 1);
+
+		m_pusher << "PLDREF";
+		m_pusher << "CTOS";
+		m_pusher << "BLESS";
+		m_pusher.popC3();
+		solAssert(stackSize == m_pusher.stackSize(), "");
+	} else if (_node.memberName() == "getData") { // tvm.getData
+		m_pusher.pushRoot();
+	} else if (_node.memberName() == "setData") { // tvm.setData
+		pushArgs();
+		m_pusher.popRoot();
+	} else if (_node.memberName() == "rawCommit") { // tvm.rawCommit
+		m_pusher << "COMMIT";
+	} else if (_node.memberName() == "commit") { // tvm.commit
+		m_pusher.pushFragmentInCallRef(0, 0, "c7_to_c4");
+		m_pusher << "COMMIT";
+	} else if (_node.memberName() == "log") { // tvm.log
+		compileLog();
+	} else if (_node.memberName() == "resetStorage") { //tvm.resetStorage
+		m_pusher.resetAllStateVars();
+	} else if (_node.memberName() == "functionId") { // tvm.functionId
+		functionId();
+	} else if (_node.memberName() == "encodeBody") { // tvm.encodeBody
+		abiEncodeBody();
+	} else if (_node.memberName() == "rawReserve") {
+		pushArgs();
+		int n = m_arguments.size();
+		solAssert(isIn(n, 2, 3), "");
+		m_pusher << (n == 2 ? "RAWRESERVE" : "RAWRESERVEX");
+	} else if (isIn(_node.memberName(), "exit", "exit1")) {
+		m_pusher.was_c4_to_c7_called();
+		m_pusher.fixStack(-1); // fix stack
+
+		m_pusher.startContinuation();
+		m_pusher.pushFragment(0, 0, "c7_to_c4");
+		m_pusher.endContinuationFromRef();
+		m_pusher.ifNot();
+
+		if (_node.memberName() == "exit")
+			m_pusher._throw("THROW 0");
+		else
+			m_pusher._throw("THROW 1");
+	} else if (_node.memberName() == "code") {
+		m_pusher << "MYCODE";
+	} else if (_node.memberName() == "codeSalt") {
+		codeSalt();
+	} else if (_node.memberName() == "setCodeSalt") {
+		setCodeSalt();
 	} else if (_node.memberName() == "replayProtTime") {
 		m_pusher.getGlob(TvmConst::C7::ReplayProtTime);
 	} else if (_node.memberName() == "setReplayProtTime") {
@@ -3013,45 +3096,62 @@ CALLREF {
 
 void FunctionCallCompiler::abiFunction() {
 	switch (m_funcType->kind()) {
-		case FunctionType::Kind::ABIEncode: {
-			std::vector<Type const *> types;
-			for (ASTPointer<Expression const> const& arg : m_arguments) {
-				types.emplace_back(arg->annotation().type->mobileType());
-			}
-			DecodePositionAbiV2 position{0, 0, types};
+	case FunctionType::Kind::ABIEncode: {
+		std::vector<Type const *> types;
+		for (ASTPointer<Expression const> const& arg : m_arguments) {
+			types.emplace_back(arg->annotation().type->mobileType());
+		}
+		DecodePositionAbiV2 position{0, 0, types};
 
-			for (ASTPointer<Expression const> const& arg : m_arguments | boost::adaptors::reversed) {
-				acceptExpr(arg.get());
-			}
-			m_pusher << "NEWC";
-			ChainDataEncoder encoder{&m_pusher};
-			encoder.encodeParameters(types, position);
-			m_pusher << "ENDC";
-			break;
+		for (ASTPointer<Expression const> const& arg : m_arguments | boost::adaptors::reversed) {
+			acceptExpr(arg.get());
 		}
-		case FunctionType::Kind::ABIDecode: {
-			std::vector<Type const*> types;
-			auto te = to<TupleExpression>(m_arguments.at(1).get());
-			if (te) {
-				for (const ASTPointer<Expression>& e : te->components()) {
-					auto const* argTypeType = dynamic_cast<TypeType const*>(e->annotation().type);
-					Type const* actualType = argTypeType->actualType();
-					types.emplace_back(actualType);
-				}
-			} else {
-				auto const* argTypeType = dynamic_cast<TypeType const*>(m_arguments.at(1)->annotation().type);
+		m_pusher << "NEWC";
+		ChainDataEncoder encoder{&m_pusher};
+		encoder.encodeParameters(types, position);
+		m_pusher << "ENDC";
+		break;
+	}
+	case FunctionType::Kind::ABIDecode: {
+		std::vector<Type const*> types;
+		auto te = to<TupleExpression>(m_arguments.at(1).get());
+		if (te) {
+			for (const ASTPointer<Expression>& e : te->components()) {
+				auto const* argTypeType = dynamic_cast<TypeType const*>(e->annotation().type);
 				Type const* actualType = argTypeType->actualType();
 				types.emplace_back(actualType);
 			}
-
-			acceptExpr(m_arguments.at(0).get());
-			m_pusher << "CTOS";
-			ChainDataDecoder decoder{&m_pusher};
-			decoder.decodeData(0, 0, types);
-			break;
+		} else {
+			auto const* argTypeType = dynamic_cast<TypeType const*>(m_arguments.at(1)->annotation().type);
+			Type const* actualType = argTypeType->actualType();
+			types.emplace_back(actualType);
 		}
-		default:
-			cast_error(m_functionCall, "Not supported");
+
+		acceptExpr(m_arguments.at(0).get());
+		m_pusher << "CTOS";
+		ChainDataDecoder decoder{&m_pusher};
+		decoder.decodeData(0, 0, types);
+		break;
+	}
+	case FunctionType::Kind::ABICodeSalt: {
+		codeSalt();
+		break;
+	}
+	case FunctionType::Kind::ABISetCodeSalt: {
+		setCodeSalt();
+		break;
+	}
+	case FunctionType::Kind::ABIFunctionId: {
+		functionId();
+		break;
+	}
+	case FunctionType::Kind::ABIDecodeFunctionParams: {
+		pushArgAndConvert(1);
+		decodeFunctionParams();
+		break;
+	}
+	default:
+		cast_error(m_functionCall, "Not supported");
 	}
 }
 
@@ -3142,12 +3242,11 @@ bool FunctionCallCompiler::checkAddressThis() {
 }
 
 void FunctionCallCompiler::createObject() {
-	Type const* resultType = m_functionCall.annotation().type;
-	switch (resultType->category()) {
-	case Type::Category::TvmCell: {
-		m_pusher.pushDefaultValue(resultType);
+	switch (m_retType->category()) {
+	case Type::Category::TvmCell:
+	case Type::Category::TvmBuilder:
+		m_pusher.pushDefaultValue(m_retType);
 		break;
-	}
 	default:
 		solUnimplemented("");
 	}
@@ -3156,14 +3255,13 @@ void FunctionCallCompiler::createObject() {
 void FunctionCallCompiler::typeConversion() {
 	solAssert(m_arguments.size() == 1, "");
 	Type const* argType = m_arguments[0]->annotation().type;
-	Type const* resultType = m_functionCall.annotation().type;
 
 	if (auto funCall = to<FunctionCall>(m_arguments[0].get())) {
 		if (*funCall->annotation().kind == FunctionCallKind::TypeConversion && funCall->arguments().size() == 1) {
 			// c(b(a)), e.g. uint8 x; int(uint(x));
 			auto a = to<IntegerType>(funCall->arguments().at(0)->annotation().type);
 			auto b = to<IntegerType>(funCall->annotation().type);
-			auto c = to<IntegerType>(resultType);
+			auto c = to<IntegerType>(m_retType);
 			if (a && b && c) {
 				if (!a->isSigned() && !b->isSigned() && c->isSigned() &&
 					a->numBits() < b->numBits() && b->numBits() == c->numBits()
@@ -3176,9 +3274,51 @@ void FunctionCallCompiler::typeConversion() {
 		}
 	}
 
+	auto getDigits = [](Type const* type)-> int {
+		if (auto fix = to<FixedPointType>(type))
+			return fix->fractionalDigits();
+		if (isIn(type->category(), Type::Category::Integer, Type::Category::VarInteger, Type::Category::Enum))
+			return 0;
+		solUnimplemented("");
+	};
+
+	auto adjustDigits = [&]() {
+		int const delta = getDigits(m_retType) - getDigits(argType->mobileType());
+		if (delta > 0) {
+			m_pusher.pushInt(MathConsts::power10().at(delta));
+			m_pusher << "MUL";
+		}
+		if (delta < 0) {
+			m_pusher.pushInt(MathConsts::power10().at(-delta));
+			m_pusher << "DIV";
+		}
+	};
+
 	solAssert(m_arguments.size() == 1, "");
 	acceptExpr(m_arguments.at(0).get());
-	m_pusher.convert(resultType, argType);
+	switch (m_retType->category()) {
+	case Type::Category::Enum:
+	case Type::Category::FixedPoint:
+	case Type::Category::Integer:
+	case Type::Category::VarInteger:
+		if (argType->category() == Type::Category::FixedBytes) {
+			// do nothing
+		} else {
+			adjustDigits();
+			if (!argType->isImplicitlyConvertibleTo(*m_retType))
+				m_pusher.checkFit(m_retType);
+		}
+		break;
+	case Type::Category::Address:
+	case Type::Category::Contract:
+	case Type::Category::FixedBytes:
+	case Type::Category::Array:
+	case Type::Category::TvmSlice:
+		m_pusher.convert(m_retType, argType);
+		break;
+	default:
+		solUnimplemented(m_retType->humanReadableName());
+	}
 }
 
 bool FunctionCallCompiler::checkLocalFunctionOrLibCall(const Identifier *identifier) {
@@ -3351,6 +3491,7 @@ bool FunctionCallCompiler::checkSolidityUnits() {
 			return true;
 		}
 		case FunctionType::Kind::Format: {
+			const int stackSize = m_pusher.stackSize();
 			auto literal = to<Literal>(m_arguments[0].get());
 			std::string formatStr = literal->value();
 			size_t pos = 0;
@@ -3360,7 +3501,7 @@ bool FunctionCallCompiler::checkSolidityUnits() {
 				size_t close_pos = formatStr.find('}', pos);
 				if (pos == string::npos || close_pos == string::npos)
 					break;
-				if ((formatStr[pos + 1] != ':') && (close_pos != pos + 1)) {
+				if (formatStr[pos + 1] != ':' && close_pos != pos + 1) {
 					pos++;
 					continue;
 				}
@@ -3371,30 +3512,30 @@ bool FunctionCallCompiler::checkSolidityUnits() {
 				formatStr = formatStr.substr(close_pos + 1);
 				pos = 0;
 			}
-			// create new vector(TvmBuilder)
-			m_pusher.pushDefaultValue(TypeProvider::tvmtuple(TypeProvider::tvmbuilder()));
-			// create new builder to store data in it
+			// stack: Stack(TvmBuilder)
 			m_pusher << "NEWC";
+			m_pusher << "NULL";
+			m_pusher << "TUPLE 2";
 
 			auto pushConstStr = [&](const string& constStr) {
 				if (!constStr.empty()) {
 					size_t maxSlice = TvmConst::CellBitLength / 8;
 					for(size_t i = 0; i  < constStr.length(); i += maxSlice) {
 						m_pusher.pushString(constStr.substr(i, min(maxSlice, constStr.length() - i)), true);
-						// stack: BldrList builder Slice
-						m_pusher.pushFragmentInCallRef(3, 2, "storeStringInBuilders");
+						// stack: Stack(TvmBuilder) slice
+						m_pusher.pushFragmentInCallRef(2, 1, "__appendSliceToStringBuilder");
 					}
-					// stack: BldrList builder
+					// stack: Stack(TvmBuilder) slice
 				}
 			};
 			for (size_t it = 0; it < substrings.size(); it++) {
-				// stack: vector(TvmBuilder) builder
+				// stack: Stack(TvmBuilder)
 				pushConstStr(substrings[it].first);
 
 				Type::Category cat = m_arguments[it + 1]->annotation().type->category();
 				Type const *argType = m_arguments[it + 1]->annotation().type;
 				if (cat == Type::Category::Integer || cat == Type::Category::RationalNumber) {
-					// stack: vector(TvmBuilder) builder
+					// stack: Stack(TvmBuilder)
 					std::string format = substrings[it].second;
 					bool leadingZeroes = !format.empty() && (format[0] == '0');
 					bool isHex = !format.empty() && (format.back() == 'x' || format.back() == 'X');
@@ -3407,65 +3548,50 @@ bool FunctionCallCompiler::checkSolidityUnits() {
 						int width = 0;
 						if (format.length() > 0)
 							width = std::stoi(format);
-						if (width < 0)
-							solUnimplemented("Width should be a positive integer.");
-						auto mt = m_arguments[it + 1]->annotation().type->mobileType();
-						auto isInt = dynamic_cast<IntegerType const *>(mt);
+						if (width < 0 || width > 127)
+							cast_error(m_functionCall, "Width should be in range of 0 to 127.");
 						acceptExpr(m_arguments[it + 1].get());
-						if (isInt->isSigned())
-							m_pusher << "ABS";
+						// stack: stack x
 						m_pusher.pushInt(width);
 						m_pusher << (leadingZeroes ? "TRUE" : "FALSE");
+						// stack: stack x width leadingZeroes
 						if (isHex) {
 							if (isLower)
 								m_pusher << "TRUE";
 							else
 								m_pusher << "FALSE";
-						}
-						if (isInt->isSigned()) {
-							acceptExpr(m_arguments[it + 1].get());
-							m_pusher << "ISNEG";
-						} else {
-							m_pusher << "FALSE";
-						}
-						// stack: vector(TvmBuilder) builder abs(number) width leadingZeroes addMinus
-						if (isHex) {
-							m_pusher.pushFragmentInCallRef(7, 2, "convertIntToHexStr");
+							m_pusher.pushFragmentInCallRef(5, 1, "__convertIntToHexString");
 						} else {
-							m_pusher.pushFragmentInCallRef(6, 2, "convertIntToDecStr");
+							m_pusher.pushFragmentInCallRef(4, 1, "__convertIntToString");
 						}
-						// stack: vector(TvmBuilder) builder
 					} else {
 						acceptExpr(m_arguments[it + 1].get());
 						m_pusher.pushInt(9);
-						m_pusher.pushFragmentInCallRef(4, 2, "convertFixedPointToString");
+						m_pusher.pushInt(MathConsts::power10().at(9));
+						m_pusher.pushFragmentInCallRef(4, 1, "__convertFixedPointToString");
 					}
 				} else if (cat == Type::Category::Address) {
-					// stack: vector(TvmBuilder) builder
 					acceptExpr(m_arguments[it + 1].get());
-					// stack: vector(TvmBuilder) builder address
-					m_pusher.pushFragmentInCallRef(3, 2, "convertAddressToHexString");
-					// stack: vector(TvmBuilder) builder
+					m_pusher.pushFragmentInCallRef(2, 1, "__convertAddressToHexString");
 				} else if (isStringOrStringLiteralOrBytes(argType)) {
-					// stack: vector(TvmBuilder) builder
 					acceptExpr(m_arguments[it + 1].get());
-					// stack: vector(TvmBuilder) builder string(cell)
 					m_pusher << "CTOS";
-					// stack: vector(TvmBuilder) builder string(slice)
-					m_pusher.pushFragmentInCallRef(3, 2, "storeStringInBuilders");
-					// stack: vector(TvmBuilder) builder
+					m_pusher.pushFragmentInCallRef(2, 1, "__appendStringToStringBuilder");
 				} else if (cat == Type::Category::FixedPoint) {
 					int power = to<FixedPointType>(argType)->fractionalDigits();
 					acceptExpr(m_arguments[it + 1].get());
 					m_pusher.pushInt(power);
-					m_pusher.pushFragmentInCallRef(4, 2, "convertFixedPointToString");
+					m_pusher.pushInt(MathConsts::power10().at(power));
+					m_pusher.pushFragmentInCallRef(4, 1, "__convertFixedPointToString");
 				} else {
 					cast_error(*m_arguments[it + 1].get(), "Unsupported argument type");
 				}
 			}
 			pushConstStr(formatStr);
 
-			m_pusher.pushFragmentInCallRef(2, 1, "assembleList");
+			m_pusher.pushFragmentInCallRef(1, 1, "__makeString");
+
+			solAssert(stackSize + 1 == m_pusher.stackSize(), "");
 			return true;
 		}
 		case FunctionType::Kind::Stoi: {
@@ -3483,9 +3609,9 @@ bool FunctionCallCompiler::checkLocalFunctionOrLibCallOrFuncVarCall() {
 	auto expr = &m_functionCall.expression();
 	if (auto identifier = to<Identifier>(expr); identifier && checkLocalFunctionOrLibCall(identifier)) {
 	} else if (expr->annotation().type->category() == Type::Category::Function) {
-		if (auto ma = to<MemberAccess>(expr)) {
-			auto category = getType(&ma->expression())->category();
-			if (category == Type::Category::TypeType || isSuper(&ma->expression())) {
+		if (m_memberAccess) {
+			auto category = getType(&m_memberAccess->expression())->category();
+			if (category == Type::Category::TypeType || isSuper(&m_memberAccess->expression())) {
 				// calling of base/super method or typeTypeMethods
 				return false;
 			}
@@ -3536,6 +3662,7 @@ bool FunctionCallCompiler::createNewContract() {
 		bool hasVars = varInit != nullptr;
 		auto ct = to<ContractType>(newExpr->typeName().annotation().type);
 		stateInitExprs[StateInitMembers::Data] = generateDataSection(
+			false,
 			pushKey,
 			hasVars ? varInit : nullptr,
 			ct
@@ -3551,7 +3678,7 @@ bool FunctionCallCompiler::createNewContract() {
 			};
 		}
 
-		buildStateInit(stateInitExprs);
+		encodeStateInit(stateInitExprs);
 
 		// stack: stateInit
 		solAssert(ss + 1 == m_pusher.stackSize(), "");
@@ -3765,8 +3892,7 @@ bool FunctionCallCompiler::checkNewExpression() {
 	if (to<NewExpression>(&m_functionCall.expression()) == nullptr) {
 		return false;
 	}
-	Type const *resultType = m_functionCall.annotation().type;
-	if (resultType->category() == Type::Category::Contract) {
+	if (m_retType->category() == Type::Category::Contract) {
 		cast_error(m_functionCall, R"(Unsupported contract creating. Use call options: "stateInit", "value", "flag")");
 	}
 
@@ -3777,7 +3903,7 @@ bool FunctionCallCompiler::checkNewExpression() {
 void FunctionCallCompiler::creatArrayWithDefaultValue() {
 	std::optional<bigint> num = ExprUtils::constValue(*m_arguments.at(0));
 	if (num.has_value() && num.value() == 0) {
-		auto arrayType = to<ArrayType>(m_functionCall.annotation().type);
+		auto arrayType = to<ArrayType>(m_retType);
 		m_pusher.pushDefaultValue(arrayType);
 		return ;
 	}
@@ -3799,7 +3925,7 @@ void FunctionCallCompiler::creatArrayWithDefaultValue() {
 
 void FunctionCallCompiler::honestArrayCreation(bool onlyDict) {
 	const int stackSize = m_pusher.stackSize();
-	auto arrayType = to<ArrayType>(m_functionCall.annotation().type);
+	auto arrayType = to<ArrayType>(m_retType);
 	IntegerType const& key = getArrayKeyType();
 	Type const* arrayBaseType = arrayType->baseType();
 
@@ -3836,18 +3962,17 @@ void FunctionCallCompiler::honestArrayCreation(bool onlyDict) {
 }
 
 bool FunctionCallCompiler::structMethodCall() {
-	auto ma = to<MemberAccess>(&m_functionCall.expression());
-	if (ma->memberName() != "unpack") {
+	if (m_memberAccess->memberName() != "unpack") {
 		return false;
 	}
-	acceptExpr(&ma->expression());
-	auto structType = to<StructType>(getType(&ma->expression()));
+	acceptExpr(&m_memberAccess->expression());
+	auto structType = to<StructType>(getType(&m_memberAccess->expression()));
 	int memberQty = structType->structDefinition().members().size();
 	m_pusher.untuple(memberQty);
 	return true;
 }
 
-void FunctionCallCompiler::buildStateInit(std::map<StateInitMembers, std::function<void()>> exprs) {
+void FunctionCallCompiler::encodeStateInit(std::map<StateInitMembers, std::function<void()>> exprs) {
 	solAssert(exprs.count(StateInitMembers::Special) == 0, "");
 	solAssert(exprs.count(StateInitMembers::Library) == 0, "");
 	solAssert(exprs.count(StateInitMembers::Code) == 1, "Code must present");
@@ -3864,7 +3989,7 @@ void FunctionCallCompiler::buildStateInit(std::map<StateInitMembers, std::functi
 	// stack: code
 	exprs.at(StateInitMembers::Code)();
 
-	// stake: data code
+	// stack: data code
 	// let's store split_depth and special options
 	if (exprs.count(StateInitMembers::SplitDepth) > 0) {
 		exprs.at(StateInitMembers::SplitDepth)();
@@ -3874,11 +3999,11 @@ void FunctionCallCompiler::buildStateInit(std::map<StateInitMembers, std::functi
 		m_pusher.stzeroes(1);
 	} else {
 		m_pusher << "NEWC";
-		// stake: data code builder
+		// stack: data code builder
 		m_pusher << "STSLICECONST x2_"; // no split_depth and no special // 0 0
 	}
 
-	// stake: data code builder
+	// stack: data code builder
 	m_pusher << "STDICT"; // store code
 	m_pusher << "STDICT"; // store data
 	m_pusher << "STZERO"; // store library
diff --git a/compiler/libsolidity/codegen/TVMFunctionCall.hpp b/compiler/libsolidity/codegen/TVMFunctionCall.hpp
index 258789ff..8da3b789 100644
--- a/compiler/libsolidity/codegen/TVMFunctionCall.hpp
+++ b/compiler/libsolidity/codegen/TVMFunctionCall.hpp
@@ -47,16 +47,20 @@ class FunctionCallCompiler {
 	void userDefinedValueMethods(MemberAccess const& _node);
 	void addressMethods(MemberAccess const& _node);
 	bool libraryCall(MemberAccess const& ma);
-	bool checkForTvmDeployMethods(MemberAccess const& _node, Type::Category category);
-	void tvmBuildIntMsg();
-	void tvmBuildDataInit();
-	void tvmBuildMsgMethod();
+	bool checkTvmABIDeployMethods(Type::Category category);
+	void abiBuildIntMsg();
+	void abiBuildDataInit();
+	void abiBuildExtMsg();
+	void abiDecodeData();
+	int decodeData();
+	int decodeFunctionParams();
 	void sliceMethods(MemberAccess const& _node);
 	void arrayMethods(MemberAccess const& _node);
 	bool checkForOptionalMethods(MemberAccess const& _node);
 	void builderMethods(MemberAccess const& _node);
 	bool checkForTvmVectorMethods(MemberAccess const& _node, Type::Category category);
 	void cellMethods(MemberAccess const& _node);
+	void integerMethods();
 	void variantMethods(MemberAccess const& _node);
 	void addressMethod();
 	bool checkForTvmConfigParamFunction(MemberAccess const& _node);
@@ -64,6 +68,10 @@ class FunctionCallCompiler {
 	void msgFunction(MemberAccess const& _node);
 	void rndFunction(MemberAccess const& _node);
 	void goshFunction();
+	void codeSalt();
+	void setCodeSalt();
+	void functionId();
+	void abiEncodeBody();
 	bool checkForTvmFunction(MemberAccess const& _node);
 	void abiFunction();
 	void mathFunction(MemberAccess const& _node);
@@ -98,8 +106,9 @@ class FunctionCallCompiler {
 		Data,
 		Library
 	};
-	void buildStateInit(std::map<StateInitMembers, std::function<void()>> exprs);
+	void encodeStateInit(std::map<StateInitMembers, std::function<void()>> exprs);
 	std::function<void()> generateDataSection(
+		bool data_map_supported,
 		const std::function<void()>& pushKey,
 		Expression const* vars,
 		ContractType const* ct
@@ -138,6 +147,7 @@ class FunctionCallCompiler {
 	StackPusher& m_pusher;
 	TVMExpressionCompiler m_exprCompiler;
 	FunctionCall const& m_functionCall;
+	MemberAccess const* m_memberAccess{};
 	std::vector<ASTPointer<Expression const>> m_arguments;
 	FunctionType const* m_funcType{};
 	Type const* m_retType{};
diff --git a/compiler/libsolidity/codegen/TVMFunctionCompiler.cpp b/compiler/libsolidity/codegen/TVMFunctionCompiler.cpp
index dc8fd07f..652c9e9c 100644
--- a/compiler/libsolidity/codegen/TVMFunctionCompiler.cpp
+++ b/compiler/libsolidity/codegen/TVMFunctionCompiler.cpp
@@ -15,6 +15,7 @@
  */
 
 #include <tuple>
+#include <numeric>
 #include <boost/algorithm/string/replace.hpp>
 
 #include <liblangutil/SourceReferenceExtractor.h>
@@ -153,38 +154,48 @@ TVMFunctionCompiler::generateC4ToC7(TVMCompilerContext& ctx) {
 		pusher << "LDU 64       ; pubkey timestamp c4";
 	}
 	pusher << "LDU 1      ; ctor flag";
-	pusher.dropUnder(1, 1); // ignore
 	if (pusher.ctx().usage().hasAwaitCall()) {
 		pusher << "LDI 1       ; await flag";
 		pusher.dropUnder(1, 1);
 	}
-	if (!pusher.ctx().notConstantStateVariables().empty()) {
-		pusher.getStack().change(+1); // slice
-		// slice on stack
-		std::vector<Type const *> stateVarTypes = pusher.ctx().notConstantStateVariableTypes();
-		const int ss = pusher.stackSize();
-		ChainDataDecoder decoder{&pusher};
-		decoder.decodeData(pusher.ctx().getOffsetC4(),
-						   pusher.ctx().usage().hasAwaitCall() ? 1 : 0,
-						   stateVarTypes);
-
-		const int varQty = stateVarTypes.size();
-		if (pusher.ctx().tooMuchStateVariables()) {
-			for (int i = 0; i < TvmConst::C7::FirstIndexForVariables; ++i) {
-				pusher.getGlob(i);
-			}
-			pusher.blockSwap(varQty, TvmConst::C7::FirstIndexForVariables);
-			pusher.makeTuple(varQty + TvmConst::C7::FirstIndexForVariables);
-			pusher.popC7();
-		} else {
-			for (int i = varQty - 1; i >= 0; --i) {
-				pusher.setGlob(TvmConst::C7::FirstIndexForVariables + i);
-			}
-		}
-		solAssert(ss - 1 == pusher.stackSize(), "");
+
+	pusher.getStack().change(+1); // slice
+	// slice on stack
+	std::vector<VariableDeclaration const *> stateVars = pusher.ctx().c4StateVariables();
+	std::vector<Type const*> stateVarTypes;
+	std::transform(stateVars.begin(), stateVars.end(), std::back_inserter(stateVarTypes),
+		[](VariableDeclaration const * var){
+		return var->type();
+	});
+	const int ss = pusher.stackSize();
+	ChainDataDecoder decoder{&pusher};
+	decoder.decodeData(pusher.ctx().getOffsetC4(),
+					   pusher.ctx().usage().hasAwaitCall() ? 1 : 0,
+					   stateVarTypes);
+
+	int const varQty = stateVarTypes.size();
+	auto const nostorageStateVars = pusher.ctx().nostorageStateVars();
+	int const nostorageVarQty = nostorageStateVars.size();
+	if (pusher.ctx().tooMuchStateVariables()) {
+		for (VariableDeclaration const * var : nostorageStateVars)
+			pusher.pushDefaultValue(var->type());
+		for (int i = 0; i < TvmConst::C7::FirstIndexForVariables; ++i)
+			pusher.getGlob(i);
+		pusher.blockSwap(varQty + nostorageVarQty, TvmConst::C7::FirstIndexForVariables);
+		pusher.makeTuple(varQty + nostorageVarQty + TvmConst::C7::FirstIndexForVariables);
+		pusher.popC7();
 	} else {
-		pusher << "ENDS";
+		for (VariableDeclaration const * var : nostorageStateVars)
+			pusher.pushDefaultValue(var->type());
+		for (VariableDeclaration const * var : nostorageStateVars | boost::adaptors::reversed)
+			pusher.setGlob(var);
+		for (int i = varQty - 1; i >= 0; --i)
+			pusher.setGlob(TvmConst::C7::FirstIndexForVariables + i);
 	}
+	solAssert(ss - 1 == pusher.stackSize(), "");
+
+	pusher.fixStack(+1); // fix stack
+	pusher.setGlob(TvmConst::C7::ConstructorFlag);
 
 	if (pusher.ctx().storeTimestampInC4()) {
 		pusher.setGlob(TvmConst::C7::ReplayProtTime);
@@ -198,79 +209,33 @@ TVMFunctionCompiler::generateC4ToC7(TVMCompilerContext& ctx) {
 	return f;
 }
 
-Pointer<Function>
-TVMFunctionCompiler::generateC4ToC7WithInitMemory(TVMCompilerContext& ctx) {
-	std::string const name = "c4_to_c7_with_init_storage";
-	ctx.setCurrentFunction(nullptr, name);
+Pointer<Function> TVMFunctionCompiler::generateDefaultC4(TVMCompilerContext& ctx) {
 	StackPusher pusher{&ctx};
-	TVMFunctionCompiler funCompiler{pusher, pusher.ctx().getContract()};
-
-	pusher.pushRoot();
-	pusher << "CTOS";
-	pusher << "SBITS";
-	pusher << "GTINT 1";
-
-	pusher.startContinuation();
-	pusher.pushFragment(0, 0, "c4_to_c7");
-	pusher.endContinuationFromRef();
-
-	pusher.startContinuation();
-	pusher.pushInt(0);
-	pusher.pushRoot();
-	pusher << "CTOS";
-	pusher << "PLDDICT   ; D";
-
-	int varQty = 0;
-	bool tooMuchStateVars = pusher.ctx().tooMuchStateVariables();
-	if (tooMuchStateVars) {
-		for (int i = 0; i < TvmConst::C7::FirstIndexForVariables; ++i) {
-			pusher.getGlob(i);
-			++varQty;
-		}
-	}
-	int shift = 0;
-	for (VariableDeclaration const* v : pusher.ctx().notConstantStateVariables()) {
-		if (v->isStatic()) {
-			pusher.pushInt(TvmConst::C4::PersistenceMembersStartIndex + shift++); // dict vars... index dict
-			pusher.pushS(1 + varQty); // dict vars... index dict
-			pusher.getDict(getKeyTypeOfC4(), *v->type(), GetDictOperation::GetFromMapping);
-		} else {
-			pusher.pushDefaultValue(v->type());
-		}
-		++varQty;
-	}
-	if (tooMuchStateVars) {
-		pusher.makeTuple(varQty);
-		pusher.popC7();
-	} else {
-		auto x = pusher.ctx().notConstantStateVariables(); // move
-		for (VariableDeclaration const* v : x | boost::adaptors::reversed) {
-			pusher.setGlob(v);
-		}
-	}
-
-	pusher.pushInt(64);
-	pusher.startOpaque();
-	pusher.pushAsym("DICTUGET");
-	pusher._throw("THROWIFNOT " + toString(TvmConst::RuntimeException::NoPubkeyInC4));
-	pusher.endOpaque(3, 1);
-
-	pusher << "PLDU 256";
-	pusher.setGlob(TvmConst::C7::TvmPubkey);
-	pusher << "PUSHINT 0 ; timestamp";
-	pusher.setGlob(TvmConst::C7::ReplayProtTime);
-
-	for (VariableDeclaration const *variable: pusher.ctx().notConstantStateVariables()) {
-		if (auto value = variable->value().get()) {
-			funCompiler.acceptExpr(value);
-			pusher.setGlob(variable);
-		}
+	std::vector<VariableDeclaration const *> stateVars = ctx.c4StateVariables();
+	for (VariableDeclaration const* var : stateVars | boost::adaptors::reversed)
+		pusher.pushDefaultValue(var->type());
+	if (ctx.storeTimestampInC4())
+		pusher.pushInt(0);
+	pusher.pushInt(0); // pubkey
+	pusher << "NEWC";
+	pusher << "STU 256";
+	if (ctx.storeTimestampInC4())
+		pusher << "STU 64";
+	pusher << "STZERO"; // constructor flag
+	if (ctx.usage().hasAwaitCall()) {
+		pusher << "STZERO";
+	}
+	const std::vector<Type const *>& memberTypes = ctx.c4StateVariableTypes();
+	if (!memberTypes.empty()) {
+		ChainDataEncoder encoder{&pusher};
+		DecodePositionAbiV2 position{ctx.getOffsetC4(), ctx.usage().hasAwaitCall() ? 1 : 0, memberTypes};
+		encoder.encodeParameters(memberTypes, position);
 	}
-	pusher.endContinuation();
-	pusher.ifElse();
+	pusher << "ENDC";
 
-	ctx.resetCurrentFunction();
-	return createNode<Function>(0, 0, name, nullopt, Function::FunctionType::Fragment, pusher.getBlock());
+	Pointer<CodeBlock> block = pusher.getBlock();
+	auto f = createNode<Function>(0, 0, "default_data_cell", nullopt, Function::FunctionType::Fragment, block);
+	return f;
 }
 
 Pointer<Function>
@@ -412,13 +377,13 @@ TVMFunctionCompiler::generatePublicFunction(TVMCompilerContext& ctx, FunctionDef
 	funCompiler.pushLocation(*function);
 	const bool isResponsible = function->isResponsible();
 	if (isResponsible) {
-		const int saveStakeSize = pusher.stackSize();
+		const int saveStackSize = pusher.stackSize();
 		pusher << "LDU 32"; // callbackId slice
 		pusher.getGlob(TvmConst::C7::ReturnParams); // callbackId slice c7[4]
 		pusher.blockSwap(1, 2); // slice c7[4] callbackId
 		pusher.setIndexQ(TvmConst::C7::ReturnParam::CallbackFunctionId); // slice c7[4]
 		pusher.setGlob(TvmConst::C7::ReturnParams); // slice
-		solAssert(saveStakeSize == pusher.stackSize(), "");
+		solAssert(saveStackSize == pusher.stackSize(), "");
 	}
 	funCompiler.decodeFunctionParamsAndInitVars(isResponsible);
 	funCompiler.pushLocation(*function, true);
@@ -502,8 +467,10 @@ TVMFunctionCompiler::generatePublicFunctionSelector(TVMCompilerContext& ctx, Con
 	ctx.setCurrentFunction(nullptr, name);
 	StackPusher pusher{&ctx};
 	const std::vector<std::pair<uint32_t, std::string>>& functions = pusher.ctx().getPublicFunctions();
+
 	TVMFunctionCompiler compiler{pusher, contract};
-	compiler.buildPublicFunctionSelector(functions, 0, functions.size());
+	PublicFunctionSelector pfs{int(functions.size())};
+	compiler.buildPublicFunctionSelector(functions, 0, functions.size(), pfs);
 	ctx.resetCurrentFunction();
 	return createNode<Function>(1, 1, name, nullopt, Function::FunctionType::Fragment, pusher.getBlock());
 }
@@ -1608,8 +1575,13 @@ void TVMFunctionCompiler::setGlobSenderAddressIfNeed() {
 void TVMFunctionCompiler::setCtorFlag() {
 	m_pusher.pushRoot();
 	m_pusher << "CTOS";
-	m_pusher << "SBITS";
-	m_pusher << "NEQINT 1";
+	bool hasTime = m_pusher.ctx().storeTimestampInC4();
+	if (hasTime)
+		m_pusher.pushInt(256 + 64);
+	else
+		m_pusher.pushInt(256);
+	m_pusher << "SDSKIPFIRST";
+	m_pusher << "PLDI 1";
 	m_pusher.setGlob(TvmConst::C7::ConstructorFlag);
 }
 
@@ -1642,11 +1614,10 @@ Pointer<Function> TVMFunctionCompiler::generateMainExternal(
 	TVMFunctionCompiler f{pusher, contract};
 
 	f.setCopyleftAndTryCatch();
-	f.setCtorFlag(); // TODO unit with setCopyleftAndTryCatch
 	f.setGlobSenderAddressIfNeed();
 
 	pusher.pushS(1);
-	pusher.pushFragmentInCallRef(0, 0, "c4_to_c7_with_init_storage");
+	pusher.pushFragmentInCallRef(0, 0, "c4_to_c7");
 
 	f.checkSignatureAndReadPublicKey();
 	if (pusher.ctx().afterSignatureCheck()) {
@@ -1654,8 +1625,10 @@ Pointer<Function> TVMFunctionCompiler::generateMainExternal(
 		pusher.pushS(3);
 		pusher.pushInlineFunction("afterSignatureCheck", 2, 1);
 	} else {
-		if (pusher.ctx().pragmaHelper().hasTime())   f.defaultReplayProtection();
-		if (pusher.ctx().pragmaHelper().hasExpire()) f.expire();
+		if (pusher.ctx().pragmaHelper().hasTime())
+			f.defaultReplayProtection();
+		if (pusher.ctx().pragmaHelper().hasExpire())
+			f.expire();
 	}
 
 	// msg_body
@@ -1756,7 +1729,7 @@ void TVMFunctionCompiler::defaultReplayProtection() {
 	// msgSlice
 	m_pusher << "LDU 64                         ; timestamp msgSlice";
 	m_pusher.exchange(1);
-	m_pusher.pushFragment(1, 0, "replay_protection");
+	m_pusher.pushFragment(1, 0, "__replayProtection");
 }
 
 void TVMFunctionCompiler::expire() {
@@ -1921,10 +1894,10 @@ void TVMFunctionCompiler::updC4IfItNeeds() {
 	if (m_function->stateMutability() == StateMutability::NonPayable) {
 		m_pusher.pushFragmentInCallRef(0, 0, "c7_to_c4");
 	} else {
-		// if it's external message than save values for replay protection
+		// if it's external message, then we save values for replay protection
 		if (m_pusher.ctx().afterSignatureCheck() == nullptr &&
 			m_pusher.ctx().pragmaHelper().hasTime() &&
-			m_pusher.ctx().notConstantStateVariables().size() >= 2 // just optimization
+			m_pusher.ctx().c4StateVariables().size() >= 2 // just optimization: if varQty == 1, then it's better to call c7_to_c4
 		) {
 			m_pusher.pushS(0);
 			m_pusher.startContinuation();
@@ -2008,15 +1981,9 @@ void TVMFunctionCompiler::pushReceiveOrFallback() {
 void TVMFunctionCompiler::buildPublicFunctionSelector(
 	const std::vector<std::pair<uint32_t, std::string>>& functions,
 	int left,
-	int right
+	int right,
+	PublicFunctionSelector const& pfs
 ) {
-	int qty = right - left;
-	int blockSize = 1;
-	while (4 * blockSize < qty) {
-		blockSize *= 4;
-	}
-	solAssert(4 * blockSize >= qty, "");
-
 	auto pushOne = [&](uint32_t functionId, const std::string& name) {
 		m_pusher.pushS(0);
 		m_pusher.pushInt(functionId);
@@ -2028,28 +1995,25 @@ void TVMFunctionCompiler::buildPublicFunctionSelector(
 		m_pusher.ifJmp();
 	};
 
-	// stack: functionID
-	if (right - left <= 4) {
-		for (int i = left; i < right; ++i) {
-			const auto& [functionId, name] = functions.at(i);
+	int const n = right - left;
+	std::vector<int> const& sizes = pfs.groupSizes(n);
+	int pos = left;
+	for (int const groupSize : sizes) {
+		if (groupSize == 1) {
+			const auto& [functionId, name] = functions.at(pos);
 			pushOne(functionId, name);
+		} else {
+			const auto& [functionId, name] = functions.at(pos + groupSize - 1);
+			m_pusher.pushS(0);
+			m_pusher.pushInt(functionId);
+			m_pusher << "LEQ";
+			m_pusher.startContinuation();
+			buildPublicFunctionSelector(functions, pos, pos + groupSize, pfs);
+			m_pusher.endContinuationFromRef();
+			m_pusher.ifJmp();
+
 		}
-	} else {
-		for (int i = left; i < right; i += blockSize) {
-			int j = std::min(i + blockSize, right);
-			const auto& [functionId, name] = functions.at(j - 1);
-			if (j - i == 1) {
-				pushOne(functionId, name);
-			} else {
-				m_pusher.pushS(0);
-				m_pusher.pushInt(functionId);
-				m_pusher << "LEQ";
-				m_pusher.startContinuation();
-				buildPublicFunctionSelector(functions, i, j);
-				m_pusher.endContinuationFromRef();
-				m_pusher.ifJmp();
-			}
-		}
+		pos += groupSize;
 	}
 }
 
@@ -2058,3 +2022,196 @@ void TVMFunctionCompiler::pushLocation(const ASTNode& node, bool reset) {
 	const int line = reset ? 0 : sr.position.line + 1;
 	m_pusher.pushLoc(sr.sourceName, line);
 }
+
+TVMConstructorCompiler::TVMConstructorCompiler(StackPusher &pusher) :
+	TVMFunctionCompiler{pusher, pusher.ctx().getContract()},
+	m_pusher{pusher}
+{
+
+}
+
+void TVMConstructorCompiler::dfs(ContractDefinition const *c) {
+	if (used[c]) {
+		return;
+	}
+	used[c] = true;
+	dfsOrder.push_back(c);
+	path[c] = dfsOrder;
+	for (const ASTPointer<InheritanceSpecifier>& inherSpec : c->baseContracts()) {
+		auto base = to<ContractDefinition>(inherSpec->name().annotation().referencedDeclaration);
+		ast_vec<Expression> const*  agrs = inherSpec->arguments();
+		if (agrs != nullptr && !agrs->empty()) {
+			m_args[base] = inherSpec->arguments();
+			dfs(base);
+		}
+	}
+	if (c->constructor() != nullptr) {
+		for (const ASTPointer<ModifierInvocation> &modInvoc : c->constructor()->modifiers()) {
+			auto base = to<ContractDefinition>(modInvoc->name().annotation().referencedDeclaration);
+			if (base != nullptr) {
+				if (modInvoc->arguments() != nullptr) {
+					m_args[base] = modInvoc->arguments();
+					dfs(base);
+				}
+			}
+		}
+	}
+	dfsOrder.pop_back();
+}
+
+Pointer<Function> TVMConstructorCompiler::generateConstructors() {
+	FunctionDefinition const* constructor = m_pusher.ctx().getContract()->constructor();
+	m_pusher.ctx().setCurrentFunction(constructor, "constructor");
+
+	{
+		ChainDataEncoder encode{&m_pusher};
+		uint32_t functionId =
+			constructor != nullptr ?
+			encode.calculateFunctionIDWithReason(constructor, ReasonOfOutboundMessage::RemoteCallInternal) :
+			encode.calculateConstructorFunctionID();
+		m_pusher.ctx().addPublicFunction(functionId, "constructor");
+	}
+
+	m_pusher.fixStack(+1); // push encoded params of constructor
+	m_pusher.fixStack(+1); // functionID
+	m_pusher.drop();
+
+	beginConstructor();
+
+	std::vector<ContractDefinition const*> linearizedBaseContracts =
+		m_pusher.ctx().getContract()->annotation().linearizedBaseContracts; // from derived to base
+	for (ContractDefinition const* c : linearizedBaseContracts)
+		dfs(c);
+
+	int take{};
+	if (constructor == nullptr) {
+		m_pusher << "ENDS";
+	} else {
+		take = constructor->parameters().size();
+		vector<Type const*> types = getParams(constructor->parameters()).first;
+		ChainDataDecoder{&m_pusher}.decodeFunctionParameters(types, false);
+		m_pusher.getStack().change(-static_cast<int>(constructor->parameters().size()));
+		for (const ASTPointer<VariableDeclaration>& variable: constructor->parameters())
+			m_pusher.getStack().add(variable.get(), true);
+	}
+	solAssert(m_pusher.stackSize() == take, "");
+	std::set<ContractDefinition const*> areParamsOnStack;
+	areParamsOnStack.insert(linearizedBaseContracts.at(0));
+	for (ContractDefinition const* c : linearizedBaseContracts | boost::adaptors::reversed)
+		if (c->constructor() == nullptr || c->constructor()->parameters().empty())
+			areParamsOnStack.insert(c);
+
+	bool haveConstructor = false;
+	for (ContractDefinition const* c : linearizedBaseContracts | boost::adaptors::reversed) {
+		if (c->constructor() == nullptr)
+			continue;
+		haveConstructor = true;
+		for (ContractDefinition const* parent : path[c]) {
+			if (areParamsOnStack.count(parent) == 0) {
+				areParamsOnStack.insert(parent);
+				for (size_t i = 0; i < parent->constructor()->parameters().size(); ++i) {
+					TVMExpressionCompiler(m_pusher).acceptExpr((*m_args[parent])[i].get(), true);
+					m_pusher.getStack().add(parent->constructor()->parameters()[i].get(), false);
+				}
+			}
+		}
+		int take2 = c->constructor()->parameters().size();
+		StackPusher pusher = m_pusher;
+		pusher.clear();
+		pusher.takeLast(take2);
+		TVMFunctionCompiler::generateFunctionWithModifiers(pusher, c->constructor(), false);
+		m_pusher.fixStack(-take2); // fix stack
+		m_pusher.add(pusher);
+	}
+
+	if (!haveConstructor)
+		m_pusher << "ACCEPT";
+
+//	solAssert(m_pusher.stackSize() == 0, "");
+	m_pusher.pushFragmentInCallRef(0, 0, "c7_to_c4");
+	m_pusher._throw("THROW 0");
+
+	m_pusher.ctx().resetCurrentFunction();
+	Pointer<CodeBlock> block = m_pusher.getBlock();
+	// take slice (contains params) and functionID
+	Pointer<Function> f = createNode<Function>(2, 0, "constructor", nullopt, Function::FunctionType::Fragment, block);
+	return f;
+}
+
+void TVMConstructorCompiler::beginConstructor() {
+	// copy c4 to c7
+	m_pusher.was_c4_to_c7_called();
+	m_pusher.fixStack(-1); // fix stack
+
+	m_pusher.startContinuation();
+	m_pusher.pushFragment(0, 0, "c4_to_c7");
+	m_pusher.endContinuationFromRef();
+	m_pusher._if();
+
+	// set state var, e.g. int m_x = 123;
+	for (VariableDeclaration const *variable: m_pusher.ctx().c4StateVariables()) {
+		if (Expression const* value = variable->value().get()) {
+			acceptExpr(value);
+			m_pusher.setGlob(variable);
+		}
+	}
+
+
+	// generate constructor protection
+	m_pusher.getGlob(TvmConst::C7::ConstructorFlag);
+	m_pusher._throw("THROWIF " + toString(TvmConst::RuntimeException::ConstructorIsCalledTwice));
+}
+
+PublicFunctionSelector::PublicFunctionSelector(int _n) {
+	maxPath = vector<int>(_n + 1, INF);
+	sumPaths = vector<int>(_n + 1, INF);
+	prev = vector<vector<int>>(_n + 1);
+	maxPath[0] = INF;
+	for (int n = 1; n <= _n; ++n) {
+		maxPath[n] = INF;
+		dfs(0, n);
+	}
+	//for (int n = 1; n <= _n; ++n)  cout
+	//	<< std::setw(2) << n << ": "
+	//	<< std::setw(4) << int(double(sumPaths[n]) / n) << " "
+	//	<< std::setw(4) << maxPath[n]
+	//	<< endl;
+}
+
+void PublicFunctionSelector::dfs(int pos, int n) {
+	if (curGroupSize.size() > 4)
+		return;
+	int curSum = std::accumulate(curGroupSize.begin(), curGroupSize.end(), 0);
+	if (curSum > n)
+		return;
+
+	if (curSum == n) {
+		int curMaxPath = 0;
+		int curSumPath = 0;
+		for (int i = 0; i < int(curGroupSize.size()); ++i) {
+			int giSize = curGroupSize.at(i);
+			if (giSize == 1) {
+				curMaxPath = max(curMaxPath, FAIL_JMP * i + OK_JMP);
+				curSumPath += FAIL_JMP * i + OK_JMP;
+			} else {
+				curMaxPath = max(curMaxPath, FAIL_JMP * i + OK_JMP + maxPath.at(giSize));
+				curSumPath += (FAIL_JMP * i + OK_JMP) * giSize + sumPaths.at(giSize);
+			}
+		}
+		if (maxPath[n] > curMaxPath || (maxPath[n] == curMaxPath && sumPaths[n] > curSumPath)) {
+			maxPath[n] = curMaxPath;
+			sumPaths[n] = curSumPath;
+			prev[n] = curGroupSize;
+		}
+	} else if (pos < int(curGroupSize.size())) {
+		++curGroupSize[pos];
+		dfs(pos, n);
+		dfs(pos + 1, n);
+		--curGroupSize[pos];
+	} else {
+		curGroupSize.push_back(1);
+		dfs(pos, n);
+		dfs(pos + 1, n);
+		curGroupSize.pop_back();
+	}
+}
diff --git a/compiler/libsolidity/codegen/TVMFunctionCompiler.hpp b/compiler/libsolidity/codegen/TVMFunctionCompiler.hpp
index 353cfddc..2615f4c5 100644
--- a/compiler/libsolidity/codegen/TVMFunctionCompiler.hpp
+++ b/compiler/libsolidity/codegen/TVMFunctionCompiler.hpp
@@ -20,13 +20,13 @@
 
 namespace solidity::frontend {
 
-
+class PublicFunctionSelector;
 
 class TVMFunctionCompiler: public ASTConstVisitor, private boost::noncopyable
 {
-private:
+protected:
 	TVMFunctionCompiler(StackPusher& pusher, ContractDefinition const *contract);
-
+private:
 	TVMFunctionCompiler(
 		StackPusher& pusher,
 		int modifier,
@@ -39,7 +39,7 @@ class TVMFunctionCompiler: public ASTConstVisitor, private boost::noncopyable
 public:
 	static Pointer<Function> updateOnlyTime(TVMCompilerContext& ctx);
 	static Pointer<Function> generateC4ToC7(TVMCompilerContext& ctx);
-	static Pointer<Function> generateC4ToC7WithInitMemory(TVMCompilerContext& ctx);
+	static Pointer<Function> generateDefaultC4(TVMCompilerContext& ctx);
 	static Pointer<Function> generateBuildTuple(TVMCompilerContext& ctx, std::string const& name, const std::vector<Type const*>& types);
 	static Pointer<Function> generateNewArrays(TVMCompilerContext& ctx, std::string const& name, FunctionCall const* arr);
 	static Pointer<Function> generateConstArrays(TVMCompilerContext& ctx, std::string const& name, TupleExpression const* arr);
@@ -127,7 +127,8 @@ class TVMFunctionCompiler: public ASTConstVisitor, private boost::noncopyable
 	void updC4IfItNeeds();
 	void pushReceiveOrFallback();
 
-	void buildPublicFunctionSelector(const std::vector<std::pair<uint32_t, std::string>>& functions, int left, int right);
+	void buildPublicFunctionSelector(const std::vector<std::pair<uint32_t, std::string>>& functions, int left, int right,
+									 PublicFunctionSelector const& pfs);
     void pushLocation(const ASTNode& node, bool reset = false);
 
 private:
@@ -142,4 +143,35 @@ class TVMFunctionCompiler: public ASTConstVisitor, private boost::noncopyable
 	const bool m_pushArgs{};
 };
 
+class TVMConstructorCompiler: public TVMFunctionCompiler {
+	StackPusher& m_pusher;
+	std::map<ContractDefinition const*, std::vector<ContractDefinition const*>> path;
+	std::vector<ContractDefinition const*> dfsOrder;
+	std::map<ContractDefinition const*, bool> used;
+	std::map<ContractDefinition const*, std::vector<ASTPointer<Expression>> const*> m_args;
+
+public:
+	explicit TVMConstructorCompiler(StackPusher& pusher);
+	void dfs(ContractDefinition const* c);
+	Pointer<Function> generateConstructors();
+private:
+	void beginConstructor();
+};
+
+class PublicFunctionSelector {
+public:
+	explicit PublicFunctionSelector(int n);
+	std::vector<int> const& groupSizes(int n) const { return prev.at(n); }
+private:
+	void dfs(int pos, int n);
+private:
+	std::vector<int> curGroupSize;
+	const int INF = 1e9;
+	const int OK_JMP = 18 + 23 + 18 + 126;  // DUP / PUSHINT ? / LEQ / IFJMPREF
+	const int FAIL_JMP = 18 + 23 + 18 + 26; // DUP / PUSHINT ? / LEQ / IFJMPREF
+	std::vector<int> maxPath;
+	std::vector<int> sumPaths;
+	std::vector<std::vector<int>> prev;
+};
+
 } // end solidity::frontend
diff --git a/compiler/libsolidity/codegen/TVMPusher.cpp b/compiler/libsolidity/codegen/TVMPusher.cpp
index f3704078..4e5c9548 100644
--- a/compiler/libsolidity/codegen/TVMPusher.cpp
+++ b/compiler/libsolidity/codegen/TVMPusher.cpp
@@ -63,7 +63,7 @@ void StackPusher::pushLog() {
 
 // TODO move to function compiler
 Pointer<Function> StackPusher::generateC7ToC4(bool forAwait) {
-	const std::vector<Type const *>& memberTypes = m_ctx->notConstantStateVariableTypes();
+	const std::vector<Type const *>& memberTypes = m_ctx->c4StateVariableTypes();
 	const int stateVarQty = memberTypes.size();
 	if (ctx().tooMuchStateVariables()) {
 		const int saveStack = stackSize();
@@ -75,13 +75,11 @@ Pointer<Function> StackPusher::generateC7ToC4(bool forAwait) {
 		drop(TvmConst::C7::FirstIndexForVariables);
 		solAssert(saveStack + stateVarQty == stackSize(), "");
 	} else {
-		for (int i = stateVarQty - 1; i >= 0; --i) {
+		for (int i = stateVarQty - 1; i >= 0; --i)
 			getGlob(TvmConst::C7::FirstIndexForVariables + i);
-		}
 	}
-	if (ctx().storeTimestampInC4()) {
+	if (ctx().storeTimestampInC4())
 		getGlob(TvmConst::C7::ReplayProtTime);
-	}
 	getGlob(TvmConst::C7::TvmPubkey);
 	*this << "NEWC";
 	*this << "STU 256";
@@ -704,7 +702,7 @@ StackPusher& StackPusher::operator<<(std::string const& opcode) {
 }
 
 void StackPusher::push(std::string const& cmd) {
-	Pointer<GenOpcode> opcode = gen(cmd);
+	Pointer<StackOpcode> opcode = gen(cmd);
 	change(opcode->take(), opcode->ret());
 	m_instructions.back().push_back(opcode);
 }
@@ -976,14 +974,15 @@ void StackPusher::makeTuple(int qty) {
 	} else {
 		solAssert(qty <= 255, "");
 		pushInt(qty);
-		auto opcode = createNode<GenOpcode>("TUPLEVAR", qty + 1, 1);
+		auto opcode = createNode<StackOpcode>("TUPLEVAR", qty + 1, 1);
 		m_instructions.back().push_back(opcode);
 		change(qty + 1, 1);
 	}
 }
 
 void StackPusher::resetAllStateVars() {
-	std::vector<VariableDeclaration const *> const stateVariables = ctx().notConstantStateVariables();
+	std::vector<VariableDeclaration const *> const stateVariables = ctx().c4StateVariables();
+	std::vector<VariableDeclaration const *> const nostorageStateVariables = ctx().nostorageStateVars();
 	if (m_ctx->tooMuchStateVariables()) {
 		pushC7();
 		*this << "FALSE";
@@ -991,12 +990,18 @@ void StackPusher::resetAllStateVars() {
 		unpackFirst(TvmConst::C7::FirstIndexForVariables);
 		for (VariableDeclaration const *variable: stateVariables)
 			pushDefaultValue(variable->type());
-		const int stateVarQty = stateVariables.size();
+		for (VariableDeclaration const *variable: nostorageStateVariables)
+			pushDefaultValue(variable->type());
+		const int stateVarQty = stateVariables.size() + nostorageStateVariables.size();
 		makeTuple(TvmConst::C7::FirstIndexForVariables + stateVarQty);
 		popC7();
 	} else {
 		for (VariableDeclaration const *variable: stateVariables)
 			pushDefaultValue(variable->type());
+		for (VariableDeclaration const *variable: nostorageStateVariables)
+			pushDefaultValue(variable->type());
+		for (VariableDeclaration const *variable: nostorageStateVariables | boost::adaptors::reversed)
+			setGlob(variable);
 		for (VariableDeclaration const *variable: stateVariables | boost::adaptors::reversed)
 			setGlob(variable);
 	}
@@ -1051,7 +1056,7 @@ void StackPusher::popC7() {
 }
 
 void StackPusher::execute(int take, int ret) {
-	auto opcode = createNode<GenOpcode>("EXECUTE", take, ret);
+	auto opcode = createNode<StackOpcode>("EXECUTE", take, ret);
 	change(take, ret);
 	m_instructions.back().push_back(opcode);
 }
@@ -1074,11 +1079,6 @@ void StackPusher::pushS(int i) {
 	change(+1);
 }
 
-void StackPusher::dup2() {
-	m_instructions.back().push_back(makePUSH2(1, 0));
-	change(+2);
-}
-
 void StackPusher::pushS2(int i, int j) {
 	solAssert(i >= 0 && j >= 0, "");
 	m_instructions.back().push_back(makePUSH2(i, j));
@@ -1106,7 +1106,7 @@ bool StackPusher::fastLoad(const Type* type) {
 				*this << "LDDICT";
 			} else {
 				startOpaque();
-				const int saveStakeSize = stackSize();
+				const int saveStackSize = stackSize();
 				auto opt = to<OptionalType>(type);
 
 				auto f = [&](bool reverseOrder) {
@@ -1144,7 +1144,7 @@ bool StackPusher::fastLoad(const Type* type) {
 				endContinuation();
 				fixStack(-1); // fix stack
 				if (!hasLock()) {
-					solAssert(saveStakeSize == stackSize(), "");
+					solAssert(saveStackSize == stackSize(), "");
 				}
 
 				startContinuation();
@@ -1153,13 +1153,13 @@ bool StackPusher::fastLoad(const Type* type) {
 				endContinuation();
 				fixStack(-1); // fix stack
 				if (!hasLock()) {
-					solAssert(saveStakeSize == stackSize(), "");
+					solAssert(saveStackSize == stackSize(), "");
 				}
 
 				ifElse();
 				fixStack(+1); // fix stack
 				if (!hasLock()) {
-					solAssert(saveStakeSize + 1 == stackSize(), "");
+					solAssert(saveStackSize + 1 == stackSize(), "");
 				}
 				endOpaque(1, 2);
 			}
@@ -1595,9 +1595,10 @@ void StackPusher::checkFit(Type const *type) {
 	switch (type->category()) {
 	case Type::Category::Integer: {
 		auto it = to<IntegerType>(type);
-		if (it->isSigned())
-			*this << "FITS " + toString(it->numBits());
-		else
+		if (it->isSigned()) {
+			if (it->numBits() != 257)
+				*this << "FITS " + toString(it->numBits());
+		} else
 			*this << "UFITS " + toString(it->numBits());
 		break;
 	}
@@ -1609,14 +1610,27 @@ void StackPusher::checkFit(Type const *type) {
 			*this << "UFITS " + toString(fp->numBits());
 		break;
 	}
-
 	case Type::Category::VarInteger: {
 		auto varInt = to<VarIntegerType>(type);
 		checkFit(&varInt->asIntegerType());
 		break;
 	}
+	case Type::Category::Enum: {
+		auto enumType = to<EnumType>(type);
+		int size = enumType->numberOfMembers();
+		// TODO special case if size == 2**p
+		pushS(0);
+		pushInt(size); // x x size
+		*this << "LESS"; // x x<size
+		pushS(1); // x x<size x
+		pushInt(-1); // x x<size x -1
+		*this << "GREATER"; // x x<size x>-1
+		*this << "AND"; // x (x<size && x>-1)
+		this->_throw("THROWIFNOT 4");
+		break;
+	}
 	default:
-		solUnimplemented("");
+		solUnimplemented(type->humanReadableName());
 		break;
 	}
 }
@@ -1658,7 +1672,7 @@ void StackPusher::pushCallOrCallRef(
 void StackPusher::pushFragment(int take, int ret, const std::string& functionName) {
 	solAssert(!ctx().callGraph().tryToAddEdge(ctx().currentFunctionName(), functionName), "");
 	change(take, ret);
-	auto opcode = createNode<GenOpcode>(".inline " + functionName, take, ret);
+	auto opcode = createNode<StackOpcode>(".inline " + functionName, take, ret);
 	m_instructions.back().push_back(opcode);
 }
 
@@ -2133,8 +2147,14 @@ void TVMCompilerContext::initMembers(ContractDefinition const *contract) {
 	m_contract = contract;
 
 	ignoreIntOverflow = m_pragmaHelper.hasIgnoreIntOverflow();
-	for (VariableDeclaration const *variable: notConstantStateVariables()) {
-		m_stateVarIndex[variable] = TvmConst::C7::FirstIndexForVariables + m_stateVarIndex.size();
+	auto const c4StateVars = c4StateVariables();
+	for (VariableDeclaration const *variable : c4StateVars) {
+		int index = TvmConst::C7::FirstIndexForVariables + m_stateVarIndex.size();
+		m_stateVarIndex[variable] = index;
+	}
+	for (VariableDeclaration const *variable : nostorageStateVars()) {
+		int index = TvmConst::C7::FirstIndexForVariables + m_stateVarIndex.size();
+		m_stateVarIndex[variable] = index;
 	}
 }
 
@@ -2151,17 +2171,21 @@ int TVMCompilerContext::getStateVarIndex(VariableDeclaration const *variable) co
 	return m_stateVarIndex.at(variable);
 }
 
-std::vector<VariableDeclaration const *> TVMCompilerContext::notConstantStateVariables() const {
-	return ::notConstantStateVariables(getContract());
+std::vector<VariableDeclaration const *> TVMCompilerContext::c4StateVariables() const {
+	return ::stateVariables(getContract(), false);
+}
+
+std::vector<VariableDeclaration const *> TVMCompilerContext::nostorageStateVars() const {
+	return ::stateVariables(getContract(), true);
 }
 
 bool TVMCompilerContext::tooMuchStateVariables() const {
-	return notConstantStateVariables().size() >= TvmConst::C7::FirstIndexForVariables + 6;
+	return c4StateVariables().size() + nostorageStateVars().size() >= TvmConst::C7::FirstIndexForVariables + 6;
 }
 
-std::vector<Type const *> TVMCompilerContext::notConstantStateVariableTypes() const {
+std::vector<Type const *> TVMCompilerContext::c4StateVariableTypes() const {
 	std::vector<Type const *> types;
-	for (VariableDeclaration const * var : notConstantStateVariables()) {
+	for (VariableDeclaration const * var : c4StateVariables()) {
 		types.emplace_back(var->type());
 	}
 	return types;
@@ -2249,7 +2273,7 @@ int TVMCompilerContext::getOffsetC4() const {
 std::vector<std::pair<VariableDeclaration const*, int>> TVMCompilerContext::getStaticVariables() const {
 	int shift = 0;
 	std::vector<std::pair<VariableDeclaration const*, int>> res;
-	for (VariableDeclaration const* v : notConstantStateVariables()) {
+	for (VariableDeclaration const* v : c4StateVariables()) {
 		if (v->isStatic()) {
 			res.emplace_back(v, TvmConst::C4::PersistenceMembersStartIndex + shift++);
 		}
@@ -2299,7 +2323,7 @@ void StackPusher::pushDefaultValue(Type const* _type) {
 	switch (cat) {
 		case Type::Category::Address:
 		case Type::Category::Contract:
-			pushZeroAddress();
+			pushSlice("x2_"); // addr_none$00 = MsgAddressExt;
 			break;
 		case Type::Category::Bool:
 		case Type::Category::FixedBytes:
diff --git a/compiler/libsolidity/codegen/TVMPusher.hpp b/compiler/libsolidity/codegen/TVMPusher.hpp
index 1880fb08..a3237ab5 100644
--- a/compiler/libsolidity/codegen/TVMPusher.hpp
+++ b/compiler/libsolidity/codegen/TVMPusher.hpp
@@ -83,9 +83,10 @@ class TVMCompilerContext {
 	TVMCompilerContext(ContractDefinition const* contract, PragmaDirectiveHelper const& pragmaHelper);
 	void initMembers(ContractDefinition const* contract);
 	int getStateVarIndex(VariableDeclaration const *variable) const;
-	std::vector<VariableDeclaration const *> notConstantStateVariables() const;
+	std::vector<VariableDeclaration const *> c4StateVariables() const;
+	std::vector<VariableDeclaration const *> nostorageStateVars() const;
 	bool tooMuchStateVariables() const;
-	std::vector<Type const *> notConstantStateVariableTypes() const;
+	std::vector<Type const *> c4StateVariableTypes() const;
 	PragmaDirectiveHelper const& pragmaHelper() const;
 	bool isStdlib() const;
 	std::string getFunctionInternalName(FunctionDefinition const* _function, bool calledByPoint = true) const;
@@ -268,8 +269,7 @@ class StackPusher {
 	void setGlob(int index);
 	void setGlob(VariableDeclaration const * vd);
 	void pushS(int i);
-	void dup2();
-	void pushS2(int i, int j);
+	void pushS2(int i, int j); // TODO delete
 	void popS(int i);
 	void pushInt(const bigint& i);
 	void stzeroes(int qty);
diff --git a/compiler/libsolidity/codegen/TVMSimulator.cpp b/compiler/libsolidity/codegen/TVMSimulator.cpp
index f1899ac7..301e6252 100644
--- a/compiler/libsolidity/codegen/TVMSimulator.cpp
+++ b/compiler/libsolidity/codegen/TVMSimulator.cpp
@@ -26,14 +26,21 @@ void Simulator::run(const std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
 		auto nextIter = m_iter + 1;
 		if (nextIter != _end && isPopAndDrop(*m_iter, *nextIter)) {
 			solAssert(m_isDropped, "");
-			solAssert(!m_unableToConvertOpcode, "");
+			solAssert(m_ableToConvertOpcode, "");
 			m_iter += 2;
 			break;
 		}
 
 		auto node = m_iter->get();
 		node->accept(*this);
-		if (m_unableToConvertOpcode || m_isDropped) {
+		if (m_wasSet && m_stopSimulationIfSet) {
+			break;
+		}
+		if (m_wasMoved && m_stopSimulationIfMoved) {
+			++m_iter;
+			break;
+		}
+		if (!m_ableToConvertOpcode || m_isDropped) {
 			++m_iter;
 			break;
 		}
@@ -48,7 +55,6 @@ void Simulator::run(const std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
 
 bool Simulator::visit(AsymGen &/*_node*/) {
 	solUnimplemented("");
-	return false;
 }
 
 bool Simulator::visit(DeclRetFlag &_node) {
@@ -97,7 +103,7 @@ bool Simulator::visit(ReturnOrBreakOrCont &_node) {
 	}
 	m_wasReturnBreakContinue = true;
 	Simulator sim{_node.body()->instructions().begin(), _node.body()->instructions().end(), m_stackSize, m_segment};
-	if (sim.m_unableToConvertOpcode || !sim.m_isDropped) {
+	if (!sim.m_ableToConvertOpcode || !sim.m_isDropped) {
 		// check if value has been dropped because in otherwise, this value is from scope that hasn't been dropped
 		unableToConvertOpcode();
 	} else {
@@ -119,7 +125,7 @@ bool Simulator::visit(TvmException &_node) {
 	return false;
 }
 
-bool Simulator::visit(GenOpcode &_node) {
+bool Simulator::visit(StackOpcode &_node) {
 	if (_node.take() > rest()) {
 		unableToConvertOpcode();
 	} else {
@@ -173,176 +179,202 @@ bool Simulator::visit(Stack &_node) {
 	int newj = j < maxDownIndex ? j : j - m_segment;
 	int newk = k < maxDownIndex ? k : k - m_segment;
 	switch (_node.opcode()) {
-		case Stack::Opcode::PUSH_S: {
-			if (minUpIndex <= i && i <= maxDownIndex) {
-				unableToConvertOpcode();
-			} else if (i < maxDownIndex) {
-				m_commands.emplace_back(_node.shared_from_this());
-				++m_stackSize;
-			} else if (i > maxDownIndex) {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi));
-				++m_stackSize;
-			}
-			break;
+	case Stack::Opcode::PUSH_S: {
+		if (minUpIndex <= i && i <= maxDownIndex) {
+			unableToConvertOpcode();
+		} else if (i < maxDownIndex) {
+			m_commands.emplace_back(_node.shared_from_this());
+			++m_stackSize;
+		} else if (i > maxDownIndex) {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi));
+			++m_stackSize;
 		}
-		case Stack::Opcode::POP_S: {
-			if (m_segment == 1 && i == 1 && m_stackSize == 2) { // it equals to BLKDROP2 1, 1
-				m_isDropped = true;
-			} else if (rest() == 0) {
-				unableToConvertOpcode();
-			} else if (i == maxDownIndex && m_segment == 1) {
-				m_wasSet = true;
-				--m_stackSize; // TODO delete this
-				// don't push to m_commands, just ignore the opcode
-			} else if (i < minUpIndex) {
-				--m_stackSize;
-				m_commands.emplace_back(_node.shared_from_this());
-			} else if (i > maxDownIndex) {
-				// here _node.i() >= 2
-				--m_stackSize;
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi));
-			} else {
-				unableToConvertOpcode();
-			}
-			break;
+		break;
+	}
+	case Stack::Opcode::POP_S: {
+		if (m_segment == 1 && i == 1 && m_stackSize == 2) { // it equals to BLKDROP2 1, 1
+			m_isDropped = true;
+		} else if (rest() == 0) {
+			unableToConvertOpcode();
+		} else if (i == maxDownIndex && m_segment == 1) {
+			m_wasSet = true;
+			--m_stackSize; // TODO delete this
+			// don't push to m_commands, just ignore the opcode
+		} else if (i < minUpIndex) {
+			--m_stackSize;
+			m_commands.emplace_back(_node.shared_from_this());
+		} else if (i > maxDownIndex) {
+			// here _node.i() >= 2
+			--m_stackSize;
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi));
+		} else {
+			unableToConvertOpcode();
 		}
-		case Stack::Opcode::DROP: {
-			int n = i;
-			if (m_stackSize <= n) {
-				m_isDropped = true;
-				if (n - m_segment > 0)
-					m_commands.emplace_back(makeDROP(n - m_segment));
-			} else if (rest() >= n) {
-				m_stackSize -= n;
-				m_commands.emplace_back(makeDROP(n));
-			} else {
-				unableToConvertOpcode();
-			}
-			break;
+		break;
+	}
+	case Stack::Opcode::DROP: {
+		int n = i;
+		if (m_stackSize <= n) {
+			m_isDropped = true;
+			if (n - m_segment > 0)
+				m_commands.emplace_back(makeDROP(n - m_segment));
+		} else if (rest() >= n) {
+			m_stackSize -= n;
+			m_commands.emplace_back(makeDROP(n));
+		} else {
+			unableToConvertOpcode();
 		}
+		break;
+	}
 
-		case Stack::Opcode::BLKDROP2: {
-			int drop = i;
-			int rest = j;
-			if (rest >= m_stackSize) {
-				m_commands.emplace_back(makeBLKDROP2(drop, rest - m_segment));
-			} else if (rest <= this->rest() && rest + drop >= m_stackSize) {
-				if (drop - m_segment > 0) {
-					m_commands.emplace_back(makeBLKDROP2(drop - m_segment, rest));
-				}
-				m_isDropped = true;
-			} else if (rest + drop <= this->rest()) {
-				m_commands.emplace_back(makeBLKDROP2(drop, rest));
-				m_stackSize -= drop;
-			} else {
-				unableToConvertOpcode();
-			}
-			break;
-		}
-		case Stack::Opcode::BLKPUSH: {
-			int n = i;
-			int maxDownPushIndex = j;
-			int minUpPushIndex = maxDownPushIndex - n + 1; // include
-			if (std::max(minUpIndex, minUpPushIndex) > std::min(maxDownIndex, maxDownPushIndex)) {
-				m_commands.emplace_back(makeBLKPUSH(n, newj));
-				m_stackSize += n;
-			} else {
-				unableToConvertOpcode();
+	case Stack::Opcode::BLKDROP2: {
+		int drop = i;
+		int rest = j;
+		if (rest >= m_stackSize) {
+			m_commands.emplace_back(makeBLKDROP2(drop, rest - m_segment));
+		} else if (rest <= this->rest() && rest + drop >= m_stackSize) {
+			if (drop - m_segment > 0) {
+				m_commands.emplace_back(makeBLKDROP2(drop - m_segment, rest));
 			}
-			break;
+			m_isDropped = true;
+		} else if (rest + drop <= this->rest()) {
+			m_commands.emplace_back(makeBLKDROP2(drop, rest));
+			m_stackSize -= drop;
+		} else {
+			unableToConvertOpcode();
 		}
-		case Stack::Opcode::REVERSE: {
-			int n = i;
-			int minUpReverseIndex = j;
-			int maxDownReverseIndex = minUpReverseIndex + n - 1; // include
-			if (std::max(minUpIndex, minUpReverseIndex) > std::min(maxDownIndex, maxDownReverseIndex)) {
-				if (maxDownIndex < minUpReverseIndex) {
-					m_commands.emplace_back(makeREVERSE(n, j - m_segment));
-				} else {
-					m_commands.emplace_back(_node.shared_from_this());
-				}
-			} else {
-				unableToConvertOpcode();
-			}
-			break;
+		break;
+	}
+	case Stack::Opcode::BLKPUSH: {
+		int n = i;
+		int maxDownPushIndex = j;
+		int minUpPushIndex = maxDownPushIndex - n + 1; // include
+		if (std::max(minUpIndex, minUpPushIndex) > std::min(maxDownIndex, maxDownPushIndex)) {
+			m_commands.emplace_back(makeBLKPUSH(n, newj));
+			m_stackSize += n;
+		} else {
+			unableToConvertOpcode();
 		}
-		case Stack::Opcode::BLKSWAP:
-			if (i == 1 && j + i == m_stackSize) {
-				unableToConvertOpcode();
-				if (m_segment == 1) {
-					m_wasMoved = true;
-				}
-			} else if (i + j <= rest()) {
-				m_commands.emplace_back(makeBLKSWAP(i, j));
-			 } else if (j >= m_stackSize) {
-				if (j - m_segment >= 1) {
-					m_commands.emplace_back(makeBLKSWAP(i, j - m_segment));
-				}
-				m_stackSize += i; // we take i element and push ones to the top of the stack
-			} else {
-				unableToConvertOpcode();
-			}
-			break;
-		case Stack::Opcode::XCHG:
-			if ((minUpIndex <= i && i <= maxDownIndex) ||
-				(minUpIndex <= j && j <= maxDownIndex)) { // it's ok if j==-1
-				unableToConvertOpcode();
-			} else {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
-			}
-			break;
-		case Stack::Opcode::PUSH2_S:
-			if ((minUpIndex <= i && i <= maxDownIndex) ||
-				(minUpIndex <= j && j <= maxDownIndex)) {
-				unableToConvertOpcode();
-			} else {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
-			}
-			m_stackSize += 2;
-			break;
-		case Stack::Opcode::PUSH3_S:
-			if ((minUpIndex <= i && i <= maxDownIndex) ||
-				(minUpIndex <= j && j <= maxDownIndex) ||
-				(minUpIndex <= k && k <= maxDownIndex)) {
-				unableToConvertOpcode();
+		break;
+	}
+	case Stack::Opcode::REVERSE: {
+		int n = i;
+		int minUpReverseIndex = j;
+		int maxDownReverseIndex = minUpReverseIndex + n - 1; // include
+		if (m_segment == 1 && minUpReverseIndex <= m_stackSize - 1 && m_stackSize - 1 <= maxDownReverseIndex) {
+			if (i - 1 >= 2)
+				m_commands.emplace_back(makeREVERSE(i - 1, j));
+			m_stackSize = minUpReverseIndex + (maxDownReverseIndex - (m_stackSize - 1)) + 1;
+		} else if (std::max(minUpIndex, minUpReverseIndex) > std::min(maxDownIndex, maxDownReverseIndex)) {
+			if (maxDownIndex < minUpReverseIndex) {
+				m_commands.emplace_back(makeREVERSE(n, j - m_segment));
 			} else {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj, newk));
-			}
-			m_stackSize += 3;
-			break;
-
-		case Stack::Opcode::TUCK:
-			if (rest() >= 2) {
 				m_commands.emplace_back(_node.shared_from_this());
-				++m_stackSize;
-			} else {
-				unableToConvertOpcode();
 			}
-			break;
-
-		case Stack::Opcode::PUXC:
-			if ((minUpIndex <= i && i <= maxDownIndex) ||
-				(minUpIndex <= j && j <= maxDownIndex) ||  // note: it's false if j==-1
-				rest() == 0 // because we make PUSH Si, SWAP ...
-			) {
-				unableToConvertOpcode();
-			} else {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
-				++m_stackSize;
+		} else {
+			unableToConvertOpcode();
+		}
+		break;
+	}
+	case Stack::Opcode::BLKSWAP: {
+		// int down = i;
+		// int up = j;
+		if (i == 1 && j + i == m_stackSize && m_segment == 1 && m_stopSimulationIfMoved) {
+			m_wasMoved = true; // TODO call unableToConvertOpcode with reason: moved, set, etc
+		} else if (j <= rest() && i + j >= m_stackSize) {
+			if (i - m_segment >= 1)
+				m_commands.emplace_back(makeBLKSWAP(i - m_segment, j));
+			m_stackSize -= j;
+		} else if (i + j <= rest()) {
+			m_commands.emplace_back(makeBLKSWAP(i, j));
+		} else if (j >= m_stackSize) {
+			if (j - m_segment >= 1) {
+				m_commands.emplace_back(makeBLKSWAP(i, j - m_segment));
 			}
-			break;
-
-		case Stack::Opcode::XCPU: {
-			if ((minUpIndex <= i && i <= maxDownIndex) ||
-				(minUpIndex <= j && j <= maxDownIndex)
-			) {
-				unableToConvertOpcode();
-			} else {
-				m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
-				++m_stackSize;
+			m_stackSize += i; // we take i elements and push ones to the top of the stack
+		} else {
+			unableToConvertOpcode();
+		}
+		break;
+	}
+	case Stack::Opcode::XCHG:
+		solAssert(i < j, "");
+		solAssert(j != -1, "");
+		if (m_segment == 1 && i == m_stackSize - 1) {
+			if (j >= 2) {
+				m_commands.emplace_back(makeREVERSE(j, 0));
+				if (j - i - 1 >= 1)
+					m_commands.emplace_back(makeBLKSWAP(j - i - 1, 1));
+				m_commands.emplace_back(makeREVERSE(j, 0));
 			}
-			break;
+			m_stackSize = j + 1;
+		} else if (m_segment == 1 && j == m_stackSize - 1) {
+			if (i > 0)
+				m_commands.emplace_back(makeBLKSWAP(1, i));
+			if (j - 1 >= 1)
+				m_commands.emplace_back(makeBLKSWAP(j - 1, 1));
+			m_stackSize = i + 1;
+		} else if ((minUpIndex <= i && i <= maxDownIndex) ||
+			(minUpIndex <= j && j <= maxDownIndex)) { // it's ok if j==-1
+			unableToConvertOpcode();
+		} else {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
+		}
+		break;
+	case Stack::Opcode::PUSH2_S:
+		if ((minUpIndex <= i && i <= maxDownIndex) ||
+			(minUpIndex <= j && j <= maxDownIndex)) {
+			unableToConvertOpcode();
+		} else {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
+		}
+		m_stackSize += 2;
+		break;
+	case Stack::Opcode::PUSH3_S:
+		if ((minUpIndex <= i && i <= maxDownIndex) ||
+			(minUpIndex <= j && j <= maxDownIndex) ||
+			(minUpIndex <= k && k <= maxDownIndex)) {
+			unableToConvertOpcode();
+		} else {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj, newk));
+		}
+		m_stackSize += 3;
+		break;
+
+	case Stack::Opcode::PUXC:
+		if ((minUpIndex <= i && i <= maxDownIndex) ||
+			(minUpIndex <= j && j <= maxDownIndex) ||  // note: it's false if j==-1
+			rest() == 0 // because we make PUSH Si, SWAP ...
+		) {
+			unableToConvertOpcode();
+		} else {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
+			++m_stackSize;
 		}
+		break;
+
+	case Stack::Opcode::XCPU: {
+		if ((minUpIndex <= i && i <= maxDownIndex) ||
+			(minUpIndex <= j && j <= maxDownIndex)
+		) {
+			unableToConvertOpcode();
+		} else {
+			m_commands.emplace_back(createNode<Stack>(_node.opcode(), newi, newj));
+			++m_stackSize;
+		}
+		break;
+	}
+	case Stack::Opcode::PUXC2:
+	case Stack::Opcode::XC2PU:
+	case Stack::Opcode::XCPU2:
+	case Stack::Opcode::XCHG2:
+	case Stack::Opcode::XCPUXC:
+	case Stack::Opcode::PUXCPU:
+	case Stack::Opcode::PU2XC:
+	case Stack::Opcode::XCHG3: {
+		// TODO implement
+		unableToConvertOpcode();
+	}
 	}
 
 	return false;
@@ -485,7 +517,7 @@ void Simulator::endVisit(CodeBlock &/*_node*/) {
 std::optional<std::pair<Pointer<CodeBlock>, bool>>
 Simulator::trySimulate(CodeBlock const& body, int begStackSize, int /*endStackSize*/) {
 	Simulator sim{body.instructions().begin(), body.instructions().end(), begStackSize, m_segment};
-	if (sim.m_unableToConvertOpcode || sim.m_wasSet) {
+	if (!sim.m_ableToConvertOpcode || sim.m_wasSet) {
 		unableToConvertOpcode();
 		return {};
 	}
@@ -511,7 +543,7 @@ bool Simulator::isPopAndDrop(Pointer<TvmAstNode> const& a, Pointer<TvmAstNode> c
 }
 
 bool Simulator::success() const {
-	if (m_unableToConvertOpcode) {
+	if (!m_ableToConvertOpcode) {
 		return false;
 	}
 	return m_isDropped && !m_wasSet;
diff --git a/compiler/libsolidity/codegen/TVMSimulator.hpp b/compiler/libsolidity/codegen/TVMSimulator.hpp
index cbfe849e..0e2604b8 100644
--- a/compiler/libsolidity/codegen/TVMSimulator.hpp
+++ b/compiler/libsolidity/codegen/TVMSimulator.hpp
@@ -19,82 +19,89 @@
 #include "TvmAstVisitor.hpp"
 
 namespace solidity::frontend {
-	class Simulator : public TvmAstVisitor {
-	public:
-		explicit Simulator(
-			std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
-			std::vector<Pointer<TvmAstNode>>::const_iterator _end,
-			int _startSize,
-			int _segment
-		) :
-			m_segment{_segment},
-			m_stackSize{_startSize}
-		{
-			run(_beg, _end);
-		}
-	private:
-		void run(std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
-				 std::vector<Pointer<TvmAstNode>>::const_iterator _end);
-	public:
-		bool visit(AsymGen &_node) override;
-		bool visit(DeclRetFlag &_node) override;
-		bool visit(Opaque &_node) override;
-		bool visit(HardCode &_node) override;
-		bool visit(Loc &_node) override;
-		bool visit(TvmReturn &_node) override;
-		bool visit(ReturnOrBreakOrCont &_node) override;
-		bool visit(TvmException &_node) override;
-		bool visit(GenOpcode &_node) override;
-		bool visit(PushCellOrSlice &_node) override;
-		bool visit(Glob &_node) override;
-		bool visit(Stack &_node) override;
-		bool visit(CodeBlock &_node) override;
-		bool visit(SubProgram &_node) override;
-		bool visit(LogCircuit &_node) override;
-		bool visit(TryCatch &_node) override;
-		bool visit(TvmIfElse &_node) override;
-		bool visit(TvmRepeat &_node) override;
-		bool visit(TvmUntil &_node) override;
-		bool visit(While &_node) override;
-		bool visit(Contract &_node) override;
-		bool visit(Function &_node) override;
-		void endVisit(CodeBlock &_node) override;
+class Simulator : public TvmAstVisitor {
+public:
+	explicit Simulator(
+		std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
+		std::vector<Pointer<TvmAstNode>>::const_iterator _end,
+		int _stackSize,
+		int _segment,
+		bool _stopSimulationIfSet = false,
+		bool _stopSimulationIfMoved = false
+	) :
+		m_stopSimulationIfSet{_stopSimulationIfSet},
+		m_stopSimulationIfMoved{_stopSimulationIfMoved},
+		m_segment{_segment},
+		m_stackSize{_stackSize}
+	{
+		solAssert(_segment <= _stackSize, "");
+		run(_beg, _end);
+	}
+private:
+	void run(std::vector<Pointer<TvmAstNode>>::const_iterator _beg,
+			 std::vector<Pointer<TvmAstNode>>::const_iterator _end);
+public:
+	bool visit(AsymGen &_node) override;
+	bool visit(DeclRetFlag &_node) override;
+	bool visit(Opaque &_node) override;
+	bool visit(HardCode &_node) override;
+	bool visit(Loc &_node) override;
+	bool visit(TvmReturn &_node) override;
+	bool visit(ReturnOrBreakOrCont &_node) override;
+	bool visit(TvmException &_node) override;
+	bool visit(StackOpcode &_node) override;
+	bool visit(PushCellOrSlice &_node) override;
+	bool visit(Glob &_node) override;
+	bool visit(Stack &_node) override;
+	bool visit(CodeBlock &_node) override;
+	bool visit(SubProgram &_node) override;
+	bool visit(LogCircuit &_node) override;
+	bool visit(TryCatch &_node) override;
+	bool visit(TvmIfElse &_node) override;
+	bool visit(TvmRepeat &_node) override;
+	bool visit(TvmUntil &_node) override;
+	bool visit(While &_node) override;
+	bool visit(Contract &_node) override;
+	bool visit(Function &_node) override;
+	void endVisit(CodeBlock &_node) override;
 
-		std::optional<std::pair<Pointer<CodeBlock>, bool>> trySimulate(CodeBlock const& block, int begStackSize, int endStackSize);
-		bool isPopAndDrop(Pointer<TvmAstNode> const& a, Pointer<TvmAstNode> const& b);
+	std::optional<std::pair<Pointer<CodeBlock>, bool>> trySimulate(CodeBlock const& block, int begStackSize, int endStackSize);
+	bool isPopAndDrop(Pointer<TvmAstNode> const& a, Pointer<TvmAstNode> const& b);
 
-		bool success() const;
-		bool wasSet() const { return m_wasSet; }
-		bool wasMoved() const { return m_wasMoved; }
-		std::vector<Pointer<TvmAstNode>> const& commands() const { return m_commands; }
-		std::vector<Pointer<TvmAstNode>>::const_iterator getIter() const { return m_iter; }
-		std::set<int> setGlobIndexes() const { return m_setGlobs; }
-		bool wasCall() const { return m_wasCall; }
+	bool success() const;
+	bool wasSet() const { return m_wasSet; }
+	bool wasMoved() const { return m_wasMoved; }
+	std::vector<Pointer<TvmAstNode>> const& commands() const { return m_commands; }
+	std::vector<Pointer<TvmAstNode>>::const_iterator getIter() const { return m_iter; }
+	std::set<int> setGlobIndexes() const { return m_setGlobs; }
+	bool wasCall() const { return m_wasCall; }
 
-	protected:
-		bool visitNode(TvmAstNode const&) override;
-		void endVisitNode(TvmAstNode const&) override;
+protected:
+	bool visitNode(TvmAstNode const&) override;
+	void endVisitNode(TvmAstNode const&) override;
 
-	private:
-		int rest() const;
-		void unableToConvertOpcode() {
-			m_unableToConvertOpcode = true;
-		}
+private:
+	int rest() const;
+	void unableToConvertOpcode() {
+		m_ableToConvertOpcode = false;
+	}
 
-	private:
-		bool m_wasSet{};
-		bool m_wasMoved{};
-		bool m_unableToConvertOpcode{};
-		bool m_isDropped{};
-		bool m_wasReturnBreakContinue{};
+private:
+	bool m_wasSet{};
+	bool m_stopSimulationIfSet{};
+	bool m_stopSimulationIfMoved{};
+	bool m_wasMoved{};
+	bool m_ableToConvertOpcode = true;
+	bool m_isDropped{};
+	bool m_wasReturnBreakContinue{};
 
-		int const m_segment{};
-		int m_stackSize{};
-		std::vector<Pointer<TvmAstNode>> m_commands;
-		std::vector<Pointer<TvmAstNode>>::const_iterator m_iter{};
-		std::set<int> m_setGlobs;
-		bool m_wasCall{};
-	};
+	int const m_segment;
+	int m_stackSize{};
+	std::vector<Pointer<TvmAstNode>> m_commands;
+	std::vector<Pointer<TvmAstNode>>::const_iterator m_iter{};
+	std::set<int> m_setGlobs;
+	bool m_wasCall{};
+};
 } // end solidity::frontend
 
 
diff --git a/compiler/libsolidity/codegen/TVMTypeChecker.cpp b/compiler/libsolidity/codegen/TVMTypeChecker.cpp
index cea3b3c7..bdafb33f 100644
--- a/compiler/libsolidity/codegen/TVMTypeChecker.cpp
+++ b/compiler/libsolidity/codegen/TVMTypeChecker.cpp
@@ -166,9 +166,18 @@ bool TVMTypeChecker::visit(TryStatement const& _tryStatement) {
 	return true;
 }
 
-bool TVMTypeChecker::visit(VariableDeclaration const& _node) {
-	if (_node.isStateVariable() && _node.type()->category() == Type::Category::TvmSlice) {
-		m_errorReporter.typeError(9191_error, _node.location(), "This type can't be used for state variables.");
+bool TVMTypeChecker::visit(VariableDeclaration const& _variable) {
+	if (_variable.isStateVariable()) {
+		ASTString const& name = _variable.name();
+		if (name == "_pubkey" || name == "_timestamp" || name == "_constructorFlag")
+			m_errorReporter.typeError(7984_error, _variable.location(), "The name \"" + name + "\" is reserved.");
+		Type::Category const category = _variable.type()->category();
+		if (category == Type::Category::TvmSlice || category == Type::Category::TvmVector)
+			m_errorReporter.typeError(9191_error, _variable.location(), "This type can't be used for state variables.");
+		if (_variable.isNoStorage() && _variable.isStatic())
+			m_errorReporter.typeError(4161_error, _variable.location(), R"(State variable can not be marked as "nostorage" and "static" simultaneously.)");
+		if (_variable.isNoStorage() && _variable.value())
+			m_errorReporter.typeError(4161_error, _variable.location(), "\"nostorage\" state variable can not be initialized here.");
 	}
 	return true;
 }
@@ -262,6 +271,8 @@ bool TVMTypeChecker::visit(IndexRangeAccess const& indexRangeAccess) {
 void TVMTypeChecker::checkDeprecation(FunctionCall const& _functionCall) {
 	auto memberAccess = to<MemberAccess>(&_functionCall.expression());
 	ASTString const& memberName = memberAccess ? memberAccess->memberName() : "";
+	auto magicType = memberAccess ? to<MagicType>(memberAccess->expression().annotation().type) : nullptr;
+	MagicType::Kind kind = magicType ? magicType->kind() : MagicType::Kind::TVM;
 	Type const* expressionType = _functionCall.expression().annotation().type;
 	switch (expressionType->category()) {
 	case Type::Category::Function: {
@@ -272,63 +283,104 @@ void TVMTypeChecker::checkDeprecation(FunctionCall const& _functionCall) {
 									"\"<optional(T)>.reset()\" is deprecated. Use \"delete <optional(T)>;\".");
 			break;
 		case FunctionType::Kind::TVMSliceLoad:
-			if (memberName == "decode") {
+			if (memberName == "decode")
 				m_errorReporter.warning(9518_error, _functionCall.location(),
 										"\"<TvmSlice>.decode()\" is deprecated. Use \"<TvmSlice>.load()\"");
-			}
 			break;
 		case FunctionType::Kind::TVMSliceLoadQ:
-			if (memberName == "decodeQ") {
+			if (memberName == "decodeQ")
 				m_errorReporter.warning(6501_error, _functionCall.location(),
 										"\"<TvmSlice>.decodeQ()\" is deprecated. Use \"<TvmSlice>.loadQ()\"");
-			}
 			break;
 		case FunctionType::Kind::TVMSliceLoadFunctionParams:
-			if (memberName == "decodeFunctionParams") {
-				m_errorReporter.warning(9789_error, _functionCall.location(),
-										"\"<TvmSlice>.decodeFunctionParams()\" is deprecated. Use \"<TvmSlice>.loadFunctionParams()\"");
-			}
+			m_errorReporter.warning(9789_error, _functionCall.location(),
+									"\"<TvmSlice>.loadFunctionParams()\" and \"<TvmSlice>.decodeFunctionParams()\" are deprecated. Use \"abi.decodeFunctionParams()\"");
 			break;
 		case FunctionType::Kind::TVMSliceLoadStateVars:
-			if (memberName == "decodeStateVars") {
-				m_errorReporter.warning(3738_error, _functionCall.location(),
-										"\"<TvmSlice>.decodeStateVars()\" is deprecated. Use \"<TvmSlice>.loadStateVars()\"");
-			}
+			m_errorReporter.warning(2953_error, _functionCall.location(),
+									"\"<TvmSlice>.loadStateVars()\" and \"<TvmSlice>.decodeStateVars()\" are deprecated. Use \"abi.decodeData()\"");
 			break;
 		case FunctionType::Kind::TVMSliceLoadUint:
-			if (memberName == "loadUnsigned") {
+			if (memberName == "loadUnsigned")
 				m_errorReporter.warning(5093_error, _functionCall.location(),
 										"\"<TvmSlice>.loadUnsigned()\" is deprecated. Use \"<TvmSlice>.loadUint()\"");
-			}
 			break;
 		case FunctionType::Kind::TVMSliceLoadInt:
-			if (memberName == "loadSigned") {
+			if (memberName == "loadSigned")
 				m_errorReporter.warning(1581_error, _functionCall.location(),
 										"\"<TvmSlice>.loadSigned()\" is deprecated. Use \"<TvmSlice>.loadInt()\"");
-			}
 			break;
 		case FunctionType::Kind::TVMBuilderStoreUint:
-			if (memberName == "storeUnsigned") {
+			if (memberName == "storeUnsigned")
 				m_errorReporter.warning(1214_error, _functionCall.location(),
 										"\"<TvmBuilder>.storeUnsigned()\" is deprecated. Use \"<TvmBuilder>.storeUint()\"");
-			}
 			break;
 		case FunctionType::Kind::TVMBuilderStoreInt:
-			if (memberName == "storeSigned") {
+			if (memberName == "storeSigned")
 				m_errorReporter.warning(9509_error, _functionCall.location(),
 										"\"<TvmBuilder>.storeSigned()\" is deprecated. Use \"<TvmBuilder>.storeInt()\"");
-			}
 			break;
-		case FunctionType::Kind::ByteToSlice: {
+		case FunctionType::Kind::ByteToSlice:
 			m_errorReporter.warning(9791_error, _functionCall.location(),
 									"\"<bytes>.toSlice()\" is deprecated. Use explicit conversion: \"TvmSlice(<bytes>)\"");
 			break;
-		}
-		case FunctionType::Kind::StringToSlice: {
+		case FunctionType::Kind::StringToSlice:
 			m_errorReporter.warning(6953_error, _functionCall.location(),
 									"\"<string>.toSlice()\" is deprecated. Use explicit conversion: \"TvmSlice(<string>)\"");
 			break;
-		}
+		case FunctionType::Kind::ABIStateInitHash:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(6336_error, _functionCall.location(),
+										"\"tvm.stateInitHash()\" is deprecated. Use: \"abi.stateInitHash()\"");
+			break;
+		case FunctionType::Kind::ABIEncodeStateInit:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(1078_error, _functionCall.location(),
+										"\"tvm.buildStateInit()\" is deprecated. Use: \"abi.encodeStateInit()\"");
+			break;
+		case FunctionType::Kind::ABIEncodeData:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(5638_error, _functionCall.location(),
+										"\"tvm.buildDataInit()\" is deprecated. Use: \"abi.encodeData()\"");
+			break;
+		case FunctionType::Kind::ABICodeSalt:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(9082_error, _functionCall.location(),
+										"\"tvm.codeSalt()\" is deprecated. Use: \"abi.codeSalt()\"");
+			break;
+		case FunctionType::Kind::ABISetCodeSalt:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(2638_error, _functionCall.location(),
+										"\"tvm.setCodeSalt()\" is deprecated. Use: \"abi.setCodeSalt()\"");
+			break;
+		case FunctionType::Kind::ABIFunctionId:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(4767_error, _functionCall.location(),
+										"\"tvm.functionId()\" is deprecated. Use: \"abi.functionId()\"");
+			break;
+		case FunctionType::Kind::ABIBuildExtMsg:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(9856_error, _functionCall.location(),
+										"\"tvm.buildExtMsg()\" is deprecated. Use: \"abi.encodeExtMsg()\"");
+			break;
+		case FunctionType::Kind::ABIBuildIntMsg:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(4063_error, _functionCall.location(),
+										"\"tvm.buildIntMsg()\" is deprecated. Use: \"abi.encodeIntMsg()\"");
+			break;
+		case FunctionType::Kind::ABIEncodeBody:
+			if (kind == MagicType::Kind::TVM)
+				m_errorReporter.warning(7329_error, _functionCall.location(),
+										"\"tvm.encodeBody()\" is deprecated. Use: \"abi.encodeBody()\"");
+			break;
+		case FunctionType::Kind::TVMSliceLoadTons:
+			m_errorReporter.warning(1085_error, _functionCall.location(),
+									"\"<TvmSlice>.loadTons()\" is deprecated. Use \"<TvmSlice>.load(coins)\"");
+			break;
+		case FunctionType::Kind::TVMBuilderStoreTons:
+			m_errorReporter.warning(7954_error, _functionCall.location(),
+									"\"<TvmBuilder>.storeTons()\" is deprecated. Use \"coins x = ...; <TvmBuilder>.store(x)\"");
+			break;
 		default:
 			break;
 		}
@@ -406,7 +458,7 @@ bool TVMTypeChecker::visit(FunctionCall const& _functionCall) {
 					ABITypeSize size{structType};
 					if (size.maxBits > 1023 || size.maxRefs > 4)
 						m_errorReporter.warning(
-							228_error, arg->location(),
+							3185_error, arg->location(),
 							"The structure may not fit to the builder."
 							" Store manually structure's members to several builders."
 						);
diff --git a/compiler/libsolidity/codegen/TVMTypeChecker.hpp b/compiler/libsolidity/codegen/TVMTypeChecker.hpp
index 0c37f2aa..07a23eb4 100644
--- a/compiler/libsolidity/codegen/TVMTypeChecker.hpp
+++ b/compiler/libsolidity/codegen/TVMTypeChecker.hpp
@@ -27,7 +27,7 @@ class TVMTypeChecker : public ASTConstVisitor {
 
 public:
 	bool visit(TryStatement const& _node) override;
-	bool visit(VariableDeclaration const& _node) override;
+	bool visit(VariableDeclaration const& _variable) override;
 	bool visit(Mapping const& _mapping) override;
 	bool visit(FunctionDefinition const& fc) override;
 	bool visit(ContractDefinition const& ) override;
diff --git a/compiler/libsolidity/codegen/TvmAst.cpp b/compiler/libsolidity/codegen/TvmAst.cpp
index ed62fb07..3aa57da5 100644
--- a/compiler/libsolidity/codegen/TvmAst.cpp
+++ b/compiler/libsolidity/codegen/TvmAst.cpp
@@ -158,7 +158,7 @@ bool HardCode::operator==(TvmAstNode const& _node) const {
 	return g && std::tie(m_code, m_take, m_ret) == std::tie(g->m_code, g->m_take, g->m_ret);
 }
 
-GenOpcode::GenOpcode(const std::string& opcode, int take, int ret, bool _isPure) : Gen{_isPure},  m_take{take}, m_ret{ret} {
+StackOpcode::StackOpcode(const std::string& opcode, int take, int ret, bool _isPure) : Gen{_isPure}, m_take{take}, m_ret{ret} {
 	vector<string> lines = split(opcode, ';');
 	solAssert(lines.size() <= 2, "");
 
@@ -173,11 +173,11 @@ GenOpcode::GenOpcode(const std::string& opcode, int take, int ret, bool _isPure)
 }
 
 
-void GenOpcode::accept(TvmAstVisitor& _visitor) {
+void StackOpcode::accept(TvmAstVisitor& _visitor) {
 	_visitor.visit(*this);
 }
 
-std::string GenOpcode::fullOpcode() const {
+std::string StackOpcode::fullOpcode() const {
 	std::string ret = m_opcode;
 	if (!m_arg.empty())
 		ret += " " + m_arg;
@@ -186,8 +186,8 @@ std::string GenOpcode::fullOpcode() const {
 	return ret;
 }
 
-bool GenOpcode::operator==(TvmAstNode const& _node) const {
-	auto gen = to<GenOpcode>(&_node);
+bool StackOpcode::operator==(TvmAstNode const& _node) const {
+	auto gen = to<StackOpcode>(&_node);
 	if (gen) {
 		if (
 			(isIn(fullOpcode(), "TRUE", "PUSHINT -1") && isIn(gen->fullOpcode(), "TRUE", "PUSHINT -1")) ||
@@ -462,7 +462,7 @@ void Contract::accept(TvmAstVisitor& _visitor) {
 }
 
 namespace solidity::frontend {
-Pointer<GenOpcode> gen(const std::string& cmd) {
+Pointer<StackOpcode> gen(const std::string& cmd) {
 	std::string op;
 	std::string param;
 	{
@@ -602,6 +602,7 @@ Pointer<GenOpcode> gen(const std::string& cmd) {
 		{"PLDU", {1, 1}},
 		{"PLDULE4", {1, 1}},
 		{"PLDULE8", {1, 1}},
+		{"POW2", {1, 1}},
 		{"RAND", {1, 1}},
 		{"SBITS", {1, 1, true}},
 		{"SDEMPTY", {1, 1, true}},
@@ -755,34 +756,34 @@ Pointer<GenOpcode> gen(const std::string& cmd) {
 		{"SPLIT", {3, 2}}
 	};
 
-	Pointer<GenOpcode> opcode;
+	Pointer<StackOpcode> opcode;
 	if (opcodes.count(op)) {
 		OpcodeParams params = opcodes.at(op);
-		opcode = createNode<GenOpcode>(cmd, params.take, params.ret, params.isPure);
+		opcode = createNode<StackOpcode>(cmd, params.take, params.ret, params.isPure);
 	} else if (dictSet()) {
-		opcode = createNode<GenOpcode>(cmd, 4, 1);
+		opcode = createNode<StackOpcode>(cmd, 4, 1);
 	} else if (dictReplaceOrAdd()) {
-		opcode = createNode<GenOpcode>(cmd, 4, 2);
+		opcode = createNode<StackOpcode>(cmd, 4, 2);
 	} else if (f("TUPLE")) {
 		int ret = boost::lexical_cast<int>(param);
-		opcode = createNode<GenOpcode>(cmd, ret, 1);
+		opcode = createNode<StackOpcode>(cmd, ret, 1);
 	} else if (f("UNTUPLE")) {
 		int ret = boost::lexical_cast<int>(param);
-		opcode = createNode<GenOpcode>(cmd, 1, ret);
+		opcode = createNode<StackOpcode>(cmd, 1, ret);
 	} else if (f("UNPACKFIRST")) {
 		int ret = boost::lexical_cast<int>(param);
-		opcode = createNode<GenOpcode>(cmd, 1, ret);
+		opcode = createNode<StackOpcode>(cmd, 1, ret);
 	} else if (f("LSHIFT") || f("RSHIFT")) {
 		if (param.empty()) {
-			opcode = createNode<GenOpcode>(cmd, 2, 1);
+			opcode = createNode<StackOpcode>(cmd, 2, 1);
 		} else {
-			opcode = createNode<GenOpcode>(cmd, 1, 1);
+			opcode = createNode<StackOpcode>(cmd, 1, 1);
 		}
 	} else if (f("MULRSHIFT")) {
 		if (param.empty()) {
-			opcode = createNode<GenOpcode>(cmd, 3, 1);
+			opcode = createNode<StackOpcode>(cmd, 3, 1);
 		} else {
-			opcode = createNode<GenOpcode>(cmd, 2, 1);
+			opcode = createNode<StackOpcode>(cmd, 2, 1);
 		}
 	} else {
 		solUnimplemented("Unknown opcode: " + cmd);
@@ -948,10 +949,10 @@ Pointer<PushCellOrSlice> makePUSHREF(const std::string& data) {
 	return createNode<PushCellOrSlice>(PushCellOrSlice::Type::PUSHREF, data, nullptr);
 }
 
-Pointer<Stack> makeREVERSE(int i, int j) {
-	solAssert(i >= 2, "");
-	solAssert(j >= 0, "");
-	return createNode<Stack>(Stack::Opcode::REVERSE, i, j);
+Pointer<Stack> makeREVERSE(int qty, int index) {
+	solAssert(qty >= 2, "");
+	solAssert(index >= 0, "");
+	return createNode<Stack>(Stack::Opcode::REVERSE, qty, index);
 }
 
 Pointer<Stack> makeROT() {
@@ -967,10 +968,6 @@ Pointer<Stack> makeBLKSWAP(int down, int top) {
 	return createNode<Stack>(Stack::Opcode::BLKSWAP, down, top);
 }
 
-Pointer<Stack> makeTUCK() {
-	return createNode<Stack>(Stack::Opcode::TUCK);
-}
-
 Pointer<Stack> makePUXC(int i, int j) {
 	solAssert(0 <= i && i <= 15, "");
 	solAssert(-1 <= j && j <= 14, "");
@@ -991,6 +988,7 @@ Pointer<TvmIfElse> flipIfElse(TvmIfElse const& node) {
 }
 
 bool isPureGen01(TvmAstNode const& node) {
+	// See also isSimpleCommand
 	auto gen = to<Gen>(&node);
 	return gen && gen->isPure() && gen->take() == 0 && gen->ret() == 1;
 }
@@ -1055,18 +1053,34 @@ std::optional<int> isPOP(Pointer<TvmAstNode> const& node) {
 	return {};
 }
 
+std::optional<int> isPUSH(Pointer<TvmAstNode> const& node) {
+	if (auto stack = to<Stack>(node.get())) {
+		switch (stack->opcode()) {
+		case Stack::Opcode::PUSH_S:
+			return stack->i();
+		case Stack::Opcode::BLKPUSH:
+			if (stack->i() == 1)
+				return stack->j();
+			break;
+		default:
+			break;
+		}
+	}
+	return {};
+}
+
 std::optional<std::pair<int, int>> isBLKPUSH(Pointer<TvmAstNode> const& node) {
-	auto stack = to<Stack>(node.get());
-	if (stack) {
+	if (auto stack = to<Stack>(node.get())) {
 		switch (stack->opcode()) {
-			case Stack::Opcode::BLKPUSH:
-				return {{stack->i(), stack->j()}};
-			case Stack::Opcode::PUSH_S:
-				if (stack->i() == 0)
-					return {{1, 0}};
-				break;
-			default:
-				break;
+		case Stack::Opcode::BLKPUSH:
+			return {{stack->i(), stack->j()}};
+		case Stack::Opcode::PUSH_S:
+			if (stack->i() == 0)
+				return {{1, 0}};
+			break;
+		// TODO add PUSH_S and PUSH2_S
+		default:
+			break;
 		}
 	}
 	return {};
@@ -1154,4 +1168,89 @@ Pointer<AsymGen> getZeroOrNullAlignment(bool isZero, bool isSwap, bool isNot) {
 	return std::make_shared<AsymGen>(cmd);
 }
 
+int OpcodeUtils::gasCost(Stack const& opcode) {
+	int i = opcode.i();
+	int j = opcode.j();
+	//int k = opcode.k();
+	switch (opcode.opcode()) {
+	case Stack::Opcode::POP_S:
+		return 18;
+	case Stack::Opcode::DROP: {
+		int n = i;
+		if (n == 1 || n == 2)
+			return 18; // "DROP" "DROP2"
+		if (n <= 15)
+			return 26; // BLKDROP
+		return 18 + 18; // PUSHINT N + DROPX
+	}
+	case Stack::Opcode::BLKDROP2: {
+		if (i > 15 || j > 15)
+			solUnimplemented("");
+		return 26;
+	}
+	case Stack::Opcode::BLKSWAP: {
+		int bottom = i;
+		int top = j;
+		if (bottom == 1 && top == 1) {
+			return 18; // SWAP
+		} else if (bottom == 1 && top == 2) {
+			return 18; // "ROT";
+		} else if (bottom == 2 && top == 1) {
+			return 18; // "ROTREV";
+		} else if (bottom == 2 && top == 2) {
+			return 18; // "SWAP2";
+		} else if (1 <= bottom && bottom <= 16 && 1 <= top && top <= 16) {
+			return 26; // "ROLL " "ROLLREV " "BLKSWAP"
+		} else {
+			solUnimplemented(""); // "ROLLX" "ROLLREVX" "BLKSWX"
+		}
+	}
+	case Stack::Opcode::BLKPUSH: {
+		if ((i == 2 && j == 1) || (i == 2 && j == 3)) {
+			return 18; // "DUP2" "OVER2"
+		} else {
+			if (i > 15)
+				solAssert(j == 0, "");
+			int rest = i;
+			int cost = 0;
+			while (rest > 0) {
+				cost += 26; // "BLKPUSH "
+				rest -= 15;
+			}
+			return cost;
+		}
+	}
+	case Stack::Opcode::PUSH2_S:
+		if ((i == 1 && j == 0) || (i == 3 && j == 2))
+			return 18; // "DUP2" "OVER2"
+		return 26; // "PUSH2"
+	case Stack::Opcode::REVERSE:
+		if ((i == 2 && j == 0) || (i == 3 && j == 0))
+			return 18; // "SWAP" "XCHG S2"
+		else if (2 <= i && i <= 17 && 0 <= j && j <= 15)
+			return 26; // "REVERSE"
+		solUnimplemented("");
+	case Stack::Opcode::XCHG:
+		if (i == 0 || i == 1)
+			return 18; // "XCHG Sj" "XCHG s1, Sj"
+		return 26; // XCHG Si, Sj
+	case Stack::Opcode::PUSH_S:
+		return 18;
+	case Stack::Opcode::XCHG3:
+	case Stack::Opcode::XCHG2:
+	case Stack::Opcode::XCPU:
+	case Stack::Opcode::PUXC:
+		return 26;
+	case Stack::Opcode::PUSH3_S:
+	case Stack::Opcode::XC2PU:
+	case Stack::Opcode::XCPU2:
+	case Stack::Opcode::PUXC2:
+	case Stack::Opcode::XCPUXC:
+	case Stack::Opcode::PUXCPU:
+	case Stack::Opcode::PU2XC:
+		return 34;
+	}
+	solUnimplemented("");
+}
+
 } // end solidity::frontend
diff --git a/compiler/libsolidity/codegen/TvmAst.hpp b/compiler/libsolidity/codegen/TvmAst.hpp
index 67142a62..96395d9a 100644
--- a/compiler/libsolidity/codegen/TvmAst.hpp
+++ b/compiler/libsolidity/codegen/TvmAst.hpp
@@ -74,9 +74,17 @@ class Stack : public TvmAstNode {
 		REVERSE, //  REVERSE 2, 0  |  REVERSE 3, 0
 		XCHG,    //  XCHG S0 S1    |  XCHG S0 S2,
 
-		TUCK,
+		//  Compound stack manipulation primitives
+		XCHG3,
+		XCHG2,
+		XCPU,  //XCPU s1,s1 == TUCK
 		PUXC,
-		XCPU,
+		XC2PU,
+		XCPU2,
+		PUXC2,
+		XCPUXC,
+		PUXCPU,
+		PU2XC
 	};
 	explicit Stack(Opcode opcode, int i = -1, int j = -1, int k = -1);
 	void accept(TvmAstVisitor& _visitor) override;
@@ -178,9 +186,9 @@ class HardCode : public Gen {
 	int m_ret{};
 };
 
-class GenOpcode : public Gen {
+class StackOpcode : public Gen {
 public:
-	explicit GenOpcode(const std::string& opcode, int take, int ret, bool _isPure = false);
+	explicit StackOpcode(const std::string& opcode, int take, int ret, bool _isPure = false);
 	void accept(TvmAstVisitor& _visitor) override;
 	std::string fullOpcode() const;
 	std::string const &opcode() const { return m_opcode; }
@@ -261,7 +269,7 @@ class PushCellOrSlice : public Gen {
 		PUSHREFSLICE_COMPUTE,
 		PUSHREF,
 		PUSHREFSLICE,
-		CELL,
+		CELL, // TODO DELETE
 		PUSHSLICE
 	};
 	PushCellOrSlice(Type type, std::string blob, Pointer<PushCellOrSlice> child) :
@@ -519,7 +527,7 @@ class Contract : public TvmAstNode {
 	std::map<uint32_t, std::string> m_privateFunctions;
 };
 
-Pointer<GenOpcode> gen(const std::string& cmd);
+Pointer<StackOpcode> gen(const std::string& cmd);
 Pointer<PushCellOrSlice> genPushSlice(const std::string& _str);
 Pointer<PushCellOrSlice> makePushCellOrSlice(std::string const& hexStr, bool toSlice);
 Pointer<Stack> makeDROP(int cnt = 1);
@@ -541,11 +549,10 @@ Pointer<Glob> makeGetGlob(int i);
 Pointer<Glob> makeSetGlob(int i);
 Pointer<Stack> makeBLKDROP2(int droppedCount, int leftCount);
 Pointer<PushCellOrSlice> makePUSHREF(const std::string& data = "");
-Pointer<Stack> makeREVERSE(int i, int j);
+Pointer<Stack> makeREVERSE(int qty, int index);
 Pointer<Stack> makeROT();
 Pointer<Stack> makeROTREV();
 Pointer<Stack> makeBLKSWAP(int down, int top);
-Pointer<Stack> makeTUCK();
 Pointer<Stack> makePUXC(int i, int j);
 Pointer<Stack> makeXCPU(int i, int j);
 Pointer<TvmIfElse> flipIfElse(TvmIfElse const& node);
@@ -555,6 +562,7 @@ bool isSWAP(Pointer<TvmAstNode> const& node);
 std::optional<std::pair<int, int>> isBLKSWAP(Pointer<TvmAstNode> const& node);
 std::optional<int> isDrop(Pointer<TvmAstNode> const& node);
 std::optional<int> isPOP(Pointer<TvmAstNode> const& node);
+std::optional<int> isPUSH(Pointer<TvmAstNode> const& node);
 std::optional<std::pair<int, int>> isBLKPUSH(Pointer<TvmAstNode> const& node);
 bool isXCHG(Pointer<TvmAstNode> const& node, int i, int j);
 std::optional<int> isXCHG_S0(Pointer<TvmAstNode> const& node);
@@ -565,4 +573,8 @@ int getRootBitSize(PushCellOrSlice const &_node);
 
 Pointer<AsymGen> getZeroOrNullAlignment(bool isZero, bool isSwap, bool isNot);
 
+namespace OpcodeUtils{
+	int gasCost(Stack const& opcode);
+}
+
 }	// end solidity::frontend
diff --git a/compiler/libsolidity/codegen/TvmAstVisitor.cpp b/compiler/libsolidity/codegen/TvmAstVisitor.cpp
index 544edcf0..b122369d 100644
--- a/compiler/libsolidity/codegen/TvmAstVisitor.cpp
+++ b/compiler/libsolidity/codegen/TvmAstVisitor.cpp
@@ -20,7 +20,6 @@
 #include <libsolidity/codegen/TvmAstVisitor.hpp>
 #include <liblangutil/Exceptions.h>
 #include "TVMCommons.hpp"
-#include "TVMABI.hpp"
 
 using namespace solidity::frontend;
 
@@ -70,7 +69,7 @@ bool Printer::visit(TvmReturn &_node) {
 	if (_node.withAlt()) {
 		m_out << "ALT";
 	}
-	endL();
+	m_out << std::endl;
 	return false;
 }
 
@@ -92,9 +91,11 @@ bool Printer::visit(TvmException &_node) {
 	return false;
 }
 
-bool Printer::visit(GenOpcode &_node) {
+bool Printer::visit(StackOpcode &_node) {
 	tabs();
 	if (_node.fullOpcode() == "BITNOT") m_out << "NOT";
+	//else if (_node.fullOpcode() == "STVARUINT16") m_out << "STGRAMS";
+	//else if (_node.fullOpcode() == "LDVARUINT16") m_out << "LDGRAMS";
 	else if (_node.fullOpcode() == "TUPLE 1") m_out << "SINGLE";
 	else if (_node.fullOpcode() == "TUPLE 2") m_out << "PAIR";
 	else if (_node.fullOpcode() == "TUPLE 3") m_out << "TRIPLE";
@@ -106,8 +107,7 @@ bool Printer::visit(GenOpcode &_node) {
 		if (ret <= 15) {
 			m_out << "UNTUPLE " << ret;
 		} else {
-			m_out << "PUSHINT " << ret;
-			endL();
+			m_out << "PUSHINT " << ret << std::endl;
 			tabs();
 			m_out << "UNTUPLEVAR";
 		}
@@ -116,8 +116,7 @@ bool Printer::visit(GenOpcode &_node) {
 		if (ret <= 15) {
 			m_out << "UNPACKFIRST " << ret;
 		} else {
-			m_out << "PUSHINT " << ret;
-			endL();
+			m_out << "PUSHINT " << ret << std::endl;
 			tabs();
 			m_out << "UNPACKFIRSTVAR";
 		}
@@ -178,10 +177,10 @@ bool Printer::visit(PushCellOrSlice &_node) {
 			m_out << ".cell {";
 			break;
 	}
-	endL();
+	m_out << std::endl;
 
 	++m_tab;
-	if (!_node.blob().empty()) {
+	if (!_node.blob().empty() && _node.blob() != "x") {
 		tabs();
 		m_out << ".blob " << _node.blob() << std::endl;
 	}
@@ -237,7 +236,7 @@ bool Printer::visit(Glob &_node) {
 			m_out << "POP C7";
 			break;
 	}
-	endL();
+	m_out << std::endl;
 	return false;
 }
 
@@ -281,181 +280,203 @@ bool Printer::visit(Stack &_node) {
 	};
 
 	switch (_node.opcode()) {
-		case Stack::Opcode::DROP: {
-			drop(i);
-			break;
+	case Stack::Opcode::DROP: {
+		drop(i);
+		break;
+	}
+	case Stack::Opcode::PUSH_S:
+		solAssert(j == -1, "");
+		if (i == 0) {
+			m_out << "DUP";
+		} else if (i == 1) {
+			m_out << "OVER";
+		} else {
+			m_out << "PUSH S" << i;
 		}
-		case Stack::Opcode::PUSH_S:
-			solAssert(j == -1, "");
-			if (i == 0) {
-				m_out << "DUP";
-			} else if (i == 1) {
-				m_out << "OVER";
+		break;
+	case Stack::Opcode::XCHG: {
+		if (i == 0) {
+			if (j == 1) {
+				m_out << "SWAP";
 			} else {
-				m_out << "PUSH S" << i;
+				m_out << "XCHG S" << j;
 			}
-			break;
-		case Stack::Opcode::XCHG: {
-			if (i == 0) {
-				if (j == 1) {
-					m_out << "SWAP";
-				} else {
-					m_out << "XCHG S" << j;
-				}
+		} else {
+			m_out << "XCHG S" << i << ", S" << j;
+		}
+		break;
+	}
+	case Stack::Opcode::BLKDROP2:
+		if (i > 15 || j > 15) {
+			printPushInt(i);
+			m_out << std::endl;
+			tabs();
+			printPushInt(j);
+			m_out << std::endl;
+			tabs();
+			m_out << "BLKSWX" << std::endl;
+			tabs();
+			drop(i);
+		} else {
+			solAssert((i >= 2 && j >= 1) || (i >= 1 && j >= 2), "");
+			m_out << "BLKDROP2";
+			printIndexes();
+		}
+		break;
+	case Stack::Opcode::PUSH2_S:
+		if (i == 1 && j == 0)
+			m_out << "DUP2";
+		else if (i == 3 && j == 2)
+			m_out << "OVER2";
+		else {
+			m_out << "PUSH2";
+			printSS();
+		}
+		break;
+	case Stack::Opcode::POP_S:
+		if (i == 1) {
+			m_out << "NIP";
+		} else {
+			m_out << "POP";
+			printSS();
+		}
+		break;
+	case Stack::Opcode::BLKSWAP: {
+		int bottom = _node.i();
+		int top = _node.j();
+		if (bottom == 1 && top == 1) {
+			m_out << "SWAP";
+		} else if (bottom == 1 && top == 2) {
+			m_out << "ROT";
+		} else if (bottom == 2 && top == 1) {
+			m_out << "ROTREV";
+		} else if (bottom == 2 && top == 2) {
+			m_out << "SWAP2";
+		} else if (1 <= bottom && bottom <= 16 && 1 <= top && top <= 16) {
+			if (bottom == 1) {
+				m_out << "ROLL " << top;
+			} else if (top == 1) {
+				m_out << "ROLLREV " << bottom;
 			} else {
-				m_out << "XCHG S" << i << ", S" << j;
+				m_out << "BLKSWAP";
+				printIndexes();
 			}
-			break;
-		}
-		case Stack::Opcode::BLKDROP2:
-			if (i > 15 || j > 15) {
-				printPushInt(i);
+		} else {
+			if (bottom == 1) {
+				printPushInt(top);
 				m_out << std::endl;
 				tabs();
-				printPushInt(j);
+				m_out << "ROLLX";
+			} else if (top == 1) {
+				printPushInt(bottom);
 				m_out << std::endl;
 				tabs();
-				m_out << "BLKSWX" << std::endl;
-				tabs();
-				drop(i);
-			} else {
-				solAssert((i >= 2 && j >= 1) || (i >= 1 && j >= 2), "");
-				m_out << "BLKDROP2";
-				printIndexes();
-			}
-			break;
-		case Stack::Opcode::PUSH2_S:
-			if (i == 1 && j == 0)
-				m_out << "DUP2";
-			else if (i == 3 && j == 2)
-				m_out << "OVER2";
-			else {
-				m_out << "PUSH2";
-				printSS();
-			}
-			break;
-		case Stack::Opcode::POP_S:
-			if (i == 1) {
-				m_out << "NIP";
-			} else {
-				m_out << "POP";
-				printSS();
-			}
-			break;
-		case Stack::Opcode::BLKSWAP: {
-			int bottom = _node.i();
-			int top = _node.j();
-			if (bottom == 1 && top == 1) {
-				m_out << "SWAP";
-			} else if (bottom == 1 && top == 2) {
-				m_out << "ROT";
-			} else if (bottom == 2 && top == 1) {
-				m_out << "ROTREV";
-			} else if (bottom == 2 && top == 2) {
-				m_out << "SWAP2";
-			} else if (1 <= bottom && bottom <= 16 && 1 <= top && top <= 16) {
-				if (bottom == 1) {
-					m_out << "ROLL " << top;
-				} else if (top == 1) {
-					m_out << "ROLLREV " << bottom;
-				} else {
-					m_out << "BLKSWAP";
-					printIndexes();
-				}
+				m_out << "ROLLREVX";
 			} else {
-				if (bottom == 1) {
-					printPushInt(top);
-					m_out << std::endl;
-					tabs();
-					m_out << "ROLLX";
-				} else if (top == 1) {
-					printPushInt(bottom);
-					m_out << std::endl;
-					tabs();
-					m_out << "ROLLREVX";
-				} else {
-					printPushInt(bottom);
-					m_out << std::endl;
-					tabs();
-					printPushInt(top);
-					m_out << std::endl;
-					tabs();
-					m_out << "BLKSWX";
-				}
-			}
-			break;
-		}
-		case Stack::Opcode::REVERSE:
-			solAssert(2 <= i, "");
-			if (i == 2 && j == 0) {
-				m_out << "SWAP";
-			} else if (i == 3 && j == 0) {
-				m_out << "XCHG S2";
-			} else if (2 <= i && i <= 17 && 0 <= j && j <= 15) {
-				m_out << "REVERSE";
-				printIndexes();
-			} else {
-				printPushInt(i);
+				printPushInt(bottom);
 				m_out << std::endl;
 				tabs();
-				printPushInt(j);
+				printPushInt(top);
 				m_out << std::endl;
 				tabs();
-				m_out << "REVX";
+				m_out << "BLKSWX";
 			}
-			break;
-		case Stack::Opcode::BLKPUSH:
-			if (i == 2 && j == 1) {
-				m_out << "DUP2";
-			} else if (i == 2 && j == 3) {
-				m_out << "OVER2";
-			} else {
-				if (i > 15)
-					solAssert(j == 0, "");
-				int rest = i;
-				bool first = true;
-				while (rest > 0) {
-					if (!first) {
-						m_out << std::endl;
-						tabs();
-					}
-					m_out << "BLKPUSH " << std::min(15, rest) << ", " << j;
-
-					rest -= 15;
-					first = false;
+		}
+		break;
+	}
+	case Stack::Opcode::REVERSE:
+		solAssert(2 <= i, "");
+		if (i == 2 && j == 0) {
+			m_out << "SWAP";
+		} else if (i == 3 && j == 0) {
+			m_out << "XCHG S2";
+		} else if (2 <= i && i <= 17 && 0 <= j && j <= 15) {
+			m_out << "REVERSE";
+			printIndexes();
+		} else {
+			printPushInt(i);
+			m_out << std::endl;
+			tabs();
+			printPushInt(j);
+			m_out << std::endl;
+			tabs();
+			m_out << "REVX";
+		}
+		break;
+	case Stack::Opcode::BLKPUSH:
+		if (i == 2 && j == 1) {
+			m_out << "DUP2";
+		} else if (i == 2 && j == 3) {
+			m_out << "OVER2";
+		} else {
+			if (i > 15)
+				solAssert(j == 0, "");
+			int rest = i;
+			bool first = true;
+			while (rest > 0) {
+				if (!first) {
+					m_out << std::endl;
+					tabs();
 				}
-			}
-			break;
-		case Stack::Opcode::PUSH3_S:
-			m_out << "PUSH3";
-			printSS();
-			break;
+				m_out << "BLKPUSH " << std::min(15, rest) << ", " << j;
 
-		case Stack::Opcode::TUCK:
+				rest -= 15;
+				first = false;
+			}
+		}
+		break;
+	case Stack::Opcode::PUSH3_S:
+		m_out << "PUSH3";
+		printSS();
+		break;
+	case Stack::Opcode::PUXC:
+		m_out << "PUXC S" << i << ", S" << j;
+		break;
+	case Stack::Opcode::XCPU:
+		if (i == 1 && j == 1)
 			m_out << "TUCK";
-			break;
-
-		case Stack::Opcode::PUXC:
-			m_out << "PUXC S" << i << ", S" << j;
-			break;
-
-		case Stack::Opcode::XCPU:
+		else
 			m_out << "XCPU S" << i << ", S" << j;
-			break;
+		break;
+	case Stack::Opcode::XC2PU:
+		m_out << "XC2PU S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::XCHG2:
+		m_out << "XCHG2 S" << i << ", S" << j;
+		break;
+	case Stack::Opcode::XCHG3:
+		m_out << "XCHG3 S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::XCPU2:
+		m_out << "XCPU2 S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::PUXC2:
+		m_out << "PUXC2 S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::PUXCPU:
+		m_out << "PUXCPU S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::XCPUXC:
+		m_out << "XCPUXC S" << i << ", S" << j << ", S" << k;
+		break;
+	case Stack::Opcode::PU2XC:
+		m_out << "PU2XC S" << i << ", S" << j << ", S" << k;
+		break;
 	}
-	endL();
+
+	m_out << std::endl;
 	return false;
 }
 
 bool Printer::visit(CodeBlock &_node) {
 	switch (_node.type()) {
-		case CodeBlock::Type::None:
-			break;
-		default:
-			tabs();
-			m_out << CodeBlock::toString(_node.type()) << " {" << std::endl;
-			++m_tab;
-			break;
+	case CodeBlock::Type::None:
+		break;
+	default:
+		tabs();
+		m_out << CodeBlock::toString(_node.type()) << " {" << std::endl;
+		++m_tab;
+		break;
 	}
 
 	for (Pointer<TvmAstNode> const& inst : _node.instructions()) {
@@ -477,38 +498,38 @@ bool Printer::visit(CodeBlock &_node) {
 
 bool Printer::visit(SubProgram &_node) {
 	switch (_node.block()->type()) {
-		case CodeBlock::Type::None:
-			solUnimplemented("");
-		case CodeBlock::Type::PUSHCONT:
-			_node.block()->accept(*this);
+	case CodeBlock::Type::None:
+		solUnimplemented("");
+	case CodeBlock::Type::PUSHCONT:
+		_node.block()->accept(*this);
 
-			tabs();
-			if (_node.isJmp()) {
-				m_out << "JMPX";
-			} else {
-				m_out << "CALLX";
-			}
-			endL();
+		tabs();
+		if (_node.isJmp()) {
+			m_out << "JMPX";
+		} else {
+			m_out << "CALLX";
+		}
+		m_out << std::endl;
 
-			break;
-		case CodeBlock::Type::PUSHREFCONT:
-			tabs();
-			if (_node.isJmp()) {
-				m_out << "JMPREF {";
-			} else {
-				m_out << "CALLREF {";
-			}
-			endL();
+		break;
+	case CodeBlock::Type::PUSHREFCONT:
+		tabs();
+		if (_node.isJmp()) {
+			m_out << "JMPREF {";
+		} else {
+			m_out << "CALLREF {";
+		}
+		m_out << std::endl;
 
-			++m_tab;
-			for (Pointer<TvmAstNode> const& i : _node.block()->instructions()) {
-				i->accept(*this);
-			}
-			--m_tab;
+		++m_tab;
+		for (Pointer<TvmAstNode> const& i : _node.block()->instructions()) {
+			i->accept(*this);
+		}
+		--m_tab;
 
-			tabs();
-			m_out << "}" << std::endl;
-			break;
+		tabs();
+		m_out << "}" << std::endl;
+		break;
 	}
 	return false;
 }
@@ -540,73 +561,79 @@ bool Printer::visit(LogCircuit &_node) {
 
 bool Printer::visit(TvmIfElse &_node) {
 	if (_node.falseBody() == nullptr) {
-		switch (_node.trueBody()->type()) {
-			case CodeBlock::Type::None:
-				solUnimplemented("");
-				break;
-			case CodeBlock::Type::PUSHCONT:
-				_node.trueBody()->accept(*this);
+	switch (_node.trueBody()->type()) {
+		case CodeBlock::Type::None:
+			solUnimplemented("");
+			break;
+		case CodeBlock::Type::PUSHCONT:
+			_node.trueBody()->accept(*this);
 
-				tabs();
-				m_out << "IF";
-				if (_node.withNot())
-					m_out << "NOT";
-				if (_node.withJmp())
-					m_out << "JMP";
-				endL();
-
-				break;
-			case CodeBlock::Type::PUSHREFCONT:
-				tabs();
-				m_out << "IF";
-				if (_node.withNot())
-					m_out << "NOT";
-				if (_node.withJmp())
-					m_out << "JMP";
-				m_out << "REF {";
-				endL();
+			tabs();
+			m_out << "IF";
+			if (_node.withNot())
+				m_out << "NOT";
+			if (_node.withJmp())
+				m_out << "JMP";
+			m_out << std::endl;
 
-				++m_tab;
-				for (Pointer<TvmAstNode> const& i : _node.trueBody()->instructions()) {
-					i->accept(*this);
-				}
-				--m_tab;
+			break;
+		case CodeBlock::Type::PUSHREFCONT:
+			tabs();
+			m_out << "IF";
+			if (_node.withNot())
+				m_out << "NOT";
+			if (_node.withJmp())
+				m_out << "JMP";
+			m_out << "REF {" << std::endl;
 
-				tabs();
-				m_out << "}" << std::endl;
-				break;
+			++m_tab;
+			for (Pointer<TvmAstNode> const& i : _node.trueBody()->instructions()) {
+				i->accept(*this);
+			}
+			--m_tab;
+
+			tabs();
+			m_out << "}" << std::endl;
+			break;
 		}
 	} else {
 		if (_node.trueBody()->type() == CodeBlock::Type::PUSHREFCONT &&
 			_node.falseBody()->type() == CodeBlock::Type::PUSHREFCONT
 		) {
+			tabs();
 			m_out << "IFREFELSEREF" << std::endl;
 			for (Pointer<CodeBlock> const& body : {_node.trueBody(), _node.falseBody()}) {
+				tabs();
 				m_out << "{" << std::endl;
 				++m_tab;
 				for (Pointer<TvmAstNode> const &n: body->instructions()) {
 					n->accept(*this);
 				}
 				--m_tab;
+				tabs();
 				m_out << "}" << std::endl;
 			}
 		} else  if (_node.trueBody()->type() == CodeBlock::Type::PUSHREFCONT) {
 			_node.falseBody()->accept(*this);
+			tabs();
 			m_out << "IFREFELSE {" << std::endl;
 			++m_tab;
 			for (Pointer<TvmAstNode> const& n : _node.trueBody()->instructions()) {
 				n->accept(*this);
 			}
 			--m_tab;
+			tabs();
 			m_out << "}" << std::endl;
 		} else  if (_node.falseBody()->type() == CodeBlock::Type::PUSHREFCONT) {
 			_node.trueBody()->accept(*this);
+			tabs();
 			m_out << "IFELSEREF {" << std::endl;
 			++m_tab;
 			for (Pointer<TvmAstNode> const& n : _node.falseBody()->instructions()) {
 				n->accept(*this);
 			}
 			--m_tab;
+			tabs();
 			m_out << "}" << std::endl;
 		} else {
 			_node.trueBody()->accept(*this);
@@ -615,8 +642,7 @@ bool Printer::visit(TvmIfElse &_node) {
 				solUnimplemented("");
 
 			tabs();
-			m_out << "IFELSE";
-			endL();
+			m_out << "IFELSE" << std::endl;
 		}
 	}
 	return false;
@@ -703,17 +729,6 @@ bool Printer::visit(Contract &_node) {
 			m_out << std::endl;
 		}
 
-		m_out << ".fragment default_data_dict_cell, {" << std::endl;
-		m_out << "	PUSHINT 0" << std::endl;
-		m_out << "	NEWC" << std::endl;
-		m_out << "	STU 256" << std::endl;
-		m_out << "	PUSHINT 0" << std::endl;
-		m_out << "	NEWDICT" << std::endl;
-		m_out << "	PUSHINT 64" << std::endl;
-		m_out << "	DICTUSETB" << std::endl;
-		m_out << "}" << std::endl;
-		m_out << std::endl;
-
 		m_out << "; The code below forms a value of the StateInit type." << std::endl;
 		m_out << ".blob x4_ ; split_depth = nothing" << std::endl;
 		m_out << ".blob x4_ ; special = nothing" << std::endl;
@@ -786,10 +801,7 @@ bool Printer::visit(Contract &_node) {
 
 		m_out << ".blob xc_ ; data = just" << std::endl;
 		m_out << ".cell { " << std::endl;
-		m_out << "	.blob xc_" << std::endl;
-		m_out << "	.cell { " << std::endl;
-		m_out << "		.inline-computed-cell default_data_dict_cell, 0" << std::endl;
-		m_out << "	}" << std::endl;
+		m_out << "	.inline-computed-cell default_data_cell, 0" << std::endl;
 		m_out << "}" << std::endl;
 		m_out << ".blob x4_ ; library = hme_empty" << std::endl;
 	}
@@ -811,10 +823,6 @@ bool Printer::visitNode(TvmAstNode const&) {
 	solUnimplemented("");
 }
 
-void Printer::endL() {
-	m_out << std::endl;
-}
-
 void Printer::tabs() {
 	solAssert(m_tab >= 0, "");
 	m_out << std::string(m_tab, '\t');
@@ -1003,9 +1011,8 @@ bool LogCircuitExpander::isPureOperation(Pointer<TvmAstNode> const& op) {
 		return true;
 	}
 
-	auto stack = to<Stack>(op.get());
-	if (stack && stack->opcode() == Stack::Opcode::PUSH_S) {
-		int index = stack->i();
+	if (auto push = isPUSH(op)) {
+		int index = *push;
 		if (index + 1 < m_stackSize) {
 			m_newInst.emplace_back(makePUSH(index));
 		} else {
diff --git a/compiler/libsolidity/codegen/TvmAstVisitor.hpp b/compiler/libsolidity/codegen/TvmAstVisitor.hpp
index faeb362f..992d4672 100644
--- a/compiler/libsolidity/codegen/TvmAstVisitor.hpp
+++ b/compiler/libsolidity/codegen/TvmAstVisitor.hpp
@@ -37,7 +37,7 @@ class TvmAstVisitor {
 	virtual bool visit(TvmReturn &_node) { return visitNode(_node); }
 	virtual bool visit(ReturnOrBreakOrCont &_node) { return visitNode(_node); }
 	virtual bool visit(TvmException &_node) { return visitNode(_node); }
-	virtual bool visit(GenOpcode &_node) { return visitNode(_node); }
+	virtual bool visit(StackOpcode &_node) { return visitNode(_node); }
 	virtual bool visit(PushCellOrSlice &_node) { return visitNode(_node); }
 	virtual bool visit(Glob &_node) { return visitNode(_node); }
 	virtual bool visit(Stack &_node) { return visitNode(_node); }
@@ -69,7 +69,7 @@ class Printer : public TvmAstVisitor {
 	bool visit(TvmReturn &_node) override;
 	bool visit(ReturnOrBreakOrCont &_node) override;
 	bool visit(TvmException &_node) override;
-	bool visit(GenOpcode &_node) override;
+	bool visit(StackOpcode &_node) override;
 	bool visit(PushCellOrSlice &_node) override;
 	bool visit(Glob &_node) override;
 	bool visit(Stack &_node) override;
@@ -86,7 +86,6 @@ class Printer : public TvmAstVisitor {
 protected:
 	bool visitNode(TvmAstNode const&) override;
 private:
-	void endL();
 	void tabs();
 	void printPushInt(std::string const& arg, std::string const& comment = "");
 	void printPushInt(int i);
diff --git a/compiler/libsolidity/experimental/analysis/Analysis.cpp b/compiler/libsolidity/experimental/analysis/Analysis.cpp
new file mode 100644
index 00000000..44170067
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/Analysis.cpp
@@ -0,0 +1,204 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/DebugWarner.h>
+#include <libsolidity/experimental/analysis/FunctionDependencyAnalysis.h>
+#include <libsolidity/experimental/analysis/SyntaxRestrictor.h>
+#include <libsolidity/experimental/analysis/TypeClassRegistration.h>
+#include <libsolidity/experimental/analysis/TypeInference.h>
+#include <libsolidity/experimental/analysis/TypeRegistration.h>
+
+using namespace solidity::langutil;
+using namespace solidity::frontend::experimental;
+
+// TODO: creating all of them for all nodes up front may be wasteful, we should improve the mechanism.
+struct Analysis::AnnotationContainer
+{
+	TypeClassRegistration::Annotation typeClassRegistrationAnnotation;
+	TypeRegistration::Annotation typeRegistrationAnnotation;
+	TypeInference::Annotation typeInferenceAnnotation;
+};
+
+struct Analysis::GlobalAnnotationContainer
+{
+	FunctionDependencyAnalysis::GlobalAnnotation functionDependencyGraphAnnotation;
+	TypeClassRegistration::GlobalAnnotation typeClassRegistrationAnnotation;
+	TypeRegistration::GlobalAnnotation typeRegistrationAnnotation;
+	TypeInference::GlobalAnnotation typeInferenceAnnotation;
+};
+
+template<>
+TypeClassRegistration::Annotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeClassRegistration>::get(ASTNode const& _node)
+{
+	return analysis.annotationContainer(_node).typeClassRegistrationAnnotation;
+}
+
+template<>
+TypeClassRegistration::GlobalAnnotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeClassRegistration>::get() const
+{
+	return analysis.annotationContainer().typeClassRegistrationAnnotation;
+}
+
+template<>
+TypeClassRegistration::GlobalAnnotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeClassRegistration>::get()
+{
+	return analysis.annotationContainer().typeClassRegistrationAnnotation;
+}
+
+template<>
+TypeClassRegistration::Annotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeClassRegistration>::get(ASTNode const& _node) const
+{
+	return analysis.annotationContainer(_node).typeClassRegistrationAnnotation;
+}
+
+template<>
+FunctionDependencyAnalysis::GlobalAnnotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<FunctionDependencyAnalysis>::get() const
+{
+	return analysis.annotationContainer().functionDependencyGraphAnnotation;
+}
+
+template<>
+FunctionDependencyAnalysis::GlobalAnnotation& solidity::frontend::experimental::detail::AnnotationFetcher<FunctionDependencyAnalysis>::get()
+{
+	return analysis.annotationContainer().functionDependencyGraphAnnotation;
+}
+
+template<>
+TypeRegistration::Annotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeRegistration>::get(ASTNode const& _node)
+{
+	return analysis.annotationContainer(_node).typeRegistrationAnnotation;
+}
+
+template<>
+TypeRegistration::GlobalAnnotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeRegistration>::get() const
+{
+	return analysis.annotationContainer().typeRegistrationAnnotation;
+}
+
+template<>
+TypeRegistration::GlobalAnnotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeRegistration>::get()
+{
+	return analysis.annotationContainer().typeRegistrationAnnotation;
+}
+
+template<>
+TypeRegistration::Annotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeRegistration>::get(ASTNode const& _node) const
+{
+	return analysis.annotationContainer(_node).typeRegistrationAnnotation;
+}
+
+template<>
+TypeInference::Annotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeInference>::get(ASTNode const& _node)
+{
+	return analysis.annotationContainer(_node).typeInferenceAnnotation;
+}
+
+template<>
+TypeInference::Annotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeInference>::get(ASTNode const& _node) const
+{
+	return analysis.annotationContainer(_node).typeInferenceAnnotation;
+}
+
+template<>
+TypeInference::GlobalAnnotation const& solidity::frontend::experimental::detail::ConstAnnotationFetcher<TypeInference>::get() const
+{
+	return analysis.annotationContainer().typeInferenceAnnotation;
+}
+
+template<>
+TypeInference::GlobalAnnotation& solidity::frontend::experimental::detail::AnnotationFetcher<TypeInference>::get()
+{
+	return analysis.annotationContainer().typeInferenceAnnotation;
+}
+
+Analysis::AnnotationContainer& Analysis::annotationContainer(ASTNode const& _node)
+{
+	solAssert(_node.id() > 0);
+	size_t id = static_cast<size_t>(_node.id());
+	solAssert(id <= m_maxAstId);
+	return m_annotations[id];
+}
+
+Analysis::AnnotationContainer const& Analysis::annotationContainer(ASTNode const& _node) const
+{
+	solAssert(_node.id() > 0);
+	size_t id = static_cast<size_t>(_node.id());
+	solAssert(id <= m_maxAstId);
+	return m_annotations[id];
+}
+
+Analysis::Analysis(langutil::ErrorReporter& _errorReporter, uint64_t _maxAstId):
+	m_errorReporter(_errorReporter),
+	m_maxAstId(_maxAstId),
+	m_annotations(std::make_unique<AnnotationContainer[]>(static_cast<size_t>(_maxAstId + 1))),
+	m_globalAnnotation(std::make_unique<GlobalAnnotationContainer>())
+{
+}
+
+Analysis::~Analysis()
+{}
+
+template<size_t... Is>
+std::tuple<std::integral_constant<size_t, Is>...> makeIndexTuple(std::index_sequence<Is...>) {
+	return std::make_tuple( std::integral_constant<size_t, Is>{}...);
+}
+
+bool Analysis::check(std::vector<std::shared_ptr<SourceUnit const>> const& _sourceUnits)
+{
+	using AnalysisSteps = std::tuple<
+		SyntaxRestrictor,
+		TypeClassRegistration,
+		TypeRegistration,
+		// TODO move after step introduced in https://github.com/ethereum/solidity/pull/14578, but before TypeInference
+		FunctionDependencyAnalysis,
+		TypeInference,
+		DebugWarner
+	>;
+
+	return std::apply([&](auto... _indexTuple) {
+		return ([&](auto&& _step) {
+			for (auto source: _sourceUnits)
+				if (!_step.analyze(*source))
+					return false;
+			return true;
+		}(std::tuple_element_t<decltype(_indexTuple)::value, AnalysisSteps>{*this}) && ...);
+	}, makeIndexTuple(std::make_index_sequence<std::tuple_size_v<AnalysisSteps>>{}));
+
+/*
+	{
+		SyntaxRestrictor syntaxRestrictor{*this};
+		for (auto source: _sourceUnits)
+			if (!syntaxRestrictor.analyze(*source))
+				return false;
+	}
+
+	{
+		TypeRegistration typeRegistration{*this};
+		for (auto source: _sourceUnits)
+			if (!typeRegistration.analyze(*source))
+				return false;
+	}
+	{
+		TypeInference typeInference{*this};
+		for (auto source: _sourceUnits)
+			if (!typeInference.analyze(*source))
+				return false;
+	}
+	return true;
+ */
+}
diff --git a/compiler/libsolidity/experimental/analysis/Analysis.h b/compiler/libsolidity/experimental/analysis/Analysis.h
new file mode 100644
index 00000000..dde3a24e
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/Analysis.h
@@ -0,0 +1,115 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/experimental/ast/TypeSystem.h>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace solidity::frontend
+{
+class SourceUnit;
+class ASTNode;
+}
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+}
+
+namespace solidity::frontend::experimental
+{
+
+class TypeSystem;
+
+class Analysis;
+
+namespace detail
+{
+template<typename Step>
+struct AnnotationFetcher
+{
+	Analysis& analysis;
+	typename Step::Annotation& get(ASTNode const& _node);
+	typename Step::GlobalAnnotation& get();
+};
+template<typename Step>
+struct ConstAnnotationFetcher
+{
+	Analysis const& analysis;
+	typename Step::Annotation const& get(ASTNode const& _node) const;
+	typename Step::GlobalAnnotation const& get() const;
+};
+}
+
+class Analysis
+{
+	struct AnnotationContainer;
+	struct GlobalAnnotationContainer;
+
+public:
+	Analysis(langutil::ErrorReporter& _errorReporter, uint64_t _maxAstId);
+	Analysis(Analysis const&) = delete;
+	~Analysis();
+	Analysis const& operator=(Analysis const&) = delete;
+	bool check(std::vector<std::shared_ptr<SourceUnit const>> const& _sourceUnits);
+	langutil::ErrorReporter& errorReporter() { return m_errorReporter; }
+	uint64_t maxAstId() const { return m_maxAstId; }
+	TypeSystem& typeSystem() { return m_typeSystem; }
+	TypeSystem const& typeSystem() const { return m_typeSystem; }
+
+	template<typename Step>
+	typename Step::Annotation& annotation(ASTNode const& _node)
+	{
+		return detail::AnnotationFetcher<Step>{*this}.get(_node);
+	}
+
+	template<typename Step>
+	typename Step::Annotation const& annotation(ASTNode const& _node) const
+	{
+		return detail::ConstAnnotationFetcher<Step>{*this}.get(_node);
+	}
+
+	template<typename Step>
+	typename Step::GlobalAnnotation& annotation()
+	{
+		return detail::AnnotationFetcher<Step>{*this}.get();
+	}
+
+	template<typename Step>
+	typename Step::GlobalAnnotation const& annotation() const
+	{
+		return detail::ConstAnnotationFetcher<Step>{*this}.get();
+	}
+
+	AnnotationContainer& annotationContainer(ASTNode const& _node);
+	AnnotationContainer const& annotationContainer(ASTNode const& _node) const;
+	GlobalAnnotationContainer& annotationContainer() { return *m_globalAnnotation; }
+	GlobalAnnotationContainer const& annotationContainer() const { return *m_globalAnnotation; }
+
+private:
+	langutil::ErrorReporter& m_errorReporter;
+	TypeSystem m_typeSystem;
+	uint64_t m_maxAstId = 0;
+	std::unique_ptr<AnnotationContainer[]> m_annotations;
+	std::unique_ptr<GlobalAnnotationContainer> m_globalAnnotation;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/DebugWarner.cpp b/compiler/libsolidity/experimental/analysis/DebugWarner.cpp
new file mode 100644
index 00000000..2b5c23b9
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/DebugWarner.cpp
@@ -0,0 +1,50 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/experimental/analysis/DebugWarner.h>
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/TypeInference.h>
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+
+#include <liblangutil/Exceptions.h>
+
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+using namespace solidity::langutil;
+
+DebugWarner::DebugWarner(Analysis& _analysis): m_analysis(_analysis), m_errorReporter(_analysis.errorReporter())
+{}
+
+bool DebugWarner::analyze(ASTNode const& _astRoot)
+{
+	_astRoot.accept(*this);
+	return !Error::containsErrors(m_errorReporter.errors());
+}
+
+bool DebugWarner::visitNode(ASTNode const& _node)
+{
+	std::optional<Type> const& inferredType = m_analysis.annotation<TypeInference>(_node).type;
+	if (inferredType.has_value())
+		m_errorReporter.info(
+			4164_error,
+			_node.location(),
+			"Inferred type: " + TypeEnvironmentHelpers{m_analysis.typeSystem().env()}.typeToString(*inferredType)
+		);
+	return true;
+}
diff --git a/compiler/libsolidity/experimental/analysis/DebugWarner.h b/compiler/libsolidity/experimental/analysis/DebugWarner.h
new file mode 100644
index 00000000..a7b5ac6d
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/DebugWarner.h
@@ -0,0 +1,42 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/ast/ASTVisitor.h>
+
+#include <liblangutil/ErrorReporter.h>
+
+namespace solidity::frontend::experimental
+{
+class Analysis;
+
+class DebugWarner: public ASTConstVisitor
+{
+public:
+	DebugWarner(Analysis& _analysis);
+
+	bool analyze(ASTNode const& _astRoot);
+
+private:
+	bool visitNode(ASTNode const& _node) override;
+
+	Analysis& m_analysis;
+	langutil::ErrorReporter& m_errorReporter;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.cpp b/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.cpp
new file mode 100644
index 00000000..332f7620
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.cpp
@@ -0,0 +1,72 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/FunctionDependencyAnalysis.h>
+
+using namespace solidity::frontend::experimental;
+using namespace solidity::util;
+
+FunctionDependencyAnalysis::FunctionDependencyAnalysis(Analysis& _analysis):
+	m_analysis(_analysis),
+	m_errorReporter(_analysis.errorReporter())
+{
+}
+
+bool FunctionDependencyAnalysis::analyze(SourceUnit const& _sourceUnit)
+{
+	_sourceUnit.accept(*this);
+	return !m_errorReporter.hasErrors();
+}
+
+bool FunctionDependencyAnalysis::visit(FunctionDefinition const& _functionDefinition)
+{
+	solAssert(!m_currentFunction);
+	m_currentFunction = &_functionDefinition;
+	// Insert a function definition pointer that maps to an empty set; the pointed to set will later be
+	// populated in ``endVisit(Identifier const& _identifier)`` if ``m_currentFunction`` references another.
+	auto [_, inserted] = annotation().functionCallGraph.edges.try_emplace(
+		m_currentFunction, std::set<FunctionDefinition const*, ASTCompareByID<FunctionDefinition>>{}
+	);
+	solAssert(inserted);
+	return true;
+}
+
+void FunctionDependencyAnalysis::endVisit(FunctionDefinition const&)
+{
+	m_currentFunction = nullptr;
+}
+
+void FunctionDependencyAnalysis::endVisit(Identifier const& _identifier)
+{
+	auto const* callee = dynamic_cast<FunctionDefinition const*>(_identifier.annotation().referencedDeclaration);
+	// Check that the identifier is within a function body and is a function, and add it to the graph
+	// as an ``m_currentFunction`` -> ``callee`` edge.
+	if (m_currentFunction && callee)
+		addEdge(m_currentFunction, callee);
+}
+
+void FunctionDependencyAnalysis::addEdge(FunctionDefinition const* _caller, FunctionDefinition const* _callee)
+{
+	annotation().functionCallGraph.edges[_caller].insert(_callee);
+}
+
+FunctionDependencyAnalysis::GlobalAnnotation& FunctionDependencyAnalysis::annotation()
+{
+	return m_analysis.annotation<FunctionDependencyAnalysis>();
+}
diff --git a/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.h b/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.h
new file mode 100644
index 00000000..acd3f1b2
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/FunctionDependencyAnalysis.h
@@ -0,0 +1,57 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <liblangutil/ErrorReporter.h>
+#include <libsolidity/ast/ASTForward.h>
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/experimental/ast/FunctionCallGraph.h>
+
+#include <memory>
+
+namespace solidity::frontend::experimental
+{
+
+class Analysis;
+
+class FunctionDependencyAnalysis: private ASTConstVisitor
+{
+public:
+	FunctionDependencyAnalysis(Analysis& _analysis);
+	bool analyze(SourceUnit const& _sourceUnit);
+
+	struct Annotation {};
+	struct GlobalAnnotation
+	{
+		FunctionDependencyGraph functionCallGraph;
+	};
+
+private:
+	bool visit(FunctionDefinition const& _functionDefinition) override;
+	void endVisit(FunctionDefinition const&) override;
+	void endVisit(Identifier const& _identifier) override;
+	void addEdge(FunctionDefinition const* _caller, FunctionDefinition const* _callee);
+	GlobalAnnotation& annotation();
+
+	Analysis& m_analysis;
+	langutil::ErrorReporter& m_errorReporter;
+	FunctionDefinition const* m_currentFunction = nullptr;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.cpp b/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.cpp
new file mode 100644
index 00000000..41961528
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.cpp
@@ -0,0 +1,111 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/experimental/analysis/SyntaxRestrictor.h>
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+
+#include <liblangutil/Exceptions.h>
+
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+using namespace solidity::langutil;
+
+SyntaxRestrictor::SyntaxRestrictor(Analysis& _analysis): m_errorReporter(_analysis.errorReporter())
+{}
+
+bool SyntaxRestrictor::analyze(ASTNode const& _astRoot)
+{
+	_astRoot.accept(*this);
+	return !Error::containsErrors(m_errorReporter.errors());
+}
+
+bool SyntaxRestrictor::visitNode(ASTNode const& _node)
+{
+	if (!_node.experimentalSolidityOnly())
+		m_errorReporter.syntaxError(9282_error, _node.location(), "Unsupported AST node.");
+	return false;
+}
+
+bool SyntaxRestrictor::visit(ContractDefinition const& _contractDefinition)
+{
+	if (_contractDefinition.contractKind() != ContractKind::Contract)
+		m_errorReporter.syntaxError(9159_error, _contractDefinition.location(), "Only contracts are supported.");
+	if (!_contractDefinition.baseContracts().empty())
+		m_errorReporter.syntaxError(5731_error, _contractDefinition.location(), "Inheritance unsupported.");
+	return true;
+}
+
+bool SyntaxRestrictor::visit(FunctionDefinition const& _functionDefinition)
+{
+	if (!_functionDefinition.isImplemented())
+		m_errorReporter.syntaxError(1741_error, _functionDefinition.location(), "Functions must be implemented.");
+	if (!_functionDefinition.modifiers().empty())
+		m_errorReporter.syntaxError(9988_error, _functionDefinition.location(), "Function may not have modifiers.");
+	if (_functionDefinition.overrides())
+		m_errorReporter.syntaxError(5044_error, _functionDefinition.location(), "Function may not have override specifiers.");
+	solAssert(!_functionDefinition.returnParameterList());
+	if (_functionDefinition.isFree())
+	{
+		if (_functionDefinition.stateMutability() != StateMutability::NonPayable)
+			m_errorReporter.syntaxError(5714_error, _functionDefinition.location(), "Free functions may not have a mutability.");
+	}
+	else
+	{
+		if (_functionDefinition.isFallback())
+		{
+			if (_functionDefinition.visibility() != Visibility::External)
+				m_errorReporter.syntaxError(7341_error, _functionDefinition.location(), "Fallback function must be external.");
+		}
+		else
+			m_errorReporter.syntaxError(4496_error, _functionDefinition.location(), "Only fallback functions are supported in contracts.");
+	}
+
+	return true;
+}
+
+bool SyntaxRestrictor::visit(VariableDeclarationStatement const& _variableDeclarationStatement)
+{
+	if (_variableDeclarationStatement.declarations().size() == 1)
+	{
+		if (!_variableDeclarationStatement.declarations().front())
+			m_errorReporter.syntaxError(9658_error, _variableDeclarationStatement.initialValue()->location(), "Variable declaration has to declare a single variable.");
+	}
+	else
+		m_errorReporter.syntaxError(3520_error, _variableDeclarationStatement.initialValue()->location(), "Variable declarations can only declare a single variable.");
+	return true;
+}
+
+bool SyntaxRestrictor::visit(VariableDeclaration const& _variableDeclaration)
+{
+	if (_variableDeclaration.value())
+		m_errorReporter.syntaxError(1801_error, _variableDeclaration.value()->location(), "Variable declarations with initial value not supported.");
+	if (_variableDeclaration.isStateVariable())
+		m_errorReporter.syntaxError(6388_error, _variableDeclaration.location(), "State variables are not supported.");
+	if (!_variableDeclaration.isLocalVariable())
+		m_errorReporter.syntaxError(8953_error, _variableDeclaration.location(), "Only local variables are supported.");
+	if (_variableDeclaration.mutability() != VariableDeclaration::Mutability::Mutable)
+		m_errorReporter.syntaxError(2934_error, _variableDeclaration.location(), "Only mutable variables are supported.");
+	if (_variableDeclaration.isIndexed())
+		m_errorReporter.syntaxError(9603_error, _variableDeclaration.location(), "Indexed variables are not supported.");
+	if (!_variableDeclaration.noVisibilitySpecified())
+		m_errorReporter.syntaxError(8809_error, _variableDeclaration.location(), "Variables with visibility not supported.");
+	if (_variableDeclaration.overrides())
+		m_errorReporter.syntaxError(6175_error, _variableDeclaration.location(), "Variables with override specifier not supported.");
+	return true;
+}
diff --git a/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.h b/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.h
new file mode 100644
index 00000000..8fdaa11b
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/SyntaxRestrictor.h
@@ -0,0 +1,66 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/ast/ASTVisitor.h>
+
+#include <liblangutil/ErrorReporter.h>
+#include <liblangutil/Exceptions.h>
+
+namespace solidity::frontend::experimental
+{
+class Analysis;
+
+class SyntaxRestrictor: public ASTConstVisitor
+{
+public:
+	SyntaxRestrictor(Analysis& _analysis);
+
+	bool analyze(ASTNode const& _astRoot);
+
+private:
+	/// Default visit will reject all AST nodes that are not explicitly allowed.
+	bool visitNode(ASTNode const& _node) override;
+
+	bool visit(SourceUnit const&) override { return true; }
+	bool visit(PragmaDirective const&) override { return true; }
+	bool visit(ImportDirective const&) override { return true; }
+	bool visit(ContractDefinition const& _contractDefinition) override;
+	bool visit(FunctionDefinition const& _functionDefinition) override;
+	bool visit(ExpressionStatement const&) override { return true; }
+	bool visit(FunctionCall const&) override { return true; }
+	bool visit(Assignment const&) override { return true; }
+	bool visit(Block const&) override { return true; }
+	bool visit(Identifier const&) override { return true; }
+	bool visit(IdentifierPath const&) override { return true; }
+	bool visit(IfStatement const&) override { return true; }
+	bool visit(VariableDeclarationStatement const&) override;
+	bool visit(VariableDeclaration const&) override;
+	bool visit(ElementaryTypeName const&) override { return true; }
+	bool visit(ParameterList const&) override { return true; }
+	bool visit(Return const&) override { return true; }
+	bool visit(MemberAccess const&) override { return true; }
+	bool visit(BinaryOperation const&) override { return true; }
+	bool visit(ElementaryTypeNameExpression const&) override { return true; }
+	bool visit(TupleExpression const&) override { return true; }
+	bool visit(Literal const&) override { return true; }
+
+	langutil::ErrorReporter& m_errorReporter;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeClassRegistration.cpp b/compiler/libsolidity/experimental/analysis/TypeClassRegistration.cpp
new file mode 100644
index 00000000..fe70a44d
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeClassRegistration.cpp
@@ -0,0 +1,62 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolidity/experimental/analysis/TypeClassRegistration.h>
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+
+#include <liblangutil/ErrorReporter.h>
+#include <liblangutil/Exceptions.h>
+
+using namespace solidity::frontend::experimental;
+using namespace solidity::langutil;
+
+TypeClassRegistration::TypeClassRegistration(Analysis& _analysis):
+	m_analysis(_analysis),
+	m_errorReporter(_analysis.errorReporter()),
+	m_typeSystem(_analysis.typeSystem())
+{
+}
+
+bool TypeClassRegistration::analyze(SourceUnit const& _sourceUnit)
+{
+	_sourceUnit.accept(*this);
+	return !m_errorReporter.hasErrors();
+}
+
+bool TypeClassRegistration::visit(TypeClassDefinition const& _typeClassDefinition)
+{
+	std::variant<TypeClass, std::string> typeClassOrError = m_typeSystem.declareTypeClass(
+		_typeClassDefinition.name(),
+		&_typeClassDefinition
+	);
+
+	m_analysis.annotation<TypeClassRegistration>(_typeClassDefinition).typeClass = std::visit(
+		util::GenericVisitor{
+			[](TypeClass _class) -> TypeClass { return _class; },
+			[&](std::string _error) -> TypeClass {
+				m_errorReporter.fatalTypeError(4767_error, _typeClassDefinition.location(), _error);
+				util::unreachable();
+			}
+		},
+		typeClassOrError
+	);
+
+	return true;
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeClassRegistration.h b/compiler/libsolidity/experimental/analysis/TypeClassRegistration.h
new file mode 100644
index 00000000..c0c1c354
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeClassRegistration.h
@@ -0,0 +1,58 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/experimental/ast/TypeSystem.h>
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+}
+
+namespace solidity::frontend::experimental
+{
+
+class Analysis;
+class TypeSystem;
+
+class TypeClassRegistration: public ASTConstVisitor
+{
+public:
+	struct Annotation
+	{
+		// Type classes.
+		std::optional<TypeClass> typeClass;
+	};
+	struct GlobalAnnotation
+	{
+	};
+
+	TypeClassRegistration(Analysis& _analysis);
+
+	bool analyze(SourceUnit const& _sourceUnit);
+
+private:
+	bool visit(TypeClassDefinition const& _typeClassDefinition) override;
+
+	Analysis& m_analysis;
+	langutil::ErrorReporter& m_errorReporter;
+	TypeSystem& m_typeSystem;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeInference.cpp b/compiler/libsolidity/experimental/analysis/TypeInference.cpp
new file mode 100644
index 00000000..a82496b7
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeInference.cpp
@@ -0,0 +1,1160 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolidity/experimental/analysis/TypeInference.h>
+
+#include <libsolidity/experimental/analysis/TypeClassRegistration.h>
+#include <libsolidity/experimental/analysis/TypeRegistration.h>
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+
+#include <libsolutil/Numeric.h>
+#include <libsolutil/StringUtils.h>
+#include <liblangutil/Exceptions.h>
+
+#include <boost/algorithm/string.hpp>
+#include <range/v3/view/transform.hpp>
+
+using namespace solidity;
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+using namespace solidity::langutil;
+
+TypeInference::TypeInference(Analysis& _analysis):
+	m_analysis(_analysis),
+	m_errorReporter(_analysis.errorReporter()),
+	m_typeSystem(_analysis.typeSystem()),
+	m_env(&m_typeSystem.env()),
+	m_voidType(m_typeSystem.type(PrimitiveType::Void, {})),
+	m_wordType(m_typeSystem.type(PrimitiveType::Word, {})),
+	m_integerType(m_typeSystem.type(PrimitiveType::Integer, {})),
+	m_unitType(m_typeSystem.type(PrimitiveType::Unit, {})),
+	m_boolType(m_typeSystem.type(PrimitiveType::Bool, {}))
+{
+	TypeSystemHelpers helper{m_typeSystem};
+
+	auto declareBuiltinClass = [&](std::string _name, BuiltinClass _class) -> TypeClass {
+		auto result = m_typeSystem.declareTypeClass(_name, nullptr);
+		if (auto error = std::get_if<std::string>(&result))
+			solAssert(!error, *error);
+		TypeClass declaredClass = std::get<TypeClass>(result);
+		// TODO: validation?
+		solAssert(annotation().builtinClassesByName.emplace(_name, _class).second);
+		return annotation().builtinClasses.emplace(_class, declaredClass).first->second;
+	};
+
+	auto registeredTypeClass = [&](BuiltinClass _builtinClass) -> TypeClass {
+		return annotation().builtinClasses.at(_builtinClass);
+	};
+
+	auto defineConversion = [&](BuiltinClass _builtinClass, PrimitiveType _fromType, std::string _functionName) {
+		annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
+			std::move(_functionName),
+			helper.functionType(
+				m_typeSystem.type(_fromType, {}),
+				m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable
+			),
+		}};
+	};
+
+	auto defineBinaryMonoidalOperator = [&](BuiltinClass _builtinClass, Token _token, std::string _functionName) {
+		Type typeVar = m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable;
+		annotation().operators.emplace(_token, std::make_tuple(registeredTypeClass(_builtinClass), _functionName));
+		annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
+			std::move(_functionName),
+			helper.functionType(
+				helper.tupleType({typeVar, typeVar}),
+				typeVar
+			)
+		}};
+	};
+
+	auto defineBinaryCompareOperator = [&](BuiltinClass _builtinClass, Token _token, std::string _functionName) {
+		Type typeVar = m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable;
+		annotation().operators.emplace(_token, std::make_tuple(registeredTypeClass(_builtinClass), _functionName));
+		annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
+			std::move(_functionName),
+			helper.functionType(
+				helper.tupleType({typeVar, typeVar}),
+				m_typeSystem.type(PrimitiveType::Bool, {})
+			)
+		}};
+	};
+
+	declareBuiltinClass("integer", BuiltinClass::Integer);
+	declareBuiltinClass("*", BuiltinClass::Mul);
+	declareBuiltinClass("+", BuiltinClass::Add);
+	declareBuiltinClass("==", BuiltinClass::Equal);
+	declareBuiltinClass("<", BuiltinClass::Less);
+	declareBuiltinClass("<=", BuiltinClass::LessOrEqual);
+	declareBuiltinClass(">", BuiltinClass::Greater);
+	declareBuiltinClass(">=", BuiltinClass::GreaterOrEqual);
+
+	defineConversion(BuiltinClass::Integer, PrimitiveType::Integer, "fromInteger");
+
+	defineBinaryMonoidalOperator(BuiltinClass::Mul, Token::Mul, "mul");
+	defineBinaryMonoidalOperator(BuiltinClass::Add, Token::Add, "add");
+
+	defineBinaryCompareOperator(BuiltinClass::Equal, Token::Equal, "eq");
+	defineBinaryCompareOperator(BuiltinClass::Less, Token::LessThan, "lt");
+	defineBinaryCompareOperator(BuiltinClass::LessOrEqual, Token::LessThanOrEqual, "leq");
+	defineBinaryCompareOperator(BuiltinClass::Greater, Token::GreaterThan, "gt");
+	defineBinaryCompareOperator(BuiltinClass::GreaterOrEqual, Token::GreaterThanOrEqual, "geq");
+}
+
+bool TypeInference::analyze(SourceUnit const& _sourceUnit)
+{
+	_sourceUnit.accept(*this);
+	return !m_errorReporter.hasErrors();
+}
+
+bool TypeInference::visit(FunctionDefinition const& _functionDefinition)
+{
+	solAssert(m_expressionContext == ExpressionContext::Term);
+	auto& functionAnnotation = annotation(_functionDefinition);
+	if (functionAnnotation.type)
+		return false;
+
+	ScopedSaveAndRestore signatureRestore(m_currentFunctionType, std::nullopt);
+
+	Type argumentsType = m_typeSystem.freshTypeVariable({});
+	Type returnType = m_typeSystem.freshTypeVariable({});
+	Type functionType = TypeSystemHelpers{m_typeSystem}.functionType(argumentsType, returnType);
+
+	m_currentFunctionType = functionType;
+	functionAnnotation.type = functionType;
+
+
+	_functionDefinition.parameterList().accept(*this);
+	unify(argumentsType, type(_functionDefinition.parameterList()), _functionDefinition.parameterList().location());
+	if (_functionDefinition.experimentalReturnExpression())
+	{
+		ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+		_functionDefinition.experimentalReturnExpression()->accept(*this);
+		unify(
+			returnType,
+			type(*_functionDefinition.experimentalReturnExpression()),
+			_functionDefinition.experimentalReturnExpression()->location()
+		);
+	}
+	else
+		unify(returnType, m_unitType, _functionDefinition.location());
+
+	if (_functionDefinition.isImplemented())
+		_functionDefinition.body().accept(*this);
+
+	return false;
+}
+
+void TypeInference::endVisit(Return const& _return)
+{
+	solAssert(m_currentFunctionType);
+	Type functionReturnType = std::get<1>(TypeSystemHelpers{m_typeSystem}.destFunctionType(*m_currentFunctionType));
+	if (_return.expression())
+		unify(functionReturnType, type(*_return.expression()), _return.location());
+	else
+		unify(functionReturnType, m_unitType, _return.location());
+}
+
+void TypeInference::endVisit(ParameterList const& _parameterList)
+{
+	auto& listAnnotation = annotation(_parameterList);
+	solAssert(!listAnnotation.type);
+	listAnnotation.type = TypeSystemHelpers{m_typeSystem}.tupleType(
+		_parameterList.parameters() | ranges::views::transform([&](auto _arg) { return type(*_arg); }) | ranges::to<std::vector<Type>>
+	);
+}
+
+bool TypeInference::visit(TypeClassDefinition const& _typeClassDefinition)
+{
+	solAssert(m_expressionContext == ExpressionContext::Term);
+	auto& typeClassDefinitionAnnotation = annotation(_typeClassDefinition);
+	if (typeClassDefinitionAnnotation.type)
+		return false;
+
+	typeClassDefinitionAnnotation.type = type(&_typeClassDefinition, {});
+
+	{
+		ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+		_typeClassDefinition.typeVariable().accept(*this);
+	}
+
+	std::map<std::string, Type> functionTypes;
+
+	solAssert(m_analysis.annotation<TypeClassRegistration>(_typeClassDefinition).typeClass.has_value());
+	TypeClass typeClass = m_analysis.annotation<TypeClassRegistration>(_typeClassDefinition).typeClass.value();
+	Type typeVar = m_typeSystem.typeClassVariable(typeClass);
+	auto& typeMembersAnnotation = annotation().members[typeConstructor(&_typeClassDefinition)];
+
+	for (auto subNode: _typeClassDefinition.subNodes())
+	{
+		subNode->accept(*this);
+		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());
+		solAssert(functionDefinition);
+		auto functionType = type(*functionDefinition);
+		if (!functionTypes.emplace(functionDefinition->name(), functionType).second)
+			m_errorReporter.fatalTypeError(3195_error, functionDefinition->location(), "Function in type class declared multiple times.");
+		auto typeVars = TypeEnvironmentHelpers{*m_env}.typeVars(functionType);
+		if (typeVars.size() != 1)
+			m_errorReporter.fatalTypeError(8379_error, functionDefinition->location(), "Function in type class may only depend on the type class variable.");
+		unify(typeVars.front(), typeVar, functionDefinition->location());
+		typeMembersAnnotation[functionDefinition->name()] = TypeMember{functionType};
+	}
+
+	annotation().typeClassFunctions[typeClass] = std::move(functionTypes);
+
+	for (auto [functionName, functionType]: functionTypes)
+	{
+		TypeEnvironmentHelpers helper{*m_env};
+		auto typeVars = helper.typeVars(functionType);
+		if (typeVars.empty())
+			m_errorReporter.typeError(1723_error, _typeClassDefinition.location(), "Function " + functionName + " does not depend on class variable.");
+		if (typeVars.size() > 2)
+			m_errorReporter.typeError(6387_error, _typeClassDefinition.location(), "Function " + functionName + " depends on multiple type variables.");
+		if (!m_env->typeEquals(typeVars.front(), typeVar))
+			m_errorReporter.typeError(1807_error, _typeClassDefinition.location(), "Function " + functionName + " depends on invalid type variable.");
+	}
+
+	unify(type(_typeClassDefinition.typeVariable()), m_typeSystem.freshTypeVariable({{typeClass}}), _typeClassDefinition.location());
+	for (auto instantiation: m_analysis.annotation<TypeRegistration>(_typeClassDefinition).instantiations | ranges::views::values)
+		// TODO: recursion-safety? Order of instantiation?
+		instantiation->accept(*this);
+
+	return false;
+}
+
+bool TypeInference::visit(BinaryOperation const& _binaryOperation)
+{
+	auto& operationAnnotation = annotation(_binaryOperation);
+	solAssert(!operationAnnotation.type);
+	TypeSystemHelpers helper{m_typeSystem};
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+		if (auto* operatorInfo = util::valueOrNullptr(annotation().operators, _binaryOperation.getOperator()))
+		{
+			auto [typeClass, functionName] = *operatorInfo;
+			// TODO: error robustness?
+			Type functionType = m_env->fresh(annotation().typeClassFunctions.at(typeClass).at(functionName));
+
+			_binaryOperation.leftExpression().accept(*this);
+			_binaryOperation.rightExpression().accept(*this);
+
+			Type argTuple = helper.tupleType({type(_binaryOperation.leftExpression()), type(_binaryOperation.rightExpression())});
+			Type resultType = m_typeSystem.freshTypeVariable({});
+			Type genericFunctionType = helper.functionType(argTuple, resultType);
+			unify(functionType, genericFunctionType, _binaryOperation.location());
+
+			operationAnnotation.type = resultType;
+		}
+		else if (_binaryOperation.getOperator() == Token::Colon)
+		{
+			_binaryOperation.leftExpression().accept(*this);
+			{
+				ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+				_binaryOperation.rightExpression().accept(*this);
+			}
+			Type leftType = type(_binaryOperation.leftExpression());
+			unify(leftType, type(_binaryOperation.rightExpression()), _binaryOperation.location());
+			operationAnnotation.type = leftType;
+		}
+		else
+		{
+			m_errorReporter.typeError(4504_error, _binaryOperation.location(), "Binary operation in term context not yet supported.");
+			operationAnnotation.type = m_typeSystem.freshTypeVariable({});
+		}
+		return false;
+	case ExpressionContext::Type:
+		if (_binaryOperation.getOperator() == Token::Colon)
+		{
+			_binaryOperation.leftExpression().accept(*this);
+			{
+				ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Sort};
+				_binaryOperation.rightExpression().accept(*this);
+			}
+			Type leftType = type(_binaryOperation.leftExpression());
+			unify(leftType, type(_binaryOperation.rightExpression()), _binaryOperation.location());
+			operationAnnotation.type = leftType;
+		}
+		else if (_binaryOperation.getOperator() == Token::RightArrow)
+		{
+			_binaryOperation.leftExpression().accept(*this);
+			_binaryOperation.rightExpression().accept(*this);
+			operationAnnotation.type = helper.functionType(type(_binaryOperation.leftExpression()), type(_binaryOperation.rightExpression()));
+		}
+		else if (_binaryOperation.getOperator() == Token::BitOr)
+		{
+			_binaryOperation.leftExpression().accept(*this);
+			_binaryOperation.rightExpression().accept(*this);
+			operationAnnotation.type = helper.sumType({type(_binaryOperation.leftExpression()), type(_binaryOperation.rightExpression())});
+		}
+		else
+		{
+			m_errorReporter.typeError(1439_error, _binaryOperation.location(), "Invalid binary operations in type context.");
+			operationAnnotation.type = m_typeSystem.freshTypeVariable({});
+		}
+		return false;
+	case ExpressionContext::Sort:
+		m_errorReporter.typeError(1017_error, _binaryOperation.location(), "Invalid binary operation in sort context.");
+		operationAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return false;
+	}
+	return false;
+}
+
+void TypeInference::endVisit(VariableDeclarationStatement const& _variableDeclarationStatement)
+{
+	solAssert(m_expressionContext == ExpressionContext::Term);
+	if (_variableDeclarationStatement.declarations().size () != 1)
+	{
+		m_errorReporter.typeError(2655_error, _variableDeclarationStatement.location(), "Multi variable declaration not supported.");
+		return;
+	}
+	Type variableType = type(*_variableDeclarationStatement.declarations().front());
+	if (_variableDeclarationStatement.initialValue())
+		unify(variableType, type(*_variableDeclarationStatement.initialValue()), _variableDeclarationStatement.location());
+}
+
+bool TypeInference::visit(VariableDeclaration const& _variableDeclaration)
+{
+	solAssert(!_variableDeclaration.value());
+	auto& variableAnnotation = annotation(_variableDeclaration);
+	solAssert(!variableAnnotation.type);
+
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+		if (_variableDeclaration.typeExpression())
+		{
+			ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+			_variableDeclaration.typeExpression()->accept(*this);
+			variableAnnotation.type = type(*_variableDeclaration.typeExpression());
+			return false;
+		}
+		variableAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return false;
+	case ExpressionContext::Type:
+		variableAnnotation.type = m_typeSystem.freshTypeVariable({});
+		if (_variableDeclaration.typeExpression())
+		{
+			ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Sort};
+			_variableDeclaration.typeExpression()->accept(*this);
+			unify(*variableAnnotation.type, type(*_variableDeclaration.typeExpression()), _variableDeclaration.typeExpression()->location());
+		}
+		return false;
+	case ExpressionContext::Sort:
+		m_errorReporter.typeError(2399_error, _variableDeclaration.location(), "Variable declaration in sort context.");
+		variableAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return false;
+	}
+	util::unreachable();
+}
+
+void TypeInference::endVisit(IfStatement const& _ifStatement)
+{
+	auto& ifAnnotation = annotation(_ifStatement);
+	solAssert(!ifAnnotation.type);
+
+	if (m_expressionContext != ExpressionContext::Term)
+	{
+		m_errorReporter.typeError(2015_error, _ifStatement.location(), "If statement outside term context.");
+		ifAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return;
+	}
+
+	unify(type(_ifStatement.condition()), m_boolType, _ifStatement.condition().location());
+
+	ifAnnotation.type = m_unitType;
+}
+
+void TypeInference::endVisit(Assignment const& _assignment)
+{
+	auto& assignmentAnnotation = annotation(_assignment);
+	solAssert(!assignmentAnnotation.type);
+
+	if (m_expressionContext != ExpressionContext::Term)
+	{
+		m_errorReporter.typeError(4337_error, _assignment.location(), "Assignment outside term context.");
+		assignmentAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return;
+	}
+
+	Type leftType = type(_assignment.leftHandSide());
+	unify(leftType, type(_assignment.rightHandSide()), _assignment.location());
+	assignmentAnnotation.type = leftType;
+}
+
+experimental::Type TypeInference::handleIdentifierByReferencedDeclaration(langutil::SourceLocation _location, Declaration const& _declaration)
+{
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+	{
+		if (
+			!dynamic_cast<FunctionDefinition const*>(&_declaration) &&
+			!dynamic_cast<VariableDeclaration const*>(&_declaration) &&
+			!dynamic_cast<TypeClassDefinition const*>(&_declaration) &&
+			!dynamic_cast<TypeDefinition const*>(&_declaration)
+		)
+		{
+			SecondarySourceLocation ssl;
+			ssl.append("Referenced node.", _declaration.location());
+			m_errorReporter.fatalTypeError(3101_error, _location, ssl, "Attempt to type identifier referring to unexpected node.");
+		}
+
+		auto& declarationAnnotation = annotation(_declaration);
+		if (!declarationAnnotation.type)
+			_declaration.accept(*this);
+
+		solAssert(declarationAnnotation.type);
+
+		if (dynamic_cast<VariableDeclaration const*>(&_declaration))
+			return *declarationAnnotation.type;
+		else if (dynamic_cast<FunctionDefinition const*>(&_declaration))
+			return polymorphicInstance(*declarationAnnotation.type);
+		else if (dynamic_cast<TypeClassDefinition const*>(&_declaration))
+		{
+			solAssert(TypeEnvironmentHelpers{*m_env}.typeVars(*declarationAnnotation.type).empty());
+			return *declarationAnnotation.type;
+		}
+		else if (dynamic_cast<TypeDefinition const*>(&_declaration))
+		{
+			// TODO: can we avoid this?
+			Type type = *declarationAnnotation.type;
+			if (TypeSystemHelpers{m_typeSystem}.isTypeFunctionType(type))
+				type = std::get<1>(TypeSystemHelpers{m_typeSystem}.destTypeFunctionType(type));
+			return polymorphicInstance(type);
+		}
+		else
+			solAssert(false);
+		break;
+	}
+	case ExpressionContext::Type:
+	{
+		if (
+			!dynamic_cast<VariableDeclaration const*>(&_declaration) &&
+			!dynamic_cast<TypeDefinition const*>(&_declaration)
+		)
+		{
+			SecondarySourceLocation ssl;
+			ssl.append("Referenced node.", _declaration.location());
+			m_errorReporter.fatalTypeError(2217_error, _location, ssl, "Attempt to type identifier referring to unexpected node.");
+		}
+
+		// TODO: Assert that this is a type class variable declaration?
+		auto& declarationAnnotation = annotation(_declaration);
+		if (!declarationAnnotation.type)
+			_declaration.accept(*this);
+
+		solAssert(declarationAnnotation.type);
+
+		if (dynamic_cast<VariableDeclaration const*>(&_declaration))
+			return *declarationAnnotation.type;
+		else if (dynamic_cast<TypeDefinition const*>(&_declaration))
+			return polymorphicInstance(*declarationAnnotation.type);
+		else
+			solAssert(false);
+		break;
+	}
+	case ExpressionContext::Sort:
+	{
+		if (auto const* typeClassDefinition = dynamic_cast<TypeClassDefinition const*>(&_declaration))
+		{
+			ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Term};
+			typeClassDefinition->accept(*this);
+
+			solAssert(m_analysis.annotation<TypeClassRegistration>(*typeClassDefinition).typeClass.has_value());
+			TypeClass typeClass = m_analysis.annotation<TypeClassRegistration>(*typeClassDefinition).typeClass.value();
+			return m_typeSystem.freshTypeVariable(Sort{{typeClass}});
+		}
+		else
+		{
+			m_errorReporter.typeError(2599_error, _location, "Expected type class.");
+			return m_typeSystem.freshTypeVariable({});
+		}
+		break;
+	}
+	}
+	util::unreachable();
+}
+
+bool TypeInference::visit(Identifier const& _identifier)
+{
+	auto& identifierAnnotation = annotation(_identifier);
+	solAssert(!identifierAnnotation.type);
+
+	if (auto const* referencedDeclaration = _identifier.annotation().referencedDeclaration)
+	{
+		identifierAnnotation.type = handleIdentifierByReferencedDeclaration(_identifier.location(), *referencedDeclaration);
+		return false;
+	}
+
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+		// TODO: error handling
+		solAssert(false);
+		break;
+	case ExpressionContext::Type:
+		// TODO: register free type variable name!
+		identifierAnnotation.type = m_typeSystem.freshTypeVariable({});
+		return false;
+	case ExpressionContext::Sort:
+		// TODO: error handling
+		solAssert(false);
+		break;
+	}
+
+	return false;
+}
+
+void TypeInference::endVisit(TupleExpression const& _tupleExpression)
+{
+	auto& expressionAnnotation = annotation(_tupleExpression);
+	solAssert(!expressionAnnotation.type);
+
+	TypeSystemHelpers helper{m_typeSystem};
+	auto componentTypes = _tupleExpression.components() | ranges::views::transform([&](auto _expr) -> Type {
+		auto& componentAnnotation = annotation(*_expr);
+		solAssert(componentAnnotation.type);
+		return *componentAnnotation.type;
+	}) | ranges::to<std::vector<Type>>;
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+	case ExpressionContext::Type:
+		expressionAnnotation.type = helper.tupleType(componentTypes);
+		break;
+	case ExpressionContext::Sort:
+	{
+		Type type = m_typeSystem.freshTypeVariable({});
+		for (auto componentType: componentTypes)
+			unify(type, componentType, _tupleExpression.location());
+		expressionAnnotation.type = type;
+		break;
+	}
+	}
+}
+
+bool TypeInference::visit(IdentifierPath const& _identifierPath)
+{
+	auto& identifierAnnotation = annotation(_identifierPath);
+	solAssert(!identifierAnnotation.type);
+
+	if (auto const* referencedDeclaration = _identifierPath.annotation().referencedDeclaration)
+	{
+		identifierAnnotation.type = handleIdentifierByReferencedDeclaration(_identifierPath.location(), *referencedDeclaration);
+		return false;
+	}
+
+	// TODO: error handling
+	solAssert(false);
+}
+
+bool TypeInference::visit(TypeClassInstantiation const& _typeClassInstantiation)
+{
+	ScopedSaveAndRestore activeInstantiations{m_activeInstantiations, m_activeInstantiations + std::set<TypeClassInstantiation const*>{&_typeClassInstantiation}};
+	// Note: recursion is resolved due to special handling during unification.
+	auto& instantiationAnnotation = annotation(_typeClassInstantiation);
+	if (instantiationAnnotation.type)
+		return false;
+	instantiationAnnotation.type = m_voidType;
+	std::optional<TypeClass> typeClass = std::visit(util::GenericVisitor{
+		[&](ASTPointer<IdentifierPath> _typeClassName) -> std::optional<TypeClass> {
+			if (auto const* typeClassDefinition = dynamic_cast<TypeClassDefinition const*>(_typeClassName->annotation().referencedDeclaration))
+			{
+				// visiting the type class will re-visit this instantiation
+				typeClassDefinition->accept(*this);
+				// TODO: more error handling? Should be covered by the visit above.
+				solAssert(m_analysis.annotation<TypeClassRegistration>(*typeClassDefinition).typeClass.has_value());
+				return m_analysis.annotation<TypeClassRegistration>(*typeClassDefinition).typeClass.value();
+			}
+			else
+			{
+				m_errorReporter.typeError(9817_error, _typeClassInstantiation.typeClass().location(), "Expected type class.");
+				return std::nullopt;
+			}
+		},
+		[&](Token _token) -> std::optional<TypeClass> {
+			if (auto builtinClass = builtinClassFromToken(_token))
+				if (auto typeClass = util::valueOrNullptr(annotation().builtinClasses, *builtinClass))
+					return *typeClass;
+			m_errorReporter.typeError(2658_error, _typeClassInstantiation.location(), "Invalid type class name.");
+			return std::nullopt;
+		}
+	}, _typeClassInstantiation.typeClass().name());
+	if (!typeClass)
+		return false;
+
+	// TODO: _typeClassInstantiation.typeConstructor().accept(*this); ?
+	auto typeConstructor = m_analysis.annotation<TypeRegistration>(_typeClassInstantiation.typeConstructor()).typeConstructor;
+	if (!typeConstructor)
+	{
+		m_errorReporter.typeError(2138_error, _typeClassInstantiation.typeConstructor().location(), "Invalid type constructor.");
+		return false;
+	}
+
+	std::vector<Type> arguments;
+	Arity arity{
+		{},
+		*typeClass
+	};
+
+	{
+		ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+		if (_typeClassInstantiation.argumentSorts())
+		{
+			_typeClassInstantiation.argumentSorts()->accept(*this);
+			auto& argumentSortAnnotation = annotation(*_typeClassInstantiation.argumentSorts());
+			solAssert(argumentSortAnnotation.type);
+			arguments = TypeSystemHelpers{m_typeSystem}.destTupleType(*argumentSortAnnotation.type);
+			arity.argumentSorts = arguments | ranges::views::transform([&](Type _type) {
+				return m_env->sort(_type);
+			}) | ranges::to<std::vector<Sort>>;
+		}
+	}
+
+	Type instanceType{TypeConstant{*typeConstructor, arguments}};
+
+	std::map<std::string, Type> functionTypes;
+
+	for (auto subNode: _typeClassInstantiation.subNodes())
+	{
+		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());
+		solAssert(functionDefinition);
+		subNode->accept(*this);
+		if (!functionTypes.emplace(functionDefinition->name(), type(*functionDefinition)).second)
+			m_errorReporter.typeError(3654_error, subNode->location(), "Duplicate definition of function " + functionDefinition->name() + " during type class instantiation.");
+	}
+
+	if (auto error = m_typeSystem.instantiateClass(instanceType, arity))
+		m_errorReporter.typeError(5094_error, _typeClassInstantiation.location(), *error);
+
+	auto const& classFunctions = annotation().typeClassFunctions.at(*typeClass);
+
+	TypeEnvironment newEnv = m_env->clone();
+	if (!newEnv.unify(m_typeSystem.typeClassVariable(*typeClass), instanceType).empty())
+	{
+		m_errorReporter.typeError(4686_error, _typeClassInstantiation.location(), "Unification of class and instance variable failed.");
+		return false;
+	}
+
+	for (auto [name, classFunctionType]: classFunctions)
+	{
+		if (!functionTypes.count(name))
+		{
+			m_errorReporter.typeError(6948_error, _typeClassInstantiation.location(), "Missing function: " + name);
+			continue;
+		}
+		Type instanceFunctionType = functionTypes.at(name);
+		functionTypes.erase(name);
+
+		if (!newEnv.typeEquals(instanceFunctionType, classFunctionType))
+			m_errorReporter.typeError(7428_error, _typeClassInstantiation.location(), "Type mismatch for function " + name + " " + TypeEnvironmentHelpers{newEnv}.typeToString(instanceFunctionType) + " != " + TypeEnvironmentHelpers{newEnv}.typeToString(classFunctionType));
+	}
+
+	if (!functionTypes.empty())
+		m_errorReporter.typeError(4873_error, _typeClassInstantiation.location(), "Additional functions in class instantiation.");
+
+	return false;
+}
+
+bool TypeInference::visit(MemberAccess const& _memberAccess)
+{
+	if (m_expressionContext != ExpressionContext::Term)
+	{
+		m_errorReporter.typeError(5195_error, _memberAccess.location(), "Member access outside term context.");
+		annotation(_memberAccess).type = m_typeSystem.freshTypeVariable({});
+		return false;
+	}
+	return true;
+}
+
+experimental::Type TypeInference::memberType(Type _type, std::string _memberName, langutil::SourceLocation _location)
+{
+	Type resolvedType = m_env->resolve(_type);
+	TypeSystemHelpers helper{m_typeSystem};
+	if (helper.isTypeConstant(resolvedType))
+	{
+		auto constructor = std::get<0>(helper.destTypeConstant(resolvedType));
+		if (auto* typeMember = util::valueOrNullptr(annotation().members.at(constructor), _memberName))
+			return polymorphicInstance(typeMember->type);
+		else
+		{
+			m_errorReporter.typeError(5755_error, _location, fmt::format("Member {} not found in type {}.", _memberName, TypeEnvironmentHelpers{*m_env}.typeToString(_type)));
+			return m_typeSystem.freshTypeVariable({});
+		}
+	}
+	else
+	{
+		m_errorReporter.typeError(5104_error, _location, "Unsupported member access expression.");
+		return m_typeSystem.freshTypeVariable({});
+	}
+}
+
+void TypeInference::endVisit(MemberAccess const& _memberAccess)
+{
+	auto& memberAccessAnnotation = annotation(_memberAccess);
+	solAssert(!memberAccessAnnotation.type);
+	Type expressionType = type(_memberAccess.expression());
+	memberAccessAnnotation.type = memberType(expressionType, _memberAccess.memberName(), _memberAccess.location());
+}
+
+bool TypeInference::visit(TypeDefinition const& _typeDefinition)
+{
+	bool isBuiltIn = dynamic_cast<Builtin const*>(_typeDefinition.typeExpression());
+
+	TypeSystemHelpers helper{m_typeSystem};
+	auto& typeDefinitionAnnotation = annotation(_typeDefinition);
+	if (typeDefinitionAnnotation.type)
+		return false;
+
+	if (_typeDefinition.arguments())
+		_typeDefinition.arguments()->accept(*this);
+
+	std::vector<Type> arguments;
+	if (_typeDefinition.arguments())
+		for (size_t i = 0; i < _typeDefinition.arguments()->parameters().size(); ++i)
+			arguments.emplace_back(m_typeSystem.freshTypeVariable({}));
+
+	Type definedType = type(&_typeDefinition, arguments);
+	if (arguments.empty())
+		typeDefinitionAnnotation.type = definedType;
+	else
+		typeDefinitionAnnotation.type = helper.typeFunctionType(helper.tupleType(arguments), definedType);
+
+	std::optional<Type> underlyingType;
+
+	if (isBuiltIn)
+		// TODO: This special case should eventually become user-definable.
+		underlyingType = m_wordType;
+	else if (_typeDefinition.typeExpression())
+	{
+		ScopedSaveAndRestore expressionContext{m_expressionContext, ExpressionContext::Type};
+		_typeDefinition.typeExpression()->accept(*this);
+
+		underlyingType = annotation(*_typeDefinition.typeExpression()).type;
+	}
+
+	TypeConstructor constructor = typeConstructor(&_typeDefinition);
+	auto [members, newlyInserted] = annotation().members.emplace(constructor, std::map<std::string, TypeMember>{});
+	solAssert(newlyInserted, fmt::format("Members of type '{}' are already defined.", m_typeSystem.constructorInfo(constructor).name));
+	if (underlyingType)
+	{
+		members->second.emplace("abs", TypeMember{helper.functionType(*underlyingType, definedType)});
+		members->second.emplace("rep", TypeMember{helper.functionType(definedType, *underlyingType)});
+	}
+
+	if (helper.isPrimitiveType(definedType, PrimitiveType::Pair))
+	{
+		solAssert(isBuiltIn);
+		solAssert(arguments.size() == 2);
+		members->second.emplace("first", TypeMember{helper.functionType(definedType, arguments[0])});
+		members->second.emplace("second", TypeMember{helper.functionType(definedType, arguments[1])});
+	}
+
+	return false;
+}
+
+bool TypeInference::visit(FunctionCall const&) { return true; }
+void TypeInference::endVisit(FunctionCall const& _functionCall)
+{
+	auto& functionCallAnnotation = annotation(_functionCall);
+	solAssert(!functionCallAnnotation.type);
+
+	Type functionType = type(_functionCall.expression());
+
+	TypeSystemHelpers helper{m_typeSystem};
+	std::vector<Type> argTypes;
+	for (auto arg: _functionCall.arguments())
+	{
+		switch (m_expressionContext)
+		{
+		case ExpressionContext::Term:
+		case ExpressionContext::Type:
+			argTypes.emplace_back(type(*arg));
+			break;
+		case ExpressionContext::Sort:
+			m_errorReporter.typeError(9173_error, _functionCall.location(), "Function call in sort context.");
+			functionCallAnnotation.type = m_typeSystem.freshTypeVariable({});
+			break;
+		}
+	}
+
+	switch (m_expressionContext)
+	{
+	case ExpressionContext::Term:
+	{
+		Type argTuple = helper.tupleType(argTypes);
+		Type resultType = m_typeSystem.freshTypeVariable({});
+		Type genericFunctionType = helper.functionType(argTuple, resultType);
+		unify(functionType, genericFunctionType, _functionCall.location());
+		functionCallAnnotation.type = resultType;
+		break;
+	}
+	case ExpressionContext::Type:
+	{
+		Type argTuple = helper.tupleType(argTypes);
+		Type resultType = m_typeSystem.freshTypeVariable({});
+		Type genericFunctionType = helper.typeFunctionType(argTuple, resultType);
+		unify(functionType, genericFunctionType, _functionCall.location());
+		functionCallAnnotation.type = resultType;
+		break;
+	}
+	case ExpressionContext::Sort:
+		solAssert(false);
+	}
+}
+
+// TODO: clean up rational parsing
+namespace
+{
+
+std::optional<rational> parseRational(std::string const& _value)
+{
+	rational value;
+	try
+	{
+		auto radixPoint = find(_value.begin(), _value.end(), '.');
+
+		if (radixPoint != _value.end())
+		{
+			if (
+				!all_of(radixPoint + 1, _value.end(), util::isDigit) ||
+				!all_of(_value.begin(), radixPoint, util::isDigit)
+			)
+				return std::nullopt;
+
+			// Only decimal notation allowed here, leading zeros would switch to octal.
+			auto fractionalBegin = find_if_not(
+				radixPoint + 1,
+				_value.end(),
+				[](char const& a) { return a == '0'; }
+			);
+
+			rational numerator;
+			rational denominator(1);
+
+			denominator = bigint(std::string(fractionalBegin, _value.end()));
+			denominator /= boost::multiprecision::pow(
+				bigint(10),
+				static_cast<unsigned>(distance(radixPoint + 1, _value.end()))
+			);
+			numerator = bigint(std::string(_value.begin(), radixPoint));
+			value = numerator + denominator;
+		}
+		else
+			value = bigint(_value);
+		return value;
+	}
+	catch (...)
+	{
+		return std::nullopt;
+	}
+}
+
+/// Checks whether _mantissa * (10 ** _expBase10) fits into 4096 bits.
+bool fitsPrecisionBase10(bigint const& _mantissa, uint32_t _expBase10)
+{
+	double const log2Of10AwayFromZero = 3.3219280948873624;
+	return fitsPrecisionBaseX(_mantissa, log2Of10AwayFromZero, _expBase10);
+}
+
+std::optional<rational> rationalValue(Literal const& _literal)
+{
+	rational value;
+	try
+	{
+		ASTString valueString = _literal.valueWithoutUnderscores();
+
+		auto expPoint = find(valueString.begin(), valueString.end(), 'e');
+		if (expPoint == valueString.end())
+			expPoint = find(valueString.begin(), valueString.end(), 'E');
+
+		if (boost::starts_with(valueString, "0x"))
+		{
+			// process as hex
+			value = bigint(valueString);
+		}
+		else if (expPoint != valueString.end())
+		{
+			// Parse mantissa and exponent. Checks numeric limit.
+			std::optional<rational> mantissa = parseRational(std::string(valueString.begin(), expPoint));
+
+			if (!mantissa)
+				return std::nullopt;
+			value = *mantissa;
+
+			// 0E... is always zero.
+			if (value == 0)
+				return std::nullopt;
+
+			bigint exp = bigint(std::string(expPoint + 1, valueString.end()));
+
+			if (exp > std::numeric_limits<int32_t>::max() || exp < std::numeric_limits<int32_t>::min())
+				return std::nullopt;
+
+			uint32_t expAbs = bigint(abs(exp)).convert_to<uint32_t>();
+
+			if (exp < 0)
+			{
+				if (!fitsPrecisionBase10(abs(value.denominator()), expAbs))
+					return std::nullopt;
+				value /= boost::multiprecision::pow(
+					bigint(10),
+					expAbs
+				);
+			}
+			else if (exp > 0)
+			{
+				if (!fitsPrecisionBase10(abs(value.numerator()), expAbs))
+					return std::nullopt;
+				value *= boost::multiprecision::pow(
+					bigint(10),
+					expAbs
+				);
+			}
+		}
+		else
+		{
+			// parse as rational number
+			std::optional<rational> tmp = parseRational(valueString);
+			if (!tmp)
+				return std::nullopt;
+			value = *tmp;
+		}
+	}
+	catch (...)
+	{
+		return std::nullopt;
+	}
+	switch (_literal.subDenomination())
+	{
+	case Literal::SubDenomination::None:
+	case Literal::SubDenomination::Second:
+		break;
+	case Literal::SubDenomination::Minute:
+		value *= bigint("60");
+		break;
+	case Literal::SubDenomination::Hour:
+		value *= bigint("3600");
+		break;
+	case Literal::SubDenomination::Day:
+		value *= bigint("86400");
+		break;
+	case Literal::SubDenomination::Week:
+		value *= bigint("604800");
+		break;
+	case Literal::SubDenomination::Year:
+		value *= bigint("31536000");
+		break;
+	default:
+		solUnimplemented("TODO DELETE: ADD another cases!");
+	}
+
+	return value;
+}
+}
+
+bool TypeInference::visit(Literal const& _literal)
+{
+	auto& literalAnnotation = annotation(_literal);
+	if (_literal.token() != Token::Number)
+	{
+		m_errorReporter.typeError(4316_error, _literal.location(), "Only number literals are supported.");
+		return false;
+	}
+	std::optional<rational> value = rationalValue(_literal);
+	if (!value)
+	{
+		m_errorReporter.typeError(6739_error, _literal.location(), "Invalid number literals.");
+		return false;
+	}
+	if (value->denominator() != 1)
+	{
+		m_errorReporter.typeError(2345_error, _literal.location(), "Only integers are supported.");
+		return false;
+	}
+	literalAnnotation.type = m_typeSystem.freshTypeVariable(Sort{{annotation().builtinClasses.at(BuiltinClass::Integer)}});
+	return false;
+}
+
+
+namespace
+{
+// TODO: put at a nice place to deduplicate.
+TypeRegistration::TypeClassInstantiations const& typeClassInstantiations(Analysis const& _analysis, TypeClass _class)
+{
+	auto const* typeClassDeclaration = _analysis.typeSystem().typeClassDeclaration(_class);
+	if (typeClassDeclaration)
+		return _analysis.annotation<TypeRegistration>(*typeClassDeclaration).instantiations;
+	// TODO: better mechanism than fetching by name.
+	auto const& annotation = _analysis.annotation<TypeRegistration>();
+	auto const& inferenceAnnotation = _analysis.annotation<TypeInference>();
+	return annotation.builtinClassInstantiations.at(
+		inferenceAnnotation.builtinClassesByName.at(
+			_analysis.typeSystem().typeClassName(_class)
+		)
+	);
+}
+}
+
+experimental::Type TypeInference::polymorphicInstance(Type const& _scheme)
+{
+	return m_env->fresh(_scheme);
+}
+
+void TypeInference::unify(Type _a, Type _b, langutil::SourceLocation _location)
+{
+	TypeSystemHelpers helper{m_typeSystem};
+	auto unificationFailures = m_env->unify(_a, _b);
+
+	if (!m_activeInstantiations.empty())
+	{
+		// TODO: This entire logic is superfluous - I thought mutually recursive dependencies between
+		// class instantiations are a problem, but in fact they're not, they just resolve to mutually recursive
+		// functions that are fine. So instead, all instantiations can be registered with the type system directly
+		// when visiting the type class (assuming that they all work out) - and then all instantiations can be checked
+		// individually, which should still catch all actual issues (while allowing recursions).
+		// Original comment: Attempt to resolve interdependencies between type class instantiations.
+		std::vector<TypeClassInstantiation const*> missingInstantiations;
+		bool recursion = false;
+		bool onlyMissingInstantiations = [&]() {
+			for (auto failure: unificationFailures)
+			{
+				if (auto* sortMismatch = std::get_if<TypeEnvironment::SortMismatch>(&failure))
+					if (helper.isTypeConstant(sortMismatch->type))
+					{
+						TypeConstructor constructor = std::get<0>(helper.destTypeConstant(sortMismatch->type));
+						for (auto typeClass: sortMismatch->sort.classes)
+						{
+							if (auto const* instantiation = util::valueOrDefault(typeClassInstantiations(m_analysis, typeClass), constructor, nullptr))
+							{
+								if (m_activeInstantiations.count(instantiation))
+								{
+									langutil::SecondarySourceLocation ssl;
+									for (auto activeInstantiation: m_activeInstantiations)
+										ssl.append("Involved instantiation", activeInstantiation->location());
+									m_errorReporter.typeError(
+										3573_error,
+										_location,
+										ssl,
+										"Recursion during type class instantiation."
+									);
+									recursion = true;
+									return false;
+								}
+								missingInstantiations.emplace_back(instantiation);
+							}
+							else
+								return false;
+						}
+						continue;
+					}
+				return false;
+			}
+			return true;
+		}();
+
+		if (recursion)
+			return;
+
+		if (onlyMissingInstantiations)
+		{
+			for (auto instantiation: missingInstantiations)
+				instantiation->accept(*this);
+			unificationFailures = m_env->unify(_a, _b);
+		}
+	}
+
+	for (auto failure: unificationFailures)
+	{
+		TypeEnvironmentHelpers envHelper{*m_env};
+		std::visit(util::GenericVisitor{
+			[&](TypeEnvironment::TypeMismatch _typeMismatch) {
+				m_errorReporter.typeError(
+					8456_error,
+					_location,
+					fmt::format(
+						"Cannot unify {} and {}.",
+						envHelper.typeToString(_typeMismatch.a),
+						envHelper.typeToString(_typeMismatch.b)
+					)
+				);
+			},
+			[&](TypeEnvironment::SortMismatch _sortMismatch) {
+				m_errorReporter.typeError(3111_error, _location, fmt::format(
+					"{} does not have sort {}",
+					envHelper.typeToString(_sortMismatch.type),
+					TypeSystemHelpers{m_typeSystem}.sortToString(_sortMismatch.sort)
+				));
+			},
+			[&](TypeEnvironment::RecursiveUnification _recursiveUnification) {
+				m_errorReporter.typeError(
+					6460_error,
+					_location,
+					fmt::format(
+						"Recursive unification: {} occurs in {}.",
+						envHelper.typeToString(_recursiveUnification.var),
+						envHelper.typeToString(_recursiveUnification.type)
+					)
+				);
+			}
+		}, failure);
+	}
+}
+
+experimental::Type TypeInference::type(ASTNode const& _node) const
+{
+	auto result = annotation(_node).type;
+	solAssert(result);
+	return *result;
+}
+TypeConstructor TypeInference::typeConstructor(Declaration const* _type) const
+{
+	if (auto const& constructor = m_analysis.annotation<TypeRegistration>(*_type).typeConstructor)
+		return *constructor;
+	m_errorReporter.fatalTypeError(5904_error, _type->location(), "Unregistered type.");
+	util::unreachable();
+}
+experimental::Type TypeInference::type(Declaration const* _type, std::vector<Type> _arguments) const
+{
+	return m_typeSystem.type(typeConstructor(_type), std::move(_arguments));
+}
+
+bool TypeInference::visitNode(ASTNode const& _node)
+{
+	m_errorReporter.fatalTypeError(5348_error, _node.location(), "Unsupported AST node during type inference.");
+	return false;
+}
+
+TypeInference::Annotation& TypeInference::annotation(ASTNode const& _node)
+{
+	return m_analysis.annotation<TypeInference>(_node);
+}
+
+TypeInference::Annotation const& TypeInference::annotation(ASTNode const& _node) const
+{
+	return m_analysis.annotation<TypeInference>(_node);
+}
+
+TypeInference::GlobalAnnotation& TypeInference::annotation()
+{
+	return m_analysis.annotation<TypeInference>();
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeInference.h b/compiler/libsolidity/experimental/analysis/TypeInference.h
new file mode 100644
index 00000000..ae86de5f
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeInference.h
@@ -0,0 +1,123 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/experimental/ast/TypeSystem.h>
+
+#include <liblangutil/ErrorReporter.h>
+
+namespace solidity::frontend::experimental
+{
+
+class Analysis;
+
+class TypeInference: public ASTConstVisitor
+{
+public:
+	TypeInference(Analysis& _analysis);
+
+	bool analyze(SourceUnit const& _sourceUnit);
+
+	struct Annotation
+	{
+		/// Expressions, variable declarations, function declarations.
+		std::optional<Type> type;
+	};
+	struct TypeMember
+	{
+		Type type;
+	};
+	struct GlobalAnnotation
+	{
+		std::map<BuiltinClass, TypeClass> builtinClasses;
+		std::map<std::string, BuiltinClass> builtinClassesByName;
+		std::map<TypeClass, std::map<std::string, Type>> typeClassFunctions;
+		std::map<Token, std::tuple<TypeClass, std::string>> operators;
+		std::map<TypeConstructor, std::map<std::string, TypeMember>> members;
+	};
+	bool visit(Block const&) override { return true; }
+	bool visit(VariableDeclarationStatement const&) override { return true; }
+	void endVisit(VariableDeclarationStatement const& _variableDeclarationStatement) override;
+	bool visit(VariableDeclaration const& _variableDeclaration) override;
+
+	bool visit(FunctionDefinition const& _functionDefinition) override;
+	bool visit(ParameterList const&) override { return true; }
+	void endVisit(ParameterList const& _parameterList) override;
+	bool visit(SourceUnit const&) override { return true; }
+	bool visit(ContractDefinition const&) override { return true; }
+	bool visit(ImportDirective const&) override { return true; }
+	bool visit(PragmaDirective const&) override { return false; }
+
+	bool visit(IfStatement const&) override { return true; }
+	void endVisit(IfStatement const& _ifStatement) override;
+	bool visit(ExpressionStatement const&) override { return true; }
+	bool visit(Assignment const&) override { return true; }
+	void endVisit(Assignment const& _assignment) override;
+	bool visit(Identifier const&) override;
+	bool visit(IdentifierPath const&) override;
+	bool visit(FunctionCall const& _functionCall) override;
+	void endVisit(FunctionCall const& _functionCall) override;
+	bool visit(Return const&) override { return true; }
+	void endVisit(Return const& _return) override;
+
+	bool visit(MemberAccess const& _memberAccess) override;
+	void endVisit(MemberAccess const& _memberAccess) override;
+
+	bool visit(TypeClassDefinition const& _typeClassDefinition) override;
+	bool visit(TypeClassInstantiation const& _typeClassInstantiation) override;
+	bool visit(TupleExpression const&) override { return true; }
+	void endVisit(TupleExpression const& _tupleExpression) override;
+	bool visit(TypeDefinition const& _typeDefinition) override;
+
+	bool visitNode(ASTNode const& _node) override;
+
+	bool visit(BinaryOperation const& _operation) override;
+
+	bool visit(Literal const& _literal) override;
+private:
+	Analysis& m_analysis;
+	langutil::ErrorReporter& m_errorReporter;
+	TypeSystem& m_typeSystem;
+	TypeEnvironment* m_env = nullptr;
+	Type m_voidType;
+	Type m_wordType;
+	Type m_integerType;
+	Type m_unitType;
+	Type m_boolType;
+	std::optional<Type> m_currentFunctionType;
+
+	Type type(ASTNode const& _node) const;
+
+	Annotation& annotation(ASTNode const& _node);
+	Annotation const& annotation(ASTNode const& _node) const;
+	GlobalAnnotation& annotation();
+
+	void unify(Type _a, Type _b, langutil::SourceLocation _location = {});
+	/// Creates a polymorphic instance of a global type scheme
+	Type polymorphicInstance(Type const& _scheme);
+	Type memberType(Type _type, std::string _memberName, langutil::SourceLocation _location = {});
+	enum class ExpressionContext { Term, Type, Sort };
+	Type handleIdentifierByReferencedDeclaration(langutil::SourceLocation _location, Declaration const& _declaration);
+	TypeConstructor typeConstructor(Declaration const* _type) const;
+	Type type(Declaration const* _type, std::vector<Type> _arguments) const;
+	ExpressionContext m_expressionContext = ExpressionContext::Term;
+	std::set<TypeClassInstantiation const*, ASTCompareByID<TypeClassInstantiation>> m_activeInstantiations;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeRegistration.cpp b/compiler/libsolidity/experimental/analysis/TypeRegistration.cpp
new file mode 100644
index 00000000..e9ac5286
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeRegistration.cpp
@@ -0,0 +1,207 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolidity/experimental/analysis/TypeRegistration.h>
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+#include <liblangutil/Exceptions.h>
+
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+using namespace solidity::langutil;
+
+TypeRegistration::TypeRegistration(Analysis& _analysis):
+	m_analysis(_analysis),
+	m_errorReporter(_analysis.errorReporter()),
+	m_typeSystem(_analysis.typeSystem())
+{
+}
+
+bool TypeRegistration::analyze(SourceUnit const& _sourceUnit)
+{
+	_sourceUnit.accept(*this);
+	return !m_errorReporter.hasErrors();
+}
+
+bool TypeRegistration::visit(TypeClassDefinition const& _typeClassDefinition)
+{
+	if (annotation(_typeClassDefinition).typeConstructor)
+		return false;
+	annotation(_typeClassDefinition).typeConstructor = m_typeSystem.declareTypeConstructor(
+		_typeClassDefinition.name(),
+		"t_" + *_typeClassDefinition.annotation().canonicalName + "_" + util::toString(_typeClassDefinition.id()),
+		0,
+		&_typeClassDefinition
+	);
+	return true;
+}
+
+bool TypeRegistration::visit(Builtin const& _builtin)
+{
+	if (annotation(_builtin).typeConstructor)
+		return false;
+
+	auto primitiveType = [&](std::string _name) -> std::optional<PrimitiveType> {
+		if (_name == "void") return PrimitiveType::Void;
+		if (_name == "fun") return PrimitiveType::Function;
+		if (_name == "unit") return PrimitiveType::Unit;
+		if (_name == "pair") return PrimitiveType::Pair;
+		if (_name == "word") return PrimitiveType::Word;
+		if (_name == "integer") return PrimitiveType::Integer;
+		if (_name == "bool") return PrimitiveType::Bool;
+		return std::nullopt;
+	}(_builtin.nameParameter());
+
+	if (!primitiveType.has_value())
+		m_errorReporter.fatalTypeError(
+			7758_error,
+			_builtin.location(),
+			"Expected the name of a built-in primitive type."
+		);
+
+	annotation(_builtin).typeConstructor = m_typeSystem.constructor(primitiveType.value());
+	return true;
+}
+
+void TypeRegistration::endVisit(ElementaryTypeNameExpression const & _typeNameExpression)
+{
+	if (annotation(_typeNameExpression).typeConstructor)
+		return;
+
+	// TODO: this is not visited in the ElementaryTypeNameExpression visit - is that intentional?
+	_typeNameExpression.type().accept(*this);
+	if (auto constructor = annotation(_typeNameExpression.type()).typeConstructor)
+		annotation(_typeNameExpression).typeConstructor = constructor;
+	else
+		solAssert(m_errorReporter.hasErrors());
+}
+
+bool TypeRegistration::visit(UserDefinedTypeName const& _userDefinedTypeName)
+{
+	if (annotation(_userDefinedTypeName).typeConstructor)
+		return false;
+	auto const* declaration = _userDefinedTypeName.pathNode().annotation().referencedDeclaration;
+	if (!declaration)
+	{
+		// TODO: fatal/non-fatal
+		m_errorReporter.fatalTypeError(5096_error, _userDefinedTypeName.pathNode().location(), "Expected declaration.");
+		return false;
+	}
+	declaration->accept(*this);
+	if (!(annotation(_userDefinedTypeName).typeConstructor = annotation(*declaration).typeConstructor))
+	{
+		// TODO: fatal/non-fatal
+		m_errorReporter.fatalTypeError(9831_error, _userDefinedTypeName.pathNode().location(), "Expected type declaration.");
+		return false;
+	}
+	return true;
+}
+
+bool TypeRegistration::visit(TypeClassInstantiation const& _typeClassInstantiation)
+{
+	if (annotation(_typeClassInstantiation).typeConstructor)
+		return false;
+	_typeClassInstantiation.typeConstructor().accept(*this);
+	auto typeConstructor = annotation(_typeClassInstantiation.typeConstructor()).typeConstructor;
+	if (!typeConstructor)
+	{
+		m_errorReporter.typeError(5577_error, _typeClassInstantiation.typeConstructor().location(), "Invalid type name.");
+		return false;
+	}
+	auto* instantiations = std::visit(util::GenericVisitor{
+		[&](ASTPointer<IdentifierPath> _path) -> TypeClassInstantiations*
+		{
+			if (TypeClassDefinition const* classDefinition = dynamic_cast<TypeClassDefinition const*>(_path->annotation().referencedDeclaration))
+				return &annotation(*classDefinition).instantiations;
+			m_errorReporter.typeError(3570_error, _typeClassInstantiation.typeClass().location(), "Expected a type class.");
+			return nullptr;
+		},
+		[&](Token _token) -> TypeClassInstantiations*
+		{
+			if (auto typeClass = builtinClassFromToken(_token))
+				return &annotation().builtinClassInstantiations[*typeClass];
+			m_errorReporter.typeError(5262_error, _typeClassInstantiation.typeClass().location(), "Expected a type class.");
+			return nullptr;
+		}
+	}, _typeClassInstantiation.typeClass().name());
+
+	if (!instantiations)
+		return false;
+
+	if (
+		auto [instantiation, newlyInserted] = instantiations->emplace(*typeConstructor, &_typeClassInstantiation);
+		!newlyInserted
+	)
+	{
+		SecondarySourceLocation ssl;
+		ssl.append("Previous instantiation.", instantiation->second->location());
+		m_errorReporter.typeError(6620_error, _typeClassInstantiation.location(), ssl, "Duplicate type class instantiation.");
+	}
+
+	return true;
+}
+
+bool TypeRegistration::visit(TypeDefinition const& _typeDefinition)
+{
+	return !annotation(_typeDefinition).typeConstructor.has_value();
+}
+
+void TypeRegistration::endVisit(TypeDefinition const& _typeDefinition)
+{
+	if (annotation(_typeDefinition).typeConstructor.has_value())
+		return;
+
+	if (auto const* builtin = dynamic_cast<Builtin const*>(_typeDefinition.typeExpression()))
+	{
+		auto [previousDefinitionIt, inserted] = annotation().builtinTypeDefinitions.try_emplace(
+			builtin->nameParameter(),
+			&_typeDefinition
+		);
+
+		if (inserted)
+			annotation(_typeDefinition).typeConstructor = annotation(*builtin).typeConstructor;
+		else
+		{
+			auto const& [builtinName, previousDefinition] = *previousDefinitionIt;
+			m_errorReporter.typeError(
+				9609_error,
+				_typeDefinition.location(),
+				SecondarySourceLocation{}.append("Previous definition:", previousDefinition->location()),
+				"Duplicate builtin type definition."
+			);
+		}
+	}
+	else
+		annotation(_typeDefinition).typeConstructor = m_typeSystem.declareTypeConstructor(
+			_typeDefinition.name(),
+			"t_" + *_typeDefinition.annotation().canonicalName + "_" + util::toString(_typeDefinition.id()),
+			_typeDefinition.arguments() ? _typeDefinition.arguments()->parameters().size() : 0,
+			&_typeDefinition
+		);
+}
+
+TypeRegistration::Annotation& TypeRegistration::annotation(ASTNode const& _node)
+{
+	return m_analysis.annotation<TypeRegistration>(_node);
+}
+
+TypeRegistration::GlobalAnnotation& TypeRegistration::annotation()
+{
+	return m_analysis.annotation<TypeRegistration>();
+}
diff --git a/compiler/libsolidity/experimental/analysis/TypeRegistration.h b/compiler/libsolidity/experimental/analysis/TypeRegistration.h
new file mode 100644
index 00000000..9bc49a29
--- /dev/null
+++ b/compiler/libsolidity/experimental/analysis/TypeRegistration.h
@@ -0,0 +1,67 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/experimental/ast/TypeSystem.h>
+
+#include <liblangutil/ErrorReporter.h>
+
+namespace solidity::frontend::experimental
+{
+
+class Analysis;
+
+class TypeRegistration: public ASTConstVisitor
+{
+public:
+	using TypeClassInstantiations = std::map<TypeConstructor, TypeClassInstantiation const*>;
+	struct Annotation
+	{
+		// For type class definitions.
+		TypeClassInstantiations instantiations;
+		// For builtins, type definitions, type class definitions, type names and type name expressions.
+		std::optional<TypeConstructor> typeConstructor;
+	};
+	struct GlobalAnnotation
+	{
+		std::map<PrimitiveClass, TypeClassInstantiations> primitiveClassInstantiations;
+		std::map<BuiltinClass, TypeClassInstantiations> builtinClassInstantiations;
+		std::map<std::string, TypeDefinition const*> builtinTypeDefinitions;
+	};
+	TypeRegistration(Analysis& _analysis);
+
+	bool analyze(SourceUnit const& _sourceUnit);
+private:
+	bool visit(TypeClassDefinition const& _typeClassDefinition) override;
+	bool visit(TypeClassInstantiation const& _typeClassInstantiation) override;
+	bool visit(TypeDefinition const& _typeDefinition) override;
+	void endVisit(TypeDefinition const& _typeDefinition) override;
+	bool visit(UserDefinedTypeName const& _typeName) override;
+	void endVisit(ElementaryTypeNameExpression const& _typeName) override;
+	bool visit(Builtin const& _builtin) override;
+	Annotation& annotation(ASTNode const& _node);
+	GlobalAnnotation& annotation();
+
+	Analysis& m_analysis;
+	langutil::ErrorReporter& m_errorReporter;
+	TypeSystem& m_typeSystem;
+	std::set<int64_t> m_visitedClasses;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/ast/FunctionCallGraph.h b/compiler/libsolidity/experimental/ast/FunctionCallGraph.h
new file mode 100644
index 00000000..0a1db845
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/FunctionCallGraph.h
@@ -0,0 +1,40 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Data structure representing a function dependency graph.
+
+#pragma once
+
+#include <libsolidity/ast/AST.h>
+
+#include <map>
+#include <set>
+#include <ostream>
+
+namespace solidity::frontend::experimental
+{
+
+struct FunctionDependencyGraph
+{
+	/// Graph edges. Edges are directed and lead from the caller to the callee.
+	/// The map contains a key for every function, even if does not actually perform
+	/// any calls.
+	std::map<FunctionDefinition const*, std::set<FunctionDefinition const*, ASTCompareByID<FunctionDefinition>>, ASTCompareByID<FunctionDefinition>> edges;
+};
+
+}
diff --git a/compiler/libsolidity/experimental/ast/Type.cpp b/compiler/libsolidity/experimental/ast/Type.cpp
new file mode 100644
index 00000000..ec822dc6
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/Type.cpp
@@ -0,0 +1,62 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/experimental/ast/Type.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/view/drop_last.hpp>
+#include <range/v3/view/zip.hpp>
+
+#include <sstream>
+
+using namespace solidity;
+using namespace solidity::frontend::experimental;
+
+bool Sort::operator==(Sort const& _rhs) const
+{
+	if (classes.size() != _rhs.classes.size())
+		return false;
+	for (auto [lhs, rhs]: ranges::zip_view(classes, _rhs.classes))
+		if (lhs != rhs)
+			return false;
+	return true;
+}
+
+bool Sort::operator<=(Sort const& _rhs) const
+{
+	for (auto c: classes)
+		if (!_rhs.classes.count(c))
+			return false;
+	return true;
+}
+
+Sort Sort::operator+(Sort const& _rhs) const
+{
+	Sort result { classes };
+	result.classes += _rhs.classes;
+	return result;
+}
+
+
+Sort Sort::operator-(Sort const& _rhs) const
+{
+	Sort result { classes };
+	result.classes -= _rhs.classes;
+	return result;
+}
diff --git a/compiler/libsolidity/experimental/ast/Type.h b/compiler/libsolidity/experimental/ast/Type.h
new file mode 100644
index 00000000..dde41b1d
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/Type.h
@@ -0,0 +1,154 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <cstddef>
+#include <set>
+#include <variant>
+#include <vector>
+
+namespace solidity::frontend::experimental
+{
+
+class TypeSystem;
+
+struct TypeConstant;
+struct TypeVariable;
+
+using Type = std::variant<std::monostate, TypeConstant, TypeVariable>;
+
+enum class PrimitiveType
+{
+	Void,
+	Function,
+	TypeFunction,
+	Itself,
+	Unit,
+	Pair,
+	Sum,
+	Word,
+	Bool,
+	Integer
+};
+
+enum class PrimitiveClass
+{
+	Type
+};
+
+// TODO: move elsewhere?
+enum class BuiltinClass
+{
+	Integer,
+	Mul,
+	Add,
+	Equal,
+	Less,
+	LessOrEqual,
+	Greater,
+	GreaterOrEqual
+};
+
+struct TypeConstructor
+{
+public:
+	TypeConstructor(TypeConstructor const& _typeConstructor): m_index(_typeConstructor.m_index) {}
+	TypeConstructor& operator=(TypeConstructor const& _typeConstructor)
+	{
+		m_index = _typeConstructor.m_index;
+		return *this;
+	}
+	bool operator<(TypeConstructor const& _rhs) const
+	{
+		return m_index < _rhs.m_index;
+	}
+	bool operator==(TypeConstructor const& _rhs) const
+	{
+		return m_index == _rhs.m_index;
+	}
+	bool operator!=(TypeConstructor const& _rhs) const
+	{
+		return m_index != _rhs.m_index;
+	}
+private:
+	friend class TypeSystem;
+	TypeConstructor(std::size_t _index): m_index(_index) {}
+	std::size_t m_index = 0;
+};
+
+struct TypeConstant
+{
+	TypeConstructor constructor;
+	std::vector<Type> arguments;
+};
+
+struct TypeClass
+{
+public:
+	TypeClass(TypeClass const& _typeClass): m_index(_typeClass.m_index) {}
+	TypeClass& operator=(TypeClass const& _typeConstructor)
+	{
+		m_index = _typeConstructor.m_index;
+		return *this;
+	}
+	bool operator<(TypeClass const& _rhs) const
+	{
+		return m_index < _rhs.m_index;
+	}
+	bool operator==(TypeClass const& _rhs) const
+	{
+		return m_index == _rhs.m_index;
+	}
+	bool operator!=(TypeClass const& _rhs) const
+	{
+		return m_index != _rhs.m_index;
+	}
+private:
+	friend class TypeSystem;
+	TypeClass(std::size_t _index): m_index(_index) {}
+	std::size_t m_index = 0;
+};
+
+struct Sort
+{
+	std::set<TypeClass> classes;
+	bool operator==(Sort const& _rhs) const;
+	bool operator!=(Sort const& _rhs) const { return !operator==(_rhs); }
+	bool operator<=(Sort const& _rhs) const;
+	Sort operator+(Sort const& _rhs) const;
+	Sort operator-(Sort const& _rhs) const;
+};
+
+struct Arity
+{
+	std::vector<Sort> argumentSorts;
+	TypeClass typeClass;
+};
+
+struct TypeVariable
+{
+	std::size_t index() const { return m_index; }
+	Sort const& sort() const { return m_sort; }
+private:
+	friend class TypeSystem;
+	std::size_t m_index = 0;
+	Sort m_sort;
+	TypeVariable(std::size_t _index, Sort _sort): m_index(_index), m_sort(std::move(_sort)) {}
+};
+
+}
diff --git a/compiler/libsolidity/experimental/ast/TypeSystem.cpp b/compiler/libsolidity/experimental/ast/TypeSystem.cpp
new file mode 100644
index 00000000..680edce8
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/TypeSystem.cpp
@@ -0,0 +1,347 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolidity/experimental/ast/TypeSystem.h>
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+#include <libsolidity/ast/AST.h>
+#include <liblangutil/Exceptions.h>
+
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/to_container.hpp>
+#include <range/v3/view/drop_exactly.hpp>
+#include <range/v3/view/drop_last.hpp>
+#include <range/v3/view/reverse.hpp>
+#include <range/v3/view/zip.hpp>
+
+#include <fmt/format.h>
+
+#include <unordered_map>
+
+using namespace solidity;
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+
+std::vector<TypeEnvironment::UnificationFailure> TypeEnvironment::unify(Type _a, Type _b)
+{
+	std::vector<UnificationFailure> failures;
+	auto unificationFailure = [&]() {
+		failures.emplace_back(UnificationFailure{TypeMismatch{_a, _b}});
+	};
+	_a = resolve(_a);
+	_b = resolve(_b);
+	std::visit(util::GenericVisitor{
+		[&](TypeVariable _left, TypeVariable _right) {
+			if (_left.index() == _right.index())
+				solAssert(_left.sort() == _right.sort());
+			else
+			{
+				if (_left.sort() <= _right.sort())
+					failures += instantiate(_left, _right);
+				else if (_right.sort() <= _left.sort())
+					failures += instantiate(_right, _left);
+				else
+				{
+					Type newVar = m_typeSystem.freshVariable(_left.sort() + _right.sort());
+					failures += instantiate(_left, newVar);
+					failures += instantiate(_right, newVar);
+				}
+			}
+		},
+		[&](TypeVariable _var, auto) {
+			failures += instantiate(_var, _b);
+		},
+		[&](auto, TypeVariable _var) {
+			failures += instantiate(_var, _a);
+		},
+		[&](TypeConstant _left, TypeConstant _right) {
+			if (_left.constructor != _right.constructor)
+				return unificationFailure();
+			if (_left.arguments.size() != _right.arguments.size())
+				return unificationFailure();
+			for (auto&& [left, right]: ranges::zip_view(_left.arguments, _right.arguments))
+				failures += unify(left, right);
+		},
+		[&](auto, auto) {
+			unificationFailure();
+		}
+	}, _a, _b);
+	return failures;
+}
+
+bool TypeEnvironment::typeEquals(Type _lhs, Type _rhs) const
+{
+	return std::visit(util::GenericVisitor{
+		[&](TypeVariable _left, TypeVariable _right) {
+			if (_left.index() == _right.index())
+			{
+				solAssert(_left.sort() == _right.sort());
+				return true;
+			}
+			return false;
+		},
+		[&](TypeConstant _left, TypeConstant _right) {
+			if (_left.constructor != _right.constructor)
+				return false;
+			if (_left.arguments.size() != _right.arguments.size())
+				return false;
+			for (auto&& [left, right]: ranges::zip_view(_left.arguments, _right.arguments))
+				if (!typeEquals(left, right))
+					return false;
+			return true;
+		},
+		[&](auto, auto) {
+			return false;
+		}
+	}, resolve(_lhs), resolve(_rhs));
+}
+
+TypeEnvironment TypeEnvironment::clone() const
+{
+	TypeEnvironment result{m_typeSystem};
+	result.m_typeVariables = m_typeVariables;
+	return result;
+}
+
+TypeSystem::TypeSystem()
+{
+	auto declarePrimitiveClass = [&](std::string _name) {
+		return std::visit(util::GenericVisitor{
+			[](std::string _error) -> TypeClass {
+				solAssert(false, _error);
+			},
+			[](TypeClass _class) -> TypeClass { return _class; }
+		}, declareTypeClass(_name, nullptr, true /* _primitive */));
+	};
+
+	m_primitiveTypeClasses.emplace(PrimitiveClass::Type, declarePrimitiveClass("type"));
+
+	for (auto [type, name, arity]: std::initializer_list<std::tuple<PrimitiveType, char const*, size_t>>{
+		{PrimitiveType::TypeFunction, "tfun", 2},
+		{PrimitiveType::Function, "fun", 2},
+		{PrimitiveType::Itself, "itself", 1},
+		{PrimitiveType::Void, "void", 0},
+		{PrimitiveType::Unit, "unit", 0},
+		{PrimitiveType::Pair, "pair", 2},
+		{PrimitiveType::Sum, "sum", 2},
+		{PrimitiveType::Word, "word", 0},
+		{PrimitiveType::Integer, "integer", 0},
+		{PrimitiveType::Bool, "bool", 0},
+	})
+		m_primitiveTypeConstructors.emplace(type, declareTypeConstructor(name, name, arity, nullptr));
+
+	TypeClass classType = primitiveClass(PrimitiveClass::Type);
+	//TypeClass classKind = primitiveClass(PrimitiveClass::Kind);
+	Sort typeSort{{classType}};
+	m_typeConstructors.at(m_primitiveTypeConstructors.at(PrimitiveType::TypeFunction).m_index).arities = {Arity{std::vector<Sort>{{typeSort},{typeSort}}, classType}};
+	m_typeConstructors.at(m_primitiveTypeConstructors.at(PrimitiveType::Function).m_index).arities = {Arity{std::vector<Sort>{{typeSort, typeSort}}, classType}};
+	m_typeConstructors.at(m_primitiveTypeConstructors.at(PrimitiveType::Itself).m_index).arities = {Arity{std::vector<Sort>{{typeSort, typeSort}}, classType}};
+}
+
+experimental::Type TypeSystem::freshVariable(Sort _sort)
+{
+	size_t index = m_numTypeVariables++;
+	return TypeVariable(index, std::move(_sort));
+}
+
+experimental::Type TypeSystem::freshTypeVariable(Sort _sort)
+{
+	_sort.classes.emplace(primitiveClass(PrimitiveClass::Type));
+	return freshVariable(_sort);
+}
+
+std::vector<TypeEnvironment::UnificationFailure> TypeEnvironment::instantiate(TypeVariable _variable, Type _type)
+{
+	for (auto const& maybeTypeVar: TypeEnvironmentHelpers{*this}.typeVars(_type))
+		if (auto const* typeVar = std::get_if<TypeVariable>(&maybeTypeVar))
+			if (typeVar->index() == _variable.index())
+				return {UnificationFailure{RecursiveUnification{_variable, _type}}};
+	Sort typeSort = sort(_type);
+	if (!(_variable.sort() <= typeSort))
+	{
+		return {UnificationFailure{SortMismatch{_type, _variable.sort() - typeSort}}};
+	}
+	solAssert(m_typeVariables.emplace(_variable.index(), _type).second);
+	return {};
+}
+
+experimental::Type TypeEnvironment::resolve(Type _type) const
+{
+	Type result = _type;
+	while (auto const* var = std::get_if<TypeVariable>(&result))
+		if (Type const* resolvedType = util::valueOrNullptr(m_typeVariables, var->index()))
+			result = *resolvedType;
+		else
+			break;
+	return result;
+}
+
+experimental::Type TypeEnvironment::resolveRecursive(Type _type) const
+{
+	return std::visit(util::GenericVisitor{
+		[&](TypeConstant const& _typeConstant) -> Type {
+			return TypeConstant{
+				_typeConstant.constructor,
+				_typeConstant.arguments | ranges::views::transform([&](Type const& _argType) {
+					return resolveRecursive(_argType);
+				}) | ranges::to<std::vector<Type>>
+			};
+		},
+		[](TypeVariable const& _typeVar) -> Type {
+			return _typeVar;
+		},
+		[](std::monostate _nothing) -> Type {
+			return _nothing;
+		}
+	}, resolve(_type));
+}
+
+Sort TypeEnvironment::sort(Type _type) const
+{
+	return std::visit(util::GenericVisitor{
+		[&](TypeConstant const& _expression) -> Sort
+		{
+			auto const& constructorInfo = m_typeSystem.constructorInfo(_expression.constructor);
+			auto argumentSorts = _expression.arguments | ranges::views::transform([&](Type _argumentType) {
+				return sort(resolve(_argumentType));
+			}) | ranges::to<std::vector<Sort>>;
+			Sort sort;
+			for (auto const& arity: constructorInfo.arities)
+			{
+				solAssert(arity.argumentSorts.size() == argumentSorts.size());
+				bool hasArity = true;
+				for (auto&& [argumentSort, arityArgumentSort]: ranges::zip_view(argumentSorts, arity.argumentSorts))
+				{
+					if (!(arityArgumentSort <= argumentSort))
+					{
+						hasArity = false;
+						break;
+					}
+				}
+
+				if (hasArity)
+					sort.classes.insert(arity.typeClass);
+			}
+			return sort;
+		},
+		[](TypeVariable const& _variable) -> Sort { return _variable.sort(); },
+		[](std::monostate) -> Sort { solAssert(false); }
+	}, _type);
+}
+
+TypeConstructor TypeSystem::declareTypeConstructor(std::string _name, std::string _canonicalName, size_t _arguments, Declaration const* _declaration)
+{
+	solAssert(m_canonicalTypeNames.insert(_canonicalName).second, "Duplicate canonical type name.");
+	Sort baseSort{{primitiveClass(PrimitiveClass::Type)}};
+	size_t index = m_typeConstructors.size();
+	m_typeConstructors.emplace_back(TypeConstructorInfo{
+		_name,
+		_canonicalName,
+		{Arity{std::vector<Sort>{_arguments, baseSort}, primitiveClass(PrimitiveClass::Type)}},
+		_declaration
+	});
+	TypeConstructor constructor{index};
+	if (_arguments)
+	{
+		std::vector<Sort> argumentSorts;
+		std::generate_n(std::back_inserter(argumentSorts), _arguments, [&](){ return Sort{{primitiveClass(PrimitiveClass::Type)}}; });
+		std::vector<Type> argumentTypes;
+		std::generate_n(std::back_inserter(argumentTypes), _arguments, [&](){ return freshVariable({}); });
+		auto error = instantiateClass(type(constructor, argumentTypes), Arity{argumentSorts, primitiveClass(PrimitiveClass::Type)});
+		solAssert(!error, *error);
+	}
+	else
+	{
+		auto error = instantiateClass(type(constructor, {}), Arity{{}, primitiveClass(PrimitiveClass::Type)});
+		solAssert(!error, *error);
+	}
+	return constructor;
+}
+
+std::variant<TypeClass, std::string> TypeSystem::declareTypeClass(std::string _name, Declaration const* _declaration, bool _primitive)
+{
+	TypeClass typeClass{m_typeClasses.size()};
+
+	Type typeVariable = (_primitive ? freshVariable({{typeClass}}) : freshTypeVariable({{typeClass}}));
+	solAssert(std::holds_alternative<TypeVariable>(typeVariable));
+
+	m_typeClasses.emplace_back(TypeClassInfo{
+		typeVariable,
+		_name,
+		_declaration
+	});
+	return typeClass;
+}
+
+experimental::Type TypeSystem::type(TypeConstructor _constructor, std::vector<Type> _arguments) const
+{
+	// TODO: proper error handling
+	auto const& info = m_typeConstructors.at(_constructor.m_index);
+	solAssert(
+		info.arguments() == _arguments.size(),
+		fmt::format("Type constructor '{}' accepts {} type arguments (got {}).", constructorInfo(_constructor).name, info.arguments(), _arguments.size())
+	);
+	return TypeConstant{_constructor, _arguments};
+}
+
+experimental::Type TypeEnvironment::fresh(Type _type)
+{
+	std::unordered_map<size_t, Type> mapping;
+	auto freshImpl = [&](Type _type, auto _recurse) -> Type {
+		return std::visit(util::GenericVisitor{
+			[&](TypeConstant const& _type) -> Type {
+				return TypeConstant{
+					_type.constructor,
+					_type.arguments | ranges::views::transform([&](Type _argType) {
+						return _recurse(_argType, _recurse);
+					}) | ranges::to<std::vector<Type>>
+				};
+			},
+			[&](TypeVariable const& _var) -> Type {
+				if (auto* mapped = util::valueOrNullptr(mapping, _var.index()))
+				{
+					auto* typeVariable = std::get_if<TypeVariable>(mapped);
+					solAssert(typeVariable);
+					// TODO: can there be a mismatch?
+					solAssert(typeVariable->sort() == _var.sort());
+					return *mapped;
+				}
+				return mapping[_var.index()] = m_typeSystem.freshTypeVariable(_var.sort());
+			},
+			[](std::monostate) -> Type { solAssert(false); }
+		}, resolve(_type));
+	};
+	return freshImpl(_type, freshImpl);
+}
+
+std::optional<std::string> TypeSystem::instantiateClass(Type _instanceVariable, Arity _arity)
+{
+	if (!TypeSystemHelpers{*this}.isTypeConstant(_instanceVariable))
+		return "Invalid instance variable.";
+	auto [typeConstructor, typeArguments] = TypeSystemHelpers{*this}.destTypeConstant(_instanceVariable);
+	auto& typeConstructorInfo = m_typeConstructors.at(typeConstructor.m_index);
+	if (_arity.argumentSorts.size() != typeConstructorInfo.arguments())
+		return "Invalid arity.";
+	if (typeArguments.size() != typeConstructorInfo.arguments())
+		return "Invalid arity.";
+
+	typeConstructorInfo.arities.emplace_back(_arity);
+
+	return std::nullopt;
+}
diff --git a/compiler/libsolidity/experimental/ast/TypeSystem.h b/compiler/libsolidity/experimental/ast/TypeSystem.h
new file mode 100644
index 00000000..cac0feb8
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/TypeSystem.h
@@ -0,0 +1,184 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/experimental/ast/Type.h>
+#include <liblangutil/Exceptions.h>
+
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace solidity::frontend
+{
+class Declaration;
+}
+
+namespace solidity::frontend::experimental
+{
+
+class TypeEnvironment
+{
+public:
+	struct TypeMismatch
+	{
+		Type a;
+		Type b;
+	};
+
+	struct SortMismatch {
+		Type type;
+		Sort sort;
+	};
+
+	struct RecursiveUnification
+	{
+		Type var;
+		Type type;
+	};
+
+	using UnificationFailure = std::variant<
+		TypeMismatch,
+		SortMismatch,
+		RecursiveUnification
+	>;
+
+	TypeEnvironment(TypeSystem& _typeSystem): m_typeSystem(_typeSystem) {}
+	TypeEnvironment(TypeEnvironment const&) = delete;
+	TypeEnvironment& operator=(TypeEnvironment const&) = delete;
+	TypeEnvironment clone() const;
+
+	Type resolve(Type _type) const;
+	Type resolveRecursive(Type _type) const;
+	Type fresh(Type _type);
+	[[nodiscard]] std::vector<UnificationFailure> unify(Type _a, Type _b);
+	Sort sort(Type _type) const;
+	bool typeEquals(Type _lhs, Type _rhs) const;
+
+	TypeSystem& typeSystem() { return m_typeSystem; }
+	TypeSystem const& typeSystem() const { return m_typeSystem; }
+
+private:
+	TypeEnvironment(TypeEnvironment&& _env):
+		m_typeSystem(_env.m_typeSystem),
+		m_typeVariables(std::move(_env.m_typeVariables))
+	{}
+
+	[[nodiscard]] std::vector<TypeEnvironment::UnificationFailure> instantiate(TypeVariable _variable, Type _type);
+
+	TypeSystem& m_typeSystem;
+	std::map<size_t, Type> m_typeVariables;
+};
+
+class TypeSystem
+{
+public:
+	struct TypeConstructorInfo
+	{
+		std::string name;
+		std::string canonicalName;
+		std::vector<Arity> arities;
+		Declaration const* typeDeclaration = nullptr;
+		size_t arguments() const
+		{
+			solAssert(!arities.empty());
+			return arities.front().argumentSorts.size();
+		}
+	};
+	struct TypeClassInfo
+	{
+		Type typeVariable;
+		std::string name;
+		Declaration const* classDeclaration = nullptr;
+	};
+	TypeSystem();
+	TypeSystem(TypeSystem const&) = delete;
+	TypeSystem const& operator=(TypeSystem const&) = delete;
+	Type type(PrimitiveType _typeConstructor, std::vector<Type> _arguments) const
+	{
+		return type(m_primitiveTypeConstructors.at(_typeConstructor), std::move(_arguments));
+	}
+	Type type(TypeConstructor _typeConstructor, std::vector<Type> _arguments) const;
+	std::string typeName(TypeConstructor _typeConstructor) const
+	{
+		// TODO: proper error handling
+		return m_typeConstructors.at(_typeConstructor.m_index).name;
+	}
+	std::string canonicalName(TypeConstructor _typeConstructor) const
+	{
+		// TODO: proper error handling
+		return m_typeConstructors.at(_typeConstructor.m_index).canonicalName;
+	}
+	TypeConstructor declareTypeConstructor(std::string _name, std::string _canonicalName, size_t _arguments, Declaration const* _declaration);
+	TypeConstructor constructor(PrimitiveType _type) const
+	{
+		return m_primitiveTypeConstructors.at(_type);
+	}
+	TypeClass primitiveClass(PrimitiveClass _class) const
+	{
+		return m_primitiveTypeClasses.at(_class);
+	}
+	size_t constructorArguments(TypeConstructor _typeConstructor) const
+	{
+		// TODO: error handling
+		return m_typeConstructors.at(_typeConstructor.m_index).arguments();
+	}
+	TypeConstructorInfo const& constructorInfo(TypeConstructor _typeConstructor) const
+	{
+		// TODO: error handling
+		return m_typeConstructors.at(_typeConstructor.m_index);
+	}
+	TypeConstructorInfo const& constructorInfo(PrimitiveType _typeConstructor) const
+	{
+		return constructorInfo(constructor(_typeConstructor));
+	}
+
+	std::variant<TypeClass, std::string> declareTypeClass(std::string _name, Declaration const* _declaration, bool _primitive = false);
+	[[nodiscard]] std::optional<std::string> instantiateClass(Type _instanceVariable, Arity _arity);
+
+	Type freshTypeVariable(Sort _sort);
+
+	TypeEnvironment const& env() const { return m_globalTypeEnvironment; }
+	TypeEnvironment& env() { return m_globalTypeEnvironment; }
+
+	Type freshVariable(Sort _sort);
+	std::string typeClassName(TypeClass _class) const { return m_typeClasses.at(_class.m_index).name; }
+	Declaration const* typeClassDeclaration(TypeClass _class) const { return m_typeClasses.at(_class.m_index).classDeclaration; }
+	Type typeClassVariable(TypeClass _class) const
+	{
+		return m_typeClasses.at(_class.m_index).typeVariable;
+	}
+
+	TypeClassInfo const& typeClassInfo(TypeClass _class) const
+	{
+		return m_typeClasses.at(_class.m_index);
+	}
+
+private:
+	friend class TypeEnvironment;
+	size_t m_numTypeVariables = 0;
+	std::map<PrimitiveType, TypeConstructor> m_primitiveTypeConstructors;
+	std::map<PrimitiveClass, TypeClass> m_primitiveTypeClasses;
+	std::set<std::string> m_canonicalTypeNames;
+	std::vector<TypeConstructorInfo> m_typeConstructors;
+	std::vector<TypeClassInfo> m_typeClasses;
+	TypeEnvironment m_globalTypeEnvironment{*this};
+};
+
+}
diff --git a/compiler/libsolidity/experimental/ast/TypeSystemHelper.cpp b/compiler/libsolidity/experimental/ast/TypeSystemHelper.cpp
new file mode 100644
index 00000000..bc7dd4fc
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/TypeSystemHelper.cpp
@@ -0,0 +1,404 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+#include <libsolidity/ast/AST.h>
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/TypeRegistration.h>
+
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/to_container.hpp>
+#include <range/v3/view/drop_exactly.hpp>
+#include <range/v3/view/drop_last.hpp>
+#include <range/v3/view/reverse.hpp>
+
+#include <fmt/format.h>
+
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::experimental;
+
+/*std::optional<TypeConstructor> experimental::typeConstructorFromTypeName(Analysis const& _analysis, TypeName const& _typeName)
+{
+	if (auto const* elementaryTypeName = dynamic_cast<ElementaryTypeName const*>(&_typeName))
+	{
+		if (auto constructor = typeConstructorFromToken(_analysis, elementaryTypeName->typeName().token()))
+			return *constructor;
+	}
+	else if (auto const* userDefinedType = dynamic_cast<UserDefinedTypeName const*>(&_typeName))
+	{
+		if (auto const* referencedDeclaration = userDefinedType->pathNode().annotation().referencedDeclaration)
+			return _analysis.annotation<TypeRegistration>(*referencedDeclaration).typeConstructor;
+	}
+	return nullopt;
+}*/
+/*
+std::optional<TypeConstructor> experimental::typeConstructorFromToken(Analysis const& _analysis, langutil::Token _token)
+{
+	TypeSystem const& typeSystem = _analysis.typeSystem();
+	switch (_token)
+	{
+	case Token::Void:
+		return typeSystem.builtinConstructor(BuiltinType::Void);
+	case Token::Fun:
+		return typeSystem.builtinConstructor(BuiltinType::Function);
+	case Token::Unit:
+		return typeSystem.builtinConstructor(BuiltinType::Unit);
+	case Token::Pair:
+		return typeSystem.builtinConstructor(BuiltinType::Pair);
+	case Token::Word:
+		return typeSystem.builtinConstructor(BuiltinType::Word);
+	case Token::IntegerType:
+		return typeSystem.builtinConstructor(BuiltinType::Integer);
+	case Token::Bool:
+		return typeSystem.builtinConstructor(BuiltinType::Bool);
+	default:
+		return nullopt;
+	}
+}*/
+
+std::optional<BuiltinClass> experimental::builtinClassFromToken(langutil::Token _token)
+{
+	switch (_token)
+	{
+	case Token::Integer:
+		return BuiltinClass::Integer;
+	case Token::Mul:
+		return BuiltinClass::Mul;
+	case Token::Add:
+		return BuiltinClass::Add;
+	case Token::Equal:
+		return BuiltinClass::Equal;
+	case Token::LessThan:
+		return BuiltinClass::Less;
+	case Token::LessThanOrEqual:
+		return BuiltinClass::LessOrEqual;
+	case Token::GreaterThan:
+		return BuiltinClass::Greater;
+	case Token::GreaterThanOrEqual:
+		return BuiltinClass::GreaterOrEqual;
+	default:
+		return std::nullopt;
+	}
+}
+/*
+std::optional<TypeClass> experimental::typeClassFromTypeClassName(TypeClassName const& _typeClass)
+{
+	return std::visit(util::GenericVisitor{
+		[&](ASTPointer<IdentifierPath> _path) -> optional<TypeClass> {
+			auto classDefinition = dynamic_cast<TypeClassDefinition const*>(_path->annotation().referencedDeclaration);
+			if (!classDefinition)
+				return nullopt;
+			return TypeClass{classDefinition};
+		},
+		[&](Token _token) -> optional<TypeClass> {
+			return typeClassFromToken(_token);
+		}
+	}, _typeClass.name());
+}
+*/
+experimental::Type TypeSystemHelpers::tupleType(std::vector<Type> _elements) const
+{
+	if (_elements.empty())
+		return typeSystem.type(PrimitiveType::Unit, {});
+	if (_elements.size() == 1)
+		return _elements.front();
+	Type result = _elements.back();
+	for (Type type: _elements | ranges::views::reverse | ranges::views::drop_exactly(1))
+		result = typeSystem.type(PrimitiveType::Pair, {type, result});
+	return result;
+}
+
+std::vector<experimental::Type> TypeSystemHelpers::destTupleType(Type _tupleType) const
+{
+	if (!isTypeConstant(_tupleType))
+		return {_tupleType};
+	TypeConstructor pairConstructor = typeSystem.constructor(PrimitiveType::Pair);
+	auto [constructor, arguments] = destTypeConstant(_tupleType);
+	if (constructor == typeSystem.constructor(PrimitiveType::Unit))
+		return {};
+	if (constructor != pairConstructor)
+		return {_tupleType};
+	solAssert(arguments.size() == 2);
+
+	std::vector<Type> result;
+	result.emplace_back(arguments.front());
+	Type tail = arguments.back();
+	while (true)
+	{
+		if (!isTypeConstant(tail))
+			break;
+		auto [tailConstructor, tailArguments] = destTypeConstant(tail);
+		if (tailConstructor != pairConstructor)
+			break;
+		solAssert(tailArguments.size() == 2);
+		result.emplace_back(tailArguments.front());
+		tail = tailArguments.back();
+	}
+	result.emplace_back(tail);
+	return result;
+}
+
+experimental::Type TypeSystemHelpers::sumType(std::vector<Type> _elements) const
+{
+	if (_elements.empty())
+		return typeSystem.type(PrimitiveType::Void, {});
+	if (_elements.size() == 1)
+		return _elements.front();
+	Type result = _elements.back();
+	for (Type type: _elements | ranges::views::reverse | ranges::views::drop_exactly(1))
+		result = typeSystem.type(PrimitiveType::Sum, {type, result});
+	return result;
+}
+
+std::vector<experimental::Type> TypeSystemHelpers::destSumType(Type _tupleType) const
+{
+	if (!isTypeConstant(_tupleType))
+		return {_tupleType};
+	TypeConstructor sumConstructor = typeSystem.constructor(PrimitiveType::Sum);
+	auto [constructor, arguments] = destTypeConstant(_tupleType);
+	if (constructor == typeSystem.constructor(PrimitiveType::Void))
+		return {};
+	if (constructor != sumConstructor)
+		return {_tupleType};
+	solAssert(arguments.size() == 2);
+
+	std::vector<Type> result;
+	result.emplace_back(arguments.front());
+	Type tail = arguments.back();
+	while (true)
+	{
+		if (!isTypeConstant(tail))
+			break;
+		auto [tailConstructor, tailArguments] = destTypeConstant(tail);
+		if (tailConstructor != sumConstructor)
+			break;
+		solAssert(tailArguments.size() == 2);
+		result.emplace_back(tailArguments.front());
+		tail = tailArguments.back();
+	}
+	result.emplace_back(tail);
+	return result;
+}
+
+std::tuple<TypeConstructor, std::vector<experimental::Type>> TypeSystemHelpers::destTypeConstant(Type _type) const
+{
+	using ResultType = std::tuple<TypeConstructor, std::vector<Type>>;
+	return std::visit(util::GenericVisitor{
+		[&](TypeConstant const& _type) -> ResultType {
+			return std::make_tuple(_type.constructor, _type.arguments);
+		},
+		[](auto const&) -> ResultType {
+			solAssert(false);
+		}
+	}, _type);
+}
+
+bool TypeSystemHelpers::isTypeConstant(Type _type) const
+{
+	return std::visit(util::GenericVisitor{
+		[&](TypeConstant const&) -> bool {
+			return true;
+		},
+		[](auto const&) -> bool {
+			return false;
+		}
+	}, _type);
+}
+
+bool TypeSystemHelpers::isPrimitiveType(Type _type, PrimitiveType _primitiveType) const
+{
+	if (!isTypeConstant(_type))
+		return false;
+	auto constructor = std::get<0>(destTypeConstant(_type));
+	return constructor == typeSystem.constructor(_primitiveType);
+}
+
+experimental::Type TypeSystemHelpers::functionType(experimental::Type _argType, experimental::Type _resultType) const
+{
+	return typeSystem.type(PrimitiveType::Function, {_argType, _resultType});
+}
+
+std::tuple<experimental::Type, experimental::Type> TypeSystemHelpers::destFunctionType(Type _functionType) const
+{
+	auto [constructor, arguments] = destTypeConstant(_functionType);
+	solAssert(constructor == typeSystem.constructor(PrimitiveType::Function));
+	solAssert(arguments.size() == 2);
+	return std::make_tuple(arguments.front(), arguments.back());
+}
+
+bool TypeSystemHelpers::isFunctionType(Type _type) const
+{
+	return isPrimitiveType(_type, PrimitiveType::Function);
+}
+
+experimental::Type TypeSystemHelpers::typeFunctionType(experimental::Type _argType, experimental::Type _resultType) const
+{
+	return typeSystem.type(PrimitiveType::TypeFunction, {_argType, _resultType});
+}
+
+std::tuple<experimental::Type, experimental::Type> TypeSystemHelpers::destTypeFunctionType(Type _functionType) const
+{
+	auto [constructor, arguments] = destTypeConstant(_functionType);
+	solAssert(constructor == typeSystem.constructor(PrimitiveType::TypeFunction));
+	solAssert(arguments.size() == 2);
+	return std::make_tuple(arguments.front(), arguments.back());
+}
+
+bool TypeSystemHelpers::isTypeFunctionType(Type _type) const
+{
+	return isPrimitiveType(_type, PrimitiveType::TypeFunction);
+}
+
+std::vector<experimental::Type> TypeEnvironmentHelpers::typeVars(Type _type) const
+{
+	std::set<size_t> indices;
+	std::vector<Type> typeVars;
+	auto typeVarsImpl = [&](Type _type, auto _recurse) -> void {
+		std::visit(util::GenericVisitor{
+			[&](TypeConstant const& _type) {
+				for (auto arg: _type.arguments)
+					_recurse(arg, _recurse);
+			},
+			[&](TypeVariable const& _var) {
+				if (indices.emplace(_var.index()).second)
+					typeVars.emplace_back(_var);
+			},
+			[](std::monostate) { solAssert(false); }
+		}, env.resolve(_type));
+	};
+	typeVarsImpl(_type, typeVarsImpl);
+	return typeVars;
+
+}
+
+
+std::string TypeSystemHelpers::sortToString(Sort _sort) const
+{
+	switch (_sort.classes.size())
+	{
+	case 0:
+		return "()";
+	case 1:
+		return typeSystem.typeClassName(*_sort.classes.begin());
+	default:
+	{
+		std::stringstream stream;
+		stream << "(";
+		for (auto typeClass: _sort.classes | ranges::views::drop_last(1))
+			stream << typeSystem.typeClassName(typeClass) << ", ";
+		stream << typeSystem.typeClassName(*_sort.classes.rbegin()) << ")";
+		return stream.str();
+	}
+	}
+}
+
+std::string TypeEnvironmentHelpers::canonicalTypeName(Type _type) const
+{
+	return visit(util::GenericVisitor{
+		[&](TypeConstant _type) -> std::string {
+			std::stringstream stream;
+			stream << env.typeSystem().constructorInfo(_type.constructor).canonicalName;
+			if (!_type.arguments.empty())
+			{
+				stream << "$";
+				for (auto type: _type.arguments | ranges::views::drop_last(1))
+					stream << canonicalTypeName(type) << "$";
+				stream << canonicalTypeName(_type.arguments.back());
+				stream << "$";
+			}
+			return stream.str();
+		},
+		[](TypeVariable) -> std::string {
+			solAssert(false);
+		},
+		[](std::monostate) -> std::string {
+			solAssert(false);
+		},
+	}, env.resolve(_type));
+}
+
+std::string TypeEnvironmentHelpers::typeToString(Type const& _type) const
+{
+	std::map<TypeConstructor, std::function<std::string(std::vector<Type>)>> formatters{
+		{env.typeSystem().constructor(PrimitiveType::Function), [&](auto const& _args) {
+			solAssert(_args.size() == 2);
+			return fmt::format("{} -> {}", typeToString(_args.front()), typeToString(_args.back()));
+		}},
+		{env.typeSystem().constructor(PrimitiveType::Unit), [&](auto const& _args) {
+			solAssert(_args.size() == 0);
+			return "()";
+		}},
+		{env.typeSystem().constructor(PrimitiveType::Pair), [&](auto const& _arguments) {
+			auto tupleTypes = TypeSystemHelpers{env.typeSystem()}.destTupleType(_arguments.back());
+			std::string result = "(";
+			result += typeToString(_arguments.front());
+			for (auto type: tupleTypes)
+				result += ", " + typeToString(type);
+			result += ")";
+			return result;
+		}},
+	};
+	return std::visit(util::GenericVisitor{
+		[&](TypeConstant const& _type) {
+			if (auto* formatter = util::valueOrNullptr(formatters, _type.constructor))
+				return (*formatter)(_type.arguments);
+			std::stringstream stream;
+			stream << env.typeSystem().constructorInfo(_type.constructor).name;
+			if (!_type.arguments.empty())
+			{
+				stream << "(";
+				for (auto type: _type.arguments | ranges::views::drop_last(1))
+					stream << typeToString(type) << ", ";
+				stream << typeToString(_type.arguments.back());
+				stream << ")";
+			}
+			return stream.str();
+		},
+		[&](TypeVariable const& _type) {
+			std::stringstream stream;
+			std::string varName;
+			size_t index = _type.index();
+			varName += static_cast<char>('a' + (index%26));
+			while (index /= 26)
+				varName += static_cast<char>('a' + (index%26));
+			reverse(varName.begin(), varName.end());
+			stream << '\'' << varName;
+			switch (_type.sort().classes.size())
+			{
+			case 0:
+				break;
+			case 1:
+				stream << ":" << env.typeSystem().typeClassName(*_type.sort().classes.begin());
+				break;
+			default:
+				stream << ":(";
+				for (auto typeClass: _type.sort().classes | ranges::views::drop_last(1))
+					stream << env.typeSystem().typeClassName(typeClass) << ", ";
+				stream << env.typeSystem().typeClassName(*_type.sort().classes.rbegin());
+				stream << ")";
+				break;
+			}
+			return stream.str();
+		},
+		[](std::monostate) -> std::string { solAssert(false); }
+	}, env.resolve(_type));
+}
diff --git a/compiler/libsolidity/experimental/ast/TypeSystemHelper.h b/compiler/libsolidity/experimental/ast/TypeSystemHelper.h
new file mode 100644
index 00000000..fd55c1bf
--- /dev/null
+++ b/compiler/libsolidity/experimental/ast/TypeSystemHelper.h
@@ -0,0 +1,60 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/experimental/ast/TypeSystem.h>
+#include <libsolidity/ast/ASTForward.h>
+#include <liblangutil/Token.h>
+
+namespace solidity::frontend::experimental
+{
+class Analysis;
+enum class BuiltinClass;
+//std::optional<TypeConstructor> typeConstructorFromTypeName(Analysis const& _analysis, TypeName const& _typeName);
+//std::optional<TypeConstructor> typeConstructorFromToken(Analysis const& _analysis, langutil::Token _token);
+//std::optional<TypeClass> typeClassFromTypeClassName(TypeClassName const& _typeClass);
+std::optional<BuiltinClass> builtinClassFromToken(langutil::Token _token);
+
+struct TypeSystemHelpers
+{
+	TypeSystem const& typeSystem;
+	std::tuple<TypeConstructor, std::vector<Type>> destTypeConstant(Type _type) const;
+	bool isTypeConstant(Type _type) const;
+	bool isPrimitiveType(Type _type, PrimitiveType _primitiveType) const;
+	Type tupleType(std::vector<Type> _elements) const;
+	std::vector<Type> destTupleType(Type _tupleType) const;
+	Type sumType(std::vector<Type> _elements) const;
+	std::vector<Type> destSumType(Type _tupleType) const;
+	Type functionType(Type _argType, Type _resultType) const;
+	std::tuple<Type, Type> destFunctionType(Type _functionType) const;
+	bool isFunctionType(Type _type) const;
+	Type typeFunctionType(Type _argType, Type _resultType) const;
+	std::tuple<Type, Type> destTypeFunctionType(Type _functionType) const;
+	bool isTypeFunctionType(Type _type) const;
+	std::string sortToString(Sort _sort) const;
+};
+
+struct TypeEnvironmentHelpers
+{
+	TypeEnvironment const& env;
+	std::string typeToString(Type const& _type) const;
+	std::string canonicalTypeName(Type _type) const;
+	std::vector<Type> typeVars(Type _type) const;
+};
+
+}
diff --git a/compiler/libsolidity/formal/ArraySlicePredicate.cpp b/compiler/libsolidity/formal/ArraySlicePredicate.cpp
new file mode 100644
index 00000000..21d5fb1a
--- /dev/null
+++ b/compiler/libsolidity/formal/ArraySlicePredicate.cpp
@@ -0,0 +1,90 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/ArraySlicePredicate.h>
+
+#include <liblangutil/Exceptions.h>
+
+using namespace solidity;
+using namespace solidity::smtutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+std::map<std::string, ArraySlicePredicate::SliceData> ArraySlicePredicate::m_slicePredicates;
+
+std::pair<bool, ArraySlicePredicate::SliceData const&> ArraySlicePredicate::create(SortPointer _sort, EncodingContext& _context)
+{
+	solAssert(_sort->kind == Kind::Tuple, "");
+	auto tupleSort = std::dynamic_pointer_cast<TupleSort>(_sort);
+	solAssert(tupleSort, "");
+
+	auto tupleName = tupleSort->name;
+	if (m_slicePredicates.count(tupleName))
+		return {true, m_slicePredicates.at(tupleName)};
+
+	auto sort = tupleSort->components.at(0);
+	solAssert(sort->kind == Kind::Array, "");
+
+	smt::SymbolicArrayVariable aVar{sort, "a_" + tupleName, _context };
+	smt::SymbolicArrayVariable bVar{sort, "b_" + tupleName, _context};
+	smt::SymbolicIntVariable startVar{TypeProvider::uint256(), TypeProvider::uint256(), "start_" + tupleName, _context};
+	smt::SymbolicIntVariable endVar{TypeProvider::uint256(), TypeProvider::uint256(), "end_" + tupleName, _context };
+	smt::SymbolicIntVariable iVar{TypeProvider::uint256(), TypeProvider::uint256(), "i_" + tupleName, _context};
+
+	std::vector<SortPointer> domain{sort, sort, startVar.sort(), endVar.sort()};
+	auto sliceSort = std::make_shared<FunctionSort>(domain, SortProvider::boolSort);
+	Predicate const& slice = *Predicate::create(sliceSort, "array_slice_" + tupleName, PredicateType::Custom, _context);
+
+	domain.emplace_back(iVar.sort());
+	auto predSort = std::make_shared<FunctionSort>(domain, SortProvider::boolSort);
+	Predicate const& header = *Predicate::create(predSort, "array_slice_header_" + tupleName, PredicateType::Custom, _context);
+	Predicate const& loop = *Predicate::create(predSort, "array_slice_loop_" + tupleName, PredicateType::Custom, _context);
+
+	auto a = aVar.elements();
+	auto b = bVar.elements();
+	auto start = startVar.currentValue();
+	auto end = endVar.currentValue();
+	auto i = iVar.currentValue();
+
+	auto rule1 = smtutil::Expression::implies(
+		end > start,
+		header({a, b, start, end, 0})
+	);
+
+	auto rule2 = smtutil::Expression::implies(
+		header({a, b, start, end, i}) && i >= (end - start),
+		slice({a, b, start, end})
+	);
+
+	auto rule3 = smtutil::Expression::implies(
+		header({a, b, start, end, i}) && i >= 0 && i < (end - start),
+		loop({a, b, start, end, i})
+	);
+
+	auto b_i = smtutil::Expression::select(b, i);
+	auto a_start_i = smtutil::Expression::select(a, start + i);
+	auto rule4 = smtutil::Expression::implies(
+		loop({a, b, start, end, i}) && b_i == a_start_i,
+		header({a, b, start, end, i + 1})
+	);
+
+	return {false, m_slicePredicates[tupleName] = {
+		{&slice, &header, &loop},
+		{std::move(rule1), std::move(rule2), std::move(rule3), std::move(rule4)}
+	}};
+}
diff --git a/compiler/libsolidity/formal/BMC.cpp b/compiler/libsolidity/formal/BMC.cpp
new file mode 100644
index 00000000..b16182af
--- /dev/null
+++ b/compiler/libsolidity/formal/BMC.cpp
@@ -0,0 +1,1329 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/BMC.h>
+
+#include <libsolidity/formal/SymbolicTypes.h>
+
+#include <libsmtutil/SMTPortfolio.h>
+
+#include <liblangutil/CharStream.h>
+#include <liblangutil/CharStreamProvider.h>
+
+#include <utility>
+
+#ifdef HAVE_Z3_DLOPEN
+#include <z3_version.h>
+#endif
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+
+BMC::BMC(
+	smt::EncodingContext& _context,
+	UniqueErrorReporter& _errorReporter,
+	UniqueErrorReporter& _unsupportedErrorReporter,
+	std::map<h256, std::string> const& _smtlib2Responses,
+	ReadCallback::Callback const& _smtCallback,
+	ModelCheckerSettings _settings,
+	CharStreamProvider const& _charStreamProvider
+):
+	SMTEncoder(_context, _settings, _errorReporter, _unsupportedErrorReporter, _charStreamProvider),
+	m_interface(std::make_unique<smtutil::SMTPortfolio>(
+		_smtlib2Responses, _smtCallback, _settings.solvers, _settings.timeout, _settings.printQuery
+	))
+{
+	solAssert(!_settings.printQuery || _settings.solvers == smtutil::SMTSolverChoice::SMTLIB2(), "Only SMTLib2 solver can be enabled to print queries");
+#if defined (HAVE_Z3) || defined (HAVE_CVC4)
+	if (m_settings.solvers.cvc4 || m_settings.solvers.z3)
+		if (!_smtlib2Responses.empty())
+			m_errorReporter.warning(
+				5622_error,
+				"SMT-LIB2 query responses were given in the auxiliary input, "
+				"but this Solidity binary uses an SMT solver (Z3/CVC4) directly."
+				"These responses will be ignored."
+				"Consider disabling Z3/CVC4 at compilation time in order to use SMT-LIB2 responses."
+			);
+#endif
+}
+
+void BMC::analyze(SourceUnit const& _source, std::map<ASTNode const*, std::set<VerificationTargetType>, smt::EncodingContext::IdCompare> _solvedTargets)
+{
+	// At this point every enabled solver is available.
+	if (!m_settings.solvers.cvc4 && !m_settings.solvers.smtlib2 && !m_settings.solvers.z3)
+	{
+		m_errorReporter.warning(
+			7710_error,
+			SourceLocation(),
+			"BMC analysis was not possible since no SMT solver was found and enabled."
+			" The accepted solvers for BMC are cvc4 and z3."
+		);
+		return;
+	}
+
+	SMTEncoder::resetSourceAnalysis();
+
+	state().prepareForSourceUnit(_source, false);
+	m_solvedTargets = std::move(_solvedTargets);
+	m_context.setSolver(m_interface.get());
+	m_context.reset();
+	m_context.setAssertionAccumulation(true);
+	m_variableUsage.setFunctionInlining(shouldInlineFunctionCall);
+	createFreeConstants(sourceDependencies(_source));
+	m_unprovedAmt = 0;
+
+	_source.accept(*this);
+
+	if (m_unprovedAmt > 0 && !m_settings.showUnproved)
+		m_errorReporter.warning(
+			2788_error,
+			{},
+			"BMC: " +
+			std::to_string(m_unprovedAmt) +
+			" verification condition(s) could not be proved." +
+			" Enable the model checker option \"show unproved\" to see all of them." +
+			" Consider choosing a specific contract to be verified in order to reduce the solving problems." +
+			" Consider increasing the timeout per query."
+		);
+
+	if (!m_settings.showProvedSafe && !m_safeTargets.empty())
+		m_errorReporter.info(
+			6002_error,
+			"BMC: " +
+			std::to_string(m_safeTargets.size()) +
+			" verification condition(s) proved safe!" +
+			" Enable the model checker option \"show proved safe\" to see all of them."
+		);
+	else if (m_settings.showProvedSafe)
+		for (auto const& [node, targets]: m_safeTargets)
+			for (auto const& target: targets)
+				m_errorReporter.info(
+					2961_error,
+					node->location(),
+					"BMC: " +
+					targetDescription(target) +
+					" check is safe!"
+				);
+
+
+	// If this check is true, Z3 and CVC4 are not available
+	// and the query answers were not provided, since SMTPortfolio
+	// guarantees that SmtLib2Interface is the first solver, if enabled.
+	if (
+		!m_interface->unhandledQueries().empty() &&
+		m_interface->solvers() == 1 &&
+		m_settings.solvers.smtlib2
+	)
+		m_errorReporter.warning(
+			8084_error,
+			SourceLocation(),
+			"BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available."
+			" None of the installed solvers was enabled."
+#ifdef HAVE_Z3_DLOPEN
+			" Install libz3.so." + std::to_string(Z3_MAJOR_VERSION) + "." + std::to_string(Z3_MINOR_VERSION) + " to enable Z3."
+#endif
+		);
+}
+
+bool BMC::shouldInlineFunctionCall(
+	FunctionCall const& _funCall,
+	ContractDefinition const* _scopeContract,
+	ContractDefinition const* _contextContract
+)
+{
+	auto funDef = functionCallToDefinition(_funCall, _scopeContract, _contextContract);
+	if (!funDef || !funDef->isImplemented())
+		return false;
+
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	if (funType.kind() == FunctionType::Kind::External)
+		return isExternalCallToThis(&_funCall.expression());
+	else if (funType.kind() != FunctionType::Kind::Internal)
+		return false;
+
+	return true;
+}
+
+/// AST visitors.
+
+bool BMC::visit(ContractDefinition const& _contract)
+{
+	initContract(_contract);
+
+	SMTEncoder::visit(_contract);
+
+	return false;
+}
+
+void BMC::endVisit(ContractDefinition const& _contract)
+{
+	if (auto constructor = _contract.constructor())
+		constructor->accept(*this);
+	else
+	{
+		/// Visiting implicit constructor - we need a dummy callstack frame
+		pushCallStack({nullptr, nullptr});
+		inlineConstructorHierarchy(_contract);
+		popCallStack();
+		/// Check targets created by state variable initialization.
+		checkVerificationTargets();
+		m_verificationTargets.clear();
+	}
+
+	SMTEncoder::endVisit(_contract);
+}
+
+bool BMC::visit(FunctionDefinition const& _function)
+{
+	// Free functions need to be visited in the context of a contract.
+	if (!m_currentContract)
+		return false;
+
+	auto contract = dynamic_cast<ContractDefinition const*>(_function.scope());
+	auto const& hierarchy = m_currentContract->annotation().linearizedBaseContracts;
+	if (contract && find(hierarchy.begin(), hierarchy.end(), contract) == hierarchy.end())
+		createStateVariables(*contract);
+
+	if (m_callStack.empty())
+	{
+		reset();
+		initFunction(_function);
+		if (_function.isConstructor() || _function.isPublic())
+			m_context.addAssertion(state().txTypeConstraints() && state().txFunctionConstraints(_function));
+		resetStateVariables();
+	}
+
+	if (_function.isConstructor())
+	{
+		solAssert(contract, "");
+		inlineConstructorHierarchy(*contract);
+	}
+
+	/// Already visits the children.
+	SMTEncoder::visit(_function);
+
+	return false;
+}
+
+void BMC::endVisit(FunctionDefinition const& _function)
+{
+	// Free functions need to be visited in the context of a contract.
+	if (!m_currentContract)
+		return;
+
+	if (isRootFunction())
+	{
+		checkVerificationTargets();
+		m_verificationTargets.clear();
+		m_pathConditions.clear();
+	}
+
+	SMTEncoder::endVisit(_function);
+}
+
+bool BMC::visit(IfStatement const& _node)
+{
+	auto indicesBeforePush = copyVariableIndices();
+	// This check needs to be done in its own context otherwise
+	// constraints from the If body might influence it.
+	m_context.pushSolver();
+	_node.condition().accept(*this);
+
+	// We ignore called functions here because they have
+	// specific input values.
+	if (isRootFunction() && !isInsideLoop())
+		addVerificationTarget(
+			VerificationTargetType::ConstantCondition,
+			expr(_node.condition()),
+			&_node.condition()
+		);
+	m_context.popSolver();
+	resetVariableIndices(std::move(indicesBeforePush));
+
+	_node.condition().accept(*this);
+	auto conditionExpr = expr(_node.condition());
+	// visit true branch
+	auto [indicesEndTrue, trueEndPathCondition] = visitBranch(&_node.trueStatement(), conditionExpr);
+
+	// visit false branch
+	decltype(indicesEndTrue) indicesEndFalse;
+	auto falseEndPathCondition = currentPathConditions() && !conditionExpr;
+	if (_node.falseStatement())
+		std::tie(indicesEndFalse, falseEndPathCondition) = visitBranch(_node.falseStatement(), !conditionExpr);
+	else
+		indicesEndFalse = copyVariableIndices();
+
+	// merge the information from branches
+	setPathCondition(trueEndPathCondition || falseEndPathCondition);
+	mergeVariables(expr(_node.condition()), indicesEndTrue, indicesEndFalse);
+
+	return false;
+}
+
+bool BMC::visit(Conditional const& _op)
+{
+	auto indicesBeforePush = copyVariableIndices();
+	m_context.pushSolver();
+	_op.condition().accept(*this);
+
+	if (isRootFunction() && !isInsideLoop())
+		addVerificationTarget(
+			VerificationTargetType::ConstantCondition,
+			expr(_op.condition()),
+			&_op.condition()
+		);
+	m_context.popSolver();
+	resetVariableIndices(std::move(indicesBeforePush));
+
+	SMTEncoder::visit(_op);
+
+	return false;
+}
+
+// Unrolls while or do-while loop
+bool BMC::visit(WhileStatement const& _node)
+{
+	unsigned int bmcLoopIterations = m_settings.bmcLoopIterations.value_or(1);
+	smtutil::Expression broke(false);
+	smtutil::Expression loopCondition(true);
+	if (_node.isDoWhile())
+	{
+		for (unsigned int i = 0; i < bmcLoopIterations; ++i)
+		{
+			m_loopCheckpoints.emplace();
+
+			auto indicesBefore = copyVariableIndices();
+			_node.body().accept(*this);
+
+			auto brokeInCurrentIteration = mergeVariablesFromLoopCheckpoints();
+
+			auto indicesBreak = copyVariableIndices();
+			_node.condition().accept(*this);
+			mergeVariables(
+				!brokeInCurrentIteration,
+				copyVariableIndices(),
+				indicesBreak
+			);
+
+			mergeVariables(
+				broke || !loopCondition,
+				indicesBefore,
+				copyVariableIndices()
+			);
+			loopCondition = loopCondition && expr(_node.condition());
+			broke = broke || brokeInCurrentIteration;
+			m_loopCheckpoints.pop();
+		}
+		if (bmcLoopIterations > 0)
+			m_context.addAssertion(!loopCondition || broke);
+	}
+	else {
+		smtutil::Expression loopConditionOnPreviousIterations(true);
+		for (unsigned int i = 0; i < bmcLoopIterations; ++i)
+		{
+			m_loopCheckpoints.emplace();
+			auto indicesBefore = copyVariableIndices();
+			_node.condition().accept(*this);
+			loopCondition = expr(_node.condition());
+
+			auto indicesAfterCondition = copyVariableIndices();
+
+			pushPathCondition(loopCondition);
+			_node.body().accept(*this);
+			popPathCondition();
+
+			auto brokeInCurrentIteration =	mergeVariablesFromLoopCheckpoints();
+
+			// merges indices modified when accepting loop condition that no longer holds
+			mergeVariables(
+				!loopCondition,
+				indicesAfterCondition,
+				copyVariableIndices()
+			);
+
+			// handles breaks in previous iterations
+			// breaks in current iterations are handled when traversing loop checkpoints
+			// handles case when the loop condition no longer holds but bmc loop iterations still unrolls the loop
+			mergeVariables(
+				broke || !loopConditionOnPreviousIterations,
+				indicesBefore,
+				copyVariableIndices()
+			);
+			m_loopCheckpoints.pop();
+			broke = broke || brokeInCurrentIteration;
+			loopConditionOnPreviousIterations = loopConditionOnPreviousIterations && loopCondition;
+		}
+		if (bmcLoopIterations > 0)
+		{
+			//after loop iterations are done, we check the loop condition last final time
+			auto indices = copyVariableIndices();
+			_node.condition().accept(*this);
+			loopCondition = expr(_node.condition());
+			// asseert that the loop is complete
+			m_context.addAssertion(!loopCondition || broke || !loopConditionOnPreviousIterations);
+			mergeVariables(
+				broke || !loopConditionOnPreviousIterations,
+				indices,
+				copyVariableIndices()
+			);
+		}
+	}
+	m_loopExecutionHappened = true;
+	return false;
+}
+
+// Unrolls for loop
+bool BMC::visit(ForStatement const& _node)
+{
+	if (_node.initializationExpression())
+		_node.initializationExpression()->accept(*this);
+
+	smtutil::Expression broke(false);
+	smtutil::Expression forCondition(true);
+	smtutil::Expression forConditionOnPreviousIterations(true);
+	unsigned int bmcLoopIterations = m_settings.bmcLoopIterations.value_or(1);
+	for (unsigned int i = 0; i < bmcLoopIterations; ++i)
+	{
+		auto indicesBefore = copyVariableIndices();
+		if (_node.condition())
+		{
+			_node.condition()->accept(*this);
+			// values in loop condition might change during loop iteration
+			forCondition = expr(*_node.condition());
+		}
+		m_loopCheckpoints.emplace();
+		auto indicesAfterCondition = copyVariableIndices();
+
+		pushPathCondition(forCondition);
+		_node.body().accept(*this);
+
+		auto brokeInCurrentIteration =	mergeVariablesFromLoopCheckpoints();
+
+		// accept loop expression if there was no break
+		if (_node.loopExpression())
+		{
+			auto indicesBreak = copyVariableIndices();
+			_node.loopExpression()->accept(*this);
+			mergeVariables(
+				!brokeInCurrentIteration,
+				copyVariableIndices(),
+				indicesBreak
+			);
+		}
+		popPathCondition();
+
+		// merges indices modified when accepting loop condition that does no longer hold
+		mergeVariables(
+			!forCondition,
+			indicesAfterCondition,
+			copyVariableIndices()
+		);
+
+		// handles breaks in previous iterations
+		// breaks in current iterations are handled when traversing loop checkpoints
+		// handles case when the loop condition no longer holds but bmc loop iterations still unrolls the loop
+		mergeVariables(
+			broke || !forConditionOnPreviousIterations,
+			indicesBefore,
+			copyVariableIndices()
+		);
+		m_loopCheckpoints.pop();
+		broke = broke || brokeInCurrentIteration;
+		forConditionOnPreviousIterations = forConditionOnPreviousIterations && forCondition;
+	}
+	if (bmcLoopIterations > 0)
+	{
+		//after loop iterations are done, we check the loop condition last final time
+		auto indices = copyVariableIndices();
+		if (_node.condition())
+		{
+			_node.condition()->accept(*this);
+			forCondition = expr(*_node.condition());
+		}
+		// asseert that the loop is complete
+		m_context.addAssertion(!forCondition || broke || !forConditionOnPreviousIterations);
+		mergeVariables(
+			broke || !forConditionOnPreviousIterations,
+			indices,
+			copyVariableIndices()
+		);
+	}
+	m_loopExecutionHappened = true;
+	return false;
+}
+
+// merges variables based on loop control statements
+// returns expression indicating whether there was a break in current loop unroll iteration
+smtutil::Expression BMC::mergeVariablesFromLoopCheckpoints()
+{
+	smtutil::Expression continues(false);
+	smtutil::Expression brokeInCurrentIteration(false);
+	for (auto const& loopControl: m_loopCheckpoints.top())
+	{
+		// use SSAs associated with this break statement only if
+		// loop didn't break or continue earlier in the iteration
+		// loop condition is included in break path conditions
+		mergeVariables(
+			!brokeInCurrentIteration && !continues && loopControl.pathConditions,
+			loopControl.variableIndices,
+			copyVariableIndices()
+		);
+		if (loopControl.kind == LoopControlKind::Break)
+			brokeInCurrentIteration =
+				brokeInCurrentIteration || loopControl.pathConditions;
+		else if (loopControl.kind == LoopControlKind::Continue)
+			continues = continues || loopControl.pathConditions;
+	}
+	return brokeInCurrentIteration;
+}
+
+bool BMC::visit(TryStatement const& _tryStatement)
+{
+	FunctionCall const* externalCall = dynamic_cast<FunctionCall const*>(&_tryStatement.externalCall());
+	solAssert(externalCall && externalCall->annotation().tryCall, "");
+
+	externalCall->accept(*this);
+	if (_tryStatement.successClause()->parameters())
+		expressionToTupleAssignment(_tryStatement.successClause()->parameters()->parameters(), *externalCall);
+
+	smtutil::Expression clauseId = m_context.newVariable("clause_choice_" + std::to_string(m_context.newUniqueId()), smtutil::SortProvider::uintSort);
+	auto const& clauses = _tryStatement.clauses();
+	m_context.addAssertion(clauseId >= 0 && clauseId < clauses.size());
+	solAssert(clauses[0].get() == _tryStatement.successClause(), "First clause of TryStatement should be the success clause");
+	std::vector<std::pair<VariableIndices, smtutil::Expression>> clausesVisitResults;
+	for (size_t i = 0; i < clauses.size(); ++i)
+		clausesVisitResults.push_back(visitBranch(clauses[i].get()));
+
+	// merge the information from all clauses
+	smtutil::Expression pathCondition = clausesVisitResults.front().second;
+	auto currentIndices = clausesVisitResults[0].first;
+	for (size_t i = 1; i < clauses.size(); ++i)
+	{
+		mergeVariables(clauseId == i, clausesVisitResults[i].first, currentIndices);
+		currentIndices = copyVariableIndices();
+		pathCondition = pathCondition || clausesVisitResults[i].second;
+	}
+	setPathCondition(pathCondition);
+
+	return false;
+}
+
+bool BMC::visit(Break const&)
+{
+	LoopControl control = {
+		LoopControlKind::Break,
+		currentPathConditions(),
+		copyVariableIndices()
+	};
+	m_loopCheckpoints.top().emplace_back(control);
+	return false;
+}
+
+bool BMC::visit(Continue const&)
+{
+	LoopControl control = {
+		LoopControlKind::Continue,
+		currentPathConditions(),
+		copyVariableIndices()
+	};
+	m_loopCheckpoints.top().emplace_back(control);
+	return false;
+}
+
+void BMC::endVisit(UnaryOperation const& _op)
+{
+	SMTEncoder::endVisit(_op);
+
+	// User-defined operators are essentially function calls.
+	if (auto funDef = *_op.annotation().userDefinedFunction)
+	{
+		std::vector<Expression const*> arguments;
+		arguments.push_back(&_op.subExpression());
+		// pushCallStack and defineExpr inside createReturnedExpression should be called on the expression
+		// in case of a user-defined operator call
+		inlineFunctionCall(funDef, _op, std::nullopt, arguments);
+		return;
+	}
+
+	if (
+		_op.annotation().type->category() == Type::Category::RationalNumber ||
+		_op.annotation().type->category() == Type::Category::FixedPoint
+	)
+		return;
+
+	if (_op.getOperator() == Token::Sub && smt::isInteger(*_op.annotation().type))
+		addVerificationTarget(
+			VerificationTargetType::UnderOverflow,
+			expr(_op),
+			&_op
+		);
+}
+
+void BMC::endVisit(BinaryOperation const& _op)
+{
+	SMTEncoder::endVisit(_op);
+
+	if (auto funDef = *_op.annotation().userDefinedFunction)
+	{
+		std::vector<Expression const*> arguments;
+		arguments.push_back(&_op.leftExpression());
+		arguments.push_back(&_op.rightExpression());
+
+		// pushCallStack and defineExpr inside createReturnedExpression should be called on the expression
+		// in case of a user-defined operator call
+		inlineFunctionCall(funDef, _op, std::nullopt, arguments);
+	}
+}
+
+void BMC::endVisit(FunctionCall const& _funCall)
+{
+	auto functionCallKind = *_funCall.annotation().kind;
+
+	if (functionCallKind != FunctionCallKind::FunctionCall)
+	{
+		SMTEncoder::endVisit(_funCall);
+		return;
+	}
+
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	switch (funType.kind())
+	{
+	case FunctionType::Kind::Assert:
+		visitAssert(_funCall);
+		SMTEncoder::endVisit(_funCall);
+		break;
+	case FunctionType::Kind::Require:
+		visitRequire(_funCall);
+		SMTEncoder::endVisit(_funCall);
+		break;
+	case FunctionType::Kind::Internal:
+	case FunctionType::Kind::External:
+	case FunctionType::Kind::DelegateCall:
+	case FunctionType::Kind::BareCall:
+	case FunctionType::Kind::BareCallCode:
+	case FunctionType::Kind::BareDelegateCall:
+	case FunctionType::Kind::BareStaticCall:
+	case FunctionType::Kind::Creation:
+		SMTEncoder::endVisit(_funCall);
+		internalOrExternalFunctionCall(_funCall);
+		break;
+	case FunctionType::Kind::Send:
+	case FunctionType::Kind::Transfer:
+	{
+		auto value = _funCall.arguments().front();
+		solAssert(value, "");
+		smtutil::Expression thisBalance = state().balance();
+
+		addVerificationTarget(
+			VerificationTargetType::Balance,
+			thisBalance < expr(*value),
+			&_funCall
+		);
+
+		SMTEncoder::endVisit(_funCall);
+		break;
+	}
+	case FunctionType::Kind::KECCAK256:
+	case FunctionType::Kind::ECRecover:
+	case FunctionType::Kind::SHA256:
+	case FunctionType::Kind::RIPEMD160:
+	case FunctionType::Kind::BlockHash:
+	case FunctionType::Kind::AddMod:
+	case FunctionType::Kind::MulMod:
+	case FunctionType::Kind::Unwrap:
+	case FunctionType::Kind::Wrap:
+		[[fallthrough]];
+	default:
+		SMTEncoder::endVisit(_funCall);
+		break;
+	}
+}
+
+void BMC::endVisit(Return const& _return)
+{
+	SMTEncoder::endVisit(_return);
+	setPathCondition(smtutil::Expression(false));
+}
+
+/// Visitor helpers.
+
+void BMC::visitAssert(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() == 1, "");
+	solAssert(args.front()->annotation().type->category() == Type::Category::Bool, "");
+	addVerificationTarget(
+		VerificationTargetType::Assert,
+		expr(*args.front()),
+		&_funCall
+	);
+}
+
+void BMC::visitRequire(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() >= 1, "");
+	solAssert(args.front()->annotation().type->category() == Type::Category::Bool, "");
+	if (isRootFunction() && !isInsideLoop())
+		addVerificationTarget(
+			VerificationTargetType::ConstantCondition,
+			expr(*args.front()),
+			args.front().get()
+		);
+}
+
+void BMC::visitAddMulMod(FunctionCall const& _funCall)
+{
+	solAssert(_funCall.arguments().at(2), "");
+	addVerificationTarget(
+		VerificationTargetType::DivByZero,
+		expr(*_funCall.arguments().at(2)),
+		&_funCall
+	);
+
+	SMTEncoder::visitAddMulMod(_funCall);
+}
+
+void BMC::inlineFunctionCall(
+	FunctionDefinition const* _funDef,
+	Expression const& _callStackExpr,
+	std::optional<Expression const*> _boundArgumentCall,
+	std::vector<Expression const*> const& _arguments
+)
+{
+	solAssert(_funDef, "");
+
+	if (visitedFunction(_funDef))
+	{
+		auto const& returnParams = _funDef->returnParameters();
+		for (auto param: returnParams)
+		{
+			m_context.newValue(*param);
+			m_context.setUnknownValue(*param);
+		}
+	}
+	else
+	{
+		initializeFunctionCallParameters(*_funDef, symbolicArguments(_funDef->parameters(), _arguments, _boundArgumentCall));
+
+		// The reason why we need to pushCallStack here instead of visit(FunctionDefinition)
+		// is that there we don't have `_callStackExpr`.
+		pushCallStack({_funDef, &_callStackExpr});
+		pushPathCondition(currentPathConditions());
+		auto oldChecked = std::exchange(m_checked, true);
+		_funDef->accept(*this);
+		m_checked = oldChecked;
+		popPathCondition();
+	}
+
+	createReturnedExpressions(_funDef, _callStackExpr);
+}
+
+void BMC::inlineFunctionCall(FunctionCall const& _funCall)
+{
+	solAssert(shouldInlineFunctionCall(_funCall, currentScopeContract(), m_currentContract), "");
+
+	auto funDef = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	Expression const* expr = &_funCall.expression();
+	auto funType = dynamic_cast<FunctionType const*>(expr->annotation().type);
+	std::optional<Expression const*> boundArgumentCall =
+		funType->hasBoundFirstArgument() ? std::make_optional(expr) : std::nullopt;
+
+	std::vector<Expression const*> arguments;
+	for (auto& arg: _funCall.sortedArguments())
+		arguments.push_back(&(*arg));
+
+	// pushCallStack and defineExpr inside createReturnedExpression should be called
+	// on the FunctionCall object for the normal function call case
+	inlineFunctionCall(funDef, _funCall, boundArgumentCall, arguments);
+}
+
+void BMC::internalOrExternalFunctionCall(FunctionCall const& _funCall)
+{
+	auto const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	if (shouldInlineFunctionCall(_funCall, currentScopeContract(), m_currentContract))
+		inlineFunctionCall(_funCall);
+	else if (publicGetter(_funCall.expression()))
+	{
+		// Do nothing here.
+		// The processing happens in SMT Encoder, but we need to prevent the resetting of the state variables.
+	}
+	else if (funType.kind() == FunctionType::Kind::Internal)
+		m_unsupportedErrors.warning(
+			5729_error,
+			_funCall.location(),
+			"BMC does not yet implement this type of function call."
+		);
+	else if (funType.kind() == FunctionType::Kind::BareStaticCall)
+	{
+		// Do nothing here.
+		// Neither storage nor balances should be modified.
+	}
+	else
+	{
+		m_externalFunctionCallHappened = true;
+		resetStorageVariables();
+		resetBalances();
+	}
+}
+
+std::pair<smtutil::Expression, smtutil::Expression> BMC::arithmeticOperation(
+	Token _op,
+	smtutil::Expression const& _left,
+	smtutil::Expression const& _right,
+	Type const* _commonType,
+	Expression const& _expression
+)
+{
+	// Unchecked does not disable div by 0 checks.
+	if (_op == Token::Div || _op == Token::Mod)
+		addVerificationTarget(
+			VerificationTargetType::DivByZero,
+			_right,
+			&_expression
+		);
+
+	auto values = SMTEncoder::arithmeticOperation(_op, _left, _right, _commonType, _expression);
+
+	if (!m_checked)
+		return values;
+
+	auto const* intType = dynamic_cast<IntegerType const*>(_commonType);
+	if (!intType)
+		intType = TypeProvider::uint256();
+
+	// Mod does not need underflow/overflow checks.
+	if (_op == Token::Mod)
+		return values;
+
+	VerificationTargetType type;
+	// The order matters here:
+	// If _op is Div and intType is signed, we only care about overflow.
+	if (_op == Token::Div)
+	{
+		if (intType->isSigned())
+			// Signed division can only overflow.
+			type = VerificationTargetType::Overflow;
+		else
+			// Unsigned division cannot underflow/overflow.
+			return values;
+	}
+	else if (intType->isSigned())
+		type = VerificationTargetType::UnderOverflow;
+	else if (_op == Token::Sub)
+		type = VerificationTargetType::Underflow;
+	else if (_op == Token::Add || _op == Token::Mul)
+		type = VerificationTargetType::Overflow;
+	else
+		solAssert(false, "");
+
+	addVerificationTarget(
+		type,
+		values.second,
+		&_expression
+	);
+	return values;
+}
+
+void BMC::reset()
+{
+	m_externalFunctionCallHappened = false;
+	m_loopExecutionHappened = false;
+}
+
+std::pair<std::vector<smtutil::Expression>, std::vector<std::string>> BMC::modelExpressions()
+{
+	std::vector<smtutil::Expression> expressionsToEvaluate;
+	std::vector<std::string> expressionNames;
+	for (auto const& var: m_context.variables())
+		if (var.first->type()->isValueType())
+		{
+			expressionsToEvaluate.emplace_back(currentValue(*var.first));
+			expressionNames.push_back(var.first->name());
+		}
+	for (auto const& var: m_context.globalSymbols())
+	{
+		auto const& type = var.second->type();
+		if (
+			type->isValueType() &&
+			smt::smtKind(*type) != smtutil::Kind::Function
+		)
+		{
+			expressionsToEvaluate.emplace_back(var.second->currentValue());
+			expressionNames.push_back(var.first);
+		}
+	}
+	for (auto const& uf: m_uninterpretedTerms)
+		if (uf->annotation().type->isValueType())
+		{
+			expressionsToEvaluate.emplace_back(expr(*uf));
+			std::string expressionName;
+			if (uf->location().hasText())
+				expressionName = m_charStreamProvider.charStream(*uf->location().sourceName).text(
+					uf->location()
+				);
+			expressionNames.push_back(std::move(expressionName));
+		}
+
+	return {expressionsToEvaluate, expressionNames};
+}
+
+/// Verification targets.
+
+std::string BMC::targetDescription(BMCVerificationTarget const& _target)
+{
+	if (
+		_target.type == VerificationTargetType::Underflow ||
+		_target.type == VerificationTargetType::Overflow
+	)
+	{
+		auto const* intType = dynamic_cast<IntegerType const*>(_target.expression->annotation().type);
+		if (!intType)
+			intType = TypeProvider::uint256();
+
+		if (_target.type == VerificationTargetType::Underflow)
+			return "Underflow (resulting value less than " + formatNumberReadable(intType->minValue()) + ")";
+		return "Overflow (resulting value larger than " + formatNumberReadable(intType->maxValue()) + ")";
+	}
+	else if (_target.type == VerificationTargetType::DivByZero)
+		return "Division by zero";
+	else if (_target.type == VerificationTargetType::Assert)
+		return "Assertion violation";
+	else if (_target.type == VerificationTargetType::Balance)
+		return "Insufficient funds";
+	solAssert(false);
+}
+
+void BMC::checkVerificationTargets()
+{
+	for (auto& target: m_verificationTargets)
+		checkVerificationTarget(target);
+}
+
+void BMC::checkVerificationTarget(BMCVerificationTarget& _target)
+{
+	switch (_target.type)
+	{
+		case VerificationTargetType::ConstantCondition:
+			checkConstantCondition(_target);
+			break;
+		case VerificationTargetType::Underflow:
+			checkUnderflow(_target);
+			break;
+		case VerificationTargetType::Overflow:
+			checkOverflow(_target);
+			break;
+		case VerificationTargetType::UnderOverflow:
+			checkUnderflow(_target);
+			checkOverflow(_target);
+			break;
+		case VerificationTargetType::DivByZero:
+			checkDivByZero(_target);
+			break;
+		case VerificationTargetType::Balance:
+			checkBalance(_target);
+			break;
+		case VerificationTargetType::Assert:
+			checkAssert(_target);
+			break;
+		default:
+			solAssert(false, "");
+	}
+}
+
+void BMC::checkConstantCondition(BMCVerificationTarget& _target)
+{
+	checkBooleanNotConstant(
+		*_target.expression,
+		_target.constraints,
+		_target.value,
+		_target.callStack
+	);
+}
+
+void BMC::checkUnderflow(BMCVerificationTarget& _target)
+{
+	solAssert(
+		_target.type == VerificationTargetType::Underflow ||
+			_target.type == VerificationTargetType::UnderOverflow,
+		""
+	);
+
+	if (
+		m_solvedTargets.count(_target.expression) && (
+			m_solvedTargets.at(_target.expression).count(VerificationTargetType::Underflow) ||
+			m_solvedTargets.at(_target.expression).count(VerificationTargetType::UnderOverflow)
+		)
+	)
+		return;
+
+	auto const* intType = dynamic_cast<IntegerType const*>(_target.expression->annotation().type);
+	if (!intType)
+		intType = TypeProvider::uint256();
+
+	checkCondition(
+		_target,
+		_target.constraints && _target.value < smt::minValue(*intType),
+		_target.callStack,
+		_target.modelExpressions,
+		_target.expression->location(),
+		4144_error,
+		8312_error,
+		"<result>",
+		&_target.value
+	);
+}
+
+void BMC::checkOverflow(BMCVerificationTarget& _target)
+{
+	solAssert(
+		_target.type == VerificationTargetType::Overflow ||
+			_target.type == VerificationTargetType::UnderOverflow,
+		""
+	);
+
+	if (
+		m_solvedTargets.count(_target.expression) && (
+			m_solvedTargets.at(_target.expression).count(VerificationTargetType::Overflow) ||
+			m_solvedTargets.at(_target.expression).count(VerificationTargetType::UnderOverflow)
+		)
+	)
+		return;
+
+	auto const* intType = dynamic_cast<IntegerType const*>(_target.expression->annotation().type);
+	if (!intType)
+		intType = TypeProvider::uint256();
+
+	checkCondition(
+		_target,
+		_target.constraints && _target.value > smt::maxValue(*intType),
+		_target.callStack,
+		_target.modelExpressions,
+		_target.expression->location(),
+		2661_error,
+		8065_error,
+		"<result>",
+		&_target.value
+	);
+}
+
+void BMC::checkDivByZero(BMCVerificationTarget& _target)
+{
+	solAssert(_target.type == VerificationTargetType::DivByZero, "");
+
+	if (
+		m_solvedTargets.count(_target.expression) &&
+		m_solvedTargets.at(_target.expression).count(VerificationTargetType::DivByZero)
+	)
+		return;
+
+	checkCondition(
+		_target,
+		_target.constraints && (_target.value == 0),
+		_target.callStack,
+		_target.modelExpressions,
+		_target.expression->location(),
+		3046_error,
+		5272_error,
+		"<result>",
+		&_target.value
+	);
+}
+
+void BMC::checkBalance(BMCVerificationTarget& _target)
+{
+	solAssert(_target.type == VerificationTargetType::Balance, "");
+	checkCondition(
+		_target,
+		_target.constraints && _target.value,
+		_target.callStack,
+		_target.modelExpressions,
+		_target.expression->location(),
+		1236_error,
+		4010_error,
+		"address(this).balance"
+	);
+}
+
+void BMC::checkAssert(BMCVerificationTarget& _target)
+{
+	solAssert(_target.type == VerificationTargetType::Assert, "");
+
+	if (
+		m_solvedTargets.count(_target.expression) &&
+		m_solvedTargets.at(_target.expression).count(_target.type)
+	)
+		return;
+
+	checkCondition(
+		_target,
+		_target.constraints && !_target.value,
+		_target.callStack,
+		_target.modelExpressions,
+		_target.expression->location(),
+		4661_error,
+		7812_error
+	);
+}
+
+void BMC::addVerificationTarget(
+	VerificationTargetType _type,
+	smtutil::Expression const& _value,
+	Expression const* _expression
+)
+{
+	if (!m_settings.targets.has(_type) || (m_currentContract && !shouldAnalyze(*m_currentContract)))
+		return;
+
+	BMCVerificationTarget target{
+		{
+			_type,
+			_value,
+			currentPathConditions() && m_context.assertions()
+		},
+		_expression,
+		m_callStack,
+		modelExpressions()
+	};
+	if (_type == VerificationTargetType::ConstantCondition)
+		checkVerificationTarget(target);
+	else
+		m_verificationTargets.emplace_back(std::move(target));
+}
+
+/// Solving.
+
+void BMC::checkCondition(
+	BMCVerificationTarget const& _target,
+	smtutil::Expression _condition,
+	std::vector<SMTEncoder::CallStackEntry> const& _callStack,
+	std::pair<std::vector<smtutil::Expression>, std::vector<std::string>> const& _modelExpressions,
+	SourceLocation const& _location,
+	ErrorId _errorHappens,
+	ErrorId _errorMightHappen,
+	std::string const& _additionalValueName,
+	smtutil::Expression const* _additionalValue
+)
+{
+	m_interface->push();
+	m_interface->addAssertion(_condition);
+
+	std::vector<smtutil::Expression> expressionsToEvaluate;
+	std::vector<std::string> expressionNames;
+	tie(expressionsToEvaluate, expressionNames) = _modelExpressions;
+	if (!_callStack.empty())
+		if (_additionalValue)
+		{
+			expressionsToEvaluate.emplace_back(*_additionalValue);
+			expressionNames.push_back(_additionalValueName);
+		}
+	smtutil::CheckResult result;
+	std::vector<std::string> values;
+	tie(result, values) = checkSatisfiableAndGenerateModel(expressionsToEvaluate);
+
+	std::string extraComment = SMTEncoder::extraComment();
+	if (m_loopExecutionHappened)
+		extraComment +=
+			"False negatives are possible when unrolling loops.\n"
+			"This is due to the possibility that the BMC loop iteration setting is"
+			" smaller than the actual number of iterations needed to complete a loop.";
+	if (m_externalFunctionCallHappened)
+		extraComment +=
+			"\nNote that external function calls are not inlined,"
+			" even if the source code of the function is available."
+			" This is due to the possibility that the actual called contract"
+			" has the same ABI but implements the function differently.";
+
+	SecondarySourceLocation secondaryLocation{};
+	secondaryLocation.append(extraComment, SourceLocation{});
+
+	switch (result)
+	{
+	case smtutil::CheckResult::SATISFIABLE:
+	{
+		solAssert(!_callStack.empty(), "");
+		std::ostringstream message;
+		message << "BMC: " << targetDescription(_target) << " happens here.";
+
+		std::ostringstream modelMessage;
+		// Sometimes models have complex smtlib2 expressions that SMTLib2Interface fails to parse.
+		if (values.size() == expressionNames.size())
+		{
+			modelMessage << "Counterexample:\n";
+			std::map<std::string, std::string> sortedModel;
+			for (size_t i = 0; i < values.size(); ++i)
+				if (expressionsToEvaluate.at(i).name != values.at(i))
+					sortedModel[expressionNames.at(i)] = values.at(i);
+
+			for (auto const& eval: sortedModel)
+				modelMessage << "  " << eval.first << " = " << eval.second << "\n";
+		}
+
+		m_errorReporter.warning(
+			_errorHappens,
+			_location,
+			message.str(),
+			SecondarySourceLocation().append(modelMessage.str(), SourceLocation{})
+			.append(SMTEncoder::callStackMessage(_callStack))
+			.append(std::move(secondaryLocation))
+		);
+		break;
+	}
+	case smtutil::CheckResult::UNSATISFIABLE:
+	{
+		m_safeTargets[_target.expression].insert(_target);
+		break;
+	}
+	case smtutil::CheckResult::UNKNOWN:
+	{
+		++m_unprovedAmt;
+		if (m_settings.showUnproved)
+			m_errorReporter.warning(_errorMightHappen, _location, "BMC: " + targetDescription(_target) + " might happen here.", secondaryLocation);
+		break;
+	}
+	case smtutil::CheckResult::CONFLICTING:
+		m_errorReporter.warning(1584_error, _location, "BMC: At least two SMT solvers provided conflicting answers. Results might not be sound.");
+		break;
+	case smtutil::CheckResult::ERROR:
+		m_errorReporter.warning(1823_error, _location, "BMC: Error trying to invoke SMT solver.");
+		break;
+	}
+
+	m_interface->pop();
+}
+
+void BMC::checkBooleanNotConstant(
+	Expression const& _condition,
+	smtutil::Expression const& _constraints,
+	smtutil::Expression const& _value,
+	std::vector<SMTEncoder::CallStackEntry> const& _callStack
+)
+{
+	// Do not check for const-ness if this is a constant.
+	if (dynamic_cast<Literal const*>(&_condition))
+		return;
+
+	m_interface->push();
+	m_interface->addAssertion(_constraints && _value);
+	auto positiveResult = checkSatisfiable();
+	m_interface->pop();
+
+	m_interface->push();
+	m_interface->addAssertion(_constraints && !_value);
+	auto negatedResult = checkSatisfiable();
+	m_interface->pop();
+
+	if (positiveResult == smtutil::CheckResult::ERROR || negatedResult == smtutil::CheckResult::ERROR)
+		m_errorReporter.warning(8592_error, _condition.location(), "BMC: Error trying to invoke SMT solver.");
+	else if (positiveResult == smtutil::CheckResult::CONFLICTING || negatedResult == smtutil::CheckResult::CONFLICTING)
+		m_errorReporter.warning(3356_error, _condition.location(), "BMC: At least two SMT solvers provided conflicting answers. Results might not be sound.");
+	else if (positiveResult == smtutil::CheckResult::SATISFIABLE && negatedResult == smtutil::CheckResult::SATISFIABLE)
+	{
+		// everything fine.
+	}
+	else if (positiveResult == smtutil::CheckResult::UNKNOWN || negatedResult == smtutil::CheckResult::UNKNOWN)
+	{
+		// can't do anything.
+	}
+	else if (positiveResult == smtutil::CheckResult::UNSATISFIABLE && negatedResult == smtutil::CheckResult::UNSATISFIABLE)
+		m_errorReporter.warning(2512_error, _condition.location(), "BMC: Condition unreachable.", SMTEncoder::callStackMessage(_callStack));
+	else
+	{
+		std::string description;
+		if (positiveResult == smtutil::CheckResult::SATISFIABLE)
+		{
+			solAssert(negatedResult == smtutil::CheckResult::UNSATISFIABLE, "");
+			description = "BMC: Condition is always true.";
+		}
+		else
+		{
+			solAssert(positiveResult == smtutil::CheckResult::UNSATISFIABLE, "");
+			solAssert(negatedResult == smtutil::CheckResult::SATISFIABLE, "");
+			description = "BMC: Condition is always false.";
+		}
+		m_errorReporter.warning(
+			6838_error,
+			_condition.location(),
+			description,
+			SMTEncoder::callStackMessage(_callStack)
+		);
+	}
+}
+
+std::pair<smtutil::CheckResult, std::vector<std::string>>
+BMC::checkSatisfiableAndGenerateModel(std::vector<smtutil::Expression> const& _expressionsToEvaluate)
+{
+	smtutil::CheckResult result;
+	std::vector<std::string> values;
+	try
+	{
+		if (m_settings.printQuery)
+		{
+			auto portfolio = dynamic_cast<smtutil::SMTPortfolio*>(m_interface.get());
+			std::string smtlibCode = portfolio->dumpQuery(_expressionsToEvaluate);
+			m_errorReporter.info(
+				6240_error,
+				"BMC: Requested query:\n" + smtlibCode
+			);
+		}
+		tie(result, values) = m_interface->check(_expressionsToEvaluate);
+	}
+	catch (smtutil::SolverError const& _e)
+	{
+		std::string description("BMC: Error querying SMT solver");
+		if (_e.comment())
+			description += ": " + *_e.comment();
+		m_errorReporter.warning(8140_error, description);
+		result = smtutil::CheckResult::ERROR;
+	}
+
+	for (std::string& value: values)
+	{
+		try
+		{
+			// Parse and re-format nicely
+			value = formatNumberReadable(bigint(value));
+		}
+		catch (...) { }
+	}
+
+	return make_pair(result, values);
+}
+
+smtutil::CheckResult BMC::checkSatisfiable()
+{
+	return checkSatisfiableAndGenerateModel({}).first;
+}
+
+void BMC::assignment(smt::SymbolicVariable& _symVar, smtutil::Expression const& _value)
+{
+	auto oldVar = _symVar.currentValue();
+	auto newVar = _symVar.increaseIndex();
+	m_context.addAssertion(smtutil::Expression::ite(
+		currentPathConditions(),
+		newVar == _value,
+		newVar == oldVar
+	));
+}
+
+bool BMC::isInsideLoop() const
+{
+	return !m_loopCheckpoints.empty();
+}
diff --git a/compiler/libsolidity/formal/BMC.h b/compiler/libsolidity/formal/BMC.h
new file mode 100644
index 00000000..9daa1683
--- /dev/null
+++ b/compiler/libsolidity/formal/BMC.h
@@ -0,0 +1,236 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Class that implements an SMT-based Bounded Model Checker (BMC).
+ * Traverses the AST such that:
+ * - Loops are unrolled
+ * - Internal function calls are inlined
+ * Creates verification targets for:
+ * - Underflow/Overflow
+ * - Constant conditions
+ * - Assertions
+ */
+
+#pragma once
+
+
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/ModelCheckerSettings.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <libsolidity/interface/ReadFile.h>
+
+#include <libsmtutil/SolverInterface.h>
+#include <liblangutil/UniqueErrorReporter.h>
+
+#include <set>
+#include <string>
+#include <vector>
+
+using solidity::util::h256;
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+struct ErrorId;
+struct SourceLocation;
+}
+
+namespace solidity::frontend
+{
+
+class BMC: public SMTEncoder
+{
+public:
+	BMC(
+		smt::EncodingContext& _context,
+		langutil::UniqueErrorReporter& _errorReporter,
+		langutil::UniqueErrorReporter& _unsupportedErrorReporter,
+		std::map<h256, std::string> const& _smtlib2Responses,
+		ReadCallback::Callback const& _smtCallback,
+		ModelCheckerSettings _settings,
+		langutil::CharStreamProvider const& _charStreamProvider
+	);
+
+	void analyze(SourceUnit const& _sources, std::map<ASTNode const*, std::set<VerificationTargetType>, smt::EncodingContext::IdCompare> _solvedTargets);
+
+	/// This is used if the SMT solver is not directly linked into this binary.
+	/// @returns a list of inputs to the SMT solver that were not part of the argument to
+	/// the constructor.
+	std::vector<std::string> unhandledQueries() { return m_interface->unhandledQueries(); }
+
+	/// @returns true if _funCall should be inlined, otherwise false.
+	/// @param _scopeContract The contract that contains the current function being analyzed.
+	/// @param _contextContract The most derived contract, currently being analyzed.
+	static bool shouldInlineFunctionCall(
+		FunctionCall const& _funCall,
+		ContractDefinition const* _scopeContract,
+		ContractDefinition const* _contextContract
+	);
+
+private:
+	/// AST visitors.
+	/// Only nodes that lead to verification targets being built
+	/// or checked are visited.
+	//@{
+	bool visit(ContractDefinition const& _node) override;
+	void endVisit(ContractDefinition const& _node) override;
+	bool visit(FunctionDefinition const& _node) override;
+	void endVisit(FunctionDefinition const& _node) override;
+	bool visit(IfStatement const& _node) override;
+	bool visit(Conditional const& _node) override;
+	bool visit(WhileStatement const& _node) override;
+	bool visit(ForStatement const& _node) override;
+	void endVisit(UnaryOperation const& _node) override;
+	void endVisit(BinaryOperation const& _node) override;
+	void endVisit(FunctionCall const& _node) override;
+	void endVisit(Return const& _node) override;
+	bool visit(TryStatement const& _node) override;
+	bool visit(Break const& _node) override;
+	bool visit(Continue const& _node) override;
+	//@}
+
+	/// Visitor helpers.
+	//@{
+	void visitAssert(FunctionCall const& _funCall);
+	void visitRequire(FunctionCall const& _funCall);
+	void visitAddMulMod(FunctionCall const& _funCall) override;
+	void assignment(smt::SymbolicVariable& _symVar, smtutil::Expression const& _value) override;
+	/// Visits the FunctionDefinition of the called function
+	/// if available and inlines the return value.
+	void inlineFunctionCall(FunctionCall const& _funCall);
+	void inlineFunctionCall(
+		FunctionDefinition const* _funDef,
+		Expression const& _callStackExpr,
+		std::optional<Expression const*> _calledExpr,
+		std::vector<Expression const*> const& _arguments
+	);
+	/// Inlines if the function call is internal or external to `this`.
+	/// Erases knowledge about state variables if external.
+	void internalOrExternalFunctionCall(FunctionCall const& _funCall);
+
+	/// Creates underflow/overflow verification targets.
+	std::pair<smtutil::Expression, smtutil::Expression> arithmeticOperation(
+		Token _op,
+		smtutil::Expression const& _left,
+		smtutil::Expression const& _right,
+		Type const* _commonType,
+		Expression const& _expression
+	) override;
+
+	void reset();
+
+	std::pair<std::vector<smtutil::Expression>, std::vector<std::string>> modelExpressions();
+	//@}
+
+	/// Verification targets.
+	//@{
+	struct BMCVerificationTarget: VerificationTarget
+	{
+		Expression const* expression;
+		std::vector<CallStackEntry> callStack;
+		std::pair<std::vector<smtutil::Expression>, std::vector<std::string>> modelExpressions;
+
+		friend bool operator<(BMCVerificationTarget const& _a, BMCVerificationTarget const& _b)
+		{
+			return _a.expression->id() < _b.expression->id();
+		}
+	};
+
+	std::string targetDescription(BMCVerificationTarget const& _target);
+
+	void checkVerificationTargets();
+	void checkVerificationTarget(BMCVerificationTarget& _target);
+	void checkConstantCondition(BMCVerificationTarget& _target);
+	void checkUnderflow(BMCVerificationTarget& _target);
+	void checkOverflow(BMCVerificationTarget& _target);
+	void checkDivByZero(BMCVerificationTarget& _target);
+	void checkBalance(BMCVerificationTarget& _target);
+	void checkAssert(BMCVerificationTarget& _target);
+	void addVerificationTarget(
+		VerificationTargetType _type,
+		smtutil::Expression const& _value,
+		Expression const* _expression
+	);
+	//@}
+
+	/// Solver related.
+	//@{
+	/// Check that a condition can be satisfied.
+	void checkCondition(
+		BMCVerificationTarget const& _target,
+		smtutil::Expression _condition,
+		std::vector<CallStackEntry> const& _callStack,
+		std::pair<std::vector<smtutil::Expression>, std::vector<std::string>> const& _modelExpressions,
+		langutil::SourceLocation const& _location,
+		langutil::ErrorId _errorHappens,
+		langutil::ErrorId _errorMightHappen,
+		std::string const& _additionalValueName = "",
+		smtutil::Expression const* _additionalValue = nullptr
+	);
+	/// Checks that a boolean condition is not constant. Do not warn if the expression
+	/// is a literal constant.
+	void checkBooleanNotConstant(
+		Expression const& _condition,
+		smtutil::Expression const& _constraints,
+		smtutil::Expression const& _value,
+		std::vector<CallStackEntry> const& _callStack
+	);
+	std::pair<smtutil::CheckResult, std::vector<std::string>>
+	checkSatisfiableAndGenerateModel(std::vector<smtutil::Expression> const& _expressionsToEvaluate);
+
+	smtutil::CheckResult checkSatisfiable();
+	//@}
+
+	smtutil::Expression mergeVariablesFromLoopCheckpoints();
+	bool isInsideLoop() const;
+
+	std::unique_ptr<smtutil::SolverInterface> m_interface;
+
+	/// Flags used for better warning messages.
+	bool m_loopExecutionHappened = false;
+	bool m_externalFunctionCallHappened = false;
+
+	std::vector<BMCVerificationTarget> m_verificationTargets;
+
+	/// Targets proved safe by this engine.
+	std::map<ASTNode const*, std::set<BMCVerificationTarget>, smt::EncodingContext::IdCompare> m_safeTargets;
+
+	/// Targets that were already proven before this engine started.
+	std::map<ASTNode const*, std::set<VerificationTargetType>, smt::EncodingContext::IdCompare> m_solvedTargets;
+
+	/// Number of verification conditions that could not be proved.
+	size_t m_unprovedAmt = 0;
+
+	enum class LoopControlKind
+	{
+		Continue,
+		Break
+	};
+
+	// Current path conditions and SSA indices for break or continue statement
+	struct LoopControl {
+		LoopControlKind kind;
+		smtutil::Expression pathConditions;
+		VariableIndices variableIndices;
+	};
+
+	// Loop control statements for every loop
+	std::stack<std::vector<LoopControl>> m_loopCheckpoints;
+};
+}
diff --git a/compiler/libsolidity/formal/CHC.cpp b/compiler/libsolidity/formal/CHC.cpp
new file mode 100644
index 00000000..2c9075ab
--- /dev/null
+++ b/compiler/libsolidity/formal/CHC.cpp
@@ -0,0 +1,2494 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/CHC.h>
+
+#include <libsolidity/formal/ModelChecker.h>
+
+#ifdef HAVE_Z3
+#include <libsmtutil/Z3CHCInterface.h>
+#endif
+
+#include <libsolidity/formal/ArraySlicePredicate.h>
+#include <libsolidity/formal/Invariants.h>
+#include <libsolidity/formal/PredicateInstance.h>
+#include <libsolidity/formal/PredicateSort.h>
+#include <libsolidity/formal/SymbolicTypes.h>
+
+#include <libsolidity/ast/TypeProvider.h>
+
+#include <libsmtutil/CHCSmtLib2Interface.h>
+#include <liblangutil/CharStreamProvider.h>
+#include <libsolutil/Algorithms.h>
+#include <libsolutil/StringUtils.h>
+
+#ifdef HAVE_Z3_DLOPEN
+#include <z3_version.h>
+#endif
+
+#include <boost/algorithm/string.hpp>
+
+#include <range/v3/algorithm/for_each.hpp>
+#include <range/v3/view.hpp>
+#include <range/v3/view/enumerate.hpp>
+#include <range/v3/view/reverse.hpp>
+
+#include <charconv>
+#include <queue>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::smtutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+CHC::CHC(
+	EncodingContext& _context,
+	UniqueErrorReporter& _errorReporter,
+	UniqueErrorReporter& _unsupportedErrorReporter,
+	std::map<util::h256, std::string> const& _smtlib2Responses,
+	ReadCallback::Callback const& _smtCallback,
+	ModelCheckerSettings _settings,
+	CharStreamProvider const& _charStreamProvider
+):
+	SMTEncoder(_context, _settings, _errorReporter, _unsupportedErrorReporter, _charStreamProvider),
+	m_smtlib2Responses(_smtlib2Responses),
+	m_smtCallback(_smtCallback)
+{
+	solAssert(!_settings.printQuery || _settings.solvers == smtutil::SMTSolverChoice::SMTLIB2(), "Only SMTLib2 solver can be enabled to print queries");
+}
+
+void CHC::analyze(SourceUnit const& _source)
+{
+	// At this point every enabled solver is available.
+	if (!m_settings.solvers.eld && !m_settings.solvers.smtlib2 && !m_settings.solvers.z3)
+	{
+		m_errorReporter.warning(
+			7649_error,
+			SourceLocation(),
+			"CHC analysis was not possible since no Horn solver was found and enabled."
+			" The accepted solvers for CHC are Eldarica and z3."
+		);
+		return;
+	}
+
+	if (m_settings.solvers.eld && m_settings.solvers.z3)
+		m_errorReporter.warning(
+			5798_error,
+			SourceLocation(),
+			"Multiple Horn solvers were selected for CHC."
+			" CHC only supports one solver at a time, therefore only z3 will be used."
+			" If you wish to use Eldarica, please enable Eldarica only."
+		);
+
+	if (!shouldAnalyze(_source))
+		return;
+
+	resetSourceAnalysis();
+
+	auto sources = sourceDependencies(_source);
+	collectFreeFunctions(sources);
+	createFreeConstants(sources);
+	state().prepareForSourceUnit(_source, encodeExternalCallsAsTrusted());
+
+	for (auto const* source: sources)
+		defineInterfacesAndSummaries(*source);
+	for (auto const* source: sources)
+		source->accept(*this);
+
+	checkVerificationTargets();
+
+	bool ranSolver = true;
+	// If ranSolver is true here it's because an SMT solver callback was
+	// actually given and the queries were solved,
+	// or Eldarica was chosen and was present in the system.
+	if (auto const* smtLibInterface = dynamic_cast<CHCSmtLib2Interface const*>(m_interface.get()))
+		ranSolver = smtLibInterface->unhandledQueries().empty();
+	if (!ranSolver)
+		m_errorReporter.warning(
+			3996_error,
+			SourceLocation(),
+			"CHC analysis was not possible. No Horn solver was available."
+			" None of the installed solvers was enabled."
+		);
+}
+
+std::vector<std::string> CHC::unhandledQueries() const
+{
+	if (auto smtlib2 = dynamic_cast<CHCSmtLib2Interface const*>(m_interface.get()))
+		return smtlib2->unhandledQueries();
+
+	return {};
+}
+
+bool CHC::visit(ContractDefinition const& _contract)
+{
+	if (!shouldAnalyze(_contract))
+		return false;
+
+	resetContractAnalysis();
+	initContract(_contract);
+	clearIndices(&_contract);
+
+	m_scopes.push_back(&_contract);
+
+	m_stateVariables = SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract);
+	solAssert(m_currentContract, "");
+
+	SMTEncoder::visit(_contract);
+	return false;
+}
+
+void CHC::endVisit(ContractDefinition const& _contract)
+{
+	if (!shouldAnalyze(_contract))
+		return;
+
+	for (auto base: _contract.annotation().linearizedBaseContracts)
+	{
+		if (auto constructor = base->constructor())
+			constructor->accept(*this);
+		defineContractInitializer(*base, _contract);
+	}
+
+	auto const& entry = *createConstructorBlock(_contract, "implicit_constructor_entry");
+
+	// In case constructors use uninitialized state variables,
+	// they need to be zeroed.
+	// This is not part of `initialConstraints` because it's only true here,
+	// at the beginning of the deployment routine.
+	smtutil::Expression zeroes(true);
+	for (auto var: stateVariablesIncludingInheritedAndPrivate(_contract))
+		zeroes = zeroes && currentValue(*var) == smt::zeroValue(var->type());
+
+	smtutil::Expression newAddress = encodeExternalCallsAsTrusted() ?
+		!state().addressActive(state().thisAddress()) :
+		smtutil::Expression(true);
+
+	// The contract's address might already have funds before deployment,
+	// so the balance must be at least `msg.value`, but not equals.
+	auto initialBalanceConstraint = state().balance(state().thisAddress()) >= state().txMember("msg.value");
+	addRule(smtutil::Expression::implies(
+		initialConstraints(_contract) && zeroes && newAddress && initialBalanceConstraint,
+		predicate(entry)
+	), entry.functor().name);
+
+	setCurrentBlock(entry);
+
+	if (encodeExternalCallsAsTrusted())
+	{
+		auto const& entryAfterAddress = *createConstructorBlock(_contract, "implicit_constructor_entry_after_address");
+		state().setAddressActive(state().thisAddress(), true);
+
+		connectBlocks(m_currentBlock, predicate(entryAfterAddress));
+		setCurrentBlock(entryAfterAddress);
+	}
+
+	solAssert(!m_errorDest, "");
+	m_errorDest = m_constructorSummaries.at(&_contract);
+	// We need to evaluate the base constructor calls (arguments) from derived -> base
+	auto baseArgs = baseArguments(_contract);
+	for (auto base: _contract.annotation().linearizedBaseContracts)
+		if (base != &_contract)
+		{
+			m_callGraph[&_contract].insert(base);
+
+			auto baseConstructor = base->constructor();
+			if (baseConstructor && baseArgs.count(base))
+			{
+				std::vector<ASTPointer<Expression>> const& args = baseArgs.at(base);
+				auto const& params = baseConstructor->parameters();
+				solAssert(params.size() == args.size(), "");
+				for (unsigned i = 0; i < params.size(); ++i)
+				{
+					args.at(i)->accept(*this);
+					if (params.at(i))
+					{
+						solAssert(m_context.knownVariable(*params.at(i)), "");
+						m_context.addAssertion(currentValue(*params.at(i)) == expr(*args.at(i), params.at(i)->type()));
+					}
+				}
+			}
+		}
+	m_errorDest = nullptr;
+	// Then call initializer_Base from base -> derived
+	for (auto base: _contract.annotation().linearizedBaseContracts | ranges::views::reverse)
+	{
+		errorFlag().increaseIndex();
+		m_context.addAssertion(smt::constructorCall(*m_contractInitializers.at(&_contract).at(base), m_context));
+		connectBlocks(m_currentBlock, summary(_contract), errorFlag().currentValue() > 0);
+		m_context.addAssertion(errorFlag().currentValue() == 0);
+	}
+
+	if (encodeExternalCallsAsTrusted())
+		state().writeStateVars(_contract, state().thisAddress());
+
+	connectBlocks(m_currentBlock, summary(_contract));
+
+	setCurrentBlock(*m_constructorSummaries.at(&_contract));
+
+	solAssert(&_contract == m_currentContract, "");
+	if (shouldAnalyze(_contract))
+	{
+		auto constructor = _contract.constructor();
+		auto txConstraints = state().txTypeConstraints();
+		if (!constructor || !constructor->isPayable())
+			txConstraints = txConstraints && state().txNonPayableConstraint();
+		m_queryPlaceholders[&_contract].push_back({txConstraints, errorFlag().currentValue(), m_currentBlock});
+		connectBlocks(m_currentBlock, interface(), txConstraints && errorFlag().currentValue() == 0);
+	}
+
+	solAssert(m_scopes.back() == &_contract, "");
+	m_scopes.pop_back();
+
+	SMTEncoder::endVisit(_contract);
+}
+
+bool CHC::visit(FunctionDefinition const& _function)
+{
+	// Free functions need to be visited in the context of a contract.
+	if (!m_currentContract)
+		return false;
+
+	if (
+		!_function.isImplemented() ||
+		abstractAsNondet(_function)
+	)
+	{
+		smtutil::Expression conj(true);
+		if (
+			_function.stateMutability() == StateMutability::Pure ||
+			_function.stateMutability() == StateMutability::View
+		)
+			conj = conj && currentEqualInitialVarsConstraints(stateVariablesIncludingInheritedAndPrivate(_function));
+
+		conj = conj && errorFlag().currentValue() == 0;
+		addRule(smtutil::Expression::implies(conj, summary(_function)), "summary_function_" + std::to_string(_function.id()));
+		return false;
+	}
+
+	// No inlining.
+	solAssert(!m_currentFunction, "Function inlining should not happen in CHC.");
+	m_currentFunction = &_function;
+
+	m_scopes.push_back(&_function);
+
+	initFunction(_function);
+
+	auto functionEntryBlock = createBlock(m_currentFunction, PredicateType::FunctionBlock);
+	auto bodyBlock = createBlock(&m_currentFunction->body(), PredicateType::FunctionBlock);
+
+	auto functionPred = predicate(*functionEntryBlock);
+	auto bodyPred = predicate(*bodyBlock);
+
+	addRule(functionPred, functionPred.name);
+
+	solAssert(m_currentContract, "");
+	m_context.addAssertion(initialConstraints(*m_currentContract, &_function));
+
+	connectBlocks(functionPred, bodyPred);
+
+	setCurrentBlock(*bodyBlock);
+
+	solAssert(!m_errorDest, "");
+	m_errorDest = m_summaries.at(m_currentContract).at(&_function);
+	SMTEncoder::visit(*m_currentFunction);
+	m_errorDest = nullptr;
+
+	return false;
+}
+
+void CHC::endVisit(FunctionDefinition const& _function)
+{
+	// Free functions need to be visited in the context of a contract.
+	if (!m_currentContract)
+		return;
+
+	if (
+		!_function.isImplemented() ||
+		abstractAsNondet(_function)
+	)
+		return;
+
+	solAssert(m_currentFunction && m_currentContract, "");
+	// No inlining.
+	solAssert(m_currentFunction == &_function, "");
+
+	solAssert(m_scopes.back() == &_function, "");
+	m_scopes.pop_back();
+
+	connectBlocks(m_currentBlock, summary(_function));
+	setCurrentBlock(*m_summaries.at(m_currentContract).at(&_function));
+
+	// Query placeholders for constructors are not created here because
+	// of contracts without constructors.
+	// Instead, those are created in endVisit(ContractDefinition).
+	if (
+		!_function.isConstructor() &&
+		_function.isPublic() &&
+		contractFunctions(*m_currentContract).count(&_function) &&
+		shouldAnalyze(*m_currentContract)
+	)
+	{
+		defineExternalFunctionInterface(_function, *m_currentContract);
+		setCurrentBlock(*m_interfaces.at(m_currentContract));
+
+		// Create the rule
+		// interface \land externalFunctionEntry => interface'
+		auto ifacePre = smt::interfacePre(*m_interfaces.at(m_currentContract), *m_currentContract, m_context);
+		auto sum = externalSummary(_function);
+
+		m_queryPlaceholders[&_function].push_back({sum, errorFlag().currentValue(), ifacePre});
+		connectBlocks(ifacePre, interface(), sum && errorFlag().currentValue() == 0);
+	}
+
+	m_currentFunction = nullptr;
+
+	SMTEncoder::endVisit(_function);
+}
+
+bool CHC::visit(Block const& _block)
+{
+	m_scopes.push_back(&_block);
+	return SMTEncoder::visit(_block);
+}
+
+void CHC::endVisit(Block const& _block)
+{
+	solAssert(m_scopes.back() == &_block, "");
+	m_scopes.pop_back();
+	SMTEncoder::endVisit(_block);
+}
+
+bool CHC::visit(IfStatement const& _if)
+{
+	solAssert(m_currentFunction, "");
+
+	bool unknownFunctionCallWasSeen = m_unknownFunctionCallSeen;
+	m_unknownFunctionCallSeen = false;
+
+	solAssert(m_currentFunction, "");
+	auto const& functionBody = m_currentFunction->body();
+
+	auto ifHeaderBlock = createBlock(&_if, PredicateType::FunctionBlock, "if_header_");
+	auto trueBlock = createBlock(&_if.trueStatement(), PredicateType::FunctionBlock, "if_true_");
+	auto falseBlock = _if.falseStatement() ? createBlock(_if.falseStatement(), PredicateType::FunctionBlock, "if_false_") : nullptr;
+	auto afterIfBlock = createBlock(&functionBody, PredicateType::FunctionBlock);
+
+	connectBlocks(m_currentBlock, predicate(*ifHeaderBlock));
+
+	setCurrentBlock(*ifHeaderBlock);
+	_if.condition().accept(*this);
+	auto condition = expr(_if.condition());
+
+	connectBlocks(m_currentBlock, predicate(*trueBlock), condition);
+	if (_if.falseStatement())
+		connectBlocks(m_currentBlock, predicate(*falseBlock), !condition);
+	else
+		connectBlocks(m_currentBlock, predicate(*afterIfBlock), !condition);
+
+	setCurrentBlock(*trueBlock);
+	_if.trueStatement().accept(*this);
+	connectBlocks(m_currentBlock, predicate(*afterIfBlock));
+
+	if (_if.falseStatement())
+	{
+		setCurrentBlock(*falseBlock);
+		_if.falseStatement()->accept(*this);
+		connectBlocks(m_currentBlock, predicate(*afterIfBlock));
+	}
+
+	setCurrentBlock(*afterIfBlock);
+
+	if (m_unknownFunctionCallSeen)
+		eraseKnowledge();
+
+	m_unknownFunctionCallSeen = unknownFunctionCallWasSeen;
+
+	return false;
+}
+
+bool CHC::visit(WhileStatement const& _while)
+{
+	bool unknownFunctionCallWasSeen = m_unknownFunctionCallSeen;
+	m_unknownFunctionCallSeen = false;
+
+	solAssert(m_currentFunction, "");
+	auto const& functionBody = m_currentFunction->body();
+
+	auto namePrefix = std::string(_while.isDoWhile() ? "do_" : "") + "while";
+	auto loopHeaderBlock = createBlock(&_while, PredicateType::FunctionBlock, namePrefix + "_header_");
+	auto loopBodyBlock = createBlock(&_while.body(), PredicateType::FunctionBlock, namePrefix + "_body_");
+	auto afterLoopBlock = createBlock(&functionBody, PredicateType::FunctionBlock);
+
+	auto outerBreakDest = m_breakDest;
+	auto outerContinueDest = m_continueDest;
+	m_breakDest = afterLoopBlock;
+	m_continueDest = loopHeaderBlock;
+
+	if (_while.isDoWhile())
+		_while.body().accept(*this);
+
+	connectBlocks(m_currentBlock, predicate(*loopHeaderBlock));
+
+	setCurrentBlock(*loopHeaderBlock);
+
+	_while.condition().accept(*this);
+	auto condition = expr(_while.condition());
+
+	connectBlocks(m_currentBlock, predicate(*loopBodyBlock), condition);
+	connectBlocks(m_currentBlock, predicate(*afterLoopBlock), !condition);
+
+	// Loop body visit.
+	setCurrentBlock(*loopBodyBlock);
+	_while.body().accept(*this);
+
+	m_breakDest = outerBreakDest;
+	m_continueDest = outerContinueDest;
+
+	// Back edge.
+	connectBlocks(m_currentBlock, predicate(*loopHeaderBlock));
+	setCurrentBlock(*afterLoopBlock);
+
+	if (m_unknownFunctionCallSeen)
+		eraseKnowledge();
+
+	m_unknownFunctionCallSeen = unknownFunctionCallWasSeen;
+
+	return false;
+}
+
+bool CHC::visit(ForStatement const& _for)
+{
+	m_scopes.push_back(&_for);
+
+	bool unknownFunctionCallWasSeen = m_unknownFunctionCallSeen;
+	m_unknownFunctionCallSeen = false;
+
+	solAssert(m_currentFunction, "");
+	auto const& functionBody = m_currentFunction->body();
+
+	auto loopHeaderBlock = createBlock(&_for, PredicateType::FunctionBlock, "for_header_");
+	auto loopBodyBlock = createBlock(&_for.body(), PredicateType::FunctionBlock, "for_body_");
+	auto afterLoopBlock = createBlock(&functionBody, PredicateType::FunctionBlock);
+	auto postLoop = _for.loopExpression();
+	auto postLoopBlock = postLoop ? createBlock(postLoop, PredicateType::FunctionBlock, "for_post_") : nullptr;
+
+	auto outerBreakDest = m_breakDest;
+	auto outerContinueDest = m_continueDest;
+	m_breakDest = afterLoopBlock;
+	m_continueDest = postLoop ? postLoopBlock : loopHeaderBlock;
+
+	if (auto init = _for.initializationExpression())
+		init->accept(*this);
+
+	connectBlocks(m_currentBlock, predicate(*loopHeaderBlock));
+	setCurrentBlock(*loopHeaderBlock);
+
+	auto condition = smtutil::Expression(true);
+	if (auto forCondition = _for.condition())
+	{
+		forCondition->accept(*this);
+		condition = expr(*forCondition);
+	}
+
+	connectBlocks(m_currentBlock, predicate(*loopBodyBlock), condition);
+	connectBlocks(m_currentBlock, predicate(*afterLoopBlock), !condition);
+
+	// Loop body visit.
+	setCurrentBlock(*loopBodyBlock);
+	_for.body().accept(*this);
+
+	if (postLoop)
+	{
+		connectBlocks(m_currentBlock, predicate(*postLoopBlock));
+		setCurrentBlock(*postLoopBlock);
+		postLoop->accept(*this);
+	}
+
+	m_breakDest = outerBreakDest;
+	m_continueDest = outerContinueDest;
+
+	// Back edge.
+	connectBlocks(m_currentBlock, predicate(*loopHeaderBlock));
+	setCurrentBlock(*afterLoopBlock);
+
+	if (m_unknownFunctionCallSeen)
+		eraseKnowledge();
+
+	m_unknownFunctionCallSeen = unknownFunctionCallWasSeen;
+
+	return false;
+}
+
+void CHC::endVisit(ForStatement const& _for)
+{
+	solAssert(m_scopes.back() == &_for, "");
+	m_scopes.pop_back();
+}
+
+void CHC::endVisit(UnaryOperation const& _op)
+{
+	SMTEncoder::endVisit(_op);
+
+	if (auto funDef = *_op.annotation().userDefinedFunction)
+	{
+		std::vector<Expression const*> arguments;
+		arguments.push_back(&_op.subExpression());
+		internalFunctionCall(funDef, std::nullopt, _op.userDefinedFunctionType(), arguments, state().thisAddress());
+
+		createReturnedExpressions(funDef, _op);
+	}
+}
+
+void CHC::endVisit(BinaryOperation const& _op)
+{
+	SMTEncoder::endVisit(_op);
+
+	if (auto funDef = *_op.annotation().userDefinedFunction)
+	{
+		std::vector<Expression const*> arguments;
+		arguments.push_back(&_op.leftExpression());
+		arguments.push_back(&_op.rightExpression());
+		internalFunctionCall(funDef, std::nullopt, _op.userDefinedFunctionType(), arguments, state().thisAddress());
+
+		createReturnedExpressions(funDef, _op);
+	}
+}
+
+void CHC::endVisit(FunctionCall const& _funCall)
+{
+	auto functionCallKind = *_funCall.annotation().kind;
+
+	if (functionCallKind != FunctionCallKind::FunctionCall)
+	{
+		SMTEncoder::endVisit(_funCall);
+		return;
+	}
+
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	switch (funType.kind())
+	{
+	case FunctionType::Kind::Assert:
+		visitAssert(_funCall);
+		SMTEncoder::endVisit(_funCall);
+		break;
+	case FunctionType::Kind::Internal:
+		internalFunctionCall(_funCall);
+		break;
+	case FunctionType::Kind::External:
+	case FunctionType::Kind::BareStaticCall:
+	case FunctionType::Kind::BareCall:
+		externalFunctionCall(_funCall);
+		SMTEncoder::endVisit(_funCall);
+		break;
+	case FunctionType::Kind::Creation:
+		visitDeployment(_funCall);
+		break;
+	case FunctionType::Kind::DelegateCall:
+	case FunctionType::Kind::BareCallCode:
+	case FunctionType::Kind::BareDelegateCall:
+		SMTEncoder::endVisit(_funCall);
+		unknownFunctionCall(_funCall);
+		break;
+	case FunctionType::Kind::KECCAK256:
+	case FunctionType::Kind::ECRecover:
+	case FunctionType::Kind::SHA256:
+	case FunctionType::Kind::RIPEMD160:
+	case FunctionType::Kind::BlockHash:
+	case FunctionType::Kind::AddMod:
+	case FunctionType::Kind::MulMod:
+	case FunctionType::Kind::Unwrap:
+	case FunctionType::Kind::Wrap:
+		[[fallthrough]];
+	default:
+		SMTEncoder::endVisit(_funCall);
+		break;
+	}
+
+	auto funDef = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	createReturnedExpressions(funDef, _funCall);
+}
+
+void CHC::endVisit(Break const& _break)
+{
+	solAssert(m_breakDest, "");
+	connectBlocks(m_currentBlock, predicate(*m_breakDest));
+
+	// Add an unreachable ghost node to collect unreachable statements after a break.
+	auto breakGhost = createBlock(&_break, PredicateType::FunctionBlock, "break_ghost_");
+	m_currentBlock = predicate(*breakGhost);
+}
+
+void CHC::endVisit(Continue const& _continue)
+{
+	solAssert(m_continueDest, "");
+	connectBlocks(m_currentBlock, predicate(*m_continueDest));
+
+	// Add an unreachable ghost node to collect unreachable statements after a continue.
+	auto continueGhost = createBlock(&_continue, PredicateType::FunctionBlock, "continue_ghost_");
+	m_currentBlock = predicate(*continueGhost);
+}
+
+void CHC::endVisit(IndexRangeAccess const& _range)
+{
+	createExpr(_range);
+
+	auto baseArray = std::dynamic_pointer_cast<SymbolicArrayVariable>(m_context.expression(_range.baseExpression()));
+	auto sliceArray = std::dynamic_pointer_cast<SymbolicArrayVariable>(m_context.expression(_range));
+	solAssert(baseArray && sliceArray, "");
+
+	auto const& sliceData = ArraySlicePredicate::create(sliceArray->sort(), m_context);
+	if (!sliceData.first)
+	{
+		for (auto pred: sliceData.second.predicates)
+			m_interface->registerRelation(pred->functor());
+		for (auto const& rule: sliceData.second.rules)
+			addRule(rule, "");
+	}
+
+	auto start = _range.startExpression() ? expr(*_range.startExpression()) : 0;
+	auto end = _range.endExpression() ? expr(*_range.endExpression()) : baseArray->length();
+	auto slicePred = (*sliceData.second.predicates.at(0))({
+		baseArray->elements(),
+		sliceArray->elements(),
+		start,
+		end
+	});
+
+	m_context.addAssertion(slicePred);
+	m_context.addAssertion(sliceArray->length() == end - start);
+}
+
+void CHC::endVisit(Return const& _return)
+{
+	SMTEncoder::endVisit(_return);
+
+	connectBlocks(m_currentBlock, predicate(*m_returnDests.back()));
+
+	// Add an unreachable ghost node to collect unreachable statements after a return.
+	auto returnGhost = createBlock(&_return, PredicateType::FunctionBlock, "return_ghost_");
+	m_currentBlock = predicate(*returnGhost);
+}
+
+bool CHC::visit(TryCatchClause const& _tryStatement)
+{
+	m_scopes.push_back(&_tryStatement);
+	return SMTEncoder::visit(_tryStatement);
+}
+
+void CHC::endVisit(TryCatchClause const& _tryStatement)
+{
+	solAssert(m_scopes.back() == &_tryStatement, "");
+	m_scopes.pop_back();
+}
+
+bool CHC::visit(TryStatement const& _tryStatement)
+{
+	FunctionCall const* externalCall = dynamic_cast<FunctionCall const*>(&_tryStatement.externalCall());
+	solAssert(externalCall && externalCall->annotation().tryCall, "");
+	solAssert(m_currentFunction, "");
+
+	auto tryHeaderBlock = createBlock(&_tryStatement, PredicateType::FunctionBlock, "try_header_");
+	auto afterTryBlock = createBlock(&m_currentFunction->body(), PredicateType::FunctionBlock);
+
+	auto const& clauses = _tryStatement.clauses();
+	solAssert(clauses[0].get() == _tryStatement.successClause(), "First clause of TryStatement should be the success clause");
+	auto clauseBlocks = applyMap(clauses, [this](ASTPointer<TryCatchClause> clause) {
+		return createBlock(clause.get(), PredicateType::FunctionBlock, "try_clause_" + std::to_string(clause->id()));
+	});
+
+	connectBlocks(m_currentBlock, predicate(*tryHeaderBlock));
+	setCurrentBlock(*tryHeaderBlock);
+	// Visit everything, except the actual external call.
+	externalCall->expression().accept(*this);
+	ASTNode::listAccept(externalCall->arguments(), *this);
+	// Branch directly to all catch clauses, since in these cases, any effects of the external call are reverted.
+	for (size_t i = 1; i < clauseBlocks.size(); ++i)
+		connectBlocks(m_currentBlock, predicate(*clauseBlocks[i]));
+	// Only now visit the actual call to record its effects and connect to the success clause.
+	endVisit(*externalCall);
+	if (_tryStatement.successClause()->parameters())
+		expressionToTupleAssignment(_tryStatement.successClause()->parameters()->parameters(), *externalCall);
+
+	connectBlocks(m_currentBlock, predicate(*clauseBlocks[0]));
+
+	for (size_t i = 0; i < clauses.size(); ++i)
+	{
+		setCurrentBlock(*clauseBlocks[i]);
+		clauses[i]->accept(*this);
+		connectBlocks(m_currentBlock, predicate(*afterTryBlock));
+	}
+	setCurrentBlock(*afterTryBlock);
+
+	return false;
+}
+
+void CHC::pushInlineFrame(CallableDeclaration const& _callable)
+{
+	m_returnDests.push_back(createBlock(&_callable, PredicateType::FunctionBlock, "return_"));
+}
+
+void CHC::popInlineFrame(CallableDeclaration const& _callable)
+{
+	solAssert(!m_returnDests.empty(), "");
+	auto const& ret = *m_returnDests.back();
+	solAssert(ret.programNode() == &_callable, "");
+	connectBlocks(m_currentBlock, predicate(ret));
+	setCurrentBlock(ret);
+	m_returnDests.pop_back();
+}
+
+void CHC::visitAssert(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() == 1, "");
+	solAssert(args.front()->annotation().type->category() == Type::Category::Bool, "");
+
+	solAssert(m_currentContract, "");
+	solAssert(m_currentFunction, "");
+	auto errorCondition = !m_context.expression(*args.front())->currentValue();
+	verificationTargetEncountered(&_funCall, VerificationTargetType::Assert, errorCondition);
+}
+
+void CHC::visitPublicGetter(FunctionCall const& _funCall)
+{
+	createExpr(_funCall);
+	if (encodeExternalCallsAsTrusted())
+	{
+		auto const& access = dynamic_cast<MemberAccess const&>(_funCall.expression());
+		auto const& contractType = dynamic_cast<ContractType const&>(*access.expression().annotation().type);
+		state().writeStateVars(*m_currentContract, state().thisAddress());
+		state().readStateVars(contractType.contractDefinition(), expr(access.expression()));
+	}
+	SMTEncoder::visitPublicGetter(_funCall);
+}
+
+void CHC::visitAddMulMod(FunctionCall const& _funCall)
+{
+	solAssert(_funCall.arguments().at(2), "");
+
+	verificationTargetEncountered(&_funCall, VerificationTargetType::DivByZero, expr(*_funCall.arguments().at(2)) == 0);
+
+	SMTEncoder::visitAddMulMod(_funCall);
+}
+
+void CHC::visitDeployment(FunctionCall const& _funCall)
+{
+	if (!encodeExternalCallsAsTrusted())
+	{
+		SMTEncoder::endVisit(_funCall);
+		unknownFunctionCall(_funCall);
+		return;
+	}
+
+	auto [callExpr, callOptions] = functionCallExpression(_funCall);
+	auto funType = dynamic_cast<FunctionType const*>(callExpr->annotation().type);
+	ContractDefinition const* contract =
+		&dynamic_cast<ContractType const&>(*funType->returnParameterTypes().front()).contractDefinition();
+
+	// copy state variables from m_currentContract to state.storage.
+	state().writeStateVars(*m_currentContract, state().thisAddress());
+	errorFlag().increaseIndex();
+
+	Expression const* value = valueOption(callOptions);
+	if (value)
+		decreaseBalanceFromOptionsValue(*value);
+
+	auto originalTx = state().tx();
+	newTxConstraints(value);
+
+	auto prevThisAddr = state().thisAddress();
+	auto newAddr = state().newThisAddress();
+
+	if (auto constructor = contract->constructor())
+	{
+		auto const& args = _funCall.sortedArguments();
+		auto const& params = constructor->parameters();
+		solAssert(args.size() == params.size(), "");
+		for (auto [arg, param]: ranges::zip_view(args, params))
+			m_context.addAssertion(expr(*arg) == m_context.variable(*param)->currentValue());
+	}
+	for (auto var: stateVariablesIncludingInheritedAndPrivate(*contract))
+		m_context.variable(*var)->increaseIndex();
+	Predicate const& constructorSummary = *m_constructorSummaries.at(contract);
+	m_context.addAssertion(smt::constructorCall(constructorSummary, m_context, false));
+
+	solAssert(m_errorDest, "");
+	connectBlocks(
+		m_currentBlock,
+		predicate(*m_errorDest),
+		errorFlag().currentValue() > 0
+	);
+	m_context.addAssertion(errorFlag().currentValue() == 0);
+
+	m_context.addAssertion(state().newThisAddress() == prevThisAddr);
+
+	// copy state variables from state.storage to m_currentContract.
+	state().readStateVars(*m_currentContract, state().thisAddress());
+
+	state().newTx();
+	m_context.addAssertion(originalTx == state().tx());
+
+	defineExpr(_funCall, newAddr);
+}
+
+void CHC::internalFunctionCall(
+	FunctionDefinition const* _funDef,
+	std::optional<Expression const*> _boundArgumentCall,
+	FunctionType const* _funType,
+	std::vector<Expression const*> const& _arguments,
+	smtutil::Expression _contractAddressValue
+)
+{
+	solAssert(m_currentContract, "");
+	solAssert(_funType, "");
+
+	if (_funDef)
+	{
+		if (m_currentFunction && !m_currentFunction->isConstructor())
+			m_callGraph[m_currentFunction].insert(_funDef);
+		else
+			m_callGraph[m_currentContract].insert(_funDef);
+	}
+
+	m_context.addAssertion(predicate(_funDef, _boundArgumentCall, _funType, _arguments, _contractAddressValue));
+
+	solAssert(m_errorDest, "");
+	connectBlocks(
+		m_currentBlock,
+		predicate(*m_errorDest),
+		errorFlag().currentValue() > 0 && currentPathConditions()
+	);
+	m_context.addAssertion(smtutil::Expression::implies(currentPathConditions(), errorFlag().currentValue() == 0));
+	m_context.addAssertion(errorFlag().increaseIndex() == 0);
+}
+
+void CHC::internalFunctionCall(FunctionCall const& _funCall)
+{
+	solAssert(m_currentContract, "");
+
+	auto funDef = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	if (funDef)
+	{
+		if (m_currentFunction && !m_currentFunction->isConstructor())
+			m_callGraph[m_currentFunction].insert(funDef);
+		else
+			m_callGraph[m_currentContract].insert(funDef);
+	}
+
+	Expression const* calledExpr = &_funCall.expression();
+	auto funType = dynamic_cast<FunctionType const*>(calledExpr->annotation().type);
+
+	auto contractAddressValue = [this](FunctionCall const& _f) {
+		auto [callExpr, callOptions] = functionCallExpression(_f);
+
+		FunctionType const& funType = dynamic_cast<FunctionType const&>(*callExpr->annotation().type);
+		if (funType.kind() == FunctionType::Kind::Internal)
+			return state().thisAddress();
+		if (MemberAccess const* callBase = dynamic_cast<MemberAccess const*>(callExpr))
+			return expr(callBase->expression());
+		solAssert(false, "Unreachable!");
+	};
+
+	std::vector<Expression const*> arguments;
+	for (auto& arg: _funCall.sortedArguments())
+		arguments.push_back(&(*arg));
+
+	std::optional<Expression const*> boundArgumentCall =
+		funType->hasBoundFirstArgument() ? std::make_optional(calledExpr) : std::nullopt;
+	internalFunctionCall(funDef, boundArgumentCall, funType, arguments, contractAddressValue(_funCall));
+}
+
+void CHC::addNondetCalls(ContractDefinition const& _contract)
+{
+	for (auto var: _contract.stateVariables())
+		if (auto contractType = dynamic_cast<ContractType const*>(var->type()))
+		{
+			auto const& symbVar = m_context.variable(*var);
+			m_context.addAssertion(symbVar->currentValue() == symbVar->valueAtIndex(0));
+			nondetCall(contractType->contractDefinition(), *var);
+		}
+}
+
+void CHC::nondetCall(ContractDefinition const& _contract, VariableDeclaration const& _var)
+{
+	auto address = m_context.variable(_var)->currentValue();
+	// Load the called contract's state variables from the global state.
+	state().readStateVars(_contract, address);
+
+	m_context.addAssertion(state().state() == state().state(0));
+	auto preCallState = std::vector<smtutil::Expression>{state().state()} + currentStateVariables(_contract);
+
+	state().newState();
+	for (auto const* var: _contract.stateVariables())
+		m_context.variable(*var)->increaseIndex();
+
+	Predicate const& callPredicate = *createSymbolicBlock(
+		nondetInterfaceSort(_contract, state()),
+		"nondet_call_" + uniquePrefix(),
+		PredicateType::FunctionSummary,
+		&_var,
+		m_currentContract
+	);
+	auto postCallState = std::vector<smtutil::Expression>{state().state()} + currentStateVariables(_contract);
+	std::vector<smtutil::Expression> stateExprs = commonStateExpressions(errorFlag().increaseIndex(), address);
+
+	auto nondet = (*m_nondetInterfaces.at(&_contract))(stateExprs + preCallState + postCallState);
+	auto nondetCall = callPredicate(stateExprs + preCallState + postCallState);
+
+	addRule(smtutil::Expression::implies(nondet, nondetCall), nondetCall.name);
+
+	m_context.addAssertion(nondetCall);
+
+	// Load the called contract's state variables into the global state.
+	state().writeStateVars(_contract, address);
+}
+
+void CHC::externalFunctionCall(FunctionCall const& _funCall)
+{
+	/// In external function calls we do not add a "predicate call"
+	/// because we do not trust their function body anyway,
+	/// so we just add the nondet_interface predicate.
+
+	solAssert(m_currentContract, "");
+
+	auto [callExpr, callOptions] = functionCallExpression(_funCall);
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*callExpr->annotation().type);
+
+	auto kind = funType.kind();
+	solAssert(
+		kind == FunctionType::Kind::External ||
+		kind == FunctionType::Kind::BareCall ||
+		kind == FunctionType::Kind::BareStaticCall,
+		""
+	);
+
+
+	// Only consider high level external calls in trusted mode.
+	if (
+		kind == FunctionType::Kind::External &&
+		(encodeExternalCallsAsTrusted() || isExternalCallToThis(callExpr))
+	)
+	{
+		externalFunctionCallToTrustedCode(_funCall);
+		return;
+	}
+
+	// Low level calls are still encoded nondeterministically.
+
+	auto function = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	if (function)
+		for (auto var: function->returnParameters())
+			m_context.variable(*var)->increaseIndex();
+
+	// If we see a low level call in trusted mode,
+	// we need to havoc the global state.
+	if (
+		kind == FunctionType::Kind::BareCall &&
+		encodeExternalCallsAsTrusted()
+	)
+		state().newStorage();
+
+	// No reentrancy from constructor calls.
+	if (!m_currentFunction || m_currentFunction->isConstructor())
+		return;
+
+	if (Expression const* value = valueOption(callOptions))
+		decreaseBalanceFromOptionsValue(*value);
+
+	auto preCallState = std::vector<smtutil::Expression>{state().state()} + currentStateVariables();
+
+	if (!usesStaticCall(_funCall))
+	{
+		state().newState();
+		for (auto const* var: m_stateVariables)
+			m_context.variable(*var)->increaseIndex();
+	}
+
+	Predicate const& callPredicate = *createSymbolicBlock(
+		nondetInterfaceSort(*m_currentContract, state()),
+		"nondet_call_" + uniquePrefix(),
+		PredicateType::ExternalCallUntrusted,
+		&_funCall
+	);
+	auto postCallState = std::vector<smtutil::Expression>{state().state()} + currentStateVariables();
+	std::vector<smtutil::Expression> stateExprs = commonStateExpressions(errorFlag().increaseIndex(), state().thisAddress());
+
+	auto nondet = (*m_nondetInterfaces.at(m_currentContract))(stateExprs + preCallState + postCallState);
+	auto nondetCall = callPredicate(stateExprs + preCallState + postCallState);
+
+	addRule(smtutil::Expression::implies(nondet, nondetCall), nondetCall.name);
+
+	m_context.addAssertion(nondetCall);
+	solAssert(m_errorDest, "");
+	connectBlocks(m_currentBlock, predicate(*m_errorDest), errorFlag().currentValue() > 0 && currentPathConditions());
+
+	// To capture the possibility of a reentrant call, we record in the call graph that the  current function
+	// can call any of the external methods of the current contract.
+	if (m_currentFunction)
+		for (auto const* definedFunction: contractFunctions(*m_currentContract))
+			if (!definedFunction->isConstructor() && definedFunction->isPublic())
+				m_callGraph[m_currentFunction].insert(definedFunction);
+
+	m_context.addAssertion(errorFlag().currentValue() == 0);
+}
+
+void CHC::externalFunctionCallToTrustedCode(FunctionCall const& _funCall)
+{
+	if (publicGetter(_funCall.expression()))
+		visitPublicGetter(_funCall);
+
+	solAssert(m_currentContract, "");
+
+	auto [callExpr, callOptions] = functionCallExpression(_funCall);
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*callExpr->annotation().type);
+
+	auto kind = funType.kind();
+	solAssert(kind == FunctionType::Kind::External || kind == FunctionType::Kind::BareStaticCall, "");
+
+	auto function = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	if (!function)
+		return;
+
+	// Remember the external call in the call graph to properly detect verification targets for the current function
+	if (m_currentFunction && !m_currentFunction->isConstructor())
+		m_callGraph[m_currentFunction].insert(function);
+	else
+		m_callGraph[m_currentContract].insert(function);
+
+	// External call creates a new transaction.
+	auto originalTx = state().tx();
+	Expression const* value = valueOption(callOptions);
+	newTxConstraints(value);
+
+	auto calledAddress = contractAddressValue(_funCall);
+	if (value)
+	{
+		decreaseBalanceFromOptionsValue(*value);
+		state().addBalance(calledAddress, expr(*value));
+	}
+
+	if (encodeExternalCallsAsTrusted())
+	{
+		// The order here is important!! Write should go first.
+
+		// Load the caller contract's state variables into the global state.
+		state().writeStateVars(*m_currentContract, state().thisAddress());
+		// Load the called contract's state variables from the global state.
+		state().readStateVars(*function->annotation().contract, contractAddressValue(_funCall));
+	}
+
+	std::vector<Expression const*> arguments;
+	for (auto& arg: _funCall.sortedArguments())
+		arguments.push_back(&(*arg));
+	smtutil::Expression pred = predicate(function, std::nullopt, &funType, arguments, calledAddress);
+
+	auto txConstraints = state().txTypeConstraints() && state().txFunctionConstraints(*function);
+	m_context.addAssertion(pred && txConstraints);
+	// restore the original transaction data
+	state().newTx();
+	m_context.addAssertion(originalTx == state().tx());
+
+	solAssert(m_errorDest, "");
+	connectBlocks(
+		m_currentBlock,
+		predicate(*m_errorDest),
+		(errorFlag().currentValue() > 0)
+	);
+	m_context.addAssertion(errorFlag().currentValue() == 0);
+
+	if (!usesStaticCall(_funCall))
+		if (encodeExternalCallsAsTrusted())
+		{
+			// The order here is important!! Write should go first.
+
+			// Load the called contract's state variables into the global state.
+			state().writeStateVars(*function->annotation().contract, contractAddressValue(_funCall));
+			// Load the caller contract's state variables from the global state.
+			state().readStateVars(*m_currentContract, state().thisAddress());
+		}
+}
+
+void CHC::unknownFunctionCall(FunctionCall const&)
+{
+	/// Function calls are not handled at the moment,
+	/// so always erase knowledge.
+	/// TODO remove when function calls get predicates/blocks.
+	eraseKnowledge();
+
+	/// Used to erase outer scope knowledge in loops and ifs.
+	/// TODO remove when function calls get predicates/blocks.
+	m_unknownFunctionCallSeen = true;
+}
+
+void CHC::makeArrayPopVerificationTarget(FunctionCall const& _arrayPop)
+{
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_arrayPop.expression().annotation().type);
+	solAssert(funType.kind() == FunctionType::Kind::ArrayPop, "");
+
+	auto memberAccess = dynamic_cast<MemberAccess const*>(cleanExpression(_arrayPop.expression()));
+	solAssert(memberAccess, "");
+	auto symbArray = std::dynamic_pointer_cast<SymbolicArrayVariable>(m_context.expression(memberAccess->expression()));
+	solAssert(symbArray, "");
+
+	verificationTargetEncountered(&_arrayPop, VerificationTargetType::PopEmptyArray, symbArray->length() <= 0);
+}
+
+void CHC::makeOutOfBoundsVerificationTarget(IndexAccess const& _indexAccess)
+{
+	if (_indexAccess.annotation().type->category() == Type::Category::TypeType)
+		return;
+
+	auto baseType = _indexAccess.baseExpression().annotation().type;
+
+	std::optional<smtutil::Expression> length;
+	if (smt::isArray(*baseType))
+		length = dynamic_cast<smt::SymbolicArrayVariable const&>(
+			*m_context.expression(_indexAccess.baseExpression())
+		).length();
+	else if (auto const* type = dynamic_cast<FixedBytesType const*>(baseType))
+		length = smtutil::Expression(static_cast<size_t>(type->numBytes()));
+
+	std::optional<smtutil::Expression> target;
+	if (
+		auto index = _indexAccess.indexExpression();
+		index && length
+	)
+		target = expr(*index) < 0 || expr(*index) >= *length;
+
+	if (target)
+		verificationTargetEncountered(&_indexAccess, VerificationTargetType::OutOfBounds, *target);
+}
+
+std::pair<smtutil::Expression, smtutil::Expression> CHC::arithmeticOperation(
+	Token _op,
+	smtutil::Expression const& _left,
+	smtutil::Expression const& _right,
+	Type const* _commonType,
+	frontend::Expression const& _expression
+)
+{
+	// Unchecked does not disable div by 0 checks.
+	if (_op == Token::Mod || _op == Token::Div)
+		verificationTargetEncountered(&_expression, VerificationTargetType::DivByZero, _right == 0);
+
+	auto values = SMTEncoder::arithmeticOperation(_op, _left, _right, _commonType, _expression);
+
+	if (!m_checked)
+		return values;
+
+	IntegerType const* intType = nullptr;
+	if (auto const* type = dynamic_cast<IntegerType const*>(_commonType))
+		intType = type;
+	else
+		intType = TypeProvider::uint256();
+
+	// Mod does not need underflow/overflow checks.
+	// Div only needs overflow check for signed types.
+	if (_op == Token::Mod || (_op == Token::Div && !intType->isSigned()))
+		return values;
+
+	if (_op == Token::Div)
+		verificationTargetEncountered(&_expression, VerificationTargetType::Overflow, values.second > intType->maxValue());
+	else if (intType->isSigned())
+	{
+		verificationTargetEncountered(&_expression, VerificationTargetType::Underflow, values.second < intType->minValue());
+		verificationTargetEncountered(&_expression, VerificationTargetType::Overflow, values.second > intType->maxValue());
+	}
+	else if (_op == Token::Sub)
+		verificationTargetEncountered(&_expression, VerificationTargetType::Underflow, values.second < intType->minValue());
+	else if (_op == Token::Add || _op == Token::Mul)
+		verificationTargetEncountered(&_expression, VerificationTargetType::Overflow, values.second > intType->maxValue());
+	else
+		solAssert(false, "");
+	return values;
+}
+
+void CHC::resetSourceAnalysis()
+{
+	SMTEncoder::resetSourceAnalysis();
+
+	m_unprovedTargets.clear();
+	m_invariants.clear();
+	m_functionTargetIds.clear();
+	m_verificationTargets.clear();
+	m_queryPlaceholders.clear();
+	m_callGraph.clear();
+	m_summaries.clear();
+	m_externalSummaries.clear();
+	m_interfaces.clear();
+	m_nondetInterfaces.clear();
+	m_constructorSummaries.clear();
+	m_contractInitializers.clear();
+	Predicate::reset();
+	ArraySlicePredicate::reset();
+	m_blockCounter = 0;
+
+	// At this point every enabled solver is available.
+	// If more than one Horn solver is selected we go with z3.
+	// We still need the ifdef because of Z3CHCInterface.
+	if (m_settings.solvers.z3)
+	{
+#ifdef HAVE_Z3
+		// z3::fixedpoint does not have a reset mechanism, so we need to create another.
+		m_interface = std::make_unique<Z3CHCInterface>(m_settings.timeout);
+		auto z3Interface = dynamic_cast<Z3CHCInterface const*>(m_interface.get());
+		solAssert(z3Interface, "");
+		m_context.setSolver(z3Interface->z3Interface());
+#else
+		solAssert(false);
+#endif
+	}
+	if (!m_settings.solvers.z3)
+	{
+		solAssert(m_settings.solvers.smtlib2 || m_settings.solvers.eld);
+
+		if (!m_interface)
+			m_interface = std::make_unique<CHCSmtLib2Interface>(m_smtlib2Responses, m_smtCallback, m_settings.solvers, m_settings.timeout);
+
+		auto smtlib2Interface = dynamic_cast<CHCSmtLib2Interface*>(m_interface.get());
+		solAssert(smtlib2Interface, "");
+		smtlib2Interface->reset();
+		m_context.setSolver(smtlib2Interface->smtlib2Interface());
+	}
+
+	m_context.reset();
+	m_context.resetUniqueId();
+	m_context.setAssertionAccumulation(false);
+}
+
+void CHC::resetContractAnalysis()
+{
+	m_stateVariables.clear();
+	m_unknownFunctionCallSeen = false;
+	m_breakDest = nullptr;
+	m_continueDest = nullptr;
+	m_returnDests.clear();
+	errorFlag().resetIndex();
+}
+
+void CHC::eraseKnowledge()
+{
+	resetStorageVariables();
+	resetBalances();
+}
+
+void CHC::clearIndices(ContractDefinition const* _contract, FunctionDefinition const* _function)
+{
+	SMTEncoder::clearIndices(_contract, _function);
+	for (auto const* var: m_stateVariables)
+		/// SSA index 0 is reserved for state variables at the beginning
+		/// of the current transaction.
+		m_context.variable(*var)->increaseIndex();
+	if (_function)
+	{
+		for (auto const& var: _function->parameters() + _function->returnParameters())
+			m_context.variable(*var)->increaseIndex();
+		for (auto const& var: localVariablesIncludingModifiers(*_function, _contract))
+			m_context.variable(*var)->increaseIndex();
+	}
+
+	state().newState();
+}
+
+void CHC::setCurrentBlock(Predicate const& _block)
+{
+	if (m_context.solverStackHeigh() > 0)
+		m_context.popSolver();
+	solAssert(m_currentContract, "");
+	clearIndices(m_currentContract, m_currentFunction);
+	m_context.pushSolver();
+	m_currentBlock = predicate(_block);
+}
+
+std::set<unsigned> CHC::transactionVerificationTargetsIds(ASTNode const* _txRoot)
+{
+	std::set<unsigned> verificationTargetsIds;
+	struct ASTNodeCompare: EncodingContext::IdCompare
+	{
+		bool operator<(ASTNodeCompare _other) const { return operator()(node, _other.node); }
+		ASTNode const* node;
+	};
+	solidity::util::BreadthFirstSearch<ASTNodeCompare>{{{{}, _txRoot}}}.run([&](auto _node, auto&& _addChild) {
+		verificationTargetsIds.insert(m_functionTargetIds[_node.node].begin(), m_functionTargetIds[_node.node].end());
+		for (ASTNode const* called: m_callGraph[_node.node])
+			_addChild({{}, called});
+	});
+	return verificationTargetsIds;
+}
+
+bool CHC::usesStaticCall(FunctionDefinition const* _funDef, FunctionType const* _funType)
+{
+	auto kind = _funType->kind();
+	return (_funDef && (_funDef->stateMutability() == StateMutability::Pure || _funDef->stateMutability() == StateMutability::View)) || kind == FunctionType::Kind::BareStaticCall;
+}
+
+bool CHC::usesStaticCall(FunctionCall const& _funCall)
+{
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	auto kind = funType.kind();
+	auto function = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
+	return (function && (function->stateMutability() == StateMutability::Pure || function->stateMutability() == StateMutability::View)) || kind == FunctionType::Kind::BareStaticCall;
+}
+
+std::optional<CHC::CHCNatspecOption> CHC::natspecOptionFromString(std::string const& _option)
+{
+	static std::map<std::string, CHCNatspecOption> options{
+		{"abstract-function-nondet", CHCNatspecOption::AbstractFunctionNondet}
+	};
+	if (options.count(_option))
+		return options.at(_option);
+	return {};
+}
+
+std::set<CHC::CHCNatspecOption> CHC::smtNatspecTags(FunctionDefinition const& _function)
+{
+	std::set<CHC::CHCNatspecOption> options;
+	std::string smtStr = "custom:smtchecker";
+	bool errorSeen = false;
+	for (auto const& [tag, value]: _function.annotation().docTags)
+		if (tag == smtStr)
+		{
+			std::string const& content = value.content;
+			if (auto option = natspecOptionFromString(content))
+				options.insert(*option);
+			else if (!errorSeen)
+			{
+				errorSeen = true;
+				m_errorReporter.warning(3130_error, _function.location(), "Unknown option for \"" + smtStr + "\": \"" + content + "\"");
+			}
+		}
+	return options;
+}
+
+bool CHC::abstractAsNondet(FunctionDefinition const& _function)
+{
+	return smtNatspecTags(_function).count(CHCNatspecOption::AbstractFunctionNondet);
+}
+
+SortPointer CHC::sort(FunctionDefinition const& _function)
+{
+	return functionBodySort(_function, m_currentContract, state());
+}
+
+bool CHC::encodeExternalCallsAsTrusted()
+{
+	return m_settings.externalCalls.isTrusted();
+}
+
+SortPointer CHC::sort(ASTNode const* _node)
+{
+	if (auto funDef = dynamic_cast<FunctionDefinition const*>(_node))
+		return sort(*funDef);
+
+	solAssert(m_currentFunction, "");
+	return functionBodySort(*m_currentFunction, m_currentContract, state());
+}
+
+Predicate const* CHC::createSymbolicBlock(SortPointer _sort, std::string const& _name, PredicateType _predType, ASTNode const* _node, ContractDefinition const* _contractContext)
+{
+	auto const* block = Predicate::create(_sort, _name, _predType, m_context, _node, _contractContext, m_scopes);
+	m_interface->registerRelation(block->functor());
+	return block;
+}
+
+void CHC::defineInterfacesAndSummaries(SourceUnit const& _source)
+{
+	for (auto const& node: _source.nodes())
+		if (auto const* contract = dynamic_cast<ContractDefinition const*>(node.get()))
+		{
+			std::string suffix = contract->name() + "_" + std::to_string(contract->id());
+			m_interfaces[contract] = createSymbolicBlock(interfaceSort(*contract, state()), "interface_" + uniquePrefix() + "_" + suffix, PredicateType::Interface, contract, contract);
+			m_nondetInterfaces[contract] = createSymbolicBlock(nondetInterfaceSort(*contract, state()), "nondet_interface_" + uniquePrefix() + "_" + suffix, PredicateType::NondetInterface, contract, contract);
+			m_constructorSummaries[contract] = createConstructorBlock(*contract, "summary_constructor");
+
+			for (auto const* var: stateVariablesIncludingInheritedAndPrivate(*contract))
+				if (!m_context.knownVariable(*var))
+					createVariable(*var);
+
+			/// Base nondeterministic interface that allows
+			/// 0 steps to be taken, used as base for the inductive
+			/// rule for each function.
+			auto const& iface = *m_nondetInterfaces.at(contract);
+			addRule(smtutil::Expression::implies(errorFlag().currentValue() == 0, smt::nondetInterface(iface, *contract, m_context, 0, 0)), "base_nondet");
+
+			auto const& resolved = contractFunctions(*contract);
+			for (auto const* function: contractFunctionsWithoutVirtual(*contract) + allFreeFunctions())
+			{
+				for (auto var: function->parameters())
+					createVariable(*var);
+				for (auto var: function->returnParameters())
+					createVariable(*var);
+				for (auto const* var: localVariablesIncludingModifiers(*function, contract))
+					createVariable(*var);
+
+				m_summaries[contract].emplace(function, createSummaryBlock(*function, *contract));
+
+				if (
+					!function->isConstructor() &&
+					function->isPublic() &&
+					// Public library functions should have interfaces only for the libraries
+					// they're declared in.
+					(!function->libraryFunction() || (function->scope() == contract)) &&
+					resolved.count(function)
+				)
+				{
+					m_externalSummaries[contract].emplace(function, createSummaryBlock(*function, *contract));
+
+					auto state1 = stateVariablesAtIndex(1, *contract);
+					auto state2 = stateVariablesAtIndex(2, *contract);
+
+					auto errorPre = errorFlag().currentValue();
+					auto nondetPre = smt::nondetInterface(iface, *contract, m_context, 0, 1);
+					auto errorPost = errorFlag().increaseIndex();
+					auto nondetPost = smt::nondetInterface(iface, *contract, m_context, 0, 2);
+
+					std::vector<smtutil::Expression> args =
+						commonStateExpressions(errorPost, state().thisAddress()) +
+						std::vector<smtutil::Expression>{state().tx(), state().state(1)};
+					args += state1 +
+						applyMap(function->parameters(), [this](auto _var) { return valueAtIndex(*_var, 0); }) +
+						std::vector<smtutil::Expression>{state().state(2)} +
+						state2 +
+						applyMap(function->parameters(), [this](auto _var) { return valueAtIndex(*_var, 1); }) +
+						applyMap(function->returnParameters(), [this](auto _var) { return valueAtIndex(*_var, 1); });
+
+					connectBlocks(nondetPre, nondetPost, errorPre == 0 && (*m_externalSummaries.at(contract).at(function))(args));
+				}
+			}
+		}
+}
+
+void CHC::defineExternalFunctionInterface(FunctionDefinition const& _function, ContractDefinition const& _contract)
+{
+	// Create a rule that represents an external call to this function.
+	// This contains more things than the function body itself,
+	// such as balance updates because of ``msg.value``.
+	auto functionEntryBlock = createBlock(&_function, PredicateType::FunctionBlock);
+	auto functionPred = predicate(*functionEntryBlock);
+	addRule(functionPred, functionPred.name);
+	setCurrentBlock(*functionEntryBlock);
+
+	m_context.addAssertion(initialConstraints(_contract, &_function));
+	m_context.addAssertion(state().txTypeConstraints() && state().txFunctionConstraints(_function));
+
+	// The contract may have received funds through a selfdestruct or
+	// block.coinbase, which do not trigger calls into the contract.
+	// So the only constraint we can add here is that the balance of
+	// the contract grows by at least `msg.value`.
+	SymbolicIntVariable k{TypeProvider::uint256(), TypeProvider::uint256(), "funds_" + std::to_string(m_context.newUniqueId()), m_context};
+	m_context.addAssertion(k.currentValue() >= state().txMember("msg.value"));
+	// Assume that address(this).balance cannot overflow.
+	m_context.addAssertion(smt::symbolicUnknownConstraints(state().balance(state().thisAddress()) + k.currentValue(), TypeProvider::uint256()));
+	state().addBalance(state().thisAddress(), k.currentValue());
+
+	if (encodeExternalCallsAsTrusted())
+	{
+		// If the contract has state variables that are addresses to other contracts,
+		// we need to encode the fact that those contracts may have been called in between
+		// transactions to _contract.
+		//
+		// We do that by adding nondet_interface constraints for those contracts,
+		// in the last line of this if block.
+		//
+		// If there are state variables of container types like structs or arrays
+		// that indirectly contain contract types, we havoc the state for simplicity,
+		// in the first part of this block.
+		// TODO: This could actually be supported.
+		// For structs: simply collect the SMT expressions of all the indirect contract type members.
+		// For arrays: more involved, needs to traverse the array symbolically and do the same for each contract.
+		// For mappings: way more complicated if the element type is a contract.
+		auto hasContractOrAddressSubType = [&](VariableDeclaration const* _var) -> bool {
+			bool foundContract = false;
+			solidity::util::BreadthFirstSearch<Type const*> bfs{{_var->type()}};
+			bfs.run([&](auto _type, auto&& _addChild) {
+				if (
+					_type->category() == Type::Category::Address ||
+					_type->category() == Type::Category::Contract
+				)
+				{
+					foundContract = true;
+					bfs.abort();
+				}
+				if (auto const* mapType = dynamic_cast<MappingType const*>(_type))
+					_addChild(mapType->valueType());
+				else if (auto const* arrayType = dynamic_cast<ArrayType const*>(_type))
+					_addChild(arrayType->baseType());
+				else if (auto const* structType = dynamic_cast<StructType const*>(_type))
+					for (auto const& member: structType->nativeMembers(nullptr))
+						_addChild(member.type);
+			});
+			return foundContract;
+		};
+		bool found = false;
+		for (auto var: m_currentContract->stateVariables())
+			if (
+				var->type()->category() != Type::Category::Address &&
+				var->type()->category() != Type::Category::Contract &&
+				hasContractOrAddressSubType(var)
+			)
+			{
+				found = true;
+				break;
+			}
+
+		if (found)
+			state().newStorage();
+		else
+			addNondetCalls(*m_currentContract);
+	}
+
+	errorFlag().increaseIndex();
+	m_context.addAssertion(summaryCall(_function));
+
+	connectBlocks(functionPred, externalSummary(_function));
+}
+
+void CHC::defineContractInitializer(ContractDefinition const& _contract, ContractDefinition const& _contextContract)
+{
+	m_contractInitializers[&_contextContract][&_contract] = createConstructorBlock(_contract, "contract_initializer");
+	auto const& implicitConstructorPredicate = *createConstructorBlock(_contract, "contract_initializer_entry");
+
+	auto implicitFact = smt::constructor(implicitConstructorPredicate, m_context);
+	addRule(smtutil::Expression::implies(initialConstraints(_contract), implicitFact), implicitFact.name);
+	setCurrentBlock(implicitConstructorPredicate);
+
+	auto prevErrorDest = m_errorDest;
+	m_errorDest = m_contractInitializers.at(&_contextContract).at(&_contract);
+	for (auto var: _contract.stateVariables())
+		if (var->value())
+		{
+			var->value()->accept(*this);
+			assignment(*var, *var->value());
+		}
+	m_errorDest = prevErrorDest;
+
+	auto const& afterInit = *createConstructorBlock(_contract, "contract_initializer_after_init");
+	connectBlocks(m_currentBlock, predicate(afterInit));
+	setCurrentBlock(afterInit);
+
+	if (auto constructor = _contract.constructor())
+	{
+		errorFlag().increaseIndex();
+		m_context.addAssertion(smt::functionCall(*m_summaries.at(&_contextContract).at(constructor), &_contextContract, m_context));
+		connectBlocks(m_currentBlock, initializer(_contract, _contextContract), errorFlag().currentValue() > 0);
+		m_context.addAssertion(errorFlag().currentValue() == 0);
+	}
+
+	connectBlocks(m_currentBlock, initializer(_contract, _contextContract));
+}
+
+smtutil::Expression CHC::interface()
+{
+	solAssert(m_currentContract, "");
+	return interface(*m_currentContract);
+}
+
+smtutil::Expression CHC::interface(ContractDefinition const& _contract)
+{
+	return ::interface(*m_interfaces.at(&_contract), _contract, m_context);
+}
+
+smtutil::Expression CHC::error()
+{
+	return (*m_errorPredicate)({});
+}
+
+smtutil::Expression CHC::error(unsigned _idx)
+{
+	return m_errorPredicate->functor(_idx)({});
+}
+
+smtutil::Expression CHC::initializer(ContractDefinition const& _contract, ContractDefinition const& _contractContext)
+{
+	return predicate(*m_contractInitializers.at(&_contractContext).at(&_contract));
+}
+
+smtutil::Expression CHC::summary(ContractDefinition const& _contract)
+{
+	return predicate(*m_constructorSummaries.at(&_contract));
+}
+
+smtutil::Expression CHC::summary(FunctionDefinition const& _function, ContractDefinition const& _contract)
+{
+	return smt::function(*m_summaries.at(&_contract).at(&_function), &_contract, m_context);
+}
+
+smtutil::Expression CHC::summary(FunctionDefinition const& _function)
+{
+	solAssert(m_currentContract, "");
+	return summary(_function, *m_currentContract);
+}
+
+smtutil::Expression CHC::summaryCall(FunctionDefinition const& _function, ContractDefinition const& _contract)
+{
+	return smt::functionCall(*m_summaries.at(&_contract).at(&_function), &_contract, m_context);
+}
+
+smtutil::Expression CHC::summaryCall(FunctionDefinition const& _function)
+{
+	solAssert(m_currentContract, "");
+	return summaryCall(_function, *m_currentContract);
+}
+
+smtutil::Expression CHC::externalSummary(FunctionDefinition const& _function, ContractDefinition const& _contract)
+{
+	return smt::function(*m_externalSummaries.at(&_contract).at(&_function), &_contract, m_context);
+}
+
+smtutil::Expression CHC::externalSummary(FunctionDefinition const& _function)
+{
+	solAssert(m_currentContract, "");
+	return externalSummary(_function, *m_currentContract);
+}
+
+Predicate const* CHC::createBlock(ASTNode const* _node, PredicateType _predType, std::string const& _prefix)
+{
+	auto block = createSymbolicBlock(
+		sort(_node),
+		"block_" + uniquePrefix() + "_" + _prefix + predicateName(_node),
+		_predType,
+		_node,
+		m_currentContract
+	);
+
+	solAssert(m_currentFunction, "");
+	return block;
+}
+
+Predicate const* CHC::createSummaryBlock(FunctionDefinition const& _function, ContractDefinition const& _contract, PredicateType _type)
+{
+	return createSymbolicBlock(
+		functionSort(_function, &_contract, state()),
+		"summary_" + uniquePrefix() + "_" + predicateName(&_function, &_contract),
+		_type,
+		&_function,
+		&_contract
+	);
+}
+
+Predicate const* CHC::createConstructorBlock(ContractDefinition const& _contract, std::string const& _prefix)
+{
+	return createSymbolicBlock(
+		constructorSort(_contract, state()),
+		_prefix + "_" + uniquePrefix() + "_" + contractSuffix(_contract),
+		PredicateType::ConstructorSummary,
+		&_contract,
+		&_contract
+	);
+}
+
+void CHC::createErrorBlock()
+{
+	m_errorPredicate = createSymbolicBlock(
+		arity0FunctionSort(),
+		"error_target_" + std::to_string(m_context.newUniqueId()),
+		PredicateType::Error
+	);
+	m_interface->registerRelation(m_errorPredicate->functor());
+}
+
+void CHC::connectBlocks(smtutil::Expression const& _from, smtutil::Expression const& _to, smtutil::Expression const& _constraints)
+{
+	smtutil::Expression edge = smtutil::Expression::implies(
+		_from && m_context.assertions() && _constraints,
+		_to
+	);
+	addRule(edge, _from.name + "_to_" + _to.name);
+}
+
+smtutil::Expression CHC::initialConstraints(ContractDefinition const& _contract, FunctionDefinition const* _function)
+{
+	smtutil::Expression conj = state().state() == state().state(0);
+	conj = conj && errorFlag().currentValue() == 0;
+	conj = conj && currentEqualInitialVarsConstraints(stateVariablesIncludingInheritedAndPrivate(_contract));
+
+	FunctionDefinition const* function = _function ? _function : _contract.constructor();
+	if (function)
+		conj = conj && currentEqualInitialVarsConstraints(applyMap(function->parameters(), [](auto&& _var) -> VariableDeclaration const* { return _var.get(); }));
+
+	return conj;
+}
+
+std::vector<smtutil::Expression> CHC::initialStateVariables()
+{
+	return stateVariablesAtIndex(0);
+}
+
+std::vector<smtutil::Expression> CHC::stateVariablesAtIndex(unsigned _index)
+{
+	solAssert(m_currentContract, "");
+	return stateVariablesAtIndex(_index, *m_currentContract);
+}
+
+std::vector<smtutil::Expression> CHC::stateVariablesAtIndex(unsigned _index, ContractDefinition const& _contract)
+{
+	return applyMap(
+		SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract),
+		[&](auto _var) { return valueAtIndex(*_var, _index); }
+	);
+}
+
+std::vector<smtutil::Expression> CHC::currentStateVariables()
+{
+	solAssert(m_currentContract, "");
+	return currentStateVariables(*m_currentContract);
+}
+
+std::vector<smtutil::Expression> CHC::currentStateVariables(ContractDefinition const& _contract)
+{
+	return applyMap(SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract), [this](auto _var) { return currentValue(*_var); });
+}
+
+smtutil::Expression CHC::currentEqualInitialVarsConstraints(std::vector<VariableDeclaration const*> const& _vars) const
+{
+	return fold(_vars, smtutil::Expression(true), [this](auto&& _conj, auto _var) {
+		return std::move(_conj) && currentValue(*_var) == m_context.variable(*_var)->valueAtIndex(0);
+	});
+}
+
+std::string CHC::predicateName(ASTNode const* _node, ContractDefinition const* _contract)
+{
+	std::string prefix;
+	if (auto funDef = dynamic_cast<FunctionDefinition const*>(_node))
+	{
+		prefix += TokenTraits::toString(funDef->kind());
+		if (!funDef->name().empty())
+			prefix += "_" + funDef->name() + "_";
+	}
+	else if (m_currentFunction && !m_currentFunction->name().empty())
+		prefix += m_currentFunction->name();
+
+	auto contract = _contract ? _contract : m_currentContract;
+	solAssert(contract, "");
+	return prefix + "_" + std::to_string(_node->id()) + "_" + std::to_string(contract->id());
+}
+
+smtutil::Expression CHC::predicate(Predicate const& _block)
+{
+	switch (_block.type())
+	{
+	case PredicateType::Interface:
+		solAssert(m_currentContract, "");
+		return ::interface(_block, *m_currentContract, m_context);
+	case PredicateType::ConstructorSummary:
+		return constructor(_block, m_context);
+	case PredicateType::FunctionSummary:
+	case PredicateType::InternalCall:
+	case PredicateType::ExternalCallTrusted:
+	case PredicateType::ExternalCallUntrusted:
+		return smt::function(_block, m_currentContract, m_context);
+	case PredicateType::FunctionBlock:
+	case PredicateType::FunctionErrorBlock:
+		solAssert(m_currentFunction, "");
+		return functionBlock(_block, *m_currentFunction, m_currentContract, m_context);
+	case PredicateType::Error:
+		return _block({});
+	case PredicateType::NondetInterface:
+		// Nondeterministic interface predicates are handled differently.
+		solAssert(false, "");
+	case PredicateType::Custom:
+		// Custom rules are handled separately.
+		solAssert(false, "");
+	}
+	solAssert(false, "");
+}
+
+smtutil::Expression CHC::predicate(
+	FunctionDefinition const* _funDef,
+	std::optional<Expression const*> _boundArgumentCall,
+	FunctionType const* _funType,
+	std::vector<Expression const*> _arguments,
+	smtutil::Expression _contractAddressValue
+)
+{
+	solAssert(_funType, "");
+	auto kind = _funType->kind();
+	solAssert(kind == FunctionType::Kind::Internal || kind == FunctionType::Kind::External || kind == FunctionType::Kind::BareStaticCall, "");
+	if (!_funDef)
+		return smtutil::Expression(true);
+
+	errorFlag().increaseIndex();
+
+	std::vector<smtutil::Expression> args =
+		commonStateExpressions(errorFlag().currentValue(), _contractAddressValue) +
+		std::vector<smtutil::Expression>{state().tx(), state().state()};
+
+	auto const* contract = _funDef->annotation().contract;
+	auto const& hierarchy = m_currentContract->annotation().linearizedBaseContracts;
+	solAssert(kind != FunctionType::Kind::Internal || _funDef->isFree() || (contract && contract->isLibrary()) || util::contains(hierarchy, contract), "");
+
+	if (kind == FunctionType::Kind::Internal)
+		contract = m_currentContract;
+
+	args += currentStateVariables(*contract);
+	args += symbolicArguments(_funDef->parameters(), _arguments, _boundArgumentCall);
+	if (!usesStaticCall(_funDef, _funType))
+	{
+		state().newState();
+		for (auto const& var: stateVariablesIncludingInheritedAndPrivate(*contract))
+			m_context.variable(*var)->increaseIndex();
+	}
+	args += std::vector<smtutil::Expression>{state().state()};
+	args += currentStateVariables(*contract);
+
+	for (auto var: _funDef->parameters() + _funDef->returnParameters())
+	{
+		if (m_context.knownVariable(*var))
+			m_context.variable(*var)->increaseIndex();
+		else
+			createVariable(*var);
+		args.push_back(currentValue(*var));
+	}
+
+	Predicate const& summary = *m_summaries.at(contract).at(_funDef);
+	auto from = smt::function(summary, contract, m_context);
+	Predicate const& callPredicate = *createSummaryBlock(
+		*_funDef,
+		*contract,
+		kind == FunctionType::Kind::Internal ? PredicateType::InternalCall : PredicateType::ExternalCallTrusted
+	);
+	auto to = smt::function(callPredicate, contract, m_context);
+	addRule(smtutil::Expression::implies(from, to), to.name);
+
+	return callPredicate(args);
+}
+
+void CHC::addRule(smtutil::Expression const& _rule, std::string const& _ruleName)
+{
+	m_interface->addRule(_rule, _ruleName);
+}
+
+std::tuple<CheckResult, smtutil::Expression, CHCSolverInterface::CexGraph> CHC::query(smtutil::Expression const& _query, langutil::SourceLocation const& _location)
+{
+	CheckResult result;
+	smtutil::Expression invariant(true);
+	CHCSolverInterface::CexGraph cex;
+	if (m_settings.printQuery)
+	{
+		auto smtLibInterface = dynamic_cast<CHCSmtLib2Interface*>(m_interface.get());
+		solAssert(smtLibInterface, "Requested to print queries but CHCSmtLib2Interface not available");
+		std::string smtLibCode = smtLibInterface->dumpQuery(_query);
+		m_errorReporter.info(
+			2339_error,
+			"CHC: Requested query:\n" + smtLibCode
+		);
+	}
+	std::tie(result, invariant, cex) = m_interface->query(_query);
+	switch (result)
+	{
+	case CheckResult::SATISFIABLE:
+	{
+	// We still need the ifdef because of Z3CHCInterface.
+		if (m_settings.solvers.z3)
+		{
+#ifdef HAVE_Z3
+			// Even though the problem is SAT, Spacer's pre processing makes counterexamples incomplete.
+			// We now disable those optimizations and check whether we can still solve the problem.
+			auto* spacer = dynamic_cast<Z3CHCInterface*>(m_interface.get());
+			solAssert(spacer, "");
+			spacer->setSpacerOptions(false);
+
+			CheckResult resultNoOpt;
+			smtutil::Expression invariantNoOpt(true);
+			CHCSolverInterface::CexGraph cexNoOpt;
+			std::tie(resultNoOpt, invariantNoOpt, cexNoOpt) = m_interface->query(_query);
+
+			if (resultNoOpt == CheckResult::SATISFIABLE)
+				cex = std::move(cexNoOpt);
+
+			spacer->setSpacerOptions(true);
+#else
+			solAssert(false);
+#endif
+		}
+		break;
+	}
+	case CheckResult::UNSATISFIABLE:
+		break;
+	case CheckResult::UNKNOWN:
+		break;
+	case CheckResult::CONFLICTING:
+		m_errorReporter.warning(1988_error, _location, "CHC: At least two SMT solvers provided conflicting answers. Results might not be sound.");
+		break;
+	case CheckResult::ERROR:
+		m_errorReporter.warning(1218_error, _location, "CHC: Error trying to invoke SMT solver.");
+		break;
+	}
+	return {result, invariant, cex};
+}
+
+void CHC::verificationTargetEncountered(
+	ASTNode const* const _errorNode,
+	VerificationTargetType _type,
+	smtutil::Expression const& _errorCondition
+)
+{
+	if (!m_settings.targets.has(_type))
+		return;
+
+	if (!(m_currentContract || m_currentFunction))
+		return;
+
+	bool scopeIsFunction = m_currentFunction && !m_currentFunction->isConstructor();
+	auto errorId = newErrorId();
+	solAssert(m_verificationTargets.count(errorId) == 0, "Error ID is not unique!");
+	m_verificationTargets.emplace(errorId, CHCVerificationTarget{{_type, _errorCondition, smtutil::Expression(true)}, errorId, _errorNode});
+	if (scopeIsFunction)
+		m_functionTargetIds[m_currentFunction].push_back(errorId);
+	else
+		m_functionTargetIds[m_currentContract].push_back(errorId);
+	auto previousError = errorFlag().currentValue();
+	errorFlag().increaseIndex();
+	auto extendedErrorCondition = currentPathConditions() && _errorCondition;
+
+	Predicate const* localBlock = m_currentFunction ?
+		createBlock(m_currentFunction, PredicateType::FunctionErrorBlock) :
+		createConstructorBlock(*m_currentContract, "local_error");
+
+	auto pred = predicate(*localBlock);
+	connectBlocks(
+		m_currentBlock,
+		pred,
+		extendedErrorCondition && errorFlag().currentValue() == errorId
+	);
+	solAssert(m_errorDest, "");
+	addRule(smtutil::Expression::implies(pred, predicate(*m_errorDest)), pred.name);
+
+	m_context.addAssertion(errorFlag().currentValue() == previousError);
+}
+
+std::pair<std::string, ErrorId> CHC::targetDescription(CHCVerificationTarget const& _target)
+{
+	if (_target.type == VerificationTargetType::PopEmptyArray)
+	{
+		solAssert(dynamic_cast<FunctionCall const*>(_target.errorNode), "");
+		return {"Empty array \"pop\"", 2529_error};
+	}
+	else if (_target.type == VerificationTargetType::OutOfBounds)
+	{
+		solAssert(dynamic_cast<IndexAccess const*>(_target.errorNode), "");
+		return {"Out of bounds access", 6368_error};
+	}
+	else if (
+		_target.type == VerificationTargetType::Underflow ||
+		_target.type == VerificationTargetType::Overflow
+	)
+	{
+		auto const* expr = dynamic_cast<Expression const*>(_target.errorNode);
+		solAssert(expr, "");
+		auto const* intType = dynamic_cast<IntegerType const*>(expr->annotation().type);
+		if (!intType)
+			intType = TypeProvider::uint256();
+
+		if (_target.type == VerificationTargetType::Underflow)
+			return {
+				"Underflow (resulting value less than " + formatNumberReadable(intType->minValue()) + ")",
+				3944_error
+			};
+
+		return {
+			"Overflow (resulting value larger than " + formatNumberReadable(intType->maxValue()) + ")",
+			4984_error
+		};
+	}
+	else if (_target.type == VerificationTargetType::DivByZero)
+		return {"Division by zero", 4281_error};
+	else if (_target.type == VerificationTargetType::Assert)
+		return {"Assertion violation", 6328_error};
+	else
+		solAssert(false);
+}
+
+void CHC::checkVerificationTargets()
+{
+	// The verification conditions have been collected per function where they have been encountered (m_verificationTargets).
+	// Also, all possible contexts in which an external function can be called has been recorded (m_queryPlaceholders).
+	// Here we combine every context in which an external function can be called with all possible verification conditions
+	// in its call graph. Each such combination forms a unique verification target.
+	std::map<unsigned, std::vector<CHCQueryPlaceholder>> targetEntryPoints;
+	for (auto const& [function, placeholders]: m_queryPlaceholders)
+	{
+		auto functionTargets = transactionVerificationTargetsIds(function);
+		for (auto const& placeholder: placeholders)
+			for (unsigned id: functionTargets)
+				targetEntryPoints[id].push_back(placeholder);
+	}
+
+	std::set<unsigned> checkedErrorIds;
+	for (auto const& [targetId, placeholders]: targetEntryPoints)
+	{
+		auto const& target = m_verificationTargets.at(targetId);
+		auto [errorType, errorReporterId] = targetDescription(target);
+
+		checkAndReportTarget(target, placeholders, errorReporterId, errorType + " happens here.", errorType + " might happen here.");
+		checkedErrorIds.insert(target.errorId);
+	}
+
+	auto toReport = m_unsafeTargets;
+	if (m_settings.showUnproved)
+		for (auto const& [node, targets]: m_unprovedTargets)
+			for (auto const& [target, info]: targets)
+				toReport[node].emplace(target, info);
+
+	for (auto const& [node, targets]: toReport)
+		for (auto const& [target, info]: targets)
+			m_errorReporter.warning(
+				info.error,
+				info.location,
+				info.message
+			);
+
+	if (!m_settings.showUnproved && !m_unprovedTargets.empty())
+		m_errorReporter.warning(
+			5840_error,
+			{},
+			"CHC: " +
+			std::to_string(m_unprovedTargets.size()) +
+			" verification condition(s) could not be proved." +
+			" Enable the model checker option \"show unproved\" to see all of them." +
+			" Consider choosing a specific contract to be verified in order to reduce the solving problems." +
+			" Consider increasing the timeout per query."
+		);
+
+	if (!m_settings.showProvedSafe && !m_safeTargets.empty())
+		m_errorReporter.info(
+			1391_error,
+			"CHC: " +
+			std::to_string(m_safeTargets.size()) +
+			" verification condition(s) proved safe!" +
+			" Enable the model checker option \"show proved safe\" to see all of them."
+		);
+	else if (m_settings.showProvedSafe)
+		for (auto const& [node, targets]: m_safeTargets)
+			for (auto const& target: targets)
+				m_errorReporter.info(
+					9576_error,
+					node->location(),
+					"CHC: " +
+					targetDescription(target).first +
+					" check is safe!"
+				);
+
+	if (!m_settings.invariants.invariants.empty())
+	{
+		std::string msg;
+		for (auto pred: m_invariants | ranges::views::keys)
+		{
+			ASTNode const* node = pred->programNode();
+			std::string what;
+			if (auto contract = dynamic_cast<ContractDefinition const*>(node))
+				what = contract->fullyQualifiedName();
+			else
+				solAssert(false, "");
+
+			std::string invType;
+			if (pred->type() == PredicateType::Interface)
+				invType = "Contract invariant(s)";
+			else if (pred->type() == PredicateType::NondetInterface)
+				invType = "Reentrancy property(ies)";
+			else
+				solAssert(false, "");
+
+			msg += invType + " for " + what + ":\n";
+			for (auto const& inv: m_invariants.at(pred))
+				msg += inv + "\n";
+		}
+		if (msg.find("<errorCode>") != std::string::npos)
+		{
+			std::set<unsigned> seenErrors;
+			msg += "<errorCode> = 0 -> no errors\n";
+			for (auto const& [id, target]: m_verificationTargets)
+				if (!seenErrors.count(target.errorId))
+				{
+					seenErrors.insert(target.errorId);
+					std::string loc = std::string(m_charStreamProvider.charStream(*target.errorNode->location().sourceName).text(target.errorNode->location()));
+					msg += "<errorCode> = " + std::to_string(target.errorId) + " -> " + ModelCheckerTargets::targetTypeToString.at(target.type) + " at " + loc + "\n";
+
+				}
+		}
+		if (!msg.empty())
+			m_errorReporter.info(1180_error, msg);
+	}
+
+	// There can be targets in internal functions that are not reachable from the external interface.
+	// These are safe by definition and are not even checked by the CHC engine, but this information
+	// must still be reported safe by the BMC engine.
+	std::set<unsigned> allErrorIds;
+	for (auto const& entry: m_functionTargetIds)
+		for (unsigned id: entry.second)
+			allErrorIds.insert(id);
+
+	std::set<unsigned> unreachableErrorIds;
+	set_difference(
+		allErrorIds.begin(),
+		allErrorIds.end(),
+		checkedErrorIds.begin(),
+		checkedErrorIds.end(),
+		inserter(unreachableErrorIds, unreachableErrorIds.begin())
+	);
+	for (auto id: unreachableErrorIds)
+		m_safeTargets[m_verificationTargets.at(id).errorNode].insert(m_verificationTargets.at(id));
+}
+
+void CHC::checkAndReportTarget(
+	CHCVerificationTarget const& _target,
+	std::vector<CHCQueryPlaceholder> const& _placeholders,
+	ErrorId _errorReporterId,
+	std::string _satMsg,
+	std::string _unknownMsg
+)
+{
+	if (m_unsafeTargets.count(_target.errorNode) && m_unsafeTargets.at(_target.errorNode).count(_target.type))
+		return;
+
+	createErrorBlock();
+	for (auto const& placeholder: _placeholders)
+		connectBlocks(
+			placeholder.fromPredicate,
+			error(),
+			placeholder.constraints && placeholder.errorExpression == _target.errorId
+		);
+	auto const& location = _target.errorNode->location();
+	auto [result, invariant, model] = query(error(), location);
+	if (result == CheckResult::UNSATISFIABLE)
+	{
+		m_safeTargets[_target.errorNode].insert(_target);
+		std::set<Predicate const*> predicates;
+		for (auto const* pred: m_interfaces | ranges::views::values)
+			predicates.insert(pred);
+		for (auto const* pred: m_nondetInterfaces | ranges::views::values)
+			predicates.insert(pred);
+		std::map<Predicate const*, std::set<std::string>> invariants = collectInvariants(invariant, predicates, m_settings.invariants);
+		for (auto pred: invariants | ranges::views::keys)
+			m_invariants[pred] += std::move(invariants.at(pred));
+	}
+	else if (result == CheckResult::SATISFIABLE)
+	{
+		solAssert(!_satMsg.empty(), "");
+		auto cex = generateCounterexample(model, error().name);
+		if (cex)
+			m_unsafeTargets[_target.errorNode][_target.type] = {
+				_errorReporterId,
+				location,
+				"CHC: " + _satMsg + "\nCounterexample:\n" + *cex
+			};
+		else
+			m_unsafeTargets[_target.errorNode][_target.type] = {
+				_errorReporterId,
+				location,
+				"CHC: " + _satMsg
+			};
+	}
+	else if (!_unknownMsg.empty())
+		m_unprovedTargets[_target.errorNode][_target.type] = {
+			_errorReporterId,
+			location,
+			"CHC: " + _unknownMsg
+		};
+}
+
+/**
+The counterexample DAG has the following properties:
+1) The root node represents the reachable error predicate.
+2) The root node has 1 or 2 children:
+	- One of them is the summary of the function that was called and led to that node.
+	If this is the only child, this function must be the constructor.
+	- If it has 2 children, the function is not the constructor and the other child is the interface node,
+	that is, it represents the state of the contract before the function described above was called.
+3) Interface nodes also have property 2.
+
+We run a BFS on the DAG from the root node collecting the reachable function summaries from the given node.
+When a function summary is seen, the search continues with that summary as the new root for its subgraph.
+The result of the search is a callgraph containing:
+- Functions calls needed to reach the root node, that is, transaction entry points.
+- Functions called by other functions (internal calls or external calls/internal transactions).
+The BFS visit order and the shape of the DAG described in the previous paragraph guarantee that the order of
+the function summaries in the callgraph of the error node is the reverse transaction trace.
+
+The first function summary seen contains the values for the state, input and output variables at the
+error point.
+*/
+std::optional<std::string> CHC::generateCounterexample(CHCSolverInterface::CexGraph const& _graph, std::string const& _root)
+{
+	std::optional<unsigned> rootId;
+	for (auto const& [id, node]: _graph.nodes)
+		if (node.name == _root)
+		{
+			rootId = id;
+			break;
+		}
+	if (!rootId)
+		return {};
+
+	std::vector<std::string> path;
+	std::string localState;
+
+	auto callGraph = summaryCalls(_graph, *rootId);
+
+	auto nodePred = [&](auto _node) { return Predicate::predicate(_graph.nodes.at(_node).name); };
+	auto nodeArgs = [&](auto _node) { return _graph.nodes.at(_node).arguments; };
+
+	bool first = true;
+	for (auto summaryId: callGraph.at(*rootId))
+	{
+		CHCSolverInterface::CexNode const& summaryNode = _graph.nodes.at(summaryId);
+		Predicate const* summaryPredicate = Predicate::predicate(summaryNode.name);
+		auto const& summaryArgs = summaryNode.arguments;
+
+		if (!summaryPredicate->programVariable())
+		{
+			auto stateVars = summaryPredicate->stateVariables();
+			solAssert(stateVars.has_value(), "");
+			auto stateValues = summaryPredicate->summaryStateValues(summaryArgs);
+			solAssert(stateValues.size() == stateVars->size(), "");
+
+			if (first)
+			{
+				first = false;
+				/// Generate counterexample message local to the failed target.
+				localState = formatVariableModel(*stateVars, stateValues, ", ") + "\n";
+
+				if (auto calledFun = summaryPredicate->programFunction())
+				{
+					auto inValues = summaryPredicate->summaryPostInputValues(summaryArgs);
+					auto const& inParams = calledFun->parameters();
+					if (auto inStr = formatVariableModel(inParams, inValues, "\n"); !inStr.empty())
+						localState += inStr + "\n";
+					auto outValues = summaryPredicate->summaryPostOutputValues(summaryArgs);
+					auto const& outParams = calledFun->returnParameters();
+					if (auto outStr = formatVariableModel(outParams, outValues, "\n"); !outStr.empty())
+						localState += outStr + "\n";
+
+					std::optional<unsigned> localErrorId;
+					solidity::util::BreadthFirstSearch<unsigned> bfs{{summaryId}};
+					bfs.run([&](auto _nodeId, auto&& _addChild) {
+						auto const& children = _graph.edges.at(_nodeId);
+						if (
+							children.size() == 1 &&
+							nodePred(children.front())->isFunctionErrorBlock()
+						)
+						{
+							localErrorId = children.front();
+							bfs.abort();
+						}
+						ranges::for_each(children, _addChild);
+					});
+
+					if (localErrorId.has_value())
+					{
+						auto const* localError = nodePred(*localErrorId);
+						solAssert(localError && localError->isFunctionErrorBlock(), "");
+						auto const [localValues, localVars] = localError->localVariableValues(nodeArgs(*localErrorId));
+						if (auto localStr = formatVariableModel(localVars, localValues, "\n"); !localStr.empty())
+							localState += localStr + "\n";
+					}
+				}
+			}
+			else
+			{
+				auto modelMsg = formatVariableModel(*stateVars, stateValues, ", ");
+				/// We report the state after every tx in the trace except for the last, which is reported
+				/// first in the code above.
+				if (!modelMsg.empty())
+					path.emplace_back("State: " + modelMsg);
+			}
+		}
+		std::string txCex = summaryPredicate->formatSummaryCall(summaryArgs, m_charStreamProvider);
+
+		std::list<std::string> calls;
+		auto dfs = [&](unsigned parent, unsigned node, unsigned depth, auto&& _dfs) -> void {
+			auto pred = nodePred(node);
+			auto parentPred = nodePred(parent);
+			solAssert(pred && pred->isSummary(), "");
+			solAssert(parentPred && parentPred->isSummary(), "");
+			auto callTraceSize = calls.size();
+			if (!pred->isConstructorSummary())
+				for (unsigned v: callGraph[node])
+					_dfs(node, v, depth + 1, _dfs);
+
+			bool appendTxVars = pred->isConstructorSummary() || pred->isFunctionSummary() || pred->isExternalCallUntrusted();
+
+			calls.push_front(std::string(depth * 4, ' ') + pred->formatSummaryCall(nodeArgs(node), m_charStreamProvider, appendTxVars));
+			if (pred->isInternalCall())
+				calls.front() += " -- internal call";
+			else if (pred->isExternalCallTrusted())
+				calls.front() += " -- trusted external call";
+			else if (pred->isExternalCallUntrusted())
+			{
+				calls.front() += " -- untrusted external call";
+				if (calls.size() > callTraceSize + 1)
+					calls.front() += ", synthesized as:";
+			}
+			else if (pred->programVariable())
+			{
+				calls.front() += "-- action on external contract in state variable \"" + pred->programVariable()->name() + "\"";
+				if (calls.size() > callTraceSize + 1)
+					calls.front() += ", synthesized as:";
+			}
+			else if (pred->isFunctionSummary() && parentPred->isExternalCallUntrusted())
+				calls.front() += " -- reentrant call";
+		};
+		dfs(summaryId, summaryId, 0, dfs);
+		path.emplace_back(boost::algorithm::join(calls, "\n"));
+	}
+
+	return localState + "\nTransaction trace:\n" + boost::algorithm::join(path | ranges::views::reverse, "\n");
+}
+
+std::map<unsigned, std::vector<unsigned>> CHC::summaryCalls(CHCSolverInterface::CexGraph const& _graph, unsigned _root)
+{
+	std::map<unsigned, std::vector<unsigned>> calls;
+
+	auto compare = [&](unsigned _a, unsigned _b) {
+		auto extract = [&](std::string const& _s) {
+			// We want to sort sibling predicates in the counterexample graph by their unique predicate id.
+			// For most predicates, this actually doesn't matter.
+			// The cases where this matters are internal and external function calls which have the form:
+			// summary_<CALLID>_<suffix>
+			// nondet_call_<CALLID>_<suffix>
+			// Those have the extra unique <CALLID> numbers based on the traversal order, and are necessary
+			// to infer the call order so that's shown property in the counterexample trace.
+			// Predicates that do not have a CALLID have a predicate id at the end of <suffix>,
+			// so the assertion below should still hold.
+			auto beg = _s.data();
+			while (beg != _s.data() + _s.size() && !isDigit(*beg)) ++beg;
+			auto end = beg;
+			while (end != _s.data() + _s.size() && isDigit(*end)) ++end;
+
+			solAssert(beg != end, "Expected to find numerical call or predicate id.");
+
+			int result;
+			auto [p, ec] = std::from_chars(beg, end, result);
+			solAssert(ec == std::errc(), "Id should be a number.");
+
+			return result;
+		};
+		return extract(_graph.nodes.at(_a).name) > extract(_graph.nodes.at(_b).name);
+	};
+
+	std::queue<std::pair<unsigned, unsigned>> q;
+	q.push({_root, _root});
+	while (!q.empty())
+	{
+		auto [node, root] = q.front();
+		q.pop();
+
+		Predicate const* nodePred = Predicate::predicate(_graph.nodes.at(node).name);
+		Predicate const* rootPred = Predicate::predicate(_graph.nodes.at(root).name);
+		if (nodePred->isSummary() && (
+			_root == root ||
+			nodePred->isInternalCall() ||
+			nodePred->isExternalCallTrusted() ||
+			nodePred->isExternalCallUntrusted() ||
+			rootPred->isExternalCallUntrusted() ||
+			rootPred->programVariable()
+		))
+		{
+			calls[root].push_back(node);
+			root = node;
+		}
+		auto const& edges = _graph.edges.at(node);
+		for (unsigned v: std::set<unsigned, decltype(compare)>(begin(edges), end(edges), compare))
+			q.push({v, root});
+	}
+
+	return calls;
+}
+
+std::string CHC::cex2dot(CHCSolverInterface::CexGraph const& _cex)
+{
+	std::string dot = "digraph {\n";
+
+	auto pred = [&](CHCSolverInterface::CexNode const& _node) {
+		std::vector<std::string> args = applyMap(
+			_node.arguments,
+			[&](auto const& arg) { return arg.name; }
+		);
+		return "\"" + _node.name + "(" + boost::algorithm::join(args, ", ") + ")\"";
+	};
+
+	for (auto const& [u, vs]: _cex.edges)
+		for (auto v: vs)
+			dot += pred(_cex.nodes.at(v)) + " -> " + pred(_cex.nodes.at(u)) + "\n";
+
+	dot += "}";
+	return dot;
+}
+
+std::string CHC::uniquePrefix()
+{
+	return std::to_string(m_blockCounter++);
+}
+
+std::string CHC::contractSuffix(ContractDefinition const& _contract)
+{
+	return _contract.name() + "_" + std::to_string(_contract.id());
+}
+
+unsigned CHC::newErrorId()
+{
+	unsigned errorId = m_context.newUniqueId();
+	// We need to make sure the error id is not zero,
+	// because error id zero actually means no error in the CHC encoding.
+	if (errorId == 0)
+		errorId = m_context.newUniqueId();
+	return errorId;
+}
+
+SymbolicIntVariable& CHC::errorFlag()
+{
+	return state().errorFlag();
+}
+
+void CHC::newTxConstraints(Expression const* _value)
+{
+	auto txOrigin = state().txMember("tx.origin");
+	state().newTx();
+	// set the transaction sender as this contract
+	m_context.addAssertion(state().txMember("msg.sender") == state().thisAddress());
+	// set the origin to be the current transaction origin
+	m_context.addAssertion(state().txMember("tx.origin") == txOrigin);
+
+	if (_value)
+		// set the msg value
+		m_context.addAssertion(state().txMember("msg.value") == expr(*_value));
+}
+
+frontend::Expression const* CHC::valueOption(FunctionCallOptions const* _options)
+{
+	if (_options)
+		for (auto&& [i, name]: _options->names() | ranges::views::enumerate)
+			if (name && *name == "value")
+				return _options->options().at(i).get();
+	return nullptr;
+}
+
+void CHC::decreaseBalanceFromOptionsValue(Expression const& _value)
+{
+	state().addBalance(state().thisAddress(), 0 - expr(_value));
+}
+
+std::vector<smtutil::Expression> CHC::commonStateExpressions(smtutil::Expression const& error, smtutil::Expression const& address)
+{
+	if (state().hasBytesConcatFunction())
+		return {error, address, state().abi(), state().bytesConcat(), state().crypto()};
+	return {error, address, state().abi(), state().crypto()};
+}
diff --git a/compiler/libsolidity/formal/CHC.h b/compiler/libsolidity/formal/CHC.h
new file mode 100644
index 00000000..be150baf
--- /dev/null
+++ b/compiler/libsolidity/formal/CHC.h
@@ -0,0 +1,477 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/**
+ * Model checker based on Constrained Horn Clauses.
+ *
+ * A Solidity contract's CFG is encoded into a system of Horn clauses where
+ * each block has a predicate and edges are rules.
+ *
+ * The entry block is the constructor which has no in-edges.
+ * The constructor has one out-edge to an artificial block named _Interface_
+ * which has in/out-edges from/to all public functions.
+ *
+ * Loop invariants for Interface -> Interface' are state invariants.
+ */
+
+#pragma once
+
+#include <libsolidity/formal/ModelCheckerSettings.h>
+#include <libsolidity/formal/Predicate.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <libsolidity/interface/ReadFile.h>
+
+#include <libsmtutil/CHCSolverInterface.h>
+
+#include <liblangutil/SourceLocation.h>
+#include <liblangutil/UniqueErrorReporter.h>
+
+#include <boost/algorithm/string/join.hpp>
+
+#include <map>
+#include <optional>
+#include <set>
+
+namespace solidity::frontend
+{
+
+class CHC: public SMTEncoder
+{
+public:
+	CHC(
+		smt::EncodingContext& _context,
+		langutil::UniqueErrorReporter& _errorReporter,
+		langutil::UniqueErrorReporter& _unsupportedErrorReporter,
+		std::map<util::h256, std::string> const& _smtlib2Responses,
+		ReadCallback::Callback const& _smtCallback,
+		ModelCheckerSettings _settings,
+		langutil::CharStreamProvider const& _charStreamProvider
+	);
+
+	void analyze(SourceUnit const& _sources);
+
+	struct CHCVerificationTarget: VerificationTarget
+	{
+		unsigned const errorId;
+		ASTNode const* const errorNode;
+
+		friend bool operator<(CHCVerificationTarget const& _a, CHCVerificationTarget const& _b)
+		{
+			return _a.errorId < _b.errorId;
+		}
+	};
+
+	struct ReportTargetInfo
+	{
+		langutil::ErrorId error;
+		langutil::SourceLocation location;
+		std::string message;
+	};
+
+	std::map<ASTNode const*, std::set<CHCVerificationTarget>, smt::EncodingContext::IdCompare> const& safeTargets() const { return m_safeTargets; }
+	std::map<ASTNode const*, std::map<VerificationTargetType, ReportTargetInfo>, smt::EncodingContext::IdCompare> const& unsafeTargets() const { return m_unsafeTargets; }
+
+	/// This is used if the Horn solver is not directly linked into this binary.
+	/// @returns a list of inputs to the Horn solver that were not part of the argument to
+	/// the constructor.
+	std::vector<std::string> unhandledQueries() const;
+
+	enum class CHCNatspecOption
+	{
+		AbstractFunctionNondet
+	};
+
+private:
+	/// Visitor functions.
+	//@{
+	bool visit(ContractDefinition const& _node) override;
+	void endVisit(ContractDefinition const& _node) override;
+	bool visit(FunctionDefinition const& _node) override;
+	void endVisit(FunctionDefinition const& _node) override;
+	bool visit(Block const& _block) override;
+	void endVisit(Block const& _block) override;
+	bool visit(IfStatement const& _node) override;
+	bool visit(WhileStatement const&) override;
+	bool visit(ForStatement const&) override;
+	void endVisit(ForStatement const&) override;
+	void endVisit(FunctionCall const& _node) override;
+	void endVisit(BinaryOperation const& _op) override;
+	void endVisit(UnaryOperation const& _op) override;
+	void endVisit(Break const& _node) override;
+	void endVisit(Continue const& _node) override;
+	void endVisit(IndexRangeAccess const& _node) override;
+	void endVisit(Return const& _node) override;
+	bool visit(TryCatchClause const&) override;
+	void endVisit(TryCatchClause const&) override;
+	bool visit(TryStatement const& _node) override;
+
+	void pushInlineFrame(CallableDeclaration const& _callable) override;
+	void popInlineFrame(CallableDeclaration const& _callable) override;
+
+	void visitAssert(FunctionCall const& _funCall);
+	void visitPublicGetter(FunctionCall const& _funCall) override;
+	void visitAddMulMod(FunctionCall const& _funCall) override;
+	void visitDeployment(FunctionCall const& _funCall);
+	void internalFunctionCall(FunctionCall const& _funCall);
+	void internalFunctionCall(
+		FunctionDefinition const* _funDef,
+		std::optional<Expression const*> _boundArgumentCall,
+		FunctionType const* _funType,
+		std::vector<Expression const*> const& _arguments,
+		smtutil::Expression _contractAddressValue
+	);
+	void externalFunctionCall(FunctionCall const& _funCall);
+	void externalFunctionCallToTrustedCode(FunctionCall const& _funCall);
+	void addNondetCalls(ContractDefinition const& _contract);
+	void nondetCall(ContractDefinition const& _contract, VariableDeclaration const& _var);
+	void unknownFunctionCall(FunctionCall const& _funCall);
+	void makeArrayPopVerificationTarget(FunctionCall const& _arrayPop) override;
+	void makeOutOfBoundsVerificationTarget(IndexAccess const& _access) override;
+	/// Creates underflow/overflow verification targets.
+	std::pair<smtutil::Expression, smtutil::Expression> arithmeticOperation(
+		Token _op,
+		smtutil::Expression const& _left,
+		smtutil::Expression const& _right,
+		Type const* _commonType,
+		Expression const& _expression
+	) override;
+	//@}
+
+	/// Helpers.
+	//@{
+	void resetSourceAnalysis();
+	void resetContractAnalysis();
+	void eraseKnowledge();
+	void clearIndices(ContractDefinition const* _contract, FunctionDefinition const* _function = nullptr) override;
+	void setCurrentBlock(Predicate const& _block);
+	std::set<unsigned> transactionVerificationTargetsIds(ASTNode const* _txRoot);
+	bool usesStaticCall(FunctionDefinition const* _funDef, FunctionType const* _funType);
+	bool usesStaticCall(FunctionCall const& _funCall);
+	//@}
+
+	/// SMT Natspec and abstraction helpers.
+	//@{
+	/// @returns a CHCNatspecOption enum if _option is a valid SMTChecker Natspec value
+	/// or nullopt otherwise.
+	static std::optional<CHCNatspecOption> natspecOptionFromString(std::string const& _option);
+	/// @returns which SMTChecker options are enabled by @a _function's Natspec via
+	/// `@custom:smtchecker <option>` or nullopt if none is used.
+	std::set<CHCNatspecOption> smtNatspecTags(FunctionDefinition const& _function);
+	/// @returns true if _function is Natspec annotated to be abstracted by
+	/// nondeterministic values.
+	bool abstractAsNondet(FunctionDefinition const& _function);
+
+	/// @returns true if external calls should be considered trusted.
+	/// If that's the case, their code is used if available at compile time.
+	bool encodeExternalCallsAsTrusted();
+	//@}
+
+	/// Sort helpers.
+	//@{
+	smtutil::SortPointer sort(FunctionDefinition const& _function);
+	smtutil::SortPointer sort(ASTNode const* _block);
+	//@}
+
+	/// Predicate helpers.
+	//@{
+	/// @returns a new block of given _sort and _name.
+	Predicate const* createSymbolicBlock(smtutil::SortPointer _sort, std::string const& _name, PredicateType _predType, ASTNode const* _node = nullptr, ContractDefinition const* _contractContext = nullptr);
+
+	/// Creates summary predicates for all functions of all contracts
+	/// in a given _source.
+	void defineInterfacesAndSummaries(SourceUnit const& _source);
+
+	/// Creates the rule
+	/// summary_function \land transaction_entry_constraints => external_summary_function
+	/// This is needed to add these transaction entry constraints which include
+	/// potential balance increase by external means, for example.
+	void defineExternalFunctionInterface(FunctionDefinition const& _function, ContractDefinition const& _contract);
+
+	/// Creates a CHC system that, for a given contract,
+	/// - initializes its state variables (as 0 or given value, if any).
+	/// - "calls" the explicit constructor function of the contract, if any.
+	void defineContractInitializer(ContractDefinition const& _contract, ContractDefinition const& _contractContext);
+
+	/// Interface predicate over current variables.
+	smtutil::Expression interface();
+	smtutil::Expression interface(ContractDefinition const& _contract);
+	/// Error predicate over current variables.
+	smtutil::Expression error();
+	smtutil::Expression error(unsigned _idx);
+
+	/// Creates a block for the given _node.
+	Predicate const* createBlock(ASTNode const* _node, PredicateType _predType, std::string const& _prefix = "");
+	/// Creates a call block for the given function _function from contract _contract.
+	/// The contract is needed here because of inheritance.
+	/// There are different types of summaries, where the most common is FunctionSummary,
+	/// but other summaries are also used for internal and external function calls.
+	Predicate const* createSummaryBlock(
+		FunctionDefinition const& _function,
+		ContractDefinition const& _contract,
+		PredicateType _type = PredicateType::FunctionSummary
+	);
+
+	/// @returns a block related to @a _contract's constructor.
+	Predicate const* createConstructorBlock(ContractDefinition const& _contract, std::string const& _prefix);
+
+	/// Creates a new error block to be used by an assertion.
+	/// Also registers the predicate.
+	void createErrorBlock();
+
+	void connectBlocks(smtutil::Expression const& _from, smtutil::Expression const& _to, smtutil::Expression const& _constraints = smtutil::Expression(true));
+
+	/// @returns The initial constraints that set up the beginning of a function.
+	smtutil::Expression initialConstraints(ContractDefinition const& _contract, FunctionDefinition const* _function = nullptr);
+
+	/// @returns the symbolic values of the state variables at the beginning
+	/// of the current transaction.
+	std::vector<smtutil::Expression> initialStateVariables();
+	std::vector<smtutil::Expression> stateVariablesAtIndex(unsigned _index);
+	std::vector<smtutil::Expression> stateVariablesAtIndex(unsigned _index, ContractDefinition const& _contract);
+	/// @returns the current symbolic values of the current state variables.
+	std::vector<smtutil::Expression> currentStateVariables();
+	std::vector<smtutil::Expression> currentStateVariables(ContractDefinition const& _contract);
+
+	/// @returns \bigwedge currentValue(_vars[i]) == initialState(_var[i])
+	smtutil::Expression currentEqualInitialVarsConstraints(std::vector<VariableDeclaration const*> const& _vars) const;
+
+	/// @returns the predicate name for a given node.
+	std::string predicateName(ASTNode const* _node, ContractDefinition const* _contract = nullptr);
+	/// @returns a predicate application after checking the predicate's type.
+	smtutil::Expression predicate(Predicate const& _block);
+	/// @returns the summary predicate for the called function.
+	smtutil::Expression predicate(
+		FunctionDefinition const* _funDef,
+		std::optional<Expression const*> _boundArgumentCall,
+		FunctionType const* _funType,
+		std::vector<Expression const*> _arguments,
+		smtutil::Expression _contractAddressValue
+	);
+	/// @returns a predicate that defines a contract initializer for _contract in the context of _contractContext.
+	smtutil::Expression initializer(ContractDefinition const& _contract, ContractDefinition const& _contractContext);
+	/// @returns a predicate that defines a constructor summary.
+	smtutil::Expression summary(ContractDefinition const& _contract);
+	/// @returns a predicate that defines a function summary.
+	smtutil::Expression summary(FunctionDefinition const& _function);
+	smtutil::Expression summary(FunctionDefinition const& _function, ContractDefinition const& _contract);
+	/// @returns a predicate that applies a function summary
+	/// over the constrained variables.
+	smtutil::Expression summaryCall(FunctionDefinition const& _function);
+	smtutil::Expression summaryCall(FunctionDefinition const& _function, ContractDefinition const& _contract);
+	/// @returns a predicate that defines an external function summary.
+	smtutil::Expression externalSummary(FunctionDefinition const& _function);
+	smtutil::Expression externalSummary(FunctionDefinition const& _function, ContractDefinition const& _contract);
+	//@}
+
+	/// Solver related.
+	//@{
+	/// Adds Horn rule to the solver.
+	void addRule(smtutil::Expression const& _rule, std::string const& _ruleName);
+	/// @returns <true, invariant, empty> if query is unsatisfiable (safe).
+	/// @returns <false, Expression(true), model> otherwise.
+	std::tuple<smtutil::CheckResult, smtutil::Expression, smtutil::CHCSolverInterface::CexGraph> query(smtutil::Expression const& _query, langutil::SourceLocation const& _location);
+
+	void verificationTargetEncountered(ASTNode const* const _errorNode, VerificationTargetType _type, smtutil::Expression const& _errorCondition);
+
+	void checkVerificationTargets();
+	struct CHCQueryPlaceholder;
+	void checkAssertTarget(ASTNode const* _scope, CHCVerificationTarget const& _target);
+	void checkAndReportTarget(
+		CHCVerificationTarget const& _target,
+		std::vector<CHCQueryPlaceholder> const& _placeholders,
+		langutil::ErrorId _errorReporterId,
+		std::string _satMsg,
+		std::string _unknownMsg = ""
+	);
+
+	std::pair<std::string, langutil::ErrorId> targetDescription(CHCVerificationTarget const& _target);
+
+	std::optional<std::string> generateCounterexample(smtutil::CHCSolverInterface::CexGraph const& _graph, std::string const& _root);
+
+	/// @returns a call graph for function summaries in the counterexample graph.
+	/// The returned map also contains a key _root, whose value are the
+	/// summaries called by _root.
+	std::map<unsigned, std::vector<unsigned>> summaryCalls(
+		smtutil::CHCSolverInterface::CexGraph const& _graph,
+		unsigned _root
+	);
+
+	/// @returns a set of pairs _var = _value separated by _separator.
+	template <typename T>
+	std::string formatVariableModel(std::vector<T> const& _variables, std::vector<std::optional<std::string>> const& _values, std::string const& _separator) const
+	{
+		solAssert(_variables.size() == _values.size(), "");
+
+		std::vector<std::string> assignments;
+		for (unsigned i = 0; i < _values.size(); ++i)
+		{
+			auto var = _variables.at(i);
+			if (var && _values.at(i))
+				assignments.emplace_back(var->name() + " = " + *_values.at(i));
+		}
+
+		return boost::algorithm::join(assignments, _separator);
+	}
+
+	/// @returns a DAG in the dot format.
+	/// Used for debugging purposes.
+	std::string cex2dot(smtutil::CHCSolverInterface::CexGraph const& _graph);
+	//@}
+
+	/// Misc.
+	//@{
+	/// @returns a prefix to be used in a new unique block name
+	/// and increases the block counter.
+	std::string uniquePrefix();
+
+	/// @returns a suffix to be used by contract related predicates.
+	std::string contractSuffix(ContractDefinition const& _contract);
+
+	/// @returns a new unique error id associated with _expr and stores
+	/// it into m_errorIds.
+	unsigned newErrorId();
+
+	smt::SymbolicIntVariable& errorFlag();
+
+	/// Adds to the solver constraints that
+	/// - propagate tx.origin
+	/// - set the current contract as msg.sender
+	/// - set the msg.value as _value, if not nullptr
+	void newTxConstraints(Expression const* _value);
+
+	/// @returns the expression representing the value sent in
+	/// an external call if present,
+	/// and nullptr otherwise.
+	frontend::Expression const* valueOption(FunctionCallOptions const* _options);
+
+	/// Adds constraints that decrease the balance of the caller by _value.
+	void decreaseBalanceFromOptionsValue(Expression const& _value);
+
+	std::vector<smtutil::Expression> commonStateExpressions(smtutil::Expression const& error, smtutil::Expression const& address);
+	//@}
+
+	/// Predicates.
+	//@{
+	/// Artificial Interface predicate.
+	/// Single entry block for all functions.
+	std::map<ContractDefinition const*, Predicate const*> m_interfaces;
+
+	/// Nondeterministic interfaces.
+	/// These are used when the analyzed contract makes external calls to unknown code,
+	/// which means that the analyzed contract can potentially be called
+	/// nondeterministically.
+	std::map<ContractDefinition const*, Predicate const*> m_nondetInterfaces;
+
+	std::map<ContractDefinition const*, Predicate const*> m_constructorSummaries;
+	std::map<ContractDefinition const*, std::map<ContractDefinition const*, Predicate const*>> m_contractInitializers;
+
+	/// Artificial Error predicate.
+	/// Single error block for all assertions.
+	Predicate const* m_errorPredicate = nullptr;
+
+	/// Function predicates.
+	std::map<ContractDefinition const*, std::map<FunctionDefinition const*, Predicate const*>> m_summaries;
+
+	/// External function predicates.
+	std::map<ContractDefinition const*, std::map<FunctionDefinition const*, Predicate const*>> m_externalSummaries;
+	//@}
+
+	/// Variables.
+	//@{
+	/// State variables.
+	/// Used to create all predicates.
+	std::vector<VariableDeclaration const*> m_stateVariables;
+	//@}
+
+	/// Verification targets.
+	//@{
+	/// Query placeholder stores information necessary to create the final query edge in the CHC system.
+	/// It is combined with the unique error id (and error type) to create a complete Verification Target.
+	struct CHCQueryPlaceholder
+	{
+		smtutil::Expression const constraints;
+		smtutil::Expression const errorExpression;
+		smtutil::Expression const fromPredicate;
+	};
+
+	/// Query placeholders for constructors, if the key has type ContractDefinition*,
+	/// or external functions, if the key has type FunctionDefinition*.
+	/// A placeholder is created for each possible context of a function (e.g. multiple contracts in contract inheritance hierarchy).
+	std::map<ASTNode const*, std::vector<CHCQueryPlaceholder>, smt::EncodingContext::IdCompare> m_queryPlaceholders;
+
+	/// Records verification conditions IDs per function encountered during an analysis of that function.
+	/// The key is the ASTNode of the function where the verification condition has been encountered,
+	/// or the ASTNode of the contract if the verification condition happens inside an implicit constructor.
+	std::map<ASTNode const*, std::vector<unsigned>, smt::EncodingContext::IdCompare> m_functionTargetIds;
+	/// Helper mapping unique IDs to actual verification targets.
+	std::map<unsigned, CHCVerificationTarget> m_verificationTargets;
+
+	/// Targets proved safe.
+	std::map<ASTNode const*, std::set<CHCVerificationTarget>, smt::EncodingContext::IdCompare> m_safeTargets;
+	/// Targets proved unsafe.
+	std::map<ASTNode const*, std::map<VerificationTargetType, ReportTargetInfo>, smt::EncodingContext::IdCompare> m_unsafeTargets;
+	/// Targets not proved.
+	std::map<ASTNode const*, std::map<VerificationTargetType, ReportTargetInfo>, smt::EncodingContext::IdCompare> m_unprovedTargets;
+
+	/// Inferred invariants.
+	std::map<Predicate const*, std::set<std::string>, PredicateCompare> m_invariants;
+	//@}
+
+	/// Control-flow.
+	//@{
+	FunctionDefinition const* m_currentFunction = nullptr;
+
+	std::map<ASTNode const*, std::set<ASTNode const*, smt::EncodingContext::IdCompare>, smt::EncodingContext::IdCompare> m_callGraph;
+
+	/// The current block.
+	smtutil::Expression m_currentBlock = smtutil::Expression(true);
+
+	/// Counter to generate unique block names.
+	unsigned m_blockCounter = 0;
+
+	/// Whether a function call was seen in the current scope.
+	bool m_unknownFunctionCallSeen = false;
+
+	/// Block where a loop break should go to.
+	Predicate const* m_breakDest = nullptr;
+	/// Block where a loop continue should go to.
+	Predicate const* m_continueDest = nullptr;
+
+	/// Block where an error condition should go to.
+	/// This can be:
+	/// 1) Constructor initializer summary, if error happens while evaluating initial values of state variables.
+	/// 2) Constructor summary, if error happens while evaluating base constructor arguments.
+	/// 3) Function summary, if error happens inside a function.
+	Predicate const* m_errorDest = nullptr;
+
+	/// Represents the stack of destinations where a `return` should go.
+	/// This is different from `m_errorDest` above:
+	/// - Constructor initializers and constructor summaries will never be `return` targets because they are artificial.
+	/// - Modifiers also have their own `return` target blocks, whereas they do not have their own error destination.
+	std::vector<Predicate const*> m_returnDests;
+	//@}
+
+	/// CHC solver.
+	std::unique_ptr<smtutil::CHCSolverInterface> m_interface;
+
+	std::map<util::h256, std::string> const& m_smtlib2Responses;
+	ReadCallback::Callback const& m_smtCallback;
+};
+
+}
diff --git a/compiler/libsolidity/formal/EncodingContext.cpp b/compiler/libsolidity/formal/EncodingContext.cpp
new file mode 100644
index 00000000..e0a09bcf
--- /dev/null
+++ b/compiler/libsolidity/formal/EncodingContext.cpp
@@ -0,0 +1,214 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/EncodingContext.h>
+
+#include <libsolidity/formal/SymbolicTypes.h>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend::smt;
+
+EncodingContext::EncodingContext():
+	m_state(*this)
+{
+}
+
+void EncodingContext::reset()
+{
+	resetAllVariables();
+	m_expressions.clear();
+	m_globalContext.clear();
+	m_state.reset();
+	m_assertions.clear();
+}
+
+void EncodingContext::resetUniqueId()
+{
+	m_nextUniqueId = 0;
+}
+
+unsigned EncodingContext::newUniqueId()
+{
+	return m_nextUniqueId++;
+}
+
+/// Variables.
+
+std::shared_ptr<SymbolicVariable> EncodingContext::variable(frontend::VariableDeclaration const& _varDecl)
+{
+	solAssert(knownVariable(_varDecl), "");
+	return m_variables[&_varDecl];
+}
+
+bool EncodingContext::createVariable(frontend::VariableDeclaration const& _varDecl)
+{
+	solAssert(!knownVariable(_varDecl), "");
+	auto const& type = _varDecl.type();
+	auto result = newSymbolicVariable(*type, _varDecl.name() + "_" + std::to_string(_varDecl.id()), *this);
+	m_variables.emplace(&_varDecl, result.second);
+	return result.first;
+}
+
+bool EncodingContext::knownVariable(frontend::VariableDeclaration const& _varDecl)
+{
+	return m_variables.count(&_varDecl);
+}
+
+void EncodingContext::resetVariable(frontend::VariableDeclaration const& _variable)
+{
+	newValue(_variable);
+	setUnknownValue(_variable);
+}
+
+void EncodingContext::resetVariables(std::set<frontend::VariableDeclaration const*> const& _variables)
+{
+	for (auto const* decl: _variables)
+		resetVariable(*decl);
+}
+
+void EncodingContext::resetVariables(std::function<bool(frontend::VariableDeclaration const&)> const& _filter)
+{
+	for_each(begin(m_variables), end(m_variables), [&](auto _variable)
+	{
+		if (_filter(*_variable.first))
+			this->resetVariable(*_variable.first);
+	});
+}
+
+void EncodingContext::resetAllVariables()
+{
+	resetVariables([&](frontend::VariableDeclaration const&) { return true; });
+}
+
+smtutil::Expression EncodingContext::newValue(frontend::VariableDeclaration const& _decl)
+{
+	solAssert(knownVariable(_decl), "");
+	return m_variables.at(&_decl)->increaseIndex();
+}
+
+void EncodingContext::setZeroValue(frontend::VariableDeclaration const& _decl)
+{
+	solAssert(knownVariable(_decl), "");
+	setZeroValue(*m_variables.at(&_decl));
+}
+
+void EncodingContext::setZeroValue(SymbolicVariable& _variable)
+{
+	setSymbolicZeroValue(_variable, *this);
+}
+
+void EncodingContext::setUnknownValue(frontend::VariableDeclaration const& _decl)
+{
+	solAssert(knownVariable(_decl), "");
+	setUnknownValue(*m_variables.at(&_decl));
+}
+
+void EncodingContext::setUnknownValue(SymbolicVariable& _variable)
+{
+	setSymbolicUnknownValue(_variable, *this);
+}
+
+/// Expressions
+
+std::shared_ptr<SymbolicVariable> EncodingContext::expression(frontend::Expression const& _e)
+{
+	if (!knownExpression(_e))
+		createExpression(_e);
+	return m_expressions.at(&_e);
+}
+
+bool EncodingContext::createExpression(frontend::Expression const& _e, std::shared_ptr<SymbolicVariable> _symbVar)
+{
+	solAssert(_e.annotation().type, "");
+	if (knownExpression(_e))
+	{
+		expression(_e)->increaseIndex();
+		return false;
+	}
+	else if (_symbVar)
+	{
+		m_expressions.emplace(&_e, _symbVar);
+		return false;
+	}
+	else
+	{
+		auto result = newSymbolicVariable(*_e.annotation().type, "expr_" + std::to_string(_e.id()), *this);
+		m_expressions.emplace(&_e, result.second);
+		return result.first;
+	}
+}
+
+bool EncodingContext::knownExpression(frontend::Expression const& _e) const
+{
+	return m_expressions.count(&_e);
+}
+
+/// Global variables and functions.
+
+std::shared_ptr<SymbolicVariable> EncodingContext::globalSymbol(std::string const& _name)
+{
+	solAssert(knownGlobalSymbol(_name), "");
+	return m_globalContext.at(_name);
+}
+
+bool EncodingContext::createGlobalSymbol(std::string const& _name, frontend::Expression const& _expr)
+{
+	solAssert(!knownGlobalSymbol(_name), "");
+	auto result = newSymbolicVariable(*_expr.annotation().type, _name, *this);
+	m_globalContext.emplace(_name, result.second);
+	setUnknownValue(*result.second);
+	return result.first;
+}
+
+bool EncodingContext::knownGlobalSymbol(std::string const& _var) const
+{
+	return m_globalContext.count(_var);
+}
+
+/// Solver.
+
+smtutil::Expression EncodingContext::assertions()
+{
+	if (m_assertions.empty())
+		return smtutil::Expression(true);
+
+	return m_assertions.back();
+}
+
+void EncodingContext::pushSolver()
+{
+	if (m_accumulateAssertions)
+		m_assertions.push_back(assertions());
+	else
+		m_assertions.emplace_back(true);
+}
+
+void EncodingContext::popSolver()
+{
+	solAssert(!m_assertions.empty(), "");
+	m_assertions.pop_back();
+}
+
+void EncodingContext::addAssertion(smtutil::Expression const& _expr)
+{
+	if (m_assertions.empty())
+		m_assertions.push_back(_expr);
+	else
+		m_assertions.back() = _expr && std::move(m_assertions.back());
+}
diff --git a/compiler/libsolidity/formal/ExpressionFormatter.cpp b/compiler/libsolidity/formal/ExpressionFormatter.cpp
new file mode 100644
index 00000000..cf2f2c3b
--- /dev/null
+++ b/compiler/libsolidity/formal/ExpressionFormatter.cpp
@@ -0,0 +1,183 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/ExpressionFormatter.h>
+
+#include <libsolutil/Algorithms.h>
+#include <libsolutil/CommonData.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <range/v3/algorithm/for_each.hpp>
+
+#include <map>
+#include <vector>
+#include <string>
+
+using boost::algorithm::starts_with;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::smtutil;
+using namespace solidity::frontend::smt;
+
+namespace solidity::frontend::smt
+{
+
+namespace
+{
+
+std::string formatDatatypeAccessor(smtutil::Expression const& _expr, std::vector<std::string> const& _args)
+{
+	auto const& op = _expr.name;
+
+	// This is the most complicated part of the translation.
+	// Datatype accessor means access to a field of a datatype.
+	// In our encoding, datatypes are used to encode:
+	// - arrays/mappings as the tuple (array, length)
+	// - structs as the tuple (<member1>, ..., <memberK>)
+	// - hash and signature functions as the tuple (keccak256, sha256, ripemd160, ecrecover),
+	//   where each element is an array emulating an UF
+	// - abi.* functions as the tuple (<abiCall1>, ..., <abiCallK>).
+	if (op == "dt_accessor_keccak256")
+		return "keccak256";
+	if (op == "dt_accessor_sha256")
+		return "sha256";
+	if (op == "dt_accessor_ripemd160")
+		return "ripemd160";
+	if (op == "dt_accessor_ecrecover")
+		return "ecrecover";
+
+	std::string accessorStr = "accessor_";
+	// Struct members have suffix "accessor_<memberName>".
+	std::string type = op.substr(op.rfind(accessorStr) + accessorStr.size());
+	solAssert(_expr.arguments.size() == 1, "");
+
+	if (type == "length")
+		return _args.at(0) + ".length";
+	if (type == "array")
+		return _args.at(0);
+
+	if (
+		starts_with(type, "block") ||
+		starts_with(type, "msg") ||
+		starts_with(type, "tx") ||
+		starts_with(type, "abi")
+	)
+		return type;
+
+	if (starts_with(type, "t_function_abi"))
+		return type;
+
+	return _args.at(0) + "." + type;
+}
+
+std::string formatGenericOp(smtutil::Expression const& _expr, std::vector<std::string> const& _args)
+{
+	return _expr.name + "(" + boost::algorithm::join(_args, ", ") + ")";
+}
+
+std::string formatInfixOp(std::string const& _op, std::vector<std::string> const& _args)
+{
+	return "(" + boost::algorithm::join(_args, " " + _op + " ") + ")";
+}
+
+std::string formatArrayOp(smtutil::Expression const& _expr, std::vector<std::string> const& _args)
+{
+	if (_expr.name == "select")
+	{
+		auto const& a0 = _args.at(0);
+		static std::set<std::string> const ufs{"keccak256", "sha256", "ripemd160", "ecrecover"};
+		if (ufs.count(a0) || starts_with(a0, "t_function_abi"))
+			return _args.at(0) + "(" + _args.at(1) + ")";
+		return _args.at(0) + "[" + _args.at(1) + "]";
+	}
+	if (_expr.name == "store")
+		return "(" + _args.at(0) + "[" + _args.at(1) + "] := " + _args.at(2) + ")";
+	return formatGenericOp(_expr, _args);
+}
+
+std::string formatUnaryOp(smtutil::Expression const& _expr, std::vector<std::string> const& _args)
+{
+	if (_expr.name == "not")
+		return "!" + _args.at(0);
+	// Other operators such as exists may end up here.
+	return formatGenericOp(_expr, _args);
+}
+
+}
+
+smtutil::Expression substitute(smtutil::Expression _from, std::map<std::string, std::string> const& _subst)
+{
+	// TODO For now we ignore nested quantifier expressions,
+	// but we should support them in the future.
+	if (_from.name == "forall" || _from.name == "exists")
+		return smtutil::Expression(true);
+	if (_subst.count(_from.name))
+		_from.name = _subst.at(_from.name);
+	for (auto& arg: _from.arguments)
+		arg = substitute(arg, _subst);
+	return _from;
+}
+
+std::string toSolidityStr(smtutil::Expression const& _expr)
+{
+	auto const& op = _expr.name;
+
+	auto const& args = _expr.arguments;
+	auto strArgs = util::applyMap(args, [](auto const& _arg) { return toSolidityStr(_arg); });
+
+	// Constant or variable.
+	if (args.empty())
+		return op;
+
+	if (starts_with(op, "dt_accessor"))
+		return formatDatatypeAccessor(_expr, strArgs);
+
+	// Infix operators with format replacements.
+	static std::map<std::string, std::string> const infixOps{
+		{"and", "&&"},
+		{"or", "||"},
+		{"implies", "=>"},
+		{"=", "="},
+		{">", ">"},
+		{">=", ">="},
+		{"<", "<"},
+		{"<=", "<="},
+		{"+", "+"},
+		{"-", "-"},
+		{"*", "*"},
+		{"/", "/"},
+		{"div", "/"},
+		{"mod", "%"}
+	};
+	// Some of these (and, or, +, *) may have >= 2 arguments from z3.
+	if (infixOps.count(op))
+		return formatInfixOp(infixOps.at(op), strArgs);
+
+	static std::set<std::string> const arrayOps{"select", "store", "const_array"};
+	if (arrayOps.count(op))
+		return formatArrayOp(_expr, strArgs);
+
+	if (args.size() == 1)
+		return formatUnaryOp(_expr, strArgs);
+
+	// Other operators such as bv2int, int2bv may end up here.
+	return op + "(" + boost::algorithm::join(strArgs, ", ") + ")";
+}
+
+}
diff --git a/compiler/libsolidity/formal/Invariants.cpp b/compiler/libsolidity/formal/Invariants.cpp
new file mode 100644
index 00000000..017ab1e3
--- /dev/null
+++ b/compiler/libsolidity/formal/Invariants.cpp
@@ -0,0 +1,85 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/Invariants.h>
+
+#include <libsolidity/formal/ExpressionFormatter.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <libsolutil/Algorithms.h>
+
+#include <boost/algorithm/string.hpp>
+
+using boost::algorithm::starts_with;
+using namespace solidity;
+using namespace solidity::smtutil;
+using namespace solidity::frontend::smt;
+
+namespace solidity::frontend::smt
+{
+
+std::map<Predicate const*, std::set<std::string>> collectInvariants(
+	smtutil::Expression const& _proof,
+	std::set<Predicate const*> const& _predicates,
+	ModelCheckerInvariants const& _invariantsSetting
+)
+{
+	std::set<std::string> targets;
+	if (_invariantsSetting.has(InvariantType::Contract))
+		targets.insert("interface_");
+	if (_invariantsSetting.has(InvariantType::Reentrancy))
+		targets.insert("nondet_interface_");
+
+	std::map<std::string, std::pair<smtutil::Expression, smtutil::Expression>> equalities;
+	// Collect equalities where one of the sides is a predicate we're interested in.
+	util::BreadthFirstSearch<smtutil::Expression const*>{{&_proof}}.run([&](auto&& _expr, auto&& _addChild) {
+		if (_expr->name == "=")
+			for (auto const& t: targets)
+			{
+				auto arg0 = _expr->arguments.at(0);
+				auto arg1 = _expr->arguments.at(1);
+				if (starts_with(arg0.name, t))
+					equalities.insert({arg0.name, {arg0, std::move(arg1)}});
+				else if (starts_with(arg1.name, t))
+					equalities.insert({arg1.name, {arg1, std::move(arg0)}});
+			}
+		for (auto const& arg: _expr->arguments)
+			_addChild(&arg);
+	});
+
+	std::map<Predicate const*, std::set<std::string>> invariants;
+	for (auto pred: _predicates)
+	{
+		auto predName = pred->functor().name;
+		if (!equalities.count(predName))
+			continue;
+
+		solAssert(pred->contextContract(), "");
+
+		auto const& [predExpr, invExpr] = equalities.at(predName);
+
+		static std::set<std::string> const ignore{"true", "false"};
+		auto r = substitute(invExpr, pred->expressionSubstitution(predExpr));
+		// No point in reporting true/false as invariants.
+		if (!ignore.count(r.name))
+			invariants[pred].insert(toSolidityStr(r));
+	}
+	return invariants;
+}
+
+}
diff --git a/compiler/libsolidity/formal/ModelChecker.cpp b/compiler/libsolidity/formal/ModelChecker.cpp
new file mode 100644
index 00000000..5632ff5c
--- /dev/null
+++ b/compiler/libsolidity/formal/ModelChecker.cpp
@@ -0,0 +1,220 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/ModelChecker.h>
+#ifdef HAVE_Z3
+#include <libsmtutil/Z3Interface.h>
+#endif
+#ifdef HAVE_Z3_DLOPEN
+#include <z3_version.h>
+#endif
+
+#if defined(__linux) || defined(__APPLE__)
+#include <boost/process.hpp>
+#endif
+
+#include <range/v3/algorithm/any_of.hpp>
+#include <range/v3/view.hpp>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::smtutil;
+
+ModelChecker::ModelChecker(
+	ErrorReporter& _errorReporter,
+	langutil::CharStreamProvider const& _charStreamProvider,
+	std::map<h256, std::string> const& _smtlib2Responses,
+	ModelCheckerSettings _settings,
+	ReadCallback::Callback const& _smtCallback
+):
+	m_errorReporter(_errorReporter),
+	m_settings(std::move(_settings)),
+	m_context(),
+	m_bmc(m_context, m_uniqueErrorReporter, m_unsupportedErrorReporter, _smtlib2Responses, _smtCallback, m_settings, _charStreamProvider),
+	m_chc(m_context, m_uniqueErrorReporter, m_unsupportedErrorReporter, _smtlib2Responses, _smtCallback, m_settings, _charStreamProvider)
+{
+}
+
+// TODO This should be removed for 0.9.0.
+bool ModelChecker::isPragmaPresent(std::vector<std::shared_ptr<SourceUnit>> const& _sources)
+{
+	return ranges::any_of(_sources, [](auto _source) {
+		return _source && _source->annotation().experimentalFeatures.count(ExperimentalFeature::SMTChecker);
+	});
+}
+
+void ModelChecker::checkRequestedSourcesAndContracts(std::vector<std::shared_ptr<SourceUnit>> const& _sources)
+{
+	std::map<std::string, std::set<std::string>> exist;
+	for (auto const& source: _sources)
+		for (auto node: source->nodes())
+			if (auto contract = std::dynamic_pointer_cast<ContractDefinition>(node))
+				exist[contract->sourceUnitName()].insert(contract->name());
+
+	// Requested sources
+	for (auto const& sourceName: m_settings.contracts.contracts | ranges::views::keys)
+	{
+		if (!exist.count(sourceName))
+		{
+			m_uniqueErrorReporter.warning(
+				9134_error,
+				SourceLocation(),
+				"Requested source \"" + sourceName + "\" does not exist."
+			);
+			continue;
+		}
+		auto const& source = exist.at(sourceName);
+		// Requested contracts in source `s`.
+		for (auto const& contract: m_settings.contracts.contracts.at(sourceName))
+			if (!source.count(contract))
+				m_uniqueErrorReporter.warning(
+					7400_error,
+					SourceLocation(),
+					"Requested contract \"" + contract + "\" does not exist in source \"" + sourceName + "\"."
+				);
+	}
+}
+
+void ModelChecker::analyze(SourceUnit const& _source)
+{
+	// TODO This should be removed for 0.9.0.
+	if (_source.annotation().experimentalFeatures.count(ExperimentalFeature::SMTChecker))
+	{
+		PragmaDirective const* smtPragma = nullptr;
+		for (auto node: _source.nodes())
+			if (auto pragma = std::dynamic_pointer_cast<PragmaDirective>(node))
+				if (
+					pragma->literals().size() >= 2 &&
+					pragma->literals().at(1) == "SMTChecker"
+				)
+				{
+					smtPragma = pragma.get();
+					break;
+				}
+		solAssert(smtPragma, "");
+		m_uniqueErrorReporter.warning(
+			5523_error,
+			smtPragma->location(),
+			"The SMTChecker pragma has been deprecated and will be removed in the future. "
+			"Please use the \"model checker engine\" compiler setting to activate the SMTChecker instead. "
+			"If the pragma is enabled, all engines will be used."
+		);
+	}
+
+	if (m_settings.engine.none())
+		return;
+
+	if (m_settings.engine.chc)
+		m_chc.analyze(_source);
+
+	std::map<ASTNode const*, std::set<VerificationTargetType>, smt::EncodingContext::IdCompare> solvedTargets;
+
+	for (auto const& [node, targets]: m_chc.safeTargets())
+		for (auto const& target: targets)
+			solvedTargets[node].insert(target.type);
+
+	for (auto const& [node, targets]: m_chc.unsafeTargets())
+		solvedTargets[node] += targets | ranges::views::keys;
+
+	if (m_settings.engine.bmc)
+		m_bmc.analyze(_source, solvedTargets);
+
+	if (m_settings.showUnsupported)
+	{
+		m_errorReporter.append(m_unsupportedErrorReporter.errors());
+		m_unsupportedErrorReporter.clear();
+	}
+	else if (!m_unsupportedErrorReporter.errors().empty())
+		m_errorReporter.warning(
+			5724_error,
+			{},
+			"SMTChecker: " +
+			std::to_string(m_unsupportedErrorReporter.errors().size()) +
+			" unsupported language feature(s)."
+			" Enable the model checker option \"show unsupported\" to see all of them."
+		);
+
+	m_errorReporter.append(m_uniqueErrorReporter.errors());
+	m_uniqueErrorReporter.clear();
+}
+
+std::vector<std::string> ModelChecker::unhandledQueries()
+{
+	return m_bmc.unhandledQueries() + m_chc.unhandledQueries();
+}
+
+SMTSolverChoice ModelChecker::availableSolvers()
+{
+	smtutil::SMTSolverChoice available = smtutil::SMTSolverChoice::SMTLIB2();
+#if defined(__linux) || defined(__APPLE__)
+	available.eld = !boost::process::search_path("eld").empty();
+#endif
+#ifdef HAVE_Z3
+	available.z3 = solidity::smtutil::Z3Interface::available();
+#endif
+#ifdef HAVE_CVC4
+	available.cvc4 = true;
+#endif
+	return available;
+}
+
+SMTSolverChoice ModelChecker::checkRequestedSolvers(SMTSolverChoice _enabled, ErrorReporter& _errorReporter)
+{
+	SMTSolverChoice availableSolvers{ModelChecker::availableSolvers()};
+
+	if (_enabled.cvc4 && !availableSolvers.cvc4)
+	{
+		_enabled.cvc4 = false;
+		_errorReporter.warning(
+			4902_error,
+			SourceLocation(),
+			"Solver CVC4 was selected for SMTChecker but it is not available."
+		);
+	}
+
+	if (_enabled.eld && !availableSolvers.eld)
+	{
+		_enabled.eld = false;
+		_errorReporter.warning(
+			4458_error,
+			SourceLocation(),
+#if defined(__linux) || defined(__APPLE__)
+			"Solver Eldarica was selected for SMTChecker but it was not found in the system."
+#else
+			"Solver Eldarica was selected for SMTChecker but it is only supported on Linux and MacOS."
+#endif
+		);
+	}
+
+	if (_enabled.z3 && !availableSolvers.z3)
+	{
+		_enabled.z3 = false;
+		_errorReporter.warning(
+			8158_error,
+			SourceLocation(),
+			"Solver z3 was selected for SMTChecker but it is not available."
+#ifdef HAVE_Z3_DLOPEN
+			" libz3.so." + std::to_string(Z3_MAJOR_VERSION) + "." + std::to_string(Z3_MINOR_VERSION) + " was not found."
+#endif
+		);
+	}
+
+	return _enabled;
+}
diff --git a/compiler/libsolidity/formal/ModelChecker.h b/compiler/libsolidity/formal/ModelChecker.h
new file mode 100644
index 00000000..4c795fa7
--- /dev/null
+++ b/compiler/libsolidity/formal/ModelChecker.h
@@ -0,0 +1,110 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Entry point to the model checking engines.
+ * The goal of this class is to make different
+ * engines share knowledge to boost their proving power.
+ */
+
+#pragma once
+
+#include <libsolidity/formal/BMC.h>
+#include <libsolidity/formal/CHC.h>
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/ModelCheckerSettings.h>
+
+#include <libsolidity/interface/ReadFile.h>
+
+#include <libsmtutil/SolverInterface.h>
+
+#include <liblangutil/ErrorReporter.h>
+#include <liblangutil/UniqueErrorReporter.h>
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+struct SourceLocation;
+}
+
+namespace solidity::frontend
+{
+
+class ModelChecker
+{
+public:
+	/// @param _enabledSolvers represents a runtime choice of which SMT solvers
+	/// should be used, even if all are available. The default choice is to use all.
+	ModelChecker(
+		langutil::ErrorReporter& _errorReporter,
+		langutil::CharStreamProvider const& _charStreamProvider,
+		std::map<solidity::util::h256, std::string> const& _smtlib2Responses,
+		ModelCheckerSettings _settings = ModelCheckerSettings{},
+		ReadCallback::Callback const& _smtCallback = ReadCallback::Callback()
+	);
+
+	// TODO This should be removed for 0.9.0.
+	static bool isPragmaPresent(std::vector<std::shared_ptr<SourceUnit>> const& _sources);
+
+	/// Generates error messages if the requested sources and contracts
+	/// do not exist.
+	void checkRequestedSourcesAndContracts(std::vector<std::shared_ptr<SourceUnit>> const& _sources);
+
+	void analyze(SourceUnit const& _sources);
+
+	/// This is used if the SMT solver is not directly linked into this binary.
+	/// @returns a list of inputs to the SMT solver that were not part of the argument to
+	/// the constructor.
+	std::vector<std::string> unhandledQueries();
+
+	/// @returns SMT solvers that are available via the C++ API.
+	static smtutil::SMTSolverChoice availableSolvers();
+
+	/// @returns the intersection of the enabled and available solvers,
+	/// reporting warnings when a solver is enabled but not available.
+	static smtutil::SMTSolverChoice checkRequestedSolvers(smtutil::SMTSolverChoice _enabled, langutil::ErrorReporter& _errorReporter);
+
+private:
+	/// Error reporter from CompilerStack.
+	/// We need to append m_uniqueErrorReporter
+	/// to this one when the analysis is done.
+	langutil::ErrorReporter& m_errorReporter;
+
+	/// Used by ModelChecker, SMTEncoder, BMC and CHC to avoid duplicates.
+	/// This is local to ModelChecker, so needs to be appended
+	/// to m_errorReporter at the end of the analysis.
+	langutil::UniqueErrorReporter m_uniqueErrorReporter;
+
+	/// Used by SMTEncoder, BMC and CHC to accumulate unsupported
+	/// warnings and avoid duplicates.
+	/// This is local to ModelChecker, so needs to be appended
+	/// to m_errorReporter at the end of the analysis.
+	langutil::UniqueErrorReporter m_unsupportedErrorReporter;
+
+	ModelCheckerSettings m_settings;
+
+	/// Stores the context of the encoding.
+	smt::EncodingContext m_context;
+
+	/// Bounded Model Checker engine.
+	BMC m_bmc;
+
+	/// Constrained Horn Clauses engine.
+	CHC m_chc;
+};
+
+}
diff --git a/compiler/libsolidity/formal/ModelCheckerSettings.cpp b/compiler/libsolidity/formal/ModelCheckerSettings.cpp
new file mode 100644
index 00000000..ed4d5ce2
--- /dev/null
+++ b/compiler/libsolidity/formal/ModelCheckerSettings.cpp
@@ -0,0 +1,140 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/ModelCheckerSettings.h>
+
+#include <optional>
+#include <range/v3/view.hpp>
+
+using namespace solidity;
+using namespace solidity::frontend;
+
+std::map<std::string, InvariantType> const ModelCheckerInvariants::validInvariants{
+	{"contract", InvariantType::Contract},
+	{"reentrancy", InvariantType::Reentrancy}
+};
+
+std::optional<ModelCheckerInvariants> ModelCheckerInvariants::fromString(std::string const& _invs)
+{
+	std::set<InvariantType> chosenInvs;
+	if (_invs == "default")
+	{
+		// The default is that no invariants are reported.
+	}
+	else if (_invs == "all")
+		for (auto&& v: validInvariants | ranges::views::values)
+			chosenInvs.insert(v);
+	else
+		for (auto&& t: _invs | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
+		{
+			if (!validInvariants.count(t))
+				return {};
+			chosenInvs.insert(validInvariants.at(t));
+		}
+
+	return ModelCheckerInvariants{chosenInvs};
+}
+
+bool ModelCheckerInvariants::setFromString(std::string const& _inv)
+{
+	if (!validInvariants.count(_inv))
+		return false;
+	invariants.insert(validInvariants.at(_inv));
+	return true;
+}
+
+using TargetType = VerificationTargetType;
+std::map<std::string, TargetType> const ModelCheckerTargets::targetStrings{
+	{"constantCondition", TargetType::ConstantCondition},
+	{"underflow", TargetType::Underflow},
+	{"overflow", TargetType::Overflow},
+	{"divByZero", TargetType::DivByZero},
+	{"balance", TargetType::Balance},
+	{"assert", TargetType::Assert},
+	{"popEmptyArray", TargetType::PopEmptyArray},
+	{"outOfBounds", TargetType::OutOfBounds}
+};
+
+std::map<TargetType, std::string> const ModelCheckerTargets::targetTypeToString{
+	{TargetType::ConstantCondition, "Constant condition"},
+	{TargetType::Underflow, "Underflow"},
+	{TargetType::Overflow, "Overflow"},
+	{TargetType::DivByZero, "Division by zero"},
+	{TargetType::Balance, "Insufficient balance"},
+	{TargetType::Assert, "Assertion failed"},
+	{TargetType::PopEmptyArray, "Empty array pop"},
+	{TargetType::OutOfBounds, "Out of bounds access"}
+};
+
+std::optional<ModelCheckerTargets> ModelCheckerTargets::fromString(std::string const& _targets)
+{
+	std::set<TargetType> chosenTargets;
+	if (_targets == "default" || _targets == "all")
+	{
+		bool all = _targets == "all";
+		for (auto&& v: targetStrings | ranges::views::values)
+		{
+			if (!all && (v == TargetType::Underflow || v == TargetType::Overflow))
+				continue;
+			chosenTargets.insert(v);
+		}
+	}
+	else
+		for (auto&& t: _targets | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
+		{
+			if (!targetStrings.count(t))
+				return {};
+			chosenTargets.insert(targetStrings.at(t));
+		}
+
+	return ModelCheckerTargets{chosenTargets};
+}
+
+bool ModelCheckerTargets::setFromString(std::string const& _target)
+{
+	if (!targetStrings.count(_target))
+		return false;
+	targets.insert(targetStrings.at(_target));
+	return true;
+}
+
+std::optional<ModelCheckerContracts> ModelCheckerContracts::fromString(std::string const& _contracts)
+{
+	std::map<std::string, std::set<std::string>> chosen;
+	if (_contracts == "default")
+		return ModelCheckerContracts::Default();
+
+	for (auto&& sourceContract: _contracts | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
+	{
+		auto&& names = sourceContract | ranges::views::split(':') | ranges::to<std::vector<std::string>>();
+		if (names.size() != 2 || names.at(0).empty() || names.at(1).empty())
+			return {};
+		chosen[names.at(0)].insert(names.at(1));
+	}
+
+	return ModelCheckerContracts{chosen};
+}
+
+std::optional<ModelCheckerExtCalls> ModelCheckerExtCalls::fromString(std::string const& _mode)
+{
+	if (_mode == "untrusted")
+		return ModelCheckerExtCalls{Mode::UNTRUSTED};
+	if (_mode == "trusted")
+		return ModelCheckerExtCalls{Mode::TRUSTED};
+	return {};
+}
diff --git a/compiler/libsolidity/formal/ModelCheckerSettings.h b/compiler/libsolidity/formal/ModelCheckerSettings.h
new file mode 100644
index 00000000..b645f7c3
--- /dev/null
+++ b/compiler/libsolidity/formal/ModelCheckerSettings.h
@@ -0,0 +1,200 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsmtutil/SolverInterface.h>
+
+#include <optional>
+#include <set>
+
+namespace solidity::frontend
+{
+
+struct ModelCheckerContracts
+{
+	/// By default all contracts are analyzed.
+	static ModelCheckerContracts Default() { return {}; }
+
+	/// Parses a string of the form <path>:<contract>,<path>:contract,...
+	/// and returns nullopt if a path or contract name is empty.
+	static std::optional<ModelCheckerContracts> fromString(std::string const& _contracts);
+
+	/// @returns true if all contracts should be analyzed.
+	bool isDefault() const { return contracts.empty(); }
+
+	bool has(std::string const& _source) const { return contracts.count(_source); }
+	bool has(std::string const& _source, std::string const& _contract) const
+	{
+		return has(_source) && contracts.at(_source).count(_contract);
+	}
+
+	bool operator!=(ModelCheckerContracts const& _other) const noexcept { return !(*this == _other); }
+	bool operator==(ModelCheckerContracts const& _other) const noexcept { return contracts == _other.contracts; }
+
+	/// Represents which contracts should be analyzed by the SMTChecker
+	/// as the most derived.
+	/// The key is the source file. If the map is empty, all sources must be analyzed.
+	/// For each source, contracts[source] represents the contracts in that source
+	/// that should be analyzed.
+	/// If the set of contracts is empty, all contracts in that source should be analyzed.
+	std::map<std::string, std::set<std::string>> contracts;
+};
+
+struct ModelCheckerEngine
+{
+	bool bmc = false;
+	bool chc = false;
+
+	static constexpr ModelCheckerEngine All() { return {true, true}; }
+	static constexpr ModelCheckerEngine BMC() { return {true, false}; }
+	static constexpr ModelCheckerEngine CHC() { return {false, true}; }
+	static constexpr ModelCheckerEngine None() { return {false, false}; }
+
+	bool none() const { return !any(); }
+	bool any() const { return bmc || chc; }
+	bool all() const { return bmc && chc; }
+
+	static std::optional<ModelCheckerEngine> fromString(std::string const& _engine)
+	{
+		static std::map<std::string, ModelCheckerEngine> engineMap{
+			{"all", All()},
+			{"bmc", BMC()},
+			{"chc", CHC()},
+			{"none", None()}
+		};
+		if (engineMap.count(_engine))
+			return engineMap.at(_engine);
+		return {};
+	}
+
+	bool operator!=(ModelCheckerEngine const& _other) const noexcept { return !(*this == _other); }
+	bool operator==(ModelCheckerEngine const& _other) const noexcept { return bmc == _other.bmc && chc == _other.chc; }
+};
+
+enum class InvariantType { Contract, Reentrancy };
+
+struct ModelCheckerInvariants
+{
+	/// Adds the default targets, that is, all except underflow and overflow.
+	static ModelCheckerInvariants Default() { return *fromString("default"); }
+	/// Adds all targets, including underflow and overflow.
+	static ModelCheckerInvariants All() { return *fromString("all"); }
+	static ModelCheckerInvariants None() { return {{}}; }
+
+	static std::optional<ModelCheckerInvariants> fromString(std::string const& _invs);
+
+	bool has(InvariantType _inv) const { return invariants.count(_inv); }
+
+	/// @returns true if the @p _target is valid,
+	/// and false otherwise.
+	bool setFromString(std::string const& _target);
+
+	static std::map<std::string, InvariantType> const validInvariants;
+
+	bool operator!=(ModelCheckerInvariants const& _other) const noexcept { return !(*this == _other); }
+	bool operator==(ModelCheckerInvariants const& _other) const noexcept { return invariants == _other.invariants; }
+
+	std::set<InvariantType> invariants;
+};
+
+enum class VerificationTargetType { ConstantCondition, Underflow, Overflow, UnderOverflow, DivByZero, Balance, Assert, PopEmptyArray, OutOfBounds };
+
+struct ModelCheckerTargets
+{
+	/// Adds the default targets, that is, all except underflow and overflow.
+	static ModelCheckerTargets Default() { return *fromString("default"); }
+	/// Adds all targets, including underflow and overflow.
+	static ModelCheckerTargets All() { return *fromString("all"); }
+
+	static std::optional<ModelCheckerTargets> fromString(std::string const& _targets);
+
+	bool has(VerificationTargetType _type) const { return targets.count(_type); }
+
+	/// @returns true if the @p _target is valid,
+	/// and false otherwise.
+	bool setFromString(std::string const& _target);
+
+	static std::map<std::string, VerificationTargetType> const targetStrings;
+
+	static std::map<VerificationTargetType, std::string> const targetTypeToString;
+
+	bool operator!=(ModelCheckerTargets const& _other) const noexcept { return !(*this == _other); }
+	bool operator==(ModelCheckerTargets const& _other) const noexcept { return targets == _other.targets; }
+
+	std::set<VerificationTargetType> targets;
+};
+
+struct ModelCheckerExtCalls
+{
+	enum class Mode
+	{
+		UNTRUSTED,
+		TRUSTED
+	};
+
+	Mode mode = Mode::UNTRUSTED;
+
+	static std::optional<ModelCheckerExtCalls> fromString(std::string const& _mode);
+
+	bool isTrusted() const { return mode == Mode::TRUSTED; }
+};
+
+struct ModelCheckerSettings
+{
+	std::optional<unsigned> bmcLoopIterations;
+	ModelCheckerContracts contracts = ModelCheckerContracts::Default();
+	/// Currently division and modulo are replaced by multiplication with slack vars, such that
+	/// a / b <=> a = b * k + m
+	/// where k and m are slack variables.
+	/// This is the default because Spacer prefers that over precise / and mod.
+	/// This option allows disabling this mechanism since other solvers
+	/// might prefer the precise encoding.
+	bool divModNoSlacks = false;
+	ModelCheckerEngine engine = ModelCheckerEngine::None();
+	ModelCheckerExtCalls externalCalls = {};
+	ModelCheckerInvariants invariants = ModelCheckerInvariants::Default();
+	bool printQuery = false;
+	bool showProvedSafe = false;
+	bool showUnproved = false;
+	bool showUnsupported = false;
+	smtutil::SMTSolverChoice solvers = smtutil::SMTSolverChoice::Z3();
+	ModelCheckerTargets targets = ModelCheckerTargets::Default();
+	std::optional<unsigned> timeout;
+
+	bool operator!=(ModelCheckerSettings const& _other) const noexcept { return !(*this == _other); }
+	bool operator==(ModelCheckerSettings const& _other) const noexcept
+	{
+		return
+			bmcLoopIterations == _other.bmcLoopIterations &&
+			contracts == _other.contracts &&
+			divModNoSlacks == _other.divModNoSlacks &&
+			engine == _other.engine &&
+			externalCalls.mode == _other.externalCalls.mode &&
+			invariants == _other.invariants &&
+			printQuery == _other.printQuery &&
+			showProvedSafe == _other.showProvedSafe &&
+			showUnproved == _other.showUnproved &&
+			showUnsupported == _other.showUnsupported &&
+			solvers == _other.solvers &&
+			targets == _other.targets &&
+			timeout == _other.timeout;
+	}
+};
+
+}
diff --git a/compiler/libsolidity/formal/Predicate.cpp b/compiler/libsolidity/formal/Predicate.cpp
new file mode 100644
index 00000000..58a5a5a3
--- /dev/null
+++ b/compiler/libsolidity/formal/Predicate.cpp
@@ -0,0 +1,680 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/Predicate.h>
+
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <liblangutil/CharStreamProvider.h>
+#include <liblangutil/CharStream.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/TypeProvider.h>
+
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string.hpp>
+
+#include <range/v3/view.hpp>
+#include <utility>
+
+using boost::algorithm::starts_with;
+using namespace solidity;
+using namespace solidity::smtutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+std::map<std::string, Predicate> Predicate::m_predicates;
+
+Predicate const* Predicate::create(
+	SortPointer _sort,
+	std::string _name,
+	PredicateType _type,
+	EncodingContext& _context,
+	ASTNode const* _node,
+	ContractDefinition const* _contractContext,
+	std::vector<ScopeOpener const*> _scopeStack
+)
+{
+	smt::SymbolicFunctionVariable predicate{_sort, std::move(_name), _context};
+	std::string functorName = predicate.currentName();
+	solAssert(!m_predicates.count(functorName), "");
+	return &m_predicates.emplace(
+		std::piecewise_construct,
+		std::forward_as_tuple(functorName),
+		std::forward_as_tuple(std::move(predicate), _type, _context.state().hasBytesConcatFunction(),
+			_node, _contractContext, std::move(_scopeStack))
+	).first->second;
+}
+
+Predicate::Predicate(
+	smt::SymbolicFunctionVariable&& _predicate,
+	PredicateType _type,
+	bool _bytesConcatFunctionInContext,
+	ASTNode const* _node,
+	ContractDefinition const* _contractContext,
+	std::vector<ScopeOpener const*> _scopeStack
+):
+	m_predicate(std::move(_predicate)),
+	m_type(_type),
+	m_node(_node),
+	m_contractContext(_contractContext),
+	m_scopeStack(_scopeStack),
+	m_bytesConcatFunctionInContext(_bytesConcatFunctionInContext)
+{
+}
+
+Predicate const* Predicate::predicate(std::string const& _name)
+{
+	return &m_predicates.at(_name);
+}
+
+void Predicate::reset()
+{
+	m_predicates.clear();
+}
+
+smtutil::Expression Predicate::operator()(std::vector<smtutil::Expression> const& _args) const
+{
+	return m_predicate(_args);
+}
+
+smtutil::Expression Predicate::functor() const
+{
+	return m_predicate.currentFunctionValue();
+}
+
+smtutil::Expression Predicate::functor(unsigned _idx) const
+{
+	return m_predicate.functionValueAtIndex(_idx);
+}
+
+void Predicate::newFunctor()
+{
+	m_predicate.increaseIndex();
+}
+
+ASTNode const* Predicate::programNode() const
+{
+	return m_node;
+}
+
+ContractDefinition const* Predicate::contextContract() const
+{
+	return m_contractContext;
+}
+
+ContractDefinition const* Predicate::programContract() const
+{
+	if (auto const* contract = dynamic_cast<ContractDefinition const*>(m_node))
+		if (!contract->constructor())
+			return contract;
+
+	return nullptr;
+}
+
+FunctionDefinition const* Predicate::programFunction() const
+{
+	if (auto const* contract = dynamic_cast<ContractDefinition const*>(m_node))
+	{
+		if (contract->constructor())
+			return contract->constructor();
+		return nullptr;
+	}
+
+	if (auto const* fun = dynamic_cast<FunctionDefinition const*>(m_node))
+		return fun;
+
+	return nullptr;
+}
+
+FunctionCall const* Predicate::programFunctionCall() const
+{
+	return dynamic_cast<FunctionCall const*>(m_node);
+}
+
+VariableDeclaration  const* Predicate::programVariable() const
+{
+	return dynamic_cast<VariableDeclaration const*>(m_node);
+}
+
+std::optional<std::vector<VariableDeclaration const*>> Predicate::stateVariables() const
+{
+	if (m_contractContext)
+		return SMTEncoder::stateVariablesIncludingInheritedAndPrivate(*m_contractContext);
+
+	return std::nullopt;
+}
+
+bool Predicate::isSummary() const
+{
+	return isFunctionSummary() ||
+		isInternalCall() ||
+		isExternalCallTrusted() ||
+		isExternalCallUntrusted() ||
+		isConstructorSummary();
+}
+
+bool Predicate::isFunctionSummary() const
+{
+	return m_type == PredicateType::FunctionSummary;
+}
+
+bool Predicate::isFunctionBlock() const
+{
+	return m_type == PredicateType::FunctionBlock;
+}
+
+bool Predicate::isFunctionErrorBlock() const
+{
+	return m_type == PredicateType::FunctionErrorBlock;
+}
+
+bool Predicate::isInternalCall() const
+{
+	return m_type == PredicateType::InternalCall;
+}
+
+bool Predicate::isExternalCallTrusted() const
+{
+	return m_type == PredicateType::ExternalCallTrusted;
+}
+
+bool Predicate::isExternalCallUntrusted() const
+{
+	return m_type == PredicateType::ExternalCallUntrusted;
+}
+
+bool Predicate::isConstructorSummary() const
+{
+	return m_type == PredicateType::ConstructorSummary;
+}
+
+bool Predicate::isInterface() const
+{
+	return m_type == PredicateType::Interface;
+}
+
+bool Predicate::isNondetInterface() const
+{
+	return m_type == PredicateType::NondetInterface;
+}
+
+std::string Predicate::formatSummaryCall(
+	std::vector<smtutil::Expression> const& _args,
+	langutil::CharStreamProvider const& _charStreamProvider,
+	bool _appendTxVars
+) const
+{
+	solAssert(isSummary(), "");
+
+	if (programVariable())
+		return {};
+
+	if (auto funCall = programFunctionCall())
+	{
+		if (funCall->location().hasText())
+			return std::string(_charStreamProvider.charStream(*funCall->location().sourceName).text(funCall->location()));
+		else
+			return {};
+	}
+
+	/// The signature of a function summary predicate is: summary(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockChainState, preStateVars, preInputVars, postBlockchainState, postStateVars, postInputVars, outputVars).
+	/// Here we are interested in preInputVars to format the function call.
+
+	std::string txModel;
+
+	if (_appendTxVars)
+	{
+		std::set<std::string> txVars;
+		if (isFunctionSummary())
+		{
+			solAssert(programFunction(), "");
+			if (programFunction()->isPayable())
+				txVars.insert("msg.value");
+		}
+		else if (isConstructorSummary())
+		{
+			FunctionDefinition const* fun = programFunction();
+			if (fun && fun->isPayable())
+				txVars.insert("msg.value");
+		}
+
+		struct TxVarsVisitor: public ASTConstVisitor
+		{
+			bool visit(MemberAccess const& _memberAccess)
+			{
+				Expression const* memberExpr = SMTEncoder::innermostTuple(_memberAccess.expression());
+
+				Type const* exprType = memberExpr->annotation().type;
+				solAssert(exprType, "");
+				if (exprType->category() == Type::Category::Magic)
+					if (auto const* identifier = dynamic_cast<Identifier const*>(memberExpr))
+					{
+						ASTString const& name = identifier->name();
+						auto memberName = _memberAccess.memberName();
+
+						// TODO remove this for 0.9.0
+						if (name == "block" && memberName == "difficulty")
+							memberName = "prevrandao";
+
+						if (name == "block" || name == "msg" || name == "tx")
+							txVars.insert(name + "." + memberName);
+					}
+
+				return true;
+			}
+
+			std::set<std::string> txVars;
+		} txVarsVisitor;
+
+		if (auto fun = programFunction())
+		{
+			fun->accept(txVarsVisitor);
+			txVars += txVarsVisitor.txVars;
+		}
+
+		// Here we are interested in txData from the summary predicate.
+		auto txValues = readTxVars(_args.at(txValuesIndex()));
+		std::vector<std::string> values;
+		for (auto const& _var: txVars)
+			if (auto v = txValues.at(_var))
+				values.push_back(_var + ": " + *v);
+
+		if (!values.empty())
+			txModel = "{ " + boost::algorithm::join(values, ", ") + " }";
+	}
+
+	if (auto contract = programContract())
+		return contract->name() + ".constructor()" + txModel;
+
+	auto stateVars = stateVariables();
+	solAssert(stateVars.has_value(), "");
+	auto const* fun = programFunction();
+	solAssert(fun, "");
+
+	auto first = _args.begin() + static_cast<int>(firstArgIndex()) + static_cast<int>(stateVars->size());
+	auto last = first + static_cast<int>(fun->parameters().size());
+	solAssert(first >= _args.begin() && first <= _args.end(), "");
+	solAssert(last >= _args.begin() && last <= _args.end(), "");
+	auto inTypes = SMTEncoder::replaceUserTypes(FunctionType(*fun).parameterTypes());
+	std::vector<std::optional<std::string>> functionArgsCex = formatExpressions(std::vector<smtutil::Expression>(first, last), inTypes);
+	std::vector<std::string> functionArgs;
+
+	auto const& params = fun->parameters();
+	solAssert(params.size() == functionArgsCex.size(), "");
+	for (unsigned i = 0; i < params.size(); ++i)
+		if (params.at(i) && functionArgsCex.at(i))
+			functionArgs.emplace_back(*functionArgsCex.at(i));
+		else
+			functionArgs.emplace_back(params[i]->name());
+
+	std::string fName = fun->isConstructor() ? "constructor" :
+		fun->isFallback() ? "fallback" :
+		fun->isReceive() ? "receive" :
+		fun->name();
+
+	std::string prefix;
+	if (fun->isFree())
+		prefix = !fun->sourceUnitName().empty() ? (fun->sourceUnitName() + ":") : "";
+	else
+	{
+		solAssert(fun->annotation().contract, "");
+		prefix = fun->annotation().contract->name() + ".";
+	}
+	return prefix + fName + "(" + boost::algorithm::join(functionArgs, ", ") + ")" + txModel;
+}
+
+std::vector<std::optional<std::string>> Predicate::summaryStateValues(std::vector<smtutil::Expression> const& _args) const
+{
+	/// The signature of a function summary predicate is: summary(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockchainState, preStateVars, preInputVars, postBlockchainState, postStateVars, postInputVars, outputVars).
+	/// The signature of the summary predicate of a contract without constructor is: summary(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockchainState, postBlockchainState, preStateVars, postStateVars).
+	/// Here we are interested in postStateVars.
+	auto stateVars = stateVariables();
+	solAssert(stateVars.has_value(), "");
+
+	std::vector<smtutil::Expression>::const_iterator stateFirst;
+	std::vector<smtutil::Expression>::const_iterator stateLast;
+	if (auto const* function = programFunction())
+	{
+		stateFirst = _args.begin() + static_cast<int>(firstArgIndex()) + static_cast<int>(stateVars->size()) + static_cast<int>(function->parameters().size()) + 1;
+		stateLast = stateFirst + static_cast<int>(stateVars->size());
+	}
+	else if (programContract())
+	{
+		stateFirst = _args.begin() + static_cast<int>(firstStateVarIndex()) + static_cast<int>(stateVars->size());
+		stateLast = stateFirst + static_cast<int>(stateVars->size());
+	}
+	else if (programVariable())
+		return {};
+	else
+		solAssert(false, "");
+
+	solAssert(stateFirst >= _args.begin() && stateFirst <= _args.end(), "");
+	solAssert(stateLast >= _args.begin() && stateLast <= _args.end(), "");
+
+	std::vector<smtutil::Expression> stateArgs(stateFirst, stateLast);
+	solAssert(stateArgs.size() == stateVars->size(), "");
+	auto stateTypes = util::applyMap(*stateVars, [&](auto const& _var) { return _var->type(); });
+	return formatExpressions(stateArgs, stateTypes);
+}
+
+std::vector<std::optional<std::string>> Predicate::summaryPostInputValues(std::vector<smtutil::Expression> const& _args) const
+{
+	/// The signature of a function summary predicate is: summary(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockchainState, preStateVars, preInputVars, postBlockchainState, postStateVars, postInputVars, outputVars).
+	/// Here we are interested in postInputVars.
+	auto const* function = programFunction();
+	solAssert(function, "");
+
+	auto stateVars = stateVariables();
+	solAssert(stateVars.has_value(), "");
+
+	auto const& inParams = function->parameters();
+
+	auto first = _args.begin() + static_cast<int>(firstArgIndex()) + static_cast<int>(stateVars->size()) * 2 + static_cast<int>(inParams.size()) + 1;
+	auto last = first + static_cast<int>(inParams.size());
+
+	solAssert(first >= _args.begin() && first <= _args.end(), "");
+	solAssert(last >= _args.begin() && last <= _args.end(), "");
+
+	std::vector<smtutil::Expression> inValues(first, last);
+	solAssert(inValues.size() == inParams.size(), "");
+	auto inTypes = SMTEncoder::replaceUserTypes(FunctionType(*function).parameterTypes());
+	return formatExpressions(inValues, inTypes);
+}
+
+std::vector<std::optional<std::string>> Predicate::summaryPostOutputValues(std::vector<smtutil::Expression> const& _args) const
+{
+	/// The signature of a function summary predicate is: summary(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockchainState, preStateVars, preInputVars, postBlockchainState, postStateVars, postInputVars, outputVars).
+	/// Here we are interested in outputVars.
+	auto const* function = programFunction();
+	solAssert(function, "");
+
+	auto stateVars = stateVariables();
+	solAssert(stateVars.has_value(), "");
+
+	auto const& inParams = function->parameters();
+
+	auto first = _args.begin() + static_cast<int>(firstArgIndex()) + static_cast<int>(stateVars->size()) * 2 + static_cast<int>(inParams.size()) * 2 + 1;
+
+	solAssert(first >= _args.begin() && first <= _args.end(), "");
+
+	std::vector<smtutil::Expression> outValues(first, _args.end());
+	solAssert(outValues.size() == function->returnParameters().size(), "");
+	auto outTypes = SMTEncoder::replaceUserTypes(FunctionType(*function).returnParameterTypes());
+	return formatExpressions(outValues, outTypes);
+}
+
+std::pair<std::vector<std::optional<std::string>>, std::vector<VariableDeclaration const*>> Predicate::localVariableValues(std::vector<smtutil::Expression> const& _args) const
+{
+	/// The signature of a local block predicate is:
+	/// block(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, txData, preBlockchainState, preStateVars, preInputVars, postBlockchainState, postStateVars, postInputVars, outputVars, localVars).
+	/// Here we are interested in localVars.
+	auto const* function = programFunction();
+	solAssert(function, "");
+
+	auto const& localVars = SMTEncoder::localVariablesIncludingModifiers(*function, m_contractContext);
+	auto first = _args.end() - static_cast<int>(localVars.size());
+	std::vector<smtutil::Expression> outValues(first, _args.end());
+
+	auto mask = util::applyMap(
+		localVars,
+		[this](auto _var) {
+			auto varScope = dynamic_cast<ScopeOpener const*>(_var->scope());
+			return find(begin(m_scopeStack), end(m_scopeStack), varScope) != end(m_scopeStack);
+		}
+	);
+	auto localVarsInScope = util::filter(localVars, mask);
+	auto outValuesInScope = util::filter(outValues, mask);
+
+	auto outTypes = util::applyMap(localVarsInScope, [](auto _var) { return _var->type(); });
+	return {formatExpressions(outValuesInScope, outTypes), localVarsInScope};
+}
+
+std::map<std::string, std::string> Predicate::expressionSubstitution(smtutil::Expression const& _predExpr) const
+{
+	std::map<std::string, std::string> subst;
+	std::string predName = functor().name;
+
+	solAssert(contextContract(), "");
+	auto const& stateVars = SMTEncoder::stateVariablesIncludingInheritedAndPrivate(*contextContract());
+
+	auto nArgs = _predExpr.arguments.size();
+
+	// The signature of an interface predicate is
+	// interface(this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, blockchainState, stateVariables).
+	// An invariant for an interface predicate is a contract
+	// invariant over its state, for example `x <= 0`.
+	if (isInterface())
+	{
+		size_t shift = txValuesIndex();
+		solAssert(starts_with(predName, "interface"), "");
+		subst[_predExpr.arguments.at(0).name] = "address(this)";
+		solAssert(nArgs == stateVars.size() + shift, "");
+		for (size_t i = nArgs - stateVars.size(); i < nArgs; ++i)
+			subst[_predExpr.arguments.at(i).name] = stateVars.at(i - shift)->name();
+	}
+	// The signature of a nondet interface predicate is
+	// nondet_interface(error, this, abiFunctions, (optionally) bytesConcatFunctions, cryptoFunctions, blockchainState, stateVariables, blockchainState', stateVariables').
+	// An invariant for a nondet interface predicate is a reentrancy property
+	// over the pre and post state variables of a contract, where pre state vars
+	// are represented by the variable's name and post state vars are represented
+	// by the primed variable's name, for example
+	// `(x <= 0) => (x' <= 100)`.
+	else if (isNondetInterface())
+	{
+		solAssert(starts_with(predName, "nondet_interface"), "");
+		subst[_predExpr.arguments.at(0).name] = "<errorCode>";
+		subst[_predExpr.arguments.at(1).name] = "address(this)";
+		solAssert(nArgs == stateVars.size() * 2 + firstArgIndex(), "");
+		for (size_t i = nArgs - stateVars.size(), s = 0; i < nArgs; ++i, ++s)
+			subst[_predExpr.arguments.at(i).name] = stateVars.at(s)->name() + "'";
+		for (size_t i = nArgs - (stateVars.size() * 2 + 1), s = 0; i < nArgs - (stateVars.size() + 1); ++i, ++s)
+			subst[_predExpr.arguments.at(i).name] = stateVars.at(s)->name();
+	}
+
+	return subst;
+}
+
+std::vector<std::optional<std::string>> Predicate::formatExpressions(std::vector<smtutil::Expression> const& _exprs, std::vector<Type const*> const& _types) const
+{
+	solAssert(_exprs.size() == _types.size(), "");
+	std::vector<std::optional<std::string>> strExprs;
+	for (unsigned i = 0; i < _exprs.size(); ++i)
+		strExprs.push_back(expressionToString(_exprs.at(i), _types.at(i)));
+	return strExprs;
+}
+
+std::optional<std::string> Predicate::expressionToString(smtutil::Expression const& _expr, Type const* _type) const
+{
+	if (smt::isNumber(*_type))
+	{
+		solAssert(_expr.sort->kind == Kind::Int, "");
+		solAssert(_expr.arguments.empty(), "");
+
+		if (
+			_type->category() == Type::Category::Address ||
+			_type->category() == Type::Category::FixedBytes
+		)
+		{
+			try
+			{
+				if (_expr.name == "0")
+					return "0x0";
+				// For some reason the code below returns "0x" for "0".
+				return util::toHex(toCompactBigEndian(bigint(_expr.name)), util::HexPrefix::Add, util::HexCase::Lower);
+			}
+			catch (std::out_of_range const&)
+			{
+			}
+			catch (std::invalid_argument const&)
+			{
+			}
+		}
+
+		return _expr.name;
+	}
+	if (smt::isBool(*_type))
+	{
+		solAssert(_expr.sort->kind == Kind::Bool, "");
+		solAssert(_expr.arguments.empty(), "");
+		solAssert(_expr.name == "true" || _expr.name == "false", "");
+		return _expr.name;
+	}
+	if (smt::isFunction(*_type))
+	{
+		solAssert(_expr.arguments.empty(), "");
+		return _expr.name;
+	}
+	if (smt::isArray(*_type))
+	{
+		auto const& arrayType = dynamic_cast<ArrayType const&>(*_type);
+		if (_expr.name != "tuple_constructor")
+			return {};
+
+		auto const& tupleSort = dynamic_cast<TupleSort const&>(*_expr.sort);
+		solAssert(tupleSort.components.size() == 2, "");
+
+		unsigned long length;
+		try
+		{
+			length = stoul(_expr.arguments.at(1).name);
+		}
+		catch(std::out_of_range const&)
+		{
+			return {};
+		}
+		catch(std::invalid_argument const&)
+		{
+			return {};
+		}
+
+		// Limit this counterexample size to 1k.
+		// Some OSs give you "unlimited" memory through swap and other virtual memory,
+		// so purely relying on bad_alloc being thrown is not a good idea.
+		// In that case, the array allocation might cause OOM and the program is killed.
+		if (length >= 1024)
+			return {};
+		try
+		{
+			std::vector<std::string> array(length);
+			if (!fillArray(_expr.arguments.at(0), array, arrayType))
+				return {};
+			return "[" + boost::algorithm::join(array, ", ") + "]";
+		}
+		catch (std::bad_alloc const&)
+		{
+			// Solver gave a concrete array but length is too large.
+		}
+	}
+	if (smt::isNonRecursiveStruct(*_type))
+	{
+		auto const& structType = dynamic_cast<StructType const&>(*_type);
+		solAssert(_expr.name == "tuple_constructor", "");
+		auto const& tupleSort = dynamic_cast<TupleSort const&>(*_expr.sort);
+		auto members = structType.structDefinition().members();
+		solAssert(tupleSort.components.size() == members.size(), "");
+		solAssert(_expr.arguments.size() == members.size(), "");
+		std::vector<std::string> elements;
+		for (unsigned i = 0; i < members.size(); ++i)
+		{
+			std::optional<std::string> elementStr = expressionToString(_expr.arguments.at(i), members[i]->type());
+			elements.push_back(members[i]->name() + (elementStr.has_value() ?  ": " + elementStr.value() : ""));
+		}
+		return "{" + boost::algorithm::join(elements, ", ") + "}";
+	}
+
+	return {};
+}
+
+bool Predicate::fillArray(smtutil::Expression const& _expr, std::vector<std::string>& _array, ArrayType const& _type) const
+{
+	// Base case
+	if (_expr.name == "const_array")
+	{
+		auto length = _array.size();
+		std::optional<std::string> elemStr = expressionToString(_expr.arguments.at(1), _type.baseType());
+		if (!elemStr)
+			return false;
+		_array.clear();
+		_array.resize(length, *elemStr);
+		return true;
+	}
+
+	// Recursive case.
+	if (_expr.name == "store")
+	{
+		if (!fillArray(_expr.arguments.at(0), _array, _type))
+			return false;
+		std::optional<std::string> indexStr = expressionToString(_expr.arguments.at(1), TypeProvider::uint256());
+		if (!indexStr)
+			return false;
+		// Sometimes the solver assigns huge lengths that are not related,
+		// we should catch and ignore those.
+		unsigned long index;
+		try
+		{
+			index = stoul(*indexStr);
+		}
+		catch (std::out_of_range const&)
+		{
+			return true;
+		}
+		catch (std::invalid_argument const&)
+		{
+			return true;
+		}
+		std::optional<std::string> elemStr = expressionToString(_expr.arguments.at(2), _type.baseType());
+		if (!elemStr)
+			return false;
+		if (index < _array.size())
+			_array.at(index) = *elemStr;
+		return true;
+	}
+
+	// Special base case, not supported yet.
+	if (_expr.name.rfind("(_ as-array") == 0)
+	{
+		// Z3 expression representing reinterpretation of a different term as an array
+		return false;
+	}
+
+	solAssert(false, "");
+}
+
+std::map<std::string, std::optional<std::string>> Predicate::readTxVars(smtutil::Expression const& _tx) const
+{
+	std::map<std::string, Type const*> const txVars{
+		{"block.basefee", TypeProvider::uint256()},
+		{"block.chainid", TypeProvider::uint256()},
+		{"block.coinbase", TypeProvider::address()},
+		{"block.prevrandao", TypeProvider::uint256()},
+		{"block.gaslimit", TypeProvider::uint256()},
+		{"block.number", TypeProvider::uint256()},
+		{"block.timestamp", TypeProvider::uint256()},
+		{"blockhash", TypeProvider::array(DataLocation::Memory, TypeProvider::uint256())},
+		{"msg.data", TypeProvider::array(DataLocation::CallData)},
+		{"msg.sender", TypeProvider::address()},
+		{"msg.sig", TypeProvider::fixedBytes(4)},
+		{"msg.value", TypeProvider::uint256()},
+		{"tx.gasprice", TypeProvider::uint256()},
+		{"tx.origin", TypeProvider::address()}
+	};
+	std::map<std::string, std::optional<std::string>> vars;
+	for (auto&& [i, v]: txVars | ranges::views::enumerate)
+		vars.emplace(v.first, expressionToString(_tx.arguments.at(i), v.second));
+	return vars;
+}
diff --git a/compiler/libsolidity/formal/Predicate.h b/compiler/libsolidity/formal/Predicate.h
new file mode 100644
index 00000000..638354f9
--- /dev/null
+++ b/compiler/libsolidity/formal/Predicate.h
@@ -0,0 +1,247 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolidity/formal/SymbolicVariables.h>
+#include <libsolidity/formal/SymbolicVariables.h>
+
+#include <libsolidity/ast/AST.h>
+
+#include <libsmtutil/Sorts.h>
+
+#include <map>
+#include <optional>
+#include <vector>
+
+namespace solidity::langutil
+{
+class CharStreamProvider;
+}
+
+namespace solidity::frontend
+{
+
+enum class PredicateType
+{
+	Interface,
+	NondetInterface,
+	ConstructorSummary,
+	FunctionSummary,
+	FunctionBlock,
+	FunctionErrorBlock,
+	InternalCall,
+	ExternalCallTrusted,
+	ExternalCallUntrusted,
+	Error,
+	Custom
+};
+
+/**
+ * Represents a predicate used by the CHC engine.
+ */
+class Predicate
+{
+public:
+	static Predicate const* create(
+		smtutil::SortPointer _sort,
+		std::string _name,
+		PredicateType _type,
+		smt::EncodingContext& _context,
+		ASTNode const* _node = nullptr,
+		ContractDefinition const* _contractContext = nullptr,
+		std::vector<ScopeOpener const*> _scopeStack = {}
+	);
+
+	Predicate(
+		smt::SymbolicFunctionVariable&& _predicate,
+		PredicateType _type,
+		bool _bytesConcatFunctionInContext,
+		ASTNode const* _node = nullptr,
+		ContractDefinition const* _contractContext = nullptr,
+		std::vector<ScopeOpener const*> _scopeStack = {}
+	);
+
+	/// Predicate should not be copiable.
+	Predicate(Predicate const&) = delete;
+	Predicate& operator=(Predicate const&) = delete;
+
+	/// @returns the Predicate associated with _name.
+	static Predicate const* predicate(std::string const& _name);
+
+	/// Resets all the allocated predicates.
+	static void reset();
+
+	/// @returns a function application of the predicate over _args.
+	smtutil::Expression operator()(std::vector<smtutil::Expression> const& _args) const;
+
+	/// @returns the function declaration of the predicate.
+	smtutil::Expression functor() const;
+	/// @returns the function declaration of the predicate with index _idx.
+	smtutil::Expression functor(unsigned _idx) const;
+	/// Increases the index of the function declaration of the predicate.
+	void newFunctor();
+
+	/// @returns the program node this predicate represents.
+	ASTNode const* programNode() const;
+
+	/// @returns the ContractDefinition of the most derived contract
+	/// being analyzed.
+	ContractDefinition const* contextContract() const;
+
+	/// @returns the ContractDefinition that this predicate represents
+	/// or nullptr otherwise.
+	ContractDefinition const* programContract() const;
+
+	/// @returns the FunctionDefinition that this predicate represents
+	/// or nullptr otherwise.
+	FunctionDefinition const* programFunction() const;
+
+	/// @returns the FunctionCall that this predicate represents
+	/// or nullptr otherwise.
+	FunctionCall const* programFunctionCall() const;
+
+	/// @returns the VariableDeclaration that this predicate represents
+	/// or nullptr otherwise.
+	VariableDeclaration const* programVariable() const;
+
+	/// @returns the program state variables in the scope of this predicate.
+	std::optional<std::vector<VariableDeclaration const*>> stateVariables() const;
+
+	/// @returns true if this predicate represents a summary.
+	bool isSummary() const;
+
+	/// @returns true if this predicate represents a function summary.
+	bool isFunctionSummary() const;
+
+	/// @returns true if this predicate represents a function block.
+	bool isFunctionBlock() const;
+
+	/// @returns true if this predicate represents a function error block.
+	bool isFunctionErrorBlock() const;
+
+	/// @returns true if this predicate represents an internal function call.
+	bool isInternalCall() const;
+
+	/// @returns true if this predicate represents a trusted external function call.
+	bool isExternalCallTrusted() const;
+
+	/// @returns true if this predicate represents an untrusted external function call.
+	bool isExternalCallUntrusted() const;
+
+	/// @returns true if this predicate represents a constructor summary.
+	bool isConstructorSummary() const;
+
+	/// @returns true if this predicate represents an interface.
+	bool isInterface() const;
+
+	/// @returns true if this predicate represents a nondeterministic interface.
+	bool isNondetInterface() const;
+
+	PredicateType type() const { return m_type; }
+
+	/// @returns a formatted string representing a call to this predicate
+	/// with _args.
+	std::string formatSummaryCall(
+		std::vector<smtutil::Expression> const& _args,
+		langutil::CharStreamProvider const& _charStreamProvider,
+		bool _appendTxVars = false
+	) const;
+
+	/// @returns the values of the state variables from _args at the point
+	/// where this summary was reached.
+	std::vector<std::optional<std::string>> summaryStateValues(std::vector<smtutil::Expression> const& _args) const;
+
+	/// @returns the values of the function input variables from _args at the point
+	/// where this summary was reached.
+	std::vector<std::optional<std::string>> summaryPostInputValues(std::vector<smtutil::Expression> const& _args) const;
+
+	/// @returns the values of the function output variables from _args at the point
+	/// where this summary was reached.
+	std::vector<std::optional<std::string>> summaryPostOutputValues(std::vector<smtutil::Expression> const& _args) const;
+
+	/// @returns the values of the local variables used by this predicate.
+	std::pair<std::vector<std::optional<std::string>>, std::vector<VariableDeclaration const*>> localVariableValues(std::vector<smtutil::Expression> const& _args) const;
+
+	/// @returns a substitution map from the arguments of _predExpr
+	/// to a Solidity-like expression.
+	std::map<std::string, std::string> expressionSubstitution(smtutil::Expression const& _predExprs) const;
+
+private:
+	/// @returns the formatted version of the given SMT expressions. Those expressions must be SMT constants.
+	std::vector<std::optional<std::string>> formatExpressions(std::vector<smtutil::Expression> const& _exprs, std::vector<Type const*> const& _types) const;
+
+	/// @returns a string representation of the SMT expression based on a Solidity type.
+	std::optional<std::string> expressionToString(smtutil::Expression const& _expr, Type const* _type) const;
+
+	/// Recursively fills _array from _expr.
+	/// _expr should have the form `store(store(...(const_array(x_0), i_0, e_0), i_m, e_m), i_k, e_k)`.
+	/// @returns true if the construction worked,
+	/// and false if at least one element could not be built.
+	bool fillArray(smtutil::Expression const& _expr, std::vector<std::string>& _array, ArrayType const& _type) const;
+
+	std::map<std::string, std::optional<std::string>> readTxVars(smtutil::Expression const& _tx) const;
+
+	/// @returns index at which transaction values start in args list
+	size_t txValuesIndex() const { return m_bytesConcatFunctionInContext ? 5 : 4; }
+	/// @returns index at which function arguments start in args list
+	size_t firstArgIndex() const { return m_bytesConcatFunctionInContext ? 7 : 6; }
+	/// @returns index at which state variables values start in args list
+	size_t firstStateVarIndex() const { return m_bytesConcatFunctionInContext ? 8 : 7; }
+
+	/// The actual SMT expression.
+	smt::SymbolicFunctionVariable m_predicate;
+
+	/// The type of this predicate.
+	PredicateType m_type;
+
+	/// The ASTNode that this predicate represents.
+	/// nullptr if this predicate is not associated with a specific program AST node.
+	ASTNode const* m_node = nullptr;
+
+	/// The ContractDefinition that contains this predicate.
+	/// nullptr if this predicate is not associated with a specific contract.
+	/// This is unfortunately necessary because of virtual resolution for
+	/// function nodes.
+	ContractDefinition const* m_contractContext = nullptr;
+
+	/// Maps the name of the predicate to the actual Predicate.
+	/// Used in counterexample generation.
+	static std::map<std::string, Predicate> m_predicates;
+
+	/// The scope stack when the predicate was created.
+	/// Used to identify the subset of variables in scope.
+	std::vector<ScopeOpener const*> const m_scopeStack;
+
+	/// True iff there is a bytes concat function in contract scope
+	bool m_bytesConcatFunctionInContext;
+};
+
+struct PredicateCompare
+{
+	bool operator()(Predicate const* lhs, Predicate const* rhs) const
+	{
+		// We cannot use m_node->id() because different predicates may
+		// represent the same program node.
+		// We use the symbolic name since it is unique per predicate and
+		// the order does not really matter.
+		return lhs->functor().name < rhs->functor().name;
+	}
+};
+
+}
diff --git a/compiler/libsolidity/formal/PredicateInstance.cpp b/compiler/libsolidity/formal/PredicateInstance.cpp
new file mode 100644
index 00000000..b5b148cd
--- /dev/null
+++ b/compiler/libsolidity/formal/PredicateInstance.cpp
@@ -0,0 +1,243 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/PredicateInstance.h>
+
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+using namespace solidity::util;
+using namespace solidity::smtutil;
+
+namespace solidity::frontend::smt
+{
+smtutil::Expression interfacePre(Predicate const& _pred, ContractDefinition const& _contract, EncodingContext& _context)
+{
+	auto& state = _context.state();
+	std::vector<smtutil::Expression> stateExprs = getStateExpressionsForInterfacePre(state);
+	return _pred(stateExprs + initialStateVariables(_contract, _context));
+}
+
+smtutil::Expression interface(Predicate const& _pred, ContractDefinition const& _contract, EncodingContext& _context)
+{
+	auto const& state = _context.state();
+	std::vector<smtutil::Expression> stateExprs = getStateExpressionsForInterface(state);
+	return _pred(stateExprs + currentStateVariables(_contract, _context));
+}
+
+smtutil::Expression nondetInterface(
+	Predicate const& _pred,
+	ContractDefinition const& _contract,
+	EncodingContext& _context,
+	unsigned _preIdx,
+	unsigned _postIdx)
+{
+	auto const& state = _context.state();
+	std::vector<smtutil::Expression> stateExprs = getStateExpressionsForNondetInterface(state);
+	return _pred(
+		stateExprs +
+		std::vector<smtutil::Expression>{_context.state().state(_preIdx)} +
+		stateVariablesAtIndex(_preIdx, _contract, _context) +
+		std::vector<smtutil::Expression>{_context.state().state(_postIdx)} +
+		stateVariablesAtIndex(_postIdx, _contract, _context)
+	);
+}
+
+smtutil::Expression constructor(Predicate const& _pred, EncodingContext& _context)
+{
+	auto const& contract = dynamic_cast<ContractDefinition const&>(*_pred.programNode());
+	if (auto const* constructor = contract.constructor())
+		return _pred(currentFunctionVariablesForDefinition(*constructor, &contract, _context));
+
+	auto& state = _context.state();
+	std::vector<smtutil::Expression> stateExprs = getStateExpressionsForConstructor(state);
+	return _pred(stateExprs + initialStateVariables(contract, _context) + currentStateVariables(contract, _context));
+}
+
+smtutil::Expression constructorCall(Predicate const& _pred, EncodingContext& _context, bool _internal)
+{
+	auto const& contract = dynamic_cast<ContractDefinition const&>(*_pred.programNode());
+	if (auto const* constructor = contract.constructor())
+		return _pred(currentFunctionVariablesForCall(*constructor, &contract, _context, _internal));
+
+	auto& state = _context.state();
+	std::vector<smtutil::Expression> stateExprs = getStateExpressionsForCall(state, _internal);
+	state.newState();
+	stateExprs += std::vector<smtutil::Expression>{state.state()};
+	stateExprs += currentStateVariables(contract, _context);
+	stateExprs += newStateVariables(contract, _context);
+	return _pred(stateExprs);
+}
+
+smtutil::Expression function(
+	Predicate const& _pred,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+)
+{
+	auto const& function = dynamic_cast<FunctionDefinition const&>(*_pred.programNode());
+	return _pred(currentFunctionVariablesForDefinition(function, _contract, _context));
+}
+
+smtutil::Expression functionCall(
+	Predicate const& _pred,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+)
+{
+	auto const& function = dynamic_cast<FunctionDefinition const&>(*_pred.programNode());
+	return _pred(currentFunctionVariablesForCall(function, _contract, _context));
+}
+
+smtutil::Expression functionBlock(
+	Predicate const& _pred,
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+)
+{
+	return _pred(currentBlockVariables(_function, _contract, _context));
+}
+
+/// Helpers
+
+std::vector<smtutil::Expression> initialStateVariables(ContractDefinition const& _contract, EncodingContext& _context)
+{
+	return stateVariablesAtIndex(0, _contract, _context);
+}
+
+std::vector<smtutil::Expression> stateVariablesAtIndex(unsigned _index, ContractDefinition const& _contract, EncodingContext& _context)
+{
+	return applyMap(
+		SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract),
+		[&](auto _var) { return _context.variable(*_var)->valueAtIndex(_index); }
+	);
+}
+
+std::vector<smtutil::Expression> currentStateVariables(ContractDefinition const& _contract, EncodingContext& _context)
+{
+	return applyMap(
+		SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract),
+		[&](auto _var) { return _context.variable(*_var)->currentValue(); }
+	);
+}
+
+std::vector<smtutil::Expression> newStateVariables(ContractDefinition const& _contract, EncodingContext& _context)
+{
+	return applyMap(
+		SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract),
+		[&](auto _var) { return _context.variable(*_var)->increaseIndex(); }
+	);
+}
+
+std::vector<smtutil::Expression> currentFunctionVariablesForDefinition(
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+)
+{
+	auto& state = _context.state();
+	std::vector<smtutil::Expression> exprs = getStateExpressionsForDefinition(state);
+	exprs += _contract ? initialStateVariables(*_contract, _context) : std::vector<smtutil::Expression>{};
+	exprs += applyMap(_function.parameters(), [&](auto _var) { return _context.variable(*_var)->valueAtIndex(0); });
+	exprs += std::vector<smtutil::Expression>{state.state()};
+	exprs += _contract ? currentStateVariables(*_contract, _context) : std::vector<smtutil::Expression>{};
+	exprs += applyMap(_function.parameters(), [&](auto _var) { return _context.variable(*_var)->currentValue(); });
+	exprs += applyMap(_function.returnParameters(), [&](auto _var) { return _context.variable(*_var)->currentValue(); });
+	return exprs;
+}
+
+std::vector<smtutil::Expression> currentFunctionVariablesForCall(
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context,
+	bool _internal
+)
+{
+	auto& state = _context.state();
+	std::vector<smtutil::Expression> exprs = getStateExpressionsForCall(state, _internal);
+	exprs += _contract ? currentStateVariables(*_contract, _context) : std::vector<smtutil::Expression>{};
+	exprs += applyMap(_function.parameters(), [&](auto _var) { return _context.variable(*_var)->currentValue(); });
+
+	state.newState();
+
+	exprs += std::vector<smtutil::Expression>{state.state()};
+	exprs += _contract ? newStateVariables(*_contract, _context) : std::vector<smtutil::Expression>{};
+	exprs += applyMap(_function.parameters(), [&](auto _var) { return _context.variable(*_var)->increaseIndex(); });
+	exprs += applyMap(_function.returnParameters(), [&](auto _var) { return _context.variable(*_var)->currentValue(); });
+	return exprs;
+}
+
+std::vector<smtutil::Expression> currentBlockVariables(FunctionDefinition const& _function, ContractDefinition const* _contract, EncodingContext& _context)
+{
+	return currentFunctionVariablesForDefinition(_function, _contract, _context) +
+		applyMap(
+			SMTEncoder::localVariablesIncludingModifiers(_function, _contract),
+			[&](auto _var) { return _context.variable(*_var)->currentValue(); }
+		);
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForInterfacePre(SymbolicState const& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.thisAddress(0),
+			_state.abi(0), _state.bytesConcat(0), _state.crypto(0), _state.state(0)};
+return {_state.thisAddress(0), _state.abi(0),  _state.crypto(0), _state.state(0)};
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForInterface(SymbolicState const& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.thisAddress(0), _state.abi(0), _state.bytesConcat(0), _state.crypto(0), _state.state()};
+	return {_state.thisAddress(0), _state.abi(0), _state.crypto(0), _state.state()};
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForNondetInterface(SymbolicState const& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.errorFlag().currentValue(), _state.thisAddress(), _state.abi(), _state.bytesConcat(), _state.crypto()};
+	return {_state.errorFlag().currentValue(), _state.thisAddress(), _state.abi(), _state.crypto()};
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForConstructor(SymbolicState const& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.errorFlag().currentValue(), _state.thisAddress(0), _state.abi(0),
+			_state.bytesConcat(0), _state.crypto(0), _state.tx(0), _state.state(0), _state.state()};
+	return {_state.errorFlag().currentValue(), _state.thisAddress(0), _state.abi(0),
+		_state.crypto(0), _state.tx(0), _state.state(0), _state.state()};
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForCall(SymbolicState const& _state, bool _internal)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.errorFlag().currentValue(), _internal ? _state.thisAddress(0) : _state.thisAddress(),
+			_state.abi(0), _state.bytesConcat(0), _state.crypto(0), _internal ? _state.tx(0) : _state.tx(), _state.state()};
+	return {_state.errorFlag().currentValue(), _internal ? _state.thisAddress(0) : _state.thisAddress(),
+			_state.abi(0), _state.crypto(0), _internal ? _state.tx(0) : _state.tx(), _state.state()};
+}
+
+std::vector<smtutil::Expression> getStateExpressionsForDefinition(SymbolicState const& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.errorFlag().currentValue(), _state.thisAddress(0), _state.abi(0),
+			_state.bytesConcat(0), _state.crypto(0), _state.tx(0), _state.state(0)};
+	return {_state.errorFlag().currentValue(), _state.thisAddress(0), _state.abi(0),
+		_state.crypto(0), _state.tx(0), _state.state(0)};
+}
+}
diff --git a/compiler/libsolidity/formal/PredicateInstance.h b/compiler/libsolidity/formal/PredicateInstance.h
new file mode 100644
index 00000000..33c8a8a0
--- /dev/null
+++ b/compiler/libsolidity/formal/PredicateInstance.h
@@ -0,0 +1,104 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolidity/formal/Predicate.h>
+#include <libsolidity/formal/SymbolicState.h>
+
+namespace solidity::frontend::smt
+{
+
+class EncodingContext;
+
+/**
+ * This file represents the specification for building CHC predicate instances.
+ * The predicates follow the specification in PredicateSort.h.
+ * */
+
+smtutil::Expression interfacePre(Predicate const& _pred, ContractDefinition const& _contract, EncodingContext& _context);
+
+smtutil::Expression interface(Predicate const& _pred, ContractDefinition const& _contract, EncodingContext& _context);
+
+smtutil::Expression nondetInterface(Predicate const& _pred, ContractDefinition const& _contract, EncodingContext& _context, unsigned _preIdx, unsigned _postIdx);
+
+smtutil::Expression constructor(Predicate const& _pred, EncodingContext& _context);
+/// The encoding of the deployment procedure includes adding constraints
+/// for base constructors if inheritance is used.
+/// From the predicate point of view this is not different,
+/// but some of the arguments are different.
+/// @param _internal = true means that this constructor call is used in the
+/// deployment procedure, whereas false means it is used in the deployment
+/// of a contract.
+smtutil::Expression constructorCall(Predicate const& _pred, EncodingContext& _context, bool _internal = true);
+
+smtutil::Expression function(
+	Predicate const& _pred,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+);
+
+smtutil::Expression functionCall(
+	Predicate const& _pred,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+);
+
+smtutil::Expression functionBlock(
+	Predicate const& _pred,
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+);
+
+/// Helpers
+
+std::vector<smtutil::Expression> initialStateVariables(ContractDefinition const& _contract, EncodingContext& _context);
+
+std::vector<smtutil::Expression> stateVariablesAtIndex(unsigned _index, ContractDefinition const& _contract, EncodingContext& _context);
+
+std::vector<smtutil::Expression> currentStateVariables(ContractDefinition const& _contract, EncodingContext& _context);
+
+std::vector<smtutil::Expression> newStateVariables(ContractDefinition const& _contract, EncodingContext& _context);
+
+std::vector<smtutil::Expression> currentFunctionVariablesForDefinition(
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+);
+
+std::vector<smtutil::Expression> currentFunctionVariablesForCall(
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context,
+	bool _internal = true
+);
+
+std::vector<smtutil::Expression> currentBlockVariables(
+	FunctionDefinition const& _function,
+	ContractDefinition const* _contract,
+	EncodingContext& _context
+);
+
+std::vector<smtutil::Expression> getStateExpressionsForInterfacePre(SymbolicState const& _state);
+std::vector<smtutil::Expression> getStateExpressionsForInterface(SymbolicState  const& _state);
+std::vector<smtutil::Expression> getStateExpressionsForNondetInterface(SymbolicState  const& _state);
+std::vector<smtutil::Expression> getStateExpressionsForConstructor(SymbolicState  const& _state);
+std::vector<smtutil::Expression> getStateExpressionsForCall(SymbolicState  const& _state, bool _internal);
+std::vector<smtutil::Expression> getStateExpressionsForDefinition(SymbolicState  const& _state);
+}
diff --git a/compiler/libsolidity/formal/PredicateSort.cpp b/compiler/libsolidity/formal/PredicateSort.cpp
new file mode 100644
index 00000000..0f9eae82
--- /dev/null
+++ b/compiler/libsolidity/formal/PredicateSort.cpp
@@ -0,0 +1,128 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/PredicateSort.h>
+
+#include <libsolidity/formal/SMTEncoder.h>
+#include <libsolidity/formal/SymbolicTypes.h>
+
+using namespace solidity::util;
+using namespace solidity::smtutil;
+
+namespace solidity::frontend::smt
+{
+
+SortPointer interfaceSort(ContractDefinition const& _contract, SymbolicState& _state)
+{
+	return std::make_shared<FunctionSort>(
+		std::vector<SortPointer>{_state.thisAddressSort()} +
+			getBuiltInFunctionsSorts(_state) +
+			std::vector<SortPointer>{_state.stateSort()} +
+			stateSorts(_contract),
+		SortProvider::boolSort
+	);
+}
+
+SortPointer nondetInterfaceSort(ContractDefinition const& _contract, SymbolicState& _state)
+{
+	auto varSorts = stateSorts(_contract);
+	std::vector<SortPointer> stateSort{_state.stateSort()};
+	return std::make_shared<FunctionSort>(
+		std::vector<SortPointer>{_state.errorFlagSort(), _state.thisAddressSort()} +
+			getBuiltInFunctionsSorts(_state) +
+			stateSort +
+			varSorts +
+			stateSort +
+			varSorts,
+		SortProvider::boolSort
+	);
+}
+
+SortPointer constructorSort(ContractDefinition const& _contract, SymbolicState& _state)
+{
+	if (auto const* constructor = _contract.constructor())
+		return functionSort(*constructor, &_contract, _state);
+
+	auto varSorts = stateSorts(_contract);
+	std::vector<SortPointer> stateSort{_state.stateSort()};
+	return std::make_shared<FunctionSort>(
+		std::vector<SortPointer>{_state.errorFlagSort(), _state.thisAddressSort()} +
+			getBuiltInFunctionsSorts(_state) +
+			std::vector<SortPointer>{_state.txSort(), _state.stateSort(), _state.stateSort()} +
+			varSorts + varSorts,
+		SortProvider::boolSort
+	);
+}
+
+SortPointer functionSort(FunctionDefinition const& _function, ContractDefinition const* _contract, SymbolicState& _state)
+{
+	auto smtSort = [](auto _var) { return smt::smtSortAbstractFunction(*_var->type()); };
+	auto varSorts = _contract ? stateSorts(*_contract) : std::vector<SortPointer>{};
+	auto inputSorts = applyMap(_function.parameters(), smtSort);
+	auto outputSorts = applyMap(_function.returnParameters(), smtSort);
+	return std::make_shared<FunctionSort>(
+		std::vector<SortPointer>{_state.errorFlagSort(), _state.thisAddressSort()} +
+			getBuiltInFunctionsSorts(_state) +
+			std::vector<SortPointer>{_state.txSort(), _state.stateSort()} +
+			varSorts +
+			inputSorts +
+			std::vector<SortPointer>{_state.stateSort()} +
+			varSorts +
+			inputSorts +
+			outputSorts,
+		SortProvider::boolSort
+	);
+}
+
+SortPointer functionBodySort(FunctionDefinition const& _function, ContractDefinition const* _contract, SymbolicState& _state)
+{
+	auto fSort = std::dynamic_pointer_cast<FunctionSort>(functionSort(_function, _contract, _state));
+	solAssert(fSort, "");
+
+	auto smtSort = [](auto _var) { return smt::smtSortAbstractFunction(*_var->type()); };
+	return std::make_shared<FunctionSort>(
+		fSort->domain + applyMap(SMTEncoder::localVariablesIncludingModifiers(_function, _contract), smtSort),
+		SortProvider::boolSort
+	);
+}
+
+SortPointer arity0FunctionSort()
+{
+	return std::make_shared<FunctionSort>(
+		std::vector<SortPointer>(),
+		SortProvider::boolSort
+	);
+}
+
+/// Helpers
+
+std::vector<SortPointer> stateSorts(ContractDefinition const& _contract)
+{
+	return applyMap(
+		SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract),
+		[](auto _var) { return smt::smtSortAbstractFunction(*_var->type()); }
+	);
+}
+
+std::vector<SortPointer> getBuiltInFunctionsSorts(SymbolicState& _state)
+{
+	if (_state.hasBytesConcatFunction())
+		return {_state.abiSort(), _state.bytesConcatSort(), _state.cryptoSort()};
+	return {_state.abiSort(), _state.cryptoSort()};
+}
+}
diff --git a/compiler/libsolidity/formal/PredicateSort.h b/compiler/libsolidity/formal/PredicateSort.h
new file mode 100644
index 00000000..c5f63f2a
--- /dev/null
+++ b/compiler/libsolidity/formal/PredicateSort.h
@@ -0,0 +1,81 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolidity/formal/Predicate.h>
+
+#include <libsolidity/formal/SymbolicState.h>
+
+#include <libsmtutil/Sorts.h>
+
+namespace solidity::frontend::smt
+{
+
+/**
+ * This file represents the specification for CHC predicate sorts.
+ * Types of predicates:
+ *
+ * 1. Interface
+ * The idle state of a contract. Signature:
+ * interface(this, abiFunctions, cryptoFunctions, blockchainState, stateVariables).
+ *
+ * 2. Nondet interface
+ * The nondeterminism behavior of a contract. Signature:
+ * nondet_interface(error, this, abiFunctions, cryptoFunctions, blockchainState, stateVariables, blockchainState', stateVariables').
+ *
+ * 3. Constructor entry/summary
+ * The summary of a contract's deployment procedure.
+ * Signature:
+ * If the contract has a constructor function, this is the same as the summary of that function. Otherwise:
+ * constructor_summary(error, this, abiFunctions, cryptoFunctions, txData, blockchainState, blockchainState', stateVariables, stateVariables').
+ *
+ * 4. Function entry/summary
+ * The entry point of a function definition. Signature:
+ * function_entry(error, this, abiFunctions, cryptoFunctions, txData, blockchainState, stateVariables, inputVariables, blockchainState', stateVariables', inputVariables', outputVariables').
+ *
+ * 5. Function body
+ * Use for any predicate within a function. Signature:
+ * function_body(error, this, abiFunctions, cryptoFunctions, txData, blockchainState, stateVariables, inputVariables, blockchainState', stateVariables', inputVariables', outputVariables', localVariables).
+ */
+
+/// @returns the interface predicate sort for _contract.
+smtutil::SortPointer interfaceSort(ContractDefinition const& _contract, SymbolicState& _state);
+
+/// @returns the nondeterminisc interface predicate sort for _contract.
+smtutil::SortPointer nondetInterfaceSort(ContractDefinition const& _contract, SymbolicState& _state);
+
+/// @returns the constructor entry/summary predicate sort for _contract.
+smtutil::SortPointer constructorSort(ContractDefinition const& _contract, SymbolicState& _state);
+
+/// @returns the function entry/summary predicate sort for _function contained in _contract.
+smtutil::SortPointer functionSort(FunctionDefinition const& _function, ContractDefinition const* _contract, SymbolicState& _state);
+
+/// @returns the function body predicate sort for _function contained in _contract.
+smtutil::SortPointer functionBodySort(FunctionDefinition const& _function, ContractDefinition const* _contract, SymbolicState& _state);
+
+/// @returns the sort of a predicate without parameters.
+smtutil::SortPointer arity0FunctionSort();
+
+/// Helpers
+
+std::vector<smtutil::SortPointer> stateSorts(ContractDefinition const& _contract);
+
+std::vector<smtutil::SortPointer> getBuiltInFunctionsSorts(SymbolicState& _state);
+
+}
diff --git a/compiler/libsolidity/formal/SMTEncoder.cpp b/compiler/libsolidity/formal/SMTEncoder.cpp
new file mode 100644
index 00000000..61aad0e8
--- /dev/null
+++ b/compiler/libsolidity/formal/SMTEncoder.cpp
@@ -0,0 +1,3281 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <libsolidity/ast/TypeProvider.h>
+#include <libsolidity/formal/SymbolicState.h>
+#include <libsolidity/formal/SymbolicTypes.h>
+
+#include <libsolidity/analysis/ConstantEvaluator.h>
+
+#include <libyul/AST.h>
+#include <libyul/optimiser/Semantics.h>
+
+#include <libsmtutil/SMTPortfolio.h>
+#include <libsmtutil/Helpers.h>
+
+#include <liblangutil/CharStreamProvider.h>
+
+#include <libsolutil/Algorithms.h>
+#include <libsolutil/FunctionSelector.h>
+
+#include <range/v3/view.hpp>
+
+#include <limits>
+#include <deque>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace std::string_literals;
+
+SMTEncoder::SMTEncoder(
+	smt::EncodingContext& _context,
+	ModelCheckerSettings _settings,
+	UniqueErrorReporter& _errorReporter,
+	UniqueErrorReporter& _unsupportedErrorReporter,
+	langutil::CharStreamProvider const& _charStreamProvider
+):
+	m_errorReporter(_errorReporter),
+	m_unsupportedErrors(_unsupportedErrorReporter),
+	m_context(_context),
+	m_settings(std::move(_settings)),
+	m_charStreamProvider(_charStreamProvider)
+{
+}
+
+void SMTEncoder::resetSourceAnalysis()
+{
+	m_freeFunctions.clear();
+}
+
+bool SMTEncoder::visit(ContractDefinition const& _contract)
+{
+	solAssert(m_currentContract, "");
+
+	for (auto const& node: _contract.subNodes())
+		if (
+			!std::dynamic_pointer_cast<FunctionDefinition>(node) &&
+			!std::dynamic_pointer_cast<VariableDeclaration>(node)
+		)
+			node->accept(*this);
+
+	for (auto const& base: _contract.annotation().linearizedBaseContracts)
+	{
+		// Look for all the constructor invocations bottom up.
+		if (auto const& constructor =  base->constructor())
+			for (auto const& invocation: constructor->modifiers())
+			{
+				auto refDecl = invocation->name().annotation().referencedDeclaration;
+				if (auto const& baseContract = dynamic_cast<ContractDefinition const*>(refDecl))
+				{
+					solAssert(!m_baseConstructorCalls.count(baseContract), "");
+					m_baseConstructorCalls[baseContract] = invocation.get();
+				}
+			}
+	}
+	// Functions are visited first since they might be used
+	// for state variable initialization which is part of
+	// the constructor.
+	// Constructors are visited as part of the constructor
+	// hierarchy inlining.
+	for (auto const* function: contractFunctionsWithoutVirtual(_contract) + allFreeFunctions())
+		if (!function->isConstructor())
+			function->accept(*this);
+
+	// Constructors need to be handled by the engines separately.
+
+	return false;
+}
+
+void SMTEncoder::endVisit(ContractDefinition const& _contract)
+{
+	m_context.resetAllVariables();
+
+	m_baseConstructorCalls.clear();
+
+	solAssert(m_currentContract == &_contract, "");
+	m_currentContract = nullptr;
+
+	if (m_callStack.empty())
+		m_context.popSolver();
+}
+
+bool SMTEncoder::visit(ImportDirective const&)
+{
+	// do not visit because the identifier therein will confuse us.
+	return false;
+}
+
+void SMTEncoder::endVisit(VariableDeclaration const& _varDecl)
+{
+	// State variables are handled by the constructor.
+	if (_varDecl.isLocalVariable() &&_varDecl.value())
+		assignment(_varDecl, *_varDecl.value());
+}
+
+bool SMTEncoder::visit(ModifierDefinition const&)
+{
+	return false;
+}
+
+bool SMTEncoder::visit(FunctionDefinition const& _function)
+{
+	solAssert(m_currentContract, "");
+
+	m_modifierDepthStack.push_back(-1);
+
+	initializeLocalVariables(_function);
+
+	_function.parameterList().accept(*this);
+	if (_function.returnParameterList())
+		_function.returnParameterList()->accept(*this);
+
+	visitFunctionOrModifier();
+
+	return false;
+}
+
+void SMTEncoder::visitFunctionOrModifier()
+{
+	solAssert(!m_callStack.empty(), "");
+	solAssert(!m_modifierDepthStack.empty(), "");
+
+	++m_modifierDepthStack.back();
+	FunctionDefinition const& function = dynamic_cast<FunctionDefinition const&>(*m_callStack.back().first);
+
+	if (m_modifierDepthStack.back() == static_cast<int>(function.modifiers().size()))
+	{
+		if (function.isImplemented())
+		{
+			pushInlineFrame(function);
+			function.body().accept(*this);
+			popInlineFrame(function);
+		}
+	}
+	else
+	{
+		solAssert(m_modifierDepthStack.back() < static_cast<int>(function.modifiers().size()), "");
+		ASTPointer<ModifierInvocation> const& modifierInvocation =
+			function.modifiers()[static_cast<size_t>(m_modifierDepthStack.back())];
+		solAssert(modifierInvocation, "");
+		auto refDecl = modifierInvocation->name().annotation().referencedDeclaration;
+		if (dynamic_cast<ContractDefinition const*>(refDecl))
+			visitFunctionOrModifier();
+		else if (auto modifier = resolveModifierInvocation(*modifierInvocation, m_currentContract))
+		{
+			m_scopes.push_back(modifier);
+			inlineModifierInvocation(modifierInvocation.get(), modifier);
+			solAssert(m_scopes.back() == modifier, "");
+			m_scopes.pop_back();
+		}
+		else
+			solAssert(false, "");
+	}
+
+	--m_modifierDepthStack.back();
+}
+
+void SMTEncoder::inlineModifierInvocation(ModifierInvocation const* _invocation, CallableDeclaration const* _definition)
+{
+	solAssert(_invocation, "");
+	_invocation->accept(*this);
+
+	std::vector<smtutil::Expression> args;
+	if (auto const* arguments = _invocation->arguments())
+	{
+		auto const& modifierParams = _definition->parameters();
+		solAssert(modifierParams.size() == arguments->size(), "");
+		for (unsigned i = 0; i < arguments->size(); ++i)
+			args.push_back(expr(*arguments->at(i), modifierParams.at(i)->type()));
+	}
+
+	initializeFunctionCallParameters(*_definition, args);
+
+	pushCallStack({_definition, _invocation});
+	pushInlineFrame(*_definition);
+	if (auto modifier = dynamic_cast<ModifierDefinition const*>(_definition))
+	{
+		if (modifier->isImplemented())
+			modifier->body().accept(*this);
+		popCallStack();
+	}
+	else if (auto function = dynamic_cast<FunctionDefinition const*>(_definition))
+	{
+		if (function->isImplemented())
+			function->accept(*this);
+		// Functions are popped from the callstack in endVisit(FunctionDefinition)
+	}
+	popInlineFrame(*_definition);
+}
+
+void SMTEncoder::inlineConstructorHierarchy(ContractDefinition const& _contract)
+{
+	auto const& hierarchy = m_currentContract->annotation().linearizedBaseContracts;
+	auto it = find(begin(hierarchy), end(hierarchy), &_contract);
+	solAssert(it != end(hierarchy), "");
+
+	auto nextBase = it + 1;
+	// Initialize the base contracts here as long as their constructors are implicit,
+	// stop when the first explicit constructor is found.
+	while (nextBase != end(hierarchy))
+	{
+		if (auto baseConstructor = (*nextBase)->constructor())
+		{
+			createLocalVariables(*baseConstructor);
+			// If any subcontract explicitly called baseConstructor, use those arguments.
+			if (m_baseConstructorCalls.count(*nextBase))
+				inlineModifierInvocation(m_baseConstructorCalls.at(*nextBase), baseConstructor);
+			else if (baseConstructor->isImplemented())
+			{
+				// The first constructor found is handled like a function
+				// and its pushed into the callstack there.
+				// This if avoids duplication in the callstack.
+				if (!m_callStack.empty())
+					pushCallStack({baseConstructor, nullptr});
+				baseConstructor->accept(*this);
+				// popped by endVisit(FunctionDefinition)
+			}
+			break;
+		}
+		else
+		{
+			initializeStateVariables(**nextBase);
+			++nextBase;
+		}
+	}
+
+	initializeStateVariables(_contract);
+}
+
+bool SMTEncoder::visit(PlaceholderStatement const&)
+{
+	solAssert(!m_callStack.empty(), "");
+	auto lastCall = popCallStack();
+	visitFunctionOrModifier();
+	pushCallStack(lastCall);
+	return true;
+}
+
+void SMTEncoder::endVisit(FunctionDefinition const&)
+{
+	solAssert(m_currentContract, "");
+
+	popCallStack();
+	solAssert(m_modifierDepthStack.back() == -1, "");
+	m_modifierDepthStack.pop_back();
+	if (m_callStack.empty())
+		m_context.popSolver();
+}
+
+bool SMTEncoder::visit(Block const& _block)
+{
+	if (_block.unchecked())
+	{
+		solAssert(m_checked, "");
+		m_checked = false;
+	}
+	return true;
+}
+
+void SMTEncoder::endVisit(Block const& _block)
+{
+	if (_block.unchecked())
+	{
+		solAssert(!m_checked, "");
+		m_checked = true;
+	}
+}
+
+bool SMTEncoder::visit(InlineAssembly const& _inlineAsm)
+{
+	/// This is very similar to `yul::Assignments`, except I need to collect `Identifier`s and not just names as `YulString`s.
+	struct AssignedExternalsCollector: public yul::ASTWalker
+	{
+		AssignedExternalsCollector(InlineAssembly const& _inlineAsm): externalReferences(_inlineAsm.annotation().externalReferences)
+		{
+			this->operator()(_inlineAsm.operations());
+		}
+
+		std::map<yul::Identifier const*, InlineAssemblyAnnotation::ExternalIdentifierInfo> const& externalReferences;
+		std::set<VariableDeclaration const*> assignedVars;
+
+		using yul::ASTWalker::operator();
+		void operator()(yul::Assignment const& _assignment)
+		{
+			auto const& vars = _assignment.variableNames;
+			for (auto const& identifier: vars)
+				if (auto externalInfo = util::valueOrNullptr(externalReferences, &identifier))
+					if (auto varDecl = dynamic_cast<VariableDeclaration const*>(externalInfo->declaration))
+						assignedVars.insert(varDecl);
+		}
+	};
+
+	yul::SideEffectsCollector sideEffectsCollector(_inlineAsm.dialect(), _inlineAsm.operations());
+	if (sideEffectsCollector.invalidatesMemory())
+		resetMemoryVariables();
+	if (sideEffectsCollector.invalidatesStorage())
+		resetStorageVariables();
+
+	auto assignedVars = AssignedExternalsCollector(_inlineAsm).assignedVars;
+	for (auto const* var: assignedVars)
+	{
+		solAssert(var, "");
+		solAssert(var->isLocalVariable(), "Non-local variable assigned in inlined assembly");
+		m_context.resetVariable(*var);
+	}
+
+	m_unsupportedErrors.warning(
+		7737_error,
+		_inlineAsm.location(),
+		"Inline assembly may cause SMTChecker to produce spurious warnings (false positives)."
+	);
+	return false;
+}
+
+void SMTEncoder::pushInlineFrame(CallableDeclaration const&)
+{
+	pushPathCondition(currentPathConditions());
+}
+
+void SMTEncoder::popInlineFrame(CallableDeclaration const&)
+{
+	popPathCondition();
+}
+
+void SMTEncoder::endVisit(VariableDeclarationStatement const& _varDecl)
+{
+	if (auto init = _varDecl.initialValue())
+		expressionToTupleAssignment(_varDecl.declarations(), *init);
+}
+
+bool SMTEncoder::visit(Assignment const& _assignment)
+{
+	// RHS must be visited before LHS; as opposed to what Assignment::accept does
+	_assignment.rightHandSide().accept(*this);
+	_assignment.leftHandSide().accept(*this);
+	return false;
+}
+
+void SMTEncoder::endVisit(Assignment const& _assignment)
+{
+	createExpr(_assignment);
+
+	Token op = _assignment.assignmentOperator();
+	solAssert(TokenTraits::isAssignmentOp(op), "");
+
+	if (!isSupportedType(*_assignment.annotation().type))
+	{
+		// Give it a new index anyway to keep the SSA scheme sound.
+
+		Expression const* base = &_assignment.leftHandSide();
+		if (auto const* indexAccess = dynamic_cast<IndexAccess const*>(base))
+			base = leftmostBase(*indexAccess);
+
+		if (auto varDecl = identifierToVariable(*base))
+			m_context.newValue(*varDecl);
+	}
+	else
+	{
+		if (dynamic_cast<TupleType const*>(_assignment.rightHandSide().annotation().type))
+			tupleAssignment(_assignment.leftHandSide(), _assignment.rightHandSide());
+		else
+		{
+			auto const& type = _assignment.annotation().type;
+			auto rightHandSide = op == Token::Assign ?
+				expr(_assignment.rightHandSide(), type) :
+				compoundAssignment(_assignment);
+			defineExpr(_assignment, rightHandSide);
+			assignment(
+				_assignment.leftHandSide(),
+				expr(_assignment, type),
+				type
+			);
+		}
+	}
+}
+
+void SMTEncoder::endVisit(TupleExpression const& _tuple)
+{
+	if (_tuple.annotation().type->category() == Type::Category::Function)
+		return;
+
+	if (_tuple.annotation().type->category() == Type::Category::TypeType)
+		return;
+
+	createExpr(_tuple);
+
+	if (_tuple.isInlineArray())
+	{
+		// Add constraints for the length and values as it is known.
+		auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(_tuple));
+		solAssert(symbArray, "");
+
+		addArrayLiteralAssertions(*symbArray, applyMap(_tuple.components(), [&](auto const& c) { return expr(*c); }));
+	}
+	else
+	{
+		auto values = applyMap(_tuple.components(), [this](auto const& component) -> std::optional<smtutil::Expression> {
+			if (component)
+			{
+				if (!m_context.knownExpression(*component))
+						createExpr(*component);
+				return expr(*component);
+			}
+			return {};
+		});
+		defineExpr(_tuple, values);
+	}
+}
+
+void SMTEncoder::endVisit(UnaryOperation const& _op)
+{
+	/// We need to shortcut here due to potentially unknown
+	/// rational number sizes.
+	if (_op.annotation().type->category() == Type::Category::RationalNumber)
+		return;
+
+	if (TokenTraits::isBitOp(_op.getOperator()) && !*_op.annotation().userDefinedFunction)
+		return bitwiseNotOperation(_op);
+
+	createExpr(_op);
+
+	// User-defined operators are essentially function calls.
+	if (*_op.annotation().userDefinedFunction)
+		return;
+
+	auto const* subExpr = innermostTuple(_op.subExpression());
+	auto type = _op.annotation().type;
+	switch (_op.getOperator())
+	{
+	case Token::Not: // !
+	{
+		solAssert(smt::isBool(*type), "");
+		defineExpr(_op, !expr(*subExpr));
+		break;
+	}
+	case Token::Inc: // ++ (pre- or postfix)
+	case Token::Dec: // -- (pre- or postfix)
+	{
+		solAssert(smt::isInteger(*type) || smt::isFixedPoint(*type), "");
+		solAssert(subExpr->annotation().willBeWrittenTo, "");
+		auto innerValue = expr(*subExpr);
+		auto newValue = arithmeticOperation(
+			_op.getOperator() == Token::Inc ? Token::Add : Token::Sub,
+			innerValue,
+			smtutil::Expression(size_t(1)),
+			_op.annotation().type,
+			_op
+		).first;
+		defineExpr(_op, _op.isPrefixOperation() ? newValue : innerValue);
+		assignment(*subExpr, newValue);
+		break;
+	}
+	case Token::Sub: // -
+	{
+		defineExpr(_op, 0 - expr(*subExpr));
+		break;
+	}
+	case Token::Delete:
+	{
+		if (auto decl = identifierToVariable(*subExpr))
+		{
+			m_context.newValue(*decl);
+			m_context.setZeroValue(*decl);
+		}
+		else
+		{
+			solAssert(m_context.knownExpression(*subExpr), "");
+			auto const& symbVar = m_context.expression(*subExpr);
+			symbVar->increaseIndex();
+			m_context.setZeroValue(*symbVar);
+			if (
+				dynamic_cast<IndexAccess const*>(subExpr) ||
+				dynamic_cast<MemberAccess const*>(subExpr)
+			)
+				indexOrMemberAssignment(*subExpr, symbVar->currentValue());
+			// Empty push added a zero value anyway, so no need to delete extra.
+			else if (!isEmptyPush(*subExpr))
+				solAssert(false, "");
+		}
+		break;
+	}
+	default:
+		solAssert(false, "");
+	}
+}
+
+bool SMTEncoder::visit(UnaryOperation const& _op)
+{
+	return !shortcutRationalNumber(_op);
+}
+
+bool SMTEncoder::visit(BinaryOperation const& _op)
+{
+	if (shortcutRationalNumber(_op))
+		return false;
+	if (TokenTraits::isBooleanOp(_op.getOperator()) && !*_op.annotation().userDefinedFunction)
+	{
+		booleanOperation(_op);
+		return false;
+	}
+	return true;
+}
+
+void SMTEncoder::endVisit(BinaryOperation const& _op)
+{
+	/// If _op is const evaluated the RationalNumber shortcut was taken.
+	if (isConstant(_op))
+		return;
+	if (TokenTraits::isBooleanOp(_op.getOperator()) && !*_op.annotation().userDefinedFunction)
+		return;
+
+	createExpr(_op);
+
+	// User-defined operators are essentially function calls.
+	if (*_op.annotation().userDefinedFunction)
+		return;
+
+	if (TokenTraits::isArithmeticOp(_op.getOperator()))
+		arithmeticOperation(_op);
+	else if (TokenTraits::isCompareOp(_op.getOperator()))
+		compareOperation(_op);
+	else if (TokenTraits::isBitOp(_op.getOperator()) || TokenTraits::isShiftOp(_op.getOperator()))
+		bitwiseOperation(_op);
+	else
+		solAssert(false, "");
+}
+
+bool SMTEncoder::visit(Conditional const& _op)
+{
+	_op.condition().accept(*this);
+
+	auto indicesEndTrue = visitBranch(&_op.trueExpression(), expr(_op.condition())).first;
+
+	auto indicesEndFalse = visitBranch(&_op.falseExpression(), !expr(_op.condition())).first;
+
+	mergeVariables(expr(_op.condition()), indicesEndTrue, indicesEndFalse);
+
+	defineExpr(_op, smtutil::Expression::ite(
+		expr(_op.condition()),
+		expr(_op.trueExpression(), _op.annotation().type),
+		expr(_op.falseExpression(), _op.annotation().type)
+	));
+
+	return false;
+}
+
+bool SMTEncoder::visit(FunctionCall const& _funCall)
+{
+	auto functionCallKind = *_funCall.annotation().kind;
+	if (functionCallKind != FunctionCallKind::FunctionCall)
+		return true;
+
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	// We do not want to visit the TypeTypes in the second argument of `abi.decode`.
+	// Those types are checked/used in SymbolicState::buildABIFunctions.
+	if (funType.kind() == FunctionType::Kind::ABIDecode)
+	{
+		if (auto arg = _funCall.arguments().front())
+			arg->accept(*this);
+		return false;
+	}
+
+	// We do not really need to visit the expression in a wrap/unwrap no-op call,
+	// so we just ignore the function call expression to avoid "unsupported" warnings.
+	else if (
+		funType.kind() == FunctionType::Kind::Wrap ||
+		funType.kind() == FunctionType::Kind::Unwrap
+	)
+	{
+		if (auto arg = _funCall.arguments().front())
+			arg->accept(*this);
+		return false;
+	}
+	return true;
+}
+
+void SMTEncoder::endVisit(FunctionCall const& _funCall)
+{
+	auto functionCallKind = *_funCall.annotation().kind;
+
+	createExpr(_funCall);
+	if (functionCallKind == FunctionCallKind::StructConstructorCall)
+	{
+		visitStructConstructorCall(_funCall);
+		return;
+	}
+
+	if (functionCallKind == FunctionCallKind::TypeConversion)
+	{
+		visitTypeConversion(_funCall);
+		return;
+	}
+
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+
+	std::vector<ASTPointer<Expression const>> const args = _funCall.arguments();
+	switch (funType.kind())
+	{
+	case FunctionType::Kind::Assert:
+		visitAssert(_funCall);
+		break;
+	case FunctionType::Kind::Require:
+		visitRequire(_funCall);
+		break;
+	case FunctionType::Kind::Revert:
+		// Revert is a special case of require and equals to `require(false)`
+		addPathImpliedExpression(smtutil::Expression(false));
+		break;
+	case FunctionType::Kind::GasLeft:
+		visitGasLeft(_funCall);
+		break;
+	case FunctionType::Kind::External:
+		if (publicGetter(_funCall.expression()))
+			visitPublicGetter(_funCall);
+		break;
+	case FunctionType::Kind::BytesConcat:
+		visitBytesConcat(_funCall);
+		break;
+	case FunctionType::Kind::ABIDecode:
+	case FunctionType::Kind::ABIEncode:
+	case FunctionType::Kind::ABIEncodePacked:
+	case FunctionType::Kind::ABIEncodeWithSelector:
+	case FunctionType::Kind::ABIEncodeCall:
+	case FunctionType::Kind::ABIEncodeWithSignature:
+		visitABIFunction(_funCall);
+		break;
+	case FunctionType::Kind::Internal:
+	case FunctionType::Kind::BareStaticCall:
+	case FunctionType::Kind::BareCall:
+		break;
+	case FunctionType::Kind::KECCAK256:
+	case FunctionType::Kind::ECRecover:
+	case FunctionType::Kind::SHA256:
+	case FunctionType::Kind::RIPEMD160:
+		visitCryptoFunction(_funCall);
+		break;
+	case FunctionType::Kind::BlockHash:
+		defineExpr(_funCall, state().blockhash(expr(*_funCall.arguments().at(0))));
+		break;
+	case FunctionType::Kind::AddMod:
+	case FunctionType::Kind::MulMod:
+		visitAddMulMod(_funCall);
+		break;
+	case FunctionType::Kind::Unwrap:
+	case FunctionType::Kind::Wrap:
+		visitWrapUnwrap(_funCall);
+		break;
+	case FunctionType::Kind::Send:
+	case FunctionType::Kind::Transfer:
+	{
+		auto const& memberAccess = dynamic_cast<MemberAccess const&>(_funCall.expression());
+		auto const& address = memberAccess.expression();
+		auto const& value = args.front();
+		solAssert(value, "");
+
+		smtutil::Expression thisBalance = state().balance();
+		setSymbolicUnknownValue(thisBalance, TypeProvider::uint256(), m_context);
+
+		state().transfer(state().thisAddress(), expr(address), expr(*value));
+		break;
+	}
+	case FunctionType::Kind::ArrayPush:
+		arrayPush(_funCall);
+		break;
+	case FunctionType::Kind::ArrayPop:
+		arrayPop(_funCall);
+		break;
+	case FunctionType::Kind::Event:
+	case FunctionType::Kind::Error:
+		// This can be safely ignored.
+		break;
+	case FunctionType::Kind::ObjectCreation:
+		visitObjectCreation(_funCall);
+		return;
+	case FunctionType::Kind::Creation:
+		if (!m_settings.engine.chc || !m_settings.externalCalls.isTrusted())
+			m_unsupportedErrors.warning(
+				8729_error,
+				_funCall.location(),
+				"Contract deployment is only supported in the trusted mode for external calls"
+				" with the CHC engine."
+			);
+		break;
+	case FunctionType::Kind::DelegateCall:
+	case FunctionType::Kind::BareCallCode:
+	case FunctionType::Kind::BareDelegateCall:
+	default:
+		m_unsupportedErrors.warning(
+			4588_error,
+			_funCall.location(),
+			"Assertion checker does not yet implement this type of function call."
+		);
+	}
+}
+
+bool SMTEncoder::visit(ModifierInvocation const& _node)
+{
+	if (auto const* args = _node.arguments())
+		for (auto const& arg: *args)
+			if (arg)
+				arg->accept(*this);
+	return false;
+}
+
+void SMTEncoder::initContract(ContractDefinition const& _contract)
+{
+	solAssert(m_currentContract == nullptr, "");
+	m_currentContract = &_contract;
+
+	m_context.reset();
+	m_context.pushSolver();
+	createStateVariables(_contract);
+	clearIndices(m_currentContract, nullptr);
+	m_variableUsage.setCurrentContract(_contract);
+	m_checked = true;
+}
+
+void SMTEncoder::initFunction(FunctionDefinition const& _function)
+{
+	solAssert(m_callStack.empty(), "");
+	solAssert(m_currentContract, "");
+	m_context.pushSolver();
+	m_pathConditions.clear();
+	pushCallStack({&_function, nullptr});
+	m_uninterpretedTerms.clear();
+	createStateVariables(*m_currentContract);
+	createLocalVariables(_function);
+	m_arrayAssignmentHappened = false;
+	clearIndices(m_currentContract, &_function);
+	m_checked = true;
+}
+
+void SMTEncoder::visitAssert(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() == 1, "");
+	solAssert(args.front()->annotation().type->category() == Type::Category::Bool, "");
+}
+
+void SMTEncoder::visitRequire(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() >= 1, "");
+	solAssert(args.front()->annotation().type->category() == Type::Category::Bool, "");
+	addPathImpliedExpression(expr(*args.front()));
+}
+
+void SMTEncoder::visitBytesConcat(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.sortedArguments();
+
+	// bytes.concat call with no arguments returns an empty array
+	if (args.size() == 0)
+	{
+		defineExpr(_funCall, smt::zeroValue(TypeProvider::bytesMemory()));
+		return;
+	}
+
+	// bytes.concat with single argument of type bytes memory
+	if (args.size() == 1 && args.front()->annotation().type->category() == frontend::Type::Category::Array)
+	{
+		defineExpr(_funCall, expr(*args.front(), TypeProvider::bytesMemory()));
+		return;
+	}
+
+	auto const& [name, inTypes, outType] = state().bytesConcatFunctionTypes(&_funCall);
+	solAssert(inTypes.size() == args.size(), "");
+
+	auto symbFunction = state().bytesConcatFunction(&_funCall);
+	auto out = createSelectExpressionForFunction(symbFunction, args, inTypes, args.size());
+
+	defineExpr(_funCall, out);
+}
+
+void SMTEncoder::visitABIFunction(FunctionCall const& _funCall)
+{
+	auto symbFunction = state().abiFunction(&_funCall);
+	auto const& [name, inTypes, outTypes] = state().abiFunctionTypes(&_funCall);
+
+	auto const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	auto kind = funType.kind();
+	auto const& args = _funCall.sortedArguments();
+	auto argsActualLength = kind == FunctionType::Kind::ABIDecode ? 1 : args.size();
+
+	solAssert(inTypes.size() == argsActualLength, "");
+	if (argsActualLength == 0)
+	{
+		defineExpr(_funCall, smt::zeroValue(TypeProvider::bytesMemory()));
+		return;
+	}
+
+	auto out = createSelectExpressionForFunction(symbFunction, args, inTypes, argsActualLength);
+	if (outTypes.size() == 1)
+		defineExpr(_funCall, out);
+	else
+	{
+		auto symbTuple = std::dynamic_pointer_cast<smt::SymbolicTupleVariable>(m_context.expression(_funCall));
+		solAssert(symbTuple, "");
+		solAssert(symbTuple->components().size() == outTypes.size(), "");
+		solAssert(out.sort->kind == smtutil::Kind::Tuple, "");
+
+		symbTuple->increaseIndex();
+		for (unsigned i = 0; i < symbTuple->components().size(); ++i)
+			m_context.addAssertion(symbTuple->component(i) == smtutil::Expression::tuple_get(out, i));
+	}
+}
+
+void SMTEncoder::visitCryptoFunction(FunctionCall const& _funCall)
+{
+	auto const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	auto kind = funType.kind();
+	auto arg0 = expr(*_funCall.arguments().at(0));
+	std::optional<smtutil::Expression> result;
+	if (kind == FunctionType::Kind::KECCAK256)
+		result = smtutil::Expression::select(state().cryptoFunction("keccak256"), arg0);
+	else if (kind == FunctionType::Kind::SHA256)
+		result = smtutil::Expression::select(state().cryptoFunction("sha256"), arg0);
+	else if (kind == FunctionType::Kind::RIPEMD160)
+		result = smtutil::Expression::select(state().cryptoFunction("ripemd160"), arg0);
+	else if (kind == FunctionType::Kind::ECRecover)
+	{
+		auto e = state().cryptoFunction("ecrecover");
+		auto arg0 = expr(*_funCall.arguments().at(0));
+		auto arg1 = expr(*_funCall.arguments().at(1));
+		auto arg2 = expr(*_funCall.arguments().at(2));
+		auto arg3 = expr(*_funCall.arguments().at(3));
+		auto inputSort = dynamic_cast<smtutil::ArraySort&>(*e.sort).domain;
+		auto ecrecoverInput = smtutil::Expression::tuple_constructor(
+			smtutil::Expression(std::make_shared<smtutil::SortSort>(inputSort), ""),
+			{arg0, arg1, arg2, arg3}
+		);
+		result = smtutil::Expression::select(e, ecrecoverInput);
+	}
+	else
+		solAssert(false, "");
+
+	defineExpr(_funCall, *result);
+}
+
+void SMTEncoder::visitGasLeft(FunctionCall const& _funCall)
+{
+	std::string gasLeft = "gasleft";
+	// We increase the variable index since gasleft changes
+	// inside a tx.
+	defineGlobalVariable(gasLeft, _funCall, true);
+	auto const& symbolicVar = m_context.globalSymbol(gasLeft);
+	unsigned index = symbolicVar->index();
+	// We set the current value to unknown anyway to add type constraints.
+	m_context.setUnknownValue(*symbolicVar);
+	if (index > 0)
+		m_context.addAssertion(symbolicVar->currentValue() <= symbolicVar->valueAtIndex(index - 1));
+}
+
+void SMTEncoder::visitAddMulMod(FunctionCall const& _funCall)
+{
+	auto const& funType = dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type);
+	auto kind = funType.kind();
+	solAssert(kind == FunctionType::Kind::AddMod || kind == FunctionType::Kind::MulMod, "");
+	auto const& args = _funCall.arguments();
+	solAssert(args.at(0) && args.at(1) && args.at(2), "");
+	auto x = expr(*args.at(0));
+	auto y = expr(*args.at(1));
+	auto k = expr(*args.at(2));
+	auto const& intType = dynamic_cast<IntegerType const&>(*_funCall.annotation().type);
+
+	if (kind == FunctionType::Kind::AddMod)
+		defineExpr(_funCall, divModWithSlacks(x + y, k, intType).second);
+	else
+		defineExpr(_funCall, divModWithSlacks(x * y, k, intType).second);
+}
+
+void SMTEncoder::visitWrapUnwrap(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() == 1, "");
+	defineExpr(_funCall, expr(*args.front()));
+}
+
+void SMTEncoder::visitObjectCreation(FunctionCall const& _funCall)
+{
+	auto const& args = _funCall.arguments();
+	solAssert(args.size() >= 1, "");
+	auto argType = args.front()->annotation().type->category();
+	solAssert(argType == Type::Category::Integer || argType == Type::Category::RationalNumber, "");
+
+	smtutil::Expression arraySize = expr(*args.front());
+	setSymbolicUnknownValue(arraySize, TypeProvider::uint256(), m_context);
+	auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(_funCall));
+	solAssert(symbArray, "");
+	smt::setSymbolicZeroValue(*symbArray, m_context);
+	auto zeroElements = symbArray->elements();
+	symbArray->increaseIndex();
+	m_context.addAssertion(symbArray->length() == arraySize);
+	m_context.addAssertion(symbArray->elements() == zeroElements);
+}
+
+void SMTEncoder::endVisit(Identifier const& _identifier)
+{
+	if (auto decl = identifierToVariable(_identifier))
+	{
+		if (decl->isConstant())
+			defineExpr(_identifier, constantExpr(_identifier, *decl));
+		else
+			defineExpr(_identifier, currentValue(*decl));
+	}
+	else if (_identifier.annotation().type->category() == Type::Category::Function)
+		visitFunctionIdentifier(_identifier);
+	else if (_identifier.name() == "now")
+		defineGlobalVariable(_identifier.name(), _identifier);
+	else if (_identifier.name() == "this")
+	{
+		defineExpr(_identifier, state().thisAddress());
+		m_uninterpretedTerms.insert(&_identifier);
+	}
+	// Ignore type identifiers
+	else if (dynamic_cast<TypeType const*>(_identifier.annotation().type))
+		return;
+	// Ignore module identifiers
+	else if (dynamic_cast<ModuleType const*>(_identifier.annotation().type))
+		return;
+	// Ignore user defined value type identifiers
+	else if (dynamic_cast<UserDefinedValueType const*>(_identifier.annotation().type))
+		return;
+	// Ignore the builtin abi, it is handled in FunctionCall.
+	// TODO: ignore MagicType in general (abi, block, msg, tx, type)
+	else if (auto magicType = dynamic_cast<MagicType const*>(_identifier.annotation().type); magicType && magicType->kind() == MagicType::Kind::ABI)
+	{
+		solAssert(_identifier.name() == "abi", "");
+		return;
+	}
+	else
+		createExpr(_identifier);
+}
+
+void SMTEncoder::endVisit(ElementaryTypeNameExpression const& _typeName)
+{
+	auto const& typeType = dynamic_cast<TypeType const&>(*_typeName.annotation().type);
+	auto result = smt::newSymbolicVariable(
+		*TypeProvider::uint256(),
+		typeType.actualType()->toString(false),
+		m_context
+	);
+	solAssert(!result.first && result.second, "");
+	m_context.createExpression(_typeName, result.second);
+}
+
+namespace // helpers for SMTEncoder::visitPublicGetter
+{
+
+bool isReturnedFromStructGetter(Type const* _type)
+{
+	// So far it seems that only Mappings and ordinary Arrays are not returned.
+	auto category = _type->category();
+	if (category == Type::Category::Mapping)
+		return false;
+	if (category == Type::Category::Array)
+		return dynamic_cast<ArrayType const&>(*_type).isByteArrayOrString();
+	// default
+	return true;
+}
+
+std::vector<std::string> structGetterReturnedMembers(StructType const& _structType)
+{
+	std::vector<std::string> returnedMembers;
+	for (auto const& member: _structType.nativeMembers(nullptr))
+		if (isReturnedFromStructGetter(member.type))
+			returnedMembers.push_back(member.name);
+	return returnedMembers;
+}
+
+}
+
+void SMTEncoder::visitPublicGetter(FunctionCall const& _funCall)
+{
+	auto var = publicGetter(_funCall.expression());
+	solAssert(var && var->isStateVariable(), "");
+	solAssert(m_context.knownExpression(_funCall), "");
+	auto paramExpectedTypes = replaceUserTypes(FunctionType(*var).parameterTypes());
+	auto actualArguments = _funCall.arguments();
+	solAssert(actualArguments.size() == paramExpectedTypes.size(), "");
+	std::deque<smtutil::Expression> symbArguments;
+	for (unsigned i = 0; i < paramExpectedTypes.size(); ++i)
+		symbArguments.push_back(expr(*actualArguments[i], paramExpectedTypes[i]));
+
+	// See FunctionType::FunctionType(VariableDeclaration const& _varDecl)
+	// to understand the return types of public getters.
+	Type const* type = var->type();
+	smtutil::Expression currentExpr = currentValue(*var);
+	while (true)
+	{
+		if (
+			type->isValueType() ||
+			(type->category() == Type::Category::Array && dynamic_cast<ArrayType const&>(*type).isByteArrayOrString())
+		)
+		{
+			solAssert(symbArguments.empty(), "");
+			defineExpr(_funCall, currentExpr);
+			return;
+		}
+		switch (type->category())
+		{
+			case Type::Category::Array:
+			case Type::Category::Mapping:
+			{
+				solAssert(!symbArguments.empty(), "");
+				// For nested arrays/mappings, each argument in the call is an index to the next layer.
+				// We mirror this with `select` after unpacking the SMT-LIB array expression.
+				currentExpr = smtutil::Expression::select(smtutil::Expression::tuple_get(currentExpr, 0), symbArguments.front());
+				symbArguments.pop_front();
+				if (auto arrayType = dynamic_cast<ArrayType const*>(type))
+					type = arrayType->baseType();
+				else if (auto mappingType = dynamic_cast<MappingType const*>(type))
+					type = mappingType->valueType();
+				else
+					solAssert(false, "");
+				break;
+			}
+			case Type::Category::Struct:
+			{
+				solAssert(symbArguments.empty(), "");
+				smt::SymbolicStructVariable structVar(dynamic_cast<StructType const*>(type), "struct_temp_" + std::to_string(_funCall.id()), m_context);
+				m_context.addAssertion(structVar.currentValue() == currentExpr);
+				auto returnedMembers = structGetterReturnedMembers(dynamic_cast<StructType const&>(*structVar.type()));
+				solAssert(!returnedMembers.empty(), "");
+				auto returnedValues = applyMap(returnedMembers, [&](std::string const& memberName) -> std::optional<smtutil::Expression> { return structVar.member(memberName); });
+				defineExpr(_funCall, returnedValues);
+				return;
+			}
+			default:
+			{
+				// Unsupported cases, do nothing and the getter will be abstracted.
+				return;
+			}
+		}
+	}
+}
+
+bool SMTEncoder::shouldAnalyze(SourceUnit const& _source) const
+{
+	return m_settings.contracts.isDefault() ||
+		m_settings.contracts.has(*_source.annotation().path);
+}
+
+bool SMTEncoder::shouldAnalyze(ContractDefinition const& _contract) const
+{
+	if (!_contract.canBeDeployed())
+		return false;
+
+	return m_settings.contracts.isDefault() ||
+		m_settings.contracts.has(_contract.sourceUnitName());
+}
+
+void SMTEncoder::visitTypeConversion(FunctionCall const& _funCall)
+{
+	solAssert(*_funCall.annotation().kind == FunctionCallKind::TypeConversion, "");
+	solAssert(_funCall.arguments().size() == 1, "");
+
+	auto argument = _funCall.arguments().front();
+	auto const argType = argument->annotation().type;
+	auto const funCallType = _funCall.annotation().type;
+
+	auto symbArg = expr(*argument, funCallType);
+
+	if (smt::isStringLiteral(*argType) && smt::isFixedBytes(*funCallType))
+	{
+		defineExpr(_funCall, symbArg);
+		return;
+	}
+
+	ArrayType const* arrayType = dynamic_cast<ArrayType const*>(argType);
+	if (auto sliceType = dynamic_cast<ArraySliceType const*>(argType))
+		arrayType = &sliceType->arrayType();
+
+	if (arrayType && arrayType->isByteArrayOrString() && smt::isFixedBytes(*funCallType))
+	{
+		auto array = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(*argument));
+		bytesToFixedBytesAssertions(*array, _funCall);
+		return;
+	}
+
+	// TODO Simplify this whole thing for 0.8.0 where weird casts are disallowed.
+
+	unsigned argSize = argType->storageBytes();
+	unsigned castSize = funCallType->storageBytes();
+	bool castIsSigned = smt::isNumber(*funCallType) && smt::isSigned(funCallType);
+	bool argIsSigned = smt::isNumber(*argType) && smt::isSigned(argType);
+	std::optional<smtutil::Expression> symbMin;
+	std::optional<smtutil::Expression> symbMax;
+	if (smt::isNumber(*funCallType))
+	{
+		symbMin = smt::minValue(funCallType);
+		symbMax = smt::maxValue(funCallType);
+	}
+	if (argSize == castSize)
+	{
+		// If sizes are the same, it's possible that the signs are different.
+		if (smt::isNumber(*funCallType) && smt::isNumber(*argType))
+		{
+			// castIsSigned && !argIsSigned => might overflow if arg > castType.max
+			// !castIsSigned && argIsSigned => might underflow if arg < castType.min
+			// !castIsSigned && !argIsSigned => ok
+			// castIsSigned && argIsSigned => ok
+
+			if (castIsSigned && !argIsSigned)
+			{
+				auto wrap = smtutil::Expression::ite(
+					symbArg > *symbMax,
+					symbArg - (*symbMax - *symbMin + 1),
+					symbArg
+				);
+				defineExpr(_funCall, wrap);
+			}
+			else if (!castIsSigned && argIsSigned)
+			{
+				auto wrap = smtutil::Expression::ite(
+					symbArg < *symbMin,
+					symbArg + (*symbMax + 1),
+					symbArg
+				);
+				defineExpr(_funCall, wrap);
+			}
+			else
+				defineExpr(_funCall, symbArg);
+		}
+		else
+			defineExpr(_funCall, symbArg);
+	}
+	else if (castSize > argSize)
+	{
+		solAssert(smt::isNumber(*funCallType), "");
+		// RationalNumbers have size 32.
+		solAssert(argType->category() != Type::Category::RationalNumber, "");
+
+		// castIsSigned && !argIsSigned => ok
+		// castIsSigned && argIsSigned => ok
+		// !castIsSigned && !argIsSigned => ok except for FixedBytesType, need to adjust padding
+		// !castIsSigned && argIsSigned => might underflow if arg < castType.min
+
+		if (!castIsSigned && argIsSigned)
+		{
+			auto wrap = smtutil::Expression::ite(
+				symbArg < *symbMin,
+				symbArg + (*symbMax + 1),
+				symbArg
+			);
+			defineExpr(_funCall, wrap);
+		}
+		else if (!castIsSigned && !argIsSigned)
+		{
+			if (auto const* fixedCast = dynamic_cast<FixedBytesType const*>(funCallType))
+			{
+				auto const* fixedArg = dynamic_cast<FixedBytesType const*>(argType);
+				solAssert(fixedArg, "");
+				auto diff = fixedCast->numBytes() - fixedArg->numBytes();
+				solAssert(diff > 0, "");
+				auto bvSize = fixedCast->numBytes() * 8;
+				defineExpr(
+					_funCall,
+					smtutil::Expression::bv2int(smtutil::Expression::int2bv(symbArg, bvSize) << smtutil::Expression::int2bv(diff * 8, bvSize))
+				);
+			}
+			else
+				defineExpr(_funCall, symbArg);
+		}
+		else
+			defineExpr(_funCall, symbArg);
+	}
+	else // castSize < argSize
+	{
+		solAssert(smt::isNumber(*funCallType), "");
+
+		RationalNumberType const* rationalType = isConstant(*argument);
+		if (rationalType)
+		{
+			// The TypeChecker guarantees that a constant fits in the cast size.
+			defineExpr(_funCall, symbArg);
+			return;
+		}
+
+		auto const* fixedCast = dynamic_cast<FixedBytesType const*>(funCallType);
+		auto const* fixedArg = dynamic_cast<FixedBytesType const*>(argType);
+		if (fixedCast && fixedArg)
+		{
+			createExpr(_funCall);
+			auto diff = argSize - castSize;
+			solAssert(fixedArg->numBytes() - fixedCast->numBytes() == diff, "");
+
+			auto argValueBV = smtutil::Expression::int2bv(symbArg, argSize * 8);
+			auto shr = smtutil::Expression::int2bv(diff * 8, argSize * 8);
+			solAssert(!castIsSigned, "");
+			defineExpr(_funCall, smtutil::Expression::bv2int(argValueBV >> shr));
+		}
+		else
+		{
+			auto argValueBV = smtutil::Expression::int2bv(symbArg, castSize * 8);
+			defineExpr(_funCall, smtutil::Expression::bv2int(argValueBV, castIsSigned));
+		}
+	}
+}
+
+void SMTEncoder::visitFunctionIdentifier(Identifier const& _identifier)
+{
+	auto const& fType = dynamic_cast<FunctionType const&>(*_identifier.annotation().type);
+	if (replaceUserTypes(fType.returnParameterTypes()).size() == 1)
+	{
+		defineGlobalVariable(fType.identifier(), _identifier);
+		m_context.createExpression(_identifier, m_context.globalSymbol(fType.identifier()));
+	}
+}
+
+void SMTEncoder::visitStructConstructorCall(FunctionCall const& _funCall)
+{
+	solAssert(*_funCall.annotation().kind == FunctionCallKind::StructConstructorCall, "");
+	if (smt::isNonRecursiveStruct(*_funCall.annotation().type))
+	{
+		auto& structSymbolicVar = dynamic_cast<smt::SymbolicStructVariable&>(*m_context.expression(_funCall));
+		auto structType = dynamic_cast<StructType const*>(structSymbolicVar.type());
+		solAssert(structType, "");
+		auto const& structMembers = structType->structDefinition().members();
+		solAssert(structMembers.size() == _funCall.sortedArguments().size(), "");
+		auto args = _funCall.sortedArguments();
+		structSymbolicVar.assignAllMembers(applyMap(
+			ranges::views::zip(args, structMembers),
+			[this] (auto const& argMemberPair) { return expr(*argMemberPair.first, argMemberPair.second->type()); }
+		));
+	}
+
+}
+
+void SMTEncoder::endVisit(Literal const& _literal)
+{
+	solAssert(_literal.annotation().type, "Expected type for AST node");
+	Type const& type = *_literal.annotation().type;
+	if (smt::isNumber(type))
+		defineExpr(_literal, smtutil::Expression(type.literalValue(&_literal)));
+	else if (smt::isBool(type))
+		defineExpr(_literal, smtutil::Expression(_literal.token() == Token::TrueLiteral ? true : false));
+	else if (smt::isStringLiteral(type))
+	{
+		createExpr(_literal);
+
+		// Add constraints for the length and values as it is known.
+		auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(_literal));
+		solAssert(symbArray, "");
+
+		addArrayLiteralAssertions(
+			*symbArray,
+			applyMap(_literal.value(), [](unsigned char c) { return smtutil::Expression{size_t(c)}; })
+		);
+	}
+	else
+		solAssert(false, "");
+}
+
+void SMTEncoder::addArrayLiteralAssertions(
+	smt::SymbolicArrayVariable& _symArray,
+	std::vector<smtutil::Expression> const& _elementValues
+)
+{
+	m_context.addAssertion(_symArray.length() == _elementValues.size());
+	for (size_t i = 0; i < _elementValues.size(); i++)
+		m_context.addAssertion(smtutil::Expression::select(_symArray.elements(), i) == _elementValues[i]);
+}
+
+void SMTEncoder::bytesToFixedBytesAssertions(
+	smt::SymbolicArrayVariable& _symArray,
+	Expression const& _fixedBytes
+)
+{
+	auto const& fixed = dynamic_cast<FixedBytesType const&>(*_fixedBytes.annotation().type);
+	auto intType = TypeProvider::uint256();
+	std::string suffix = std::to_string(_fixedBytes.id()) + "_" + std::to_string(m_context.newUniqueId());
+	smt::SymbolicIntVariable k(intType, intType, "k_" + suffix, m_context);
+	m_context.addAssertion(k.currentValue() == 0);
+	size_t n = fixed.numBytes();
+	for (size_t i = 0; i < n; i++)
+	{
+		auto kPrev = k.currentValue();
+		m_context.addAssertion((smtutil::Expression::select(_symArray.elements(), i) * (u256(1) << ((n - i - 1) * 8))) + kPrev == k.increaseIndex());
+	}
+	m_context.addAssertion(expr(_fixedBytes) == k.currentValue());
+}
+
+void SMTEncoder::endVisit(Return const& _return)
+{
+	if (_return.expression() && m_context.knownExpression(*_return.expression()))
+	{
+		auto returnParams = m_callStack.back().first->returnParameters();
+		if (returnParams.size() > 1)
+		{
+			auto const& symbTuple = std::dynamic_pointer_cast<smt::SymbolicTupleVariable>(m_context.expression(*_return.expression()));
+			solAssert(symbTuple, "");
+			solAssert(symbTuple->components().size() == returnParams.size(), "");
+
+			auto const* tupleType = dynamic_cast<TupleType const*>(_return.expression()->annotation().type);
+			solAssert(tupleType, "");
+			auto const& types = tupleType->components();
+			solAssert(types.size() == returnParams.size(), "");
+
+			for (unsigned i = 0; i < returnParams.size(); ++i)
+				assignment(*returnParams.at(i), symbTuple->component(i, types.at(i), returnParams.at(i)->type()));
+		}
+		else if (returnParams.size() == 1)
+			assignment(*returnParams.front(), expr(*_return.expression(), returnParams.front()->type()));
+	}
+}
+
+bool SMTEncoder::visit(MemberAccess const& _memberAccess)
+{
+	createExpr(_memberAccess);
+
+	auto const& accessType = _memberAccess.annotation().type;
+	if (accessType->category() == Type::Category::Function)
+	{
+		auto const* functionType = dynamic_cast<FunctionType const*>(_memberAccess.annotation().type);
+		if (functionType && functionType->hasDeclaration())
+			defineExpr(
+				_memberAccess,
+				util::selectorFromSignatureU32(functionType->richIdentifier())
+			);
+
+		return true;
+	}
+
+	Expression const* memberExpr = innermostTuple(_memberAccess.expression());
+
+	auto const& exprType = memberExpr->annotation().type;
+	solAssert(exprType, "");
+
+	if (exprType->category() == Type::Category::Magic)
+	{
+		if (auto const* identifier = dynamic_cast<Identifier const*>(memberExpr))
+		{
+			auto const& name = identifier->name();
+			solAssert(name == "block" || name == "msg" || name == "tx", "");
+			auto memberName = _memberAccess.memberName();
+
+			// TODO remove this for 0.9.0
+			if (name == "block" && memberName == "difficulty")
+				memberName = "prevrandao";
+
+			defineExpr(_memberAccess, state().txMember(name + "." + memberName));
+		}
+		else if (auto magicType = dynamic_cast<MagicType const*>(exprType))
+		{
+			if (magicType->kind() == MagicType::Kind::Block)
+				defineExpr(_memberAccess, state().txMember("block." + _memberAccess.memberName()));
+			else if (magicType->kind() == MagicType::Kind::Message)
+				defineExpr(_memberAccess, state().txMember("msg." + _memberAccess.memberName()));
+			else if (magicType->kind() == MagicType::Kind::Transaction)
+				defineExpr(_memberAccess, state().txMember("tx." + _memberAccess.memberName()));
+			else if (magicType->kind() == MagicType::Kind::MetaType)
+			{
+				auto const& memberName = _memberAccess.memberName();
+				if (memberName == "min" || memberName == "max")
+				{
+					if (IntegerType const* integerType = dynamic_cast<IntegerType const*>(magicType->typeArgument()))
+						defineExpr(_memberAccess, memberName == "min" ? integerType->minValue() : integerType->maxValue());
+					else if (EnumType const* enumType = dynamic_cast<EnumType const*>(magicType->typeArgument()))
+						defineExpr(_memberAccess, memberName == "min" ? enumType->minValue() : enumType->maxValue());
+				}
+				else if (memberName == "interfaceId")
+				{
+					ContractDefinition const& contract = dynamic_cast<ContractType const&>(*magicType->typeArgument()).contractDefinition();
+					defineExpr(_memberAccess, contract.interfaceId());
+				}
+				else
+					// NOTE: supporting name, creationCode, runtimeCode would be easy enough, but the bytes/string they return are not
+					//       at all usable in the SMT checker currently
+					m_unsupportedErrors.warning(
+						7507_error,
+						_memberAccess.location(),
+						"Assertion checker does not yet support this expression."
+					);
+
+			}
+		}
+		else
+			solAssert(false, "");
+
+		return false;
+	}
+	else if (smt::isNonRecursiveStruct(*exprType))
+	{
+		memberExpr->accept(*this);
+		auto const& symbStruct = std::dynamic_pointer_cast<smt::SymbolicStructVariable>(m_context.expression(*memberExpr));
+		defineExpr(_memberAccess, symbStruct->member(_memberAccess.memberName()));
+		return false;
+	}
+	else if (exprType->category() == Type::Category::TypeType)
+	{
+		auto const* decl = expressionToDeclaration(*memberExpr);
+		if (dynamic_cast<EnumDefinition const*>(decl))
+		{
+			auto enumType = dynamic_cast<EnumType const*>(accessType);
+			solAssert(enumType, "");
+			defineExpr(_memberAccess, enumType->memberValue(_memberAccess.memberName()));
+
+			return false;
+		}
+		else if (dynamic_cast<ContractDefinition const*>(decl))
+		{
+			if (auto const* var = dynamic_cast<VariableDeclaration const*>(_memberAccess.annotation().referencedDeclaration))
+			{
+				if (var->isConstant())
+					defineExpr(_memberAccess, constantExpr(_memberAccess, *var));
+				else
+					defineExpr(_memberAccess, currentValue(*var));
+				return false;
+			}
+		}
+	}
+	else if (exprType->category() == Type::Category::Address)
+	{
+		memberExpr->accept(*this);
+		if (_memberAccess.memberName() == "balance")
+		{
+			defineExpr(_memberAccess, state().balance(expr(*memberExpr)));
+			setSymbolicUnknownValue(*m_context.expression(_memberAccess), m_context);
+			m_uninterpretedTerms.insert(&_memberAccess);
+			return false;
+		}
+	}
+	else if (exprType->category() == Type::Category::Array)
+	{
+		memberExpr->accept(*this);
+		if (_memberAccess.memberName() == "length")
+		{
+			auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(*memberExpr));
+			solAssert(symbArray, "");
+			defineExpr(_memberAccess, symbArray->length());
+			m_uninterpretedTerms.insert(&_memberAccess);
+			setSymbolicUnknownValue(
+				expr(_memberAccess),
+				_memberAccess.annotation().type,
+				m_context
+			);
+		}
+		return false;
+	}
+	else if (
+		auto const* functionType = dynamic_cast<FunctionType const*>(exprType);
+		functionType &&
+		_memberAccess.memberName() == "selector" &&
+		functionType->hasDeclaration()
+	)
+	{
+		defineExpr(_memberAccess, functionType->externalIdentifier());
+		return false;
+	}
+	else if (exprType->category() == Type::Category::Module)
+	{
+		if (auto const* var = dynamic_cast<VariableDeclaration const*>(_memberAccess.annotation().referencedDeclaration))
+		{
+			solAssert(var->isConstant(), "");
+			defineExpr(_memberAccess, constantExpr(_memberAccess, *var));
+			return false;
+		}
+	}
+
+	m_unsupportedErrors.warning(
+		7650_error,
+		_memberAccess.location(),
+		"Assertion checker does not yet support this expression."
+	);
+
+	return true;
+}
+
+void SMTEncoder::endVisit(IndexAccess const& _indexAccess)
+{
+	createExpr(_indexAccess);
+
+	if (_indexAccess.annotation().type->category() == Type::Category::TypeType)
+		return;
+
+	makeOutOfBoundsVerificationTarget(_indexAccess);
+
+	if (auto const* type = dynamic_cast<FixedBytesType const*>(_indexAccess.baseExpression().annotation().type))
+	{
+		smtutil::Expression base = expr(_indexAccess.baseExpression());
+
+		if (type->numBytes() == 1)
+			defineExpr(_indexAccess, base);
+		else
+		{
+			auto [bvSize, isSigned] = smt::typeBvSizeAndSignedness(_indexAccess.baseExpression().annotation().type);
+			solAssert(!isSigned, "");
+			solAssert(bvSize >= 16, "");
+			solAssert(bvSize % 8 == 0, "");
+
+			smtutil::Expression idx = expr(*_indexAccess.indexExpression());
+
+			auto bvBase = smtutil::Expression::int2bv(base, bvSize);
+			auto bvShl = smtutil::Expression::int2bv(idx * 8, bvSize);
+			auto bvShr = smtutil::Expression::int2bv(bvSize - 8, bvSize);
+			auto result = (bvBase << bvShl) >> bvShr;
+
+			auto anyValue = expr(_indexAccess);
+			m_context.expression(_indexAccess)->increaseIndex();
+			unsigned numBytes = bvSize / 8;
+			auto withBound = smtutil::Expression::ite(
+				idx < numBytes,
+				smtutil::Expression::bv2int(result, false),
+				anyValue
+			);
+			defineExpr(_indexAccess, withBound);
+		}
+		return;
+	}
+
+	std::shared_ptr<smt::SymbolicVariable> array;
+	if (auto const* id = dynamic_cast<Identifier const*>(&_indexAccess.baseExpression()))
+	{
+		auto varDecl = identifierToVariable(*id);
+		solAssert(varDecl, "");
+		array = m_context.variable(*varDecl);
+
+		if (varDecl && varDecl->isConstant())
+			m_context.addAssertion(currentValue(*varDecl) == expr(*id));
+	}
+	else
+	{
+		solAssert(m_context.knownExpression(_indexAccess.baseExpression()), "");
+		array = m_context.expression(_indexAccess.baseExpression());
+	}
+
+	auto arrayVar = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(array);
+	solAssert(arrayVar, "");
+
+	Type const* baseType = _indexAccess.baseExpression().annotation().type;
+	defineExpr(_indexAccess, smtutil::Expression::select(
+		arrayVar->elements(),
+		expr(*_indexAccess.indexExpression(), keyType(baseType))
+	));
+	setSymbolicUnknownValue(
+		expr(_indexAccess),
+		_indexAccess.annotation().type,
+		m_context
+	);
+	m_uninterpretedTerms.insert(&_indexAccess);
+}
+
+void SMTEncoder::endVisit(IndexRangeAccess const& _indexRangeAccess)
+{
+	createExpr(_indexRangeAccess);
+	/// The actual slice is created by CHC which also assigns the length.
+}
+
+void SMTEncoder::arrayAssignment()
+{
+	m_arrayAssignmentHappened = true;
+}
+
+void SMTEncoder::indexOrMemberAssignment(Expression const& _expr, smtutil::Expression const& _rightHandSide)
+{
+	auto toStore = _rightHandSide;
+	auto const* lastExpr = &_expr;
+	while (true)
+	{
+		if (auto const* indexAccess = dynamic_cast<IndexAccess const*>(lastExpr))
+		{
+			auto const& base = indexAccess->baseExpression();
+			if (dynamic_cast<Identifier const*>(&base))
+				base.accept(*this);
+
+			Type const* baseType = base.annotation().type;
+			auto indexExpr = expr(*indexAccess->indexExpression(), keyType(baseType));
+			auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(base));
+			solAssert(symbArray, "");
+			toStore = smtutil::Expression::tuple_constructor(
+				smtutil::Expression(std::make_shared<smtutil::SortSort>(smt::smtSort(*baseType)), baseType->toString(true)),
+				{smtutil::Expression::store(symbArray->elements(), indexExpr, toStore), symbArray->length()}
+			);
+			defineExpr(*indexAccess, smtutil::Expression::select(
+				symbArray->elements(),
+				indexExpr
+			));
+			lastExpr = &indexAccess->baseExpression();
+		}
+		else if (auto const* memberAccess = dynamic_cast<MemberAccess const*>(lastExpr))
+		{
+			auto const& base = memberAccess->expression();
+			if (dynamic_cast<Identifier const*>(&base))
+				base.accept(*this);
+
+			if (
+				auto const* structType = dynamic_cast<StructType const*>(base.annotation().type);
+				structType && structType->recursive()
+			)
+			{
+				m_unsupportedErrors.warning(
+					4375_error,
+					memberAccess->location(),
+					"Assertion checker does not support recursive structs."
+				);
+				return;
+			}
+			if (auto varDecl = identifierToVariable(*memberAccess))
+			{
+				if (varDecl->hasReferenceOrMappingType())
+					resetReferences(*varDecl);
+
+				assignment(*varDecl, toStore);
+				break;
+			}
+
+			auto symbStruct = std::dynamic_pointer_cast<smt::SymbolicStructVariable>(m_context.expression(base));
+			solAssert(symbStruct, "");
+			symbStruct->assignMember(memberAccess->memberName(), toStore);
+			toStore = symbStruct->currentValue();
+			defineExpr(*memberAccess, symbStruct->member(memberAccess->memberName()));
+			lastExpr = &memberAccess->expression();
+		}
+		else if (auto const& id = dynamic_cast<Identifier const*>(lastExpr))
+		{
+			auto varDecl = identifierToVariable(*id);
+			solAssert(varDecl, "");
+
+			if (varDecl->hasReferenceOrMappingType())
+				resetReferences(*varDecl);
+
+			assignment(*varDecl, toStore);
+			defineExpr(*id, currentValue(*varDecl));
+			break;
+		}
+		else
+		{
+			auto type = lastExpr->annotation().type;
+			if (
+				dynamic_cast<ReferenceType const*>(type) ||
+				dynamic_cast<MappingType const*>(type)
+			)
+				resetReferences(type);
+
+			assignment(*m_context.expression(*lastExpr), toStore);
+			break;
+		}
+	}
+}
+
+void SMTEncoder::arrayPush(FunctionCall const& _funCall)
+{
+	auto memberAccess = dynamic_cast<MemberAccess const*>(&_funCall.expression());
+	solAssert(memberAccess, "");
+	auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(memberAccess->expression()));
+	solAssert(symbArray, "");
+	auto oldLength = symbArray->length();
+	m_context.addAssertion(oldLength >= 0);
+	// Real world assumption: the array length is assumed to not overflow.
+	// This assertion guarantees that both the current and updated lengths have the above property.
+	m_context.addAssertion(oldLength + 1 < (smt::maxValue(*TypeProvider::uint256()) - 1));
+
+	auto const& arguments = _funCall.arguments();
+	auto arrayType = dynamic_cast<ArrayType const*>(symbArray->type());
+	solAssert(arrayType, "");
+	auto elementType = arrayType->baseType();
+	smtutil::Expression element = arguments.empty() ?
+		smt::zeroValue(elementType) :
+		expr(*arguments.front(), elementType);
+	smtutil::Expression store = smtutil::Expression::store(
+		symbArray->elements(),
+		oldLength,
+		element
+	);
+	symbArray->increaseIndex();
+	m_context.addAssertion(symbArray->elements() == store);
+	m_context.addAssertion(symbArray->length() == oldLength + 1);
+
+	if (arguments.empty())
+		defineExpr(_funCall, element);
+
+	assignment(memberAccess->expression(), symbArray->currentValue());
+}
+
+void SMTEncoder::arrayPop(FunctionCall const& _funCall)
+{
+	auto memberAccess = dynamic_cast<MemberAccess const*>(cleanExpression(_funCall.expression()));
+	solAssert(memberAccess, "");
+	auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(memberAccess->expression()));
+	solAssert(symbArray, "");
+
+	makeArrayPopVerificationTarget(_funCall);
+
+	auto oldElements = symbArray->elements();
+	auto oldLength = symbArray->length();
+
+	symbArray->increaseIndex();
+	m_context.addAssertion(symbArray->elements() == oldElements);
+	auto newLength = smtutil::Expression::ite(
+		oldLength > 0,
+		oldLength - 1,
+		0
+	);
+	m_context.addAssertion(symbArray->length() == newLength);
+
+	assignment(memberAccess->expression(), symbArray->currentValue());
+}
+
+void SMTEncoder::defineGlobalVariable(std::string const& _name, Expression const& _expr, bool _increaseIndex)
+{
+	if (!m_context.knownGlobalSymbol(_name))
+	{
+		bool abstract = m_context.createGlobalSymbol(_name, _expr);
+		if (abstract)
+			m_unsupportedErrors.warning(
+				1695_error,
+				_expr.location(),
+				"Assertion checker does not yet support this global variable."
+			);
+	}
+	else if (_increaseIndex)
+		m_context.globalSymbol(_name)->increaseIndex();
+	// The default behavior is not to increase the index since
+	// most of the global values stay the same throughout a tx.
+	if (isSupportedType(*_expr.annotation().type))
+		defineExpr(_expr, m_context.globalSymbol(_name)->currentValue());
+}
+
+bool SMTEncoder::shortcutRationalNumber(Expression const& _expr)
+{
+	RationalNumberType const* rationalType = isConstant(_expr);
+	if (!rationalType)
+		return false;
+
+	if (rationalType->isNegative())
+		defineExpr(_expr, smtutil::Expression(u2s(rationalType->literalValue(nullptr))));
+	else
+		defineExpr(_expr, smtutil::Expression(rationalType->literalValue(nullptr)));
+	return true;
+}
+
+void SMTEncoder::arithmeticOperation(BinaryOperation const& _op)
+{
+	auto type = _op.annotation().commonType;
+	solAssert(type, "");
+	solAssert(type->category() == Type::Category::Integer || type->category() == Type::Category::FixedPoint, "");
+	switch (_op.getOperator())
+	{
+	case Token::Add:
+	case Token::Sub:
+	case Token::Mul:
+	case Token::Div:
+	case Token::Mod:
+	{
+		auto values = arithmeticOperation(
+			_op.getOperator(),
+			expr(_op.leftExpression()),
+			expr(_op.rightExpression()),
+			_op.annotation().commonType,
+			_op
+		);
+		defineExpr(_op, values.first);
+		break;
+	}
+	default:
+		m_unsupportedErrors.warning(
+			5188_error,
+			_op.location(),
+			"Assertion checker does not yet implement this operator."
+		);
+	}
+}
+
+std::pair<smtutil::Expression, smtutil::Expression> SMTEncoder::arithmeticOperation(
+	Token _op,
+	smtutil::Expression const& _left,
+	smtutil::Expression const& _right,
+	Type const* _commonType,
+	Expression const& _operation
+)
+{
+	static std::set<Token> validOperators{
+		Token::Add,
+		Token::Sub,
+		Token::Mul,
+		Token::Div,
+		Token::Mod
+	};
+	solAssert(validOperators.count(_op), "");
+	solAssert(_commonType, "");
+	solAssert(
+		_commonType->category() == Type::Category::Integer || _commonType->category() == Type::Category::FixedPoint,
+		""
+	);
+
+	IntegerType const* intType = nullptr;
+	if (auto type = dynamic_cast<IntegerType const*>(_commonType))
+		intType = type;
+	else
+		intType = TypeProvider::uint256();
+
+	auto valueUnbounded = [&]() -> smtutil::Expression {
+		switch (_op)
+		{
+		case Token::Add: return _left + _right;
+		case Token::Sub: return _left - _right;
+		case Token::Mul: return _left * _right;
+		case Token::Div: return divModWithSlacks(_left, _right, *intType).first;
+		case Token::Mod: return divModWithSlacks(_left, _right, *intType).second;
+		default: solAssert(false, "");
+		}
+	}();
+
+	if (m_checked)
+		return {valueUnbounded, valueUnbounded};
+
+	if (_op == Token::Div || _op == Token::Mod)
+	{
+		// mod and unsigned division never underflow/overflow
+		if (_op == Token::Mod || !intType->isSigned())
+			return {valueUnbounded, valueUnbounded};
+
+		// The only case where division overflows is
+		// - type is signed
+		// - LHS is type.min
+		// - RHS is -1
+		// the result is then -(type.min), which wraps back to type.min
+		smtutil::Expression maxLeft = _left == smt::minValue(*intType);
+		smtutil::Expression minusOneRight = _right == std::numeric_limits<size_t >::max();
+		smtutil::Expression wrap = smtutil::Expression::ite(maxLeft && minusOneRight, smt::minValue(*intType), valueUnbounded);
+		return {wrap, valueUnbounded};
+	}
+
+	auto symbMin = smt::minValue(*intType);
+	auto symbMax = smt::maxValue(*intType);
+
+	smtutil::Expression intValueRange = (0 - symbMin) + symbMax + 1;
+	std::string suffix = std::to_string(_operation.id()) + "_" + std::to_string(m_context.newUniqueId());
+	smt::SymbolicIntVariable k(intType, intType, "k_" + suffix, m_context);
+	smt::SymbolicIntVariable m(intType, intType, "m_" + suffix, m_context);
+
+	// To wrap around valueUnbounded in case of overflow or underflow, we replace it with a k, given:
+	// 1. k + m * intValueRange = valueUnbounded
+	// 2. k is in range of the desired integer type
+	auto wrap = k.currentValue();
+	m_context.addAssertion(valueUnbounded == (k.currentValue() + intValueRange * m.currentValue()));
+	m_context.addAssertion(k.currentValue() >= symbMin);
+	m_context.addAssertion(k.currentValue() <= symbMax);
+
+	// TODO this could be refined:
+	// for unsigned types it's enough to check only the upper bound.
+	auto value = smtutil::Expression::ite(
+		valueUnbounded > symbMax,
+		wrap,
+		smtutil::Expression::ite(
+			valueUnbounded < symbMin,
+			wrap,
+			valueUnbounded
+		)
+	);
+
+	return {value, valueUnbounded};
+}
+
+smtutil::Expression SMTEncoder::bitwiseOperation(
+	Token _op,
+	smtutil::Expression const& _left,
+	smtutil::Expression const& _right,
+	Type const* _commonType
+)
+{
+	static std::set<Token> validOperators{
+		Token::BitAnd,
+		Token::BitOr,
+		Token::BitXor,
+		Token::SHL,
+		Token::SHR,
+		Token::SAR
+	};
+	solAssert(validOperators.count(_op), "");
+	solAssert(_commonType, "");
+
+	auto [bvSize, isSigned] = smt::typeBvSizeAndSignedness(_commonType);
+
+	auto bvLeft = smtutil::Expression::int2bv(_left, bvSize);
+	auto bvRight = smtutil::Expression::int2bv(_right, bvSize);
+
+	std::optional<smtutil::Expression> result;
+	switch (_op)
+	{
+		case Token::BitAnd:
+			result = bvLeft & bvRight;
+			break;
+		case Token::BitOr:
+			result = bvLeft | bvRight;
+			break;
+		case Token::BitXor:
+			result = bvLeft ^ bvRight;
+			break;
+		case Token::SHL:
+			result = bvLeft << bvRight;
+			break;
+		case Token::SHR:
+			result = bvLeft >> bvRight;
+			break;
+		case Token::SAR:
+			result = isSigned ?
+				smtutil::Expression::ashr(bvLeft, bvRight) :
+				bvLeft >> bvRight;
+			break;
+		default:
+			solAssert(false, "");
+	}
+
+	solAssert(result.has_value(), "");
+	return smtutil::Expression::bv2int(*result, isSigned);
+}
+
+void SMTEncoder::compareOperation(BinaryOperation const& _op)
+{
+	auto commonType = _op.annotation().commonType;
+	solAssert(commonType, "");
+
+	if (isSupportedType(*commonType))
+	{
+		smtutil::Expression left(expr(_op.leftExpression(), commonType));
+		smtutil::Expression right(expr(_op.rightExpression(), commonType));
+		Token op = _op.getOperator();
+		std::shared_ptr<smtutil::Expression> value;
+		if (smt::isNumber(*commonType))
+		{
+			value = std::make_shared<smtutil::Expression>(
+				op == Token::Equal ? (left == right) :
+				op == Token::NotEqual ? (left != right) :
+				op == Token::LessThan ? (left < right) :
+				op == Token::LessThanOrEqual ? (left <= right) :
+				op == Token::GreaterThan ? (left > right) :
+				/*op == Token::GreaterThanOrEqual*/ (left >= right)
+			);
+		}
+		else // Bool
+		{
+			solUnimplementedAssert(smt::isBool(*commonType), "Operation not yet supported");
+			value = std::make_shared<smtutil::Expression>(
+				op == Token::Equal ? (left == right) :
+				/*op == Token::NotEqual*/ (left != right)
+			);
+		}
+		// TODO: check that other values for op are not possible.
+		defineExpr(_op, *value);
+	}
+	else
+		m_unsupportedErrors.warning(
+			7229_error,
+			_op.location(),
+			"Assertion checker does not yet implement the type " + _op.annotation().commonType->toString() + " for comparisons"
+		);
+}
+
+void SMTEncoder::booleanOperation(BinaryOperation const& _op)
+{
+	solAssert(_op.getOperator() == Token::And || _op.getOperator() == Token::Or, "");
+	solAssert(_op.annotation().commonType, "");
+	solAssert(_op.annotation().commonType->category() == Type::Category::Bool, "");
+	// @TODO check that both of them are not constant
+	_op.leftExpression().accept(*this);
+	if (_op.getOperator() == Token::And)
+	{
+		auto indicesAfterSecond = visitBranch(&_op.rightExpression(), expr(_op.leftExpression())).first;
+		mergeVariables(!expr(_op.leftExpression()), copyVariableIndices(), indicesAfterSecond);
+		defineExpr(_op, expr(_op.leftExpression()) && expr(_op.rightExpression()));
+	}
+	else
+	{
+		auto indicesAfterSecond = visitBranch(&_op.rightExpression(), !expr(_op.leftExpression())).first;
+		mergeVariables(expr(_op.leftExpression()), copyVariableIndices(), indicesAfterSecond);
+		defineExpr(_op, expr(_op.leftExpression()) || expr(_op.rightExpression()));
+	}
+}
+
+void SMTEncoder::bitwiseOperation(BinaryOperation const& _op)
+{
+	auto op = _op.getOperator();
+	solAssert(TokenTraits::isBitOp(op) || TokenTraits::isShiftOp(op), "");
+	auto commonType = _op.annotation().commonType;
+	solAssert(commonType, "");
+
+	defineExpr(_op, bitwiseOperation(
+		_op.getOperator(),
+		expr(_op.leftExpression(), commonType),
+		expr(_op.rightExpression(), commonType),
+		commonType
+	));
+}
+
+void SMTEncoder::bitwiseNotOperation(UnaryOperation const& _op)
+{
+	solAssert(_op.getOperator() == Token::BitNot, "");
+
+	auto [bvSize, isSigned] = smt::typeBvSizeAndSignedness(_op.annotation().type);
+
+	auto bvOperand = smtutil::Expression::int2bv(expr(_op.subExpression(), _op.annotation().type), bvSize);
+	defineExpr(_op, smtutil::Expression::bv2int(~bvOperand, isSigned));
+}
+
+std::pair<smtutil::Expression, smtutil::Expression> SMTEncoder::divModWithSlacks(
+	smtutil::Expression _left,
+	smtutil::Expression _right,
+	IntegerType const& _type
+)
+{
+	if (m_settings.divModNoSlacks)
+		return {_left / _right, _left % _right};
+
+	IntegerType const* intType = &_type;
+	std::string suffix = "div_mod_" + std::to_string(m_context.newUniqueId());
+	smt::SymbolicIntVariable dSymb(intType, intType, "d_" + suffix, m_context);
+	smt::SymbolicIntVariable rSymb(intType, intType, "r_" + suffix, m_context);
+	auto d = dSymb.currentValue();
+	auto r = rSymb.currentValue();
+
+	// x / y = d and x % y = r iff d * y + r = x and
+	// either x >= 0 and 0 <= r < abs(y) (or just 0 <= r < y for unsigned)
+	// or     x < 0 and -abs(y) < r <= 0
+	m_context.addAssertion(((d * _right) + r) == _left);
+	if (_type.isSigned())
+		m_context.addAssertion(
+			(_left >= 0 && 0 <= r && (_right == 0 || r < smtutil::abs(_right))) ||
+			(_left < 0 && ((_right == 0 || 0 - smtutil::abs(_right) < r) && r <= 0))
+		);
+	else // unsigned version
+		m_context.addAssertion(0 <= r && (_right == 0 || r < _right));
+
+	auto divResult = smtutil::Expression::ite(_right == 0, 0, d);
+	auto modResult = smtutil::Expression::ite(_right == 0, 0, r);
+	return {divResult, modResult};
+}
+
+void SMTEncoder::assignment(Expression const& _left, smtutil::Expression const& _right)
+{
+	assignment(_left, _right, _left.annotation().type);
+}
+
+void SMTEncoder::assignment(
+	Expression const& _left,
+	smtutil::Expression const& _right,
+	Type const* _type
+)
+{
+	solAssert(
+		_left.annotation().type->category() != Type::Category::Tuple,
+		"Tuple assignments should be handled by tupleAssignment."
+	);
+
+	Expression const* left = cleanExpression(_left);
+
+	if (!isSupportedType(*_type))
+	{
+		// Give it a new index anyway to keep the SSA scheme sound.
+		if (auto varDecl = identifierToVariable(*left))
+			m_context.newValue(*varDecl);
+	}
+	else if (auto varDecl = identifierToVariable(*left))
+	{
+		if (varDecl->hasReferenceOrMappingType())
+			resetReferences(*varDecl);
+		assignment(*varDecl, _right);
+	}
+	else if (
+		dynamic_cast<IndexAccess const*>(left) ||
+		dynamic_cast<MemberAccess const*>(left)
+	)
+		indexOrMemberAssignment(*left, _right);
+	else if (auto const* funCall = dynamic_cast<FunctionCall const*>(left))
+	{
+		if (auto funType = dynamic_cast<FunctionType const*>(funCall->expression().annotation().type))
+		{
+			if (funType->kind() == FunctionType::Kind::ArrayPush)
+			{
+				auto memberAccess = dynamic_cast<MemberAccess const*>(&funCall->expression());
+				solAssert(memberAccess, "");
+				auto symbArray = std::dynamic_pointer_cast<smt::SymbolicArrayVariable>(m_context.expression(memberAccess->expression()));
+				solAssert(symbArray, "");
+
+				auto oldLength = symbArray->length();
+				auto store = smtutil::Expression::store(
+					symbArray->elements(),
+					symbArray->length() - 1,
+					_right
+				);
+				symbArray->increaseIndex();
+				m_context.addAssertion(symbArray->elements() == store);
+				m_context.addAssertion(symbArray->length() == oldLength);
+				assignment(memberAccess->expression(), symbArray->currentValue());
+			}
+			else if (funType->kind() == FunctionType::Kind::Internal)
+			{
+				for (auto type: replaceUserTypes(funType->returnParameterTypes()))
+					if (type->category() == Type::Category::Mapping || dynamic_cast<ReferenceType const*>(type))
+						resetReferences(type);
+			}
+		}
+	}
+	else
+		solAssert(false, "");
+}
+
+void SMTEncoder::tupleAssignment(Expression const& _left, Expression const& _right)
+{
+	auto lTuple = dynamic_cast<TupleExpression const*>(innermostTuple(_left));
+	solAssert(lTuple, "");
+	Expression const* right = innermostTuple(_right);
+
+	auto const& lComponents = lTuple->components();
+
+	// If both sides are tuple expressions, we individually and potentially
+	// recursively assign each pair of components.
+	// This is because of potential type conversion.
+	if (auto rTuple = dynamic_cast<TupleExpression const*>(right))
+	{
+		auto const& rComponents = rTuple->components();
+		solAssert(lComponents.size() == rComponents.size(), "");
+		for (unsigned i = 0; i < lComponents.size(); ++i)
+		{
+			if (!lComponents.at(i) || !rComponents.at(i))
+				continue;
+			auto const& lExpr = *lComponents.at(i);
+			auto const& rExpr = *rComponents.at(i);
+			if (lExpr.annotation().type->category() == Type::Category::Tuple)
+				tupleAssignment(lExpr, rExpr);
+			else
+			{
+				auto type = lExpr.annotation().type;
+				assignment(lExpr, expr(rExpr, type), type);
+			}
+		}
+	}
+	else
+	{
+		auto rType = dynamic_cast<TupleType const*>(right->annotation().type);
+		solAssert(rType, "");
+
+		auto const& rComponents = rType->components();
+		solAssert(lComponents.size() == rComponents.size(), "");
+
+		auto symbRight = expr(*right);
+		solAssert(symbRight.sort->kind == smtutil::Kind::Tuple, "");
+
+		for (unsigned i = 0; i < lComponents.size(); ++i)
+			if (auto component = lComponents.at(i); component && rComponents.at(i))
+				assignment(*component, smtutil::Expression::tuple_get(symbRight, i), component->annotation().type);
+	}
+}
+
+smtutil::Expression SMTEncoder::compoundAssignment(Assignment const& _assignment)
+{
+	static std::map<Token, Token> const compoundToArithmetic{
+		{Token::AssignAdd, Token::Add},
+		{Token::AssignSub, Token::Sub},
+		{Token::AssignMul, Token::Mul},
+		{Token::AssignDiv, Token::Div},
+		{Token::AssignMod, Token::Mod}
+	};
+	static std::map<Token, Token> const compoundToBitwise{
+		{Token::AssignBitAnd, Token::BitAnd},
+		{Token::AssignBitOr, Token::BitOr},
+		{Token::AssignBitXor, Token::BitXor},
+		{Token::AssignShl, Token::SHL},
+		{Token::AssignShr, Token::SHR},
+		{Token::AssignSar, Token::SAR}
+	};
+	Token op = _assignment.assignmentOperator();
+	solAssert(compoundToArithmetic.count(op) || compoundToBitwise.count(op), "");
+
+	auto decl = identifierToVariable(_assignment.leftHandSide());
+
+	if (compoundToBitwise.count(op))
+		return bitwiseOperation(
+			compoundToBitwise.at(op),
+			decl ? currentValue(*decl) : expr(_assignment.leftHandSide(), _assignment.annotation().type),
+			expr(_assignment.rightHandSide(), _assignment.annotation().type),
+			_assignment.annotation().type
+		);
+
+	auto values = arithmeticOperation(
+		compoundToArithmetic.at(op),
+		decl ? currentValue(*decl) : expr(_assignment.leftHandSide(), _assignment.annotation().type),
+		expr(_assignment.rightHandSide(), _assignment.annotation().type),
+		_assignment.annotation().type,
+		_assignment
+	);
+	return values.first;
+}
+
+void SMTEncoder::expressionToTupleAssignment(std::vector<std::shared_ptr<VariableDeclaration>> const& _variables, Expression const& _rhs)
+{
+	auto symbolicVar = m_context.expression(_rhs);
+	if (_variables.size() > 1)
+	{
+		auto symbTuple = std::dynamic_pointer_cast<smt::SymbolicTupleVariable>(symbolicVar);
+		solAssert(symbTuple, "");
+		auto const& symbComponents = symbTuple->components();
+		solAssert(symbComponents.size() == _variables.size(), "");
+		auto tupleType = dynamic_cast<TupleType const*>(_rhs.annotation().type);
+		solAssert(tupleType, "");
+		auto const& typeComponents = tupleType->components();
+		solAssert(typeComponents.size() == symbComponents.size(), "");
+		for (unsigned i = 0; i < symbComponents.size(); ++i)
+		{
+			auto param = _variables.at(i);
+			if (param)
+			{
+				solAssert(m_context.knownVariable(*param), "");
+				assignment(*param, symbTuple->component(i, typeComponents[i], param->type()));
+			}
+		}
+	}
+	else if (_variables.size() == 1)
+	{
+		auto const& var = *_variables.front();
+		solAssert(m_context.knownVariable(var), "");
+		assignment(var, _rhs);
+	}
+}
+
+void SMTEncoder::assignment(VariableDeclaration const& _variable, Expression const& _value)
+{
+	// In general, at this point, the SMT sorts of _variable and _value are the same,
+	// even if there is implicit conversion.
+	// This is a special case where the SMT sorts are different.
+	// For now we are unaware of other cases where this happens, but if they do appear
+	// we should extract this into an `implicitConversion` function.
+	assignment(_variable, expr(_value, _variable.type()));
+}
+
+void SMTEncoder::assignment(VariableDeclaration const& _variable, smtutil::Expression const& _value)
+{
+	Type const* type = _variable.type();
+	if (type->category() == Type::Category::Mapping)
+		arrayAssignment();
+	assignment(*m_context.variable(_variable), _value);
+}
+
+void SMTEncoder::assignment(smt::SymbolicVariable& _symVar, smtutil::Expression const& _value)
+{
+	m_context.addAssertion(_symVar.increaseIndex() == _value);
+}
+
+std::pair<SMTEncoder::VariableIndices, smtutil::Expression> SMTEncoder::visitBranch(
+	ASTNode const* _statement,
+	smtutil::Expression _condition
+)
+{
+	return visitBranch(_statement, &_condition);
+}
+
+std::pair<SMTEncoder::VariableIndices, smtutil::Expression> SMTEncoder::visitBranch(
+	ASTNode const* _statement,
+	smtutil::Expression const* _condition
+)
+{
+	auto indicesBeforeBranch = copyVariableIndices();
+	if (_condition)
+		pushPathCondition(*_condition);
+	_statement->accept(*this);
+	auto pathConditionOnExit = currentPathConditions();
+	if (_condition)
+		popPathCondition();
+	auto indicesAfterBranch = copyVariableIndices();
+	resetVariableIndices(indicesBeforeBranch);
+	return {indicesAfterBranch, pathConditionOnExit};
+}
+
+void SMTEncoder::initializeFunctionCallParameters(CallableDeclaration const& _function, std::vector<smtutil::Expression> const& _callArgs)
+{
+	auto const& funParams = _function.parameters();
+	solAssert(funParams.size() == _callArgs.size(), "");
+	for (unsigned i = 0; i < funParams.size(); ++i)
+		if (createVariable(*funParams[i]))
+		{
+			m_context.addAssertion(_callArgs[i] == m_context.newValue(*funParams[i]));
+			if (funParams[i]->annotation().type->category() == Type::Category::Mapping)
+				m_arrayAssignmentHappened = true;
+		}
+
+	std::vector<VariableDeclaration const*> localVars;
+	if (auto const* fun = dynamic_cast<FunctionDefinition const*>(&_function))
+		localVars = localVariablesIncludingModifiers(*fun, m_currentContract);
+	else
+		localVars = _function.localVariables();
+	for (auto const& variable: localVars)
+		if (createVariable(*variable))
+		{
+			m_context.newValue(*variable);
+			m_context.setZeroValue(*variable);
+		}
+
+	if (_function.returnParameterList())
+		for (auto const& retParam: _function.returnParameters())
+			if (createVariable(*retParam))
+			{
+				m_context.newValue(*retParam);
+				m_context.setZeroValue(*retParam);
+			}
+}
+
+void SMTEncoder::createStateVariables(ContractDefinition const& _contract)
+{
+	for (auto var: stateVariablesIncludingInheritedAndPrivate(_contract))
+		createVariable(*var);
+}
+
+void SMTEncoder::initializeStateVariables(ContractDefinition const& _contract)
+{
+	for (auto var: _contract.stateVariables())
+	{
+		solAssert(m_context.knownVariable(*var), "");
+		m_context.setZeroValue(*var);
+	}
+
+	for (auto var: _contract.stateVariables())
+		if (var->value())
+		{
+			var->value()->accept(*this);
+			assignment(*var, *var->value());
+		}
+}
+
+void SMTEncoder::createLocalVariables(FunctionDefinition const& _function)
+{
+	for (auto const& variable: localVariablesIncludingModifiers(_function, m_currentContract))
+		createVariable(*variable);
+
+	for (auto const& param: _function.parameters())
+		createVariable(*param);
+
+	if (_function.returnParameterList())
+		for (auto const& retParam: _function.returnParameters())
+			createVariable(*retParam);
+}
+
+void SMTEncoder::initializeLocalVariables(FunctionDefinition const& _function)
+{
+	for (auto const& variable: localVariablesIncludingModifiers(_function, m_currentContract))
+	{
+		solAssert(m_context.knownVariable(*variable), "");
+		m_context.setZeroValue(*variable);
+	}
+
+	for (auto const& param: _function.parameters())
+	{
+		solAssert(m_context.knownVariable(*param), "");
+		m_context.setUnknownValue(*param);
+	}
+
+	if (_function.returnParameterList())
+		for (auto const& retParam: _function.returnParameters())
+		{
+			solAssert(m_context.knownVariable(*retParam), "");
+			m_context.setZeroValue(*retParam);
+		}
+}
+
+void SMTEncoder::resetStateVariables()
+{
+	m_context.resetVariables([&](VariableDeclaration const& _variable) { return _variable.isStateVariable(); });
+}
+
+void SMTEncoder::resetMemoryVariables()
+{
+	m_context.resetVariables([&](VariableDeclaration const& _variable) {
+		return _variable.referenceLocation() == VariableDeclaration::Location::Memory;
+	});
+}
+
+void SMTEncoder::resetStorageVariables()
+{
+	m_context.resetVariables([&](VariableDeclaration const& _variable) {
+		return _variable.referenceLocation() == VariableDeclaration::Location::Storage || _variable.isStateVariable();
+	});
+}
+
+void SMTEncoder::resetBalances()
+{
+	state().newBalances();
+}
+
+void SMTEncoder::resetReferences(VariableDeclaration const& _varDecl)
+{
+	m_context.resetVariables([&](VariableDeclaration const& _var) {
+		if (_var == _varDecl)
+			return false;
+
+		// If both are state variables no need to clear knowledge.
+		if (_var.isStateVariable() && _varDecl.isStateVariable())
+			return false;
+
+		return sameTypeOrSubtype(_var.type(), _varDecl.type());
+	});
+}
+
+void SMTEncoder::resetReferences(Type const* _type)
+{
+	m_context.resetVariables([&](VariableDeclaration const& _var) {
+		return sameTypeOrSubtype(_var.type(), _type);
+	});
+}
+
+bool SMTEncoder::sameTypeOrSubtype(Type const* _a, Type const* _b)
+{
+	bool foundSame = false;
+
+	solidity::util::BreadthFirstSearch<Type const*> bfs{{_a}};
+	bfs.run([&](auto _type, auto&& _addChild) {
+		if (*typeWithoutPointer(_b) == *typeWithoutPointer(_type))
+		{
+			foundSame = true;
+			bfs.abort();
+		}
+		if (auto const* mapType = dynamic_cast<MappingType const*>(_type))
+			_addChild(mapType->valueType());
+		else if (auto const* arrayType = dynamic_cast<ArrayType const*>(_type))
+			_addChild(arrayType->baseType());
+		else if (auto const* structType = dynamic_cast<StructType const*>(_type))
+			for (auto const& member: structType->nativeMembers(nullptr))
+				_addChild(member.type);
+	});
+
+	return foundSame;
+}
+
+bool SMTEncoder::isSupportedType(Type const& _type) const
+{
+	return smt::isSupportedType(*underlyingType(&_type));
+}
+
+Type const* SMTEncoder::typeWithoutPointer(Type const* _type)
+{
+	if (auto refType = dynamic_cast<ReferenceType const*>(_type))
+		return TypeProvider::withLocationIfReference(refType->location(), _type);
+	return _type;
+}
+
+void SMTEncoder::mergeVariables(smtutil::Expression const& _condition, VariableIndices const& _indicesEndTrue, VariableIndices const& _indicesEndFalse)
+{
+	for (auto const& entry: _indicesEndTrue)
+	{
+		VariableDeclaration const* var = entry.first;
+		auto trueIndex = entry.second;
+		if (_indicesEndFalse.count(var) && _indicesEndFalse.at(var) != trueIndex)
+		{
+			m_context.addAssertion(m_context.newValue(*var) == smtutil::Expression::ite(
+				_condition,
+				valueAtIndex(*var, trueIndex),
+				valueAtIndex(*var, _indicesEndFalse.at(var)))
+			);
+		}
+	}
+}
+
+smtutil::Expression SMTEncoder::currentValue(VariableDeclaration const& _decl) const
+{
+	solAssert(m_context.knownVariable(_decl), "");
+	return m_context.variable(_decl)->currentValue();
+}
+
+smtutil::Expression SMTEncoder::valueAtIndex(VariableDeclaration const& _decl, unsigned _index) const
+{
+	solAssert(m_context.knownVariable(_decl), "");
+	return m_context.variable(_decl)->valueAtIndex(_index);
+}
+
+bool SMTEncoder::createVariable(VariableDeclaration const& _varDecl)
+{
+	if (m_context.knownVariable(_varDecl))
+		return true;
+	bool abstract = m_context.createVariable(_varDecl);
+	if (abstract)
+	{
+		m_unsupportedErrors.warning(
+			8115_error,
+			_varDecl.location(),
+			"Assertion checker does not yet support the type of this variable."
+		);
+		return false;
+	}
+	return true;
+}
+
+smtutil::Expression SMTEncoder::expr(Expression const& _e, Type const* _targetType)
+{
+	if (!m_context.knownExpression(_e))
+	{
+		m_unsupportedErrors.warning(6031_error, _e.location(), "Internal error: Expression undefined for SMT solver." );
+		createExpr(_e);
+	}
+
+	return m_context.expression(_e)->currentValue(underlyingType(_targetType));
+}
+
+void SMTEncoder::createExpr(Expression const& _e)
+{
+	bool abstract = m_context.createExpression(_e);
+	if (abstract)
+		m_unsupportedErrors.warning(
+			8364_error,
+			_e.location(),
+			"Assertion checker does not yet implement type " + _e.annotation().type->toString()
+		);
+}
+
+void SMTEncoder::defineExpr(Expression const& _e, smtutil::Expression _value)
+{
+	auto type = _e.annotation().type;
+	createExpr(_e);
+	solAssert(_value.sort->kind != smtutil::Kind::Function, "Equality operator applied to type that is not fully supported");
+	if (!smt::isInaccessibleDynamic(*type))
+		m_context.addAssertion(expr(_e) == _value);
+
+	if (m_checked && smt::isNumber(*type))
+		m_context.addAssertion(smtutil::Expression::implies(
+			currentPathConditions(),
+			smt::symbolicUnknownConstraints(expr(_e), type)
+		));
+}
+
+void SMTEncoder::defineExpr(Expression const& _e, std::vector<std::optional<smtutil::Expression>> const& _values)
+{
+	if (_values.size() == 1 && _values.front())
+	{
+		defineExpr(_e, *_values.front());
+		return;
+	}
+	auto const& symbTuple = std::dynamic_pointer_cast<smt::SymbolicTupleVariable>(m_context.expression(_e));
+	solAssert(symbTuple, "");
+	symbTuple->increaseIndex();
+	auto const& symbComponents = symbTuple->components();
+	solAssert(symbComponents.size() == _values.size(), "");
+	auto tupleType = dynamic_cast<TupleType const*>(_e.annotation().type);
+	solAssert(tupleType, "");
+	solAssert(tupleType->components().size() == symbComponents.size(), "");
+	for (unsigned i = 0; i < symbComponents.size(); ++i)
+		if (_values[i] && !smt::isInaccessibleDynamic(*tupleType->components()[i]))
+			m_context.addAssertion(symbTuple->component(i) == *_values[i]);
+}
+
+void SMTEncoder::popPathCondition()
+{
+	solAssert(m_pathConditions.size() > 0, "Cannot pop path condition, empty.");
+	m_pathConditions.pop_back();
+}
+
+void SMTEncoder::pushPathCondition(smtutil::Expression const& _e)
+{
+	m_pathConditions.push_back(currentPathConditions() && _e);
+}
+
+void SMTEncoder::setPathCondition(smtutil::Expression const& _e)
+{
+	if (m_pathConditions.empty())
+		m_pathConditions.push_back(_e);
+	else
+		m_pathConditions.back() = _e;
+}
+
+smtutil::Expression SMTEncoder::currentPathConditions()
+{
+	if (m_pathConditions.empty())
+		return smtutil::Expression(true);
+	return m_pathConditions.back();
+}
+
+SecondarySourceLocation SMTEncoder::callStackMessage(std::vector<CallStackEntry> const& _callStack)
+{
+	SecondarySourceLocation callStackLocation;
+	solAssert(!_callStack.empty(), "");
+	callStackLocation.append("Callstack:", SourceLocation());
+	for (auto const& call: _callStack | ranges::views::reverse)
+		if (call.second)
+			callStackLocation.append("", call.second->location());
+	return callStackLocation;
+}
+
+std::pair<CallableDeclaration const*, ASTNode const*> SMTEncoder::popCallStack()
+{
+	solAssert(!m_callStack.empty(), "");
+	auto lastCalled = m_callStack.back();
+	m_callStack.pop_back();
+	return lastCalled;
+}
+
+void SMTEncoder::pushCallStack(CallStackEntry _entry)
+{
+	m_callStack.push_back(_entry);
+}
+
+void SMTEncoder::addPathImpliedExpression(smtutil::Expression const& _e)
+{
+	m_context.addAssertion(smtutil::Expression::implies(currentPathConditions(), _e));
+}
+
+bool SMTEncoder::isRootFunction()
+{
+	return m_callStack.size() == 1;
+}
+
+bool SMTEncoder::visitedFunction(FunctionDefinition const* _funDef)
+{
+	for (auto const& call: m_callStack)
+		if (call.first == _funDef)
+			return true;
+	return false;
+}
+
+ContractDefinition const* SMTEncoder::currentScopeContract()
+{
+	for (auto&& f: m_callStack | ranges::views::reverse | ranges::views::keys)
+		if (auto fun = dynamic_cast<FunctionDefinition const*>(f))
+			return fun->annotation().contract;
+	return nullptr;
+}
+
+SMTEncoder::VariableIndices SMTEncoder::copyVariableIndices()
+{
+	VariableIndices indices;
+	for (auto const& var: m_context.variables())
+		indices.emplace(var.first, var.second->index());
+	return indices;
+}
+
+void SMTEncoder::resetVariableIndices(VariableIndices const& _indices)
+{
+	for (auto const& var: _indices)
+		m_context.variable(*var.first)->setIndex(var.second);
+}
+
+void SMTEncoder::clearIndices(ContractDefinition const* _contract, FunctionDefinition const* _function)
+{
+	solAssert(_contract, "");
+	for (auto var: stateVariablesIncludingInheritedAndPrivate(*_contract))
+		m_context.variable(*var)->resetIndex();
+	if (_function)
+	{
+		for (auto const& var: _function->parameters() + _function->returnParameters())
+			m_context.variable(*var)->resetIndex();
+		for (auto const& var: localVariablesIncludingModifiers(*_function, _contract))
+			m_context.variable(*var)->resetIndex();
+	}
+	state().reset();
+}
+
+Expression const* SMTEncoder::leftmostBase(IndexAccess const& _indexAccess)
+{
+	Expression const* base = &_indexAccess.baseExpression();
+	while (auto access = dynamic_cast<IndexAccess const*>(base))
+		base = &access->baseExpression();
+	return base;
+}
+
+Type const* SMTEncoder::keyType(Type const* _type)
+{
+	if (auto const* mappingType = dynamic_cast<MappingType const*>(_type))
+		return mappingType->keyType();
+	if (
+		dynamic_cast<ArrayType const*>(_type) ||
+		dynamic_cast<ArraySliceType const*>(_type)
+	)
+		return TypeProvider::uint256();
+	else
+		solAssert(false, "");
+}
+
+Expression const* SMTEncoder::innermostTuple(Expression const& _expr)
+{
+	auto const* tuple = dynamic_cast<TupleExpression const*>(&_expr);
+	if (!tuple || tuple->isInlineArray())
+		return &_expr;
+
+	Expression const* expr = tuple;
+	while (tuple && !tuple->isInlineArray() && tuple->components().size() == 1)
+	{
+		expr = tuple->components().front().get();
+		tuple = dynamic_cast<TupleExpression const*>(expr);
+	}
+	solAssert(expr, "");
+	return expr;
+}
+
+Type const* SMTEncoder::underlyingType(Type const* _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		_type = &userType->underlyingType();
+	return _type;
+}
+
+TypePointers SMTEncoder::replaceUserTypes(TypePointers const& _types)
+{
+	return applyMap(_types, [](auto _type) {
+		if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+			return &userType->underlyingType();
+		return _type;
+	});
+}
+
+std::pair<Expression const*, FunctionCallOptions const*> SMTEncoder::functionCallExpression(FunctionCall const& _funCall)
+{
+	Expression const* callExpr = &_funCall.expression();
+	auto const* callOptions = dynamic_cast<FunctionCallOptions const*>(callExpr);
+	if (callOptions)
+		callExpr = &callOptions->expression();
+
+	return {callExpr, callOptions};
+}
+
+Expression const* SMTEncoder::cleanExpression(Expression const& _expr)
+{
+	auto const* expr = &_expr;
+	if (auto const* tuple = dynamic_cast<TupleExpression const*>(expr))
+		return cleanExpression(*innermostTuple(*tuple));
+	if (auto const* functionCall = dynamic_cast<FunctionCall const*>(expr))
+		if (*functionCall->annotation().kind == FunctionCallKind::TypeConversion)
+		{
+			auto typeType = dynamic_cast<TypeType const*>(functionCall->expression().annotation().type);
+			solAssert(typeType, "");
+			if (auto const* arrayType = dynamic_cast<ArrayType const*>(typeType->actualType()))
+				if (arrayType->isByteArrayOrString())
+				{
+					// this is a cast to `bytes`
+					solAssert(functionCall->arguments().size() == 1, "");
+					Expression const& arg = *functionCall->arguments()[0];
+					if (
+						auto const* argArrayType = dynamic_cast<ArrayType const*>(arg.annotation().type);
+						argArrayType && argArrayType->isByteArrayOrString()
+					)
+						return cleanExpression(arg);
+				}
+		}
+	solAssert(expr, "");
+	return expr;
+}
+
+std::set<VariableDeclaration const*> SMTEncoder::touchedVariables(ASTNode const& _node)
+{
+	std::vector<CallableDeclaration const*> callStack;
+	for (auto const& call: m_callStack)
+		callStack.push_back(call.first);
+	return m_variableUsage.touchedVariables(_node, callStack);
+}
+
+Declaration const* SMTEncoder::expressionToDeclaration(Expression const& _expr) const
+{
+	if (auto const* identifier = dynamic_cast<Identifier const*>(&_expr))
+		return identifier->annotation().referencedDeclaration;
+	if (auto const* outerMemberAccess = dynamic_cast<MemberAccess const*>(&_expr))
+		return outerMemberAccess->annotation().referencedDeclaration;
+	return nullptr;
+}
+
+VariableDeclaration const* SMTEncoder::identifierToVariable(Expression const& _expr) const
+{
+	// We do not use `expressionToDeclaration` here because we are not interested in
+	// struct.field, for example.
+	if (auto const* identifier = dynamic_cast<Identifier const*>(&_expr))
+		if (auto const* varDecl = dynamic_cast<VariableDeclaration const*>(identifier->annotation().referencedDeclaration))
+		{
+			solAssert(m_context.knownVariable(*varDecl), "");
+			return varDecl;
+		}
+	// But we are interested in "contract.var", because that is the same as just "var".
+	if (auto const* memberAccess = dynamic_cast<MemberAccess const*>(&_expr))
+		if (dynamic_cast<ContractDefinition const*>(expressionToDeclaration(
+			*cleanExpression(memberAccess->expression())
+		)))
+			if (auto const* varDecl = dynamic_cast<VariableDeclaration const*>(memberAccess->annotation().referencedDeclaration))
+			{
+				solAssert(m_context.knownVariable(*varDecl), "");
+				return varDecl;
+			}
+
+	return nullptr;
+}
+
+MemberAccess const* SMTEncoder::isEmptyPush(Expression const& _expr) const
+{
+	if (
+		auto const* funCall = dynamic_cast<FunctionCall const*>(&_expr);
+		funCall && funCall->arguments().empty()
+	)
+	{
+		auto const& funType = dynamic_cast<FunctionType const&>(*funCall->expression().annotation().type);
+		if (funType.kind() == FunctionType::Kind::ArrayPush)
+			return &dynamic_cast<MemberAccess const&>(funCall->expression());
+	}
+	return nullptr;
+}
+
+smtutil::Expression SMTEncoder::contractAddressValue(FunctionCall const& _f)
+{
+	FunctionType const& funType = dynamic_cast<FunctionType const&>(*_f.expression().annotation().type);
+	if (funType.kind() == FunctionType::Kind::Internal)
+		return state().thisAddress();
+	auto [funExpr, funOptions] = functionCallExpression(_f);
+	if (MemberAccess const* callBase = dynamic_cast<MemberAccess const*>(funExpr))
+		return expr(callBase->expression());
+	solAssert(false, "Unreachable!");
+}
+
+VariableDeclaration const* SMTEncoder::publicGetter(Expression const& _expr) const {
+	if (auto memberAccess = dynamic_cast<MemberAccess const*>(&_expr))
+		if (auto variableDeclaration = dynamic_cast<VariableDeclaration const*>(memberAccess->annotation().referencedDeclaration))
+			return variableDeclaration->isStateVariable() ? variableDeclaration : nullptr;
+	return nullptr;
+}
+
+bool SMTEncoder::isExternalCallToThis(Expression const* _expr) {
+	auto memberAccess = dynamic_cast<MemberAccess const*>(_expr);
+	if (!memberAccess)
+		return false;
+
+	auto identifier = dynamic_cast<Identifier const*>(&memberAccess->expression());
+	return identifier &&
+		identifier->name() == "this" &&
+		identifier->annotation().referencedDeclaration &&
+		dynamic_cast<MagicVariableDeclaration const*>(identifier->annotation().referencedDeclaration)
+	;
+}
+
+std::string SMTEncoder::extraComment()
+{
+	std::string extra;
+	if (m_arrayAssignmentHappened)
+		extra +=
+			"\nNote that array aliasing is not supported,"
+			" therefore all mapping information is erased after"
+			" a mapping local variable/parameter is assigned.\n"
+			"You can re-introduce information using require().";
+	return extra;
+}
+
+FunctionDefinition const* SMTEncoder::functionCallToDefinition(
+	FunctionCall const& _funCall,
+	ContractDefinition const* _scopeContract,
+	ContractDefinition const* _contextContract
+)
+{
+	if (*_funCall.annotation().kind != FunctionCallKind::FunctionCall)
+		return {};
+
+	auto [calledExpr, callOptions] = functionCallExpression(_funCall);
+
+	if (TupleExpression const* fun = dynamic_cast<TupleExpression const*>(calledExpr))
+	{
+		solAssert(fun->components().size() == 1, "");
+		calledExpr = innermostTuple(*calledExpr);
+	}
+
+	auto resolveVirtual = [&](auto const* _ref) -> FunctionDefinition const* {
+		VirtualLookup lookup = *_ref->annotation().requiredLookup;
+		solAssert(_contextContract || lookup == VirtualLookup::Static, "No contract context provided for function lookup resolution!");
+		auto funDef = dynamic_cast<FunctionDefinition const*>(_ref->annotation().referencedDeclaration);
+		if (!funDef)
+			return funDef;
+		switch (lookup)
+		{
+		case VirtualLookup::Virtual:
+			return &(funDef->resolveVirtual(*_contextContract));
+		case VirtualLookup::Super:
+		{
+			solAssert(_scopeContract, "");
+			auto super = _scopeContract->superContract(*_contextContract);
+			solAssert(super, "Super contract not available.");
+			return &funDef->resolveVirtual(*_contextContract, super);
+		}
+		case VirtualLookup::Static:
+			return funDef;
+		}
+		solAssert(false, "");
+	};
+
+	if (Identifier const* fun = dynamic_cast<Identifier const*>(calledExpr))
+		return resolveVirtual(fun);
+	else if (MemberAccess const* fun = dynamic_cast<MemberAccess const*>(calledExpr))
+		return resolveVirtual(fun);
+
+	return {};
+}
+
+std::vector<VariableDeclaration const*> SMTEncoder::stateVariablesIncludingInheritedAndPrivate(ContractDefinition const& _contract)
+{
+	return fold(
+		_contract.annotation().linearizedBaseContracts,
+		std::vector<VariableDeclaration const*>{},
+		[](auto&& _acc, auto _contract) { return _acc + _contract->stateVariables(); }
+	);
+}
+
+std::vector<VariableDeclaration const*> SMTEncoder::stateVariablesIncludingInheritedAndPrivate(FunctionDefinition const& _function)
+{
+	if (auto contract = dynamic_cast<ContractDefinition const*>(_function.scope()))
+		return stateVariablesIncludingInheritedAndPrivate(*contract);
+	return {};
+}
+
+std::vector<VariableDeclaration const*> SMTEncoder::localVariablesIncludingModifiers(FunctionDefinition const& _function, ContractDefinition const* _contract)
+{
+	return _function.localVariables() + tryCatchVariables(_function) + modifiersVariables(_function, _contract);
+}
+
+std::vector<VariableDeclaration const*> SMTEncoder::tryCatchVariables(FunctionDefinition const& _function)
+{
+	struct TryCatchVarsVisitor : public ASTConstVisitor
+	{
+		bool visit(TryCatchClause const& _catchClause) override
+		{
+			if (_catchClause.parameters())
+			{
+				auto const& params = _catchClause.parameters()->parameters();
+				for (auto param: params)
+					vars.push_back(param.get());
+			}
+
+			return true;
+		}
+
+		std::vector<VariableDeclaration const*> vars;
+	} tryCatchVarsVisitor;
+	_function.accept(tryCatchVarsVisitor);
+	return tryCatchVarsVisitor.vars;
+}
+
+std::vector<VariableDeclaration const*> SMTEncoder::modifiersVariables(FunctionDefinition const& _function, ContractDefinition const* _contract)
+{
+	struct BlockVars: ASTConstVisitor
+	{
+		BlockVars(Block const& _block) { _block.accept(*this); }
+		void endVisit(VariableDeclaration const& _var) { vars.push_back(&_var); }
+		std::vector<VariableDeclaration const*> vars;
+	};
+
+	std::vector<VariableDeclaration const*> vars;
+	std::set<ModifierDefinition const*> visited;
+	for (auto invok: _function.modifiers())
+	{
+		if (!invok)
+			continue;
+		auto const* modifier = resolveModifierInvocation(*invok, _contract);
+		if (!modifier || visited.count(modifier))
+			continue;
+
+		visited.insert(modifier);
+		if (modifier->isImplemented())
+		{
+			vars += applyMap(modifier->parameters(), [](auto _var) { return _var.get(); });
+			vars += BlockVars(modifier->body()).vars;
+		}
+	}
+	return vars;
+}
+
+ModifierDefinition const* SMTEncoder::resolveModifierInvocation(ModifierInvocation const& _invocation, ContractDefinition const* _contract)
+{
+	auto const* modifier = dynamic_cast<ModifierDefinition const*>(_invocation.name().annotation().referencedDeclaration);
+	if (modifier)
+	{
+		VirtualLookup lookup = *_invocation.name().annotation().requiredLookup;
+		solAssert(lookup == VirtualLookup::Virtual || lookup == VirtualLookup::Static, "");
+		solAssert(_contract || lookup == VirtualLookup::Static, "No contract context provided for modifier lookup resolution!");
+		if (lookup == VirtualLookup::Virtual)
+			modifier = &modifier->resolveVirtual(*_contract);
+	}
+	return modifier;
+}
+
+std::set<FunctionDefinition const*, ASTNode::CompareByID> const& SMTEncoder::contractFunctions(ContractDefinition const& _contract)
+{
+	if (!m_contractFunctions.count(&_contract))
+	{
+		auto const& functions = _contract.definedFunctions();
+		std::set<FunctionDefinition const*, ASTNode::CompareByID> resolvedFunctions(begin(functions), end(functions));
+		for (auto const* base: _contract.annotation().linearizedBaseContracts)
+		{
+			if (base == &_contract)
+				continue;
+			for (auto const* baseFunction: base->definedFunctions())
+			{
+				if (baseFunction->isConstructor()) // We don't want to include constructors of parent contracts
+					continue;
+				bool overridden = false;
+				for (auto const* function: resolvedFunctions)
+					if (
+						function->name() == baseFunction->name() &&
+						function->kind() == baseFunction->kind() &&
+						FunctionType(*function).asExternallyCallableFunction(false)->
+							hasEqualParameterTypes(*FunctionType(*baseFunction).asExternallyCallableFunction(false))
+						)
+					{
+						overridden = true;
+						break;
+					}
+				if (!overridden)
+					resolvedFunctions.insert(baseFunction);
+			}
+		}
+		m_contractFunctions.emplace(&_contract, std::move(resolvedFunctions));
+	}
+	return m_contractFunctions.at(&_contract);
+}
+
+std::set<FunctionDefinition const*, ASTNode::CompareByID> const& SMTEncoder::contractFunctionsWithoutVirtual(ContractDefinition const& _contract)
+{
+	if (!m_contractFunctionsWithoutVirtual.count(&_contract))
+	{
+		auto allFunctions = contractFunctions(_contract);
+		for (auto const* base: _contract.annotation().linearizedBaseContracts)
+			for (auto const* baseFun: base->definedFunctions())
+				allFunctions.insert(baseFun);
+
+		m_contractFunctionsWithoutVirtual.emplace(&_contract, std::move(allFunctions));
+
+	}
+	return m_contractFunctionsWithoutVirtual.at(&_contract);
+}
+
+std::map<ContractDefinition const*, std::vector<ASTPointer<frontend::Expression>>> SMTEncoder::baseArguments(ContractDefinition const& _contract)
+{
+	std::map<ContractDefinition const*, std::vector<ASTPointer<Expression>>> baseArgs;
+
+	for (auto contract: _contract.annotation().linearizedBaseContracts)
+	{
+		/// Collect base contracts and potential constructor arguments.
+		for (auto specifier: contract->baseContracts())
+		{
+			solAssert(specifier, "");
+			auto const& base = dynamic_cast<ContractDefinition const&>(*specifier->name().annotation().referencedDeclaration);
+			if (auto args = specifier->arguments())
+				baseArgs[&base] = *args;
+		}
+		/// Collect base constructor arguments given as constructor modifiers.
+		if (auto constructor = contract->constructor())
+			for (auto mod: constructor->modifiers())
+			{
+				auto decl = mod->name().annotation().referencedDeclaration;
+				if (auto base = dynamic_cast<ContractDefinition const*>(decl))
+				{
+					solAssert(!baseArgs.count(base), "");
+					if (auto args = mod->arguments())
+						baseArgs[base] = *args;
+				}
+			}
+	}
+
+	return baseArgs;
+}
+
+RationalNumberType const* SMTEncoder::isConstant(Expression const& _expr)
+{
+	if (auto type = dynamic_cast<RationalNumberType const*>(_expr.annotation().type))
+		return type;
+
+	// _expr may not be constant evaluable.
+	// In that case we ignore any warnings emitted by the constant evaluator,
+	// as it will return nullptr in case of failure.
+	ErrorList l;
+	ErrorReporter e(l);
+	if (auto t = ConstantEvaluator::evaluate(e, _expr))
+		return TypeProvider::rationalNumber(t->value);
+
+	return nullptr;
+}
+
+std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> SMTEncoder::collectABICalls(ASTNode const* _node)
+{
+	struct ABIFunctions: public ASTConstVisitor
+	{
+		ABIFunctions(ASTNode const* _node) { _node->accept(*this); }
+		void endVisit(FunctionCall const& _funCall)
+		{
+			if (*_funCall.annotation().kind == FunctionCallKind::FunctionCall)
+				switch (dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type).kind())
+				{
+				case FunctionType::Kind::ABIEncode:
+				case FunctionType::Kind::ABIEncodePacked:
+				case FunctionType::Kind::ABIEncodeWithSelector:
+				case FunctionType::Kind::ABIEncodeCall:
+				case FunctionType::Kind::ABIEncodeWithSignature:
+				case FunctionType::Kind::ABIDecode:
+					abiCalls.insert(&_funCall);
+					break;
+				default: {}
+				}
+		}
+
+		std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> abiCalls;
+	};
+
+	return ABIFunctions(_node).abiCalls;
+}
+
+std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> SMTEncoder::collectBytesConcatCalls(ASTNode const* _node)
+{
+	struct BytesConcatFunctions: public ASTConstVisitor
+	{
+		BytesConcatFunctions(ASTNode const* _node) { _node->accept(*this); }
+		void endVisit(FunctionCall const& _funCall)
+		{
+			if (*_funCall.annotation().kind == FunctionCallKind::FunctionCall)
+				switch (dynamic_cast<FunctionType const&>(*_funCall.expression().annotation().type).kind())
+				{
+				case FunctionType::Kind::BytesConcat:
+					bytesConcatCalls.insert(&_funCall);
+					break;
+				default: {}
+				}
+		}
+
+		std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> bytesConcatCalls;
+	};
+
+	return BytesConcatFunctions(_node).bytesConcatCalls;
+}
+
+std::set<SourceUnit const*, ASTNode::CompareByID> SMTEncoder::sourceDependencies(SourceUnit const& _source)
+{
+	std::set<SourceUnit const*, ASTNode::CompareByID> sources;
+	sources.insert(&_source);
+	for (auto const& source: _source.referencedSourceUnits(true))
+		sources.insert(source);
+	return sources;
+}
+
+void SMTEncoder::createReturnedExpressions(FunctionDefinition const* _funDef, Expression const& _callStackExpr)
+{
+	if (!_funDef)
+		return;
+
+	auto const& returnParams = _funDef->returnParameters();
+	for (auto param: returnParams)
+		createVariable(*param);
+	auto returnValues = applyMap(returnParams, [this](auto const& param) -> std::optional<smtutil::Expression> {
+		solAssert(param && m_context.knownVariable(*param), "");
+		return currentValue(*param);
+	});
+	defineExpr(_callStackExpr, returnValues);
+}
+
+std::vector<smtutil::Expression> SMTEncoder::symbolicArguments(
+	std::vector<ASTPointer<VariableDeclaration>> const& _funParameters,
+	std::vector<Expression const*> const& _arguments,
+	std::optional<Expression const*> _boundArgumentCall
+)
+{
+	std::vector<smtutil::Expression> args;
+	unsigned firstParam = 0;
+	if (_boundArgumentCall)
+	{
+		Expression const* calledExpr = innermostTuple(*_boundArgumentCall.value());
+		auto const& attachedFunction = dynamic_cast<MemberAccess const*>(calledExpr);
+		solAssert(attachedFunction, "");
+		args.push_back(expr(attachedFunction->expression(), _funParameters.front()->type()));
+		firstParam = 1;
+	}
+
+	solAssert((_arguments.size() + firstParam) == _funParameters.size(), "");
+
+	for (unsigned i = 0; i < _arguments.size(); ++i)
+		args.push_back(expr(*_arguments.at(i), _funParameters.at(i + firstParam)->type()));
+
+	return args;
+}
+
+smtutil::Expression SMTEncoder::constantExpr(Expression const& _expr, VariableDeclaration const& _var)
+{
+	if (RationalNumberType const* rationalType = isConstant(_expr))
+	{
+		if (rationalType->isNegative())
+			return smtutil::Expression(u2s(rationalType->literalValue(nullptr)));
+		else
+			return smtutil::Expression(rationalType->literalValue(nullptr));
+	}
+	else
+	{
+		solAssert(_var.value(), "");
+		_var.value()->accept(*this);
+		return expr(*_var.value(), _expr.annotation().type);
+	}
+	solAssert(false, "");
+}
+
+void SMTEncoder::collectFreeFunctions(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources)
+{
+	for (auto source: _sources)
+		for (auto node: source->nodes())
+			if (auto function = dynamic_cast<FunctionDefinition const*>(node.get()))
+				m_freeFunctions.insert(function);
+			else if (
+				auto contract = dynamic_cast<ContractDefinition const*>(node.get());
+				contract && contract->isLibrary()
+			)
+				for (auto function: contract->definedFunctions())
+					// We need to add public library functions too because they can be called
+					// internally by internal library functions that are considered free functions.
+					m_freeFunctions.insert(function);
+}
+
+void SMTEncoder::createFreeConstants(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources)
+{
+	for (auto source: _sources)
+		for (auto node: source->nodes())
+			if (auto var = dynamic_cast<VariableDeclaration const*>(node.get()))
+				createVariable(*var);
+			else if (
+				auto contract = dynamic_cast<ContractDefinition const*>(node.get());
+				contract && contract->isLibrary()
+			)
+				for (auto var: contract->stateVariables())
+				{
+					solAssert(var->isConstant(), "");
+					createVariable(*var);
+				}
+}
+
+smt::SymbolicState& SMTEncoder::state()
+{
+	return m_context.state();
+}
+
+smtutil::Expression SMTEncoder::createSelectExpressionForFunction(
+	smtutil::Expression symbFunction,
+	std::vector<frontend::ASTPointer<frontend::Expression const>> const& args,
+	frontend::TypePointers const& inTypes,
+	unsigned long argsActualLength
+)
+{
+	solAssert(argsActualLength <= args.size() && inTypes.size() == argsActualLength);
+	if (inTypes.size() == 1)
+	{
+		smtutil::Expression arg = expr(*args.at(0), inTypes.at(0));
+		return smtutil::Expression::select(symbFunction, arg);
+	}
+
+	std::vector<smtutil::Expression> symbArgs;
+	for (unsigned i = 0; i < argsActualLength; ++i)
+		if (args.at(i))
+			symbArgs.emplace_back(expr(*args.at(i), inTypes.at(i)));
+
+	auto inputSort = dynamic_cast<smtutil::ArraySort&>(*symbFunction.sort).domain;
+	smtutil::Expression arg = smtutil::Expression::tuple_constructor(
+		smtutil::Expression(std::make_shared<smtutil::SortSort>(inputSort), ""),
+		symbArgs
+	);
+	return smtutil::Expression::select(symbFunction, arg);
+}
diff --git a/compiler/libsolidity/formal/SMTEncoder.h b/compiler/libsolidity/formal/SMTEncoder.h
new file mode 100644
index 00000000..be676930
--- /dev/null
+++ b/compiler/libsolidity/formal/SMTEncoder.h
@@ -0,0 +1,515 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Encodes Solidity into SMT expressions without creating
+ * any verification targets.
+ * Also implements the SSA scheme for branches.
+ */
+
+#pragma once
+
+
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/ModelCheckerSettings.h>
+#include <libsolidity/formal/SymbolicVariables.h>
+#include <libsolidity/formal/VariableUsage.h>
+
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/interface/ReadFile.h>
+#include <liblangutil/UniqueErrorReporter.h>
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <utility>
+
+namespace solidity::langutil
+{
+class ErrorReporter;
+struct SourceLocation;
+class CharStreamProvider;
+}
+
+namespace solidity::frontend
+{
+
+class SMTEncoder: public ASTConstVisitor
+{
+public:
+	SMTEncoder(
+		smt::EncodingContext& _context,
+		ModelCheckerSettings _settings,
+		langutil::UniqueErrorReporter& _errorReporter,
+		langutil::UniqueErrorReporter& _unsupportedErrorReporter,
+		langutil::CharStreamProvider const& _charStreamProvider
+	);
+
+	/// @returns the leftmost identifier in a multi-d IndexAccess.
+	static Expression const* leftmostBase(IndexAccess const& _indexAccess);
+
+	/// @returns the key type in _type.
+	/// _type must allow IndexAccess, that is,
+	/// it must be either ArrayType or MappingType
+	static Type const* keyType(Type const* _type);
+
+	/// @returns the innermost element in a chain of 1-tuples if applicable,
+	/// otherwise _expr.
+	static Expression const* innermostTuple(Expression const& _expr);
+
+	/// @returns the underlying type if _type is UserDefinedValueType,
+	/// and _type otherwise.
+	static Type const* underlyingType(Type const* _type);
+
+	static TypePointers replaceUserTypes(TypePointers const& _types);
+
+	/// @returns {_funCall.expression(), nullptr} if function call option values are not given, and
+	/// {_funCall.expression().expression(), _funCall.expression()} if they are.
+	static std::pair<Expression const*, FunctionCallOptions const*> functionCallExpression(FunctionCall const& _funCall);
+
+	/// @returns the expression after stripping redundant syntactic sugar.
+	/// Currently supports stripping:
+	/// 1. 1-tuple; i.e. ((x)) -> x
+	/// 2. Explicit cast from string to bytes; i.e. bytes(s) -> s; for s of type string
+	static Expression const* cleanExpression(Expression const& _expr);
+
+	/// @returns the FunctionDefinition of a FunctionCall
+	/// if possible or nullptr.
+	/// @param _scopeContract is the contract that contains the function currently being
+	///        analyzed, if applicable.
+	/// @param _contextContract is the most derived contract currently being analyzed.
+	/// The difference between the two parameters appears in the case of inheritance.
+	/// Let A and B be two contracts so that B derives from A, and A defines a function `f`
+	/// that `B` does not override. Function `f` is visited twice:
+	/// - Once when A is the most derived contract, where both _scopeContract and _contextContract are A.
+	/// - Once when B is the most derived contract, where _scopeContract is A and _contextContract is B.
+	static FunctionDefinition const* functionCallToDefinition(
+		FunctionCall const& _funCall,
+		ContractDefinition const* _scopeContract,
+		ContractDefinition const* _contextContract
+	);
+
+	static std::vector<VariableDeclaration const*> stateVariablesIncludingInheritedAndPrivate(ContractDefinition const& _contract);
+	static std::vector<VariableDeclaration const*> stateVariablesIncludingInheritedAndPrivate(FunctionDefinition const& _function);
+
+	static std::vector<VariableDeclaration const*> localVariablesIncludingModifiers(FunctionDefinition const& _function, ContractDefinition const* _contract);
+	static std::vector<VariableDeclaration const*> modifiersVariables(FunctionDefinition const& _function, ContractDefinition const* _contract);
+	static std::vector<VariableDeclaration const*> tryCatchVariables(FunctionDefinition const& _function);
+
+	/// @returns the ModifierDefinition of a ModifierInvocation if possible, or nullptr.
+	static ModifierDefinition const* resolveModifierInvocation(ModifierInvocation const& _invocation, ContractDefinition const* _contract);
+
+	/// @returns the arguments for each base constructor call in the hierarchy of @a _contract.
+	std::map<ContractDefinition const*, std::vector<ASTPointer<frontend::Expression>>> baseArguments(ContractDefinition const& _contract);
+
+	/// @returns a valid RationalNumberType pointer if _expr has type
+	/// RationalNumberType or can be const evaluated, and nullptr otherwise.
+	static RationalNumberType const* isConstant(Expression const& _expr);
+
+	static std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> collectABICalls(ASTNode const* _node);
+	static std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> collectBytesConcatCalls(ASTNode const* _node);
+
+	/// @returns all the sources that @param _source depends on,
+	/// including itself.
+	static std::set<SourceUnit const*, ASTNode::CompareByID> sourceDependencies(SourceUnit const& _source);
+
+protected:
+	void resetSourceAnalysis();
+
+	// TODO: Check that we do not have concurrent reads and writes to a variable,
+	// because the order of expression evaluation is undefined
+	// TODO: or just force a certain order, but people might have a different idea about that.
+
+	bool visit(ImportDirective const& _node) override;
+	bool visit(ContractDefinition const& _node) override;
+	void endVisit(ContractDefinition const& _node) override;
+	void endVisit(VariableDeclaration const& _node) override;
+	bool visit(ModifierDefinition const& _node) override;
+	bool visit(FunctionDefinition const& _node) override;
+	void endVisit(FunctionDefinition const& _node) override;
+	bool visit(Block const& _node) override;
+	void endVisit(Block const& _node) override;
+	bool visit(PlaceholderStatement const& _node) override;
+	bool visit(IfStatement const&) override { return false; }
+	bool visit(WhileStatement const&) override { return false; }
+	bool visit(ForStatement const&) override { return false; }
+	void endVisit(ForStatement const&) override {}
+	void endVisit(VariableDeclarationStatement const& _node) override;
+	bool visit(Assignment const& _node) override;
+	void endVisit(Assignment const& _node) override;
+	void endVisit(TupleExpression const& _node) override;
+	bool visit(UnaryOperation const& _node) override;
+	void endVisit(UnaryOperation const& _node) override;
+	bool visit(BinaryOperation const& _node) override;
+	void endVisit(BinaryOperation const& _node) override;
+	bool visit(Conditional const& _node) override;
+	bool visit(FunctionCall const& _node) override;
+	void endVisit(FunctionCall const& _node) override;
+	bool visit(ModifierInvocation const& _node) override;
+	void endVisit(Identifier const& _node) override;
+	void endVisit(ElementaryTypeNameExpression const& _node) override;
+	void endVisit(Literal const& _node) override;
+	void endVisit(Return const& _node) override;
+	bool visit(MemberAccess const& _node) override;
+	void endVisit(IndexAccess const& _node) override;
+	void endVisit(IndexRangeAccess const& _node) override;
+	bool visit(InlineAssembly const& _node) override;
+	bool visit(Break const&) override { return false; }
+	void endVisit(Break const&) override {}
+	bool visit(Continue const&) override { return false; }
+	void endVisit(Continue const&) override {}
+	bool visit(TryCatchClause const&) override { return true; }
+	void endVisit(TryCatchClause const&) override {}
+	bool visit(TryStatement const&) override { return false; }
+
+	virtual void pushInlineFrame(CallableDeclaration const&);
+	virtual void popInlineFrame(CallableDeclaration const&);
+
+	/// Do not visit subtree if node is a RationalNumber.
+	/// Symbolic _expr is the rational literal.
+	bool shortcutRationalNumber(Expression const& _expr);
+	void arithmeticOperation(BinaryOperation const& _op);
+	/// @returns _op(_left, _right) with and without modular arithmetic.
+	/// Used by the function above, compound assignments and
+	/// unary increment/decrement.
+	virtual std::pair<smtutil::Expression, smtutil::Expression> arithmeticOperation(
+		Token _op,
+		smtutil::Expression const& _left,
+		smtutil::Expression const& _right,
+		Type const* _commonType,
+		Expression const& _expression
+	);
+
+	smtutil::Expression bitwiseOperation(
+		Token _op,
+		smtutil::Expression const& _left,
+		smtutil::Expression const& _right,
+		Type const* _commonType
+	);
+
+	void compareOperation(BinaryOperation const& _op);
+	void booleanOperation(BinaryOperation const& _op);
+	void bitwiseOperation(BinaryOperation const& _op);
+	void bitwiseNotOperation(UnaryOperation const& _op);
+
+	void initContract(ContractDefinition const& _contract);
+	void initFunction(FunctionDefinition const& _function);
+	void visitAssert(FunctionCall const& _funCall);
+	void visitRequire(FunctionCall const& _funCall);
+	void visitABIFunction(FunctionCall const& _funCall);
+	void visitBytesConcat(FunctionCall const& _funCall);
+	void visitCryptoFunction(FunctionCall const& _funCall);
+	void visitGasLeft(FunctionCall const& _funCall);
+	virtual void visitAddMulMod(FunctionCall const& _funCall);
+	void visitWrapUnwrap(FunctionCall const& _funCall);
+	void visitObjectCreation(FunctionCall const& _funCall);
+	void visitTypeConversion(FunctionCall const& _funCall);
+	void visitStructConstructorCall(FunctionCall const& _funCall);
+	void visitFunctionIdentifier(Identifier const& _identifier);
+	virtual void visitPublicGetter(FunctionCall const& _funCall);
+
+	/// @returns true if @param _contract is set for analysis in the settings
+	/// and it is not abstract.
+	bool shouldAnalyze(ContractDefinition const& _contract) const;
+	/// @returns true if @param _source is set for analysis in the settings.
+	bool shouldAnalyze(SourceUnit const& _source) const;
+
+	/// @returns the state variable returned by a public getter if
+	/// @a _expr is a call to a public getter,
+	/// otherwise nullptr.
+	VariableDeclaration const* publicGetter(Expression const& _expr) const;
+
+	smtutil::Expression contractAddressValue(FunctionCall const& _f);
+
+	/// Encodes a modifier or function body according to the modifier
+	/// visit depth.
+	void visitFunctionOrModifier();
+
+	/// Inlines a modifier or base constructor call.
+	void inlineModifierInvocation(ModifierInvocation const* _invocation, CallableDeclaration const* _definition);
+
+	/// Inlines the constructor hierarchy into a single constructor.
+	void inlineConstructorHierarchy(ContractDefinition const& _contract);
+
+	/// Defines a new global variable or function.
+	void defineGlobalVariable(std::string const& _name, Expression const& _expr, bool _increaseIndex = false);
+
+	/// Handles the side effects of assignment
+	/// to variable of some SMT array type
+	/// while aliasing is not supported.
+	void arrayAssignment();
+	/// Handles assignments to index or member access.
+	void indexOrMemberAssignment(Expression const& _expr, smtutil::Expression const& _rightHandSide);
+
+	void arrayPush(FunctionCall const& _funCall);
+	void arrayPop(FunctionCall const& _funCall);
+	/// Allows BMC and CHC to create verification targets for popping
+	/// an empty array.
+	virtual void makeArrayPopVerificationTarget(FunctionCall const&) {}
+	/// Allows BMC and CHC to create verification targets for out of bounds access.
+	virtual void makeOutOfBoundsVerificationTarget(IndexAccess const&) {}
+
+	void addArrayLiteralAssertions(
+		smt::SymbolicArrayVariable& _symArray,
+		std::vector<smtutil::Expression> const& _elementValues
+	);
+
+	void bytesToFixedBytesAssertions(
+		smt::SymbolicArrayVariable& _symArray,
+		Expression const& _fixedBytes
+	);
+
+	/// @returns a pair of expressions representing _left / _right and _left mod _right, respectively.
+	/// Uses slack variables and additional constraints to express the results using only operations
+	/// more friendly to the SMT solver (multiplication, addition, subtraction and comparison).
+	std::pair<smtutil::Expression, smtutil::Expression>	divModWithSlacks(
+		smtutil::Expression _left,
+		smtutil::Expression _right,
+		IntegerType const& _type
+	);
+
+	/// Handles the actual assertion of the new value to the encoding context.
+	/// Other assignment methods should use this one in the end.
+	virtual void assignment(smt::SymbolicVariable& _symVar, smtutil::Expression const& _value);
+
+	void assignment(VariableDeclaration const& _variable, Expression const& _value);
+	/// Handles assignments to variables of different types.
+	void assignment(VariableDeclaration const& _variable, smtutil::Expression const& _value);
+	/// Handles assignments between generic expressions.
+	/// Will also be used for assignments of tuple components.
+	void assignment(Expression const& _left, smtutil::Expression const& _right);
+	void assignment(
+		Expression const& _left,
+		smtutil::Expression const& _right,
+		Type const* _type
+	);
+	/// Handle assignments between tuples.
+	void tupleAssignment(Expression const& _left, Expression const& _right);
+	/// Computes the right hand side of a compound assignment.
+	smtutil::Expression compoundAssignment(Assignment const& _assignment);
+	/// Handles assignment of an expression to a tuple of variables.
+	void expressionToTupleAssignment(std::vector<std::shared_ptr<VariableDeclaration>> const& _variables, Expression const& _rhs);
+
+	/// Maps a variable to an SSA index.
+	using VariableIndices = std::unordered_map<VariableDeclaration const*, unsigned>;
+
+	/// Visits the branch given by the statement, pushes and pops the current path conditions.
+	/// @param _condition if present, asserts that this condition is true within the branch.
+	/// @returns the variable indices after visiting the branch and the expression representing
+	/// the path condition at the end of the branch.
+	std::pair<VariableIndices, smtutil::Expression> visitBranch(ASTNode const* _statement, smtutil::Expression const* _condition = nullptr);
+	std::pair<VariableIndices, smtutil::Expression> visitBranch(ASTNode const* _statement, smtutil::Expression _condition);
+
+	using CallStackEntry = std::pair<CallableDeclaration const*, ASTNode const*>;
+
+	void createStateVariables(ContractDefinition const& _contract);
+	void initializeStateVariables(ContractDefinition const& _contract);
+	void createLocalVariables(FunctionDefinition const& _function);
+	void initializeLocalVariables(FunctionDefinition const& _function);
+	void initializeFunctionCallParameters(CallableDeclaration const& _function, std::vector<smtutil::Expression> const& _callArgs);
+	void resetStateVariables();
+	void resetStorageVariables();
+	void resetMemoryVariables();
+	void resetBalances();
+	/// Resets all references/pointers that have the same type or have
+	/// a subexpression of the same type as _varDecl.
+	void resetReferences(VariableDeclaration const& _varDecl);
+	/// Resets all references/pointers that have type _type.
+	void resetReferences(Type const* _type);
+	/// @returns the type without storage pointer information if it has it.
+	Type const* typeWithoutPointer(Type const* _type);
+	/// @returns whether _a or a subtype of _a is the same as _b.
+	bool sameTypeOrSubtype(Type const* _a, Type const* _b);
+
+	bool isSupportedType(Type const& _type) const;
+
+	/// Given the state of the symbolic variables at the end of two different branches,
+	/// create a merged state using the given branch condition.
+	void mergeVariables(smtutil::Expression const& _condition, VariableIndices const& _indicesEndTrue, VariableIndices const& _indicesEndFalse);
+	/// Tries to create an uninitialized variable and returns true on success.
+	bool createVariable(VariableDeclaration const& _varDecl);
+
+	/// @returns an expression denoting the value of the variable declared in @a _decl
+	/// at the current point.
+	smtutil::Expression currentValue(VariableDeclaration const& _decl) const;
+	/// @returns an expression denoting the value of the variable declared in @a _decl
+	/// at the given index. Does not ensure that this index exists.
+	smtutil::Expression valueAtIndex(VariableDeclaration const& _decl, unsigned _index) const;
+	/// Returns the expression corresponding to the AST node.
+	/// If _targetType is not null apply conversion.
+	/// Throws if the expression does not exist.
+	smtutil::Expression expr(Expression const& _e, Type const* _targetType = nullptr);
+	/// Creates the expression (value can be arbitrary)
+	void createExpr(Expression const& _e);
+	/// Creates the expression and sets its value.
+	void defineExpr(Expression const& _e, smtutil::Expression _value);
+	/// Creates the tuple expression and sets its value.
+	void defineExpr(Expression const& _e, std::vector<std::optional<smtutil::Expression>> const& _values);
+	/// Overwrites the current path condition
+	void setPathCondition(smtutil::Expression const& _e);
+	/// Adds a new path condition
+	void pushPathCondition(smtutil::Expression const& _e);
+	/// Remove the last path condition
+	void popPathCondition();
+	/// Returns the conjunction of all path conditions or True if empty
+	smtutil::Expression currentPathConditions();
+	/// @returns a human-readable call stack. Used for models.
+	langutil::SecondarySourceLocation callStackMessage(std::vector<CallStackEntry> const& _callStack);
+	/// Copies and pops the last called node.
+	CallStackEntry popCallStack();
+	/// Adds (_definition, _node) to the callstack.
+	void pushCallStack(CallStackEntry _entry);
+	/// Add to the solver: the given expression implied by the current path conditions
+	void addPathImpliedExpression(smtutil::Expression const& _e);
+
+	/// Copy the SSA indices of m_variables.
+	VariableIndices copyVariableIndices();
+	/// Resets the variable indices.
+	void resetVariableIndices(VariableIndices const& _indices);
+	/// Used when starting a new block.
+	virtual void clearIndices(ContractDefinition const* _contract, FunctionDefinition const* _function = nullptr);
+
+
+	/// @returns variables that are touched in _node's subtree.
+	std::set<VariableDeclaration const*> touchedVariables(ASTNode const& _node);
+
+	/// @returns the declaration referenced by _expr, if any,
+	/// and nullptr otherwise.
+	Declaration const* expressionToDeclaration(Expression const& _expr) const;
+
+	/// @returns the VariableDeclaration referenced by an Expression or nullptr.
+	VariableDeclaration const* identifierToVariable(Expression const& _expr) const;
+
+	/// @returns the MemberAccess <expression>.push if _expr is an empty array push call,
+	/// otherwise nullptr.
+	MemberAccess const* isEmptyPush(Expression const& _expr) const;
+
+	/// @returns true if the given expression is `this`.
+	/// This means we don't have to abstract away effects of external function calls to this contract.
+	static bool isExternalCallToThis(Expression const* _expr);
+
+	/// Creates symbolic expressions for the returned values
+	/// and set them as the components of the symbolic tuple.
+	void createReturnedExpressions(FunctionDefinition const* _funDef, Expression const& _calledExpr);
+
+	/// @returns the symbolic arguments for a function call,
+	/// taking into account attached functions and
+	/// type conversion.
+	std::vector<smtutil::Expression> symbolicArguments(
+		std::vector<ASTPointer<VariableDeclaration>> const& _funParameters,
+		std::vector<Expression const*> const& _arguments,
+		std::optional<Expression const*> _calledExpr
+	);
+
+	smtutil::Expression constantExpr(Expression const& _expr, VariableDeclaration const& _var);
+
+	/// Traverses all source units available collecting free functions
+	/// and internal library functions in m_freeFunctions.
+	void collectFreeFunctions(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources);
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> const& allFreeFunctions() const { return m_freeFunctions; }
+	/// Create symbolic variables for the free constants in all @param _sources.
+	void createFreeConstants(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources);
+
+	/// @returns a note to be added to warnings.
+	std::string extraComment();
+
+	struct VerificationTarget
+	{
+		VerificationTargetType type;
+		smtutil::Expression value;
+		smtutil::Expression constraints;
+	};
+
+	smt::VariableUsage m_variableUsage;
+	bool m_arrayAssignmentHappened = false;
+
+	/// Stores the instances of an Uninterpreted Function applied to arguments.
+	/// These may be direct application of UFs or Array index access.
+	/// Used to retrieve models.
+	std::set<Expression const*> m_uninterpretedTerms;
+	std::vector<smtutil::Expression> m_pathConditions;
+
+	/// Whether the currently visited block uses checked
+	/// or unchecked arithmetic.
+	bool m_checked = true;
+
+	langutil::UniqueErrorReporter& m_errorReporter;
+	langutil::UniqueErrorReporter& m_unsupportedErrors;
+
+	/// Stores the current function/modifier call/invocation path.
+	std::vector<CallStackEntry> m_callStack;
+
+	/// Stack of scopes.
+	std::vector<ScopeOpener const*> m_scopes;
+
+	/// Returns true if the current function was not visited by
+	/// a function call.
+	bool isRootFunction();
+	/// Returns true if _funDef was already visited.
+	bool visitedFunction(FunctionDefinition const* _funDef);
+	/// @returns the contract that contains the current FunctionDefinition that is being visited,
+	/// or nullptr if the analysis is not inside a FunctionDefinition.
+	ContractDefinition const* currentScopeContract();
+
+	/// @returns FunctionDefinitions of the given contract (including its constructor and inherited methods),
+	/// taking into account overriding of the virtual functions.
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> const& contractFunctions(ContractDefinition const& _contract);
+	/// Cache for the method contractFunctions.
+	std::map<ContractDefinition const*, std::set<FunctionDefinition const*, ASTNode::CompareByID>> m_contractFunctions;
+
+	/// @returns FunctionDefinitions of the given contract (including its constructor and methods of bases),
+	/// without taking into account overriding of the virtual functions.
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> const& contractFunctionsWithoutVirtual(ContractDefinition const& _contract);
+	/// Cache for the method contractFunctionsWithoutVirtual.
+	std::map<ContractDefinition const*, std::set<FunctionDefinition const*, ASTNode::CompareByID>> m_contractFunctionsWithoutVirtual;
+
+	/// Depth of visit to modifiers.
+	/// When m_modifierDepth == #modifiers the function can be visited
+	/// when placeholder is visited.
+	/// Needs to be a stack because of function calls.
+	std::vector<int> m_modifierDepthStack;
+
+	std::map<ContractDefinition const*, ModifierInvocation const*> m_baseConstructorCalls;
+
+	ContractDefinition const* m_currentContract = nullptr;
+
+	/// Stores the free functions and internal library functions.
+	/// Those need to be encoded repeatedely for every analyzed contract.
+	std::set<FunctionDefinition const*, ASTNode::CompareByID> m_freeFunctions;
+
+	/// Stores the context of the encoding.
+	smt::EncodingContext& m_context;
+
+	ModelCheckerSettings m_settings;
+
+	/// Character stream for each source,
+	/// used for retrieving source text of expressions for e.g. counter-examples.
+	langutil::CharStreamProvider const& m_charStreamProvider;
+
+	smt::SymbolicState& state();
+
+private:
+	smtutil::Expression createSelectExpressionForFunction(
+		smtutil::Expression symbFunction,
+		std::vector<frontend::ASTPointer<frontend::Expression const>> const& args,
+		frontend::TypePointers const& inTypes,
+		unsigned long argsActualLength
+	);
+};
+
+}
diff --git a/compiler/libsolidity/formal/SSAVariable.cpp b/compiler/libsolidity/formal/SSAVariable.cpp
new file mode 100644
index 00000000..482388ce
--- /dev/null
+++ b/compiler/libsolidity/formal/SSAVariable.cpp
@@ -0,0 +1,40 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/SSAVariable.h>
+
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+SSAVariable::SSAVariable()
+{
+	resetIndex();
+}
+
+void SSAVariable::resetIndex()
+{
+	m_currentIndex = 0;
+	m_nextFreeIndex = 1;
+}
+
+void SSAVariable::setIndex(unsigned _index)
+{
+	m_currentIndex = _index;
+	if (m_nextFreeIndex <= _index)
+		m_nextFreeIndex = _index + 1;
+}
diff --git a/compiler/libsolidity/formal/SymbolicState.cpp b/compiler/libsolidity/formal/SymbolicState.cpp
new file mode 100644
index 00000000..bf835b80
--- /dev/null
+++ b/compiler/libsolidity/formal/SymbolicState.cpp
@@ -0,0 +1,582 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/SymbolicState.h>
+
+#include <libsolidity/formal/SymbolicTypes.h>
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <libsmtutil/Sorts.h>
+
+#include <range/v3/view.hpp>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::smtutil;
+using namespace solidity::frontend::smt;
+
+BlockchainVariable::BlockchainVariable(
+	std::string _name,
+	std::map<std::string, smtutil::SortPointer> _members,
+	EncodingContext& _context
+):
+	m_name(std::move(_name)),
+	m_members(std::move(_members)),
+	m_context(_context)
+{
+	std::vector<std::string> members;
+	std::vector<SortPointer> sorts;
+	for (auto const& [component, sort]: m_members)
+	{
+		members.emplace_back(component);
+		sorts.emplace_back(sort);
+		m_componentIndices[component] = static_cast<unsigned>(members.size() - 1);
+	}
+	m_tuple = std::make_unique<SymbolicTupleVariable>(
+		std::make_shared<smtutil::TupleSort>(m_name + "_type", members, sorts),
+		m_name,
+		m_context
+	);
+}
+
+smtutil::Expression BlockchainVariable::member(std::string const& _member) const
+{
+	return m_tuple->component(m_componentIndices.at(_member));
+}
+
+smtutil::Expression BlockchainVariable::assignMember(std::string const& _member, smtutil::Expression const& _value)
+{
+	smtutil::Expression newTuple = smt::assignMember(m_tuple->currentValue(), {{_member, _value}});
+	m_context.addAssertion(m_tuple->increaseIndex() == newTuple);
+	return m_tuple->currentValue();
+}
+
+void SymbolicState::reset()
+{
+	m_error.resetIndex();
+	m_thisAddress.resetIndex();
+	m_tx.reset();
+	m_crypto.reset();
+	if (m_abi)
+		m_abi->reset();
+	/// We don't reset nor clear these pointers on purpose,
+	/// since it only helps to keep the already generated types.
+	if (m_state)
+		m_state->reset();
+}
+
+smtutil::Expression SymbolicState::balances() const
+{
+	return m_state->member("balances");
+}
+
+smtutil::Expression SymbolicState::balance() const
+{
+	return balance(thisAddress());
+}
+
+smtutil::Expression SymbolicState::balance(smtutil::Expression _address) const
+{
+	return smtutil::Expression::select(balances(), std::move(_address));
+}
+
+smtutil::Expression SymbolicState::blockhash(smtutil::Expression _blockNumber) const
+{
+	return smtutil::Expression::select(m_tx.member("blockhash"), std::move(_blockNumber));
+}
+
+void SymbolicState::newBalances()
+{
+	auto tupleSort = std::dynamic_pointer_cast<TupleSort>(stateSort());
+	auto balanceSort = tupleSort->components.at(tupleSort->memberToIndex.at("balances"));
+	SymbolicVariable newBalances(balanceSort, "fresh_balances_" + std::to_string(m_context.newUniqueId()), m_context);
+	m_state->assignMember("balances", newBalances.currentValue());
+}
+
+void SymbolicState::transfer(smtutil::Expression _from, smtutil::Expression _to, smtutil::Expression _value)
+{
+	unsigned indexBefore = m_state->index();
+	addBalance(_from, 0 - _value);
+	addBalance(_to, std::move(_value));
+	unsigned indexAfter = m_state->index();
+	solAssert(indexAfter > indexBefore, "");
+	m_state->newVar();
+	/// Do not apply the transfer operation if _from == _to.
+	auto newState = smtutil::Expression::ite(
+		std::move(_from) == std::move(_to),
+		m_state->value(indexBefore),
+		m_state->value(indexAfter)
+	);
+	m_context.addAssertion(m_state->value() == newState);
+}
+
+smtutil::Expression SymbolicState::storage(ContractDefinition const& _contract) const
+{
+	return smt::member(m_state->member("storage"), contractStorageKey(_contract));
+}
+
+smtutil::Expression SymbolicState::storage(ContractDefinition const& _contract, smtutil::Expression _address) const
+{
+	return smtutil::Expression::select(storage(_contract), std::move(_address));
+}
+
+smtutil::Expression SymbolicState::addressActive(smtutil::Expression _address) const
+{
+	return smtutil::Expression::select(m_state->member("isActive"), std::move(_address));
+}
+
+void SymbolicState::setAddressActive(
+	smtutil::Expression _address,
+	bool _active
+)
+{
+	m_state->assignMember("isActive", smtutil::Expression::store(
+		m_state->member("isActive"),
+		std::move(_address),
+		smtutil::Expression(_active))
+	);
+}
+
+void SymbolicState::newStorage()
+{
+	auto newStorageVar = SymbolicTupleVariable(
+		m_state->member("storage").sort,
+		"havoc_storage_" + std::to_string(m_context.newUniqueId()),
+		m_context
+	);
+	m_state->assignMember("storage", newStorageVar.currentValue());
+}
+
+void SymbolicState::writeStateVars(ContractDefinition const& _contract, smtutil::Expression _address)
+{
+	auto stateVars = SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract);
+	if (stateVars.empty())
+		return;
+
+	std::map<std::string, smtutil::Expression> values;
+	for (auto var: stateVars)
+		values.emplace(stateVarStorageKey(*var, _contract), m_context.variable(*var)->currentValue());
+
+	smtutil::Expression thisStorage = storage(_contract, _address);
+	smtutil::Expression newStorage = smt::assignMember(thisStorage, values);
+	auto newContractStorage = smtutil::Expression::store(
+		storage(_contract), std::move(_address), newStorage
+	);
+	smtutil::Expression newAllStorage = smt::assignMember(m_state->member("storage"), {{contractStorageKey(_contract), newContractStorage}});
+	m_state->assignMember("storage", newAllStorage);
+}
+
+void SymbolicState::readStateVars(ContractDefinition const& _contract, smtutil::Expression _address)
+{
+	auto stateVars = SMTEncoder::stateVariablesIncludingInheritedAndPrivate(_contract);
+	if (stateVars.empty())
+		return;
+
+	auto contractStorage = storage(_contract, std::move(_address));
+	for (auto var: stateVars)
+		m_context.addAssertion(
+			m_context.variable(*var)->increaseIndex() ==
+			smt::member(contractStorage, stateVarStorageKey(*var, _contract))
+		);
+}
+
+void SymbolicState::addBalance(smtutil::Expression _address, smtutil::Expression _value)
+{
+	auto newBalances = smtutil::Expression::store(
+		balances(),
+		_address,
+		balance(_address) + std::move(_value)
+	);
+	m_state->assignMember("balances", newBalances);
+}
+
+smtutil::Expression SymbolicState::txMember(std::string const& _member) const
+{
+	return m_tx.member(_member);
+}
+
+smtutil::Expression SymbolicState::evmParisConstraints() const
+{
+	// Ensure prevrandao range as defined by EIP-4399.
+	return txMember("block.prevrandao") > (u256(1) << 64);
+}
+
+smtutil::Expression SymbolicState::txTypeConstraints() const
+{
+	return
+		evmParisConstraints() &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.basefee"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.chainid"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.coinbase"), TypeProvider::address()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.prevrandao"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.gaslimit"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.number"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("block.timestamp"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("msg.sender"), TypeProvider::address()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("msg.value"), TypeProvider::uint256()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("tx.origin"), TypeProvider::address()) &&
+		smt::symbolicUnknownConstraints(m_tx.member("tx.gasprice"), TypeProvider::uint256());
+}
+
+smtutil::Expression SymbolicState::txNonPayableConstraint() const
+{
+	return m_tx.member("msg.value") == 0;
+}
+
+smtutil::Expression SymbolicState::txFunctionConstraints(FunctionDefinition const& _function) const
+{
+	smtutil::Expression conj = _function.isPayable() ? smtutil::Expression(true) : txNonPayableConstraint();
+	if (_function.isPartOfExternalInterface())
+	{
+		auto sig = TypeProvider::function(_function)->externalIdentifier();
+		conj = conj && m_tx.member("msg.sig") == sig;
+		auto b0 = sig >> (3 * 8);
+		auto b1 = (sig & 0x00ff0000) >> (2 * 8);
+		auto b2 = (sig & 0x0000ff00) >> (1 * 8);
+		auto b3 = (sig & 0x000000ff);
+		auto data = smtutil::Expression::tuple_get(m_tx.member("msg.data"), 0);
+		conj = conj && smtutil::Expression::select(data, 0) == b0;
+		conj = conj && smtutil::Expression::select(data, 1) == b1;
+		conj = conj && smtutil::Expression::select(data, 2) == b2;
+		conj = conj && smtutil::Expression::select(data, 3) == b3;
+		auto length = smtutil::Expression::tuple_get(m_tx.member("msg.data"), 1);
+		// TODO add ABI size of function input parameters here \/
+		conj = conj && length >= 4;
+	}
+
+	return conj;
+}
+
+void SymbolicState::prepareForSourceUnit(SourceUnit const& _source, bool _storage)
+{
+	auto allSources = _source.referencedSourceUnits(true);
+	allSources.insert(&_source);
+	std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> abiCalls;
+	std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> bytesConcatCalls;
+	std::set<ContractDefinition const*, ASTCompareByID<ContractDefinition>> contracts;
+	for (auto const& source: allSources)
+	{
+		abiCalls += SMTEncoder::collectABICalls(source);
+		bytesConcatCalls += SMTEncoder::collectBytesConcatCalls(source);
+		for (auto node: source->nodes())
+			if (auto contract = dynamic_cast<ContractDefinition const*>(node.get()))
+				contracts.insert(contract);
+	}
+	buildState(contracts, _storage);
+	buildABIFunctions(abiCalls);
+	buildBytesConcatFunctions(bytesConcatCalls);
+}
+
+/// Private helpers.
+
+std::string SymbolicState::contractSuffix(ContractDefinition const& _contract) const
+{
+	return "_" + _contract.name() + "_" + std::to_string(_contract.id());
+}
+
+std::string SymbolicState::contractStorageKey(ContractDefinition const& _contract) const
+{
+	return "storage" + contractSuffix(_contract);
+}
+
+std::string SymbolicState::stateVarStorageKey(VariableDeclaration const& _var, ContractDefinition const& _contract) const
+{
+	return _var.name() + "_" + std::to_string(_var.id()) + contractSuffix(_contract);
+}
+
+void SymbolicState::buildState(std::set<ContractDefinition const*, ASTCompareByID<ContractDefinition>> const& _contracts, bool _allStorages)
+{
+	std::map<std::string, SortPointer> stateMembers{
+		{"balances", std::make_shared<smtutil::ArraySort>(smtutil::SortProvider::uintSort, smtutil::SortProvider::uintSort)}
+	};
+
+	if (_allStorages)
+	{
+		std::vector<std::string> memberNames;
+		std::vector<SortPointer> memberSorts;
+		for (auto contract: _contracts)
+		{
+			std::string suffix = contractSuffix(*contract);
+
+			// z3 doesn't like empty tuples, so if the contract has 0
+			// state vars we can't put it there.
+			auto stateVars = SMTEncoder::stateVariablesIncludingInheritedAndPrivate(*contract);
+			if (stateVars.empty())
+				continue;
+
+			auto names = applyMap(stateVars, [&](auto var) {
+				return var->name() + "_" + std::to_string(var->id()) + suffix;
+			});
+			auto sorts = applyMap(stateVars, [](auto var) { return smtSortAbstractFunction(*var->type()); });
+
+			std::string name = "storage" + suffix;
+			auto storageTuple = std::make_shared<smtutil::TupleSort>(
+				name + "_type", names, sorts
+			);
+
+			auto storageSort = std::make_shared<smtutil::ArraySort>(
+				smtSort(*TypeProvider::address()),
+				storageTuple
+			);
+
+			memberNames.emplace_back(name);
+			memberSorts.emplace_back(storageSort);
+		}
+
+		stateMembers.emplace(
+			"isActive",
+			std::make_shared<smtutil::ArraySort>(smtSort(*TypeProvider::address()), smtutil::SortProvider::boolSort)
+		);
+		stateMembers.emplace(
+			"storage",
+			std::make_shared<smtutil::TupleSort>(
+				"storage_type", memberNames, memberSorts
+			)
+		);
+	}
+
+	m_state = std::make_unique<BlockchainVariable>(
+		"state",
+		std::move(stateMembers),
+		m_context
+	);
+}
+
+void SymbolicState::buildBytesConcatFunctions(std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> const& _bytesConcatCalls)
+{
+	std::map<std::string, SortPointer> functions;
+
+	for (auto const* funCall: _bytesConcatCalls)
+	{
+		auto t = dynamic_cast<FunctionType const*>(funCall->expression().annotation().type);
+		solAssert(t->kind() == FunctionType::Kind::BytesConcat, "Expected bytes.concat function");
+
+		auto const& args = funCall->sortedArguments();
+
+		auto argTypes = [](auto const& _args) {
+			return util::applyMap(_args, [](auto arg) { return arg->annotation().type; });
+		};
+
+		// bytes.concat : (bytes/literal/fixed bytes, ... ) -> bytes
+		std::vector<frontend::Type const*> inTypes = argTypes(args);
+
+		auto replaceUserDefinedValueTypes = [](auto& _types) {
+			for (auto& t: _types)
+				if (auto userType = dynamic_cast<UserDefinedValueType const*>(t))
+					t = &userType->underlyingType();
+		};
+		auto replaceStringLiteralTypes = [](auto& _types) {
+			for (auto& t: _types)
+				if (t->category() == frontend::Type::Category::StringLiteral)
+					t = TypeProvider::bytesMemory();
+		};
+		replaceUserDefinedValueTypes(inTypes);
+		replaceStringLiteralTypes(inTypes);
+
+		auto name = t->richIdentifier();
+		for (auto paramType: inTypes)
+			name += "_" + paramType->richIdentifier();
+
+		frontend::Type const* outType = TypeProvider::bytesMemory();
+		name += "_" + outType->richIdentifier();
+
+		m_bytesConcatMembers[funCall] = {name, inTypes, outType};
+
+		if (functions.count(name))
+			continue;
+
+		/// If there is only one parameter, we use that type directly.
+		/// Otherwise we create a tuple wrapping the necessary types.
+		auto typesToSort = [](auto const& _types, std::string const& _name) -> std::shared_ptr<Sort> {
+			if (_types.size() == 1)
+				return smtSortAbstractFunction(*_types.front());
+
+			std::vector<std::string> inNames;
+			std::vector<SortPointer> sorts;
+			for (unsigned i = 0; i < _types.size(); ++i)
+			{
+				inNames.emplace_back(_name + "_input_" + std::to_string(i));
+				sorts.emplace_back(smtSortAbstractFunction(*_types.at(i)));
+			}
+			return std::make_shared<smtutil::TupleSort>(
+				_name + "_input",
+				inNames,
+				sorts
+			);
+		};
+
+		auto functionSort = std::make_shared<smtutil::ArraySort>(
+			typesToSort(inTypes, name),
+			smtSortAbstractFunction(*outType)
+		);
+
+		functions[name] = functionSort;
+	}
+
+	m_bytesConcat = std::make_unique<BlockchainVariable>("bytesConcat", std::move(functions), m_context);
+}
+
+void SymbolicState::buildABIFunctions(std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> const& _abiFunctions)
+{
+	std::map<std::string, SortPointer> functions;
+
+	for (auto const* funCall: _abiFunctions)
+	{
+		auto t = dynamic_cast<FunctionType const*>(funCall->expression().annotation().type);
+
+		auto const& args = funCall->sortedArguments();
+		auto const& paramTypes = t->parameterTypes();
+		auto const& returnTypes = t->returnParameterTypes();
+
+		auto argTypes = [](auto const& _args) {
+			return util::applyMap(_args, [](auto arg) { return arg->annotation().type; });
+		};
+
+		/// Since each abi.* function may have a different number of input/output parameters,
+		/// we generically compute those types.
+		std::vector<frontend::Type const*> inTypes;
+		std::vector<frontend::Type const*> outTypes;
+		if (t->kind() == FunctionType::Kind::ABIDecode)
+		{
+			/// abi.decode : (bytes, tuple_of_types(return_types)) -> (return_types)
+			solAssert(args.size() == 2, "Unexpected number of arguments for abi.decode");
+			inTypes.emplace_back(TypeProvider::bytesMemory());
+			auto argType = args.at(1)->annotation().type;
+			if (auto const* tupleType = dynamic_cast<TupleType const*>(argType))
+				for (auto componentType: tupleType->components())
+				{
+					auto typeType = dynamic_cast<TypeType const*>(componentType);
+					solAssert(typeType, "");
+					outTypes.emplace_back(typeType->actualType());
+				}
+			else if (auto const* typeType = dynamic_cast<TypeType const*>(argType))
+				outTypes.emplace_back(typeType->actualType());
+			else
+				solAssert(false, "Unexpected argument of abi.decode");
+		}
+		else if (t->kind() == FunctionType::Kind::ABIEncodeCall)
+		{
+			// abi.encodeCall : (functionPointer, tuple_of_args_or_one_non_tuple_arg(arguments)) -> bytes
+			solAssert(args.size() == 2, "Unexpected number of arguments for abi.encodeCall");
+
+			outTypes.emplace_back(TypeProvider::bytesMemory());
+			inTypes.emplace_back(args.at(0)->annotation().type);
+			inTypes.emplace_back(args.at(1)->annotation().type);
+		}
+		else
+		{
+			outTypes = returnTypes;
+			if (
+				t->kind() == FunctionType::Kind::ABIEncodeWithSelector ||
+				t->kind() == FunctionType::Kind::ABIEncodeWithSignature
+			)
+			{
+				/// abi.encodeWithSelector : (bytes4, one_or_more_types) -> bytes
+				/// abi.encodeWithSignature : (string, one_or_more_types) -> bytes
+				inTypes.emplace_back(paramTypes.front());
+				inTypes += argTypes(std::vector<ASTPointer<Expression const>>(args.begin() + 1, args.end()));
+			}
+			else
+			{
+				/// abi.encode/abi.encodePacked : one_or_more_types -> bytes
+				solAssert(
+					t->kind() == FunctionType::Kind::ABIEncode ||
+					t->kind() == FunctionType::Kind::ABIEncodePacked,
+					""
+				);
+				inTypes = argTypes(args);
+			}
+		}
+
+		/// Rational numbers and string literals add the concrete values to the type name,
+		/// so we replace them by uint256 and bytes since those are the same as their SMT types.
+		/// TODO we could also replace all types by their ABI type.
+		auto replaceTypes = [](auto& _types) {
+			for (auto& t: _types)
+				if (t->category() == frontend::Type::Category::RationalNumber)
+					t = TypeProvider::uint256();
+				else if (t->category() == frontend::Type::Category::StringLiteral)
+					t = TypeProvider::bytesMemory();
+				else if (auto userType = dynamic_cast<UserDefinedValueType const*>(t))
+					t = &userType->underlyingType();
+		};
+		replaceTypes(inTypes);
+		replaceTypes(outTypes);
+
+		auto name = t->richIdentifier();
+		for (auto paramType: inTypes + outTypes)
+			name += "_" + paramType->richIdentifier();
+
+		m_abiMembers[funCall] = {name, inTypes, outTypes};
+
+		if (functions.count(name))
+			continue;
+
+		/// If there is only one input or output parameter, we use that type directly.
+		/// Otherwise we create a tuple wrapping the necessary input or output types.
+		auto typesToSort = [](auto const& _types, std::string const& _name) -> std::shared_ptr<Sort> {
+			if (_types.size() == 1)
+				return smtSortAbstractFunction(*_types.front());
+
+			std::vector<std::string> inNames;
+			std::vector<SortPointer> sorts;
+			for (unsigned i = 0; i < _types.size(); ++i)
+			{
+				inNames.emplace_back(_name + "_input_" + std::to_string(i));
+				sorts.emplace_back(smtSortAbstractFunction(*_types.at(i)));
+			}
+			return std::make_shared<smtutil::TupleSort>(
+				_name + "_input",
+				inNames,
+				sorts
+			);
+		};
+
+		auto functionSort = std::make_shared<smtutil::ArraySort>(
+			typesToSort(inTypes, name),
+			typesToSort(outTypes, name)
+		);
+
+		functions[name] = functionSort;
+	}
+
+	m_abi = std::make_unique<BlockchainVariable>("abi", std::move(functions), m_context);
+}
+
+smtutil::Expression SymbolicState::abiFunction(frontend::FunctionCall const* _funCall)
+{
+	solAssert(m_abi, "");
+	return m_abi->member(std::get<0>(m_abiMembers.at(_funCall)));
+}
+
+SymbolicState::SymbolicABIFunction const& SymbolicState::abiFunctionTypes(FunctionCall const* _funCall) const
+{
+	return m_abiMembers.at(_funCall);
+}
+
+smtutil::Expression SymbolicState::bytesConcatFunction(frontend::FunctionCall const* _funCall)
+{
+	solAssert(m_bytesConcat, "");
+	return m_bytesConcat->member(std::get<0>(m_bytesConcatMembers.at(_funCall)));
+}
+
+SymbolicState::SymbolicBytesConcatFunction const& SymbolicState::bytesConcatFunctionTypes(FunctionCall const* _funCall) const
+{
+	return m_bytesConcatMembers.at(_funCall);
+}
diff --git a/compiler/libsolidity/formal/SymbolicState.h b/compiler/libsolidity/formal/SymbolicState.h
new file mode 100644
index 00000000..ac018df1
--- /dev/null
+++ b/compiler/libsolidity/formal/SymbolicState.h
@@ -0,0 +1,306 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolidity/formal/SymbolicTypes.h>
+#include <libsolidity/formal/SymbolicVariables.h>
+
+#include <libsmtutil/Sorts.h>
+#include <libsmtutil/SolverInterface.h>
+
+namespace solidity::frontend::smt
+{
+
+class EncodingContext;
+class SymbolicAddressVariable;
+class SymbolicArrayVariable;
+
+class BlockchainVariable
+{
+public:
+	BlockchainVariable(std::string _name, std::map<std::string, smtutil::SortPointer> _members, EncodingContext& _context);
+	/// @returns the variable data as a tuple.
+	smtutil::Expression value() const { return m_tuple->currentValue(); }
+	smtutil::Expression value(unsigned _idx) const { return m_tuple->valueAtIndex(_idx); }
+	smtutil::SortPointer const& sort() const { return m_tuple->sort(); }
+	unsigned index() const { return m_tuple->index(); }
+	void newVar() { m_tuple->increaseIndex(); }
+	void reset() { m_tuple->resetIndex(); }
+
+	/// @returns the symbolic _member.
+	smtutil::Expression member(std::string const& _member) const;
+	/// Generates a new tuple where _member is assigned _value.
+	smtutil::Expression assignMember(std::string const& _member, smtutil::Expression const& _value);
+
+private:
+	std::string const m_name;
+	std::map<std::string, smtutil::SortPointer> const m_members;
+	EncodingContext& m_context;
+	std::map<std::string, unsigned> m_componentIndices;
+	std::unique_ptr<SymbolicTupleVariable> m_tuple;
+};
+
+/**
+ * Symbolic representation of the blockchain context:
+ * - error flag
+ * - this (the address of the currently executing contract)
+ * - state, represented as a tuple of:
+ *   - balances
+ *   - array of address => bool representing whether an address is used by a contract
+ *   - storage of contracts
+ * - block and transaction properties, represented as a tuple of:
+ *   - blockhash
+ *   - block basefee
+ *   - block chainid
+ *   - block coinbase
+ *   - block gaslimit
+ *   - block number
+ *   - block prevrandao
+ *   - block timestamp
+ *   - TODO gasleft
+ *   - msg data
+ *   - msg sender
+ *   - msg sig
+ *   - msg value
+ *   - tx gasprice
+ *   - tx origin
+ */
+class SymbolicState
+{
+public:
+	SymbolicState(EncodingContext& _context): m_context(_context) {}
+
+	void reset();
+
+	/// Error flag.
+	//@{
+	SymbolicIntVariable& errorFlag() { return m_error; }
+	SymbolicIntVariable const& errorFlag() const { return m_error; }
+	smtutil::SortPointer const& errorFlagSort() const { return m_error.sort(); }
+	//@}
+
+	/// This.
+	//@{
+	/// @returns the symbolic value of the currently executing contract's address.
+	smtutil::Expression thisAddress() const { return m_thisAddress.currentValue(); }
+	smtutil::Expression thisAddress(unsigned _idx) const { return m_thisAddress.valueAtIndex(_idx); }
+	smtutil::Expression newThisAddress() { return m_thisAddress.increaseIndex(); }
+	smtutil::SortPointer const& thisAddressSort() const { return m_thisAddress.sort(); }
+	//@}
+
+	/// Blockchain state.
+	//@{
+	smtutil::Expression state() const { solAssert(m_state, ""); return m_state->value(); }
+	smtutil::Expression state(unsigned _idx) const { solAssert(m_state, ""); return m_state->value(_idx); }
+	smtutil::SortPointer const& stateSort() const { solAssert(m_state, ""); return m_state->sort(); }
+	void newState() { solAssert(m_state, ""); m_state->newVar(); }
+
+	void newBalances();
+
+	/// Balance.
+	/// @returns the symbolic balances.
+	smtutil::Expression balances() const;
+	/// @returns the symbolic balance of address `this`.
+	smtutil::Expression balance() const;
+	/// @returns the symbolic balance of an address.
+	smtutil::Expression balance(smtutil::Expression _address) const;
+	/// Transfer _value from _from to _to.
+	void transfer(smtutil::Expression _from, smtutil::Expression _to, smtutil::Expression _value);
+
+	/// Adds _value to _account's balance.
+	void addBalance(smtutil::Expression _account, smtutil::Expression _value);
+
+	/// Storage.
+	smtutil::Expression storage(ContractDefinition const& _contract) const;
+	smtutil::Expression storage(ContractDefinition const& _contract, smtutil::Expression _address) const;
+	smtutil::Expression addressActive(smtutil::Expression _address) const;
+	void setAddressActive(smtutil::Expression _address, bool _active);
+
+	void newStorage();
+	void writeStateVars(ContractDefinition const& _contract, smtutil::Expression _address);
+	void readStateVars(ContractDefinition const& _contract, smtutil::Expression _address);
+	//@}
+
+	/// Transaction data.
+	//@{
+	/// @returns the tx data as a tuple.
+	smtutil::Expression tx() const { return m_tx.value(); }
+	smtutil::Expression tx(unsigned _idx) const { return m_tx.value(_idx); }
+	smtutil::SortPointer const& txSort() const { return m_tx.sort(); }
+	void newTx() { m_tx.newVar(); }
+	smtutil::Expression txMember(std::string const& _member) const;
+	smtutil::Expression txFunctionConstraints(FunctionDefinition const& _function) const;
+	smtutil::Expression txTypeConstraints() const;
+	smtutil::Expression txNonPayableConstraint() const;
+	smtutil::Expression blockhash(smtutil::Expression _blockNumber) const;
+	smtutil::Expression evmParisConstraints() const;
+	//@}
+
+	/// Crypto functions.
+	//@{
+	/// @returns the crypto functions represented as a tuple of arrays.
+	smtutil::Expression crypto() const { return m_crypto.value(); }
+	smtutil::Expression crypto(unsigned _idx) const { return m_crypto.value(_idx); }
+	smtutil::SortPointer const& cryptoSort() const { return m_crypto.sort(); }
+	void newCrypto() { m_crypto.newVar(); }
+	smtutil::Expression cryptoFunction(std::string const& _member) const { return m_crypto.member(_member); }
+	//@}
+
+	/// Calls the internal methods that build
+	/// - the symbolic ABI functions based on the abi.* calls
+	///   in _source and referenced sources.
+	/// - the symbolic storages for all contracts in _source and
+	///   referenced sources.
+	void prepareForSourceUnit(SourceUnit const& _source, bool _storage);
+
+	/// ABI functions.
+	//@{
+	smtutil::Expression abiFunction(FunctionCall const* _funCall);
+	using SymbolicABIFunction = std::tuple<
+		std::string,
+		std::vector<frontend::Type const*>,
+		std::vector<frontend::Type const*>
+	>;
+	SymbolicABIFunction const& abiFunctionTypes(FunctionCall const* _funCall) const;
+
+	smtutil::Expression abi() const { solAssert(m_abi, ""); return m_abi->value(); }
+	smtutil::Expression abi(unsigned _idx) const { solAssert(m_abi, ""); return m_abi->value(_idx); }
+	smtutil::SortPointer const& abiSort() const { solAssert(m_abi, ""); return m_abi->sort(); }
+	//@}
+
+	/// bytes.concat functions.
+	//@{
+	smtutil::Expression bytesConcatFunction(FunctionCall const* _funCall);
+	using SymbolicBytesConcatFunction = std::tuple<
+		std::string,
+		std::vector<frontend::Type const*>,
+		frontend::Type const*
+	>;
+	SymbolicBytesConcatFunction const& bytesConcatFunctionTypes(FunctionCall const* _funCall) const;
+	smtutil::Expression bytesConcat() const { solAssert(m_bytesConcat, ""); return m_bytesConcat->value(); }
+	smtutil::Expression bytesConcat(unsigned _idx) const { solAssert(m_bytesConcat, ""); return m_bytesConcat->value(_idx); }
+	smtutil::SortPointer const& bytesConcatSort() const { solAssert(m_bytesConcat, ""); return m_bytesConcat->sort(); }
+	bool hasBytesConcatFunction() const {solAssert(m_bytesConcat, ""); return !m_bytesConcatMembers.empty(); }
+	//@}
+
+private:
+	std::string contractSuffix(ContractDefinition const& _contract) const;
+	std::string contractStorageKey(ContractDefinition const& _contract) const;
+	std::string stateVarStorageKey(VariableDeclaration const& _var, ContractDefinition const& _contract) const;
+
+	/// Builds state.storage based on _contracts.
+	void buildState(std::set<ContractDefinition const*, ASTCompareByID<ContractDefinition>> const& _contracts, bool _allStorages);
+
+	/// Builds m_abi based on the abi.* calls _abiFunctions.
+	void buildABIFunctions(std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> const& _abiFunctions);
+
+	/// Builds m_bytesConcat based on the bytes.concat calls
+	void buildBytesConcatFunctions(std::set<FunctionCall const*, ASTCompareByID<FunctionCall>> const& _bytesConcatCalls);
+
+	EncodingContext& m_context;
+
+	SymbolicIntVariable m_error{
+		TypeProvider::uint256(),
+		TypeProvider::uint256(),
+		"error",
+		m_context
+	};
+
+	SymbolicAddressVariable m_thisAddress{
+		"this",
+		m_context
+	};
+
+	/// m_state is a tuple of
+	/// - balances: array of address to balance of address.
+	/// - isActive: array of address to Boolean, where element is true iff address is used.
+	/// - storage: tuple containing the storage of every contract, where
+	/// each element of the tuple represents a contract,
+	/// and is defined by an array where the index is the contract's address
+	/// and the element is a tuple containing the state variables of that contract.
+	std::unique_ptr<BlockchainVariable> m_state;
+
+	BlockchainVariable m_tx{
+		"tx",
+		{
+			{"block.basefee", smtutil::SortProvider::uintSort},
+			{"block.chainid", smtutil::SortProvider::uintSort},
+			{"block.coinbase", smt::smtSort(*TypeProvider::address())},
+			{"block.prevrandao", smtutil::SortProvider::uintSort},
+			{"block.gaslimit", smtutil::SortProvider::uintSort},
+			{"block.number", smtutil::SortProvider::uintSort},
+			{"block.timestamp", smtutil::SortProvider::uintSort},
+			{"blockhash", std::make_shared<smtutil::ArraySort>(smtutil::SortProvider::uintSort, smtutil::SortProvider::uintSort)},
+			// TODO gasleft
+			{"msg.data", smt::smtSort(*TypeProvider::bytesMemory())},
+			{"msg.sender", smt::smtSort(*TypeProvider::address())},
+			{"msg.sig", smtutil::SortProvider::uintSort},
+			{"msg.value", smtutil::SortProvider::uintSort},
+			{"tx.gasprice", smtutil::SortProvider::uintSort},
+			{"tx.origin", smt::smtSort(*TypeProvider::address())}
+		},
+		m_context
+	};
+
+	BlockchainVariable m_crypto{
+		"crypto",
+		{
+			{"keccak256", std::make_shared<smtutil::ArraySort>(
+				smt::smtSort(*TypeProvider::bytesStorage()),
+				smtSort(*TypeProvider::fixedBytes(32))
+			)},
+			{"sha256", std::make_shared<smtutil::ArraySort>(
+				smt::smtSort(*TypeProvider::bytesStorage()),
+				smtSort(*TypeProvider::fixedBytes(32))
+			)},
+			{"ripemd160", std::make_shared<smtutil::ArraySort>(
+				smt::smtSort(*TypeProvider::bytesStorage()),
+				smtSort(*TypeProvider::fixedBytes(20))
+			)},
+			{"ecrecover", std::make_shared<smtutil::ArraySort>(
+				std::make_shared<smtutil::TupleSort>(
+					"ecrecover_input_type",
+					std::vector<std::string>{"hash", "v", "r", "s"},
+					std::vector<smtutil::SortPointer>{
+						smt::smtSort(*TypeProvider::fixedBytes(32)),
+						smt::smtSort(*TypeProvider::uint(8)),
+						smt::smtSort(*TypeProvider::fixedBytes(32)),
+						smt::smtSort(*TypeProvider::fixedBytes(32))
+					}
+				),
+				smtSort(*TypeProvider::address())
+			)}
+		},
+		m_context
+	};
+
+	/// Tuple containing all used ABI functions.
+	std::unique_ptr<BlockchainVariable> m_abi;
+	/// Maps ABI functions calls to their tuple names generated by
+	/// `buildABIFunctions`.
+	std::map<FunctionCall const*, SymbolicABIFunction> m_abiMembers;
+
+	/// Tuple containing all used bytes.concat functions.
+	std::unique_ptr<BlockchainVariable> m_bytesConcat;
+	/// Maps bytes.concat functions calls to their tuple names generated by
+	/// `buildBytesConcatFunctions`.
+	std::map<FunctionCall const*, SymbolicBytesConcatFunction> m_bytesConcatMembers;
+};
+
+}
diff --git a/compiler/libsolidity/formal/SymbolicTypes.cpp b/compiler/libsolidity/formal/SymbolicTypes.cpp
new file mode 100644
index 00000000..45b872b3
--- /dev/null
+++ b/compiler/libsolidity/formal/SymbolicTypes.cpp
@@ -0,0 +1,642 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/SymbolicTypes.h>
+
+#include <libsolidity/formal/EncodingContext.h>
+
+#include <libsolidity/ast/TypeProvider.h>
+#include <libsolidity/ast/Types.h>
+#include <libsolutil/CommonData.h>
+#include <memory>
+#include <vector>
+
+using namespace solidity::util;
+using namespace solidity::smtutil;
+
+namespace solidity::frontend::smt
+{
+
+SortPointer smtSort(frontend::Type const& _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(&_type))
+		return smtSort(userType->underlyingType());
+
+	switch (smtKind(_type))
+	{
+	case Kind::Int:
+		if (auto const* intType = dynamic_cast<IntegerType const*>(&_type))
+			return SortProvider::intSort(intType->isSigned());
+		if (auto const* fixedType = dynamic_cast<FixedPointType const*>(&_type))
+			return SortProvider::intSort(fixedType->isSigned());
+		return SortProvider::uintSort;
+	case Kind::Bool:
+		return SortProvider::boolSort;
+	case Kind::Function:
+	{
+		auto fType = dynamic_cast<frontend::FunctionType const*>(&_type);
+		solAssert(fType, "");
+		std::vector<SortPointer> parameterSorts = smtSort(fType->parameterTypes());
+		auto returnTypes = fType->returnParameterTypes();
+		SortPointer returnSort;
+		// TODO change this when we support tuples.
+		if (returnTypes.size() == 0)
+			// We cannot declare functions without a return sort, so we use the smallest.
+			returnSort = SortProvider::boolSort;
+		else if (returnTypes.size() > 1)
+			// Abstract sort.
+			returnSort = SortProvider::uintSort;
+		else
+			returnSort = smtSort(*returnTypes.front());
+		return std::make_shared<FunctionSort>(parameterSorts, returnSort);
+	}
+	case Kind::Array:
+	{
+		std::shared_ptr<ArraySort> array;
+		if (isMapping(_type))
+		{
+			auto mapType = dynamic_cast<frontend::MappingType const*>(&_type);
+			solAssert(mapType, "");
+			array = std::make_shared<ArraySort>(smtSortAbstractFunction(*mapType->keyType()), smtSortAbstractFunction(*mapType->valueType()));
+		}
+		else if (isStringLiteral(_type))
+		{
+			auto stringLitType = dynamic_cast<frontend::StringLiteralType const*>(&_type);
+			solAssert(stringLitType, "");
+			array = std::make_shared<ArraySort>(SortProvider::uintSort, SortProvider::uintSort);
+		}
+		else
+		{
+			frontend::ArrayType const* arrayType = nullptr;
+			if (auto const* arr = dynamic_cast<frontend::ArrayType const*>(&_type))
+				arrayType = arr;
+			else if (auto const* slice = dynamic_cast<frontend::ArraySliceType const*>(&_type))
+				arrayType = &slice->arrayType();
+			else
+				solAssert(false, "");
+
+			solAssert(arrayType, "");
+			array = std::make_shared<ArraySort>(SortProvider::uintSort, smtSortAbstractFunction(*arrayType->baseType()));
+		}
+
+		std::string tupleName;
+		auto sliceArrayType = dynamic_cast<ArraySliceType const*>(&_type);
+		ArrayType const* arrayType = sliceArrayType ? &sliceArrayType->arrayType() : dynamic_cast<ArrayType const*>(&_type);
+		if (
+			(arrayType && arrayType->isByteArrayOrString()) ||
+			_type.category() == frontend::Type::Category::StringLiteral
+		)
+			tupleName = "bytes";
+		else if (arrayType)
+		{
+			auto baseType = arrayType->baseType();
+			// Solidity allows implicit conversion also when assigning arrays.
+			// So if the base type potentially has a size, that size cannot go
+			// in the tuple's name.
+			if (auto tupleSort = std::dynamic_pointer_cast<TupleSort>(array->range))
+				tupleName = tupleSort->name;
+			else if (
+				baseType->category() == frontend::Type::Category::Integer ||
+				baseType->category() == frontend::Type::Category::FixedPoint
+			)
+				tupleName = "uint";
+			else if (baseType->category() == frontend::Type::Category::FixedBytes)
+				tupleName = "fixedbytes";
+			else
+				tupleName = arrayType->baseType()->toString(true);
+
+			tupleName += "_array";
+		}
+		else
+			tupleName = _type.toString(true);
+
+		tupleName += "_tuple";
+
+		return std::make_shared<TupleSort>(
+			tupleName,
+			std::vector<std::string>{tupleName + "_accessor_array", tupleName + "_accessor_length"},
+			std::vector<SortPointer>{array, SortProvider::uintSort}
+		);
+	}
+	case Kind::Tuple:
+	{
+		std::vector<std::string> members;
+		auto const& tupleName = _type.toString(true);
+		std::vector<SortPointer> sorts;
+
+		if (auto const* tupleType = dynamic_cast<frontend::TupleType const*>(&_type))
+		{
+			auto const& components = tupleType->components();
+			for (unsigned i = 0; i < components.size(); ++i)
+				members.emplace_back(tupleName + "_accessor_" + std::to_string(i));
+			sorts = smtSortAbstractFunction(tupleType->components());
+		}
+		else if (auto const* structType = dynamic_cast<frontend::StructType const*>(&_type))
+		{
+			solAssert(!structType->recursive(), "");
+			auto const& structMembers = structType->structDefinition().members();
+			for (auto member: structMembers)
+				members.emplace_back(tupleName + "_accessor_" + member->name());
+			sorts = smtSortAbstractFunction(applyMap(
+				structMembers,
+				[](auto var) { return var->type(); }
+			));
+		}
+		else
+			solAssert(false, "");
+
+		return std::make_shared<TupleSort>(tupleName, members, sorts);
+	}
+	default:
+		// Abstract case.
+		return SortProvider::uintSort;
+	}
+}
+
+std::vector<SortPointer> smtSort(std::vector<frontend::Type const*> const& _types)
+{
+	std::vector<SortPointer> sorts;
+	for (auto const& type: _types)
+		sorts.push_back(smtSort(*type));
+	return sorts;
+}
+
+SortPointer smtSortAbstractFunction(frontend::Type const& _type)
+{
+	if (isFunction(_type))
+		return SortProvider::uintSort;
+	return smtSort(_type);
+}
+
+std::vector<SortPointer> smtSortAbstractFunction(std::vector<frontend::Type const*> const& _types)
+{
+	std::vector<SortPointer> sorts;
+	for (auto const& type: _types)
+		if (type)
+			sorts.push_back(smtSortAbstractFunction(*type));
+		else
+			sorts.push_back(SortProvider::uintSort);
+	return sorts;
+}
+
+Kind smtKind(frontend::Type const& _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(&_type))
+		return smtKind(userType->underlyingType());
+
+	if (isNumber(_type))
+		return Kind::Int;
+	else if (isBool(_type))
+		return Kind::Bool;
+	else if (isFunction(_type))
+		return Kind::Function;
+	else if (isMapping(_type) || isArray(_type))
+		return Kind::Array;
+	else if (isTuple(_type) || isNonRecursiveStruct(_type))
+		return Kind::Tuple;
+	// Abstract case.
+	return Kind::Int;
+}
+
+bool isSupportedType(frontend::Type const& _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(&_type))
+		return isSupportedType(userType->underlyingType());
+
+	return isNumber(_type) ||
+		isBool(_type) ||
+		isMapping(_type) ||
+		isArray(_type) ||
+		isTuple(_type) ||
+		isNonRecursiveStruct(_type);
+}
+
+bool isSupportedTypeDeclaration(frontend::Type const& _type)
+{
+	return isSupportedType(_type) ||
+		isFunction(_type);
+}
+
+std::pair<bool, std::shared_ptr<SymbolicVariable>> newSymbolicVariable(
+	frontend::Type const& _type,
+	std::string const& _uniqueName,
+	EncodingContext& _context
+)
+{
+	bool abstract = false;
+	std::shared_ptr<SymbolicVariable> var;
+	frontend::Type const* type = &_type;
+
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(type))
+		return newSymbolicVariable(userType->underlyingType(), _uniqueName, _context);
+
+	if (!isSupportedTypeDeclaration(_type))
+	{
+		abstract = true;
+		var = std::make_shared<SymbolicIntVariable>(frontend::TypeProvider::uint256(), type, _uniqueName, _context);
+	}
+	else if (isBool(_type))
+		var = std::make_shared<SymbolicBoolVariable>(type, _uniqueName, _context);
+	else if (isFunction(_type))
+	{
+		auto const& fType = dynamic_cast<FunctionType const*>(type);
+		auto const& paramsIn = fType->parameterTypes();
+		auto const& paramsOut = fType->returnParameterTypes();
+		auto findFunctionParam = [&](auto&& params) {
+			return find_if(
+				begin(params),
+				end(params),
+				[&](frontend::Type const* _paramType) { return _paramType->category() == frontend::Type::Category::Function; }
+			);
+		};
+		if (
+			findFunctionParam(paramsIn) != end(paramsIn) ||
+			findFunctionParam(paramsOut) != end(paramsOut)
+		)
+		{
+			abstract = true;
+			var = std::make_shared<SymbolicIntVariable>(TypeProvider::uint256(), type, _uniqueName, _context);
+		}
+		else
+			var = std::make_shared<SymbolicFunctionVariable>(type, _uniqueName, _context);
+	}
+	else if (isInteger(_type))
+		var = std::make_shared<SymbolicIntVariable>(type, type, _uniqueName, _context);
+	else if (isFixedPoint(_type))
+		var = std::make_shared<SymbolicIntVariable>(type, type, _uniqueName, _context);
+	else if (isFixedBytes(_type))
+	{
+		auto fixedBytesType = dynamic_cast<frontend::FixedBytesType const*>(type);
+		solAssert(fixedBytesType, "");
+		var = std::make_shared<SymbolicFixedBytesVariable>(type, fixedBytesType->numBytes(), _uniqueName, _context);
+	}
+	else if (isAddress(_type) || isContract(_type))
+		var = std::make_shared<SymbolicAddressVariable>(_uniqueName, _context);
+	else if (isEnum(_type))
+		var = std::make_shared<SymbolicEnumVariable>(type, _uniqueName, _context);
+	else if (isRational(_type))
+	{
+		auto rational = dynamic_cast<frontend::RationalNumberType const*>(&_type);
+		solAssert(rational, "");
+		if (rational->isFractional())
+			var = std::make_shared<SymbolicIntVariable>(frontend::TypeProvider::uint256(), type, _uniqueName, _context);
+		else
+			var = std::make_shared<SymbolicIntVariable>(type, type, _uniqueName, _context);
+	}
+	else if (isMapping(_type) || isArray(_type))
+		var = std::make_shared<SymbolicArrayVariable>(type, type, _uniqueName, _context);
+	else if (isTuple(_type))
+		var = std::make_shared<SymbolicTupleVariable>(type, _uniqueName, _context);
+	else if (isStringLiteral(_type))
+	{
+		auto stringType = TypeProvider::stringMemory();
+		var = std::make_shared<SymbolicArrayVariable>(stringType, type, _uniqueName, _context);
+	}
+	else if (isNonRecursiveStruct(_type))
+		var = std::make_shared<SymbolicStructVariable>(type, _uniqueName, _context);
+	else
+		solAssert(false, "");
+	return make_pair(abstract, var);
+}
+
+bool isInteger(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Integer;
+}
+
+bool isFixedPoint(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::FixedPoint;
+}
+
+bool isRational(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::RationalNumber;
+}
+
+bool isFixedBytes(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::FixedBytes;
+}
+
+bool isAddress(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Address;
+}
+
+bool isContract(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Contract;
+}
+
+bool isEnum(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Enum;
+}
+
+bool isNumber(frontend::Type const& _type)
+{
+	return isInteger(_type) ||
+		isFixedPoint(_type) ||
+		isRational(_type) ||
+		isFixedBytes(_type) ||
+		isAddress(_type) ||
+		isContract(_type) ||
+		isEnum(_type);
+}
+
+bool isBool(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Bool;
+}
+
+bool isFunction(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Function;
+}
+
+bool isMapping(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Mapping;
+}
+
+bool isArray(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Array ||
+		_type.category() == frontend::Type::Category::StringLiteral ||
+		_type.category() == frontend::Type::Category::ArraySlice;
+}
+
+bool isTuple(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::Tuple;
+}
+
+bool isStringLiteral(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::StringLiteral;
+}
+
+bool isNonRecursiveStruct(frontend::Type const& _type)
+{
+	auto structType = dynamic_cast<StructType const*>(&_type);
+	return structType && !structType->recursive();
+}
+
+bool isInaccessibleDynamic(frontend::Type const& _type)
+{
+	return _type.category() == frontend::Type::Category::InaccessibleDynamic;
+}
+
+smtutil::Expression minValue(frontend::IntegerType const& _type)
+{
+	return smtutil::Expression(_type.minValue());
+}
+
+smtutil::Expression minValue(frontend::Type const* _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return minValue(&userType->underlyingType());
+
+	solAssert(isNumber(*_type), "");
+	if (auto const* intType = dynamic_cast<IntegerType const*>(_type))
+		return intType->minValue();
+	if (auto const* fixedType = dynamic_cast<FixedPointType const*>(_type))
+		return fixedType->minIntegerValue();
+	if (
+		dynamic_cast<AddressType const*>(_type) ||
+		dynamic_cast<ContractType const*>(_type) ||
+		dynamic_cast<EnumType const*>(_type) ||
+		dynamic_cast<FixedBytesType const*>(_type)
+	)
+		return 0;
+	solAssert(false, "");
+}
+
+smtutil::Expression maxValue(frontend::IntegerType const& _type)
+{
+	return smtutil::Expression(_type.maxValue());
+}
+
+smtutil::Expression maxValue(frontend::Type const* _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return maxValue(&userType->underlyingType());
+
+	solAssert(isNumber(*_type), "");
+	if (auto const* intType = dynamic_cast<IntegerType const*>(_type))
+		return intType->maxValue();
+	if (auto const* fixedType = dynamic_cast<FixedPointType const*>(_type))
+		return fixedType->maxIntegerValue();
+	if (
+		dynamic_cast<AddressType const*>(_type) ||
+		dynamic_cast<ContractType const*>(_type)
+	)
+		return TypeProvider::uint(160)->maxValue();
+	if (auto const* enumType = dynamic_cast<EnumType const*>(_type))
+		return enumType->numberOfMembers() - 1;
+	if (auto const* bytesType = dynamic_cast<FixedBytesType const*>(_type))
+		return TypeProvider::uint(bytesType->numBytes() * 8)->maxValue();
+	solAssert(false, "");
+}
+
+void setSymbolicZeroValue(SymbolicVariable const& _variable, EncodingContext& _context)
+{
+	setSymbolicZeroValue(_variable.currentValue(), _variable.type(), _context);
+}
+
+void setSymbolicZeroValue(smtutil::Expression _expr, frontend::Type const* _type, EncodingContext& _context)
+{
+	solAssert(_type, "");
+	_context.addAssertion(_expr == zeroValue(_type));
+}
+
+smtutil::Expression zeroValue(frontend::Type const* _type)
+{
+	solAssert(_type, "");
+
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return zeroValue(&userType->underlyingType());
+
+	if (isSupportedType(*_type))
+	{
+		if (isNumber(*_type))
+			return 0;
+		if (isBool(*_type))
+			return smtutil::Expression(false);
+		if (isArray(*_type) || isMapping(*_type))
+		{
+			auto tupleSort = std::dynamic_pointer_cast<TupleSort>(smtSort(*_type));
+			solAssert(tupleSort, "");
+			auto sortSort = std::make_shared<SortSort>(tupleSort->components.front());
+
+			std::optional<smtutil::Expression> zeroArray;
+			auto length = bigint(0);
+			if (auto arrayType = dynamic_cast<ArrayType const*>(_type))
+			{
+				zeroArray = smtutil::Expression::const_array(smtutil::Expression(sortSort), zeroValue(arrayType->baseType()));
+				if (!arrayType->isDynamicallySized())
+					length = bigint(arrayType->length());
+			}
+			else if (auto mappingType = dynamic_cast<MappingType const*>(_type))
+				zeroArray = smtutil::Expression::const_array(smtutil::Expression(sortSort), zeroValue(mappingType->valueType()));
+			else
+				solAssert(false, "");
+
+			solAssert(zeroArray, "");
+			return smtutil::Expression::tuple_constructor(
+				smtutil::Expression(std::make_shared<SortSort>(tupleSort), tupleSort->name),
+				std::vector<smtutil::Expression>{*zeroArray, length}
+			);
+
+		}
+		if (isNonRecursiveStruct(*_type))
+		{
+			auto const* structType = dynamic_cast<StructType const*>(_type);
+			auto structSort = std::dynamic_pointer_cast<TupleSort>(smtSort(*_type));
+			return smtutil::Expression::tuple_constructor(
+				smtutil::Expression(std::make_shared<SortSort>(structSort), structSort->name),
+				applyMap(
+					structType->structDefinition().members(),
+					[](auto var) { return zeroValue(var->type()); }
+				)
+			);
+		}
+		solAssert(false, "");
+	}
+	// Unsupported types are abstracted as Int.
+	return 0;
+}
+
+bool isSigned(frontend::Type const* _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return isSigned(&userType->underlyingType());
+
+	solAssert(smt::isNumber(*_type), "");
+	bool isSigned = false;
+	if (auto const* numberType = dynamic_cast<RationalNumberType const*>(_type))
+		isSigned |= numberType->isNegative();
+	else if (auto const* intType = dynamic_cast<IntegerType const*>(_type))
+		isSigned |= intType->isSigned();
+	else if (auto const* fixedType = dynamic_cast<FixedPointType const*>(_type))
+		isSigned |= fixedType->isSigned();
+	else if (
+		dynamic_cast<AddressType const*>(_type) ||
+		dynamic_cast<ContractType const*>(_type) ||
+		dynamic_cast<EnumType const*>(_type) ||
+		dynamic_cast<FixedBytesType const*>(_type)
+	)
+		return false;
+	else
+		solAssert(false, "");
+
+	return isSigned;
+}
+
+std::pair<unsigned, bool> typeBvSizeAndSignedness(frontend::Type const* _type)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return typeBvSizeAndSignedness(&userType->underlyingType());
+
+	if (auto const* intType = dynamic_cast<IntegerType const*>(_type))
+		return {intType->numBits(), intType->isSigned()};
+	else if (auto const* fixedType = dynamic_cast<FixedPointType const*>(_type))
+		return {fixedType->numBits(), fixedType->isSigned()};
+	else if (auto const* fixedBytesType = dynamic_cast<FixedBytesType const*>(_type))
+		return {fixedBytesType->numBytes() * 8, false};
+	else
+		solAssert(false, "");
+}
+
+void setSymbolicUnknownValue(SymbolicVariable const& _variable, EncodingContext& _context)
+{
+	setSymbolicUnknownValue(_variable.currentValue(), _variable.type(), _context);
+}
+
+void setSymbolicUnknownValue(smtutil::Expression _expr, frontend::Type const* _type, EncodingContext& _context)
+{
+	_context.addAssertion(symbolicUnknownConstraints(_expr, _type));
+}
+
+smtutil::Expression symbolicUnknownConstraints(smtutil::Expression _expr, frontend::Type const* _type)
+{
+	solAssert(_type, "");
+
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_type))
+		return symbolicUnknownConstraints(std::move(_expr), &userType->underlyingType());
+
+	if (isEnum(*_type) || isInteger(*_type) || isAddress(*_type) || isFixedBytes(*_type))
+		return _expr >= minValue(_type) && _expr <= maxValue(_type);
+	else if (
+		auto arrayType = dynamic_cast<ArrayType const*>(_type);
+		arrayType && !arrayType->isDynamicallySized()
+	)
+		return smtutil::Expression::tuple_get(_expr, 1) == arrayType->length();
+	else if (isArray(*_type) || isMapping(*_type))
+		/// Length cannot be negative.
+		return smtutil::Expression::tuple_get(_expr, 1) >= 0;
+
+	return smtutil::Expression(true);
+}
+
+std::optional<smtutil::Expression> symbolicTypeConversion(frontend::Type const* _from, frontend::Type const* _to)
+{
+	if (auto userType = dynamic_cast<UserDefinedValueType const*>(_to))
+		return symbolicTypeConversion(_from, &userType->underlyingType());
+
+	if (_to && _from)
+		// StringLiterals are encoded as SMT arrays in the generic case,
+		// but they can also be compared/assigned to fixed bytes, in which
+		// case they'd need to be encoded as numbers.
+		if (auto strType = dynamic_cast<StringLiteralType const*>(_from))
+			if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(_to))
+			{
+				if (strType->value().empty())
+					return smtutil::Expression(size_t(0));
+				auto bytesVec = util::asBytes(strType->value());
+				bytesVec.resize(fixedBytesType->numBytes(), 0);
+				return smtutil::Expression(u256(util::toHex(bytesVec, util::HexPrefix::Add)));
+			}
+
+	return std::nullopt;
+}
+
+smtutil::Expression member(smtutil::Expression const& _tuple, std::string const& _member)
+{
+	TupleSort const& _sort = dynamic_cast<TupleSort const&>(*_tuple.sort);
+	return smtutil::Expression::tuple_get(
+		_tuple,
+		_sort.memberToIndex.at(_member)
+	);
+}
+
+smtutil::Expression assignMember(smtutil::Expression const _tuple, std::map<std::string, smtutil::Expression> const& _values)
+{
+	TupleSort const& _sort = dynamic_cast<TupleSort const&>(*_tuple.sort);
+	std::vector<smtutil::Expression> args;
+	for (auto const& m: _sort.members)
+		if (auto* value = util::valueOrNullptr(_values, m))
+			args.emplace_back(*value);
+		else
+			args.emplace_back(member(_tuple, m));
+	auto sortExpr = smtutil::Expression(std::make_shared<smtutil::SortSort>(_tuple.sort), _tuple.name);
+	return smtutil::Expression::tuple_constructor(sortExpr, args);
+}
+
+}
diff --git a/compiler/libsolidity/formal/SymbolicTypes.h b/compiler/libsolidity/formal/SymbolicTypes.h
new file mode 100644
index 00000000..747e27b7
--- /dev/null
+++ b/compiler/libsolidity/formal/SymbolicTypes.h
@@ -0,0 +1,89 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolidity/formal/SymbolicVariables.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/Types.h>
+
+namespace solidity::frontend::smt
+{
+
+class EncodingContext;
+
+/// Returns the SMT sort that models the Solidity type _type.
+smtutil::SortPointer smtSort(frontend::Type const& _type);
+std::vector<smtutil::SortPointer> smtSort(std::vector<frontend::Type const*> const& _types);
+/// If _type has type Function, abstract it to Integer.
+/// Otherwise return smtSort(_type).
+smtutil::SortPointer smtSortAbstractFunction(frontend::Type const& _type);
+std::vector<smtutil::SortPointer> smtSortAbstractFunction(std::vector<frontend::Type const*> const& _types);
+/// Returns the SMT kind that models the Solidity type type category _category.
+smtutil::Kind smtKind(frontend::Type const& _type);
+
+/// Returns true if type is fully supported (declaration and operations).
+bool isSupportedType(frontend::Type const& _type);
+bool isSupportedType(frontend::Type const& _type);
+/// Returns true if type is partially supported (declaration).
+bool isSupportedTypeDeclaration(frontend::Type const& _type);
+bool isSupportedTypeDeclaration(frontend::Type const& _type);
+
+bool isInteger(frontend::Type const& _type);
+bool isFixedPoint(frontend::Type const& _type);
+bool isRational(frontend::Type const& _type);
+bool isFixedBytes(frontend::Type const& _type);
+bool isAddress(frontend::Type const& _type);
+bool isContract(frontend::Type const& _type);
+bool isEnum(frontend::Type const& _type);
+bool isNumber(frontend::Type const& _type);
+bool isBool(frontend::Type const& _type);
+bool isFunction(frontend::Type const& _type);
+bool isMapping(frontend::Type const& _type);
+bool isArray(frontend::Type const& _type);
+bool isTuple(frontend::Type const& _type);
+bool isStringLiteral(frontend::Type const& _type);
+bool isNonRecursiveStruct(frontend::Type const& _type);
+bool isInaccessibleDynamic(frontend::Type const& _type);
+
+/// Returns a new symbolic variable, according to _type.
+/// Also returns whether the type is abstract or not,
+/// which is true for unsupported types.
+std::pair<bool, std::shared_ptr<SymbolicVariable>> newSymbolicVariable(frontend::Type const& _type, std::string const& _uniqueName, EncodingContext& _context);
+
+smtutil::Expression minValue(frontend::IntegerType const& _type);
+smtutil::Expression minValue(frontend::Type const* _type);
+smtutil::Expression maxValue(frontend::IntegerType const& _type);
+smtutil::Expression maxValue(frontend::Type const* _type);
+smtutil::Expression zeroValue(frontend::Type const* _type);
+bool isSigned(frontend::Type const* _type);
+
+std::pair<unsigned, bool> typeBvSizeAndSignedness(frontend::Type const* type);
+
+void setSymbolicZeroValue(SymbolicVariable const& _variable, EncodingContext& _context);
+void setSymbolicZeroValue(smtutil::Expression _expr, frontend::Type const* _type, EncodingContext& _context);
+void setSymbolicUnknownValue(SymbolicVariable const& _variable, EncodingContext& _context);
+void setSymbolicUnknownValue(smtutil::Expression _expr, frontend::Type const* _type, EncodingContext& _context);
+smtutil::Expression symbolicUnknownConstraints(smtutil::Expression _expr, frontend::Type const* _type);
+
+std::optional<smtutil::Expression> symbolicTypeConversion(frontend::Type const* _from, frontend::Type const* _to);
+
+smtutil::Expression member(smtutil::Expression const& _tuple, std::string const& _member);
+smtutil::Expression assignMember(smtutil::Expression const _tuple, std::map<std::string, smtutil::Expression> const& _values);
+
+}
diff --git a/compiler/libsolidity/formal/SymbolicVariables.cpp b/compiler/libsolidity/formal/SymbolicVariables.cpp
new file mode 100644
index 00000000..6d6dbee6
--- /dev/null
+++ b/compiler/libsolidity/formal/SymbolicVariables.cpp
@@ -0,0 +1,400 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/SymbolicVariables.h>
+
+#include <libsolidity/formal/EncodingContext.h>
+#include <libsolidity/formal/SymbolicTypes.h>
+
+#include <libsolutil/Algorithms.h>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::smtutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+SymbolicVariable::SymbolicVariable(
+	frontend::Type const* _type,
+	frontend::Type const* _originalType,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	m_type(_type),
+	m_originalType(_originalType),
+	m_uniqueName(std::move(_uniqueName)),
+	m_context(_context),
+	m_ssa(std::make_unique<SSAVariable>())
+{
+	solAssert(m_type, "");
+	m_sort = smtSort(*m_type);
+	solAssert(m_sort, "");
+}
+
+SymbolicVariable::SymbolicVariable(
+	SortPointer _sort,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	m_sort(std::move(_sort)),
+	m_uniqueName(std::move(_uniqueName)),
+	m_context(_context),
+	m_ssa(std::make_unique<SSAVariable>())
+{
+	solAssert(m_sort, "");
+}
+
+smtutil::Expression SymbolicVariable::currentValue(frontend::Type const*) const
+{
+	return valueAtIndex(m_ssa->index());
+}
+
+std::string SymbolicVariable::currentName() const
+{
+	return uniqueSymbol(m_ssa->index());
+}
+
+smtutil::Expression SymbolicVariable::valueAtIndex(unsigned _index) const
+{
+	return m_context.newVariable(uniqueSymbol(_index), m_sort);
+}
+
+std::string SymbolicVariable::nameAtIndex(unsigned _index) const
+{
+	return uniqueSymbol(_index);
+}
+
+std::string SymbolicVariable::uniqueSymbol(unsigned _index) const
+{
+	return m_uniqueName + "_" + std::to_string(_index);
+}
+
+smtutil::Expression SymbolicVariable::resetIndex()
+{
+	m_ssa->resetIndex();
+	return currentValue();
+}
+
+smtutil::Expression SymbolicVariable::setIndex(unsigned _index)
+{
+	m_ssa->setIndex(_index);
+	return currentValue();
+}
+
+smtutil::Expression SymbolicVariable::increaseIndex()
+{
+	++(*m_ssa);
+	return currentValue();
+}
+
+SymbolicBoolVariable::SymbolicBoolVariable(
+	frontend::Type const* _type,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _type, std::move(_uniqueName), _context)
+{
+	solAssert(m_type->category() == frontend::Type::Category::Bool, "");
+}
+
+SymbolicIntVariable::SymbolicIntVariable(
+	frontend::Type const* _type,
+	frontend::Type const* _originalType,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _originalType, std::move(_uniqueName), _context)
+{
+	solAssert(isNumber(*m_type), "");
+}
+
+SymbolicAddressVariable::SymbolicAddressVariable(
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicIntVariable(TypeProvider::uint(160), TypeProvider::uint(160), std::move(_uniqueName), _context)
+{
+}
+
+SymbolicFixedBytesVariable::SymbolicFixedBytesVariable(
+	frontend::Type const* _originalType,
+	unsigned _numBytes,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicIntVariable(TypeProvider::uint(_numBytes * 8), _originalType, std::move(_uniqueName), _context)
+{
+}
+
+SymbolicFunctionVariable::SymbolicFunctionVariable(
+	frontend::Type const* _type,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _type, std::move(_uniqueName), _context),
+	m_declaration(m_context.newVariable(currentName(), m_sort))
+{
+	solAssert(m_type->category() == frontend::Type::Category::Function, "");
+}
+
+SymbolicFunctionVariable::SymbolicFunctionVariable(
+	SortPointer _sort,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(std::move(_sort), std::move(_uniqueName), _context),
+	m_declaration(m_context.newVariable(currentName(), m_sort))
+{
+	solAssert(m_sort->kind == Kind::Function, "");
+}
+
+smtutil::Expression SymbolicFunctionVariable::currentValue(frontend::Type const* _targetType) const
+{
+	return m_abstract.currentValue(_targetType);
+}
+
+smtutil::Expression SymbolicFunctionVariable::currentFunctionValue() const
+{
+	return m_declaration;
+}
+
+smtutil::Expression SymbolicFunctionVariable::valueAtIndex(unsigned _index) const
+{
+	return m_abstract.valueAtIndex(_index);
+}
+
+smtutil::Expression SymbolicFunctionVariable::functionValueAtIndex(unsigned _index) const
+{
+	return SymbolicVariable::valueAtIndex(_index);
+}
+
+smtutil::Expression SymbolicFunctionVariable::resetIndex()
+{
+	SymbolicVariable::resetIndex();
+	return m_abstract.resetIndex();
+}
+
+smtutil::Expression SymbolicFunctionVariable::setIndex(unsigned _index)
+{
+	SymbolicVariable::setIndex(_index);
+	return m_abstract.setIndex(_index);
+}
+
+smtutil::Expression SymbolicFunctionVariable::increaseIndex()
+{
+	++(*m_ssa);
+	resetDeclaration();
+	m_abstract.increaseIndex();
+	return m_abstract.currentValue();
+}
+
+smtutil::Expression SymbolicFunctionVariable::operator()(std::vector<smtutil::Expression> _arguments) const
+{
+	return m_declaration(_arguments);
+}
+
+void SymbolicFunctionVariable::resetDeclaration()
+{
+	m_declaration = m_context.newVariable(currentName(), m_sort);
+}
+
+SymbolicEnumVariable::SymbolicEnumVariable(
+	frontend::Type const* _type,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _type, std::move(_uniqueName), _context)
+{
+	solAssert(isEnum(*m_type), "");
+}
+
+SymbolicTupleVariable::SymbolicTupleVariable(
+	frontend::Type const* _type,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _type, std::move(_uniqueName), _context)
+{
+	solAssert(isTuple(*m_type), "");
+}
+
+SymbolicTupleVariable::SymbolicTupleVariable(
+	SortPointer _sort,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(std::move(_sort), std::move(_uniqueName), _context)
+{
+	solAssert(m_sort->kind == Kind::Tuple, "");
+}
+
+smtutil::Expression SymbolicTupleVariable::currentValue(frontend::Type const* _targetType) const
+{
+	if (!_targetType || sort() == smtSort(*_targetType))
+		return SymbolicVariable::currentValue();
+
+	auto thisTuple = std::dynamic_pointer_cast<TupleSort>(sort());
+	auto otherTuple = std::dynamic_pointer_cast<TupleSort>(smtSort(*_targetType));
+	solAssert(thisTuple && otherTuple, "");
+	solAssert(thisTuple->components.size() == otherTuple->components.size(), "");
+	std::vector<smtutil::Expression> args;
+	for (size_t i = 0; i < thisTuple->components.size(); ++i)
+		args.emplace_back(component(i, type(), _targetType));
+	return smtutil::Expression::tuple_constructor(
+		smtutil::Expression(std::make_shared<smtutil::SortSort>(smtSort(*_targetType)), ""),
+		args
+	);
+}
+
+std::vector<SortPointer> const& SymbolicTupleVariable::components() const
+{
+	auto tupleSort = std::dynamic_pointer_cast<TupleSort>(m_sort);
+	solAssert(tupleSort, "");
+	return tupleSort->components;
+}
+
+smtutil::Expression SymbolicTupleVariable::component(
+	size_t _index,
+	frontend::Type const* _fromType,
+	frontend::Type const* _toType
+) const
+{
+	std::optional<smtutil::Expression> conversion = symbolicTypeConversion(_fromType, _toType);
+	if (conversion)
+		return *conversion;
+
+	return smtutil::Expression::tuple_get(currentValue(), _index);
+}
+
+SymbolicArrayVariable::SymbolicArrayVariable(
+	frontend::Type const* _type,
+	frontend::Type const* _originalType,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _originalType, std::move(_uniqueName), _context),
+	m_pair(
+		smtSort(*_type),
+		m_uniqueName + "_length_pair",
+		m_context
+	)
+{
+	solAssert(isArray(*m_type) || isMapping(*m_type), "");
+}
+
+SymbolicArrayVariable::SymbolicArrayVariable(
+	SortPointer _sort,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(std::move(_sort), std::move(_uniqueName), _context),
+	m_pair(
+		std::make_shared<TupleSort>(
+			"array_length_pair",
+			std::vector<std::string>{"array", "length"},
+			std::vector<SortPointer>{m_sort, SortProvider::uintSort}
+		),
+		m_uniqueName + "_array_length_pair",
+		m_context
+	)
+{
+	solAssert(m_sort->kind == Kind::Array, "");
+}
+
+smtutil::Expression SymbolicArrayVariable::currentValue(frontend::Type const* _targetType) const
+{
+	std::optional<smtutil::Expression> conversion = symbolicTypeConversion(m_originalType, _targetType);
+	if (conversion)
+		return *conversion;
+
+	return m_pair.currentValue();
+}
+
+smtutil::Expression SymbolicArrayVariable::valueAtIndex(unsigned _index) const
+{
+	return m_pair.valueAtIndex(_index);
+}
+
+smtutil::Expression SymbolicArrayVariable::elements() const
+{
+	return m_pair.component(0);
+}
+
+smtutil::Expression SymbolicArrayVariable::length() const
+{
+	return m_pair.component(1);
+}
+
+SymbolicStructVariable::SymbolicStructVariable(
+	frontend::Type const* _type,
+	std::string _uniqueName,
+	EncodingContext& _context
+):
+	SymbolicVariable(_type, _type, std::move(_uniqueName), _context)
+{
+	solAssert(isNonRecursiveStruct(*m_type), "");
+	auto const* structType = dynamic_cast<StructType const*>(_type);
+	solAssert(structType, "");
+	auto const& members = structType->structDefinition().members();
+	for (unsigned i = 0; i < members.size(); ++i)
+	{
+		solAssert(members.at(i), "");
+		m_memberIndices.emplace(members.at(i)->name(), i);
+	}
+}
+
+smtutil::Expression SymbolicStructVariable::member(std::string const& _member) const
+{
+	return smtutil::Expression::tuple_get(currentValue(), m_memberIndices.at(_member));
+}
+
+smtutil::Expression SymbolicStructVariable::assignMember(std::string const& _member, smtutil::Expression const& _memberValue)
+{
+	auto const* structType = dynamic_cast<StructType const*>(m_type);
+	solAssert(structType, "");
+	auto const& structDef = structType->structDefinition();
+	auto const& structMembers = structDef.members();
+	auto oldMembers = applyMap(
+		structMembers,
+		[&](auto _member) { return member(_member->name()); }
+	);
+	increaseIndex();
+	for (unsigned i = 0; i < structMembers.size(); ++i)
+	{
+		auto const& memberName = structMembers.at(i)->name();
+		auto newMember = memberName == _member ? _memberValue : oldMembers.at(i);
+		m_context.addAssertion(member(memberName) == newMember);
+	}
+
+	return currentValue();
+}
+
+smtutil::Expression SymbolicStructVariable::assignAllMembers(std::vector<smtutil::Expression> const& _memberValues)
+{
+	auto structType = dynamic_cast<StructType const*>(m_type);
+	solAssert(structType, "");
+
+	auto const& structDef = structType->structDefinition();
+	auto const& structMembers = structDef.members();
+	solAssert(_memberValues.size() == structMembers.size(), "");
+	increaseIndex();
+	for (unsigned i = 0; i < _memberValues.size(); ++i)
+		m_context.addAssertion(_memberValues[i] == member(structMembers[i]->name()));
+
+	return currentValue();
+}
diff --git a/compiler/libsolidity/formal/VariableUsage.cpp b/compiler/libsolidity/formal/VariableUsage.cpp
new file mode 100644
index 00000000..ab7c425a
--- /dev/null
+++ b/compiler/libsolidity/formal/VariableUsage.cpp
@@ -0,0 +1,118 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/formal/VariableUsage.h>
+
+#include <libsolidity/formal/BMC.h>
+#include <libsolidity/formal/SMTEncoder.h>
+
+#include <range/v3/view.hpp>
+
+#include <algorithm>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend;
+using namespace solidity::frontend::smt;
+
+std::set<VariableDeclaration const*> VariableUsage::touchedVariables(ASTNode const& _node, std::vector<CallableDeclaration const*> const& _outerCallstack)
+{
+	m_touchedVariables.clear();
+	m_callStack.clear();
+	m_callStack += _outerCallstack;
+	if (!m_callStack.empty())
+		m_lastCall = m_callStack.back();
+	_node.accept(*this);
+	return m_touchedVariables;
+}
+
+void VariableUsage::endVisit(Identifier const& _identifier)
+{
+	if (_identifier.annotation().willBeWrittenTo)
+		checkIdentifier(_identifier);
+}
+
+void VariableUsage::endVisit(IndexAccess const& _indexAccess)
+{
+	if (_indexAccess.annotation().willBeWrittenTo)
+	{
+		/// identifier.annotation().willBeWrittenTo == false, that's why we
+		/// need to check that before.
+		auto identifier = dynamic_cast<Identifier const*>(SMTEncoder::leftmostBase(_indexAccess));
+		if (identifier)
+			checkIdentifier(*identifier);
+	}
+}
+
+void VariableUsage::endVisit(FunctionCall const& _funCall)
+{
+	auto scopeContract = currentScopeContract();
+	if (m_inlineFunctionCalls(_funCall, scopeContract, m_currentContract))
+		if (auto funDef = SMTEncoder::functionCallToDefinition(_funCall, scopeContract, m_currentContract))
+			if (find(m_callStack.begin(), m_callStack.end(), funDef) == m_callStack.end())
+				funDef->accept(*this);
+}
+
+bool VariableUsage::visit(FunctionDefinition const& _function)
+{
+	m_callStack.push_back(&_function);
+	return true;
+}
+
+void VariableUsage::endVisit(FunctionDefinition const&)
+{
+	solAssert(!m_callStack.empty(), "");
+	m_callStack.pop_back();
+}
+
+void VariableUsage::endVisit(ModifierInvocation const& _modifierInv)
+{
+	auto const& modifierDef = dynamic_cast<ModifierDefinition const*>(_modifierInv.name().annotation().referencedDeclaration);
+	if (modifierDef)
+		modifierDef->accept(*this);
+}
+
+void VariableUsage::endVisit(PlaceholderStatement const&)
+{
+	solAssert(!m_callStack.empty(), "");
+	FunctionDefinition const* funDef = nullptr;
+	for (auto it = m_callStack.rbegin(); it != m_callStack.rend() && !funDef; ++it)
+		funDef = dynamic_cast<FunctionDefinition const*>(*it);
+	solAssert(funDef, "");
+	if (funDef->isImplemented())
+		funDef->body().accept(*this);
+}
+
+void VariableUsage::checkIdentifier(Identifier const& _identifier)
+{
+	Declaration const* declaration = _identifier.annotation().referencedDeclaration;
+	solAssert(declaration, "");
+	if (VariableDeclaration const* varDecl = dynamic_cast<VariableDeclaration const*>(declaration))
+	{
+		if (!varDecl->isLocalVariable() || (m_lastCall && varDecl->functionOrModifierDefinition() == m_lastCall))
+			m_touchedVariables.insert(varDecl);
+	}
+}
+
+ContractDefinition const* VariableUsage::currentScopeContract()
+{
+	for (auto&& f: m_callStack | ranges::views::reverse)
+		if (auto fun = dynamic_cast<FunctionDefinition const*>(f))
+			return fun->annotation().contract;
+	return nullptr;
+}
diff --git a/compiler/libsolidity/interface/ABI.cpp b/compiler/libsolidity/interface/ABI.cpp
new file mode 100644
index 00000000..cf6e863b
--- /dev/null
+++ b/compiler/libsolidity/interface/ABI.cpp
@@ -0,0 +1,218 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Utilities to handle the Contract ABI (https://docs.soliditylang.org/en/develop/abi-spec.html)
+ */
+
+#include <libsolidity/interface/ABI.h>
+
+#include <libsolidity/ast/AST.h>
+
+using namespace solidity;
+using namespace solidity::frontend;
+
+namespace
+{
+bool anyDataStoredInStorage(TypePointers const& _pointers)
+{
+	for (Type const* pointer: _pointers)
+		if (pointer->dataStoredIn(DataLocation::Storage))
+			return true;
+
+	return false;
+}
+}
+
+Json::Value ABI::generate(ContractDefinition const& _contractDef)
+{
+	auto compare = [](Json::Value const& _a, Json::Value const& _b) -> bool {
+		return std::make_tuple(_a["type"], _a["name"]) < std::make_tuple(_b["type"], _b["name"]);
+	};
+	std::multiset<Json::Value, decltype(compare)> abi(compare);
+
+	for (auto it: _contractDef.interfaceFunctions())
+	{
+		if (_contractDef.isLibrary() && (
+			it.second->stateMutability() > StateMutability::View ||
+			anyDataStoredInStorage(it.second->parameterTypes() + it.second->returnParameterTypes())
+		))
+			continue;
+
+		FunctionType const* externalFunctionType = it.second->interfaceFunctionType();
+		solAssert(!!externalFunctionType, "");
+		Json::Value method{Json::objectValue};
+		method["type"] = "function";
+		method["name"] = it.second->declaration().name();
+		method["stateMutability"] = stateMutabilityToString(externalFunctionType->stateMutability());
+		method["inputs"] = formatTypeList(
+			externalFunctionType->parameterNames(),
+			externalFunctionType->parameterTypes(),
+			it.second->parameterTypes(),
+			_contractDef.isLibrary()
+		);
+		method["outputs"] = formatTypeList(
+			externalFunctionType->returnParameterNames(),
+			externalFunctionType->returnParameterTypes(),
+			it.second->returnParameterTypes(),
+			_contractDef.isLibrary()
+		);
+		abi.emplace(std::move(method));
+	}
+	FunctionDefinition const* constructor = _contractDef.constructor();
+	if (constructor && !_contractDef.abstract())
+	{
+		FunctionType constrType(*constructor);
+		FunctionType const* externalFunctionType = constrType.interfaceFunctionType();
+		solAssert(!!externalFunctionType, "");
+		Json::Value method{Json::objectValue};
+		method["type"] = "constructor";
+		method["stateMutability"] = stateMutabilityToString(externalFunctionType->stateMutability());
+		method["inputs"] = formatTypeList(
+			externalFunctionType->parameterNames(),
+			externalFunctionType->parameterTypes(),
+			constrType.parameterTypes(),
+			_contractDef.isLibrary()
+		);
+		abi.emplace(std::move(method));
+	}
+	for (auto const* fallbackOrReceive: {_contractDef.fallbackFunction(), _contractDef.receiveFunction()})
+		if (fallbackOrReceive)
+		{
+			auto const* externalFunctionType = FunctionType(*fallbackOrReceive).interfaceFunctionType();
+			solAssert(!!externalFunctionType, "");
+			Json::Value method{Json::objectValue};
+			method["type"] = TokenTraits::toString(fallbackOrReceive->kind());
+			method["stateMutability"] = stateMutabilityToString(externalFunctionType->stateMutability());
+			abi.emplace(std::move(method));
+		}
+	for (auto const& it: _contractDef.interfaceEvents())
+	{
+		Json::Value event{Json::objectValue};
+		event["type"] = "event";
+		event["name"] = it->name();
+		event["anonymous"] = it->isAnonymous();
+		Json::Value params{Json::arrayValue};
+		for (auto const& p: it->parameters())
+		{
+			Type const* type = p->annotation().type->interfaceType(false);
+			solAssert(type, "");
+			auto param = formatType(p->name(), *type, *p->annotation().type, false);
+			param["indexed"] = p->isIndexed();
+			params.append(std::move(param));
+		}
+		event["inputs"] = std::move(params);
+		abi.emplace(std::move(event));
+	}
+
+	for (ErrorDefinition const* error: _contractDef.interfaceErrors())
+	{
+		Json::Value errorJson{Json::objectValue};
+		errorJson["type"] = "error";
+		errorJson["name"] = error->name();
+		errorJson["inputs"] = Json::arrayValue;
+		for (auto const& p: error->parameters())
+		{
+			Type const* type = p->annotation().type->interfaceType(false);
+			solAssert(type, "");
+			errorJson["inputs"].append(
+				formatType(p->name(), *type, *p->annotation().type, false)
+			);
+		}
+		abi.emplace(std::move(errorJson));
+	}
+
+	Json::Value abiJson{Json::arrayValue};
+	for (auto& f: abi)
+		abiJson.append(std::move(f));
+	return abiJson;
+}
+
+Json::Value ABI::formatTypeList(
+	std::vector<std::string> const& _names,
+	std::vector<Type const*> const& _encodingTypes,
+	std::vector<Type const*> const& _solidityTypes,
+	bool _forLibrary
+)
+{
+	Json::Value params{Json::arrayValue};
+	solAssert(_names.size() == _encodingTypes.size(), "Names and types vector size does not match");
+	solAssert(_names.size() == _solidityTypes.size(), "");
+	for (unsigned i = 0; i < _names.size(); ++i)
+	{
+		solAssert(_encodingTypes[i], "");
+		params.append(formatType(_names[i], *_encodingTypes[i], *_solidityTypes[i], _forLibrary));
+	}
+	return params;
+}
+
+Json::Value ABI::formatType(
+	std::string const& _name,
+	Type const& _encodingType,
+	Type const& _solidityType,
+	bool _forLibrary
+)
+{
+	Json::Value ret{Json::objectValue};
+	ret["name"] = _name;
+	ret["internalType"] = _solidityType.toString(true);
+	std::string suffix = (_forLibrary && _encodingType.dataStoredIn(DataLocation::Storage)) ? " storage" : "";
+	if (_encodingType.isValueType() || (_forLibrary && _encodingType.dataStoredIn(DataLocation::Storage)))
+		ret["type"] = _encodingType.canonicalName() + suffix;
+	else if (ArrayType const* arrayType = dynamic_cast<ArrayType const*>(&_encodingType))
+	{
+		if (arrayType->isByteArrayOrString())
+			ret["type"] = _encodingType.canonicalName() + suffix;
+		else
+		{
+			std::string suffix;
+			if (arrayType->isDynamicallySized())
+				suffix = "[]";
+			else
+				suffix = std::string("[") + arrayType->length().str() + "]";
+			solAssert(arrayType->baseType(), "");
+			Json::Value subtype = formatType(
+				"",
+				*arrayType->baseType(),
+				*dynamic_cast<ArrayType const&>(_solidityType).baseType(),
+				_forLibrary
+			);
+			if (subtype.isMember("components"))
+			{
+				ret["type"] = subtype["type"].asString() + suffix;
+				ret["components"] = subtype["components"];
+			}
+			else
+				ret["type"] = subtype["type"].asString() + suffix;
+		}
+	}
+	else if (StructType const* structType = dynamic_cast<StructType const*>(&_encodingType))
+	{
+		ret["type"] = "tuple";
+		ret["components"] = Json::arrayValue;
+		for (auto const& member: structType->members(nullptr))
+		{
+			solAssert(member.type, "");
+			Type const* t = member.type->interfaceType(_forLibrary);
+			solAssert(t, "");
+			ret["components"].append(formatType(member.name, *t, *member.type, _forLibrary));
+		}
+	}
+	else
+		solAssert(false, "Invalid type.");
+	return ret;
+}
diff --git a/compiler/libsolidity/interface/CompilerStack.cpp b/compiler/libsolidity/interface/CompilerStack.cpp
index 8a6190ef..3f589172 100644
--- a/compiler/libsolidity/interface/CompilerStack.cpp
+++ b/compiler/libsolidity/interface/CompilerStack.cpp
@@ -51,8 +51,14 @@
 #include <libsolidity/interface/Version.h>
 #include <libsolidity/parsing/Parser.h>
 
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/FunctionDependencyAnalysis.h>
+
+#include <libstdlib/stdlib.h>
+
 #include <liblangutil/Scanner.h>
 #include <liblangutil/SemVerHandler.h>
+#include <liblangutil/SourceReferenceFormatter.h>
 
 #include <libsolutil/SwarmHash.h>
 #include <libsolutil/IpfsHash.h>
@@ -69,7 +75,11 @@
 
 #include <boost/algorithm/string/replace.hpp>
 
+#include <range/v3/algorithm/all_of.hpp>
 #include <range/v3/view/concat.hpp>
+#include <range/v3/view/map.hpp>
+
+#include <fmt/format.h>
 
 #include <utility>
 #include <map>
@@ -78,18 +88,18 @@
 
 #include <libsolidity/codegen/TVM.hpp>
 #include <libsolidity/codegen/TVMTypeChecker.hpp>
-#include <libsolidity/codegen/TVMAnalyzer.hpp>
 #include <libsolidity/codegen/TVMABI.hpp>
 #include <libsolidity/codegen/TvmAstVisitor.hpp>
 #include <libsolidity/codegen/TVMContractCompiler.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
+using namespace solidity::stdlib;
+using namespace solidity::yul;
+using namespace std::string_literals;
 
 using solidity::util::errinfo_comment;
-using solidity::util::toHex;
 
 using solidity::util::h256;
 
@@ -129,10 +139,10 @@ void CompilerStack::createAndAssignCallGraphs()
 			ContractDefinitionAnnotation& annotation =
 				m_contracts.at(contract->fullyQualifiedName()).contract->annotation();
 
-			annotation.creationCallGraph = make_unique<CallGraph>(
+			annotation.creationCallGraph = std::make_unique<CallGraph>(
 				FunctionCallGraphBuilder::buildCreationGraph(*contract)
 			);
-			annotation.deployedCallGraph = make_unique<CallGraph>(
+			annotation.deployedCallGraph = std::make_unique<CallGraph>(
 				FunctionCallGraphBuilder::buildDeployedGraph(
 					*contract,
 					**annotation.creationCallGraph
@@ -152,7 +162,7 @@ void CompilerStack::createAndAssignCallGraphs()
 void CompilerStack::findAndReportCyclicContractDependencies()
 {
 	// Cycles we found, used to avoid duplicate reports for the same reference
-	set<ASTNode const*, ASTNode::CompareByID> foundCycles;
+	std::set<ASTNode const*, ASTNode::CompareByID> foundCycles;
 
 	for (Source const* source: m_sourceOrder)
 	{
@@ -205,7 +215,7 @@ void CompilerStack::findAndReportCyclicContractDependencies()
 	}
 }
 
-void CompilerStack::setRemappings(vector<ImportRemapper::Remapping> _remappings)
+void CompilerStack::setRemappings(std::vector<ImportRemapper::Remapping> _remappings)
 {
 	if (m_stackState >= ParsedAndImported)
 		solThrow(CompilerError, "Must set remappings before parsing.");
@@ -226,6 +236,9 @@ void CompilerStack::setEVMVersion(langutil::EVMVersion _version)
 	if (m_stackState >= ParsedAndImported)
 		solThrow(CompilerError, "Must set EVM version before parsing.");
 	m_evmVersion = _version;
+	// GlobalContext depends on evmVersion since the Cancun hardfork.
+	// Therefore, we reset it whenever we set a new EVM version, ensuring that the context is never reused with a mismatched version.
+	m_globalContext.reset();
 }
 
 void CompilerStack::setTVMVersion(langutil::TVMVersion _version)
@@ -261,7 +274,7 @@ void CompilerStack::setOptimiserSettings(OptimiserSettings _settings)
 void CompilerStack::setRevertStringBehaviour(RevertStrings _revertStrings)
 {
 	if (m_stackState >= ParsedAndImported)
-		solThrow(CompilerError, "Must set revert string settings before parsing.");
+		solThrow(CompilerError, "Must set revert std::string settings before parsing.");
 	solUnimplementedAssert(_revertStrings != RevertStrings::VerboseDebug);
 	m_revertStrings = _revertStrings;
 }
@@ -283,7 +296,6 @@ void CompilerStack::setMetadataHash(MetadataHash _metadataHash)
 void CompilerStack::reset(bool _keepSettings)
 {
 	m_stackState = Empty;
-	m_hasError = false;
 	m_sources.clear();
 	if (!_keepSettings)
 	{
@@ -292,13 +304,14 @@ void CompilerStack::reset(bool _keepSettings)
 		m_viaIR = false;
 		m_evmVersion = langutil::EVMVersion();
 		m_generateIR = false;
-		m_generateEwasm = false;
 		m_revertStrings = RevertStrings::Default;
 		m_optimiserSettings = OptimiserSettings::minimal();
 		m_metadataLiteralSources = false;
+		m_metadataFormat = defaultMetadataFormat();
 		m_metadataHash = MetadataHash::IPFS;
 		m_stopAfter = State::CompilationSuccessful;
 	}
+	m_experimentalAnalysis.reset();
 	m_globalContext.reset();
 	m_sourceOrder.clear();
 	m_contracts.clear();
@@ -313,7 +326,7 @@ void CompilerStack::setSources(StringMap _sources)
 	if (m_stackState != Empty)
 		solThrow(CompilerError, "Must set sources before parsing.");
 	for (auto source: _sources)
-		m_sources[source.first].charStream = make_unique<CharStream>(/*content*/std::move(source.second), /*name*/source.first);
+		m_sources[source.first].charStream = std::make_unique<CharStream>(/*content*/std::move(source.second), /*name*/source.first);
 	m_stackState = SourcesSet;
 }
 
@@ -323,14 +336,15 @@ bool CompilerStack::parse()
 		solThrow(CompilerError, "Must call parse only after the SourcesSet state.");
 	m_errorReporter.clear();
 
-	Parser parser{m_errorReporter, m_evmVersion, m_parserErrorRecovery};
-	vector<string> sourcesToParse;
+	Parser parser{m_errorReporter, m_evmVersion};
+
+	std::vector<std::string> sourcesToParse;
 	for (auto const& s: m_sources)
 		sourcesToParse.push_back(s.first);
 
 	for (size_t i = 0; i < sourcesToParse.size(); ++i)
 	{
-		string const& path = sourcesToParse[i];
+		std::string const& path = sourcesToParse[i];
 		Source& source = m_sources[path];
 		source.ast = parser.parse(*source.charStream);
 		if (!source.ast)
@@ -341,6 +355,15 @@ bool CompilerStack::parse()
 			for (auto const& import: ASTNode::filteredNodes<ImportDirective>(source.ast->nodes()))
 			{
 				solAssert(!import->path().empty(), "Import path cannot be empty.");
+				// Check whether the import directive is for the standard library,
+				// and if yes, add specified file to source units to be parsed.
+				auto it = stdlib::sources.find(import->path());
+				if (it != stdlib::sources.end())
+				{
+					auto [name, content] = *it;
+					m_sources[name].charStream = std::make_unique<CharStream>(content, name);
+					sourcesToParse.push_back(name);
+				}
 
 				// The current value of `path` is the absolute path as seen from this source file.
 				// We first have to apply remappings before we can store the actual absolute path
@@ -354,55 +377,57 @@ bool CompilerStack::parse()
 			if (m_stopAfter >= ParsedAndImported)
 				for (auto const& newSource: loadMissingSources(*source.ast))
 				{
-					string const& newPath = newSource.first;
-					string const& newContents = newSource.second;
-					m_sources[newPath].charStream = make_shared<CharStream>(newContents, newPath);
+					std::string const& newPath = newSource.first;
+					std::string const& newContents = newSource.second;
+					m_sources[newPath].charStream = std::make_shared<CharStream>(newContents, newPath);
 					sourcesToParse.push_back(newPath);
 				}
 		}
 	}
 
-	if (m_stopAfter <= Parsed)
-		m_stackState = Parsed;
-	else
-		m_stackState = ParsedAndImported;
 	if (Error::containsErrors(m_errorReporter.errors()))
-		m_hasError = true;
+		return false;
 
+	m_stackState = (m_stopAfter <= Parsed ? Parsed : ParsedAndImported);
 	storeContractDefinitions();
 
-	return !m_hasError;
+	solAssert(!m_maxAstId.has_value());
+	m_maxAstId = parser.maxID();
+
+	return true;
 }
 
-void CompilerStack::importASTs(map<string, Json::Value> const& _sources)
+void CompilerStack::importASTs(std::map<std::string, Json::Value> const& _sources)
 {
 	if (m_stackState != Empty)
 		solThrow(CompilerError, "Must call importASTs only before the SourcesSet state.");
-	m_sourceJsons = _sources;
-	map<string, ASTPointer<SourceUnit>> reconstructedSources = ASTJsonImporter(m_evmVersion).jsonToSourceUnit(m_sourceJsons);
+	std::map<std::string, ASTPointer<SourceUnit>> reconstructedSources = ASTJsonImporter(m_evmVersion).jsonToSourceUnit(_sources);
 	for (auto& src: reconstructedSources)
 	{
-		string const& path = src.first;
+		solUnimplementedAssert(!src.second->experimentalSolidity());
+		std::string const& path = src.first;
 		Source source;
 		source.ast = src.second;
-		source.charStream = make_shared<CharStream>(
-			util::jsonCompactPrint(m_sourceJsons[src.first]),
+		source.charStream = std::make_shared<CharStream>(
+			util::jsonCompactPrint(_sources.at(src.first)),
 			src.first,
 			true // imported from AST
 		);
 		m_sources[path] = std::move(source);
 	}
 	m_stackState = ParsedAndImported;
-	m_importedSources = true;
+	m_compilationSourceType = CompilationSourceType::SolidityAST;
 
 	storeContractDefinitions();
 }
 
 bool CompilerStack::analyze()
 {
-	if (m_stackState != ParsedAndImported || m_stackState >= AnalysisPerformed)
-		solThrow(CompilerError, "Must call analyze only after parsing was performed.");
-	resolveImports();
+	if (m_stackState != ParsedAndImported)
+		solThrow(CompilerError, "Must call analyze only after parsing was successful.");
+
+	if (!resolveImports())
+		return false;
 
 	for (Source const* source: m_sourceOrder)
 		if (source->ast)
@@ -413,18 +438,19 @@ bool CompilerStack::analyze()
 	try
 	{
 		SyntaxChecker syntaxChecker(m_errorReporter);
+		bool experimentalSolidity = isExperimentalSolidity();
 		for (Source const* source: m_sourceOrder)
 			if (source->ast && !syntaxChecker.checkSyntax(*source->ast))
 				noErrors = false;
 
-		m_globalContext = make_shared<GlobalContext>();
+		m_globalContext = std::make_shared<GlobalContext>(m_evmVersion);
 		// We need to keep the same resolver during the whole process.
-		NameAndTypeResolver resolver(*m_globalContext, m_evmVersion, m_errorReporter);
+		NameAndTypeResolver resolver(*m_globalContext, m_evmVersion, m_errorReporter, experimentalSolidity);
 		for (Source const* source: m_sourceOrder)
 			if (source->ast && !resolver.registerDeclarations(*source->ast))
 				return false;
 
-		map<string, SourceUnit const*> sourceUnitsByName;
+		std::map<std::string, SourceUnit const*> sourceUnitsByName;
 		for (auto& source: m_sources)
 			sourceUnitsByName[source.first] = source.second.ast.get();
 		for (Source const* source: m_sourceOrder)
@@ -433,160 +459,195 @@ bool CompilerStack::analyze()
 
 		resolver.warnHomonymDeclarations();
 
-		DocStringTagParser docStringTagParser(m_errorReporter);
-		for (Source const* source: m_sourceOrder)
-			if (source->ast && !docStringTagParser.parseDocStrings(*source->ast))
-				noErrors = false;
+		{
+			DocStringTagParser docStringTagParser(m_errorReporter);
+			for (Source const* source: m_sourceOrder)
+				if (source->ast && !docStringTagParser.parseDocStrings(*source->ast))
+					noErrors = false;
+		}
 
 		// Requires DocStringTagParser
 		for (Source const* source: m_sourceOrder)
 			if (source->ast && !resolver.resolveNamesAndTypes(*source->ast))
 				return false;
 
-		DeclarationTypeChecker declarationTypeChecker(m_errorReporter, m_evmVersion);
-		for (Source const* source: m_sourceOrder)
-			if (source->ast && !declarationTypeChecker.check(*source->ast))
-				return false;
-
-		// Requires DeclarationTypeChecker to have run
-		for (Source const* source: m_sourceOrder)
-			if (source->ast && !docStringTagParser.validateDocStringsUsingTypes(*source->ast))
+		if (experimentalSolidity)
+		{
+			if (!analyzeExperimental())
 				noErrors = false;
+		}
+		else if (!analyzeLegacy(noErrors))
+			noErrors = false;
+	}
+	catch (FatalError const&)
+	{
+		if (m_errorReporter.errors().empty())
+			throw; // Something is weird here, rather throw again.
+		noErrors = false;
+	}
+
+	if (!noErrors)
+		return false;
+
+	m_stackState = AnalysisSuccessful;
+	return true;
+}
+
+
+bool CompilerStack::analyzeLegacy(bool _noErrorsSoFar)
+{
+	bool noErrors = _noErrorsSoFar;
+
+	DeclarationTypeChecker declarationTypeChecker(m_errorReporter, m_evmVersion);
+	for (Source const* source: m_sourceOrder)
+		if (source->ast && !declarationTypeChecker.check(*source->ast))
+			return false;
+
+	// Requires DeclarationTypeChecker to have run
+	DocStringTagParser docStringTagParser(m_errorReporter);
+	for (Source const* source: m_sourceOrder)
+		if (source->ast && !docStringTagParser.validateDocStringsUsingTypes(*source->ast))
+			noErrors = false;
 
-		// Next, we check inheritance, overrides, function collisions and other things at
-		// contract or function level.
-		// This also calculates whether a contract is abstract, which is needed by the
-		// type checker.
-		ContractLevelChecker contractLevelChecker(m_errorReporter);
+	// Next, we check inheritance, overrides, function collisions and other things at
+	// contract or function level.
+	// This also calculates whether a contract is abstract, which is needed by the
+	// type checker.
+	ContractLevelChecker contractLevelChecker(m_errorReporter);
 
+	for (Source const* source: m_sourceOrder)
+		if (auto sourceAst = source->ast)
+			noErrors = contractLevelChecker.check(*sourceAst);
+
+	// Now we run full type checks that go down to the expression level. This
+	// cannot be done earlier, because we need cross-contract types and information
+	// about whether a contract is abstract for the `new` expression.
+	// This populates the `type` annotation for all expressions.
+	//
+	// Note: this does not resolve overloaded functions. In order to do that, types of arguments are needed,
+	// which is only done one step later.
+	TypeChecker typeChecker(m_evmVersion, m_errorReporter);
+	for (Source const* source: m_sourceOrder)
+		if (source->ast && !typeChecker.checkTypeRequirements(*source->ast))
+			noErrors = false;
+
+	if (noErrors)
+	{
+		// Requires ContractLevelChecker and TypeChecker
+		DocStringAnalyser docStringAnalyser(m_errorReporter);
 		for (Source const* source: m_sourceOrder)
-			if (auto sourceAst = source->ast)
-				noErrors = contractLevelChecker.check(*sourceAst);
-
-		// Now we run full type checks that go down to the expression level. This
-		// cannot be done earlier, because we need cross-contract types and information
-		// about whether a contract is abstract for the `new` expression.
-		// This populates the `type` annotation for all expressions.
-		//
-		// Note: this does not resolve overloaded functions. In order to do that, types of arguments are needed,
-		// which is only done one step later.
-		TypeChecker typeChecker(m_evmVersion, m_errorReporter);
+			if (source->ast && !docStringAnalyser.analyseDocStrings(*source->ast))
+				noErrors = false;
+	}
+
+	if (noErrors)
+	{
+		// Checks that can only be done when all types of all AST nodes are known.
+		PostTypeChecker postTypeChecker(m_errorReporter);
 		for (Source const* source: m_sourceOrder)
-			if (source->ast && !typeChecker.checkTypeRequirements(*source->ast))
+			if (source->ast && !postTypeChecker.check(*source->ast))
 				noErrors = false;
+		if (!postTypeChecker.finalize())
+			noErrors = false;
+	}
 
-		if (noErrors)
-		{
-			// Requires ContractLevelChecker and TypeChecker
-			DocStringAnalyser docStringAnalyser(m_errorReporter);
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !docStringAnalyser.analyseDocStrings(*source->ast))
-					noErrors = false;
-		}
+	// Create & assign callgraphs and check for contract dependency cycles
+	if (noErrors)
+	{
+		createAndAssignCallGraphs();
+		annotateInternalFunctionIDs();
+		//findAndReportCyclicContractDependencies();
+	}
 
-		if (noErrors)
-		{
-			// Checks that can only be done when all types of all AST nodes are known.
-			PostTypeChecker postTypeChecker(m_errorReporter);
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !postTypeChecker.check(*source->ast))
-					noErrors = false;
-			if (!postTypeChecker.finalize())
+	if (noErrors)
+		for (Source const* source: m_sourceOrder)
+			if (source->ast && !PostTypeContractLevelChecker{m_errorReporter}.check(*source->ast))
 				noErrors = false;
-		}
-
-		// Create & assign callgraphs and check for contract dependency cycles
-		if (noErrors)
-		{
-			createAndAssignCallGraphs();
-		}
 
-		if (noErrors)
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !PostTypeContractLevelChecker{m_errorReporter}.check(*source->ast))
-					noErrors = false;
+	// Check that immutable variables are never read in c'tors and assigned
+	// exactly once
+	if (noErrors)
+		for (Source const* source: m_sourceOrder)
+			if (source->ast)
+				for (ASTPointer<ASTNode> const& node: source->ast->nodes())
+					if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+						ImmutableValidator(m_errorReporter, *contract).analyze();
 
-		// Check that immutable variables are never read in c'tors and assigned
-		// exactly once
-		if (noErrors)
-			for (Source const* source: m_sourceOrder)
-				if (source->ast)
-					for (ASTPointer<ASTNode> const& node: source->ast->nodes())
-						if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
-							ImmutableValidator(m_errorReporter, *contract).analyze();
+	if (noErrors)
+	{
+		// Control flow graph generator and analyzer. It can check for issues such as
+		// variable is used before it is assigned to.
+		CFG cfg(m_errorReporter);
+		for (Source const* source: m_sourceOrder)
+			if (source->ast && !cfg.constructFlow(*source->ast))
+				noErrors = false;
 
 		if (noErrors)
 		{
-			// Control flow graph generator and analyzer. It can check for issues such as
-			// variable is used before it is assigned to.
-			CFG cfg(m_errorReporter);
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !cfg.constructFlow(*source->ast))
-					noErrors = false;
+			ControlFlowRevertPruner pruner(cfg);
+			pruner.run();
 
-			if (noErrors)
-			{
-				ControlFlowRevertPruner pruner(cfg);
-				pruner.run();
-
-				ControlFlowAnalyzer controlFlowAnalyzer(cfg, m_errorReporter);
-				if (!controlFlowAnalyzer.run())
-					noErrors = false;
-			}
+			ControlFlowAnalyzer controlFlowAnalyzer(cfg, m_errorReporter);
+			if (!controlFlowAnalyzer.run())
+				noErrors = false;
 		}
+	}
 
-		if (noErrors)
-		{
-			// Checks for common mistakes. Only generates warnings.
-			StaticAnalyzer staticAnalyzer(m_errorReporter);
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !staticAnalyzer.analyze(*source->ast))
-					noErrors = false;
-		}
+	if (noErrors)
+	{
+		// Checks for common mistakes. Only generates warnings.
+		StaticAnalyzer staticAnalyzer(m_errorReporter);
+		for (Source const* source: m_sourceOrder)
+			if (source->ast && !staticAnalyzer.analyze(*source->ast))
+				noErrors = false;
+	}
 
-		if (noErrors)
-		{
-			// Check for state mutability in every function.
-			vector<ASTPointer<ASTNode>> ast;
-			for (Source const* source: m_sourceOrder)
-				if (source->ast)
-					ast.push_back(source->ast);
+	if (noErrors)
+	{
+		// Check for state mutability in every function.
+		std::vector<ASTPointer<ASTNode>> ast;
+		for (Source const* source: m_sourceOrder)
+			if (source->ast)
+				ast.push_back(source->ast);
 
-			if (!ViewPureChecker(ast, m_errorReporter).check())
-				noErrors = false;
-		}
+		if (!ViewPureChecker(ast, m_errorReporter).check())
+			noErrors = false;
+	}
 
-		if (noErrors) {
-			//Checks for TVM specific issues.
-			TVMAnalyzer tvmAnalyzer(m_errorReporter);
-			for (Source const* source: m_sourceOrder)
-				if (source->ast && !tvmAnalyzer.analyze(*source->ast))
-					noErrors = false;
-		}
+	if (noErrors) {
+		// Check for TVM specific issues.
+		TVMAnalyzer tvmAnalyzer(m_errorReporter);
+		for (Source const* source: m_sourceOrder)
+			if (source->ast && !tvmAnalyzer.analyze(*source->ast))
+				noErrors = false;
+	}
 
-		if (noErrors)
-		{
-			for (Source const* source: m_sourceOrder) {
-				TVMTypeChecker checker(m_errorReporter);
-				source->ast->accept(checker);
-				if (m_errorReporter.hasErrors()) {
-					noErrors = false;
-				}
+	if (noErrors)
+	{
+		// Check for TVM specific issues.
+		// TODO merge TVMTypeChecker and TVMAnalyzer ?
+		for (Source const* source: m_sourceOrder) {
+			TVMTypeChecker checker(m_errorReporter);
+			source->ast->accept(checker);
+			if (m_errorReporter.hasErrors()) {
+				noErrors = false;
 			}
 		}
 	}
-	catch (FatalError const&)
-	{
-		if (m_errorReporter.errors().empty())
-			throw; // Something is weird here, rather throw again.
-		noErrors = false;
-	}
 
-	m_stackState = AnalysisPerformed;
-	if (!noErrors)
-		m_hasError = true;
+	return noErrors;
+}
 
-	return !m_hasError;
+bool CompilerStack::analyzeExperimental()
+{
+	solAssert(!m_experimentalAnalysis);
+	solAssert(m_maxAstId && *m_maxAstId >= 0);
+	m_experimentalAnalysis = std::make_unique<experimental::Analysis>(m_errorReporter, static_cast<std::uint64_t>(*m_maxAstId));
+	std::vector<std::shared_ptr<SourceUnit const>> sourceAsts;
+	for (Source const* source: m_sourceOrder)
+		if (source->ast)
+			sourceAsts.emplace_back(source->ast);
+	return m_experimentalAnalysis->check(sourceAsts);
 }
 
 bool CompilerStack::parseAndAnalyze(State _stopAfter)
@@ -596,12 +657,12 @@ bool CompilerStack::parseAndAnalyze(State _stopAfter)
 	bool success = parse();
 	if (m_stackState >= m_stopAfter)
 		return success;
-	if (success || m_parserErrorRecovery)
+	if (success)
 		success = analyze();
 	return success;
 }
 
-bool CompilerStack::isRequestedSource(string const& _sourceName) const
+bool CompilerStack::isRequestedSource(std::string const& _sourceName) const
 {
 	return
 		m_requestedContractNames.empty() ||
@@ -615,7 +676,7 @@ bool CompilerStack::isRequestedContract(ContractDefinition const& _contract) con
 	if (m_requestedContractNames.empty())
 		return true;
 
-	for (auto const& key: vector<string>{"", _contract.sourceUnitName()})
+	for (auto const& key: std::vector<std::string>{"", _contract.sourceUnitName()})
 	{
 		auto const& it = m_requestedContractNames.find(key);
 		if (it != m_requestedContractNames.end())
@@ -629,13 +690,10 @@ bool CompilerStack::isRequestedContract(ContractDefinition const& _contract) con
 std::pair<bool, bool> CompilerStack::compile(bool json)
 {
 	bool didCompileSomething{};
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		if (!parseAndAnalyze())
 			return {false, didCompileSomething};
 
-//	if (m_stackState >= m_stopAfter)
-//		return true;
-
 	if (m_hasError)
 		solThrow(CompilerError, "Called compile with errors.");
 
@@ -645,7 +703,7 @@ std::pair<bool, bool> CompilerStack::compile(bool json)
 
 		bool findSrc = false;
 		for (Source const *source: m_sourceOrder) {
-			string curSrcPath = *source->ast->annotation().path;
+			std::string curSrcPath = *source->ast->annotation().path;
 			if (curSrcPath != m_inputFile) {
 				continue;
 			}
@@ -733,16 +791,26 @@ std::pair<bool, bool> CompilerStack::compile(bool json)
 					Contract const& c = contract(targetContract->name());
 					if (m_generateAbi) {
 						Json::Value abi = TVMABI::generateABIJson(targetContract, getSourceUnits(), pragmaDirectives);
-						c.abi = make_unique<Json::Value>(abi);
+						c.abi = std::make_unique<Json::Value>(abi);
 					}
 					if (m_generateCode) {
 						Pointer<solidity::frontend::Contract> codeContract =
 							TVMContractCompiler::generateContractCode(targetContract, getSourceUnits(), pragmaHelper);
-						ostringstream out;
+						std::ostringstream out;
 						Printer p{out};
 						codeContract->accept(p);
 						Json::Value code = Json::Value(out.str());
-						c.code = make_unique<Json::Value>(code);
+						c.code = std::make_unique<Json::Value>(code);
+					}
+					if (m_doPrintFunctionIds)
+					{
+						auto functionIds = TVMABI::generateFunctionIdsJson(*c.contract, pragmaHelper);
+						c.functionIds = std::make_unique<Json::Value>(functionIds);
+					}
+					if (m_doPrivateFunctionIds)
+					{
+						auto functionIds = TVMABI::generatePrivateFunctionIdsJson(*c.contract, getSourceUnits(), pragmaHelper);
+						c.privateFunctionIds = std::make_unique<Json::Value>(functionIds);
 					}
 				} else {
 					TVMCompilerProceedContract(
@@ -775,17 +843,17 @@ void CompilerStack::link()
 	solAssert(m_stackState >= CompilationSuccessful, "");
 }
 
-vector<string> CompilerStack::contractNames() const
+std::vector<std::string> CompilerStack::contractNames() const
 {
 	if (m_stackState < Parsed)
 		solThrow(CompilerError, "Parsing was not successful.");
-	vector<string> contractNames;
+	std::vector<std::string> contractNames;
 	for (auto const& contract: m_contracts)
 		contractNames.push_back(contract.first);
 	return contractNames;
 }
 
-string const* CompilerStack::sourceMapping(string const& _contractName) const
+std::string const* CompilerStack::sourceMapping(std::string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
 		solThrow(CompilerError, "Compilation was not successful.");
@@ -794,7 +862,7 @@ string const* CompilerStack::sourceMapping(string const& _contractName) const
 	return &*c.sourceMapping;
 }
 
-string const* CompilerStack::runtimeSourceMapping(string const& _contractName) const
+std::string const* CompilerStack::runtimeSourceMapping(std::string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
 		solThrow(CompilerError, "Compilation was not successful.");
@@ -803,9 +871,9 @@ string const* CompilerStack::runtimeSourceMapping(string const& _contractName) c
 	return &*c.runtimeSourceMapping;
 }
 
-std::string const CompilerStack::filesystemFriendlyName(string const& _contractName) const
+std::string const CompilerStack::filesystemFriendlyName(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "No compiled contracts found.");
 
 	// Look up the contract (by its fully-qualified name)
@@ -827,7 +895,7 @@ std::string const CompilerStack::filesystemFriendlyName(string const& _contractN
 	return matchContract.contract->name();
 }
 
-string const& CompilerStack::yulIR(string const& _contractName) const
+std::string const& CompilerStack::yulIR(std::string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
 		solThrow(CompilerError, "Compilation was not successful.");
@@ -835,7 +903,7 @@ string const& CompilerStack::yulIR(string const& _contractName) const
 	return contract(_contractName).yulIR;
 }
 
-string const& CompilerStack::yulIROptimized(string const& _contractName) const
+std::string const& CompilerStack::yulIROptimized(std::string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
 		solThrow(CompilerError, "Compilation was not successful.");
@@ -843,41 +911,15 @@ string const& CompilerStack::yulIROptimized(string const& _contractName) const
 	return contract(_contractName).yulIROptimized;
 }
 
-string const& CompilerStack::ewasm(string const& _contractName) const
-{
-	if (m_stackState != CompilationSuccessful)
-		solThrow(CompilerError, "Compilation was not successful.");
-
-	return contract(_contractName).ewasm;
-}
-
-/// TODO: cache this string
-string CompilerStack::assemblyString(std::string const&, StringMap const&) const
-{
-	if (m_stackState != CompilationSuccessful)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
-	return string();
-}
-
-/// TODO: cache the JSON
-Json::Value CompilerStack::assemblyJSON(string const&) const
-{
-	if (m_stackState != CompilationSuccessful)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
-	return Json::Value();
-}
 
-vector<string> CompilerStack::sourceNames() const
+std::vector<std::string> CompilerStack::sourceNames() const
 {
-	vector<string> names;
-	for (auto const& s: m_sources)
-		names.push_back(s.first);
-	return names;
+	return ranges::to<std::vector>(m_sources | ranges::views::keys);
 }
 
-map<string, unsigned> CompilerStack::sourceIndices() const
+std::map<std::string, unsigned> CompilerStack::sourceIndices() const
 {
-	map<string, unsigned> indices;
+	std::map<std::string, unsigned> indices;
 	unsigned index = 0;
 	for (auto const& s: m_sources)
 		indices[s.first] = index++;
@@ -893,9 +935,9 @@ std::string CompilerStack::contractSource(std::string const& _contractName) cons
 	return sourceName;
 }
 
-Json::Value const& CompilerStack::contractABI(string const& _contractName) const
+Json::Value const& CompilerStack::contractABI(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Analysis was not successful."));
 
 	auto const &abi = contract(_contractName).abi;
@@ -904,6 +946,9 @@ Json::Value const& CompilerStack::contractABI(string const& _contractName) const
 
 Json::Value const& CompilerStack::contractCode(std::string const& _contractName) const
 {
+	if (m_stackState < AnalysisSuccessful)
+		solThrow(CompilerError, "Analysis was not successful.");
+
 	auto const &code = contract(_contractName).code;
 	return code ? *code : Json::Value::null;
 }
@@ -912,38 +957,19 @@ Json::Value const& CompilerStack::functionIds(std::string const& _contractName)
 {
 	std::string sourceName = contractSource(_contractName);
 	Contract const &c = contract(_contractName);
-	if (!c.functionIds)
-	{
-		std::vector<PragmaDirective const *> pragmaDirectives = getPragmaDirectives(&source(sourceName));
-		PragmaDirectiveHelper pragmaHelper{pragmaDirectives};
-		auto functionIds = TVMABI::generateFunctionIdsJson(*c.contract, pragmaHelper);
-		c.functionIds = make_unique<Json::Value>(functionIds);
-	}
-	return *c.functionIds;
+	return c.functionIds ? *c.functionIds : Json::Value::null;
 }
 
 Json::Value const& CompilerStack::privateFunctionIds(std::string const& _contractName) const
 {
 	std::string sourceName = contractSource(_contractName);
 	Contract const &c = contract(_contractName);
-	if (!c.privateFunctionIds)
-	{
-		try {
-			std::vector<PragmaDirective const *> pragmaDirectives = getPragmaDirectives(&source(sourceName));
-			PragmaDirectiveHelper pragmaHelper{pragmaDirectives};
-			auto functionIds = TVMABI::generatePrivateFunctionIdsJson(*c.contract, getSourceUnits(), pragmaHelper);
-			c.privateFunctionIds = make_unique<Json::Value>(functionIds);
-		} catch (...) {
-			// TODO sorry
-			c.privateFunctionIds = make_unique<Json::Value>();
-		}
-	}
-	return *c.privateFunctionIds;
+	return c.privateFunctionIds ? *c.privateFunctionIds : Json::Value::null;
 }
 
-Json::Value const& CompilerStack::natspecUser(string const& _contractName) const
+Json::Value const& CompilerStack::natspecUser(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	return natspecUser(contract(_contractName));
@@ -951,17 +977,18 @@ Json::Value const& CompilerStack::natspecUser(string const& _contractName) const
 
 Json::Value const& CompilerStack::natspecUser(Contract const& _contract) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	solAssert(_contract.contract, "");
+	solUnimplementedAssert(!isExperimentalSolidity());
 
 	return _contract.userDocumentation.init([&]{ return Natspec::userDocumentation(*_contract.contract); });
 }
 
-Json::Value const& CompilerStack::natspecDev(string const& _contractName) const
+Json::Value const& CompilerStack::natspecDev(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	return natspecDev(contract(_contractName));
@@ -969,19 +996,23 @@ Json::Value const& CompilerStack::natspecDev(string const& _contractName) const
 
 Json::Value const& CompilerStack::natspecDev(Contract const& _contract) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	solAssert(_contract.contract, "");
 
+	solUnimplementedAssert(!isExperimentalSolidity());
+
 	return _contract.devDocumentation.init([&]{ return Natspec::devDocumentation(*_contract.contract); });
 }
 
-Json::Value CompilerStack::interfaceSymbols(string const& _contractName) const
+Json::Value CompilerStack::interfaceSymbols(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
+	solUnimplementedAssert(!isExperimentalSolidity());
+
 	Json::Value interfaceSymbols(Json::objectValue);
 	// Always have a methods object
 	interfaceSymbols["methods"] = Json::objectValue;
@@ -990,8 +1021,8 @@ Json::Value CompilerStack::interfaceSymbols(string const& _contractName) const
 		interfaceSymbols["methods"][it.second->externalSignature()] = it.first.hex();
 	for (ErrorDefinition const* error: contractDefinition(_contractName).interfaceErrors())
 	{
-		string signature = error->functionType(true)->externalSignature();
-		interfaceSymbols["errors"][signature] = util::toHex(toCompactBigEndian(util::selectorFromSignature32(signature), 4));
+		std::string signature = error->functionType(true)->externalSignature();
+		interfaceSymbols["errors"][signature] = util::toHex(toCompactBigEndian(util::selectorFromSignatureU32(signature), 4));
 	}
 
 	for (EventDefinition const* event: ranges::concat_view(
@@ -1000,32 +1031,34 @@ Json::Value CompilerStack::interfaceSymbols(string const& _contractName) const
 	))
 		if (!event->isAnonymous())
 		{
-			string signature = event->functionType(true)->externalSignature();
+			std::string signature = event->functionType(true)->externalSignature();
 			interfaceSymbols["events"][signature] = toHex(u256(h256::Arith(util::keccak256(signature))));
 		}
 
 	return interfaceSymbols;
 }
 
-bytes CompilerStack::cborMetadata(string const& _contractName, bool _forIR) const
+bytes CompilerStack::cborMetadata(std::string const& _contractName, bool _forIR) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	return createCBORMetadata(contract(_contractName), _forIR);
 }
 
-string const& CompilerStack::metadata(Contract const& _contract) const
+std::string const& CompilerStack::metadata(Contract const& _contract) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	solAssert(_contract.contract, "");
 
+	solUnimplementedAssert(!isExperimentalSolidity());
+
 	return _contract.metadata.init([&]{ return createMetadata(_contract, m_viaIR); });
 }
 
-CharStream const& CompilerStack::charStream(string const& _sourceName) const
+CharStream const& CompilerStack::charStream(std::string const& _sourceName) const
 {
 	if (m_stackState < SourcesSet)
 		solThrow(CompilerError, "No sources set.");
@@ -1035,19 +1068,21 @@ CharStream const& CompilerStack::charStream(string const& _sourceName) const
 	return *source(_sourceName).charStream;
 }
 
-SourceUnit const& CompilerStack::ast(string const& _sourceName) const
+SourceUnit const& CompilerStack::ast(std::string const& _sourceName) const
 {
 	if (m_stackState < Parsed)
 		solThrow(CompilerError, "Parsing not yet performed.");
-	if (!source(_sourceName).ast && !m_parserErrorRecovery)
+	if (!source(_sourceName).ast)
 		solThrow(CompilerError, "Parsing was not successful.");
 
+	solUnimplementedAssert(!isExperimentalSolidity());
+
 	return *source(_sourceName).ast;
 }
 
-ContractDefinition const& CompilerStack::contractDefinition(string const& _contractName) const
+ContractDefinition const& CompilerStack::contractDefinition(std::string const& _contractName) const
 {
-	if (m_stackState < AnalysisPerformed)
+	if (m_stackState < AnalysisSuccessful)
 		solThrow(CompilerError, "Analysis was not successful.");
 
 	return *contract(_contractName).contract;
@@ -1061,7 +1096,7 @@ size_t CompilerStack::functionEntryPoint(
 	if (m_stackState != CompilationSuccessful)
 		solThrow(CompilerError, "Compilation was not successful.");
 
-	shared_ptr<Compiler> const& compiler = contract(_contractName).compiler;
+	std::shared_ptr<Compiler> const& compiler = contract(_contractName).compiler;
 	if (!compiler)
 		return 0;
 	return 0;
@@ -1081,7 +1116,7 @@ h256 const& CompilerStack::Source::swarmHash() const
 	return swarmHashCached;
 }
 
-string const& CompilerStack::Source::ipfsUrl() const
+std::string const& CompilerStack::Source::ipfsUrl() const
 {
 	if (ipfsUrlCached.empty())
 		ipfsUrlCached = "dweb:/ipfs/" + util::ipfsHashBase58(charStream->source());
@@ -1097,12 +1132,12 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)
 		for (auto const& node: _ast.nodes())
 			if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
 			{
-				string const& importPath = *import->annotation().absolutePath;
+				std::string const& importPath = *import->annotation().absolutePath;
 
 				if (m_sources.count(importPath) || newSources.count(importPath))
 					continue;
 
-				ReadCallback::Result result{false, string("File not supplied initially.")};
+				ReadCallback::Result result{false, std::string("File not supplied initially.")};
 				if (m_readFile)
 					result = m_readFile(ReadCallback::kindString(ReadCallback::Kind::ReadFile), importPath);
 
@@ -1113,7 +1148,7 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)
 					m_errorReporter.parserError(
 						6275_error,
 						import->location(),
-						string("Source \"" + importPath + "\" not found: " + result.responseOrErrorMessage)
+						std::string("Source \"" + importPath + "\" not found: " + result.responseOrErrorMessage)
 					);
 					continue;
 				}
@@ -1126,42 +1161,65 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)
 	return newSources;
 }
 
-string CompilerStack::applyRemapping(string const& _path, string const& _context)
+std::string CompilerStack::applyRemapping(std::string const& _path, std::string const& _context)
 {
 	solAssert(m_stackState < ParsedAndImported, "");
 	return m_importRemapper.apply(_path, _context);
 }
 
-void CompilerStack::resolveImports()
+bool CompilerStack::resolveImports()
 {
 	solAssert(m_stackState == ParsedAndImported, "");
 
 	// topological sorting (depth first search) of the import graph, cutting potential cycles
-	vector<Source const*> sourceOrder;
-	set<Source const*> sourcesSeen;
+	std::vector<Source const*> sourceOrder;
+	std::set<Source const*> sourcesSeen;
 
-	function<void(Source const*)> toposort = [&](Source const* _source)
+	std::function<void(Source const*)> toposort = [&](Source const* _source)
 	{
 		if (sourcesSeen.count(_source))
 			return;
 		sourcesSeen.insert(_source);
-		if (_source->ast)
-			for (ASTPointer<ASTNode> const& node: _source->ast->nodes())
-				if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
-				{
-					string const& path = *import->annotation().absolutePath;
-					solAssert(m_sources.count(path), "");
-					import->annotation().sourceUnit = m_sources[path].ast.get();
-					toposort(&m_sources[path]);
-				}
+		solAssert(_source->ast);
+		for (ASTPointer<ASTNode> const& node: _source->ast->nodes())
+			if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
+			{
+				std::string const& path = *import->annotation().absolutePath;
+				solAssert(m_sources.count(path), "");
+				import->annotation().sourceUnit = m_sources[path].ast.get();
+				toposort(&m_sources[path]);
+			}
 		sourceOrder.push_back(_source);
 	};
 
+	std::vector<PragmaDirective const*> experimentalPragmaDirectives;
 	for (auto const& sourcePair: m_sources)
+	{
 		if (isRequestedSource(sourcePair.first))
 			toposort(&sourcePair.second);
+		if (sourcePair.second.ast && sourcePair.second.ast->experimentalSolidity())
+			for (ASTPointer<ASTNode> const& node: sourcePair.second.ast->nodes())
+				if (PragmaDirective const* pragma = dynamic_cast<PragmaDirective*>(node.get()))
+					if (pragma->literals().size() >=2 && pragma->literals()[0] == "experimental" && pragma->literals()[1] == "solidity")
+					{
+						experimentalPragmaDirectives.push_back(pragma);
+						break;
+					}
+	}
+
+	if (!experimentalPragmaDirectives.empty() && experimentalPragmaDirectives.size() != m_sources.size())
+	{
+		for (auto &&pragma: experimentalPragmaDirectives)
+			m_errorReporter.parserError(
+					2141_error,
+					pragma->location(),
+					"File declares \"pragma experimental solidity\". If you want to enable the experimental mode, all source units must include the pragma."
+			);
+		return false;
+	}
 
 	swap(m_sourceOrder, sourceOrder);
+	return true;
 }
 
 void CompilerStack::storeContractDefinitions()
@@ -1173,7 +1231,7 @@ void CompilerStack::storeContractDefinitions()
 				ASTNode::filteredNodes<ContractDefinition>(pair.second.ast->nodes())
 			)
 			{
-				string fullyQualifiedName = *pair.second.ast->annotation().path + ":" + contract->name();
+				std::string fullyQualifiedName = *pair.second.ast->annotation().path + ":" + contract->name();
 				// Note that we now reference contracts by their fully qualified names, and
 				// thus contracts can only conflict if declared in the same source file. This
 				// should already cause a double-declaration error elsewhere.
@@ -1182,9 +1240,39 @@ void CompilerStack::storeContractDefinitions()
 			}
 }
 
+void CompilerStack::annotateInternalFunctionIDs()
+{
+	for (Source const* source: m_sourceOrder)
+	{
+		if (!source->ast)
+			continue;
+
+		for (ContractDefinition const* contract: ASTNode::filteredNodes<ContractDefinition>(source->ast->nodes()))
+		{
+			uint64_t internalFunctionID = 1;
+			ContractDefinitionAnnotation& annotation = contract->annotation();
+
+			if (auto const* deployTimeInternalDispatch = util::valueOrNullptr((*annotation.deployedCallGraph)->edges, CallGraph::SpecialNode::InternalDispatch))
+				for (auto const& node: *deployTimeInternalDispatch)
+					if (auto const* callable = std::get_if<CallableDeclaration const*>(&node))
+						if (auto const* function = dynamic_cast<FunctionDefinition const*>(*callable))
+						{
+							solAssert(contract->annotation().internalFunctionIDs.count(function) == 0);
+							contract->annotation().internalFunctionIDs[function] = internalFunctionID++;
+						}
+			if (auto const* creationTimeInternalDispatch = util::valueOrNullptr((*annotation.creationCallGraph)->edges, CallGraph::SpecialNode::InternalDispatch))
+				for (auto const& node: *creationTimeInternalDispatch)
+					if (auto const* callable = std::get_if<CallableDeclaration const*>(&node))
+						if (auto const* function = dynamic_cast<FunctionDefinition const*>(*callable))
+							// Make sure the function already got an ID since it also occurs in the deploy-time internal dispatch.
+							solAssert(contract->annotation().internalFunctionIDs.count(function) != 0);
+		}
+	}
+}
+
 namespace
 {
-bool onlySafeExperimentalFeaturesActivated(set<ExperimentalFeature> const& features)
+bool onlySafeExperimentalFeaturesActivated(std::set<ExperimentalFeature> const& features)
 {
 	for (auto const feature: features)
 		if (!ExperimentalFeatureWithoutWarning.count(feature))
@@ -1193,9 +1281,9 @@ bool onlySafeExperimentalFeaturesActivated(set<ExperimentalFeature> const& featu
 }
 }
 
-CompilerStack::Contract const& CompilerStack::contract(string const& _contractName) const
+CompilerStack::Contract const& CompilerStack::contract(std::string const& _contractName) const
 {
-	solAssert(m_stackState >= AnalysisPerformed, "");
+	solAssert(m_stackState >= AnalysisSuccessful, "");
 
 	auto it = m_contracts.find(_contractName);
 	if (it != m_contracts.end())
@@ -1204,15 +1292,15 @@ CompilerStack::Contract const& CompilerStack::contract(string const& _contractNa
 	// To provide a measure of backward-compatibility, if a contract is not located by its
 	// fully-qualified name, a lookup will be attempted purely on the contract's name to see
 	// if anything will satisfy.
-	if (_contractName.find(':') == string::npos)
+	if (_contractName.find(':') == std::string::npos)
 	{
 		for (auto const& contractEntry: m_contracts)
 		{
-			stringstream ss;
+			std::stringstream ss;
 			ss.str(contractEntry.first);
 			// All entries are <source>:<contract>
-			string source;
-			string foundName;
+			std::string source;
+			std::string foundName;
 			getline(ss, source, ':');
 			getline(ss, foundName, ':');
 			if (foundName == _contractName)
@@ -1224,7 +1312,7 @@ CompilerStack::Contract const& CompilerStack::contract(string const& _contractNa
 	solThrow(CompilerError, "Contract \"" + _contractName + "\" not found.");
 }
 
-CompilerStack::Source const& CompilerStack::source(string const& _sourceName) const
+CompilerStack::Source const& CompilerStack::source(std::string const& _sourceName) const
 {
 	auto it = m_sources.find(_sourceName);
 	if (it == m_sources.end())
@@ -1233,15 +1321,25 @@ CompilerStack::Source const& CompilerStack::source(string const& _sourceName) co
 	return it->second;
 }
 
-string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) const
+std::string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) const
 {
 	Json::Value meta{Json::objectValue};
 	meta["version"] = 1;
-	meta["language"] = m_importedSources ? "SolidityAST" : "Solidity";
+	std::string sourceType;
+	switch (m_compilationSourceType)
+	{
+	case CompilationSourceType::Solidity:
+		sourceType = "Solidity";
+		break;
+	case CompilationSourceType::SolidityAST:
+		sourceType = "SolidityAST";
+		break;
+	}
+	meta["language"] = sourceType;
 	meta["compiler"]["version"] = VersionStringStrict;
 
 	/// All the source files (including self), which should be included in the metadata.
-	set<string> referencedSources;
+	std::set<std::string> referencedSources;
 	referencedSources.insert(*_contract.contract->sourceUnit().annotation().path);
 	for (auto const sourceUnit: _contract.contract->sourceUnit().referencedSourceUnits(true))
 		referencedSources.insert(*sourceUnit->annotation().path);
@@ -1254,7 +1352,7 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 
 		solAssert(s.second.charStream, "Character stream not available");
 		meta["sources"][s.first]["keccak256"] = "0x" + util::toHex(s.second.keccak256().asBytes());
-		if (optional<string> licenseString = s.second.ast->licenseString())
+		if (std::optional<std::string> licenseString = s.second.ast->licenseString())
 			meta["sources"][s.first]["license"] = *licenseString;
 		if (m_metadataLiteralSources)
 			meta["sources"][s.first]["content"] = s.second.charStream->source();
@@ -1289,12 +1387,19 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 		details["deduplicate"] = m_optimiserSettings.runDeduplicate;
 		details["cse"] = m_optimiserSettings.runCSE;
 		details["constantOptimizer"] = m_optimiserSettings.runConstantOptimiser;
+		details["simpleCounterForLoopUncheckedIncrement"] = m_optimiserSettings.simpleCounterForLoopUncheckedIncrement;
 		details["yul"] = m_optimiserSettings.runYulOptimiser;
 		if (m_optimiserSettings.runYulOptimiser)
 		{
 			details["yulDetails"] = Json::objectValue;
 			details["yulDetails"]["stackAllocation"] = m_optimiserSettings.optimizeStackAllocation;
-			details["yulDetails"]["optimizerSteps"] = m_optimiserSettings.yulOptimiserSteps;
+			details["yulDetails"]["optimizerSteps"] = m_optimiserSettings.yulOptimiserSteps + ":" + m_optimiserSettings.yulOptimiserCleanupSteps;
+		}
+		else
+		{
+			solAssert(m_optimiserSettings.optimizeStackAllocation == false);
+			solAssert(m_optimiserSettings.yulOptimiserSteps == OptimiserSettings::DefaultYulOptimiserSteps);
+			solAssert(m_optimiserSettings.yulOptimiserCleanupSteps == OptimiserSettings::DefaultYulOptimiserCleanupSteps);
 		}
 
 		meta["settings"]["optimizer"]["details"] = std::move(details);
@@ -1303,10 +1408,13 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 	if (m_revertStrings != RevertStrings::Default)
 		meta["settings"]["debug"]["revertStrings"] = revertStringsToString(m_revertStrings);
 
+	if (m_metadataFormat == MetadataFormat::NoMetadata)
+		meta["settings"]["metadata"]["appendCBOR"] = false;
+
 	if (m_metadataLiteralSources)
 		meta["settings"]["metadata"]["useLiteralContent"] = true;
 
-	static vector<string> hashes{"ipfs", "bzzr1", "none"};
+	static std::vector<std::string> hashes{"ipfs", "bzzr1", "none"};
 	meta["settings"]["metadata"]["bytecodeHash"] = hashes.at(unsigned(m_metadataHash));
 
 	if (_forIR)
@@ -1316,7 +1424,7 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 		*_contract.contract->annotation().canonicalName;
 
 	meta["settings"]["remappings"] = Json::arrayValue;
-	set<string> remappings;
+	std::set<std::string> remappings;
 	for (auto const& r: m_importRemapper.remappings())
 		remappings.insert(r.context + ":" + r.prefix + "=" + r.target);
 	for (auto const& r: remappings)
@@ -1337,21 +1445,21 @@ string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) con
 class MetadataCBOREncoder
 {
 public:
-	void pushBytes(string const& key, bytes const& value)
+	void pushBytes(std::string const& key, bytes const& value)
 	{
 		m_entryCount++;
 		pushTextString(key);
 		pushByteString(value);
 	}
 
-	void pushString(string const& key, string const& value)
+	void pushString(std::string const& key, std::string const& value)
 	{
 		m_entryCount++;
 		pushTextString(key);
 		pushTextString(value);
 	}
 
-	void pushBool(string const& key, bool value)
+	void pushBool(std::string const& key, bool value)
 	{
 		m_entryCount++;
 		pushTextString(key);
@@ -1374,7 +1482,7 @@ class MetadataCBOREncoder
 	}
 
 private:
-	void pushTextString(string const& key)
+	void pushTextString(std::string const& key)
 	{
 		size_t length = key.size();
 		if (length < 24)
@@ -1388,7 +1496,7 @@ class MetadataCBOREncoder
 			m_data += key;
 		}
 		else
-			solAssert(false, "Text string too large.");
+			solAssert(false, "Text std::string too large.");
 	}
 	void pushByteString(bytes const& key)
 	{
@@ -1404,7 +1512,7 @@ class MetadataCBOREncoder
 			m_data += key;
 		}
 		else
-			solAssert(false, "Byte string too large.");
+			solAssert(false, "Byte std::string too large.");
 	}
 	void pushBool(bool value)
 	{
@@ -1426,7 +1534,7 @@ bytes CompilerStack::createCBORMetadata(Contract const& _contract, bool _forIR)
 		_contract.contract->sourceUnit().annotation().experimentalFeatures
 	);
 
-	string meta = (_forIR == m_viaIR ? metadata(_contract) : createMetadata(_contract, _forIR));
+	std::string meta = (_forIR == m_viaIR ? metadata(_contract) : createMetadata(_contract, _forIR));
 
 	MetadataCBOREncoder encoder;
 
@@ -1455,11 +1563,9 @@ bytes CompilerStack::createCBORMetadata(Contract const& _contract, bool _forIR)
 
 std::vector<PragmaDirective const *> CompilerStack::getPragmaDirectives(Source const* source) const {
 	std::vector<PragmaDirective const *> pragmaDirectives;
-	for (ASTPointer<ASTNode> const &node: source->ast->nodes()) {
-		if (auto pragma = dynamic_cast<PragmaDirective const *>(node.get())) {
+	for (ASTPointer<ASTNode> const &node: source->ast->nodes())
+		if (auto pragma = dynamic_cast<PragmaDirective const *>(node.get()))
 			pragmaDirectives.push_back(pragma);
-		}
-	}
 	return pragmaDirectives;
 }
 
@@ -1470,3 +1576,17 @@ std::vector<std::shared_ptr<SourceUnit>> CompilerStack::getSourceUnits() const {
 	}
 	return sourceUnits;
 }
+
+bool CompilerStack::isExperimentalSolidity() const
+{
+	return
+		!m_sourceOrder.empty() &&
+		ranges::all_of(m_sourceOrder, [](auto const* _source) { return _source->ast->experimentalSolidity(); } )
+	;
+}
+
+experimental::Analysis const& CompilerStack::experimentalAnalysis() const
+{
+	solAssert(!!m_experimentalAnalysis);
+	return *m_experimentalAnalysis;
+}
diff --git a/compiler/libsolidity/interface/CompilerStack.h b/compiler/libsolidity/interface/CompilerStack.h
index fbbb94b5..dbd290bf 100644
--- a/compiler/libsolidity/interface/CompilerStack.h
+++ b/compiler/libsolidity/interface/CompilerStack.h
@@ -71,13 +71,15 @@ class GlobalContext;
 class Natspec;
 class DeclarationContainer;
 class PragmaDirective;
+namespace experimental
+{
+class Analysis;
+}
 
 /**
  * Easy to use and self-contained Solidity compiler with as few header dependencies as possible.
  * It holds state and can be used to either step through the compilation stages (and abort e.g.
  * before compilation to bytecode) or run the whole compilation in one call.
- * If error recovery is active, it is possible to progress through the stages even when
- * there are errors. In any case, producing code is only possible without errors.
  */
 class CompilerStack: public langutil::CharStreamProvider
 {
@@ -91,7 +93,7 @@ class CompilerStack: public langutil::CharStreamProvider
 		SourcesSet,
 		Parsed,
 		ParsedAndImported,
-		AnalysisPerformed,
+		AnalysisSuccessful,
 		CompilationSuccessful
 	};
 
@@ -107,6 +109,13 @@ class CompilerStack: public langutil::CharStreamProvider
 		None
 	};
 
+	enum class CompilationSourceType {
+		/// Regular compilation from Solidity source files.
+		Solidity,
+		/// Compilation from an imported Solidity AST.
+		SolidityAST,
+	};
+
 	/// Creates a new compiler stack.
 	/// @param _readFile callback used to read files for import statements. Must return
 	/// and must not emit exceptions.
@@ -120,9 +129,7 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// @returns the current state.
 	State state() const { return m_stackState; }
 
-	bool hasError() const { return m_hasError; }
-
-	bool compilationSuccessful() const { return m_stackState >= CompilationSuccessful; }
+	virtual bool compilationSuccessful() const { return m_stackState >= CompilationSuccessful; }
 
 	/// Resets the compiler to an empty state. Unless @a _keepSettings is set to true,
 	/// all settings are reset as well.
@@ -147,14 +154,6 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// Sets whether to strip revert strings, add additional strings or do nothing at all.
 	void setRevertStringBehaviour(RevertStrings _revertStrings);
 
-	/// Set whether or not parser error is desired.
-	/// When called without an argument it will revert to the default.
-	/// Must be set before parsing.
-	void setParserErrorRecovery(bool _wantErrorRecovery = false)
-	{
-		m_parserErrorRecovery = _wantErrorRecovery;
-	}
-
 	/// Sets the pipeline to go through the Yul IR or not.
 	/// Must be set before parsing.
 	void setViaIR(bool _viaIR);
@@ -176,7 +175,7 @@ class CompilerStack: public langutil::CharStreamProvider
 	}
 
 	void setMainContract(std::string mainContract) {
-		// TODO DELETE USE setRequestedContractNames
+		// TODO DELETE USE setRequestedContractNames ?
 		m_mainContract = mainContract;
 	}
 
@@ -214,9 +213,6 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// Enable generation of Yul IR code.
 	void enableIRGeneration(bool _enable = true) { m_generateIR = _enable; }
 
-	/// Enable experimental generation of Ewasm code. If enabled, IR is also generated.
-	void enableEwasmGeneration(bool _enable = true) { m_generateEwasm = _enable; }
-
 	/// @arg _metadataLiteralSources When true, store sources as literals in the contract metadata.
 	/// Must be set before parsing.
 	void useMetadataLiteralSources(bool _metadataLiteralSources);
@@ -254,8 +250,15 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// @returns false on error.
 	std::pair<bool, bool> compile(bool json = false);
 
+	/// Checks whether experimental analysis is on; used in SyntaxTests to skip compilation in case it's ``true``.
+	/// @returns true if experimental analysis is set
+	bool isExperimentalAnalysis() const
+	{
+		return !!m_experimentalAnalysis;
+	}
+
 	/// @returns the list of sources (paths) used
-	std::vector<std::string> sourceNames() const;
+	virtual std::vector<std::string> sourceNames() const;
 
 	/// @returns a mapping assigning each source name its index inside the vector returned
 	/// by sourceNames().
@@ -276,10 +279,10 @@ class CompilerStack: public langutil::CharStreamProvider
 	// std::vector<std::string> const& unhandledSMTLib2Queries() const { return m_unhandledSMTLib2Queries; }
 
 	/// @returns a list of the contract names in the sources.
-	std::vector<std::string> contractNames() const;
+	virtual std::vector<std::string> contractNames() const;
 
 	/// @returns either the contract's name or a mixture of its name and source file, sanitized for filesystem use
-	std::string const filesystemFriendlyName(std::string const& _contractName) const;
+	virtual std::string const filesystemFriendlyName(std::string const& _contractName) const;
 
 	/// @returns the IR representation of a contract.
 	std::string const& yulIR(std::string const& _contractName) const;
@@ -287,26 +290,13 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// @returns the optimized IR representation of a contract.
 	std::string const& yulIROptimized(std::string const& _contractName) const;
 
-	/// @returns the Ewasm text representation of a contract.
-	std::string const& ewasm(std::string const& _contractName) const;
-
 	/// @returns the string that provides a mapping between bytecode and sourcecode or a nullptr
 	/// if the contract does not (yet) have bytecode.
-	std::string const* sourceMapping(std::string const& _contractName) const;
+	virtual std::string const* sourceMapping(std::string const& _contractName) const;
 
 	/// @returns the string that provides a mapping between runtime bytecode and sourcecode.
 	/// if the contract does not (yet) have bytecode.
-	std::string const* runtimeSourceMapping(std::string const& _contractName) const;
-
-	/// @return a verbose text representation of the assembly.
-	/// @arg _sourceCodes is the map of input files to source code strings
-	/// Prerequisite: Successful compilation.
-	std::string assemblyString(std::string const& _contractName, StringMap const& _sourceCodes = StringMap()) const;
-
-	/// @returns a JSON representation of the assembly.
-	/// @arg _sourceCodes is the map of input files to source code strings
-	/// Prerequisite: Successful compilation.
-	Json::Value assemblyJSON(std::string const& _contractName) const;
+	virtual std::string const* runtimeSourceMapping(std::string const& _contractName) const;
 
 	/// @returns a JSON representing the contract ABI.
 	/// Prerequisite: Successful call to parse or compile.
@@ -344,10 +334,17 @@ class CompilerStack: public langutil::CharStreamProvider
 	bytes cborMetadata(std::string const& _contractName, bool _forIR) const;
 
 	/// Changes the format of the metadata appended at the end of the bytecode.
-	/// This is mostly a workaround to avoid bytecode and gas differences between compiler builds
-	/// caused by differences in metadata. Should only be used for testing.
 	void setMetadataFormat(MetadataFormat _metadataFormat) { m_metadataFormat = _metadataFormat; }
 
+	bool isExperimentalSolidity() const;
+
+	experimental::Analysis const& experimentalAnalysis() const;
+
+	static MetadataFormat defaultMetadataFormat()
+	{
+		return VersionIsRelease ? MetadataFormat::WithReleaseVersionTag : MetadataFormat::WithPrereleaseVersionTag;
+	}
+
 private:
 	/// The state per source unit. Filled gradually during parsing.
 	struct Source
@@ -370,7 +367,6 @@ class CompilerStack: public langutil::CharStreamProvider
 		std::shared_ptr<Compiler> compiler;
 		std::string yulIR; ///< Yul IR code.
 		std::string yulIROptimized; ///< Optimized Yul IR code.
-		std::string ewasm; ///< Experimental Ewasm text representation
 		util::LazyInit<std::string const> metadata; ///< The metadata json that will be hashed into the chain.
 		mutable std::unique_ptr<Json::Value const> code;
 		mutable std::unique_ptr<Json::Value const> abi;
@@ -393,17 +389,44 @@ class CompilerStack: public langutil::CharStreamProvider
 	/// @returns the newly loaded sources.
 	StringMap loadMissingSources(SourceUnit const& _ast);
 	std::string applyRemapping(std::string const& _path, std::string const& _context);
-	void resolveImports();
+	bool resolveImports();
 
 	/// Store the contract definitions in m_contracts.
 	void storeContractDefinitions();
 
+	/// Annotate internal dispatch function Ids
+	void annotateInternalFunctionIDs();
+
 	/// @returns true if the source is requested to be compiled.
 	bool isRequestedSource(std::string const& _sourceName) const;
 
 	/// @returns true if the contract is requested to be compiled.
 	bool isRequestedContract(ContractDefinition const& _contract) const;
 
+	/// Perform the analysis steps of legacy language mode.
+	/// @returns false on error.
+	bool analyzeLegacy(bool _noErrorsSoFar);
+
+	/// Perform the analysis steps of experimental language mode.
+	/// @returns false on error.
+	bool analyzeExperimental();
+
+	/// Compile a single contract.
+	/// @param _otherCompilers provides access to compilers of other contracts, to get
+	///                        their bytecode if needed. Only filled after they have been compiled.
+	void compileContract(
+		ContractDefinition const& _contract,
+		std::map<ContractDefinition const*, std::shared_ptr<Compiler const>>& _otherCompilers
+	);
+
+	/// Generate Yul IR for a single contract.
+	/// The IR is stored but otherwise unused.
+	void generateIR(ContractDefinition const& _contract);
+
+	/// Generate EVM representation for a single contract.
+	/// Depends on output generated by generateIR.
+	void generateEVMFromIR(ContractDefinition const& _contract);
+
 	/// Links all the known library addresses in the available objects. Any unknown
 	/// library will still be kept as an unlinked placeholder in the objects.
 	void link();
@@ -461,30 +484,27 @@ class CompilerStack: public langutil::CharStreamProvider
 	std::map<std::string, std::set<std::string>> m_requestedContractNames;
 	bool m_generateEvmBytecode = true;
 	bool m_generateIR = false;
-	bool m_generateEwasm = false;
 	std::map<std::string, util::h160> m_libraries;
 	ImportRemapper m_importRemapper;
 	std::map<std::string const, Source> m_sources;
 	// if imported, store AST-JSONS for each filename
 	std::map<std::string, Json::Value> m_sourceJsons;
-	// std::vector<std::string> m_unhandledSMTLib2Queries;
-	// std::map<util::h256, std::string> m_smtlib2Responses;
+	std::optional<int64_t> m_maxAstId;
 	std::shared_ptr<GlobalContext> m_globalContext;
 	std::vector<Source const*> m_sourceOrder;
 	std::map<std::string const, Contract> m_contracts;
 
 	langutil::ErrorList m_errorList;
 	langutil::ErrorReporter m_errorReporter;
+	std::unique_ptr<experimental::Analysis> m_experimentalAnalysis;
 	bool m_metadataLiteralSources = false;
 	MetadataHash m_metadataHash = MetadataHash::IPFS;
 	langutil::DebugInfoSelection m_debugInfoSelection = langutil::DebugInfoSelection::Default();
-	bool m_parserErrorRecovery = false;
 	State m_stackState = Empty;
 	bool m_importedSources = false;
 	/// Whether or not there has been an error during processing.
 	/// If this is true, the stack will refuse to generate code.
 	bool m_hasError = false;
-	MetadataFormat m_metadataFormat = VersionIsRelease ? MetadataFormat::WithReleaseVersionTag : MetadataFormat::WithPrereleaseVersionTag;
 
 	std::string m_mainContract;
 	bool m_generateAbi{};
@@ -495,6 +515,9 @@ class CompilerStack: public langutil::CharStreamProvider
 	bool m_doPrintFunctionIds = false;
     bool m_doPrivateFunctionIds = false;
 	solidity::langutil::TVMVersion m_tvmVersion;
+
+	CompilationSourceType m_compilationSourceType = CompilationSourceType::Solidity;
+	MetadataFormat m_metadataFormat = defaultMetadataFormat();
 };
 
 }
diff --git a/compiler/libsolidity/interface/FileReader.cpp b/compiler/libsolidity/interface/FileReader.cpp
index 8300feb5..4197780e 100644
--- a/compiler/libsolidity/interface/FileReader.cpp
+++ b/compiler/libsolidity/interface/FileReader.cpp
@@ -35,17 +35,13 @@ using solidity::langutil::InternalCompilerError;
 using solidity::util::errinfo_comment;
 using solidity::util::readFileAsString;
 using solidity::util::joinHumanReadable;
-using std::map;
-using std::reference_wrapper;
-using std::string;
-using std::vector;
 
 namespace solidity::frontend
 {
 
 FileReader::FileReader(
 	boost::filesystem::path _basePath,
-	vector<boost::filesystem::path> const& _includePaths,
+	std::vector<boost::filesystem::path> const& _includePaths,
 	FileSystemPathSet _allowedDirectories
 ):
 	m_allowedDirectories(std::move(_allowedDirectories)),
@@ -99,19 +95,19 @@ void FileReader::setSourceUnits(StringMap _sources)
 	m_sourceCodes = std::move(_sources);
 }
 
-ReadCallback::Result FileReader::readFile(string const& _kind, string const& _sourceUnitName)
+ReadCallback::Result FileReader::readFile(std::string const& _kind, std::string const& _sourceUnitName)
 {
 	try
 	{
 		if (_kind != ReadCallback::kindString(ReadCallback::Kind::ReadFile))
 			solAssert(false, "ReadFile callback used as callback kind " + _kind);
-		string strippedSourceUnitName = _sourceUnitName;
+		std::string strippedSourceUnitName = _sourceUnitName;
 		if (strippedSourceUnitName.find("file://") == 0)
 			strippedSourceUnitName.erase(0, 7);
 
-		vector<boost::filesystem::path> candidates;
-		vector<reference_wrapper<boost::filesystem::path>> prefixes = {m_basePath};
-		prefixes += (m_includePaths | ranges::to<vector<reference_wrapper<boost::filesystem::path>>>);
+		std::vector<boost::filesystem::path> candidates;
+		std::vector<std::reference_wrapper<boost::filesystem::path>> prefixes = {m_basePath};
+		prefixes += (m_includePaths | ranges::to<std::vector<std::reference_wrapper<boost::filesystem::path>>>);
 
 		for (auto const& prefix: prefixes)
 		{
@@ -183,9 +179,9 @@ ReadCallback::Result FileReader::readFile(string const& _kind, string const& _so
 	}
 }
 
-string FileReader::cliPathToSourceUnitName(boost::filesystem::path const& _cliPath) const
+std::string FileReader::cliPathToSourceUnitName(boost::filesystem::path const& _cliPath) const
 {
-	vector<boost::filesystem::path> prefixes = {m_basePath.empty() ? normalizeCLIPathForVFS(".") : m_basePath};
+	std::vector<boost::filesystem::path> prefixes = {m_basePath.empty() ? normalizeCLIPathForVFS(".") : m_basePath};
 	prefixes += m_includePaths;
 
 	boost::filesystem::path normalizedPath = normalizeCLIPathForVFS(_cliPath);
@@ -200,17 +196,17 @@ string FileReader::cliPathToSourceUnitName(boost::filesystem::path const& _cliPa
 	return normalizedPath.generic_string();
 }
 
-map<string, FileReader::FileSystemPathSet> FileReader::detectSourceUnitNameCollisions(FileSystemPathSet const& _cliPaths) const
+std::map<std::string, FileReader::FileSystemPathSet> FileReader::detectSourceUnitNameCollisions(FileSystemPathSet const& _cliPaths) const
 {
-	map<string, FileReader::FileSystemPathSet> nameToPaths;
+	std::map<std::string, FileReader::FileSystemPathSet> nameToPaths;
 	for (boost::filesystem::path const& cliPath: _cliPaths)
 	{
-		string sourceUnitName = cliPathToSourceUnitName(cliPath);
+		std::string sourceUnitName = cliPathToSourceUnitName(cliPath);
 		boost::filesystem::path normalizedPath = normalizeCLIPathForVFS(cliPath);
 		nameToPaths[sourceUnitName].insert(normalizedPath);
 	}
 
-	map<string, FileReader::FileSystemPathSet> collisions;
+	std::map<std::string, FileReader::FileSystemPathSet> collisions;
 	for (auto&& [sourceUnitName, cliPaths]: nameToPaths)
 		if (cliPaths.size() >= 2)
 			collisions[sourceUnitName] = std::move(cliPaths);
@@ -329,7 +325,10 @@ bool FileReader::isPathPrefix(boost::filesystem::path const& _prefix, boost::fil
 	// NOTE: On Windows paths starting with a slash (rather than a drive letter) are considered relative by boost.
 	solAssert(_prefix.is_absolute() || isUNCPath(_prefix) || _prefix.root_path() == "/", "");
 	solAssert(_path.is_absolute() || isUNCPath(_path) || _path.root_path() == "/", "");
-	solAssert(_prefix == _prefix.lexically_normal() && _path == _path.lexically_normal(), "");
+	// NOTE: On Windows before Boost 1.78 lexically_normal() would not replace the `//` UNC prefix with `\\\\`.
+	// Later versions do. Use generic_path() to normalize all slashes to `/` and ignore that difference.
+	// This does not make the assert weaker because == ignores slash type anyway.
+	solAssert(_prefix == _prefix.lexically_normal().generic_string() && _path == _path.lexically_normal().generic_string(), "");
 	solAssert(!hasDotDotSegments(_prefix) && !hasDotDotSegments(_path), "");
 
 	boost::filesystem::path strippedPath = _path.lexically_relative(
@@ -377,7 +376,7 @@ bool FileReader::hasDotDotSegments(boost::filesystem::path const& _path)
 
 bool FileReader::isUNCPath(boost::filesystem::path const& _path)
 {
-	string rootName = _path.root_name().string();
+	std::string rootName = _path.root_name().string();
 
 	return (
 		rootName.size() == 2 ||
diff --git a/compiler/libsolidity/interface/GasEstimator.cpp b/compiler/libsolidity/interface/GasEstimator.cpp
new file mode 100644
index 00000000..fd3fbbc0
--- /dev/null
+++ b/compiler/libsolidity/interface/GasEstimator.cpp
@@ -0,0 +1,124 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Gas consumption estimator working alongside the AST.
+ */
+
+#include <libsolidity/interface/GasEstimator.h>
+
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/ASTVisitor.h>
+#include <libsolidity/codegen/CompilerUtils.h>
+
+#include <libevmasm/ControlFlowGraph.h>
+#include <libevmasm/KnownState.h>
+#include <libevmasm/PathGasMeter.h>
+#include <libsolutil/FunctionSelector.h>
+#include <libsolutil/Keccak256.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+
+using namespace solidity;
+using namespace solidity::evmasm;
+using namespace solidity::frontend;
+using namespace solidity::langutil;
+
+GasEstimator::GasConsumption GasEstimator::functionalEstimation(
+	AssemblyItems const& _items,
+	std::string const& _signature
+) const
+{
+	auto state = std::make_shared<KnownState>();
+
+	if (!_signature.empty())
+	{
+		ExpressionClasses& classes = state->expressionClasses();
+		using Id = ExpressionClasses::Id;
+		using Ids = std::vector<Id>;
+		Id hashValue = classes.find(u256(util::selectorFromSignatureU32(_signature)));
+		Id calldata = classes.find(Instruction::CALLDATALOAD, Ids{classes.find(u256(0))});
+		if (!m_evmVersion.hasBitwiseShifting())
+			// div(calldataload(0), 1 << 224) equals to hashValue
+			classes.forceEqual(
+				hashValue,
+				Instruction::DIV,
+				Ids{calldata, classes.find(u256(1) << 224)}
+			);
+		else
+			// shr(0xe0, calldataload(0)) equals to hashValue
+			classes.forceEqual(
+				hashValue,
+				Instruction::SHR,
+				Ids{classes.find(u256(0xe0)), calldata}
+			);
+		// lt(calldatasize(), 4) equals to 0 (ignore the shortcut for fallback functions)
+		classes.forceEqual(
+			classes.find(u256(0)),
+			Instruction::LT,
+			Ids{classes.find(Instruction::CALLDATASIZE), classes.find(u256(4))}
+		);
+	}
+
+	return PathGasMeter::estimateMax(_items, m_evmVersion, 0, state);
+}
+
+GasEstimator::GasConsumption GasEstimator::functionalEstimation(
+	AssemblyItems const& _items,
+	size_t const& _offset,
+	FunctionDefinition const& _function
+) const
+{
+	auto state = std::make_shared<KnownState>();
+
+	unsigned parametersSize = CompilerUtils::sizeOnStack(_function.parameters());
+	if (parametersSize > 16)
+		return GasConsumption::infinite();
+
+	// Store an invalid return value on the stack, so that the path estimator breaks upon reaching
+	// the return jump.
+	AssemblyItem invalidTag(PushTag, u256(-0x10));
+	state->feedItem(invalidTag, true);
+	if (parametersSize > 0)
+		state->feedItem(swapInstruction(parametersSize));
+
+	return PathGasMeter::estimateMax(_items, m_evmVersion, _offset, state);
+}
+
+std::set<ASTNode const*> GasEstimator::finestNodesAtLocation(
+	std::vector<ASTNode const*> const& _roots
+)
+{
+	std::map<SourceLocation, ASTNode const*> locations;
+	std::set<ASTNode const*> nodes;
+	SimpleASTVisitor visitor(std::function<bool(ASTNode const&)>(), [&](ASTNode const& _n)
+	{
+		if (!locations.count(_n.location()))
+		{
+			locations[_n.location()] = &_n;
+			nodes.insert(&_n);
+		}
+	});
+
+	for (ASTNode const* root: _roots)
+		root->accept(visitor);
+	return nodes;
+}
diff --git a/compiler/libsolidity/interface/ImportRemapper.cpp b/compiler/libsolidity/interface/ImportRemapper.cpp
index 4d4fa42d..6b870875 100644
--- a/compiler/libsolidity/interface/ImportRemapper.cpp
+++ b/compiler/libsolidity/interface/ImportRemapper.cpp
@@ -19,29 +19,20 @@
 #include <libsolutil/CommonIO.h>
 #include <liblangutil/Exceptions.h>
 
-using std::equal;
-using std::find;
-using std::move;
-using std::nullopt;
-using std::optional;
-using std::string;
-using std::string_view;
-using std::vector;
-
 namespace solidity::frontend
 {
 
-void ImportRemapper::setRemappings(vector<Remapping> _remappings)
+void ImportRemapper::setRemappings(std::vector<Remapping> _remappings)
 {
 	for (auto const& remapping: _remappings)
 		solAssert(!remapping.prefix.empty(), "");
 	m_remappings = std::move(_remappings);
 }
 
-SourceUnitName ImportRemapper::apply(ImportPath const& _path, string const& _context) const
+SourceUnitName ImportRemapper::apply(ImportPath const& _path, std::string const& _context) const
 {
 	// Try to find the longest prefix match in all remappings that are active in the current context.
-	auto isPrefixOf = [](string const& _a, string const& _b)
+	auto isPrefixOf = [](std::string const& _a, std::string const& _b)
 	{
 		if (_a.length() > _b.length())
 			return false;
@@ -50,12 +41,12 @@ SourceUnitName ImportRemapper::apply(ImportPath const& _path, string const& _con
 
 	size_t longestPrefix = 0;
 	size_t longestContext = 0;
-	string bestMatchTarget;
+	std::string bestMatchTarget;
 
 	for (auto const& redir: m_remappings)
 	{
-		string context = util::sanitizePath(redir.context);
-		string prefix = util::sanitizePath(redir.prefix);
+		std::string context = util::sanitizePath(redir.context);
+		std::string prefix = util::sanitizePath(redir.prefix);
 
 		// Skip if current context is closer
 		if (context.length() < longestContext)
@@ -74,32 +65,32 @@ SourceUnitName ImportRemapper::apply(ImportPath const& _path, string const& _con
 		longestPrefix = prefix.length();
 		bestMatchTarget = util::sanitizePath(redir.target);
 	}
-	string path = bestMatchTarget;
-	path.append(_path.begin() + static_cast<string::difference_type>(longestPrefix), _path.end());
+	std::string path = bestMatchTarget;
+	path.append(_path.begin() + static_cast<std::string::difference_type>(longestPrefix), _path.end());
 	return path;
 }
 
-bool ImportRemapper::isRemapping(string_view _input)
+bool ImportRemapper::isRemapping(std::string_view _input)
 {
-	return _input.find("=") != string::npos;
+	return _input.find("=") != std::string::npos;
 }
 
-optional<ImportRemapper::Remapping> ImportRemapper::parseRemapping(string_view _input)
+	std::optional<ImportRemapper::Remapping> ImportRemapper::parseRemapping(std::string_view _input)
 {
-	auto equals = find(_input.cbegin(), _input.cend(), '=');
+	auto equals = std::find(_input.cbegin(), _input.cend(), '=');
 	if (equals == _input.end())
-		return nullopt;
+		return std::nullopt;
 
-	auto const colon = find(_input.cbegin(), equals, ':');
+	auto const colon = std::find(_input.cbegin(), equals, ':');
 
 	Remapping remapping{
-		(colon == equals ? "" : string(_input.cbegin(), colon)),
-		(colon == equals ? string(_input.cbegin(), equals) : string(colon + 1, equals)),
-		string(equals + 1, _input.cend()),
+		(colon == equals ? "" : std::string(_input.cbegin(), colon)),
+		(colon == equals ? std::string(_input.cbegin(), equals) : std::string(colon + 1, equals)),
+		std::string(equals + 1, _input.cend()),
 	};
 
 	if (remapping.prefix.empty())
-		return nullopt;
+		return std::nullopt;
 
 	return remapping;
 }
diff --git a/compiler/libsolidity/interface/Natspec.cpp b/compiler/libsolidity/interface/Natspec.cpp
index 566b6760..539a3573 100644
--- a/compiler/libsolidity/interface/Natspec.cpp
+++ b/compiler/libsolidity/interface/Natspec.cpp
@@ -30,8 +30,6 @@
 
 #include <boost/algorithm/string.hpp>
 
-
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
@@ -46,7 +44,7 @@ Json::Value Natspec::userDocumentation(ContractDefinition const& _contractDef)
 	auto constructorDefinition(_contractDef.constructor());
 	if (constructorDefinition)
 	{
-		string const value = extractDoc(constructorDefinition->annotation().docTags, "notice");
+		std::string const value = extractDoc(constructorDefinition->annotation().docTags, "notice");
 		if (!value.empty())
 		{
 			// add the constructor, only if we have any documentation to add
@@ -56,14 +54,14 @@ Json::Value Natspec::userDocumentation(ContractDefinition const& _contractDef)
 		}
 	}
 
-	string notice = extractDoc(_contractDef.annotation().docTags, "notice");
+	std::string notice = extractDoc(_contractDef.annotation().docTags, "notice");
 	if (!notice.empty())
 		doc["notice"] = Json::Value(notice);
 
 	for (auto const& it: _contractDef.interfaceFunctions())
 		if (it.second->hasDeclaration())
 		{
-			string value;
+			std::string value;
 
 			if (auto const* f = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
 				value = extractDoc(f->annotation().docTags, "notice");
@@ -78,16 +76,16 @@ Json::Value Natspec::userDocumentation(ContractDefinition const& _contractDef)
 				doc["methods"][it.second->externalSignature()]["notice"] = value;
 		}
 
-	for (auto const& event: _contractDef.definedInterfaceEvents())
+	for (auto const& event: uniqueInterfaceEvents(_contractDef))
 	{
-		string value = extractDoc(event->annotation().docTags, "notice");
+		std::string value = extractDoc(event->annotation().docTags, "notice");
 		if (!value.empty())
 			doc["events"][event->functionType(true)->externalSignature()]["notice"] = value;
 	}
 
 	for (auto const& error: _contractDef.interfaceErrors())
 	{
-		string value = extractDoc(error->annotation().docTags, "notice");
+		std::string value = extractDoc(error->annotation().docTags, "notice");
 		if (!value.empty())
 		{
 			Json::Value errorDoc{Json::objectValue};
@@ -152,7 +150,7 @@ Json::Value Natspec::devDocumentation(ContractDefinition const& _contractDef)
 		if (auto devDoc = devDocumentation(varDecl->annotation().docTags); !devDoc.empty())
 			doc["stateVariables"][varDecl->name()] = devDoc;
 
-		auto const assignIfNotEmpty = [&](string const& _name, Json::Value const& _content)
+		auto const assignIfNotEmpty = [&](std::string const& _name, Json::Value const& _content)
 		{
 			if (!_content.empty())
 				doc["stateVariables"][varDecl->name()][_name] = _content;
@@ -168,10 +166,9 @@ Json::Value Natspec::devDocumentation(ContractDefinition const& _contractDef)
 			));
 	}
 
-	for (auto const& event: _contractDef.events())
+	for (auto const& event: uniqueInterfaceEvents(_contractDef))
 		if (auto devDoc = devDocumentation(event->annotation().docTags); !devDoc.empty())
 			doc["events"][event->functionType(true)->externalSignature()] = devDoc;
-
 	for (auto const& error: _contractDef.interfaceErrors())
 		if (auto devDoc = devDocumentation(error->annotation().docTags); !devDoc.empty())
 			doc["errors"][error->functionType(true)->externalSignature()].append(devDoc);
@@ -179,7 +176,7 @@ Json::Value Natspec::devDocumentation(ContractDefinition const& _contractDef)
 	return doc;
 }
 
-Json::Value Natspec::extractReturnParameterDocs(std::multimap<std::string, DocTag> const& _tags, vector<string> const& _returnParameterNames)
+Json::Value Natspec::extractReturnParameterDocs(std::multimap<std::string, DocTag> const& _tags, std::vector<std::string> const& _returnParameterNames)
 {
 	Json::Value jsonReturn{Json::objectValue};
 	auto returnDocs = _tags.equal_range("return");
@@ -189,8 +186,8 @@ Json::Value Natspec::extractReturnParameterDocs(std::multimap<std::string, DocTa
 		size_t n = 0;
 		for (auto i = returnDocs.first; i != returnDocs.second; i++)
 		{
-			string paramName = _returnParameterNames.at(n);
-			string content = i->second.content;
+			std::string paramName = _returnParameterNames.at(n);
+			std::string content = i->second.content;
 
 			if (paramName.empty())
 				paramName = "_" + std::to_string(n);
@@ -210,18 +207,18 @@ Json::Value Natspec::extractReturnParameterDocs(std::multimap<std::string, DocTa
 	return jsonReturn;
 }
 
-string Natspec::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
+std::string Natspec::extractDoc(std::multimap<std::string, DocTag> const& _tags, std::string const& _name)
 {
-	string value;
+	std::string value;
 	auto range = _tags.equal_range(_name);
 	for (auto i = range.first; i != range.second; i++)
 		value += i->second.content;
 	return value;
 }
 
-Json::Value Natspec::extractCustomDoc(multimap<string, DocTag> const& _tags)
+Json::Value Natspec::extractCustomDoc(std::multimap<std::string, DocTag> const& _tags)
 {
-	std::map<string, string> concatenated;
+	std::map<std::string, std::string> concatenated;
 	for (auto const& [tag, value]: _tags)
 		if (boost::starts_with(tag, "custom"))
 			concatenated[tag] += value.content;
@@ -255,3 +252,34 @@ Json::Value Natspec::devDocumentation(std::multimap<std::string, DocTag> const&
 
 	return json;
 }
+
+std::vector<EventDefinition const*>  Natspec::uniqueInterfaceEvents(ContractDefinition const& _contract)
+{
+	auto eventSignature = [](EventDefinition const* _event) -> std::string {
+		FunctionType const* functionType = _event->functionType(true);
+		solAssert(functionType, "");
+		return functionType->externalSignature();
+	};
+	auto compareBySignature =
+		[&](EventDefinition const* _lhs, EventDefinition const* _rhs) -> bool {
+			return eventSignature(_lhs) < eventSignature(_rhs);
+		};
+
+	std::set<EventDefinition const*, decltype(compareBySignature)> uniqueEvents{compareBySignature};
+	// Insert events defined in the contract first so that in case of a conflict
+	// they're the ones that get selected.
+	uniqueEvents += _contract.definedInterfaceEvents();
+
+	std::set<EventDefinition const*, decltype(compareBySignature)> filteredUsedEvents{compareBySignature};
+	std::set<std::string> usedSignatures;
+	for (EventDefinition const* event: _contract.usedInterfaceEvents())
+	{
+		auto&& [eventIt, eventInserted] = filteredUsedEvents.insert(event);
+		auto&& [signatureIt, signatureInserted] = usedSignatures.insert(eventSignature(event));
+		if (!signatureInserted)
+			filteredUsedEvents.erase(eventIt);
+	}
+
+	uniqueEvents += filteredUsedEvents;
+	return util::convertContainer<std::vector<EventDefinition const*>>(std::move(uniqueEvents));
+}
diff --git a/compiler/libsolidity/interface/Natspec.h b/compiler/libsolidity/interface/Natspec.h
index bbf62438..e7548509 100644
--- a/compiler/libsolidity/interface/Natspec.h
+++ b/compiler/libsolidity/interface/Natspec.h
@@ -72,6 +72,13 @@ class Natspec
 	/// @return      A JSON representation
 	///              of a method's return notice documentation
 	static Json::Value extractReturnParameterDocs(std::multimap<std::string, DocTag> const& _tags, std::vector<std::string> const& _returnParameterNames);
+
+	/// Temporary function until https://github.com/ethereum/solidity/issues/11114 is implemented.
+	/// @return all events defined in the contract and its base contracts and all events
+	/// that are emitted during the execution of the contract, but allowing only unique signatures.
+	/// In case of conflict between a library event and a contract one, selects the latter
+	/// In case of conflict between two library events, none is selected
+	static std::vector<EventDefinition const*> uniqueInterfaceEvents(ContractDefinition const& _contract);
 };
 
 }
diff --git a/compiler/libsolidity/interface/OptimiserSettings.h b/compiler/libsolidity/interface/OptimiserSettings.h
index e233048c..46683088 100644
--- a/compiler/libsolidity/interface/OptimiserSettings.h
+++ b/compiler/libsolidity/interface/OptimiserSettings.h
@@ -59,6 +59,8 @@ struct OptimiserSettings
 		"]"
 		"jmul[jul] VcTOcul jmul";      // Make source short and pretty
 
+	static char constexpr DefaultYulOptimiserCleanupSteps[] = "fDnTOcmu";
+
 	/// No optimisations at all - not recommended.
 	static OptimiserSettings none()
 	{
@@ -70,6 +72,7 @@ struct OptimiserSettings
 		OptimiserSettings s = none();
 		s.runJumpdestRemover = true;
 		s.runPeephole = true;
+		s.simpleCounterForLoopUncheckedIncrement = true;
 		return s;
 	}
 	/// Standard optimisations.
@@ -83,6 +86,7 @@ struct OptimiserSettings
 		s.runDeduplicate = true;
 		s.runCSE = true;
 		s.runConstantOptimiser = true;
+		s.simpleCounterForLoopUncheckedIncrement = true;
 		s.runYulOptimiser = true;
 		s.optimizeStackAllocation = true;
 		return s;
@@ -101,8 +105,8 @@ struct OptimiserSettings
 			case OptimisationPreset::Minimal: return minimal();
 			case OptimisationPreset::Standard: return standard();
 			case OptimisationPreset::Full: return full();
-			default: solAssert(false, "");
 		}
+		util::unreachable();
 	}
 
 	bool operator==(OptimiserSettings const& _other) const
@@ -115,12 +119,18 @@ struct OptimiserSettings
 			runDeduplicate == _other.runDeduplicate &&
 			runCSE == _other.runCSE &&
 			runConstantOptimiser == _other.runConstantOptimiser &&
+			simpleCounterForLoopUncheckedIncrement == _other.simpleCounterForLoopUncheckedIncrement &&
 			optimizeStackAllocation == _other.optimizeStackAllocation &&
 			runYulOptimiser == _other.runYulOptimiser &&
 			yulOptimiserSteps == _other.yulOptimiserSteps &&
 			expectedExecutionsPerDeployment == _other.expectedExecutionsPerDeployment;
 	}
 
+	bool operator!=(OptimiserSettings const& _other) const
+	{
+		return !(*this == _other);
+	}
+
 	/// Move literals to the right of commutative binary operators during code generation.
 	/// This helps exploiting associativity.
 	bool runOrderLiterals = false;
@@ -138,14 +148,20 @@ struct OptimiserSettings
 	/// size/cost-trade-off.
 	bool runConstantOptimiser = false;
 	/// Perform more efficient stack allocation for variables during code generation from Yul to bytecode.
-	bool optimizeStackAllocation = false;
+	bool simpleCounterForLoopUncheckedIncrement = false;
 	/// Yul optimiser with default settings. Will only run on certain parts of the code for now.
+	bool optimizeStackAllocation = false;
+	/// Allow unchecked arithmetic when incrementing the counter of certain kinds of 'for' loop
 	bool runYulOptimiser = false;
 	/// Sequence of optimisation steps to be performed by Yul optimiser.
 	/// Note that there are some hard-coded steps in the optimiser and you cannot disable
 	/// them just by setting this to an empty string. Set @a runYulOptimiser to false if you want
 	/// no optimisations.
 	std::string yulOptimiserSteps = DefaultYulOptimiserSteps;
+	/// Sequence of clean-up optimisation steps after yulOptimiserSteps is run. Note that if the string
+	/// is left empty, there will still be hard-coded optimisation steps that will run regardless.
+	/// Set @a runYulOptimiser to false if you want no optimisations.
+	std::string yulOptimiserCleanupSteps = DefaultYulOptimiserCleanupSteps;
 	/// This specifies an estimate on how often each opcode in this assembly will be executed,
 	/// i.e. use a small value to optimise for size and a large value to optimise for runtime gas usage.
 	size_t expectedExecutionsPerDeployment = 200;
diff --git a/compiler/libsolidity/interface/SMTSolverCommand.cpp b/compiler/libsolidity/interface/SMTSolverCommand.cpp
new file mode 100644
index 00000000..92e0485b
--- /dev/null
+++ b/compiler/libsolidity/interface/SMTSolverCommand.cpp
@@ -0,0 +1,84 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#include <libsolidity/interface/SMTSolverCommand.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/Exceptions.h>
+#include <libsolutil/Keccak256.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/process.hpp>
+
+using solidity::langutil::InternalCompilerError;
+using solidity::util::errinfo_comment;
+
+
+namespace solidity::frontend
+{
+
+SMTSolverCommand::SMTSolverCommand(std::string _solverCmd) : m_solverCmd(_solverCmd) {}
+
+ReadCallback::Result SMTSolverCommand::solve(std::string const& _kind, std::string const& _query)
+{
+	try
+	{
+		if (_kind != ReadCallback::kindString(ReadCallback::Kind::SMTQuery))
+			solAssert(false, "SMTQuery callback used as callback kind " + _kind);
+
+		auto tempDir = solidity::util::TemporaryDirectory("smt");
+		util::h256 queryHash = util::keccak256(_query);
+		auto queryFileName = tempDir.path() / ("query_" + queryHash.hex() + ".smt2");
+
+		auto queryFile = boost::filesystem::ofstream(queryFileName);
+		queryFile << _query;
+
+		auto eldBin = boost::process::search_path(m_solverCmd);
+
+		if (eldBin.empty())
+			return ReadCallback::Result{false, m_solverCmd + " binary not found."};
+
+		boost::process::ipstream pipe;
+		boost::process::child eld(
+			eldBin,
+			queryFileName,
+			boost::process::std_out > pipe
+		);
+
+		std::vector<std::string> data;
+		std::string line;
+		while (eld.running() && std::getline(pipe, line))
+			if (!line.empty())
+				data.push_back(line);
+
+		eld.wait();
+
+		return ReadCallback::Result{true, boost::join(data, "\n")};
+	}
+	catch (...)
+	{
+		return ReadCallback::Result{false, "Unknown exception in SMTQuery callback: " + boost::current_exception_diagnostic_information()};
+	}
+}
+
+}
diff --git a/compiler/libsolidity/interface/SMTSolverCommand.h b/compiler/libsolidity/interface/SMTSolverCommand.h
new file mode 100644
index 00000000..56a6ba17
--- /dev/null
+++ b/compiler/libsolidity/interface/SMTSolverCommand.h
@@ -0,0 +1,46 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/interface/ReadFile.h>
+
+#include <boost/filesystem.hpp>
+
+namespace solidity::frontend
+{
+
+/// SMTSolverCommand wraps an SMT solver called via its binary in the OS.
+class SMTSolverCommand
+{
+public:
+	SMTSolverCommand(std::string _solverCmd);
+
+	/// Calls an SMT solver with the given query.
+	frontend::ReadCallback::Result solve(std::string const& _kind, std::string const& _query);
+
+	frontend::ReadCallback::Callback solver()
+	{
+		return [this](std::string const& _kind, std::string const& _query) { return solve(_kind, _query); };
+	}
+
+private:
+	/// The name of the solver's binary.
+	std::string const m_solverCmd;
+};
+
+}
diff --git a/compiler/libsolidity/interface/StandardCompiler.cpp b/compiler/libsolidity/interface/StandardCompiler.cpp
index 378ac4a3..351dde91 100644
--- a/compiler/libsolidity/interface/StandardCompiler.cpp
+++ b/compiler/libsolidity/interface/StandardCompiler.cpp
@@ -41,30 +41,29 @@
 #include <algorithm>
 #include <optional>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
 using namespace solidity::frontend;
 using namespace solidity::langutil;
+using namespace std::string_literals;
 
 namespace
 {
 
 Json::Value formatError(
-	Error::Severity _severity,
-	string const& _type,
-	string const& _component,
-	string const& _message,
-	string const& _formattedMessage = "",
-	string const& _humanFormattedMessage = "",
+	Error::Type _type,
+	std::string const& _component,
+	std::string const& _message,
+	std::string const& _formattedMessage = "",
+	std::string const& _humanFormattedMessage = "",
 	Json::Value const& _sourceLocation = Json::Value(),
 	Json::Value const& _secondarySourceLocation = Json::Value()
 )
 {
 	Json::Value error{Json::objectValue};
-	error["type"] = _type;
+	error["type"] = Error::formatErrorType(_type);
 	error["component"] = _component;
-	error["severity"] = Error::formatErrorSeverityLowercase(_severity);
+	error["severity"] = Error::formatErrorSeverityLowercase(Error::errorSeverity(_type));
 	error["message"] = _message;
 	error["formattedMessage"] = (_formattedMessage.length() > 0) ? _formattedMessage : _message;
 	error["humanFormattedMessage"] = (_humanFormattedMessage.length() > 0) ? _humanFormattedMessage : _message;
@@ -75,11 +74,11 @@ Json::Value formatError(
 	return error;
 }
 
-Json::Value formatFatalError(string const& _type, string const& _message)
+Json::Value formatFatalError(Error::Type _type, std::string const& _message)
 {
 	Json::Value output{Json::objectValue};
 	output["errors"] = Json::arrayValue;
-	output["errors"].append(formatError(Error::Severity::Error, _type, "general", _message));
+	output["errors"].append(formatError(_type, "general", _message));
 	return output;
 }
 
@@ -113,31 +112,31 @@ Json::Value formatSecondarySourceLocation(SecondarySourceLocation const* _second
 Json::Value formatErrorWithException(
 	CharStreamProvider const& _charStreamProvider,
 	util::Exception const& _exception,
-	Error::Severity _severity,
-	string const& _type,
-	string const& _component,
-	string const& _message,
-	optional<ErrorId> _errorId = nullopt
+	Error::Type _type,
+	std::string const& _component,
+	std::string const& _message,
+	std::optional<ErrorId> _errorId = std::nullopt
 )
 {
-	string message;
+	std::string message;
 	// TODO: consider enabling color
-	string formattedMessage = SourceReferenceFormatter::formatExceptionInformation(
+	std::string formattedMessage = SourceReferenceFormatter::formatExceptionInformation(
 		_exception,
 		_type,
-		_charStreamProvider
+		_charStreamProvider,
+		false // colored
 	);
 
-    string typeForHuman = boost::ends_with(_type, "Error") ? "Error" : _type;
-	string humanFormattedMessage = SourceReferenceFormatter::formatExceptionInformation(_exception, typeForHuman, _charStreamProvider, true);
+	std::string errText = Error::formatErrorSeverity(Error::errorSeverity(_type));
+    std::string typeForHuman = boost::ends_with(errText, "Error") ? "Error" : errText;
+	std::string humanFormattedMessage = SourceReferenceFormatter::formatExceptionInformation(_exception, _type, _charStreamProvider, true);
 
-	if (string const* description = _exception.comment())
+	if (std::string const* description = _exception.comment())
 		message = ((_message.length() > 0) ? (_message + ":") : "") + *description;
 	else
 		message = _message;
 
 	Json::Value error = formatError(
-		_severity,
 		_type,
 		_component,
 		message,
@@ -148,20 +147,20 @@ Json::Value formatErrorWithException(
 	);
 
 	if (_errorId)
-		error["errorCode"] = to_string(_errorId.value().error);
+		error["errorCode"] = std::to_string(_errorId.value().error);
 
 	return error;
 }
 
-map<string, set<string>> requestedContractNames(Json::Value const& _outputSelection)
+std::map<std::string, std::set<std::string>> requestedContractNames(Json::Value const& _outputSelection)
 {
-	map<string, set<string>> contracts;
+	std::map<std::string, std::set<std::string>> contracts;
 	for (auto const& sourceName: _outputSelection.getMemberNames())
 	{
-		string key = (sourceName == "*") ? "" : sourceName;
+		std::string key = (sourceName == "*") ? "" : sourceName;
 		for (auto const& contractName: _outputSelection[sourceName].getMemberNames())
 		{
-			string value = (contractName == "*") ? "" : contractName;
+			std::string value = (contractName == "*") ? "" : contractName;
 			contracts[key].insert(value);
 		}
 	}
@@ -169,7 +168,7 @@ map<string, set<string>> requestedContractNames(Json::Value const& _outputSelect
 }
 
 /// Returns true iff @a _hash (hex with 0x prefix) is the Keccak256 hash of the binary data in @a _content.
-bool hashMatchesContent(string const& _hash, string const& _content)
+bool hashMatchesContent(std::string const& _hash, std::string const& _content)
 {
 	try
 	{
@@ -181,12 +180,12 @@ bool hashMatchesContent(string const& _hash, string const& _content)
 	}
 }
 
-bool isArtifactRequested(Json::Value const& _outputSelection, string const& _artifact, bool _wildcardMatchesExperimental)
+bool isArtifactRequested(Json::Value const& _outputSelection, std::string const& _artifact, bool _wildcardMatchesExperimental)
 {
-	static set<string> experimental{"ir", "irOptimized", "wast", "ewasm", "ewasm.wast"};
+	static std::set<std::string> experimental{"ir", "irAst", "irOptimized", "irOptimizedAst"};
 	for (auto const& selectedArtifactJson: _outputSelection)
 	{
-		string const& selectedArtifact = selectedArtifactJson.asString();
+		std::string const& selectedArtifact = selectedArtifactJson.asString();
 		if (
 			_artifact == selectedArtifact ||
 			boost::algorithm::starts_with(_artifact, selectedArtifact + ".")
@@ -194,7 +193,7 @@ bool isArtifactRequested(Json::Value const& _outputSelection, string const& _art
 			return true;
 		else if (selectedArtifact == "*")
 		{
-			// "ir", "irOptimized", "wast" and "ewasm.wast" can only be matched by "*" if activated.
+			// "ir", "irOptimized" can only be matched by "*" if activated.
 			if (experimental.count(_artifact) == 0 || _wildcardMatchesExperimental)
 				return true;
 		}
@@ -215,17 +214,17 @@ bool isArtifactRequested(Json::Value const& _outputSelection, string const& _art
 ///
 /// @TODO optimise this. Perhaps flatten the structure upfront.
 ///
-bool isArtifactRequested(Json::Value const& _outputSelection, string const& _file, string const& _contract, string const& _artifact, bool _wildcardMatchesExperimental)
+bool isArtifactRequested(Json::Value const& _outputSelection, std::string const& _file, std::string const& _contract, std::string const& _artifact, bool _wildcardMatchesExperimental)
 {
 	if (!_outputSelection.isObject())
 		return false;
 
-	for (auto const& file: { _file, string("*") })
+	for (auto const& file: { _file, std::string("*") })
 		if (_outputSelection.isMember(file) && _outputSelection[file].isObject())
 		{
 			/// For SourceUnit-level targets (such as AST) only allow empty name, otherwise
 			/// for Contract-level targets try both contract name and wildcard
-			vector<string> contracts{ _contract };
+			std::vector<std::string> contracts{ _contract };
 			if (!_contract.empty())
 				contracts.emplace_back("*");
 			for (auto const& contract: contracts)
@@ -240,19 +239,11 @@ bool isArtifactRequested(Json::Value const& _outputSelection, string const& _fil
 	return false;
 }
 
-bool isArtifactRequested(Json::Value const& _outputSelection, string const& _file, string const& _contract, vector<string> const& _artifacts, bool _wildcardMatchesExperimental)
-{
-	for (auto const& artifact: _artifacts)
-		if (isArtifactRequested(_outputSelection, _file, _contract, artifact, _wildcardMatchesExperimental))
-			return true;
-	return false;
-}
-
 /// @returns all artifact names of the EVM object, either for creation or deploy time.
-vector<string> evmObjectComponents(string const& _objectKind)
+std::vector<std::string> evmObjectComponents(std::string const& _objectKind)
 {
 	solAssert(_objectKind == "bytecode" || _objectKind == "deployedBytecode", "");
-	vector<string> components{"", ".object", ".opcodes", ".sourceMap", ".functionDebugData", ".generatedSources", ".linkReferences"};
+	std::vector<std::string> components{"", ".object", ".opcodes", ".sourceMap", ".functionDebugData", ".generatedSources", ".linkReferences"};
 	if (_objectKind == "deployedBytecode")
 		components.push_back(".immutableReferences");
 	return util::applyMap(components, [&](auto const& _s) { return "evm." + _objectKind + _s; });
@@ -265,11 +256,12 @@ bool isBinaryRequested(Json::Value const& _outputSelection)
 		return false;
 
 	// This does not include "evm.methodIdentifiers" on purpose!
-	static vector<string> const outputsThatRequireBinaries = vector<string>{
+	static std::vector<std::string> const outputsThatRequireBinaries = std::vector<std::string>{
 		"*",
-		"ir", "irOptimized",
-		"assembly"
-	};
+		"assembly",
+		"ir", "irAst", "irOptimized", "irOptimizedAst",
+		"evm.gasEstimates", "evm.legacyAssembly", "evm.assembly"
+	} + evmObjectComponents("bytecode") + evmObjectComponents("deployedBytecode");
 
 	for (auto const& fileRequests: _outputSelection)
 		for (auto const& requests: fileRequests)
@@ -285,7 +277,7 @@ bool isEvmBytecodeRequested(Json::Value const& _outputSelection)
 	if (!_outputSelection.isObject())
 		return false;
 
-	static vector<string> const outputsThatRequireEvmBinaries = vector<string>{
+	static std::vector<std::string> const outputsThatRequireEvmBinaries = std::vector<std::string>{
 		"*",
 		"evm.gasEstimates", "evm.legacyAssembly", "evm.assembly"
 	} + evmObjectComponents("bytecode") + evmObjectComponents("deployedBytecode");
@@ -298,93 +290,79 @@ bool isEvmBytecodeRequested(Json::Value const& _outputSelection)
 	return false;
 }
 
-/// @returns true if any Ewasm code was requested. Note that as an exception, '*' does not
-/// yet match "ewasm.wast" or "ewasm"
-bool isEwasmRequested(Json::Value const& _outputSelection)
-{
-	if (!_outputSelection.isObject())
-		return false;
-
-	for (auto const& fileRequests: _outputSelection)
-		for (auto const& requests: fileRequests)
-			for (auto const& request: requests)
-				if (request == "ewasm" || request == "ewasm.wast")
-					return true;
-
-	return false;
-}
-
 /// @returns true if any Yul IR was requested. Note that as an exception, '*' does not
-/// yet match "ir" or "irOptimized"
+/// yet match "ir", "irAst", "irOptimized" or "irOptimizedAst"
 bool isIRRequested(Json::Value const& _outputSelection)
 {
-	if (isEwasmRequested(_outputSelection))
-		return true;
-
 	if (!_outputSelection.isObject())
 		return false;
 
 	for (auto const& fileRequests: _outputSelection)
 		for (auto const& requests: fileRequests)
 			for (auto const& request: requests)
-				if (request == "ir" || request == "irOptimized")
+				if (
+					request == "ir" ||
+					request == "irAst" ||
+					request == "irOptimized" ||
+					request == "irOptimizedAst"
+				)
 					return true;
 
 	return false;
 }
 
-std::optional<Json::Value> checkKeys(Json::Value const& _input, set<string> const& _keys, string const& _name)
+std::optional<Json::Value> checkKeys(Json::Value const& _input, std::set<std::string> const& _keys, std::string const& _name)
 {
 	if (!!_input && !_input.isObject())
-		return formatFatalError("JSONError", "\"" + _name + "\" must be an object");
+		return formatFatalError(Error::Type::JSONError, "\"" + _name + "\" must be an object");
 
 	for (auto const& member: _input.getMemberNames())
 		if (!_keys.count(member))
-			return formatFatalError("JSONError", "Unknown key \"" + member + "\"");
+			return formatFatalError(Error::Type::JSONError, "Unknown key \"" + member + "\"");
 
 	return std::nullopt;
 }
 
 std::optional<Json::Value> checkRootKeys(Json::Value const& _input)
 {
-	static set<string> keys{"auxiliaryInput", "language", "settings", "sources"};
+	static std::set<std::string> keys{"auxiliaryInput", "language", "settings", "sources"};
 	return checkKeys(_input, keys, "root");
 }
 
-std::optional<Json::Value> checkSourceKeys(Json::Value const& _input, string const& _name)
+std::optional<Json::Value> checkSourceKeys(Json::Value const& _input, std::string const& _name)
 {
-	static set<string> keys{"content", "keccak256", "urls"};
+	static std::set<std::string> keys{"content", "keccak256", "urls"};
 	return checkKeys(_input, keys, "sources." + _name);
 }
 
 std::optional<Json::Value> checkAuxiliaryInputKeys(Json::Value const& _input)
 {
-	static set<string> keys{"smtlib2responses"};
+	static std::set<std::string> keys{"smtlib2responses"};
 	return checkKeys(_input, keys, "auxiliaryInput");
 }
 
 std::optional<Json::Value> checkSettingsKeys(Json::Value const& _input)
 {
-	static set<string> keys{"parserErrorRecovery", "debug", "evmVersion", "libraries", "metadata", "optimizer", "outputSelection", "remappings",
-		"includePaths", "mainContract", "tvmVersion"};
+	static std::set<std::string> keys{"debug", "evmVersion", "libraries", "metadata", "modelChecker", "optimizer", "outputSelection", "remappings", "stopAfter", "viaIR",
+									  "includePaths", "mainContract", "tvmVersion"};
 	return checkKeys(_input, keys, "settings");
 }
 
 std::optional<Json::Value> checkModelCheckerSettingsKeys(Json::Value const& _input)
 {
-	static set<string> keys{"contracts", "divModNoSlacks", "engine", "invariants", "showUnproved", "solvers", "targets", "timeout"};
+	static std::set<std::string> keys{"bmcLoopIterations", "contracts", "divModNoSlacks", "engine", "extCalls", "invariants", "printQuery", "showProvedSafe", "showUnproved", "showUnsupported", "solvers", "targets", "timeout"};
 	return checkKeys(_input, keys, "modelChecker");
 }
 
 std::optional<Json::Value> checkOptimizerKeys(Json::Value const& _input)
 {
-	static set<string> keys{"details", "enabled", "runs"};
+	static std::set<std::string> keys{"details", "enabled", "runs"};
 	return checkKeys(_input, keys, "settings.optimizer");
 }
 
 std::optional<Json::Value> checkOptimizerDetailsKeys(Json::Value const& _input)
 {
-	static set<string> keys{"peephole", "inliner", "jumpdestRemover", "orderLiterals", "deduplicate", "cse", "constantOptimizer", "yul", "yulDetails"};
+	static std::set<std::string> keys{"peephole", "inliner", "jumpdestRemover", "orderLiterals", "deduplicate", "cse", "constantOptimizer", "yul", "yulDetails", "simpleCounterForLoopUncheckedIncrement"};
 	return checkKeys(_input, keys, "settings.optimizer.details");
 }
 
@@ -393,46 +371,33 @@ std::optional<Json::Value> checkOptimizerDetail(Json::Value const& _details, std
 	if (_details.isMember(_name))
 	{
 		if (!_details[_name].isBool())
-			return formatFatalError("JSONError", "\"settings.optimizer.details." + _name + "\" must be Boolean");
+			return formatFatalError(Error::Type::JSONError, "\"settings.optimizer.details." + _name + "\" must be Boolean");
 		_setting = _details[_name].asBool();
 	}
 	return {};
 }
 
-std::optional<Json::Value> checkOptimizerDetailSteps(Json::Value const& _details, std::string const& _name, string& _setting)
-{
-	if (_details.isMember(_name))
-	{
-		if (_details[_name].isString())
-		{
-			_setting = _details[_name].asString();
-		}
-		else
-			return formatFatalError("JSONError", "\"settings.optimizer.details." + _name + "\" must be a string");
-
-	}
-	return {};
-}
-
 std::optional<Json::Value> checkMetadataKeys(Json::Value const& _input)
 {
 	if (_input.isObject())
 	{
+		if (_input.isMember("appendCBOR") && !_input["appendCBOR"].isBool())
+			return formatFatalError(Error::Type::JSONError, "\"settings.metadata.appendCBOR\" must be Boolean");
 		if (_input.isMember("useLiteralContent") && !_input["useLiteralContent"].isBool())
-			return formatFatalError("JSONError", "\"settings.metadata.useLiteralContent\" must be Boolean");
+			return formatFatalError(Error::Type::JSONError, "\"settings.metadata.useLiteralContent\" must be Boolean");
 
-		static set<string> hashes{"ipfs", "bzzr1", "none"};
+		static std::set<std::string> hashes{"ipfs", "bzzr1", "none"};
 		if (_input.isMember("bytecodeHash") && !hashes.count(_input["bytecodeHash"].asString()))
-			return formatFatalError("JSONError", "\"settings.metadata.bytecodeHash\" must be \"ipfs\", \"bzzr1\" or \"none\"");
+			return formatFatalError(Error::Type::JSONError, "\"settings.metadata.bytecodeHash\" must be \"ipfs\", \"bzzr1\" or \"none\"");
 	}
-	static set<string> keys{"useLiteralContent", "bytecodeHash"};
+	static std::set<std::string> keys{"appendCBOR", "useLiteralContent", "bytecodeHash"};
 	return checkKeys(_input, keys, "settings.metadata");
 }
 
 std::optional<Json::Value> checkOutputSelection(Json::Value const& _outputSelection)
 {
 	if (!!_outputSelection && !_outputSelection.isObject())
-		return formatFatalError("JSONError", "\"settings.outputSelection\" must be an object");
+		return formatFatalError(Error::Type::JSONError, "\"settings.outputSelection\" must be an object");
 
 	for (auto const& sourceName: _outputSelection.getMemberNames())
 	{
@@ -440,7 +405,7 @@ std::optional<Json::Value> checkOutputSelection(Json::Value const& _outputSelect
 
 		if (!sourceVal.isObject())
 			return formatFatalError(
-				"JSONError",
+				Error::Type::JSONError,
 				"\"settings.outputSelection." + sourceName + "\" must be an object"
 			);
 
@@ -450,7 +415,7 @@ std::optional<Json::Value> checkOutputSelection(Json::Value const& _outputSelect
 
 			if (!contractVal.isArray())
 				return formatFatalError(
-					"JSONError",
+					Error::Type::JSONError,
 					"\"settings.outputSelection." +
 					sourceName +
 					"." +
@@ -461,7 +426,7 @@ std::optional<Json::Value> checkOutputSelection(Json::Value const& _outputSelect
 			for (auto const& output: contractVal)
 				if (!output.isString())
 					return formatFatalError(
-						"JSONError",
+						Error::Type::JSONError,
 						"\"settings.outputSelection." +
 						sourceName +
 						"." +
@@ -486,7 +451,7 @@ std::variant<OptimiserSettings, Json::Value> parseOptimizerSettings(Json::Value
 	if (_jsonInput.isMember("enabled"))
 	{
 		if (!_jsonInput["enabled"].isBool())
-			return formatFatalError("JSONError", "The \"enabled\" setting must be a Boolean.");
+			return formatFatalError(Error::Type::JSONError, "The \"enabled\" setting must be a Boolean.");
 
 		if (_jsonInput["enabled"].asBool())
 			settings = OptimiserSettings::standard();
@@ -495,7 +460,7 @@ std::variant<OptimiserSettings, Json::Value> parseOptimizerSettings(Json::Value
 	if (_jsonInput.isMember("runs"))
 	{
 		if (!_jsonInput["runs"].isUInt())
-			return formatFatalError("JSONError", "The \"runs\" setting must be an unsigned number.");
+			return formatFatalError(Error::Type::JSONError, "The \"runs\" setting must be an unsigned number.");
 		settings.expectedExecutionsPerDeployment = _jsonInput["runs"].asUInt();
 	}
 
@@ -521,32 +486,35 @@ std::variant<OptimiserSettings, Json::Value> parseOptimizerSettings(Json::Value
 			return *error;
 		if (auto error = checkOptimizerDetail(details, "yul", settings.runYulOptimiser))
 			return *error;
+		if (auto error = checkOptimizerDetail(details, "simpleCounterForLoopUncheckedIncrement", settings.simpleCounterForLoopUncheckedIncrement))
+			return *error;
 		settings.optimizeStackAllocation = settings.runYulOptimiser;
 		if (details.isMember("yulDetails"))
 		{
 			if (!settings.runYulOptimiser)
-				return formatFatalError("JSONError", "\"Providing yulDetails requires Yul optimizer to be enabled.");
+			{
+				if (checkKeys(details["yulDetails"], {"optimizerSteps"}, "settings.optimizer.details.yulDetails"))
+					return formatFatalError(Error::Type::JSONError, "Only optimizerSteps can be set in yulDetails when Yul optimizer is disabled.");
+				return {std::move(settings)};
+			}
 
 			if (auto result = checkKeys(details["yulDetails"], {"stackAllocation", "optimizerSteps"}, "settings.optimizer.details.yulDetails"))
 				return *result;
 			if (auto error = checkOptimizerDetail(details["yulDetails"], "stackAllocation", settings.optimizeStackAllocation))
 				return *error;
-			if (auto error = checkOptimizerDetailSteps(details["yulDetails"], "optimizerSteps", settings.yulOptimiserSteps))
-				return *error;
 		}
 	}
-	return { std::move(settings) };
+	return {std::move(settings)};
 }
 
 }
 
-
 std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler::parseInput(Json::Value const& _input)
 {
 	InputsAndSettings ret;
 
 	if (!_input.isObject())
-		return formatFatalError("JSONError", "Input is not a JSON object.");
+		return formatFatalError(Error::Type::JSONError, "Input is not a JSON object.");
 
 	if (auto result = checkRootKeys(_input))
 		return *result;
@@ -556,84 +524,115 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	Json::Value const& sources = _input["sources"];
 
 	if (!sources.isObject() && !sources.isNull())
-		return formatFatalError("JSONError", "\"sources\" is not a JSON object.");
+		return formatFatalError(Error::Type::JSONError, "\"sources\" is not a JSON object.");
 
 	if (sources.empty())
-		return formatFatalError("JSONError", "No input sources specified.");
+		return formatFatalError(Error::Type::JSONError, "No input sources specified.");
 
 	ret.errors = Json::arrayValue;
 
-	for (auto const& sourceName: sources.getMemberNames())
+	if (ret.language == "Solidity" || ret.language == "Yul")
 	{
-		string hash;
+		for (auto const& sourceName: sources.getMemberNames())
+		{
+			std::string hash;
 
-		if (auto result = checkSourceKeys(sources[sourceName], sourceName))
-			return *result;
+			if (auto result = checkSourceKeys(sources[sourceName], sourceName))
+				return *result;
 
-		if (sources[sourceName]["keccak256"].isString())
-			hash = sources[sourceName]["keccak256"].asString();
+			if (sources[sourceName]["keccak256"].isString())
+				hash = sources[sourceName]["keccak256"].asString();
 
-		if (sources[sourceName]["content"].isString())
-		{
-			string content = sources[sourceName]["content"].asString();
-			if (!hash.empty() && !hashMatchesContent(hash, content))
-				ret.errors.append(formatError(
-					Error::Severity::Error,
-					"IOError",
-					"general",
-					"Mismatch between content and supplied hash for \"" + sourceName + "\""
-				));
-			else
-				ret.sources[sourceName] = content;
-		}
-		else if (sources[sourceName]["urls"].isArray())
-		{
-			if (!m_readFile)
-				return formatFatalError("JSONError", "No import callback supplied, but URL is requested.");
+			if (sources[sourceName]["content"].isString())
+			{
+				std::string content = sources[sourceName]["content"].asString();
+				if (!hash.empty() && !hashMatchesContent(hash, content))
+					ret.errors.append(formatError(
+						Error::Type::IOError,
+						"general",
+						"Mismatch between content and supplied hash for \"" + sourceName + "\""
+					));
+				else
+					ret.sources[sourceName] = content;
+			}
+			else if (sources[sourceName]["urls"].isArray())
+			{
+				if (!m_readFile)
+					return formatFatalError(
+						Error::Type::JSONError, "No import callback supplied, but URL is requested."
+					);
 
-			bool found = false;
-			vector<string> failures;
+				std::vector<std::string> failures;
+				bool found = false;
 
-			for (auto const& url: sources[sourceName]["urls"])
-			{
-				if (!url.isString())
-					return formatFatalError("JSONError", "URL must be a string.");
-				ReadCallback::Result result = m_readFile(ReadCallback::kindString(ReadCallback::Kind::ReadFile), url.asString());
-				if (result.success)
+				for (auto const& url: sources[sourceName]["urls"])
 				{
-					if (!hash.empty() && !hashMatchesContent(hash, result.responseOrErrorMessage))
-						ret.errors.append(formatError(
-							Error::Severity::Error,
-							"IOError",
-							"general",
-							"Mismatch between content and supplied hash for \"" + sourceName + "\" at \"" + url.asString() + "\""
-						));
-					else
+					if (!url.isString())
+						return formatFatalError(Error::Type::JSONError, "URL must be a string.");
+					ReadCallback::Result result = m_readFile(ReadCallback::kindString(ReadCallback::Kind::ReadFile), url.asString());
+					if (result.success)
 					{
-						ret.sources[sourceName] = result.responseOrErrorMessage;
-						found = true;
-						break;
+						if (!hash.empty() && !hashMatchesContent(hash, result.responseOrErrorMessage))
+							ret.errors.append(formatError(
+								Error::Type::IOError,
+								"general",
+								"Mismatch between content and supplied hash for \"" + sourceName + "\" at \"" + url.asString() + "\""
+							));
+						else
+						{
+							ret.sources[sourceName] = result.responseOrErrorMessage;
+							found = true;
+							break;
+						}
 					}
+					else
+						failures.push_back(
+							"Cannot import url (\"" + url.asString() + "\"): " + result.responseOrErrorMessage
+						);
 				}
-				else
-					failures.push_back("Cannot import url (\"" + url.asString() + "\"): " + result.responseOrErrorMessage);
-			}
 
-			for (auto const& failure: failures)
-			{
-				/// If the import succeeded, let mark all the others as warnings, otherwise all of them are errors.
-				ret.errors.append(formatError(
-					found ? Error::Severity::Warning : Error::Severity::Error,
-					"IOError",
-					"general",
-					failure
-				));
+				for (auto const& failure: failures)
+				{
+					/// If the import succeeded, let mark all the others as warnings, otherwise all of them are errors.
+					ret.errors.append(formatError(
+						found ? Error::Type::Warning : Error::Type::IOError,
+						"general",
+						failure
+					));
+				}
 			}
+			else
+				return formatFatalError(Error::Type::JSONError, "Invalid input source specified.");
 		}
-		else
-			return formatFatalError("JSONError", "Invalid input source specified.");
 	}
+	else if (ret.language == "SolidityAST")
+	{
+		for (auto const& sourceName: sources.getMemberNames())
+			ret.sources[sourceName] = util::jsonCompactPrint(sources[sourceName]);
+	}
+	else if (ret.language == "EVMAssembly")
+	{
+		for (std::string const& sourceName: sources.getMemberNames())
+		{
+			solAssert(sources.isMember(sourceName));
+			if (
+				!sources[sourceName].isMember("assemblyJson") ||
+				!sources[sourceName]["assemblyJson"].isObject() ||
+				sources[sourceName].size() != 1
+			)
+				return formatFatalError(
+					Error::Type::JSONError,
+					"Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources." + sourceName
+				);
 
+			ret.jsonSources[sourceName] = sources[sourceName]["assemblyJson"];
+		}
+		if (ret.jsonSources.size() != 1)
+			return formatFatalError(
+				Error::Type::JSONError,
+				"EVMAssembly import only supports exactly one input file."
+			);
+	}
 	Json::Value const& auxInputs = _input["auxiliaryInput"];
 
 	if (auto result = checkAuxiliaryInputKeys(auxInputs))
@@ -645,7 +644,7 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 		if (!!smtlib2Responses)
 		{
 			if (!smtlib2Responses.isObject())
-				return formatFatalError("JSONError", "\"auxiliaryInput.smtlib2responses\" must be an object.");
+				return formatFatalError(Error::Type::JSONError, "\"auxiliaryInput.smtlib2responses\" must be an object.");
 
 			for (auto const& hashString: smtlib2Responses.getMemberNames())
 			{
@@ -656,12 +655,12 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 				}
 				catch (util::BadHexCharacter const&)
 				{
-					return formatFatalError("JSONError", "Invalid hex encoding of SMTLib2 auxiliary input.");
+					return formatFatalError(Error::Type::JSONError, "Invalid hex encoding of SMTLib2 auxiliary input.");
 				}
 
 				if (!smtlib2Responses[hashString].isString())
 					return formatFatalError(
-						"JSONError",
+						Error::Type::JSONError,
 						"\"smtlib2Responses." + hashString + "\" must be a string."
 					);
 
@@ -680,7 +679,7 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 		for (auto const& includePath: settings["includePaths"])
 		{
 			if (!includePath.isString())
-				return formatFatalError("JSONError", "Include path must be a string.");
+				return formatFatalError(Error::Type::JSONError, "Include path must be a string.");
 			ret.includePaths.push_back(includePath.asString());
 		}
 	}
@@ -688,52 +687,51 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	if (settings.isMember("mainContract"))
 	{
 		if (!settings["mainContract"].isString())
-			return formatFatalError("JSONError", "\"settings.mainContract\" must be a String.");
+			return formatFatalError(Error::Type::JSONError, "\"settings.mainContract\" must be a String.");
 		ret.mainContract = settings["mainContract"].asString();
 	}
 
 	if (settings.isMember("stopAfter"))
 	{
 		if (!settings["stopAfter"].isString())
-			return formatFatalError("JSONError", "\"settings.stopAfter\" must be a string.");
+			return formatFatalError(Error::Type::JSONError, "\"settings.stopAfter\" must be a string.");
 
 		if (settings["stopAfter"].asString() != "parsing")
-			return formatFatalError("JSONError", "Invalid value for \"settings.stopAfter\". Only valid value is \"parsing\".");
+			return formatFatalError(Error::Type::JSONError, "Invalid value for \"settings.stopAfter\". Only valid value is \"parsing\".");
 
 		ret.stopAfter = CompilerStack::State::Parsed;
 	}
 
-	if (settings.isMember("parserErrorRecovery"))
-	{
-		if (!settings["parserErrorRecovery"].isBool())
-			return formatFatalError("JSONError", "\"settings.parserErrorRecovery\" must be a Boolean.");
-		ret.parserErrorRecovery = settings["parserErrorRecovery"].asBool();
-	}
-
 	if (settings.isMember("viaIR"))
 	{
 		if (!settings["viaIR"].isBool())
-			return formatFatalError("JSONError", "\"settings.viaIR\" must be a Boolean.");
+			return formatFatalError(Error::Type::JSONError, "\"settings.viaIR\" must be a Boolean.");
 		ret.viaIR = settings["viaIR"].asBool();
 	}
 
 	if (settings.isMember("evmVersion"))
 	{
 		if (!settings["evmVersion"].isString())
-			return formatFatalError("JSONError", "evmVersion must be a string.");
+			return formatFatalError(Error::Type::JSONError, "evmVersion must be a string.");
 		std::optional<langutil::EVMVersion> version = langutil::EVMVersion::fromString(settings["evmVersion"].asString());
 		if (!version)
-			return formatFatalError("JSONError", "Invalid EVM version requested.");
+			return formatFatalError(Error::Type::JSONError, "Invalid EVM version requested.");
+		if (version < EVMVersion::constantinople())
+			ret.errors.append(formatError(
+				Error::Type::Warning,
+				"general",
+				"Support for EVM versions older than constantinople is deprecated and will be removed in the future."
+			));
 		ret.evmVersion = *version;
 	}
 
 	if (settings.isMember("tvmVersion"))
 	{
 		if (!settings["tvmVersion"].isString())
-			return formatFatalError("JSONError", "tvmVersion must be a string.");
+			return formatFatalError(Error::Type::JSONError, "tvmVersion must be a string.");
 		std::optional<langutil::TVMVersion> version = langutil::TVMVersion::fromString(settings["tvmVersion"].asString());
 		if (!version)
-			return formatFatalError("JSONError", "Invalid TVM version requested.");
+			return formatFatalError(Error::Type::JSONError, "Invalid TVM version requested.");
 		ret.tvmVersion = *version;
 	}
 
@@ -745,13 +743,13 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 		if (settings["debug"].isMember("revertStrings"))
 		{
 			if (!settings["debug"]["revertStrings"].isString())
-				return formatFatalError("JSONError", "settings.debug.revertStrings must be a string.");
+				return formatFatalError(Error::Type::JSONError, "settings.debug.revertStrings must be a string.");
 			std::optional<RevertStrings> revertStrings = revertStringsFromString(settings["debug"]["revertStrings"].asString());
 			if (!revertStrings)
-				return formatFatalError("JSONError", "Invalid value for settings.debug.revertStrings.");
+				return formatFatalError(Error::Type::JSONError, "Invalid value for settings.debug.revertStrings.");
 			if (*revertStrings == RevertStrings::VerboseDebug)
 				return formatFatalError(
-					"UnimplementedFeatureError",
+					Error::Type::UnimplementedFeatureError,
 					"Only \"default\", \"strip\" and \"debug\" are implemented for settings.debug.revertStrings for now."
 				);
 			ret.revertStrings = *revertStrings;
@@ -760,22 +758,22 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 		if (settings["debug"].isMember("debugInfo"))
 		{
 			if (!settings["debug"]["debugInfo"].isArray())
-				return formatFatalError("JSONError", "settings.debug.debugInfo must be an array.");
+				return formatFatalError(Error::Type::JSONError, "settings.debug.debugInfo must be an array.");
 
-			vector<string> components;
+			std::vector<std::string> components;
 			for (Json::Value const& arrayValue: settings["debug"]["debugInfo"])
 				components.push_back(arrayValue.asString());
 
-			optional<DebugInfoSelection> debugInfoSelection = DebugInfoSelection::fromComponents(
+			std::optional<DebugInfoSelection> debugInfoSelection = DebugInfoSelection::fromComponents(
 				components,
 				true /* _acceptWildcards */
 			);
 			if (!debugInfoSelection.has_value())
-				return formatFatalError("JSONError", "Invalid value in settings.debug.debugInfo.");
+				return formatFatalError(Error::Type::JSONError, "Invalid value in settings.debug.debugInfo.");
 
 			if (debugInfoSelection->snippet && !debugInfoSelection->location)
 				return formatFatalError(
-					"JSONError",
+					Error::Type::JSONError,
 					"To use 'snippet' with settings.debug.debugInfo you must select also 'location'."
 				);
 
@@ -784,16 +782,16 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	}
 
 	if (settings.isMember("remappings") && !settings["remappings"].isArray())
-		return formatFatalError("JSONError", "\"settings.remappings\" must be an array of strings.");
+		return formatFatalError(Error::Type::JSONError, "\"settings.remappings\" must be an array of strings.");
 
 	for (auto const& remapping: settings.get("remappings", Json::Value()))
 	{
 		if (!remapping.isString())
-			return formatFatalError("JSONError", "\"settings.remappings\" must be an array of strings");
+			return formatFatalError(Error::Type::JSONError, "\"settings.remappings\" must be an array of strings");
 		if (auto r = ImportRemapper::parseRemapping(remapping.asString()))
 			ret.remappings.emplace_back(std::move(*r));
 		else
-			return formatFatalError("JSONError", "Invalid remapping: \"" + remapping.asString() + "\"");
+			return formatFatalError(Error::Type::JSONError, "Invalid remapping: \"" + remapping.asString() + "\"");
 	}
 
 	if (settings.isMember("optimizer"))
@@ -807,27 +805,27 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 
 	Json::Value jsonLibraries = settings.get("libraries", Json::Value(Json::objectValue));
 	if (!jsonLibraries.isObject())
-		return formatFatalError("JSONError", "\"libraries\" is not a JSON object.");
+		return formatFatalError(Error::Type::JSONError, "\"libraries\" is not a JSON object.");
 	for (auto const& sourceName: jsonLibraries.getMemberNames())
 	{
 		auto const& jsonSourceName = jsonLibraries[sourceName];
 		if (!jsonSourceName.isObject())
-			return formatFatalError("JSONError", "Library entry is not a JSON object.");
+			return formatFatalError(Error::Type::JSONError, "Library entry is not a JSON object.");
 		for (auto const& library: jsonSourceName.getMemberNames())
 		{
 			if (!jsonSourceName[library].isString())
-				return formatFatalError("JSONError", "Library address must be a string.");
-			string address = jsonSourceName[library].asString();
+				return formatFatalError(Error::Type::JSONError, "Library address must be a string.");
+			std::string address = jsonSourceName[library].asString();
 
 			if (!boost::starts_with(address, "0x"))
 				return formatFatalError(
-					"JSONError",
+					Error::Type::JSONError,
 					"Library address is not prefixed with \"0x\"."
 				);
 
 			if (address.length() != 42)
 				return formatFatalError(
-					"JSONError",
+					Error::Type::JSONError,
 					"Library address is of invalid length."
 				);
 
@@ -838,7 +836,7 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 			catch (util::BadHexCharacter const&)
 			{
 				return formatFatalError(
-					"JSONError",
+					Error::Type::JSONError,
 					"Invalid library address (\"" + address + "\") supplied."
 				);
 			}
@@ -850,6 +848,12 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	if (auto result = checkMetadataKeys(metadataSettings))
 		return *result;
 
+	solAssert(CompilerStack::defaultMetadataFormat() != CompilerStack::MetadataFormat::NoMetadata, "");
+	ret.metadataFormat =
+		metadataSettings.get("appendCBOR", Json::Value(true)).asBool() ?
+		CompilerStack::defaultMetadataFormat() :
+		CompilerStack::MetadataFormat::NoMetadata;
+
 	ret.metadataLiteralSources = metadataSettings.get("useLiteralContent", Json::Value(false)).asBool();
 	if (metadataSettings.isMember("bytecodeHash"))
 	{
@@ -860,6 +864,13 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 				metadataHash == "bzzr1" ?
 				CompilerStack::MetadataHash::Bzzr1 :
 				CompilerStack::MetadataHash::None;
+		if (ret.metadataFormat == CompilerStack::MetadataFormat::NoMetadata && ret.metadataHash != CompilerStack::MetadataHash::None)
+			return formatFatalError(
+				Error::Type::JSONError,
+				"When the parameter \"appendCBOR\" is set to false, the parameter \"bytecodeHash\" cannot be set to \"" +
+				metadataHash +
+				"\". The parameter \"bytecodeHash\" should either be skipped, or set to \"none\"."
+			);
 	}
 
 	Json::Value outputSelection = settings.get("outputSelection", Json::Value());
@@ -871,7 +882,7 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 
 	if (ret.stopAfter != CompilerStack::State::CompilationSuccessful && isBinaryRequested(ret.outputSelection))
 		return formatFatalError(
-			"JSONError",
+			Error::Type::JSONError,
 			"Requested output selection conflicts with \"settings.stopAfter\"."
 		);
 
@@ -884,29 +895,29 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	{
 		auto const& sources = modelCheckerSettings["contracts"];
 		if (!sources.isObject() && !sources.isNull())
-			return formatFatalError("JSONError", "settings.modelChecker.contracts is not a JSON object.");
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.contracts is not a JSON object.");
 
-		map<string, set<string>> sourceContracts;
+		std::map<std::string, std::set<std::string>> sourceContracts;
 		for (auto const& source: sources.getMemberNames())
 		{
 			if (source.empty())
-				return formatFatalError("JSONError", "Source name cannot be empty.");
+				return formatFatalError(Error::Type::JSONError, "Source name cannot be empty.");
 
 			auto const& contracts = sources[source];
 			if (!contracts.isArray())
-				return formatFatalError("JSONError", "Source contracts must be an array.");
+				return formatFatalError(Error::Type::JSONError, "Source contracts must be an array.");
 
 			for (auto const& contract: contracts)
 			{
 				if (!contract.isString())
-					return formatFatalError("JSONError", "Every contract in settings.modelChecker.contracts must be a string.");
+					return formatFatalError(Error::Type::JSONError, "Every contract in settings.modelChecker.contracts must be a string.");
 				if (contract.asString().empty())
-					return formatFatalError("JSONError", "Contract name cannot be empty.");
+					return formatFatalError(Error::Type::JSONError, "Contract name cannot be empty.");
 				sourceContracts[source].insert(contract.asString());
 			}
 
 			if (sourceContracts[source].empty())
-				return formatFatalError("JSONError", "Source contracts must be a non-empty array.");
+				return formatFatalError(Error::Type::JSONError, "Source contracts must be a non-empty array.");
 		}
 	}
 
@@ -914,134 +925,144 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
 	{
 		auto const& divModNoSlacks = modelCheckerSettings["divModNoSlacks"];
 		if (!divModNoSlacks.isBool())
-			return formatFatalError("JSONError", "settings.modelChecker.divModNoSlacks must be a Boolean.");
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.divModNoSlacks must be a Boolean.");
 	}
 
 	if (modelCheckerSettings.isMember("engine"))
 	{
 		if (!modelCheckerSettings["engine"].isString())
-			return formatFatalError("JSONError", "settings.modelChecker.engine must be a string.");
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.engine must be a string.");
 	}
 
-	if (modelCheckerSettings.isMember("invariants"))
+	if (modelCheckerSettings.isMember("showProvedSafe"))
 	{
-		auto const& invariantsArray = modelCheckerSettings["invariants"];
-		if (!invariantsArray.isArray())
-			return formatFatalError("JSONError", "settings.modelChecker.invariants must be an array.");
-
-		for (auto const& i: invariantsArray)
-		{
-			if (!i.isString())
-				return formatFatalError("JSONError", "Every invariant type in settings.modelChecker.invariants must be a string.");
-		}
-
-
+		auto const& showProvedSafe = modelCheckerSettings["showProvedSafe"];
+		if (!showProvedSafe.isBool())
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.showProvedSafe must be a Boolean value.");
 	}
 
 	if (modelCheckerSettings.isMember("showUnproved"))
 	{
 		auto const& showUnproved = modelCheckerSettings["showUnproved"];
 		if (!showUnproved.isBool())
-			return formatFatalError("JSONError", "settings.modelChecker.showUnproved must be a Boolean value.");
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.showUnproved must be a Boolean value.");
+	}
+
+	if (modelCheckerSettings.isMember("showUnsupported"))
+	{
+		auto const& showUnsupported = modelCheckerSettings["showUnsupported"];
+		if (!showUnsupported.isBool())
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.showUnsupported must be a Boolean value.");
 	}
 
 	if (modelCheckerSettings.isMember("solvers"))
 	{
 		auto const& solversArray = modelCheckerSettings["solvers"];
 		if (!solversArray.isArray())
-			return formatFatalError("JSONError", "settings.modelChecker.solvers must be an array.");
+			return formatFatalError(Error::Type::JSONError, "settings.modelChecker.solvers must be an array.");
 
 		smtutil::SMTSolverChoice solvers;
 		for (auto const& s: solversArray)
 		{
 			if (!s.isString())
-				return formatFatalError("JSONError", "Every target in settings.modelChecker.solvers must be a string.");
+				return formatFatalError(Error::Type::JSONError, "Every target in settings.modelChecker.solvers must be a string.");
 			if (!solvers.setSolver(s.asString()))
-				return formatFatalError("JSONError", "Invalid model checker solvers requested.");
+				return formatFatalError(Error::Type::JSONError, "Invalid model checker solvers requested.");
 		}
 
 	}
 
-	if (modelCheckerSettings.isMember("targets"))
-	{
-		auto const& targetsArray = modelCheckerSettings["targets"];
-		if (!targetsArray.isArray())
-			return formatFatalError("JSONError", "settings.modelChecker.targets must be an array.");
-
-		for (auto const& t: targetsArray)
-		{
-			if (!t.isString())
-				return formatFatalError("JSONError", "Every target in settings.modelChecker.targets must be a string.");
-		}
-	}
+	return {std::move(ret)};
+}
 
-	if (modelCheckerSettings.isMember("timeout"))
+std::map<std::string, Json::Value> StandardCompiler::parseAstFromInput(StringMap const& _sources)
+{
+	std::map<std::string, Json::Value> sourceJsons;
+	for (auto const& [sourceName, sourceCode]: _sources)
 	{
-		if (!modelCheckerSettings["timeout"].isUInt())
-			return formatFatalError("JSONError", "settings.modelChecker.timeout must be an unsigned integer.");
+		Json::Value ast;
+		astAssert(util::jsonParseStrict(sourceCode, ast), "Input file could not be parsed to JSON");
+		std::string astKey = ast.isMember("ast") ? "ast" : "AST";
+
+		astAssert(ast.isMember(astKey), "astkey is not member");
+		astAssert(ast[astKey]["nodeType"].asString() == "SourceUnit", "Top-level node should be a 'SourceUnit'");
+		astAssert(sourceJsons.count(sourceName) == 0, "All sources must have unique names");
+		sourceJsons.emplace(sourceName, std::move(ast[astKey]));
 	}
-
-	return { std::move(ret) };
+	return sourceJsons;
 }
 
 Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSettings _inputsAndSettings)
 {
+	solAssert(_inputsAndSettings.jsonSources.empty());
+
 	CompilerStack compilerStack(m_readFile);
 
 	StringMap sourceList = std::move(_inputsAndSettings.sources);
 	compilerStack.setSources(sourceList);
-	// TODO: do we need EVMVersion and other stuff?
+	// TODO DELETE: do we need EVMVersion and other stuff?
+	compilerStack.setEVMVersion(_inputsAndSettings.evmVersion);
+	compilerStack.setViaIR(_inputsAndSettings.viaIR);
 	compilerStack.setEVMVersion(_inputsAndSettings.evmVersion);
-	compilerStack.setTVMVersion(_inputsAndSettings.tvmVersion);
-	compilerStack.setParserErrorRecovery(_inputsAndSettings.parserErrorRecovery);
 	compilerStack.setRemappings(std::move(_inputsAndSettings.remappings));
 	compilerStack.setOptimiserSettings(std::move(_inputsAndSettings.optimiserSettings));
 	compilerStack.setRevertStringBehaviour(_inputsAndSettings.revertStrings);
 	compilerStack.setLibraries(_inputsAndSettings.libraries);
 	compilerStack.useMetadataLiteralSources(_inputsAndSettings.metadataLiteralSources);
+	compilerStack.setMetadataFormat(_inputsAndSettings.metadataFormat);
 	compilerStack.setMetadataHash(_inputsAndSettings.metadataHash);
 	compilerStack.setRequestedContractNames(requestedContractNames(_inputsAndSettings.outputSelection));
 
 	compilerStack.enableEvmBytecodeGeneration(isEvmBytecodeRequested(_inputsAndSettings.outputSelection));
 	compilerStack.enableIRGeneration(isIRRequested(_inputsAndSettings.outputSelection));
-	compilerStack.enableEwasmGeneration(isEwasmRequested(_inputsAndSettings.outputSelection));
 
+	Json::Value errors = std::move(_inputsAndSettings.errors);
+
+	bool const binariesRequested = isBinaryRequested(_inputsAndSettings.outputSelection);
+
+	// TVM specific settings
 	if (sourceList.size() != 1) {
-		formatFatalError("JSONError", "Only one source is allowed.");
+		formatFatalError(Error::Type::JSONError, "Only one source is allowed.");
 	}
 	compilerStack.setInputFile(sourceList.begin()->first);
-
 	compilerStack.setMainContract(_inputsAndSettings.mainContract);
-
-	Json::Value errors = std::move(_inputsAndSettings.errors);
-
-	bool const binariesRequested = isBinaryRequested(_inputsAndSettings.outputSelection);
+	compilerStack.setTVMVersion(_inputsAndSettings.tvmVersion);
+	compilerStack.generateAbi();
+	if (binariesRequested)
+		compilerStack.generateCode();
+	compilerStack.printFunctionIds();
+	compilerStack.printPrivateFunctionIds();
 
 	try
 	{
-		compilerStack.generateAbi();
-		if (binariesRequested)
+		if (_inputsAndSettings.language == "SolidityAST")
 		{
-			compilerStack.generateCode();
+			try
+			{
+				compilerStack.importASTs(parseAstFromInput(sourceList));
+				if (!compilerStack.analyze())
+					errors.append(formatError(Error::Type::FatalError, "general", "Analysis of the AST failed."));
+				if (binariesRequested)
+					compilerStack.compile();
+			}
+			catch (util::Exception const& _exc)
+			{
+				solThrow(util::Exception, "Failed to import AST: "s + _exc.what());
+			}
 		}
 		else
-			compilerStack.parseAndAnalyze(_inputsAndSettings.stopAfter);
-		// TODO DELETE ?
-		compilerStack.compile(true);
-
-		for (auto const& error: compilerStack.errors())
 		{
-			Error const& err = dynamic_cast<Error const&>(*error);
+			compilerStack.compile(true);
 
-			errors.append(formatErrorWithException(
-				compilerStack,
-				*error,
-				Error::errorSeverity(err.type()),
-				err.typeName(),
-				"general",
-				"",
-				err.errorId()
-			));
+			for (auto const& error: compilerStack.errors())
+				errors.append(formatErrorWithException(
+					compilerStack,
+					*error,
+					error->type(),
+					"general",
+					"",
+					error->errorId()
+				));
 		}
 	}
 	/// This is only thrown in a very few locations.
@@ -1050,8 +1071,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		errors.append(formatErrorWithException(
 			compilerStack,
 			_error,
-			Error::Severity::Error,
-			_error.typeName(),
+			_error.type(),
 			"general",
 			"Uncaught error: "
 		));
@@ -1060,8 +1080,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 	catch (FatalError const& _exception)
 	{
 		errors.append(formatError(
-			Error::Severity::Error,
-			"FatalError",
+			Error::Type::FatalError,
 			"general",
 			"Uncaught fatal error: " + boost::diagnostic_information(_exception)
 		));
@@ -1071,8 +1090,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		errors.append(formatErrorWithException(
 			compilerStack,
 			_exception,
-			Error::Severity::Error,
-			"CompilerError",
+			Error::Type::CompilerError,
 			"general",
 			"Compiler error (" + _exception.lineInfo() + ")"
 		));
@@ -1082,8 +1100,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		errors.append(formatErrorWithException(
 			compilerStack,
 			_exception,
-			Error::Severity::Error,
-			"InternalCompilerError",
+			Error::Type::InternalCompilerError,
 			"general",
 			"Internal compiler error (" + _exception.lineInfo() + ")"
 		));
@@ -1093,8 +1110,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		errors.append(formatErrorWithException(
 			compilerStack,
 			_exception,
-			Error::Severity::Error,
-			"UnimplementedFeatureError",
+			Error::Type::UnimplementedFeatureError,
 			"general",
 			"Unimplemented feature (" + _exception.lineInfo() + ")"
 		));
@@ -1102,8 +1118,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 	catch (util::Exception const& _exception)
 	{
 		errors.append(formatError(
-			Error::Severity::Error,
-			"Exception",
+			Error::Type::Exception,
 			"general",
 			"Exception during compilation: " + boost::diagnostic_information(_exception)
 		));
@@ -1111,8 +1126,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 	catch (std::exception const& _exception)
 	{
 		errors.append(formatError(
-			Error::Severity::Error,
-			"Exception",
+			Error::Type::Exception,
 			"general",
 			"Unknown exception during compilation: " + boost::diagnostic_information(_exception)
 		));
@@ -1120,25 +1134,27 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 	catch (...)
 	{
 		errors.append(formatError(
-			Error::Severity::Error,
-			"Exception",
+			Error::Type::Exception,
 			"general",
 			"Unknown exception during compilation: " + boost::current_exception_diagnostic_information()
 		));
 	}
 
-	bool analysisPerformed = compilerStack.state() >= CompilerStack::State::AnalysisPerformed;
-	bool const compilationSuccess = compilerStack.state() == CompilerStack::State::CompilationSuccessful;
+	bool parsingSuccess = compilerStack.state() >= CompilerStack::State::Parsed;
+	bool analysisSuccess = compilerStack.state() >= CompilerStack::State::AnalysisSuccessful;
+	bool compilationSuccess = compilerStack.state() == CompilerStack::State::CompilationSuccessful;
 
-	if (compilerStack.hasError() && !_inputsAndSettings.parserErrorRecovery)
-		analysisPerformed = false;
+	// If analysis fails, the artifacts inside CompilerStack are potentially incomplete and must not be returned.
+	// Note that not completing analysis due to stopAfter does not count as a failure. It's neither failure nor success.
+	bool analysisFailed = !analysisSuccess && _inputsAndSettings.stopAfter >= CompilerStack::State::AnalysisSuccessful;
+	bool compilationFailed = !compilationSuccess && binariesRequested;
 
 	/// Inconsistent state - stop here to receive error reports from users
 	if (
-		((binariesRequested && !compilationSuccess) || !analysisPerformed) &&
-		(errors.empty() && _inputsAndSettings.stopAfter >= CompilerStack::State::AnalysisPerformed)
+		(compilationFailed || analysisFailed || !parsingSuccess) &&
+		errors.empty()
 	)
-		return formatFatalError("InternalCompilerError", "No error reported, but compilation failed.");
+		return formatFatalError(Error::Type::InternalCompilerError, "No error reported, but compilation failed.");
 
 	Json::Value output = Json::objectValue;
 
@@ -1149,8 +1165,10 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 
 	output["sources"] = Json::objectValue;
 	unsigned sourceIndex = 0;
-	if (compilerStack.state() >= CompilerStack::State::Parsed && (!compilerStack.hasError() || _inputsAndSettings.parserErrorRecovery))
-		for (string const& sourceName: compilerStack.sourceNames())
+	// NOTE: A case that will pass `parsingSuccess && !analysisFailed` but not `analysisSuccess` is
+	// stopAfter: parsing with no parsing errors.
+	if (parsingSuccess && !analysisFailed)
+		for (std::string const& sourceName: compilerStack.sourceNames())
 		{
 			Json::Value sourceResult = Json::objectValue;
 			sourceResult["id"] = sourceIndex++;
@@ -1160,12 +1178,12 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		}
 
 	Json::Value contractsOutput = Json::objectValue;
-	for (string const& contractName: analysisPerformed ? compilerStack.contractNames() : vector<string>())
+	for (std::string const& contractName: analysisSuccess ? compilerStack.contractNames() : std::vector<std::string>())
 	{
 		size_t colon = contractName.rfind(':');
-		solAssert(colon != string::npos, "");
-		string file = contractName.substr(0, colon);
-		string name = contractName.substr(colon + 1);
+		solAssert(colon != std::string::npos, "");
+		std::string file = contractName.substr(0, colon);
+		std::string name = contractName.substr(colon + 1);
 
 		// ABI, storage layout, documentation and metadata
 		Json::Value contractData(Json::objectValue);
@@ -1184,41 +1202,6 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 		if (isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "devdoc", wildcardMatchesExperimental))
 			contractData["devdoc"] = compilerStack.natspecDev(contractName);
 
-		// IR
-		if (compilationSuccess && isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "ir", wildcardMatchesExperimental))
-			contractData["ir"] = compilerStack.yulIR(contractName);
-		if (compilationSuccess && isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "irOptimized", wildcardMatchesExperimental))
-			contractData["irOptimized"] = compilerStack.yulIROptimized(contractName);
-
-		// TODO: do we need EVM?
-		// EVM
-		Json::Value evmData(Json::objectValue);
-		if (compilationSuccess && isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "evm.assembly", wildcardMatchesExperimental))
-			evmData["assembly"] = compilerStack.assemblyString(contractName, sourceList);
-		if (compilationSuccess && isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "evm.legacyAssembly", wildcardMatchesExperimental))
-			evmData["legacyAssembly"] = compilerStack.assemblyJSON(contractName);
-		if (isArtifactRequested(_inputsAndSettings.outputSelection, file, name, "evm.methodIdentifiers", wildcardMatchesExperimental))
-			evmData["methodIdentifiers"] = compilerStack.interfaceSymbols(contractName)["methods"];
-
-		if (compilationSuccess && isArtifactRequested(
-			_inputsAndSettings.outputSelection,
-			file,
-			name,
-			evmObjectComponents("bytecode"),
-			wildcardMatchesExperimental
-		))
-
-		if (compilationSuccess && isArtifactRequested(
-			_inputsAndSettings.outputSelection,
-			file,
-			name,
-			evmObjectComponents("deployedBytecode"),
-			wildcardMatchesExperimental
-		))
-
-		if (!evmData.empty())
-			contractData["evm"] = evmData;
-
 		if (!contractData.empty())
 		{
 			if (!contractsOutput.isMember(file))
@@ -1232,13 +1215,6 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
 	return output;
 }
 
-// TODO DELETE
-Json::Value StandardCompiler::compileYul(InputsAndSettings /*_inputsAndSettings*/)
-{
-	return Json::objectValue;
-}
-
-
 Json::Value StandardCompiler::compile(Json::Value const& _input) noexcept
 {
 	try
@@ -1249,44 +1225,44 @@ Json::Value StandardCompiler::compile(Json::Value const& _input) noexcept
 		InputsAndSettings settings = std::get<InputsAndSettings>(std::move(parsed));
 		if (settings.language == "Solidity")
 			return compileSolidity(std::move(settings));
-		else if (settings.language == "Yul")
-			return compileYul(std::move(settings));
+		else if (settings.language == "SolidityAST")
+			return compileSolidity(std::move(settings));
 		else
-			return formatFatalError("JSONError", "Only \"Solidity\" or \"Yul\" is supported as a language.");
+			return formatFatalError(Error::Type::JSONError, "Only \"Solidity\", \"Yul\", \"SolidityAST\" or \"EVMAssembly\" is supported as a language.");
 	}
 	catch (Json::LogicError const& _exception)
 	{
-		return formatFatalError("InternalCompilerError", string("JSON logic exception: ") + _exception.what());
+		return formatFatalError(Error::Type::InternalCompilerError, std::string("JSON logic exception: ") + _exception.what());
 	}
 	catch (Json::RuntimeError const& _exception)
 	{
-		return formatFatalError("InternalCompilerError", string("JSON runtime exception: ") + _exception.what());
+		return formatFatalError(Error::Type::InternalCompilerError, std::string("JSON runtime exception: ") + _exception.what());
 	}
 	catch (util::Exception const& _exception)
 	{
-		return formatFatalError("InternalCompilerError", "Internal exception in StandardCompiler::compile: " + boost::diagnostic_information(_exception));
+		return formatFatalError(Error::Type::InternalCompilerError, "Internal exception in StandardCompiler::compile: " + boost::diagnostic_information(_exception));
 	}
 	catch (...)
 	{
-		return formatFatalError("InternalCompilerError", "Internal exception in StandardCompiler::compile: " +  boost::current_exception_diagnostic_information());
+		return formatFatalError(Error::Type::InternalCompilerError, "Internal exception in StandardCompiler::compile: " +  boost::current_exception_diagnostic_information());
 	}
 }
 
-string StandardCompiler::compile(string const& _input) noexcept
+std::string StandardCompiler::compile(std::string const& _input) noexcept
 {
 	Json::Value input;
-	string errors;
+	std::string errors;
 	try
 	{
 		if (!util::jsonParseStrict(_input, input, &errors))
-			return util::jsonPrint(formatFatalError("JSONError", errors), m_jsonPrintingFormat);
+			return util::jsonPrint(formatFatalError(Error::Type::JSONError, errors), m_jsonPrintingFormat);
 	}
 	catch (...)
 	{
 		return "{\"errors\":[{\"type\":\"JSONError\",\"component\":\"general\",\"severity\":\"error\",\"message\":\"Error parsing input JSON.\"}]}";
 	}
 
-	// cout << "Input: " << input.toStyledString() << endl;
+	// std::cout << "Input: " << input.toStyledString() << std::endl;
 	Json::Value output = compile(input);
 	// cout << "Output: " << output.toStyledString() << endl;
 
@@ -1299,4 +1275,3 @@ string StandardCompiler::compile(string const& _input) noexcept
 		return "{\"errors\":[{\"type\":\"JSONError\",\"component\":\"general\",\"severity\":\"error\",\"message\":\"Error writing output JSON.\"}]}";
 	}
 }
-
diff --git a/compiler/libsolidity/interface/StandardCompiler.h b/compiler/libsolidity/interface/StandardCompiler.h
index 678cb578..3b0c6f8f 100644
--- a/compiler/libsolidity/interface/StandardCompiler.h
+++ b/compiler/libsolidity/interface/StandardCompiler.h
@@ -68,11 +68,14 @@ class StandardCompiler
 	{
 		std::string language;
 		Json::Value errors;
+
 		std::vector<std::string> includePaths;
 		bool parserErrorRecovery = false;
 		std::string mainContract;
+
 		CompilerStack::State stopAfter = CompilerStack::State::CompilationSuccessful;
 		std::map<std::string, std::string> sources;
+		std::map<std::string, Json::Value> jsonSources;
 		std::map<util::h256, std::string> smtLib2Responses;
 		langutil::EVMVersion evmVersion;
 		langutil::TVMVersion tvmVersion;
@@ -82,6 +85,7 @@ class StandardCompiler
 		std::optional<langutil::DebugInfoSelection> debugInfoSelection;
 		std::map<std::string, util::h160> libraries;
 		bool metadataLiteralSources = false;
+		CompilerStack::MetadataFormat metadataFormat = CompilerStack::defaultMetadataFormat();
 		CompilerStack::MetadataHash metadataHash = CompilerStack::MetadataHash::IPFS;
 		Json::Value outputSelection;
 		bool viaIR = false;
@@ -91,8 +95,8 @@ class StandardCompiler
 	/// it in condensed form or an error as a json object.
 	std::variant<InputsAndSettings, Json::Value> parseInput(Json::Value const& _input);
 
+	std::map<std::string, Json::Value> parseAstFromInput(StringMap const& _sources);
 	Json::Value compileSolidity(InputsAndSettings _inputsAndSettings);
-	Json::Value compileYul(InputsAndSettings _inputsAndSettings);
 
 	ReadCallback::Callback m_readFile;
 
diff --git a/compiler/libsolidity/interface/StorageLayout.cpp b/compiler/libsolidity/interface/StorageLayout.cpp
index 76c840db..8e1d0eed 100644
--- a/compiler/libsolidity/interface/StorageLayout.cpp
+++ b/compiler/libsolidity/interface/StorageLayout.cpp
@@ -20,7 +20,6 @@
 
 #include <libsolidity/ast/TypeProvider.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::frontend;
 
@@ -112,7 +111,7 @@ void StorageLayout::generate(Type const* _type)
 	solAssert(typeInfo.isMember("encoding"), "");
 }
 
-string StorageLayout::typeKeyName(Type const* _type)
+std::string StorageLayout::typeKeyName(Type const* _type)
 {
 	if (auto refType = dynamic_cast<ReferenceType const*>(_type))
 		return TypeProvider::withLocationIfReference(refType->location(), _type)->richIdentifier();
diff --git a/compiler/libsolidity/interface/UniversalCallback.h b/compiler/libsolidity/interface/UniversalCallback.h
new file mode 100644
index 00000000..3fe74c65
--- /dev/null
+++ b/compiler/libsolidity/interface/UniversalCallback.h
@@ -0,0 +1,58 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+
+#include <libsolidity/interface/FileReader.h>
+#include <libsolidity/interface/SMTSolverCommand.h>
+
+namespace solidity::frontend
+{
+
+/// UniversalCallback is used to wrap both FileReader and SMTSolverCommand
+/// callbacks in a single callback.  It uses the Kind of the callback to
+/// determine which to call internally.
+class UniversalCallback
+{
+public:
+	UniversalCallback(FileReader* _fileReader, SMTSolverCommand& _solver) :
+		m_fileReader{_fileReader},
+		m_solver{_solver}
+	{}
+
+	frontend::ReadCallback::Callback callback()
+	{
+		return [this](std::string const& _kind, std::string const& _data) -> ReadCallback::Result {
+			if (_kind == ReadCallback::kindString(ReadCallback::Kind::ReadFile))
+				if (!m_fileReader)
+					return ReadCallback::Result{false, "No import callback."};
+				else
+					return m_fileReader->readFile(_kind, _data);
+			else if (_kind == ReadCallback::kindString(ReadCallback::Kind::SMTQuery))
+				return m_solver.solve(_kind, _data);
+			solAssert(false, "Unknown callback kind.");
+		};
+	}
+
+	void resetImportCallback() { m_fileReader = nullptr; }
+
+private:
+	FileReader* m_fileReader;
+	SMTSolverCommand& m_solver;
+};
+
+}
diff --git a/compiler/libsolidity/interface/Version.cpp b/compiler/libsolidity/interface/Version.cpp
index 0f54d891..ed271ba0 100644
--- a/compiler/libsolidity/interface/Version.cpp
+++ b/compiler/libsolidity/interface/Version.cpp
@@ -25,19 +25,17 @@
 
 #include <solidity/BuildInfo.h>
 
-using namespace std;
-
 char const* solidity::frontend::VersionNumber = ETH_PROJECT_VERSION;
 
-string const solidity::frontend::VersionString =
-	string(solidity::frontend::VersionNumber) +
-//	(string(SOL_VERSION_PRERELEASE).empty() ? "" : "-" + string(SOL_VERSION_PRERELEASE)) +
-	(string(SOL_VERSION_BUILDINFO).empty() ? "" : "+" + string(SOL_VERSION_BUILDINFO));
+std::string const solidity::frontend::VersionString =
+	std::string(solidity::frontend::VersionNumber) +
+	//(std::string(SOL_VERSION_PRERELEASE).empty() ? "" : "-" + std::string(SOL_VERSION_PRERELEASE)) +
+	(std::string(SOL_VERSION_BUILDINFO).empty() ? "" : "+" + std::string(SOL_VERSION_BUILDINFO));
 
-string const solidity::frontend::VersionStringStrict =
-	string(solidity::frontend::VersionNumber) +
-	(string(SOL_VERSION_PRERELEASE).empty() ? "" : "-" + string(SOL_VERSION_PRERELEASE)) +
-	(string(SOL_VERSION_COMMIT).empty() ? "" : "+" + string(SOL_VERSION_COMMIT));
+std::string const solidity::frontend::VersionStringStrict =
+	std::string(solidity::frontend::VersionNumber) +
+	(std::string(SOL_VERSION_PRERELEASE).empty() ? "" : "-" + std::string(SOL_VERSION_PRERELEASE)) +
+	(std::string(SOL_VERSION_COMMIT).empty() ? "" : "+" + std::string(SOL_VERSION_COMMIT));
 
 solidity::bytes const solidity::frontend::VersionCompactBytes = {
 	ETH_PROJECT_VERSION_MAJOR,
@@ -45,4 +43,4 @@ solidity::bytes const solidity::frontend::VersionCompactBytes = {
 	ETH_PROJECT_VERSION_PATCH
 };
 
-bool const solidity::frontend::VersionIsRelease = string(SOL_VERSION_PRERELEASE).empty();
+bool const solidity::frontend::VersionIsRelease = std::string(SOL_VERSION_PRERELEASE).empty();
diff --git a/compiler/libsolidity/lsp/DocumentHoverHandler.cpp b/compiler/libsolidity/lsp/DocumentHoverHandler.cpp
new file mode 100644
index 00000000..39d1d72c
--- /dev/null
+++ b/compiler/libsolidity/lsp/DocumentHoverHandler.cpp
@@ -0,0 +1,123 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolidity/lsp/DocumentHoverHandler.h>
+#include <libsolidity/lsp/Utils.h>
+
+#include <fmt/format.h>
+
+namespace solidity::lsp
+{
+using namespace solidity::lsp;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+
+namespace
+{
+
+struct MarkdownBuilder
+{
+	std::stringstream result;
+
+	MarkdownBuilder& solidityCode(std::string const& _code)
+	{
+		auto constexpr SolidityLanguageId = "solidity";
+		result << "```" << SolidityLanguageId << '\n' << _code << "\n```\n\n";
+		return *this;
+	}
+
+	MarkdownBuilder& paragraph(std::string const& _text)
+	{
+		if (!_text.empty())
+		{
+			result << _text << '\n';
+			if (_text.back() != '\n') // We want double-LF to ensure constructing a paragraph.
+				result << '\n';
+		}
+		return *this;
+	}
+};
+
+}
+
+void DocumentHoverHandler::operator()(MessageID _id, Json::Value const& _args)
+{
+	auto const [sourceUnitName, lineColumn] = HandlerBase(*this).extractSourceUnitNameAndLineColumn(_args);
+	auto const [sourceNode, sourceOffset] = m_server.astNodeAndOffsetAtSourceLocation(sourceUnitName, lineColumn);
+
+	MarkdownBuilder markdown;
+	auto rangeToHighlight = toRange(sourceNode->location());
+
+	// Try getting the type definition of the underlying AST node, if available.
+	if (auto const* expression = dynamic_cast<Expression const*>(sourceNode))
+	{
+		if (auto const* declaration = ASTNode::referencedDeclaration(*expression))
+			if (declaration->type())
+				markdown.solidityCode(declaration->type()->toString(false));
+	}
+	else if (auto const* declaration = dynamic_cast<Declaration const*>(sourceNode))
+	{
+		if (declaration->type())
+			markdown.solidityCode(declaration->type()->toString(false));
+	}
+	else if (auto const* identifierPath = dynamic_cast<IdentifierPath const*>(sourceNode))
+	{
+		for (size_t i = 0; i < identifierPath->path().size(); ++i)
+		{
+			if (identifierPath->pathLocations()[i].containsOffset(sourceOffset))
+			{
+				rangeToHighlight = toRange(identifierPath->pathLocations()[i]);
+
+				if (i < identifierPath->annotation().pathDeclarations.size())
+				{
+					Declaration const* declaration = identifierPath->annotation().pathDeclarations[i];
+					if (declaration && declaration->type())
+						markdown.solidityCode(declaration->type()->toString(false));
+					if (auto const* structurallyDocumented = dynamic_cast<StructurallyDocumented const*>(declaration))
+						if (structurallyDocumented->documentation()->text())
+							markdown.paragraph(*structurallyDocumented->documentation()->text());
+				}
+				break;
+			}
+		}
+	}
+
+	// If this AST node contains documentation itself, append it.
+	if (auto const* documented = dynamic_cast<StructurallyDocumented const*>(sourceNode))
+	{
+		if (documented->documentation())
+			markdown.paragraph(*documented->documentation()->text());
+	}
+
+	auto tooltipText = markdown.result.str();
+
+	if (tooltipText.empty())
+	{
+		client().reply(_id, Json::nullValue);
+		return;
+	}
+
+	Json::Value reply = Json::objectValue;
+	reply["range"] = rangeToHighlight;
+	reply["contents"]["kind"] = "markdown";
+	reply["contents"]["value"] = std::move(tooltipText);
+
+	client().reply(_id, reply);
+}
+
+}
diff --git a/compiler/libsolidity/lsp/DocumentHoverHandler.h b/compiler/libsolidity/lsp/DocumentHoverHandler.h
new file mode 100644
index 00000000..9bb4084c
--- /dev/null
+++ b/compiler/libsolidity/lsp/DocumentHoverHandler.h
@@ -0,0 +1,32 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#pragma once
+#include <libsolidity/lsp/HandlerBase.h>
+
+namespace solidity::lsp
+{
+
+class DocumentHoverHandler: public HandlerBase
+{
+public:
+	using HandlerBase::HandlerBase;
+
+	void operator()(MessageID, Json::Value const&);
+};
+
+}
diff --git a/compiler/libsolidity/lsp/FileRepository.cpp b/compiler/libsolidity/lsp/FileRepository.cpp
index 4e8ebbb1..7138cbd8 100644
--- a/compiler/libsolidity/lsp/FileRepository.cpp
+++ b/compiler/libsolidity/lsp/FileRepository.cpp
@@ -34,7 +34,6 @@
 
 #include <fmt/format.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::lsp;
 using namespace solidity::frontend;
@@ -54,11 +53,11 @@ void FileRepository::setIncludePaths(std::vector<boost::filesystem::path> _paths
 	m_includePaths = std::move(_paths);
 }
 
-string FileRepository::sourceUnitNameToUri(string const& _sourceUnitName) const
+std::string FileRepository::sourceUnitNameToUri(std::string const& _sourceUnitName) const
 {
-	regex const windowsDriveLetterPath("^[a-zA-Z]:/");
+	std::regex const windowsDriveLetterPath("^[a-zA-Z]:/");
 
-	auto const ensurePathIsUnixLike = [&](string inputPath) -> string {
+	auto const ensurePathIsUnixLike = [&](std::string inputPath) -> std::string {
 		if (!regex_search(inputPath, windowsDriveLetterPath))
 			return inputPath;
 		else
@@ -86,13 +85,13 @@ string FileRepository::sourceUnitNameToUri(string const& _sourceUnitName) const
 		return "file:///" + _sourceUnitName;
 }
 
-string FileRepository::uriToSourceUnitName(string const& _path) const
+std::string FileRepository::uriToSourceUnitName(std::string const& _path) const
 {
-	lspAssert(boost::algorithm::starts_with(_path, "file://"), ErrorCode::InternalError, "URI must start with file://");
+	lspRequire(boost::algorithm::starts_with(_path, "file://"), ErrorCode::InternalError, "URI must start with file://");
 	return stripFileUriSchemePrefix(_path);
 }
 
-void FileRepository::setSourceByUri(string const& _uri, string _source)
+void FileRepository::setSourceByUri(std::string const& _uri, std::string _source)
 {
 	// This is needed for uris outside the base path. It can lead to collisions,
 	// but we need to mostly rewrite this in a future version anyway.
@@ -110,9 +109,9 @@ Result<boost::filesystem::path> FileRepository::tryResolvePath(std::string const
 	)
 		return boost::filesystem::path(_strippedSourceUnitName);
 
-	vector<boost::filesystem::path> candidates;
-	vector<reference_wrapper<boost::filesystem::path const>> prefixes = {m_basePath};
-	prefixes += (m_includePaths | ranges::to<vector<reference_wrapper<boost::filesystem::path const>>>);
+	std::vector<boost::filesystem::path> candidates;
+	std::vector<std::reference_wrapper<boost::filesystem::path const>> prefixes = {m_basePath};
+	prefixes += (m_includePaths | ranges::to<std::vector<std::reference_wrapper<boost::filesystem::path const>>>);
 	auto const defaultInclude = m_basePath / "node_modules";
 	if (m_includePaths.empty())
 		prefixes.emplace_back(defaultInclude);
@@ -148,7 +147,7 @@ Result<boost::filesystem::path> FileRepository::tryResolvePath(std::string const
 	return candidates[0];
 }
 
-frontend::ReadCallback::Result FileRepository::readFile(string const& _kind, string const& _sourceUnitName)
+frontend::ReadCallback::Result FileRepository::readFile(std::string const& _kind, std::string const& _sourceUnitName)
 {
 	solAssert(
 		_kind == ReadCallback::kindString(ReadCallback::Kind::ReadFile),
@@ -161,7 +160,7 @@ frontend::ReadCallback::Result FileRepository::readFile(string const& _kind, str
 		if (m_sourceCodes.count(_sourceUnitName))
 			return ReadCallback::Result{true, m_sourceCodes.at(_sourceUnitName)};
 
-		string const strippedSourceUnitName = stripFileUriSchemePrefix(_sourceUnitName);
+		std::string const strippedSourceUnitName = stripFileUriSchemePrefix(_sourceUnitName);
 		Result<boost::filesystem::path> const resolvedPath = tryResolvePath(strippedSourceUnitName);
 		if (!resolvedPath.message().empty())
 			return ReadCallback::Result{false, resolvedPath.message()};
diff --git a/compiler/libsolidity/lsp/GotoDefinition.cpp b/compiler/libsolidity/lsp/GotoDefinition.cpp
index 532792c1..136e4d7c 100644
--- a/compiler/libsolidity/lsp/GotoDefinition.cpp
+++ b/compiler/libsolidity/lsp/GotoDefinition.cpp
@@ -30,7 +30,6 @@
 using namespace solidity::frontend;
 using namespace solidity::langutil;
 using namespace solidity::lsp;
-using namespace std;
 
 void GotoDefinition::operator()(MessageID _id, Json::Value const& _args)
 {
@@ -38,7 +37,7 @@ void GotoDefinition::operator()(MessageID _id, Json::Value const& _args)
 
 	ASTNode const* sourceNode = m_server.astNodeAtSourceLocation(sourceUnitName, lineColumn);
 
-	vector<SourceLocation> locations;
+	std::vector<SourceLocation> locations;
 	if (auto const* expression = dynamic_cast<Expression const*>(sourceNode))
 	{
 		// Handles all expressions that can have one or more declaration annotation.
@@ -56,7 +55,7 @@ void GotoDefinition::operator()(MessageID _id, Json::Value const& _args)
 	{
 		auto const& path = *importDirective->annotation().absolutePath;
 		if (fileRepository().sourceUnits().count(path))
-			locations.emplace_back(SourceLocation{0, 0, make_shared<string const>(path)});
+			locations.emplace_back(SourceLocation{0, 0, std::make_shared<std::string const>(path)});
 	}
 
 	Json::Value reply = Json::arrayValue;
diff --git a/compiler/libsolidity/lsp/HandlerBase.cpp b/compiler/libsolidity/lsp/HandlerBase.cpp
index f40f189a..a23e43a8 100644
--- a/compiler/libsolidity/lsp/HandlerBase.cpp
+++ b/compiler/libsolidity/lsp/HandlerBase.cpp
@@ -29,7 +29,6 @@
 using namespace solidity::langutil;
 using namespace solidity::lsp;
 using namespace solidity::util;
-using namespace std;
 
 Json::Value HandlerBase::toRange(SourceLocation const& _location) const
 {
@@ -52,10 +51,10 @@ Json::Value HandlerBase::toJson(SourceLocation const& _location) const
 	return item;
 }
 
-pair<string, LineColumn> HandlerBase::extractSourceUnitNameAndLineColumn(Json::Value const& _args) const
+std::pair<std::string, LineColumn> HandlerBase::extractSourceUnitNameAndLineColumn(Json::Value const& _args) const
 {
-	string const uri = _args["textDocument"]["uri"].asString();
-	string const sourceUnitName = fileRepository().uriToSourceUnitName(uri);
+	std::string const uri = _args["textDocument"]["uri"].asString();
+	std::string const sourceUnitName = fileRepository().uriToSourceUnitName(uri);
 	if (!fileRepository().sourceUnits().count(sourceUnitName))
 		BOOST_THROW_EXCEPTION(
 			RequestError(ErrorCode::RequestFailed) <<
diff --git a/compiler/libsolidity/lsp/LanguageServer.cpp b/compiler/libsolidity/lsp/LanguageServer.cpp
index c2d530b7..cb456111 100644
--- a/compiler/libsolidity/lsp/LanguageServer.cpp
+++ b/compiler/libsolidity/lsp/LanguageServer.cpp
@@ -25,6 +25,7 @@
 #include <libsolidity/lsp/Utils.h>
 
 // LSP feature implementations
+#include <libsolidity/lsp/DocumentHoverHandler.h>
 #include <libsolidity/lsp/GotoDefinition.h>
 #include <libsolidity/lsp/RenameSymbol.h>
 #include <libsolidity/lsp/SemanticTokensBuilder.h>
@@ -46,7 +47,6 @@
 
 #include <fmt/format.h>
 
-using namespace std;
 using namespace std::string_literals;
 using namespace std::placeholders;
 
@@ -109,7 +109,7 @@ Json::Value semanticTokensLegend()
 	tokenTypes.append("operator");
 	tokenTypes.append("parameter");
 	tokenTypes.append("property");
-	tokenTypes.append("string");
+	tokenTypes.append("std::string");
 	tokenTypes.append("struct");
 	tokenTypes.append("type");
 	tokenTypes.append("typeParameter");
@@ -137,18 +137,19 @@ LanguageServer::LanguageServer(Transport& _transport):
 		{"$/cancelRequest", [](auto, auto) {/*nothing for now as we are synchronous */}},
 		{"cancelRequest", [](auto, auto) {/*nothing for now as we are synchronous */}},
 		{"exit", [this](auto, auto) { m_state = (m_state == State::ShutdownRequested ? State::ExitRequested : State::ExitWithoutShutdown); }},
-		{"initialize", bind(&LanguageServer::handleInitialize, this, _1, _2)},
-		{"initialized", bind(&LanguageServer::handleInitialized, this, _1, _2)},
+		{"initialize", std::bind(&LanguageServer::handleInitialize, this, _1, _2)},
+		{"initialized", std::bind(&LanguageServer::handleInitialized, this, _1, _2)},
 		{"$/setTrace", [this](auto, Json::Value const& args) { setTrace(args["value"]); }},
 		{"shutdown", [this](auto, auto) { m_state = State::ShutdownRequested; }},
 		{"textDocument/definition", GotoDefinition(*this) },
-		{"textDocument/didOpen", bind(&LanguageServer::handleTextDocumentDidOpen, this, _2)},
-		{"textDocument/didChange", bind(&LanguageServer::handleTextDocumentDidChange, this, _2)},
-		{"textDocument/didClose", bind(&LanguageServer::handleTextDocumentDidClose, this, _2)},
+		{"textDocument/didOpen", std::bind(&LanguageServer::handleTextDocumentDidOpen, this, _2)},
+		{"textDocument/didChange", std::bind(&LanguageServer::handleTextDocumentDidChange, this, _2)},
+		{"textDocument/didClose", std::bind(&LanguageServer::handleTextDocumentDidClose, this, _2)},
+		{"textDocument/hover", DocumentHoverHandler(*this) },
 		{"textDocument/rename", RenameSymbol(*this) },
 		{"textDocument/implementation", GotoDefinition(*this) },
-		{"textDocument/semanticTokens/full", bind(&LanguageServer::semanticTokensFull, this, _1, _2)},
-		{"workspace/didChangeConfiguration", bind(&LanguageServer::handleWorkspaceDidChangeConfiguration, this, _2)},
+		{"textDocument/semanticTokens/full", std::bind(&LanguageServer::semanticTokensFull, this, _1, _2)},
+		{"workspace/didChangeConfiguration", std::bind(&LanguageServer::handleWorkspaceDidChangeConfiguration, this, _2)},
 	},
 	m_fileRepository("/" /* basePath */, {} /* no search paths */) //,
 	//m_compilerStack{m_fileRepository.candidateGetter(), m_fileRepository.reader()}
@@ -185,7 +186,7 @@ void LanguageServer::changeConfiguration(Json::Value const& _settings)
 		else if (text == "directly-opened-and-on-import")
 			m_fileLoadStrategy = FileLoadStrategy::DirectlyOpenedAndOnImported;
 		else
-			lspAssert(false, ErrorCode::InvalidParams, "Invalid file load strategy: " + text);
+			lspRequire(false, ErrorCode::InvalidParams, "Invalid file load strategy: " + text);
 	}
 
 	m_settingsObject = _settings;
@@ -196,7 +197,7 @@ void LanguageServer::changeConfiguration(Json::Value const& _settings)
 		int typeFailureCount = 0;
 		if (jsonIncludePaths.isArray())
 		{
-			vector<boost::filesystem::path> includePaths;
+			std::vector<boost::filesystem::path> includePaths;
 			for (Json::Value const& jsonPath: jsonIncludePaths)
 			{
 				if (jsonPath.isString())
@@ -214,13 +215,14 @@ void LanguageServer::changeConfiguration(Json::Value const& _settings)
 	}
 }
 
-vector<boost::filesystem::path> LanguageServer::allSolidityFilesFromProject() const
+std::vector<boost::filesystem::path> LanguageServer::allSolidityFilesFromProject() const
 {
-	vector<fs::path> collectedPaths{};
+	std::vector<fs::path> collectedPaths{};
 
 	// We explicitly decided against including all files from include paths but leave the possibility
 	// open for a future PR to enable such a feature to be optionally enabled (default disabled).
 
+	// Note: Newer versions of boost have deprecated symlink_option::recurse
 #if (BOOST_VERSION < 107200)
 	auto directoryIterator = fs::recursive_directory_iterator(m_fileRepository.basePath(), fs::symlink_option::recurse);
 #else
@@ -242,7 +244,7 @@ void LanguageServer::compile()
 	// so we just remove all non-open files.
 
 	FileRepository oldRepository(m_fileRepository.basePath(), m_fileRepository.includePaths());
-	swap(oldRepository, m_fileRepository);
+	std::swap(oldRepository, m_fileRepository);
 
 	// Load all solidity files from project.
 	if (m_fileLoadStrategy == FileLoadStrategy::ProjectDirectory)
@@ -256,7 +258,7 @@ void LanguageServer::compile()
 		}
 
 	// Overwrite all files as opened by the client, including the ones which might potentially have changes.
-	for (string const& fileName: m_openFiles)
+	for (std::string const& fileName: m_openFiles)
 		m_fileRepository.setSourceByUri(
 			fileName,
 			oldRepository.sourceUnits().at(oldRepository.uriToSourceUnitName(fileName))
@@ -267,7 +269,7 @@ void LanguageServer::compile()
 	m_compilerStack.reset(false);
 	m_compilerStack.setSources(m_fileRepository.sourceUnits());
 	solUnimplemented("TODO Uncomment this");
-//	m_compilerStack.compile(CompilerStack::State::AnalysisPerformed);
+	//m_compilerStack.compile(CompilerStack::State::AnalysisSuccessful);
 }
 
 void LanguageServer::compileAndUpdateDiagnostics()
@@ -276,13 +278,13 @@ void LanguageServer::compileAndUpdateDiagnostics()
 
 	// These are the source units we will sent diagnostics to the client for sure,
 	// even if it is just to clear previous diagnostics.
-	map<string, Json::Value> diagnosticsBySourceUnit;
-	for (string const& sourceUnitName: m_fileRepository.sourceUnits() | ranges::views::keys)
+	std::map<std::string, Json::Value> diagnosticsBySourceUnit;
+	for (std::string const& sourceUnitName: m_fileRepository.sourceUnits() | ranges::views::keys)
 		diagnosticsBySourceUnit[sourceUnitName] = Json::arrayValue;
-	for (string const& sourceUnitName: m_nonemptyDiagnostics)
+	for (std::string const& sourceUnitName: m_nonemptyDiagnostics)
 		diagnosticsBySourceUnit[sourceUnitName] = Json::arrayValue;
 
-	for (shared_ptr<Error const> const& error: m_compilerStack.errors())
+	for (std::shared_ptr<Error const> const& error: m_compilerStack.errors())
 	{
 		SourceLocation const* location = error->sourceLocation();
 		if (!location || !location->sourceName)
@@ -293,8 +295,8 @@ void LanguageServer::compileAndUpdateDiagnostics()
 		jsonDiag["source"] = "solc";
 		jsonDiag["severity"] = toDiagnosticSeverity(error->type());
 		jsonDiag["code"] = Json::UInt64{error->errorId().error};
-		string message = error->typeName() + ":";
-		if (string const* comment = error->comment())
+		std::string message = Error::formatErrorType(error->type()) + ":";
+		if (std::string const* comment = error->comment())
 			message += " " + *comment;
 		jsonDiag["message"] = std::move(message);
 		jsonDiag["range"] = toRange(*location);
@@ -315,7 +317,7 @@ void LanguageServer::compileAndUpdateDiagnostics()
 	{
 		Json::Value extra;
 		extra["openFileCount"] = Json::UInt64(diagnosticsBySourceUnit.size());
-		m_client.trace("Number of currently open files: " + to_string(diagnosticsBySourceUnit.size()), extra);
+		m_client.trace("Number of currently open files: " + std::to_string(diagnosticsBySourceUnit.size()), extra);
 	}
 
 	m_nonemptyDiagnostics.clear();
@@ -337,13 +339,13 @@ bool LanguageServer::run()
 		MessageID id;
 		try
 		{
-			optional<Json::Value> const jsonMessage = m_client.receive();
+			std::optional<Json::Value> const jsonMessage = m_client.receive();
 			if (!jsonMessage)
 				continue;
 
 			if ((*jsonMessage)["method"].isString())
 			{
-				string const methodName = (*jsonMessage)["method"].asString();
+				std::string const methodName = (*jsonMessage)["method"].asString();
 				id = (*jsonMessage)["id"];
 				lspDebug(fmt::format("received method call: {}", methodName));
 
@@ -373,7 +375,7 @@ bool LanguageServer::run()
 
 void LanguageServer::requireServerInitialized()
 {
-	lspAssert(
+	lspRequire(
 		m_state == State::Initialized,
 		ErrorCode::ServerNotInitialized,
 		"Server is not properly initialized."
@@ -382,7 +384,7 @@ void LanguageServer::requireServerInitialized()
 
 void LanguageServer::handleInitialize(MessageID _id, Json::Value const& _args)
 {
-	lspAssert(
+	lspRequire(
 		m_state == State::Started,
 		ErrorCode::RequestFailed,
 		"Initialize called at the wrong time."
@@ -392,11 +394,11 @@ void LanguageServer::handleInitialize(MessageID _id, Json::Value const& _args)
 
 	// The default of FileReader is to use `.`, but the path from where the LSP was started
 	// should not matter.
-	string rootPath("/");
+	std::string rootPath("/");
 	if (Json::Value uri = _args["rootUri"])
 	{
 		rootPath = uri.asString();
-		lspAssert(
+		lspRequire(
 			boost::starts_with(rootPath, "file://"),
 			ErrorCode::InvalidParams,
 			"rootUri only supports file URI scheme."
@@ -415,7 +417,7 @@ void LanguageServer::handleInitialize(MessageID _id, Json::Value const& _args)
 
 	Json::Value replyArgs;
 	replyArgs["serverInfo"]["name"] = "solc";
-	replyArgs["serverInfo"]["version"] = string(VersionNumber);
+	replyArgs["serverInfo"]["version"] = std::string(VersionNumber);
 	replyArgs["capabilities"]["definitionProvider"] = true;
 	replyArgs["capabilities"]["implementationProvider"] = true;
 	replyArgs["capabilities"]["textDocumentSync"]["change"] = 2; // 0=none, 1=full, 2=incremental
@@ -424,6 +426,7 @@ void LanguageServer::handleInitialize(MessageID _id, Json::Value const& _args)
 	replyArgs["capabilities"]["semanticTokensProvider"]["range"] = false;
 	replyArgs["capabilities"]["semanticTokensProvider"]["full"] = true; // XOR requests.full.delta = true
 	replyArgs["capabilities"]["renameProvider"] = true;
+	replyArgs["capabilities"]["hoverProvider"] = true;
 
 	m_client.reply(_id, std::move(replyArgs));
 }
@@ -440,7 +443,7 @@ void LanguageServer::semanticTokensFull(MessageID _id, Json::Value const& _args)
 
 	compile();
 
-	auto const sourceName = m_fileRepository.uriToSourceUnitName(uri.as<string>());
+	auto const sourceName = m_fileRepository.uriToSourceUnitName(uri.as<std::string>());
 	SourceUnit const& ast = m_compilerStack.ast(sourceName);
 	m_compilerStack.charStream(sourceName);
 	Json::Value data = SemanticTokensBuilder().build(ast, m_compilerStack.charStream(sourceName));
@@ -465,7 +468,7 @@ void LanguageServer::setTrace(Json::Value const& _args)
 		// Simply ignore invalid parameter.
 		return;
 
-	string const stringValue = _args.asString();
+	std::string const stringValue = _args.asString();
 	if (stringValue == "off")
 		m_client.setTrace(TraceValue::Off);
 	else if (stringValue == "messages")
@@ -478,14 +481,14 @@ void LanguageServer::handleTextDocumentDidOpen(Json::Value const& _args)
 {
 	requireServerInitialized();
 
-	lspAssert(
+	lspRequire(
 		_args["textDocument"],
 		ErrorCode::RequestFailed,
 		"Text document parameter missing."
 	);
 
-	string text = _args["textDocument"]["text"].asString();
-	string uri = _args["textDocument"]["uri"].asString();
+	std::string text = _args["textDocument"]["text"].asString();
+	std::string uri = _args["textDocument"]["uri"].asString();
 	m_openFiles.insert(uri);
 	m_fileRepository.setSourceByUri(uri, std::move(text));
 	compileAndUpdateDiagnostics();
@@ -495,34 +498,34 @@ void LanguageServer::handleTextDocumentDidChange(Json::Value const& _args)
 {
 	requireServerInitialized();
 
-	string const uri = _args["textDocument"]["uri"].asString();
+	std::string const uri = _args["textDocument"]["uri"].asString();
 
 	for (Json::Value jsonContentChange: _args["contentChanges"])
 	{
-		lspAssert(
+		lspRequire(
 			jsonContentChange.isObject(),
 			ErrorCode::RequestFailed,
 			"Invalid content reference."
 		);
 
-		string const sourceUnitName = m_fileRepository.uriToSourceUnitName(uri);
-		lspAssert(
+		std::string const sourceUnitName = m_fileRepository.uriToSourceUnitName(uri);
+		lspRequire(
 			m_fileRepository.sourceUnits().count(sourceUnitName),
 			ErrorCode::RequestFailed,
 			"Unknown file: " + uri
 		);
 
-		string text = jsonContentChange["text"].asString();
+		std::string text = jsonContentChange["text"].asString();
 		if (jsonContentChange["range"].isObject()) // otherwise full content update
 		{
-			optional<SourceLocation> change = parseRange(m_fileRepository, sourceUnitName, jsonContentChange["range"]);
-			lspAssert(
+			std::optional<SourceLocation> change = parseRange(m_fileRepository, sourceUnitName, jsonContentChange["range"]);
+			lspRequire(
 				change && change->hasText(),
 				ErrorCode::RequestFailed,
 				"Invalid source range: " + util::jsonCompactPrint(jsonContentChange["range"])
 			);
 
-			string buffer = m_fileRepository.sourceUnits().at(sourceUnitName);
+			std::string buffer = m_fileRepository.sourceUnits().at(sourceUnitName);
 			buffer.replace(static_cast<size_t>(change->start), static_cast<size_t>(change->end - change->start), std::move(text));
 			text = std::move(buffer);
 		}
@@ -536,31 +539,33 @@ void LanguageServer::handleTextDocumentDidClose(Json::Value const& _args)
 {
 	requireServerInitialized();
 
-	lspAssert(
+	lspRequire(
 		_args["textDocument"],
 		ErrorCode::RequestFailed,
 		"Text document parameter missing."
 	);
 
-	string uri = _args["textDocument"]["uri"].asString();
+	std::string uri = _args["textDocument"]["uri"].asString();
 	m_openFiles.erase(uri);
 
 	compileAndUpdateDiagnostics();
 }
 
-
 ASTNode const* LanguageServer::astNodeAtSourceLocation(std::string const& _sourceUnitName, LineColumn const& _filePos)
 {
-	if (m_compilerStack.state() < CompilerStack::AnalysisPerformed)
-		return nullptr;
+	return std::get<ASTNode const*>(astNodeAndOffsetAtSourceLocation(_sourceUnitName, _filePos));
+}
 
+std::tuple<ASTNode const*, int> LanguageServer::astNodeAndOffsetAtSourceLocation(std::string const& _sourceUnitName, LineColumn const& _filePos)
+{
+	if (m_compilerStack.state() < CompilerStack::AnalysisSuccessful)
+		return {nullptr, -1};
 	if (!m_fileRepository.sourceUnits().count(_sourceUnitName))
-		return nullptr;
+		return {nullptr, -1};
 
-	if (optional<int> sourcePos =
-		m_compilerStack.charStream(_sourceUnitName).translateLineColumnToPosition(_filePos))
-		return locateInnermostASTNode(*sourcePos, m_compilerStack.ast(_sourceUnitName));
-	else
-		return nullptr;
-}
+	std::optional<int> sourcePos = m_compilerStack.charStream(_sourceUnitName).translateLineColumnToPosition(_filePos);
+	if (!sourcePos)
+		return {nullptr, -1};
 
+	return {locateInnermostASTNode(*sourcePos, m_compilerStack.ast(_sourceUnitName)), *sourcePos};
+}
diff --git a/compiler/libsolidity/lsp/LanguageServer.h b/compiler/libsolidity/lsp/LanguageServer.h
index a05bec49..d80f8e87 100644
--- a/compiler/libsolidity/lsp/LanguageServer.h
+++ b/compiler/libsolidity/lsp/LanguageServer.h
@@ -77,6 +77,7 @@ class LanguageServer
 
 	FileRepository& fileRepository() noexcept { return m_fileRepository; }
 	Transport& client() noexcept { return m_client; }
+	std::tuple<frontend::ASTNode const*, int> astNodeAndOffsetAtSourceLocation(std::string const& _sourceUnitName, langutil::LineColumn const& _filePos);
 	frontend::ASTNode const* astNodeAtSourceLocation(std::string const& _sourceUnitName, langutil::LineColumn const& _filePos);
 	frontend::CompilerStack const& compilerStack() const noexcept { return m_compilerStack; }
 
diff --git a/compiler/libsolidity/lsp/RenameSymbol.cpp b/compiler/libsolidity/lsp/RenameSymbol.cpp
index a91ac608..7c0025c0 100644
--- a/compiler/libsolidity/lsp/RenameSymbol.cpp
+++ b/compiler/libsolidity/lsp/RenameSymbol.cpp
@@ -27,7 +27,6 @@
 using namespace solidity::frontend;
 using namespace solidity::langutil;
 using namespace solidity::lsp;
-using namespace std;
 
 namespace
 {
@@ -49,8 +48,8 @@ CallableDeclaration const* extractCallableDeclaration(FunctionCall const& _funct
 void RenameSymbol::operator()(MessageID _id, Json::Value const& _args)
 {
 	auto const&& [sourceUnitName, lineColumn] = extractSourceUnitNameAndLineColumn(_args);
-	string const newName = _args["newName"].asString();
-	string const uri = _args["textDocument"]["uri"].asString();
+	std::string const newName = _args["newName"].asString();
+	std::string const uri = _args["textDocument"]["uri"].asString();
 
 	ASTNode const* sourceNode = m_server.astNodeAtSourceLocation(sourceUnitName, lineColumn);
 
@@ -59,7 +58,7 @@ void RenameSymbol::operator()(MessageID _id, Json::Value const& _args)
 	m_sourceUnits = { &m_server.compilerStack().ast(sourceUnitName) };
 	m_locations.clear();
 
-	optional<int> cursorBytePosition = charStreamProvider()
+	std::optional<int> cursorBytePosition = charStreamProvider()
 		.charStream(sourceUnitName)
 		.translateLineColumnToPosition(lineColumn);
 	solAssert(cursorBytePosition.has_value(), "Expected source pos");
@@ -70,7 +69,7 @@ void RenameSymbol::operator()(MessageID _id, Json::Value const& _args)
 	for (auto const& [name, content]: fileRepository().sourceUnits())
 	{
 		auto const& sourceUnit = m_server.compilerStack().ast(name);
-		for (auto const* referencedSourceUnit: sourceUnit.referencedSourceUnits(true, util::convertContainer<set<SourceUnit const*>>(m_sourceUnits)))
+		for (auto const* referencedSourceUnit: sourceUnit.referencedSourceUnits(true, util::convertContainer<std::set<SourceUnit const*>>(m_sourceUnits)))
 			if (*referencedSourceUnit->location().sourceName == sourceUnitName)
 			{
 				m_sourceUnits.insert(&sourceUnit);
@@ -99,8 +98,8 @@ void RenameSymbol::operator()(MessageID _id, Json::Value const& _args)
 		solAssert(i->isValid());
 
 		// Replace in our file repository
-		string const uri = fileRepository().sourceUnitNameToUri(*i->sourceName);
-		string buffer = fileRepository().sourceUnits().at(*i->sourceName);
+		std::string const uri = fileRepository().sourceUnitNameToUri(*i->sourceName);
+		std::string buffer = fileRepository().sourceUnits().at(*i->sourceName);
 		buffer.replace((size_t)i->start, (size_t)(i->end - i->start), newName);
 		fileRepository().setSourceByUri(uri, std::move(buffer));
 
@@ -150,10 +149,6 @@ void RenameSymbol::extractNameAndDeclaration(ASTNode const& _node, int _cursorBy
 	}
 	else if (auto const* functionCall = dynamic_cast<FunctionCall const*>(&_node))
 		extractNameAndDeclaration(*functionCall, _cursorBytePosition);
-	else if (auto const* inlineAssembly = dynamic_cast<InlineAssembly const*>(&_node))
-		extractNameAndDeclaration(*inlineAssembly, _cursorBytePosition);
-	else
-		solAssert(false, "Unexpected ASTNODE id: " + to_string(_node.id()));
 
 	lspDebug(fmt::format("Goal: rename '{}', loc: {}-{}", m_symbolName, m_declarationToRename->nameLocation().start, m_declarationToRename->nameLocation().end));
 }
@@ -271,12 +266,3 @@ void RenameSymbol::Visitor::endVisit(IdentifierPath const& _node)
 		)
 			m_outer.m_locations.emplace_back(_node.pathLocations()[i]);
 }
-
-void RenameSymbol::extractNameAndDeclaration(InlineAssembly const& , int )
-{
-}
-
-void RenameSymbol::Visitor::endVisit(InlineAssembly const&)
-{
-
-}
diff --git a/compiler/libsolidity/lsp/RenameSymbol.h b/compiler/libsolidity/lsp/RenameSymbol.h
index cafa8c06..64e71dc2 100644
--- a/compiler/libsolidity/lsp/RenameSymbol.h
+++ b/compiler/libsolidity/lsp/RenameSymbol.h
@@ -40,7 +40,6 @@ class RenameSymbol: public HandlerBase
 		void endVisit(frontend::Identifier const& _node) override;
 		void endVisit(frontend::IdentifierPath const& _node) override;
 		void endVisit(frontend::FunctionCall const& _node) override;
-		void endVisit(frontend::InlineAssembly const& _node) override;
 
 		void endVisit(frontend::ContractDefinition const& _node) override
 		{
@@ -104,7 +103,6 @@ class RenameSymbol: public HandlerBase
 	void extractNameAndDeclaration(frontend::IdentifierPath const& _identifierPath, int _cursorBytePosition);
 	void extractNameAndDeclaration(frontend::ImportDirective const& _importDirective, int _cursorBytePosition);
 	void extractNameAndDeclaration(frontend::FunctionCall const& _functionCall, int _cursorBytePosition);
-	void extractNameAndDeclaration(frontend::InlineAssembly const& _inlineAssembly, int _cursorBytePosition);
 
 	// Node to rename
 	frontend::Declaration const* m_declarationToRename = nullptr;
diff --git a/compiler/libsolidity/lsp/SemanticTokensBuilder.cpp b/compiler/libsolidity/lsp/SemanticTokensBuilder.cpp
index dae48c1b..2f443541 100644
--- a/compiler/libsolidity/lsp/SemanticTokensBuilder.cpp
+++ b/compiler/libsolidity/lsp/SemanticTokensBuilder.cpp
@@ -23,7 +23,6 @@
 
 #include <fmt/format.h>
 
-using namespace std;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
 
@@ -33,10 +32,10 @@ namespace solidity::lsp
 namespace
 {
 
-optional<SemanticTokenType> semanticTokenTypeForType(frontend::Type const* _type)
+std::optional<SemanticTokenType> semanticTokenTypeForType(frontend::Type const* _type)
 {
 	if (!_type)
-		return nullopt;
+		return std::nullopt;
 
 	switch (_type->category())
 	{
@@ -119,7 +118,7 @@ void SemanticTokensBuilder::encode(
 	auto const [line, startChar] = m_charStream->translatePositionToLineColumn(_sourceLocation.start);
 	auto const length = _sourceLocation.end - _sourceLocation.start;
 
-	lspDebug(fmt::format("encode [{}:{}..{}] {}", line, startChar, length, _tokenType));
+	lspDebug(fmt::format("encode [{}:{}..{}] {}", line, startChar, length, static_cast<int>(_tokenType)));
 
 	m_encodedTokens.append(line - m_lastLine);
 	if (line == m_lastLine)
diff --git a/compiler/libsolidity/lsp/Transport.cpp b/compiler/libsolidity/lsp/Transport.cpp
index 5af72312..7f8eb228 100644
--- a/compiler/libsolidity/lsp/Transport.cpp
+++ b/compiler/libsolidity/lsp/Transport.cpp
@@ -37,34 +37,33 @@
 #include <fcntl.h>
 #endif
 
-using namespace std;
 using namespace solidity::lsp;
 
 // {{{ Transport
-optional<Json::Value> Transport::receive()
+std::optional<Json::Value> Transport::receive()
 {
 	auto const headers = parseHeaders();
 	if (!headers)
 	{
 		error({}, ErrorCode::ParseError, "Could not parse RPC headers.");
-		return nullopt;
+		return std::nullopt;
 	}
 
 	if (!headers->count("content-length"))
 	{
 		error({}, ErrorCode::ParseError, "No content-length header found.");
-		return nullopt;
+		return std::nullopt;
 	}
 
-	string const data = readBytes(stoul(headers->at("content-length")));
+	std::string const data = readBytes(stoul(headers->at("content-length")));
 
 	Json::Value jsonMessage;
-	string jsonParsingErrors;
+	std::string jsonParsingErrors;
 	solidity::util::jsonParseStrict(data, jsonMessage, &jsonParsingErrors);
 	if (!jsonParsingErrors.empty() || !jsonMessage || !jsonMessage.isObject())
 	{
 		error({}, ErrorCode::ParseError, "Could not parse RPC JSON payload. " + jsonParsingErrors);
-		return nullopt;
+		return std::nullopt;
 	}
 
 	return {std::move(jsonMessage)};
@@ -82,9 +81,9 @@ void Transport::trace(std::string _message, Json::Value _extra)
 	}
 }
 
-optional<map<string, string>> Transport::parseHeaders()
+std::optional<std::map<std::string, std::string>> Transport::parseHeaders()
 {
-	map<string, string> headers;
+	std::map<std::string, std::string> headers;
 
 	while (true)
 	{
@@ -93,18 +92,18 @@ optional<map<string, string>> Transport::parseHeaders()
 			break;
 
 		auto const delimiterPos = line.find(':');
-		if (delimiterPos == string::npos)
-			return nullopt;
+		if (delimiterPos == std::string::npos)
+			return std::nullopt;
 
 		auto const name = boost::to_lower_copy(line.substr(0, delimiterPos));
 		auto const value = line.substr(delimiterPos + 1);
 		if (!headers.emplace(boost::trim_copy(name), boost::trim_copy(value)).second)
-			return nullopt;
+			return std::nullopt;
 	}
 	return {std::move(headers)};
 }
 
-void Transport::notify(string _method, Json::Value _message)
+void Transport::notify(std::string _method, Json::Value _message)
 {
 	Json::Value json;
 	json["method"] = std::move(_method);
@@ -119,7 +118,7 @@ void Transport::reply(MessageID _id, Json::Value _message)
 	send(std::move(json), _id);
 }
 
-void Transport::error(MessageID _id, ErrorCode _code, string _message)
+void Transport::error(MessageID _id, ErrorCode _code, std::string _message)
 {
 	Json::Value json;
 	json["error"]["code"] = static_cast<int>(_code);
@@ -135,7 +134,7 @@ void Transport::send(Json::Value _json, MessageID _id)
 		_json["id"] = _id;
 
 	// Trailing CRLF only for easier readability.
-	string const jsonString = solidity::util::jsonCompactPrint(_json);
+	std::string const jsonString = solidity::util::jsonCompactPrint(_json);
 
 	writeBytes(fmt::format("Content-Length: {}\r\n\r\n", jsonString.size()));
 	writeBytes(jsonString);
@@ -144,7 +143,7 @@ void Transport::send(Json::Value _json, MessageID _id)
 // }}}
 
 // {{{ IOStreamTransport
-IOStreamTransport::IOStreamTransport(istream& _in, ostream& _out):
+IOStreamTransport::IOStreamTransport(std::istream& _in, std::ostream& _out):
 	m_input{_in},
 	m_output{_out}
 {
@@ -162,7 +161,7 @@ std::string IOStreamTransport::readBytes(size_t _length)
 
 std::string IOStreamTransport::getline()
 {
-	string line;
+	std::string line;
 	std::getline(m_input, line);
 	return line;
 }
diff --git a/compiler/libsolidity/lsp/Transport.h b/compiler/libsolidity/lsp/Transport.h
index 8aa89b3d..3e94e039 100644
--- a/compiler/libsolidity/lsp/Transport.h
+++ b/compiler/libsolidity/lsp/Transport.h
@@ -71,7 +71,14 @@ class RequestError: public util::Exception
 	ErrorCode m_code;
 };
 
-#define lspAssert(condition, errorCode, errorMessage) \
+/**
+ * Ensures precondition check is valid.
+ * This is supposed to be a recoverable error, that means, if the condition fails to be valid,
+ * an exception is being raised to be thrown out of the current request handlers
+ * of the current LSP's client RPC call and this will cause the current request to fail
+ * with the given error code - but subsequent calls shall be able to continue.
+ */
+#define lspRequire(condition, errorCode, errorMessage) \
 	if (!(condition)) \
 	{ \
 		BOOST_THROW_EXCEPTION( \
diff --git a/compiler/libsolidity/lsp/Utils.cpp b/compiler/libsolidity/lsp/Utils.cpp
index ef19b4c2..85e27a4f 100644
--- a/compiler/libsolidity/lsp/Utils.cpp
+++ b/compiler/libsolidity/lsp/Utils.cpp
@@ -30,21 +30,20 @@ namespace solidity::lsp
 
 using namespace frontend;
 using namespace langutil;
-using namespace std;
 
-optional<LineColumn> parseLineColumn(Json::Value const& _lineColumn)
+std::optional<LineColumn> parseLineColumn(Json::Value const& _lineColumn)
 {
 	if (_lineColumn.isObject() && _lineColumn["line"].isInt() && _lineColumn["character"].isInt())
 		return LineColumn{_lineColumn["line"].asInt(), _lineColumn["character"].asInt()};
 	else
-		return nullopt;
+		return std::nullopt;
 }
 
 Json::Value toJson(LineColumn const& _pos)
 {
 	Json::Value json = Json::objectValue;
-	json["line"] = max(_pos.line, 0);
-	json["character"] = max(_pos.column, 0);
+	json["line"] = std::max(_pos.line, 0);
+	json["character"] = std::max(_pos.column, 0);
 
 	return json;
 }
@@ -70,10 +69,10 @@ Declaration const* referencedDeclaration(Expression const* _expression)
 	return nullptr;
 }
 
-optional<SourceLocation> declarationLocation(Declaration const* _declaration)
+std::optional<SourceLocation> declarationLocation(Declaration const* _declaration)
 {
 	if (!_declaration)
-		return nullopt;
+		return std::nullopt;
 
 	if (_declaration->nameLocation().isValid())
 		return _declaration->nameLocation();
@@ -81,43 +80,43 @@ optional<SourceLocation> declarationLocation(Declaration const* _declaration)
 	if (_declaration->location().isValid())
 		return _declaration->location();
 
-	return nullopt;
+	return std::nullopt;
 }
 
-optional<SourceLocation> parsePosition(
+std::optional<SourceLocation> parsePosition(
 	FileRepository const& _fileRepository,
-	string const& _sourceUnitName,
+	std::string const& _sourceUnitName,
 	Json::Value const& _position
 )
 {
 	if (!_fileRepository.sourceUnits().count(_sourceUnitName))
-		return nullopt;
+		return std::nullopt;
 
-	if (optional<LineColumn> lineColumn = parseLineColumn(_position))
-		if (optional<int> const offset = CharStream::translateLineColumnToPosition(
+	if (std::optional<LineColumn> lineColumn = parseLineColumn(_position))
+		if (std::optional<int> const offset = CharStream::translateLineColumnToPosition(
 			_fileRepository.sourceUnits().at(_sourceUnitName),
 			*lineColumn
 		))
-			return SourceLocation{*offset, *offset, make_shared<string>(_sourceUnitName)};
-	return nullopt;
+			return SourceLocation{*offset, *offset, std::make_shared<std::string>(_sourceUnitName)};
+	return std::nullopt;
 }
 
-optional<SourceLocation> parseRange(FileRepository const& _fileRepository, string const& _sourceUnitName, Json::Value const& _range)
+std::optional<SourceLocation> parseRange(FileRepository const& _fileRepository, std::string const& _sourceUnitName, Json::Value const& _range)
 {
 	if (!_range.isObject())
-		return nullopt;
-	optional<SourceLocation> start = parsePosition(_fileRepository, _sourceUnitName, _range["start"]);
-	optional<SourceLocation> end = parsePosition(_fileRepository, _sourceUnitName, _range["end"]);
+		return std::nullopt;
+	std::optional<SourceLocation> start = parsePosition(_fileRepository, _sourceUnitName, _range["start"]);
+	std::optional<SourceLocation> end = parsePosition(_fileRepository, _sourceUnitName, _range["end"]);
 	if (!start || !end)
-		return nullopt;
+		return std::nullopt;
 	solAssert(*start->sourceName == *end->sourceName);
 	start->end = end->end;
 	return start;
 }
 
-string stripFileUriSchemePrefix(string const& _path)
+std::string stripFileUriSchemePrefix(std::string const& _path)
 {
-	regex const windowsDriveLetterPath("^file:///[a-zA-Z]:/");
+	std::regex const windowsDriveLetterPath("^file:///[a-zA-Z]:/");
 	if (regex_search(_path, windowsDriveLetterPath))
 		return _path.substr(8);
 	if (_path.find("file://") == 0)
diff --git a/compiler/libsolidity/parsing/DocStringParser.cpp b/compiler/libsolidity/parsing/DocStringParser.cpp
index 7e6e158b..b9f358e0 100644
--- a/compiler/libsolidity/parsing/DocStringParser.cpp
+++ b/compiler/libsolidity/parsing/DocStringParser.cpp
@@ -28,7 +28,6 @@
 #include <range/v3/algorithm/find_if_not.hpp>
 #include <range/v3/view/subrange.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::langutil;
 using namespace solidity::frontend;
@@ -36,17 +35,17 @@ using namespace solidity::frontend;
 namespace
 {
 
-string::const_iterator skipLineOrEOS(
-	string::const_iterator _nlPos,
-	string::const_iterator _end
+std::string::const_iterator skipLineOrEOS(
+	std::string::const_iterator _nlPos,
+	std::string::const_iterator _end
 )
 {
 	return (_nlPos == _end) ? _end : ++_nlPos;
 }
 
-string::const_iterator firstNonIdentifier(
-	string::const_iterator _pos,
-	string::const_iterator _end
+std::string::const_iterator firstNonIdentifier(
+	std::string::const_iterator _pos,
+	std::string::const_iterator _end
 )
 {
 	auto currPos = _pos;
@@ -58,18 +57,18 @@ string::const_iterator firstNonIdentifier(
 	return currPos;
 }
 
-string::const_iterator firstWhitespaceOrNewline(
-	string::const_iterator _pos,
-	string::const_iterator _end
+std::string::const_iterator firstWhitespaceOrNewline(
+	std::string::const_iterator _pos,
+	std::string::const_iterator _end
 )
 {
 	return ranges::find_first_of(ranges::make_subrange(_pos, _end), " \t\n");
 }
 
 
-string::const_iterator skipWhitespace(
-	string::const_iterator _pos,
-	string::const_iterator _end
+std::string::const_iterator skipWhitespace(
+	std::string::const_iterator _pos,
+	std::string::const_iterator _end
 )
 {
 	auto isWhitespace = [](char const& c) { return (c == ' ' || c == '\t'); };
@@ -78,7 +77,7 @@ string::const_iterator skipWhitespace(
 
 }
 
-multimap<string, DocTag> DocStringParser::parse()
+std::multimap<std::string, DocTag> DocStringParser::parse()
 {
 	m_lastTag = nullptr;
 	m_docTags = {};
@@ -96,7 +95,7 @@ multimap<string, DocTag> DocStringParser::parse()
 		{
 			// we found a tag
 			iter tagNameEndPos = firstWhitespaceOrNewline(tagPos, end);
-			string tagName{tagPos + 1, tagNameEndPos};
+			std::string tagName{tagPos + 1, tagNameEndPos};
 			iter tagDataPos = (tagNameEndPos != end) ? tagNameEndPos + 1 : tagNameEndPos;
 			currPos = parseDocTag(tagDataPos, end, tagName);
 		}
@@ -141,7 +140,7 @@ DocStringParser::iter DocStringParser::parseDocTagParam(iter _pos, iter _end)
 		return _end;
 	}
 	auto nameEndPos = firstNonIdentifier(nameStartPos, _end);
-	auto paramName = string(nameStartPos, nameEndPos);
+	auto paramName = std::string(nameStartPos, nameEndPos);
 
 	auto descStartPos = skipWhitespace(nameEndPos, _end);
 	auto nlPos = find(descStartPos, _end, '\n');
@@ -152,7 +151,7 @@ DocStringParser::iter DocStringParser::parseDocTagParam(iter _pos, iter _end)
 		return _end;
 	}
 
-	auto paramDesc = string(descStartPos, nlPos);
+	auto paramDesc = std::string(descStartPos, nlPos);
 	newTag("param");
 	m_lastTag->paramName = paramName;
 	m_lastTag->content = paramDesc;
@@ -160,7 +159,7 @@ DocStringParser::iter DocStringParser::parseDocTagParam(iter _pos, iter _end)
 	return skipLineOrEOS(nlPos, _end);
 }
 
-DocStringParser::iter DocStringParser::parseDocTag(iter _pos, iter _end, string const& _tag)
+DocStringParser::iter DocStringParser::parseDocTag(iter _pos, iter _end, std::string const& _tag)
 {
 	// TODO: need to check for @(start of a tag) between here and the end of line
 	// for all cases.
@@ -178,7 +177,7 @@ DocStringParser::iter DocStringParser::parseDocTag(iter _pos, iter _end, string
 		return parseDocTagLine(_pos, _end, true);
 }
 
-void DocStringParser::newTag(string const& _tagName)
+void DocStringParser::newTag(std::string const& _tagName)
 {
 	m_lastTag = &m_docTags.insert(make_pair(_tagName, DocTag()))->second;
 }
diff --git a/compiler/libsolidity/parsing/Parser.cpp b/compiler/libsolidity/parsing/Parser.cpp
index 9919b299..6e9c623b 100644
--- a/compiler/libsolidity/parsing/Parser.cpp
+++ b/compiler/libsolidity/parsing/Parser.cpp
@@ -23,6 +23,7 @@
 
 #include <libsolidity/parsing/Parser.h>
 
+#include <libsolidity/ast/UserDefinableOperators.h>
 #include <libsolidity/interface/Version.h>
 #include <liblangutil/ErrorReporter.h>
 #include <liblangutil/Scanner.h>
@@ -31,15 +32,17 @@
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/predicate.hpp>
+
 #include <cctype>
-#include <vector>
+#include <memory>
 #include <regex>
 #include <tuple>
+#include <vector>
 
 #include "libsolidity/codegen/TVMConstants.hpp"
 
-using namespace std;
 using namespace solidity::langutil;
+using namespace std::string_literals;
 
 namespace solidity::frontend
 {
@@ -71,7 +74,7 @@ class Parser::ASTNodeFactory
 		solAssert(m_location.sourceName, "");
 		if (m_location.end < 0)
 			markEndPosition();
-		return make_shared<NodeType>(m_parser.nextID(), m_location, std::forward<Args>(_args)...);
+		return std::make_shared<NodeType>(m_parser.nextID(), m_location, std::forward<Args>(_args)...);
 	}
 
 	SourceLocation const& location() const noexcept { return m_location; }
@@ -87,16 +90,23 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 	try
 	{
 		m_recursionDepth = 0;
-		m_scanner = make_shared<Scanner>(_charStream);
+		m_scanner = std::make_shared<Scanner>(_charStream);
 		ASTNodeFactory nodeFactory(*this);
+		m_experimentalSolidityEnabledInCurrentSourceUnit = false;
+
+		std::vector<ASTPointer<ASTNode>> nodes;
+		while (m_scanner->currentToken() == Token::Pragma)
+			nodes.push_back(parsePragmaDirective(false));
+
+		if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+			m_scanner->setScannerMode(ScannerKind::ExperimentalSolidity);
 
-		vector<ASTPointer<ASTNode>> nodes;
 		while (m_scanner->currentToken() != Token::EOS)
 		{
 			switch (m_scanner->currentToken())
 			{
 			case Token::Pragma:
-				nodes.push_back(parsePragmaDirective());
+				nodes.push_back(parsePragmaDirective(true));
 				break;
 			case Token::Import:
 				nodes.push_back(parseImportDirective());
@@ -114,7 +124,10 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 				nodes.push_back(parseEnumDefinition());
 				break;
 			case Token::Type:
-				nodes.push_back(parseUserDefinedValueTypeDefinition());
+				if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+					nodes.push_back(parseTypeDefinition());
+				else
+					nodes.push_back(parseUserDefinedValueTypeDefinition());
 				break;
 			case Token::Using:
 				nodes.push_back(parseUsingDirective());
@@ -122,6 +135,17 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 			case Token::Function:
 				nodes.push_back(parseFunctionDefinition(true));
 				break;
+			case Token::Event:
+				nodes.push_back(parseEventDefinition());
+				break;
+			case Token::Class:
+				solAssert(m_experimentalSolidityEnabledInCurrentSourceUnit);
+				nodes.push_back(parseTypeClassDefinition());
+				break;
+			case Token::Instantiation:
+				solAssert(m_experimentalSolidityEnabledInCurrentSourceUnit);
+				nodes.push_back(parseTypeClassInstantiation());
+				break;
 			default:
 				if (
 					// Workaround because `error` is not a keyword.
@@ -145,7 +169,7 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 			}
 		}
 		solAssert(m_recursionDepth == 0, "");
-		return nodeFactory.createNode<SourceUnit>(findLicenseString(nodes), nodes);
+		return nodeFactory.createNode<SourceUnit>(findLicenseString(nodes), nodes, m_experimentalSolidityEnabledInCurrentSourceUnit);
 	}
 	catch (FatalError const&)
 	{
@@ -155,29 +179,30 @@ ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
 	}
 }
 
-void Parser::parsePragmaVersion(SourceLocation const& _location, vector<Token> const& _tokens, vector<string> const& _literals)
+void Parser::parsePragmaVersion(SourceLocation const& _location, std::vector<Token> const& _tokens, std::vector<std::string> const& _literals)
 {
 	SemVerMatchExpressionParser parser(_tokens, _literals);
-	auto matchExpression = parser.parse();
-	if (!matchExpression.has_value())
-		m_errorReporter.fatalParserError(
-			1684_error,
-			_location,
-			"Found version pragma, but failed to parse it. "
-			"Please ensure there is a trailing semicolon."
-		);
-	static SemVerVersion const currentVersion{string(VersionString)};
-	// FIXME: only match for major version incompatibility
-	if (!matchExpression->matches(currentVersion))
-		// If m_parserErrorRecovery is true, the same message will appear from SyntaxChecker::visit(),
-		// so we don't need to report anything here.
-		if (!m_parserErrorRecovery)
+	try
+	{
+		SemVerMatchExpression matchExpression = parser.parse();
+		static SemVerVersion const currentVersion{std::string(VersionString)};
+		// FIXME: only match for major version incompatibility
+		if (!matchExpression.matches(currentVersion))
 			m_errorReporter.fatalParserError(
 				5333_error,
 				_location,
 				"Source file requires different compiler version (current compiler is " +
-				string(VersionString) + ")"
+				std::string(VersionString) + ")"
 			);
+	}
+	catch (SemVerError const& matchError)
+	{
+		m_errorReporter.fatalParserError(
+			1684_error,
+			_location,
+			"Invalid version pragma. "s + matchError.what()
+		);
+	}
 }
 
 ASTPointer<StructuredDocumentation> Parser::parseStructuredDocumentation()
@@ -187,13 +212,13 @@ ASTPointer<StructuredDocumentation> Parser::parseStructuredDocumentation()
 		ASTNodeFactory nodeFactory{*this};
 		nodeFactory.setLocation(m_scanner->currentCommentLocation());
 		return nodeFactory.createNode<StructuredDocumentation>(
-			make_shared<ASTString>(m_scanner->currentCommentLiteral())
+			std::make_shared<ASTString>(m_scanner->currentCommentLiteral())
 		);
 	}
 	return nullptr;
 }
 
-ASTPointer<PragmaDirective> Parser::parsePragmaDirective()
+ASTPointer<PragmaDirective> Parser::parsePragmaDirective(bool const _finishedParsingTopLevelPragmas)
 {
 	RecursionGuard recursionGuard(*this);
 	// pragma anything* ;
@@ -201,8 +226,8 @@ ASTPointer<PragmaDirective> Parser::parsePragmaDirective()
 	// pragma solidity ^0.4.0 || ^0.3.0;
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::Pragma);
-	vector<string> literals;
-	vector<Token> tokens;
+	std::vector<std::string> literals;
+	std::vector<Token> tokens;
 	std::vector<ASTPointer<Expression>> parameter;
 	do
 	{
@@ -211,7 +236,7 @@ ASTPointer<PragmaDirective> Parser::parsePragmaDirective()
 			parserError(6281_error, "Token incompatible with Solidity parser as part of pragma directive.");
 		else
 		{
-			string literal = m_scanner->currentLiteral();
+			std::string literal = m_scanner->currentLiteral();
 			if (literal.empty() && TokenTraits::toString(token))
 				literal = TokenTraits::toString(token);
 			literals.push_back(literal);
@@ -235,17 +260,25 @@ ASTPointer<PragmaDirective> Parser::parsePragmaDirective()
 	nodeFactory.markEndPosition();
 	expectToken(Token::Semicolon);
 
-	if (literals.size() >= 3 && literals[0] == "ton")
+	if (literals.size() >= 3 && (literals[0] == "ton" || literals[0] == "ever"))
 	{
 		parsePragmaVersion(
 			nodeFactory.location(),
-			vector<Token>(tokens.begin() + 3, tokens.end()),
-			vector<string>(literals.begin() + 3, literals.end())
+			std::vector<Token>(tokens.begin() + 3, tokens.end()),
+			std::vector<std::string>(literals.begin() + 3, literals.end())
 		);
 	}
 
-	ASTPointer<PragmaDirective> pd = nodeFactory.createNode<PragmaDirective>(tokens, literals, parameter);
-	return pd;
+	if (literals.size() >= 2 && literals[0] == "experimental" && literals[1] == "solidity")
+	{
+		if (m_evmVersion < EVMVersion::constantinople())
+			fatalParserError(7637_error, "Experimental solidity requires Constantinople EVM version at the minimum.");
+		if (_finishedParsingTopLevelPragmas)
+			fatalParserError(8185_error, "Experimental pragma \"solidity\" can only be set at the beginning of the source unit.");
+		m_experimentalSolidityEnabledInCurrentSourceUnit = true;
+	}
+
+	return nodeFactory.createNode<PragmaDirective>(tokens, literals, parameter);
 }
 
 ASTPointer<ImportDirective> Parser::parseImportDirective()
@@ -257,13 +290,13 @@ ASTPointer<ImportDirective> Parser::parseImportDirective()
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::Import);
 	ASTPointer<ASTString> path;
-	ASTPointer<ASTString> unitAlias = make_shared<string>();
+	ASTPointer<ASTString> unitAlias = std::make_shared<std::string>();
 	SourceLocation unitAliasLocation{};
 	ImportDirective::SymbolAliasList symbolAliases;
 
-	if (m_scanner->currentToken() == Token::StringLiteral)
+	if (isQuotedPath() || isStdlibPath())
 	{
-		path = getLiteralAndAdvance();
+		path = isQuotedPath() ? getLiteralAndAdvance() : getStdlibImportPathAndAdvance();
 		if (m_scanner->currentToken() == Token::As)
 		{
 			advance();
@@ -305,9 +338,9 @@ ASTPointer<ImportDirective> Parser::parseImportDirective()
 		if (m_scanner->currentToken() != Token::Identifier || m_scanner->currentLiteral() != "from")
 			fatalParserError(8208_error, "Expected \"from\".");
 		advance();
-		if (m_scanner->currentToken() != Token::StringLiteral)
+		if (!isQuotedPath() && !isStdlibPath())
 			fatalParserError(6845_error, "Expected import path.");
-		path = getLiteralAndAdvance();
+		path = isQuotedPath() ? getLiteralAndAdvance() : getStdlibImportPathAndAdvance();
 	}
 	if (path->empty())
 		fatalParserError(6326_error, "Import path cannot be empty.");
@@ -351,83 +384,67 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
 	ASTPointer<ASTString> name =  nullptr;
 	SourceLocation nameLocation{};
 	ASTPointer<StructuredDocumentation> documentation;
-	vector<ASTPointer<InheritanceSpecifier>> baseContracts;
-	vector<ASTPointer<ASTNode>> subNodes;
+	std::vector<ASTPointer<InheritanceSpecifier>> baseContracts;
+	std::vector<ASTPointer<ASTNode>> subNodes;
 	std::pair<ContractKind, bool> contractKind{};
-	try
-	{
-		documentation = parseStructuredDocumentation();
-		contractKind = parseContractKind();
-		tie(name, nameLocation) = expectIdentifierWithLocation();
-		if (m_scanner->currentToken() == Token::Is)
-			do
-			{
-				advance();
-				baseContracts.push_back(parseInheritanceSpecifier());
-			}
-			while (m_scanner->currentToken() == Token::Comma);
-		expectToken(Token::LBrace);
-		while (true)
+	documentation = parseStructuredDocumentation();
+	contractKind = parseContractKind();
+	std::tie(name, nameLocation) = expectIdentifierWithLocation();
+	if (m_scanner->currentToken() == Token::Is)
+		do
 		{
-			Token currentTokenValue = m_scanner->currentToken();
-			if (currentTokenValue == Token::RBrace)
-				break;
-			else if (
-				(currentTokenValue == Token::Function && m_scanner->peekNextToken() != Token::LParen) ||
-				currentTokenValue == Token::Constructor ||
-				currentTokenValue == Token::Receive ||
-				currentTokenValue == Token::Fallback ||
-				currentTokenValue == Token::onBounce ||
-				currentTokenValue == Token::onTickTock
-					)
-				subNodes.push_back(parseFunctionDefinition());
-			else if (currentTokenValue == Token::Struct)
-				subNodes.push_back(parseStructDefinition());
-			else if (currentTokenValue == Token::Enum)
-				subNodes.push_back(parseEnumDefinition());
-			else if (currentTokenValue == Token::Type)
-				subNodes.push_back(parseUserDefinedValueTypeDefinition());
-			else if (
-				// Workaround because `error` is not a keyword.
-				currentTokenValue == Token::Identifier &&
-				currentLiteral() == "error" &&
-				m_scanner->peekNextToken() == Token::Identifier &&
-				m_scanner->peekNextNextToken() == Token::LParen
-			)
-				subNodes.push_back(parseErrorDefinition());
-			else if (variableDeclarationStart())
-			{
-				VarDeclParserOptions options;
-				options.kind = VarDeclKind::State;
-				options.allowInitialValue = true;
-				subNodes.push_back(parseVariableDeclaration(options));
-				expectToken(Token::Semicolon);
-			}
-			else if (currentTokenValue == Token::Modifier)
-				subNodes.push_back(parseModifierDefinition());
-			else if (currentTokenValue == Token::Event)
-				subNodes.push_back(parseEventDefinition());
-			else if (currentTokenValue == Token::Using)
-				subNodes.push_back(parseUsingDirective());
-			else
-				fatalParserError(9182_error, "Function, variable, struct or modifier declaration expected.");
+			advance();
+			baseContracts.push_back(parseInheritanceSpecifier());
 		}
-	}
-	catch (FatalError const&)
+		while (m_scanner->currentToken() == Token::Comma);
+	expectToken(Token::LBrace);
+	while (true)
 	{
-		if (
-			!m_errorReporter.hasErrors() ||
-			!m_parserErrorRecovery ||
-			m_errorReporter.hasExcessiveErrors()
+		Token currentTokenValue = m_scanner->currentToken();
+		if (currentTokenValue == Token::RBrace)
+			break;
+		else if (
+			(currentTokenValue == Token::Function && m_scanner->peekNextToken() != Token::LParen) ||
+			currentTokenValue == Token::Constructor ||
+			currentTokenValue == Token::Receive ||
+			currentTokenValue == Token::Fallback ||
+			currentTokenValue == Token::onBounce ||
+			currentTokenValue == Token::onTickTock
+		)
+			subNodes.push_back(parseFunctionDefinition());
+		else if (currentTokenValue == Token::Struct)
+			subNodes.push_back(parseStructDefinition());
+		else if (currentTokenValue == Token::Enum)
+			subNodes.push_back(parseEnumDefinition());
+		else if (currentTokenValue == Token::Type)
+			subNodes.push_back(parseUserDefinedValueTypeDefinition());
+		else if (
+			// Workaround because `error` is not a keyword.
+			currentTokenValue == Token::Identifier &&
+			currentLiteral() == "error" &&
+			m_scanner->peekNextToken() == Token::Identifier &&
+			m_scanner->peekNextNextToken() == Token::LParen
 		)
-			BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
-		m_inParserRecovery = true;
+			subNodes.push_back(parseErrorDefinition());
+		else if (variableDeclarationStart())
+		{
+			VarDeclParserOptions options;
+			options.kind = VarDeclKind::State;
+			options.allowInitialValue = true;
+			subNodes.push_back(parseVariableDeclaration(options));
+			expectToken(Token::Semicolon);
+		}
+		else if (currentTokenValue == Token::Modifier)
+			subNodes.push_back(parseModifierDefinition());
+		else if (currentTokenValue == Token::Event)
+			subNodes.push_back(parseEventDefinition());
+		else if (currentTokenValue == Token::Using)
+			subNodes.push_back(parseUsingDirective());
+		else
+			fatalParserError(9182_error, "Function, variable, struct or modifier declaration expected.");
 	}
 	nodeFactory.markEndPosition();
-	if (m_inParserRecovery)
-		expectTokenOrConsumeUntil(Token::RBrace, "ContractDefinition");
-	else
-		expectToken(Token::RBrace);
+	expectToken(Token::RBrace);
 	return nodeFactory.createNode<ContractDefinition>(
 		name,
 		nameLocation,
@@ -444,11 +461,11 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<IdentifierPath> name(parseIdentifierPath());
-	unique_ptr<vector<ASTPointer<Expression>>> arguments;
+	std::unique_ptr<std::vector<ASTPointer<Expression>>> arguments;
 	if (m_scanner->currentToken() == Token::LParen)
 	{
 		advance();
-		arguments = make_unique<vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
+		arguments = std::make_unique<std::vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
 		nodeFactory.markEndPosition();
 		expectToken(Token::RParen);
 	}
@@ -672,20 +689,30 @@ Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _isStateVari
 		else
 			break;
 	}
-	if (m_scanner->currentToken() == Token::Returns)
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit)
 	{
-		bool const permitEmptyParameterList = false;
-		advance();
-		result.returnParameters = parseParameterList(options, permitEmptyParameterList);
+		if (m_scanner->currentToken() == Token::RightArrow)
+		{
+			advance();
+			result.experimentalReturnExpression = parseBinaryExpression();
+		}
 	}
 	else
-		result.returnParameters = createEmptyParameterList();
+	{
+		if (m_scanner->currentToken() == Token::Returns)
+		{
+			bool const permitEmptyParameterList = m_experimentalSolidityEnabledInCurrentSourceUnit;
+			advance();
+			result.returnParameters = parseParameterList(options, permitEmptyParameterList);
+		}
+		else
+			result.returnParameters = createEmptyParameterList();
+	}
 	return result;
 }
 
-ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction)
+ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction, bool _allowBody)
 {
-	m_insideFunctionDefenition = true;
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
@@ -712,8 +739,8 @@ ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction)
 				{Token::onTickTock, "onTickTock function"},
 			}.at(m_scanner->currentToken());
 			nameLocation = currentLocation();
-			name = make_shared<ASTString>(TokenTraits::toString(m_scanner->currentToken()));
-			string message{
+			name = std::make_shared<ASTString>(TokenTraits::toString(m_scanner->currentToken()));
+			std::string message{
 				"This function is named \"" + *name + "\" but is not the " + expected + " of the contract. "
 				"If you intend this to be a " + expected + ", use \"" + *name + "(...) { ... }\" without "
 				"the \"function\" keyword to define it."
@@ -732,14 +759,21 @@ ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction)
 		solAssert(kind == Token::Constructor || kind == Token::Fallback || kind == Token::onBounce ||
 				  kind == Token::Receive || kind == Token::onTickTock, "");
 		advance();
-		name = make_shared<ASTString>();
+		name = std::make_shared<ASTString>();
 	}
 
 	FunctionHeaderParserResult header = parseFunctionHeader(false);
 
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+		solAssert(!header.returnParameters);
+	else
+		solAssert(!header.experimentalReturnExpression);
+
 	ASTPointer<Block> block;
 	nodeFactory.markEndPosition();
-	if (m_scanner->currentToken() == Token::Semicolon)
+	if (!_allowBody)
+		expectToken(Token::Semicolon);
+	else if (m_scanner->currentToken() == Token::Semicolon)
 		advance();
 	else
 	{
@@ -769,7 +803,8 @@ ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction)
 		header.responsible,
 		header.externalMsg,
 		header.internalMsg,
-		header.assembly
+		header.assembly,
+		header.experimentalReturnExpression
 	);
 }
 
@@ -777,9 +812,10 @@ ASTPointer<StructDefinition> Parser::parseStructDefinition()
 {
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
+	ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
 	expectToken(Token::Struct);
 	auto [name, nameLocation] = expectIdentifierWithLocation();
-	vector<ASTPointer<VariableDeclaration>> members;
+	std::vector<ASTPointer<VariableDeclaration>> members;
 	expectToken(Token::LBrace);
 	while (m_scanner->currentToken() != Token::RBrace)
 	{
@@ -788,7 +824,7 @@ ASTPointer<StructDefinition> Parser::parseStructDefinition()
 	}
 	nodeFactory.markEndPosition();
 	expectToken(Token::RBrace);
-	return nodeFactory.createNode<StructDefinition>(std::move(name), std::move(nameLocation), std::move(members));
+	return nodeFactory.createNode<StructDefinition>(std::move(name), std::move(nameLocation), std::move(members), std::move(documentation));
 }
 
 ASTPointer<EnumValue> Parser::parseEnumValue()
@@ -803,9 +839,10 @@ ASTPointer<EnumDefinition> Parser::parseEnumDefinition()
 {
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
+	ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
 	expectToken(Token::Enum);
 	auto [name, nameLocation] = expectIdentifierWithLocation();
-	vector<ASTPointer<EnumValue>> members;
+	std::vector<ASTPointer<EnumValue>> members;
 	expectToken(Token::LBrace);
 
 	while (m_scanner->currentToken() != Token::RBrace)
@@ -822,7 +859,7 @@ ASTPointer<EnumDefinition> Parser::parseEnumDefinition()
 
 	nodeFactory.markEndPosition();
 	expectToken(Token::RBrace);
-	return nodeFactory.createNode<EnumDefinition>(name, nameLocation, members);
+	return nodeFactory.createNode<EnumDefinition>(name, nameLocation, members, documentation);
 }
 
 ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
@@ -838,12 +875,6 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 	ASTPointer<TypeName> type = _lookAheadArrayType ? _lookAheadArrayType : parseTypeName();
 	nodeFactory.setEndPositionFromNode(type);
 
-	// TODO DELETE THIS FROM HERE
-	if (_options.kind == VarDeclKind::State && dynamic_cast<TvmVector*>(type.get()))
-		fatalParserError(5069_error, string(
-				"vector type can't be used for state variables."
-		));
-
 	if (dynamic_cast<FunctionTypeName*>(type.get()) && _options.kind == VarDeclKind::State && m_scanner->currentToken() == Token::LBrace)
 		fatalParserError(
 			2915_error,
@@ -857,6 +888,7 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 	ASTPointer<OverrideSpecifier> overrides = nullptr;
 	Visibility visibility(Visibility::Default);
 	bool isStatic{false};
+	bool isNoStorage{false};
 	ASTPointer<ASTString> identifier;
 	SourceLocation nameLocation{};
 
@@ -894,16 +926,29 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 			isStatic = true;
 			m_scanner->next();
 		}
+		else if (_options.kind == VarDeclKind::State && token == Token::NoStorage)
+		{
+			if (isNoStorage)
+				parserError(2643_error, "NoStorage already specified.");
+
+			isNoStorage = true;
+			m_scanner->next();
+		}
 		else
 		{
 			if (_options.allowIndexed && token == Token::Indexed)
+			{
+				if (isIndexed)
+					parserError(5399_error, "Indexed already specified.");
+
 				isIndexed = true;
+			}
 			else if (token == Token::Constant || token == Token::Immutable)
 			{
 				if (mutability != VariableDeclaration::Mutability::Mutable)
 					parserError(
 						3109_error,
-						string("Mutability already set to ") +
+						std::string("Mutability already set to ") +
 						(mutability == VariableDeclaration::Mutability::Constant ? "\"constant\"" : "\"immutable\"")
 					);
 				else if (token == Token::Constant)
@@ -919,7 +964,7 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 	}
 
 	if (_options.allowEmptyName && m_scanner->currentToken() != Token::Identifier)
-		identifier = make_shared<ASTString>("");
+		identifier = std::make_shared<ASTString>("");
 	else
 	{
 		nodeFactory.markEndPosition();
@@ -946,7 +991,8 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 		isIndexed,
 		mutability,
 		overrides,
-		isStatic
+		isStatic,
+		isNoStorage
 	);
 }
 
@@ -965,7 +1011,6 @@ ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
 	if (m_scanner->currentToken() == Token::LParen)
 	{
 		VarDeclParserOptions options;
-		options.allowIndexed = true;
 		parameters = parseParameterList(options);
 	}
 	else
@@ -1007,7 +1052,7 @@ ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
 	return nodeFactory.createNode<ModifierDefinition>(name, nameLocation, documentation, parameters, isVirtual, overrides, block);
 }
 
-pair<ASTPointer<ASTString>, SourceLocation> Parser::expectIdentifierWithLocation()
+std::pair<ASTPointer<ASTString>, SourceLocation> Parser::expectIdentifierWithLocation()
 {
 	SourceLocation nameLocation = currentLocation();
 	ASTPointer<ASTString> name = expectIdentifierToken();
@@ -1061,7 +1106,8 @@ ASTPointer<UsingForDirective> Parser::parseUsingDirective()
 
 	expectToken(Token::Using);
 
-	vector<ASTPointer<IdentifierPath>> functions;
+	std::vector<ASTPointer<IdentifierPath>> functions;
+	std::vector<std::optional<Token>> operators;
 	bool const usesBraces = m_scanner->currentToken() == Token::LBrace;
 	if (usesBraces)
 	{
@@ -1069,12 +1115,41 @@ ASTPointer<UsingForDirective> Parser::parseUsingDirective()
 		{
 			advance();
 			functions.emplace_back(parseIdentifierPath());
+			if (m_scanner->currentToken() == Token::As)
+			{
+				advance();
+				Token operator_ = m_scanner->currentToken();
+				if (!util::contains(userDefinableOperators, operator_))
+				{
+					std::string operatorName;
+					if (!m_scanner->currentLiteral().empty())
+						operatorName = m_scanner->currentLiteral();
+					else if (char const* tokenString = TokenTraits::toString(operator_))
+						operatorName = std::string(tokenString);
+
+					parserError(
+						4403_error,
+						fmt::format(
+							"Not a user-definable operator: {}. Only the following operators can be user-defined: {}",
+							operatorName,
+							util::joinHumanReadable(userDefinableOperators | ranges::views::transform([](Token _t) { return std::string{TokenTraits::toString(_t)}; }))
+						)
+					);
+				}
+				operators.emplace_back(operator_);
+				advance();
+			}
+			else
+				operators.emplace_back(std::nullopt);
 		}
 		while (m_scanner->currentToken() == Token::Comma);
 		expectToken(Token::RBrace);
 	}
 	else
+	{
 		functions.emplace_back(parseIdentifierPath());
+		operators.emplace_back(std::nullopt);
+	}
 
 	ASTPointer<TypeName> typeName;
 	expectToken(Token::For);
@@ -1090,7 +1165,7 @@ ASTPointer<UsingForDirective> Parser::parseUsingDirective()
 	}
 	nodeFactory.markEndPosition();
 	expectToken(Token::Semicolon);
-	return nodeFactory.createNode<UsingForDirective>(std::move(functions), usesBraces, typeName, global);
+	return nodeFactory.createNode<UsingForDirective>(std::move(functions), std::move(operators), usesBraces, typeName, global);
 }
 
 ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
@@ -1098,11 +1173,11 @@ ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<IdentifierPath> name(parseIdentifierPath());
-	unique_ptr<vector<ASTPointer<Expression>>> arguments;
+	std::unique_ptr<std::vector<ASTPointer<Expression>>> arguments;
 	if (m_scanner->currentToken() == Token::LParen)
 	{
 		advance();
-		arguments = make_unique<vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
+		arguments = std::make_unique<std::vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
 		nodeFactory.markEndPosition();
 		expectToken(Token::RParen);
 	}
@@ -1159,8 +1234,8 @@ ASTPointer<IdentifierPath> Parser::parseIdentifierPath()
 
 	auto [name, nameLocation] = expectIdentifierWithLocation();
 
-	vector<ASTString> identifierPath{*name};
-	vector<SourceLocation> identifierPathLocations{nameLocation};
+	std::vector<ASTString> identifierPath{*name};
+	std::vector<SourceLocation> identifierPathLocations{nameLocation};
 
 	while (m_scanner->currentToken() == Token::Period)
 	{
@@ -1202,14 +1277,14 @@ ASTPointer<TypeName> Parser::parseTypeName()
 	{
 		unsigned firstSize;
 		unsigned secondSize;
-		tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
+		std::tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
 		ElementaryTypeNameToken elemTypeName(token, firstSize, secondSize);
 		ASTNodeFactory nodeFactory(*this);
 		nodeFactory.markEndPosition();
 		advance();
 		auto stateMutability = elemTypeName.token() == Token::Address
-			? optional<StateMutability>{StateMutability::NonPayable}
-			: nullopt;
+			? std::optional<StateMutability>{StateMutability::NonPayable}
+			: std::nullopt;
 		if (TokenTraits::isStateMutabilitySpecifier(m_scanner->currentToken()))
 		{
 			if (elemTypeName.token() == Token::Address)
@@ -1248,10 +1323,12 @@ ASTPointer<TypeName> Parser::parseTypeName()
 
 ASTPointer<FunctionTypeName> Parser::parseFunctionType()
 {
+	solAssert(!m_experimentalSolidityEnabledInCurrentSourceUnit);
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::Function);
 	FunctionHeaderParserResult header = parseFunctionHeader(true);
+	solAssert(!header.experimentalReturnExpression);
 	return nodeFactory.createNode<FunctionTypeName>(
 		header.parameters,
 		header.returnParameters,
@@ -1270,7 +1347,7 @@ ASTPointer<Mapping> Parser::parseMapping()
 	Token token = m_scanner->currentToken();
 	unsigned firstSize;
 	unsigned secondSize;
-	tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
+	std::tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
 	if (token == Token::Identifier)
 		keyType = parseUserDefinedTypeName();
 	else if (TokenTraits::isElementaryTypeName(token))
@@ -1282,11 +1359,19 @@ ASTPointer<Mapping> Parser::parseMapping()
 	}
 	else
 		fatalParserError(1005_error, "Expected elementary type name or identifier for mapping key type");
+	ASTPointer<ASTString> keyName = std::make_shared<ASTString>("");
+	SourceLocation keyNameLocation{};
+	if (m_scanner->currentToken() == Token::Identifier)
+		tie(keyName, keyNameLocation) = expectIdentifierWithLocation();
 	expectToken(Token::DoubleArrow);
 	ASTPointer<TypeName> valueType = parseTypeName();
+	ASTPointer<ASTString> valueName = std::make_shared<ASTString>("");
+	SourceLocation valueNameLocation{};
+	if (m_scanner->currentToken() == Token::Identifier)
+		tie(valueName, valueNameLocation) = expectIdentifierWithLocation();
 	nodeFactory.markEndPosition();
 	expectToken(Token::RParen);
-	return nodeFactory.createNode<Mapping>(keyType, valueType);
+	return nodeFactory.createNode<Mapping>(keyType, keyName, keyNameLocation, valueType, valueName, valueNameLocation);
 }
 
 ASTPointer<Optional> Parser::parseOptional()
@@ -1295,7 +1380,7 @@ ASTPointer<Optional> Parser::parseOptional()
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::Optional);
 	expectToken(Token::LParen);
-	vector<ASTPointer<TypeName>> components;
+	std::vector<ASTPointer<TypeName>> components;
 	while (true) {
 		ASTPointer<TypeName> cur = parseTypeName();
 		components.emplace_back(std::move(cur));
@@ -1329,19 +1414,32 @@ ASTPointer<ParameterList> Parser::parseParameterList(
 {
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
-	vector<ASTPointer<VariableDeclaration>> parameters;
+	std::vector<ASTPointer<VariableDeclaration>> parameters;
 	VarDeclParserOptions options(_options);
 	options.allowEmptyName = true;
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit && m_scanner->currentToken() == Token::Identifier)
+	{
+		// Parses unary parameter lists without parentheses. TODO: is this a good idea in all cases? Including arguments?
+		parameters = {parsePostfixVariableDeclaration()};
+		nodeFactory.setEndPositionFromNode(parameters.front());
+		return nodeFactory.createNode<ParameterList>(parameters);
+	}
 	expectToken(Token::LParen);
+	auto parseSingleVariableDeclaration = [&]() {
+		if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+			return parsePostfixVariableDeclaration();
+		else
+			return parseVariableDeclaration(options);
+	};
 	if (!_allowEmpty || m_scanner->currentToken() != Token::RParen)
 	{
-		parameters.push_back(parseVariableDeclaration(options));
+		parameters.push_back(parseSingleVariableDeclaration());
 		while (m_scanner->currentToken() != Token::RParen)
 		{
 			if (m_scanner->currentToken() == Token::Comma && m_scanner->peekNextToken() == Token::RParen)
 				fatalParserError(7591_error, "Unexpected trailing comma in parameter list.");
 			expectToken(Token::Comma);
-			parameters.push_back(parseVariableDeclaration(options));
+			parameters.push_back(parseSingleVariableDeclaration());
 		}
 	}
 	nodeFactory.markEndPosition();
@@ -1361,27 +1459,11 @@ ASTPointer<Block> Parser::parseBlock(bool _allowUnchecked, ASTPointer<ASTString>
 		advance();
 	}
 	expectToken(Token::LBrace);
-	vector<ASTPointer<Statement>> statements;
-	try
-	{
-		while (m_scanner->currentToken() != Token::RBrace)
-			statements.push_back(parseStatement(true));
-		nodeFactory.markEndPosition();
-	}
-	catch (FatalError const&)
-	{
-		if (
-			!m_errorReporter.hasErrors() ||
-			!m_parserErrorRecovery ||
-			m_errorReporter.hasExcessiveErrors()
-		)
-			BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
-		m_inParserRecovery = true;
-	}
-	if (m_inParserRecovery)
-		expectTokenOrConsumeUntil(Token::RBrace, "Block");
-	else
-		expectToken(Token::RBrace);
+	std::vector<ASTPointer<Statement>> statements;
+	while (m_scanner->currentToken() != Token::RBrace)
+		statements.push_back(parseStatement(true));
+	nodeFactory.markEndPosition();
+	expectToken(Token::RBrace);
 	return nodeFactory.createNode<Block>(_docString, unchecked, statements);
 }
 
@@ -1389,23 +1471,14 @@ ASTPointer<Block> Parser::parseAssemblyBlock(ASTPointer<ASTString> const& _docSt
 {
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
-	expectToken(Token::LBrace);
-	ASTPointer<Statement> statement;
-	try
-	{
-		statement = parseAssemblyStatement();
-		nodeFactory.markEndPosition();
-	}
-	catch (FatalError const&)
+	bool const unchecked = m_scanner->currentToken() == Token::Unchecked;
+	if (unchecked)
 	{
-		if (
-			!m_errorReporter.hasErrors() ||
-			!m_parserErrorRecovery ||
-			m_errorReporter.hasExcessiveErrors()
-		)
-			BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
-		m_inParserRecovery = true;
+		advance();
 	}
+	expectToken(Token::LBrace);
+	ASTPointer<Statement> statement = parseAssemblyStatement();
+	nodeFactory.markEndPosition();
 	expectToken(Token::RBrace);
 	return nodeFactory.createNode<Block>(_docString, false, std::vector<ASTPointer<Statement>>{statement});
 }
@@ -1415,99 +1488,80 @@ ASTPointer<Statement> Parser::parseStatement(bool _allowUnchecked)
 	RecursionGuard recursionGuard(*this);
 	ASTPointer<ASTString> docString;
 	ASTPointer<Statement> statement;
-	try
+	if (m_scanner->currentCommentLiteral() != "")
+		docString = std::make_shared<ASTString>(m_scanner->currentCommentLiteral());
+	switch (m_scanner->currentToken())
 	{
-		if (m_scanner->currentCommentLiteral() != "")
-			docString = make_shared<ASTString>(m_scanner->currentCommentLiteral());
-		switch (m_scanner->currentToken())
-		{
-		case Token::If:
-			return parseIfStatement(docString);
-		case Token::While:
-			return parseWhileStatement(docString);
-		case Token::Repeat:
-			return parseRepeatStatement(docString);
-		case Token::Do:
-			return parseDoWhileStatement(docString);
-		case Token::For:
-			return parseForStatement(docString);
-		case Token::Unchecked:
-		case Token::LBrace:
-			return parseBlock(_allowUnchecked, docString);
-		case Token::Continue:
-			statement = ASTNodeFactory(*this).createNode<Continue>(docString);
-			advance();
-			break;
-		case Token::Break:
-			statement = ASTNodeFactory(*this).createNode<Break>(docString);
-			advance();
-			break;
-		case Token::Return:
-		{
-
-			expectToken(Token::Return);
-			ASTNodeFactory nodeFactory(*this);
+	case Token::If:
+		return parseIfStatement(docString);
+	case Token::While:
+		return parseWhileStatement(docString);
+	case Token::Repeat:
+		return parseRepeatStatement(docString);
+	case Token::Do:
+		return parseDoWhileStatement(docString);
+	case Token::For:
+		return parseForStatement(docString);
+	case Token::Unchecked:
+	case Token::LBrace:
+		return parseBlock(_allowUnchecked, docString);
+	case Token::Continue:
+		statement = ASTNodeFactory(*this).createNode<Continue>(docString);
+		advance();
+		break;
+	case Token::Break:
+		statement = ASTNodeFactory(*this).createNode<Break>(docString);
+		advance();
+		break;
+	case Token::Return:
+	{
+		expectToken(Token::Return);
+		ASTNodeFactory nodeFactory(*this);
 
-			FunctionCallArguments namesArgs;
-			if (currentToken() == Token::LBrace) {
-				expectToken(Token::LBrace);
-				namesArgs = parseNamedArguments();
-				expectToken(Token::RBrace);
-			}
+		FunctionCallArguments namesArgs;
+		if (currentToken() == Token::LBrace) {
+			expectToken(Token::LBrace);
+			namesArgs = parseNamedArguments();
+			expectToken(Token::RBrace);
+		}
 
-			ASTPointer<Expression> expression;
-			if (currentToken() != Token::Semicolon)
-			{
-				expression = parseExpression();
-				nodeFactory.setEndPositionFromNode(expression);
-			}
-			// TODO DELETE use namesArgs.parameterNameLocations in Return
-			statement = nodeFactory.createNode<Return>(docString, expression, namesArgs.arguments, namesArgs.parameterNames);
-			break;
+		ASTPointer<Expression> expression;
+		if (currentToken() != Token::Semicolon)
+		{
+			expression = parseExpression();
+			nodeFactory.setEndPositionFromNode(expression);
 		}
-		case Token::Throw:
+		statement = nodeFactory.createNode<Return>(docString, expression, namesArgs.arguments,
+												   namesArgs.parameterNames, namesArgs.parameterNameLocations);
+		break;
+	}
+	case Token::Throw:
+	{
+		statement = ASTNodeFactory(*this).createNode<Throw>(docString);
+		advance();
+		break;
+	}
+	case Token::Try:
+		return parseTryStatement(docString);
+	case Token::Emit:
+		statement = parseEmitStatement(docString);
+		break;
+	case Token::Identifier:
+		if (m_scanner->currentLiteral() == "revert" && m_scanner->peekNextToken() == Token::Identifier)
+			statement = parseRevertStatement(docString);
+		else if (m_insideModifier && m_scanner->currentLiteral() == "_")
 		{
-			statement = ASTNodeFactory(*this).createNode<Throw>(docString);
+			statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>(docString);
 			advance();
-			break;
 		}
-		case Token::Try:
-			return parseTryStatement(docString);
-		case Token::Assembly:
-			return parseInlineAssembly(docString);
-		case Token::Emit:
-			statement = parseEmitStatement(docString);
-			break;
-		case Token::Identifier:
-			if (m_scanner->currentLiteral() == "revert" && m_scanner->peekNextToken() == Token::Identifier)
-				statement = parseRevertStatement(docString);
-			else if (m_insideModifier && m_scanner->currentLiteral() == "_")
-			{
-				statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>(docString);
-				advance();
-			}
-			else
-				statement = parseSimpleStatement(docString);
-			break;
-		default:
+		else
 			statement = parseSimpleStatement(docString);
-			break;
-		}
-	}
-	catch (FatalError const&)
-	{
-		if (
-			!m_errorReporter.hasErrors() ||
-			!m_parserErrorRecovery ||
-			m_errorReporter.hasExcessiveErrors()
-		)
-			BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
-		m_inParserRecovery = true;
+		break;
+	default:
+		statement = parseSimpleStatement(docString);
+		break;
 	}
-	if (m_inParserRecovery)
-		expectTokenOrConsumeUntil(Token::Semicolon, "Statement");
-	else
-		expectToken(Token::Semicolon);
+	expectToken(Token::Semicolon);
 	return statement;
 }
 
@@ -1532,12 +1586,6 @@ ASTPointer<Statement> Parser::parseAssemblyStatement()
 	return nodeFactory.createNode<FreeInlineAssembly>(docString, lines);
 }
 
-ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> const& /*_docString*/)
-{
-	m_errorReporter.fatalTypeError(4277_error, currentLocation(), "Inline assembly is disabled.");
-	return nullptr;
-}
-
 ASTPointer<IfStatement> Parser::parseIfStatement(ASTPointer<ASTString> const& _docString)
 {
 	RecursionGuard recursionGuard(*this);
@@ -1577,7 +1625,7 @@ ASTPointer<TryCatchClause> Parser::parseCatchClause()
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	expectToken(Token::Catch);
-	ASTPointer<ASTString> errorName = make_shared<string>();
+	ASTPointer<ASTString> errorName = std::make_shared<std::string>();
 	ASTPointer<ParameterList> errorParameters;
 	if (m_scanner->currentToken() != Token::LBrace)
 	{
@@ -1762,12 +1810,222 @@ ASTPointer<RevertStatement> Parser::parseRevertStatement(ASTPointer<ASTString> c
 	return nodeFactory.createNode<RevertStatement>(_docString, errorCall);
 }
 
+ASTPointer<VariableDeclarationStatement> Parser::parsePostfixVariableDeclarationStatement(
+	ASTPointer<ASTString> const& _docString
+)
+{
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+
+	expectToken(Token::Let);
+
+	std::vector<ASTPointer<VariableDeclaration>> variables;
+	variables.emplace_back(parsePostfixVariableDeclaration());
+	nodeFactory.setEndPositionFromNode(variables.back());
+
+	ASTPointer<Expression> value;
+	if (m_scanner->currentToken() == Token::Assign)
+	{
+		advance();
+		value = parseExpression();
+		nodeFactory.setEndPositionFromNode(value);
+	}
+	return nodeFactory.createNode<VariableDeclarationStatement>(_docString, variables, value);
+}
+
+ASTPointer<VariableDeclaration> Parser::parsePostfixVariableDeclaration()
+{
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+
+	ASTPointer<StructuredDocumentation> const documentation = parseStructuredDocumentation();
+
+	nodeFactory.markEndPosition();
+	auto [identifier, nameLocation] = expectIdentifierWithLocation();
+
+	ASTPointer<Expression> type;
+	if (m_scanner->currentToken() == Token::Colon)
+	{
+		advance();
+		type = parseBinaryExpression();
+		nodeFactory.setEndPositionFromNode(type);
+	}
+
+	return nodeFactory.createNode<VariableDeclaration>(
+		nullptr,
+		identifier,
+		nameLocation,
+		nullptr,
+		Visibility::Default,
+		documentation,
+		false,
+		VariableDeclaration::Mutability::Mutable,
+		nullptr,
+		false,
+		false,
+		type
+	);
+}
+
+ASTPointer<TypeClassDefinition> Parser::parseTypeClassDefinition()
+{
+	solAssert(m_experimentalSolidityEnabledInCurrentSourceUnit);
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+
+	std::vector<ASTPointer<ASTNode>> subNodes;
+
+	ASTPointer<StructuredDocumentation> const documentation = parseStructuredDocumentation();
+
+	expectToken(Token::Class);
+	// TODO: parseTypeVariable()? parseTypeVariableDeclaration()?
+	ASTPointer<VariableDeclaration> typeVariable;
+	{
+		ASTNodeFactory nodeFactory(*this);
+		nodeFactory.markEndPosition();
+		auto [identifier, nameLocation] = expectIdentifierWithLocation();
+		typeVariable = nodeFactory.createNode<VariableDeclaration>(
+			nullptr,
+			identifier,
+			nameLocation,
+			nullptr,
+			Visibility::Default,
+			nullptr
+		);
+	}
+	expectToken(Token::Colon);
+	auto [name, nameLocation] = expectIdentifierWithLocation();
+	expectToken(Token::LBrace);
+	while (true)
+	{
+		Token currentTokenValue = m_scanner->currentToken();
+		if (currentTokenValue == Token::RBrace)
+			break;
+		expectToken(Token::Function, false);
+		subNodes.push_back(parseFunctionDefinition(false, false));
+	}
+	nodeFactory.markEndPosition();
+	expectToken(Token::RBrace);
+
+	return nodeFactory.createNode<TypeClassDefinition>(
+		typeVariable,
+		name,
+		nameLocation,
+		documentation,
+		subNodes
+	);
+}
+
+ASTPointer<TypeClassName> Parser::parseTypeClassName()
+{
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+	std::variant<Token, ASTPointer<IdentifierPath>> name;
+	if (TokenTraits::isBuiltinTypeClassName(m_scanner->currentToken()))
+	{
+		nodeFactory.markEndPosition();
+		name = m_scanner->currentToken();
+		advance();
+	}
+	else
+	{
+		auto identifierPath = parseIdentifierPath();
+		name = identifierPath;
+		nodeFactory.setEndPositionFromNode(identifierPath);
+	}
+	return nodeFactory.createNode<TypeClassName>(name);
+}
+
+ASTPointer<TypeClassInstantiation> Parser::parseTypeClassInstantiation()
+{
+	solAssert(m_experimentalSolidityEnabledInCurrentSourceUnit);
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+
+	std::vector<ASTPointer<ASTNode>> subNodes;
+
+	expectToken(Token::Instantiation);
+	// TODO: parseTypeConstructor()
+	ASTPointer<TypeName> typeConstructor = parseTypeName();
+	ASTPointer<ParameterList> argumentSorts;
+	if (m_scanner->currentToken() == Token::LParen)
+	{
+		argumentSorts = parseParameterList();
+	}
+	expectToken(Token::Colon);
+	ASTPointer<TypeClassName> typeClassName = parseTypeClassName();
+	expectToken(Token::LBrace);
+	while (true)
+	{
+		Token currentTokenValue = m_scanner->currentToken();
+		if (currentTokenValue == Token::RBrace)
+			break;
+		expectToken(Token::Function, false);
+		// TODO: require body already during parsing?
+		subNodes.push_back(parseFunctionDefinition(false, true));
+	}
+	nodeFactory.markEndPosition();
+	expectToken(Token::RBrace);
+
+	return nodeFactory.createNode<TypeClassInstantiation>(
+		typeConstructor,
+		argumentSorts,
+		typeClassName,
+		subNodes
+	);
+}
+
+ASTPointer<TypeDefinition> Parser::parseTypeDefinition()
+{
+	solAssert(m_experimentalSolidityEnabledInCurrentSourceUnit);
+	ASTNodeFactory nodeFactory(*this);
+	expectToken(Token::Type);
+	auto&& [name, nameLocation] = expectIdentifierWithLocation();
+
+	ASTPointer<ParameterList> arguments;
+	if (m_scanner->currentToken() == Token::LParen)
+		arguments = parseParameterList();
+
+	ASTPointer<Expression> expression;
+	if (m_scanner->currentToken() == Token::Assign)
+	{
+		expectToken(Token::Assign);
+
+		if (m_scanner->currentToken() != Token::Builtin)
+			expression = parseExpression();
+		else
+		{
+			expectToken(Token::Builtin);
+			expectToken(Token::LParen);
+
+			expression = nodeFactory.createNode<Builtin>(
+				std::make_shared<std::string>(m_scanner->currentLiteral()),
+				m_scanner->currentLocation()
+			);
+
+			expectToken(Token::StringLiteral);
+			expectToken(Token::RParen);
+		}
+	}
+	nodeFactory.markEndPosition();
+	expectToken(Token::Semicolon);
+	return nodeFactory.createNode<TypeDefinition>(
+		std::move(name),
+		std::move(nameLocation),
+		std::move(arguments),
+		std::move(expression)
+	);
+}
+
 ASTPointer<Statement> Parser::parseSimpleStatement(ASTPointer<ASTString> const& _docString, bool isInForLoop)
 {
 	RecursionGuard recursionGuard(*this);
 	LookAheadInfo statementType;
 	IndexAccessedPath iap;
 
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit && m_scanner->currentToken() == Token::Let)
+		return parsePostfixVariableDeclarationStatement(_docString);
+
 	if (m_scanner->currentToken() == Token::LParen)
 	{
 		ASTNodeFactory nodeFactory(*this);
@@ -1781,16 +2039,16 @@ ASTPointer<Statement> Parser::parseSimpleStatement(ASTPointer<ASTString> const&
 		}
 
 		// Now see whether we have a variable declaration or an expression.
-		tie(statementType, iap) = tryParseIndexAccessedPath();
+		std::tie(statementType, iap) = tryParseIndexAccessedPath();
 		switch (statementType)
 		{
 		case LookAheadInfo::VariableDeclaration:
 		{
-			vector<ASTPointer<VariableDeclaration>> variables;
+			std::vector<ASTPointer<VariableDeclaration>> variables;
 			ASTPointer<Expression> value;
 			// We have already parsed something like `(,,,,a.b.c[2][3]`
 			VarDeclParserOptions options;
-			variables = vector<ASTPointer<VariableDeclaration>>(emptyComponents, nullptr);
+			variables = std::vector<ASTPointer<VariableDeclaration>>(emptyComponents, nullptr);
 			variables.push_back(parseVariableDeclaration(options, typeNameFromIndexAccessStructure(iap)));
 
 			while (m_scanner->currentToken() != Token::RParen)
@@ -1815,7 +2073,7 @@ ASTPointer<Statement> Parser::parseSimpleStatement(ASTPointer<ASTString> const&
 		case LookAheadInfo::Expression:
 		{
 			// Complete parsing the expression in the current component.
-			vector<ASTPointer<Expression>> components(emptyComponents, nullptr);
+			std::vector<ASTPointer<Expression>> components(emptyComponents, nullptr);
 			components.push_back(parseExpression(expressionFromIndexAccessStructure(iap)));
 			while (m_scanner->currentToken() != Token::RParen)
 			{
@@ -1835,7 +2093,7 @@ ASTPointer<Statement> Parser::parseSimpleStatement(ASTPointer<ASTString> const&
 	}
 	else
 	{
-		tie(statementType, iap) = tryParseIndexAccessedPath();
+		std::tie(statementType, iap) = tryParseIndexAccessedPath();
 		switch (statementType)
 		{
 		case LookAheadInfo::VariableDeclaration:
@@ -1860,7 +2118,7 @@ bool Parser::IndexAccessedPath::empty() const
 }
 
 
-pair<Parser::LookAheadInfo, Parser::IndexAccessedPath> Parser::tryParseIndexAccessedPath()
+std::pair<Parser::LookAheadInfo, Parser::IndexAccessedPath> Parser::tryParseIndexAccessedPath()
 {
 	// These two cases are very hard to distinguish:
 	// x[7 * 20 + 3] a;     and     x[7 * 20 + 3] = 9;
@@ -1874,7 +2132,10 @@ pair<Parser::LookAheadInfo, Parser::IndexAccessedPath> Parser::tryParseIndexAcce
 	{
 	case LookAheadInfo::VariableDeclaration:
 	case LookAheadInfo::Expression:
-		return make_pair(statementType, IndexAccessedPath());
+		return std::make_pair(
+			m_experimentalSolidityEnabledInCurrentSourceUnit ? LookAheadInfo::Expression : statementType,
+			IndexAccessedPath()
+		);
 	default:
 		break;
 	}
@@ -1885,10 +2146,13 @@ pair<Parser::LookAheadInfo, Parser::IndexAccessedPath> Parser::tryParseIndexAcce
 	// VariableDeclarationStatement out of it.
 	IndexAccessedPath iap = parseIndexAccessedPath();
 
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+		return std::make_pair(LookAheadInfo::Expression, std::move(iap));
+
 	if (m_scanner->currentToken() == Token::Identifier)
-		return make_pair(LookAheadInfo::VariableDeclaration, std::move(iap));
+		return std::make_pair(LookAheadInfo::VariableDeclaration, std::move(iap));
 	else
-		return make_pair(LookAheadInfo::Expression, std::move(iap));
+		return std::make_pair(LookAheadInfo::Expression, std::move(iap));
 }
 
 ASTPointer<VariableDeclarationStatement> Parser::parseVariableDeclarationStatement(
@@ -1905,7 +2169,7 @@ ASTPointer<VariableDeclarationStatement> Parser::parseVariableDeclarationStateme
 		nodeFactory.setLocation(_lookAheadArrayType->location());
 
 	VarDeclParserOptions options;
-	vector<ASTPointer<VariableDeclaration>> variables;
+	std::vector<ASTPointer<VariableDeclaration>> variables;
 	variables.emplace_back(parseVariableDeclaration(options, _lookAheadArrayType));
 	nodeFactory.setEndPositionFromNode(variables.back());
 
@@ -1966,9 +2230,9 @@ ASTPointer<Expression> Parser::parseBinaryExpression(
 	RecursionGuard recursionGuard(*this);
 	ASTPointer<Expression> expression = parseUnaryExpression(_partiallyParsedExpression);
 	ASTNodeFactory nodeFactory(*this, expression);
-	int precedence = TokenTraits::precedence(m_scanner->currentToken());
+	int precedence = tokenPrecedence(m_scanner->currentToken());
 	for (; precedence >= _minPrecedence; --precedence)
-		while (TokenTraits::precedence(m_scanner->currentToken()) == precedence)
+		while (tokenPrecedence(m_scanner->currentToken()) == precedence)
 		{
 			Token op = m_scanner->currentToken();
 			advance();
@@ -1985,6 +2249,23 @@ ASTPointer<Expression> Parser::parseBinaryExpression(
 	return expression;
 }
 
+int Parser::tokenPrecedence(Token _token) const
+{
+	if (m_experimentalSolidityEnabledInCurrentSourceUnit)
+	{
+		switch (_token)
+		{
+		case Token::Colon:
+			return 1000;
+		case Token::RightArrow:
+			return 999;
+		default:
+			break;
+		}
+	}
+	return TokenTraits::precedence(m_scanner->currentToken());
+}
+
 ASTPointer<Expression> Parser::parseUnaryExpression(
 	ASTPointer<Expression> const& _partiallyParsedExpression
 )
@@ -1993,6 +2274,10 @@ ASTPointer<Expression> Parser::parseUnaryExpression(
 	ASTNodeFactory nodeFactory = _partiallyParsedExpression ?
 		ASTNodeFactory(*this, _partiallyParsedExpression) : ASTNodeFactory(*this);
 	Token token = m_scanner->currentToken();
+
+	if (token == Token::Add)
+		fatalParserError(9636_error, "Use of unary + is disallowed.");
+
 	if (!_partiallyParsedExpression && (TokenTraits::isUnaryOp(token) || TokenTraits::isCountOp(token)))
 	{
 		// prefix expression
@@ -2131,63 +2416,78 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression(
 	}
 }
 
-ASTPointer<Expression> Parser::parsePrimaryExpression()
+ASTPointer<Expression> Parser::parseLiteral()
 {
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
-	Token token = m_scanner->currentToken();
-	ASTPointer<Expression> expression;
+	Token initialToken = m_scanner->currentToken();
+	ASTPointer<ASTString> value = std::make_shared<std::string>(m_scanner->currentLiteral());
 
-	switch (token)
+	switch (initialToken)
 	{
 	case Token::TrueLiteral:
 	case Token::FalseLiteral:
-	case Token::NullLiteral:
-	case Token::EmptyMap:
-		nodeFactory.markEndPosition();
-		expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
-		break;
 	case Token::Number:
-		if (TokenTraits::isTonSubdenomination(m_scanner->peekNextToken()))
-		{
-			ASTPointer<ASTString> literal = getLiteralAndAdvance();
-			nodeFactory.markEndPosition();
-			Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->currentToken());
-			advance();
-			expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
-		}
-		else if (TokenTraits::isTimeSubdenomination(m_scanner->peekNextToken()))
-		{
-			ASTPointer<ASTString> literal = getLiteralAndAdvance();
-			nodeFactory.markEndPosition();
-			Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->currentToken());
-			advance();
-			expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
-		}
-		else
-		{
-			nodeFactory.markEndPosition();
-			expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
-		}
+	{
+		nodeFactory.markEndPosition();
+		advance();
 		break;
+	}
 	case Token::StringLiteral:
 	case Token::UnicodeStringLiteral:
 	case Token::HexStringLiteral:
 	{
-		string literal = m_scanner->currentLiteral();
-		Token firstToken = m_scanner->currentToken();
-		while (m_scanner->peekNextToken() == firstToken)
+		while (m_scanner->peekNextToken() == initialToken)
 		{
 			advance();
-			literal += m_scanner->currentLiteral();
+			*value += m_scanner->currentLiteral();
 		}
 		nodeFactory.markEndPosition();
 		advance();
 		if (m_scanner->currentToken() == Token::Illegal)
 			fatalParserError(5428_error, to_string(m_scanner->currentError()));
-		expression = nodeFactory.createNode<Literal>(token, make_shared<ASTString>(literal));
 		break;
 	}
+	default:
+		solAssert(false);
+	}
+
+	if (initialToken == Token::Number && (
+		TokenTraits::isTonSubdenomination(m_scanner->currentToken()) ||
+		TokenTraits::isTimeSubdenomination(m_scanner->currentToken())
+	))
+	{
+		nodeFactory.markEndPosition();
+		Literal::SubDenomination subDenomination = static_cast<Literal::SubDenomination>(m_scanner->currentToken());
+		advance();
+		return nodeFactory.createNode<Literal>(initialToken, std::move(value), subDenomination);
+	}
+
+	return nodeFactory.createNode<Literal>(initialToken, std::move(value), Literal::SubDenomination::None);
+}
+
+ASTPointer<Expression> Parser::parsePrimaryExpression()
+{
+	RecursionGuard recursionGuard(*this);
+	ASTNodeFactory nodeFactory(*this);
+	Token token = m_scanner->currentToken();
+	ASTPointer<Expression> expression;
+
+	switch (token)
+	{
+	case Token::TrueLiteral:
+	case Token::FalseLiteral:
+	case Token::NullLiteral:
+	case Token::EmptyMap:
+		nodeFactory.markEndPosition();
+		expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
+		break;
+	case Token::Number:
+	case Token::StringLiteral:
+	case Token::UnicodeStringLiteral:
+	case Token::HexStringLiteral:
+		expression = parseLiteral();
+		break;
 	case Token::Identifier:
 		nodeFactory.markEndPosition();
 		expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
@@ -2196,7 +2496,7 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 		// Inside expressions "type" is the name of a special, globally-available function.
 		nodeFactory.markEndPosition();
 		advance();
-		expression = nodeFactory.createNode<Identifier>(make_shared<ASTString>("type"));
+		expression = nodeFactory.createNode<Identifier>(std::make_shared<ASTString>("type"));
 		break;
 	case Token::LParen:
 	case Token::LBrack:
@@ -2205,7 +2505,7 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 		// Special cases: ()/[] is empty tuple/array type, (x) is not a real tuple,
 		// (x,) is one-dimensional tuple, elements in arrays cannot be left out, only in tuples.
 		advance();
-		vector<ASTPointer<Expression>> components;
+		std::vector<ASTPointer<Expression>> components;
 		Token oppositeToken = (token == Token::LParen ? Token::RParen : Token::RBrack);
 		bool isArray = (token == Token::LBrack);
 
@@ -2238,7 +2538,7 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 			//used for casts
 			unsigned firstSize;
 			unsigned secondSize;
-			tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
+			std::tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
 			auto expressionType = nodeFactory.createNode<ElementaryTypeName>(
 				ElementaryTypeNameToken(m_scanner->currentToken(), firstSize, secondSize)
 			);
@@ -2262,10 +2562,10 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 	return expression;
 }
 
-vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments(Token endToken)
+std::vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments(Token endToken)
 {
 	RecursionGuard recursionGuard(*this);
-	vector<ASTPointer<Expression>> arguments;
+	std::vector<ASTPointer<Expression>> arguments;
 	if (m_scanner->currentToken() != endToken)
 	{
 		arguments.push_back(parseExpression());
@@ -2325,8 +2625,8 @@ Parser::FunctionCallArguments Parser::parseNamedArguments()
 				auto optionList = parseNamedArguments();
 				nodeFactory.markEndPosition();
 				expectToken(Token::RBrace);
-				// TODO DELETE, SAVE parameterNameLocations
-				auto expression = nodeFactory.createNode<InitializerList>(optionList.arguments, optionList.parameterNames);
+				auto expression = nodeFactory.createNode<InitializerList>(
+					optionList.arguments, optionList.parameterNames, optionList.parameterNameLocations);
 				ret.arguments.push_back(expression);
 			} else if (*ret.parameterNames.back() == "call") {
 				ASTNodeFactory nodeFactory = ASTNodeFactory(*this);
@@ -2372,17 +2672,17 @@ bool Parser::variableDeclarationStart()
 		(currentToken == Token::Function && m_scanner->peekNextToken() == Token::LParen);
 }
 
-optional<string> Parser::findLicenseString(std::vector<ASTPointer<ASTNode>> const& _nodes)
+std::optional<std::string> Parser::findLicenseString(std::vector<ASTPointer<ASTNode>> const& _nodes)
 {
 	// We circumvent the scanner here, because it skips non-docstring comments.
-	static regex const licenseNameRegex("([a-zA-Z0-9 ()+.-]+)");
-	static regex const licenseDeclarationRegex("SPDX-License-Identifier:\\s*(.+?)([\n\r]|(\\*/))");
+	static std::regex const licenseNameRegex("([a-zA-Z0-9 ()+.-]+)");
+	static std::regex const licenseDeclarationRegex("SPDX-License-Identifier:\\s*(.+?)([\n\r]|(\\*/))");
 
 	// Search inside all parts of the source not covered by parsed nodes.
 	// This will leave e.g. "global comments".
 	using iter = std::string::const_iterator;
-	vector<pair<iter, iter>> sequencesToSearch;
-	string const& source = m_scanner->charStream().source();
+	std::vector<std::pair<iter, iter>> sequencesToSearch;
+	std::string const& source = m_scanner->charStream().source();
 	sequencesToSearch.emplace_back(source.begin(), source.end());
 	for (ASTPointer<ASTNode> const& node: _nodes)
 		if (node->location().hasText())
@@ -2391,7 +2691,7 @@ optional<string> Parser::findLicenseString(std::vector<ASTPointer<ASTNode>> cons
 			sequencesToSearch.emplace_back(source.begin() + node->location().end, source.end());
 		}
 
-	vector<string> licenseNames;
+	std::vector<std::string> licenseNames;
 	for (auto const& [start, end]: sequencesToSearch)
 	{
 		auto declarationsBegin = std::sregex_iterator(start, end, licenseDeclarationRegex);
@@ -2400,11 +2700,10 @@ optional<string> Parser::findLicenseString(std::vector<ASTPointer<ASTNode>> cons
 		for (std::sregex_iterator declIt = declarationsBegin; declIt != declarationsEnd; ++declIt)
 			if (!declIt->empty())
 			{
-				string license = boost::trim_copy(string((*declIt)[1]));
+				std::string license = boost::trim_copy(std::string((*declIt)[1]));
 				licenseNames.emplace_back(std::move(license));
 			}
 	}
-
 	return {};
 }
 
@@ -2448,14 +2747,21 @@ Parser::IndexAccessedPath Parser::parseIndexAccessedPath()
 		while (m_scanner->currentToken() == Token::Period)
 		{
 			advance();
-			iap.path.push_back(parseIdentifierOrAddress());
+			if (m_experimentalSolidityEnabledInCurrentSourceUnit && m_scanner->currentToken() == Token::Number)
+			{
+				ASTNodeFactory nodeFactory(*this);
+				nodeFactory.markEndPosition();
+				iap.path.push_back(nodeFactory.createNode<Identifier>(getLiteralAndAdvance()));
+			}
+			else
+				iap.path.push_back(parseIdentifierOrAddress());
 		}
 	}
 	else
 	{
 		unsigned firstNum;
 		unsigned secondNum;
-		tie(firstNum, secondNum) = m_scanner->currentTokenInfo();
+		std::tie(firstNum, secondNum) = m_scanner->currentTokenInfo();
 		auto expressionType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(
 			ElementaryTypeNameToken(m_scanner->currentToken(), firstNum, secondNum)
 		);
@@ -2509,8 +2815,8 @@ ASTPointer<TypeName> Parser::typeNameFromIndexAccessStructure(Parser::IndexAcces
 	}
 	else
 	{
-		vector<ASTString> path;
-		vector<SourceLocation> pathLocations;
+		std::vector<ASTString> path;
+		std::vector<SourceLocation> pathLocations;
 
 		for (auto const& el: _iap.path)
 		{
@@ -2549,7 +2855,7 @@ ASTPointer<Expression> Parser::expressionFromIndexAccessStructure(
 		Identifier const& identifier = dynamic_cast<Identifier const&>(*_iap.path[i]);
 		expression = nodeFactory.createNode<MemberAccess>(
 			expression,
-			make_shared<ASTString>(identifier.name()),
+			std::make_shared<ASTString>(identifier.name()),
 			identifier.location()
 		);
 	}
@@ -2569,7 +2875,7 @@ ASTPointer<ParameterList> Parser::createEmptyParameterList()
 	RecursionGuard recursionGuard(*this);
 	ASTNodeFactory nodeFactory(*this);
 	nodeFactory.setLocationEmpty();
-	return nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
+	return nodeFactory.createNode<ParameterList>(std::vector<ASTPointer<VariableDeclaration>>());
 }
 
 ASTPointer<ASTString> Parser::expectIdentifierToken()
@@ -2583,7 +2889,7 @@ ASTPointer<ASTString> Parser::expectIdentifierTokenOrAddress()
 	ASTPointer<ASTString> result;
 	if (m_scanner->currentToken() == Token::Address)
 	{
-		result = make_shared<ASTString>("address");
+		result = std::make_shared<ASTString>("address");
 		advance();
 	}
 	else
@@ -2596,9 +2902,30 @@ ASTPointer<ASTString> Parser::expectIdentifierTokenOrAddress()
 
 ASTPointer<ASTString> Parser::getLiteralAndAdvance()
 {
-	ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->currentLiteral());
+	ASTPointer<ASTString> identifier = std::make_shared<ASTString>(m_scanner->currentLiteral());
 	advance();
 	return identifier;
 }
 
+bool Parser::isQuotedPath() const
+{
+	return m_scanner->currentToken() == Token::StringLiteral;
+}
+
+bool Parser::isStdlibPath() const
+{
+	return m_experimentalSolidityEnabledInCurrentSourceUnit
+		&& m_scanner->currentToken() == Token::Identifier
+		&& m_scanner->currentLiteral() == "std";
+}
+
+ASTPointer<ASTString> Parser::getStdlibImportPathAndAdvance()
+{
+	ASTPointer<ASTString> std = expectIdentifierToken();
+	if (m_scanner->currentToken() == Token::Period)
+		advance();
+	ASTPointer<ASTString> library = expectIdentifierToken();
+	return std::make_shared<ASTString>(*std + "." + *library);
+}
+
 }
diff --git a/compiler/libsolidity/parsing/Parser.h b/compiler/libsolidity/parsing/Parser.h
index 855cf02b..690c52bd 100644
--- a/compiler/libsolidity/parsing/Parser.h
+++ b/compiler/libsolidity/parsing/Parser.h
@@ -40,15 +40,16 @@ class Parser: public langutil::ParserBase
 public:
 	explicit Parser(
 		langutil::ErrorReporter& _errorReporter,
-		langutil::EVMVersion _evmVersion,
-		bool _errorRecovery = false
+		langutil::EVMVersion _evmVersion
 	):
-		ParserBase(_errorReporter, _errorRecovery),
+		ParserBase(_errorReporter),
 		m_evmVersion(_evmVersion)
 	{}
 
 	ASTPointer<SourceUnit> parse(langutil::CharStream& _charStream);
 
+	/// Returns the maximal AST node ID assigned so far
+	int64_t maxID() const { return m_currentNodeID; }
 private:
 	class ASTNodeFactory;
 
@@ -80,6 +81,7 @@ class Parser: public langutil::ParserBase
 		bool externalMsg = false;
 		bool internalMsg = false;
 		bool assembly = false;
+		ASTPointer<Expression> experimentalReturnExpression;
 	};
 
 	/// Struct to share parsed function call arguments.
@@ -94,7 +96,7 @@ class Parser: public langutil::ParserBase
 	///@name Parsing functions for the AST nodes
 	void parsePragmaVersion(langutil::SourceLocation const& _location, std::vector<Token> const& _tokens, std::vector<std::string> const& _literals);
 	ASTPointer<StructuredDocumentation> parseStructuredDocumentation();
-	ASTPointer<PragmaDirective> parsePragmaDirective();
+	ASTPointer<PragmaDirective> parsePragmaDirective(bool _finishedParsingTopLevelPragmas);
 	ASTPointer<ImportDirective> parseImportDirective();
 	/// @returns an std::pair<ContractKind, bool>, where
 	/// result.second is set to true, if an abstract contract was parsed, false otherwise.
@@ -105,7 +107,7 @@ class Parser: public langutil::ParserBase
 	ASTPointer<OverrideSpecifier> parseOverrideSpecifier();
 	StateMutability parseStateMutability();
 	FunctionHeaderParserResult parseFunctionHeader(bool _isStateVariable);
-	ASTPointer<ASTNode> parseFunctionDefinition(bool _freeFunction = false);
+	ASTPointer<ASTNode> parseFunctionDefinition(bool _freeFunction = false, bool _allowBody = true);
 	ASTPointer<StructDefinition> parseStructDefinition();
 	ASTPointer<EnumDefinition> parseEnumDefinition();
 	ASTPointer<UserDefinedValueTypeDefinition> parseUserDefinedValueTypeDefinition();
@@ -137,7 +139,6 @@ class Parser: public langutil::ParserBase
 	ASTPointer<Block> parseAssemblyBlock(ASTPointer<ASTString> const& _docString = {});
 	ASTPointer<Statement> parseStatement(bool _allowUncheckedBlock = false);
 	ASTPointer<Statement> parseAssemblyStatement();
-	ASTPointer<InlineAssembly> parseInlineAssembly(ASTPointer<ASTString> const& _docString = {});
 	ASTPointer<IfStatement> parseIfStatement(ASTPointer<ASTString> const& _docString);
 	ASTPointer<TryStatement> parseTryStatement(ASTPointer<ASTString> const& _docString);
 	ASTPointer<TryCatchClause> parseCatchClause();
@@ -169,6 +170,7 @@ class Parser: public langutil::ParserBase
 	ASTPointer<Expression> parseLeftHandSideExpression(
 		ASTPointer<Expression> const& _partiallyParsedExpression = ASTPointer<Expression>()
 	);
+	ASTPointer<Expression> parseLiteral();
 	ASTPointer<Expression> parsePrimaryExpression();
 	std::vector<ASTPointer<Expression>> parseFunctionCallListArguments(langutil::Token endToken = Token::RParen);
 
@@ -177,6 +179,18 @@ class Parser: public langutil::ParserBase
 	std::pair<ASTPointer<ASTString>, langutil::SourceLocation> expectIdentifierWithLocation();
 	///@}
 
+	///@{
+	///@name Specialized parsing functions for the AST nodes of experimental solidity.
+	ASTPointer<VariableDeclarationStatement> parsePostfixVariableDeclarationStatement(
+		ASTPointer<ASTString> const& _docString
+	);
+	ASTPointer<VariableDeclaration> parsePostfixVariableDeclaration();
+	ASTPointer<TypeClassDefinition> parseTypeClassDefinition();
+	ASTPointer<TypeClassInstantiation> parseTypeClassInstantiation();
+	ASTPointer<TypeDefinition> parseTypeDefinition();
+	ASTPointer<TypeClassName> parseTypeClassName();
+	///@}
+
 	///@{
 	///@name Helper functions
 
@@ -228,6 +242,13 @@ class Parser: public langutil::ParserBase
 	ASTPointer<ASTString> getLiteralAndAdvance();
 	///@}
 
+	bool isQuotedPath() const;
+	bool isStdlibPath() const;
+
+	int tokenPrecedence(Token _token) const;
+
+	ASTPointer<ASTString> getStdlibImportPathAndAdvance();
+
 	/// Creates an empty ParameterList at the current location (used if parameters can be omitted).
 	ASTPointer<ParameterList> createEmptyParameterList();
 
@@ -236,8 +257,8 @@ class Parser: public langutil::ParserBase
 	langutil::EVMVersion m_evmVersion;
 	/// Counter for the next AST node ID
 	int64_t m_currentNodeID = 0;
-	
-	bool m_insideFunctionDefenition = false;
+	/// Flag that indicates whether experimental mode is enabled in the current source unit
+	bool m_experimentalSolidityEnabledInCurrentSourceUnit = false;
 };
 
 }
diff --git a/compiler/libsolutil/AnsiColorized.h b/compiler/libsolutil/AnsiColorized.h
index 69d10d72..08b4a4d2 100644
--- a/compiler/libsolutil/AnsiColorized.h
+++ b/compiler/libsolutil/AnsiColorized.h
@@ -52,6 +52,7 @@ static constexpr char const* BLUE_BACKGROUND = "\033[44m";
 static constexpr char const* MAGENTA_BACKGROUND = "\033[45m";
 static constexpr char const* CYAN_BACKGROUND = "\033[46m";
 static constexpr char const* WHITE_BACKGROUND = "\033[47m";
+static constexpr char const* GRAY_BACKGROUND = "\033[100m";
 
 // 256-bit-colors (incomplete set)
 static constexpr char const* RED_BACKGROUND_256 = "\033[48;5;160m";
diff --git a/compiler/libsolutil/CMakeLists.txt b/compiler/libsolutil/CMakeLists.txt
index 363baba1..f97d61b6 100644
--- a/compiler/libsolutil/CMakeLists.txt
+++ b/compiler/libsolutil/CMakeLists.txt
@@ -13,8 +13,6 @@ set(sources
 	ErrorCodes.h
 	FixedHash.h
 	FunctionSelector.h
-	IndentedWriter.cpp
-	IndentedWriter.h
 	IpfsHash.cpp
 	IpfsHash.h
 	JSON.cpp
@@ -33,6 +31,8 @@ set(sources
 	StringUtils.h
 	SwarmHash.cpp
 	SwarmHash.h
+	TemporaryDirectory.cpp
+	TemporaryDirectory.h
 	UTF8.cpp
 	UTF8.h
 	vector_ref.h
@@ -43,8 +43,8 @@ set(sources
 )
 
 add_library(solutil ${sources})
-target_link_libraries(solutil PUBLIC jsoncpp Boost::boost Boost::filesystem Boost::system range-v3)
-target_include_directories(solutil PUBLIC "${CMAKE_SOURCE_DIR}")
+target_link_libraries(solutil PUBLIC jsoncpp Boost::boost Boost::filesystem Boost::system range-v3 fmt::fmt-header-only)
+target_include_directories(solutil PUBLIC "${PROJECT_SOURCE_DIR}")
 add_dependencies(solutil solidity_BuildInfo.h)
 
 if(SOLC_LINK_STATIC)
diff --git a/compiler/libsolutil/Common.h b/compiler/libsolutil/Common.h
index 5c781461..c908c13a 100644
--- a/compiler/libsolutil/Common.h
+++ b/compiler/libsolutil/Common.h
@@ -41,15 +41,13 @@
 #include <libsolutil/vector_ref.h>
 
 #include <boost/version.hpp>
-#if (BOOST_VERSION < 106500)
-#error "Unsupported Boost version. At least 1.65 required."
-#endif
 
+#include <cstdint>
+#include <functional>
 #include <map>
+#include <string>
 #include <utility>
 #include <vector>
-#include <functional>
-#include <string>
 
 namespace solidity
 {
diff --git a/compiler/libsolutil/CommonData.cpp b/compiler/libsolutil/CommonData.cpp
index 437a090c..69f08308 100644
--- a/compiler/libsolutil/CommonData.cpp
+++ b/compiler/libsolutil/CommonData.cpp
@@ -29,7 +29,6 @@
 
 #include <boost/algorithm/string.hpp>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 
@@ -41,7 +40,7 @@ static char const* lowerHexChars = "0123456789abcdef";
 
 }
 
-string solidity::util::toHex(uint8_t _data, HexCase _case)
+std::string solidity::util::toHex(uint8_t _data, HexCase _case)
 {
 	assertThrow(_case != HexCase::Mixed, BadHexCase, "Mixed case can only be used for byte arrays.");
 
@@ -53,7 +52,7 @@ string solidity::util::toHex(uint8_t _data, HexCase _case)
 	};
 }
 
-string solidity::util::toHex(bytes const& _data, HexPrefix _prefix, HexCase _case)
+std::string solidity::util::toHex(bytes const& _data, HexPrefix _prefix, HexCase _case)
 {
 	std::string ret(_data.size() * 2 + (_prefix == HexPrefix::Add ? 2 : 0), 0);
 
@@ -90,7 +89,7 @@ int solidity::util::fromHex(char _i, WhenError _throw)
 	if (_i >= 'A' && _i <= 'F')
 		return _i - 'A' + 10;
 	if (_throw == WhenError::Throw)
-		assertThrow(false, BadHexCharacter, to_string(_i));
+		assertThrow(false, BadHexCharacter, std::to_string(_i));
 	else
 		return -1;
 }
@@ -125,31 +124,31 @@ bytes solidity::util::fromHex(std::string const& _s, WhenError _throw)
 }
 
 
-bool solidity::util::passesAddressChecksum(string const& _str, bool _strict)
+bool solidity::util::passesAddressChecksum(std::string const& _str, bool _strict)
 {
-	string s = _str.substr(0, 2) == "0x" ? _str : "0x" + _str;
+	std::string s = _str.substr(0, 2) == "0x" ? _str : "0x" + _str;
 
 	if (s.length() != 42)
 		return false;
 
 	if (!_strict && (
-		s.find_first_of("abcdef") == string::npos ||
-		s.find_first_of("ABCDEF") == string::npos
+		s.find_first_of("abcdef") == std::string::npos ||
+		s.find_first_of("ABCDEF") == std::string::npos
 	))
 		return true;
 
 	return s == solidity::util::getChecksummedAddress(s);
 }
 
-string solidity::util::getChecksummedAddress(string const& _addr)
+std::string solidity::util::getChecksummedAddress(std::string const& _addr)
 {
-	string s = _addr.substr(0, 2) == "0x" ? _addr.substr(2) : _addr;
+	std::string s = _addr.substr(0, 2) == "0x" ? _addr.substr(2) : _addr;
 	assertThrow(s.length() == 40, InvalidAddress, "");
-	assertThrow(s.find_first_not_of("0123456789abcdefABCDEF") == string::npos, InvalidAddress, "");
+	assertThrow(s.find_first_not_of("0123456789abcdefABCDEF") == std::string::npos, InvalidAddress, "");
 
 	h256 hash = keccak256(boost::algorithm::to_lower_copy(s, std::locale::classic()));
 
-	string ret = "0x";
+	std::string ret = "0x";
 	for (unsigned i = 0; i < 40; ++i)
 	{
 		char addressCharacter = s[i];
@@ -162,16 +161,16 @@ string solidity::util::getChecksummedAddress(string const& _addr)
 	return ret;
 }
 
-bool solidity::util::isValidHex(string const& _string)
+bool solidity::util::isValidHex(std::string const& _string)
 {
 	if (_string.substr(0, 2) != "0x")
 		return false;
-	if (_string.find_first_not_of("0123456789abcdefABCDEF", 2) != string::npos)
+	if (_string.find_first_not_of("0123456789abcdefABCDEF", 2) != std::string::npos)
 		return false;
 	return true;
 }
 
-bool solidity::util::isValidDecimal(string const& _string)
+bool solidity::util::isValidDecimal(std::string const& _string)
 {
 	if (_string.empty())
 		return false;
@@ -180,12 +179,12 @@ bool solidity::util::isValidDecimal(string const& _string)
 	// No leading zeros
 	if (_string.front() == '0')
 		return false;
-	if (_string.find_first_not_of("0123456789") != string::npos)
+	if (_string.find_first_not_of("0123456789") != std::string::npos)
 		return false;
 	return true;
 }
 
-string solidity::util::formatAsStringOrNumber(string const& _value)
+std::string solidity::util::formatAsStringOrNumber(std::string const& _value)
 {
 	assertThrow(_value.length() <= 32, StringTooLong, "String to be formatted longer than 32 bytes.");
 
@@ -197,9 +196,9 @@ string solidity::util::formatAsStringOrNumber(string const& _value)
 }
 
 
-string solidity::util::escapeAndQuoteString(string const& _input)
+std::string solidity::util::escapeAndQuoteString(std::string const& _input)
 {
-	string out;
+	std::string out;
 
 	for (char c: _input)
 		if (c == '\\')
@@ -214,8 +213,8 @@ string solidity::util::escapeAndQuoteString(string const& _input)
 			out += "\\t";
 		else if (!isPrint(c))
 		{
-			ostringstream o;
-			o << "\\x" << std::hex << setfill('0') << setw(2) << (unsigned)(unsigned char)(c);
+			std::ostringstream o;
+			o << "\\x" << std::hex << std::setfill('0') << std::setw(2) << (unsigned)(unsigned char)(c);
 			out += o.str();
 		}
 		else
diff --git a/compiler/libsolutil/CommonData.h b/compiler/libsolutil/CommonData.h
index b117c277..f3c168e6 100644
--- a/compiler/libsolutil/CommonData.h
+++ b/compiler/libsolutil/CommonData.h
@@ -267,7 +267,7 @@ template<
 	typename MapType,
 	typename KeyType,
 	typename ValueType = std::decay_t<decltype(std::declval<MapType>().find(std::declval<KeyType>())->second)> const&,
-	typename AllowCopyType = std::conditional_t<std::is_pod_v<ValueType> || std::is_pointer_v<ValueType>, detail::allow_copy, void*>
+	typename AllowCopyType = std::conditional_t<(std::is_trivial_v<ValueType> && std::is_standard_layout_v<ValueType>) || std::is_pointer_v<ValueType>, detail::allow_copy, void*>
 >
 decltype(auto) valueOrDefault(
 	MapType&& _map,
diff --git a/compiler/libsolutil/CommonIO.cpp b/compiler/libsolutil/CommonIO.cpp
index 6089f4db..06ce23a0 100644
--- a/compiler/libsolutil/CommonIO.cpp
+++ b/compiler/libsolutil/CommonIO.cpp
@@ -31,7 +31,6 @@
 #include <termios.h>
 #endif
 
-using namespace std;
 using namespace solidity::util;
 
 namespace
@@ -55,35 +54,35 @@ inline T readFile(boost::filesystem::path const& _file)
 
 	// get length of file:
 	is.seekg(0, is.end);
-	streamoff length = is.tellg();
+	std::streamoff length = is.tellg();
 	if (length == 0)
 		return ret; // do not read empty file (MSVC does not like it)
 	is.seekg(0, is.beg);
 
 	ret.resize((static_cast<size_t>(length) + c_elementSize - 1) / c_elementSize);
-	is.read(const_cast<char*>(reinterpret_cast<char const*>(ret.data())), static_cast<streamsize>(length));
+	is.read(const_cast<char*>(reinterpret_cast<char const*>(ret.data())), static_cast<std::streamsize>(length));
 	return ret;
 }
 
 }
 
-string solidity::util::readFileAsString(boost::filesystem::path const& _file)
+std::string solidity::util::readFileAsString(boost::filesystem::path const& _file)
 {
-	return readFile<string>(_file);
+	return readFile<std::string>(_file);
 }
 
-string solidity::util::readUntilEnd(istream& _stdin)
+std::string solidity::util::readUntilEnd(std::istream& _stdin)
 {
-	ostringstream ss;
+	std::ostringstream ss;
 	ss << _stdin.rdbuf();
 	return ss.str();
 }
 
-string solidity::util::readBytes(istream& _input, size_t _length)
+std::string solidity::util::readBytes(std::istream& _input, size_t _length)
 {
-	string output;
+	std::string output;
 	output.resize(_length);
-	_input.read(output.data(), static_cast<streamsize>(_length));
+	_input.read(output.data(), static_cast<std::streamsize>(_length));
 	// If read() reads fewer bytes it sets failbit in addition to eofbit.
 	if (_input.fail())
 		output.resize(static_cast<size_t>(_input.gcount()));
@@ -135,10 +134,10 @@ class DisableConsoleBuffering
 int solidity::util::readStandardInputChar()
 {
 	DisableConsoleBuffering disableConsoleBuffering;
-	return cin.get();
+	return std::cin.get();
 }
 
-string solidity::util::absolutePath(string const& _path, string const& _reference)
+std::string solidity::util::absolutePath(std::string const& _path, std::string const& _reference)
 {
 	boost::filesystem::path p(_path);
 	// Anything that does not start with `.` is an absolute path.
@@ -158,6 +157,6 @@ string solidity::util::absolutePath(string const& _path, string const& _referenc
 	return result.generic_string();
 }
 
-string solidity::util::sanitizePath(string const& _path) {
+std::string solidity::util::sanitizePath(std::string const& _path) {
 	return boost::filesystem::path(_path).generic_string();
 }
diff --git a/compiler/libsolutil/Exceptions.cpp b/compiler/libsolutil/Exceptions.cpp
index fa4021d3..00fe3e26 100644
--- a/compiler/libsolutil/Exceptions.cpp
+++ b/compiler/libsolutil/Exceptions.cpp
@@ -18,13 +18,12 @@
 
 #include <libsolutil/Exceptions.h>
 
-using namespace std;
 using namespace solidity::util;
 
 char const* Exception::what() const noexcept
 {
 	// Return the comment if available.
-	if (string const* cmt = comment())
+	if (std::string const* cmt = comment())
 		return cmt->data();
 
 	// Fallback to base what().
@@ -33,20 +32,20 @@ char const* Exception::what() const noexcept
 	return std::exception::what();
 }
 
-string Exception::lineInfo() const
+std::string Exception::lineInfo() const
 {
 	char const* const* file = boost::get_error_info<boost::throw_file>(*this);
 	int const* line = boost::get_error_info<boost::throw_line>(*this);
-	string ret;
+	std::string ret;
 	if (file)
 		ret += *file;
 	ret += ':';
 	if (line)
-		ret += to_string(*line);
+		ret += std::to_string(*line);
 	return ret;
 }
 
-string const* Exception::comment() const noexcept
+std::string const* Exception::comment() const noexcept
 {
 	return boost::get_error_info<errinfo_comment>(*this);
 }
diff --git a/compiler/libsolutil/Exceptions.h b/compiler/libsolutil/Exceptions.h
index 8ac7a5fa..9d73a001 100644
--- a/compiler/libsolutil/Exceptions.h
+++ b/compiler/libsolutil/Exceptions.h
@@ -54,6 +54,15 @@ struct Exception: virtual std::exception, virtual boost::exception
 		::boost::throw_line(__LINE__) \
 	)
 
+/// Throws an exception if condition is not met with a given description and extra information about the location the
+/// exception was thrown from.
+/// @param _condition if condition is not met, specified exception will be thrown.
+/// @param _exceptionType The type of the exception to throw (not an instance).
+/// @param _description The message that describes the error.
+#define solRequire(_condition, _exceptionType, _description) \
+	if (!(_condition)) \
+		solThrow(_exceptionType, (_description))
+
 /// Defines an exception type that's meant to signal a specific condition and be caught rather than
 /// unwind the stack all the way to the top-level exception handler and interrupt the program.
 /// As such it does not carry a message - the code catching it is expected to handle it without
diff --git a/compiler/libsolutil/FixedHash.h b/compiler/libsolutil/FixedHash.h
index 97a80603..c4c72e9e 100644
--- a/compiler/libsolutil/FixedHash.h
+++ b/compiler/libsolutil/FixedHash.h
@@ -61,7 +61,7 @@ class FixedHash
 	explicit FixedHash() { m_data.fill(0); }
 
 	/// Construct from another hash, filling with zeroes or cropping as necessary.
-	template <unsigned M> explicit FixedHash(FixedHash<M> const& _h, ConstructFromHashType _t = AlignLeft)
+	template <unsigned M> explicit FixedHash(FixedHash<M> const& _h, ConstructFromHashType _t)
 	{
 		m_data.fill(0);
 		unsigned c = std::min(M, N);
diff --git a/compiler/libsolutil/FunctionSelector.h b/compiler/libsolutil/FunctionSelector.h
index da6feb4e..2712f6ba 100644
--- a/compiler/libsolutil/FunctionSelector.h
+++ b/compiler/libsolutil/FunctionSelector.h
@@ -26,17 +26,22 @@
 namespace solidity::util
 {
 
+/// @returns the ABI selector for a given function signature, as a FixedHash h32.
+inline FixedHash<4> selectorFromSignatureH32(std::string const& _signature)
+{
+	return FixedHash<4>(util::keccak256(_signature), FixedHash<4>::AlignLeft);
+}
+
 /// @returns the ABI selector for a given function signature, as a 32 bit number.
-inline uint32_t selectorFromSignature32(std::string const& _signature)
+inline uint32_t selectorFromSignatureU32(std::string const& _signature)
 {
-	return uint32_t(FixedHash<4>::Arith(util::FixedHash<4>(util::keccak256(_signature))));
+	return uint32_t(FixedHash<4>::Arith(selectorFromSignatureH32(_signature)));
 }
 
 /// @returns the ABI selector for a given function signature, as a u256 (left aligned) number.
-inline u256 selectorFromSignature(std::string const& _signature)
+inline u256 selectorFromSignatureU256(std::string const& _signature)
 {
-	return u256(selectorFromSignature32(_signature)) << (256 - 32);
+	return u256(selectorFromSignatureU32(_signature)) << (256 - 32);
 }
 
-
 }
diff --git a/compiler/libsolutil/IndentedWriter.cpp b/compiler/libsolutil/IndentedWriter.cpp
deleted file mode 100644
index 0e0aded3..00000000
--- a/compiler/libsolutil/IndentedWriter.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * @date 2017
- * Indented text writer.
- */
-
-#include <libsolutil/IndentedWriter.h>
-#include <libsolutil/Assertions.h>
-
-using namespace std;
-using namespace solidity::util;
-
-string IndentedWriter::format() const
-{
-	string result;
-	for (auto const& line: m_lines)
-		result += string(line.indentation * 4, ' ') + line.contents + "\n";
-	return result;
-}
-
-void IndentedWriter::newLine()
-{
-	if (!m_lines.back().contents.empty())
-		m_lines.emplace_back(Line{string(), m_lines.back().indentation});
-}
-
-void IndentedWriter::indent()
-{
-	newLine();
-	m_lines.back().indentation++;
-}
-
-void IndentedWriter::unindent()
-{
-	newLine();
-	assertThrow(m_lines.back().indentation > 0, IndentedWriterError, "Negative indentation.");
-	m_lines.back().indentation--;
-}
-
-void IndentedWriter::add(string const& _str)
-{
-	m_lines.back().contents += _str;
-}
-
-void IndentedWriter::addLine(string const& _line)
-{
-	newLine();
-	add(_line);
-	newLine();
-}
diff --git a/compiler/libsolutil/IndentedWriter.h b/compiler/libsolutil/IndentedWriter.h
deleted file mode 100644
index 47e2817f..00000000
--- a/compiler/libsolutil/IndentedWriter.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * @date 2017
- * Indented text writer.
- */
-
-#pragma once
-
-#include <vector>
-#include <string>
-
-#include <libsolutil/Exceptions.h>
-
-namespace solidity::util
-{
-
-DEV_SIMPLE_EXCEPTION(IndentedWriterError);
-
-class IndentedWriter
-{
-public:
-	// Returns the formatted output.
-	std::string format() const;
-
-	// Go one indentation level in.
-	void indent();
-
-	// Go one indentation level out.
-	void unindent();
-
-	// Add text.
-	void add(std::string const& _str);
-
-	// Add text with new line.
-	void addLine(std::string const& _line);
-
-	// Add new line.
-	void newLine();
-
-private:
-	struct Line
-	{
-		std::string contents;
-		unsigned indentation;
-	};
-
-	std::vector<Line> m_lines{{std::string(), 0}};
-};
-
-}
diff --git a/compiler/libsolutil/IpfsHash.cpp b/compiler/libsolutil/IpfsHash.cpp
index dbf411dc..3599b712 100644
--- a/compiler/libsolutil/IpfsHash.cpp
+++ b/compiler/libsolutil/IpfsHash.cpp
@@ -23,7 +23,6 @@
 #include <libsolutil/CommonData.h>
 #include <libsolutil/Numeric.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 
@@ -56,11 +55,11 @@ bytes encodeLinkData(bytes const& _data)
 	return bytes{0x12} + varintEncoding(_data.size()) + _data;
 }
 
-string base58Encode(bytes const& _data)
+std::string base58Encode(bytes const& _data)
 {
-	static string const alphabet{"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"};
+	static std::string const alphabet{"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"};
 	bigint data(util::toHex(_data, HexPrefix::Add));
-	string output;
+	std::string output;
 	while (data)
 	{
 		output += alphabet[static_cast<size_t>(data % alphabet.size())];
@@ -84,7 +83,7 @@ struct Chunk
 	size_t blockSize = 0;
 };
 
-using Chunks = vector<Chunk>;
+using Chunks = std::vector<Chunk>;
 
 Chunk combineLinks(Chunks& _links)
 {
@@ -153,7 +152,7 @@ bytes groupChunksBottomUp(Chunks _currentLevel)
 }
 }
 
-bytes solidity::util::ipfsHash(string _data)
+bytes solidity::util::ipfsHash(std::string _data)
 {
 	size_t const maxChunkSize = 1024 * 256;
 	size_t chunkCount = _data.length() / maxChunkSize + (_data.length() % maxChunkSize > 0 ? 1 : 0);
@@ -164,7 +163,7 @@ bytes solidity::util::ipfsHash(string _data)
 	for (size_t chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
 	{
 		bytes chunkBytes = asBytes(
-			_data.substr(chunkIndex * maxChunkSize, min(maxChunkSize, _data.length() - chunkIndex * maxChunkSize))
+			_data.substr(chunkIndex * maxChunkSize, std::min(maxChunkSize, _data.length() - chunkIndex * maxChunkSize))
 		);
 
 		bytes lengthAsVarint = varintEncoding(chunkBytes.size());
@@ -197,7 +196,7 @@ bytes solidity::util::ipfsHash(string _data)
 	return groupChunksBottomUp(std::move(allChunks));
 }
 
-string solidity::util::ipfsHashBase58(string _data)
+std::string solidity::util::ipfsHashBase58(std::string _data)
 {
 	return base58Encode(ipfsHash(std::move(_data)));
 }
diff --git a/compiler/libsolutil/JSON.cpp b/compiler/libsolutil/JSON.cpp
index d27982ac..ea75ada0 100644
--- a/compiler/libsolutil/JSON.cpp
+++ b/compiler/libsolutil/JSON.cpp
@@ -30,8 +30,6 @@
 #include <map>
 #include <memory>
 
-using namespace std;
-
 static_assert(
 	(JSONCPP_VERSION_MAJOR == 1) && (JSONCPP_VERSION_MINOR == 9) && (JSONCPP_VERSION_PATCH == 3),
 	"Unexpected jsoncpp version: " JSONCPP_VERSION_STRING ". Expecting 1.9.3."
@@ -47,7 +45,7 @@ namespace
 class StreamWriterBuilder: public Json::StreamWriterBuilder
 {
 public:
-	explicit StreamWriterBuilder(map<string, Json::Value> const& _settings)
+	explicit StreamWriterBuilder(std::map<std::string, Json::Value> const& _settings)
 	{
 		for (auto const& iter: _settings)
 			this->settings_[iter.first] = iter.second;
@@ -68,10 +66,10 @@ class StrictModeCharReaderBuilder: public Json::CharReaderBuilder
 /// \param _input JSON input string
 /// \param _builder StreamWriterBuilder that is used to create new Json::StreamWriter
 /// \return serialized json object
-string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builder)
+std::string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builder)
 {
-	stringstream stream;
-	unique_ptr<Json::StreamWriter> writer(_builder.newStreamWriter());
+	std::stringstream stream;
+	std::unique_ptr<Json::StreamWriter> writer(_builder.newStreamWriter());
 	writer->write(_input, &stream);
 	return stream.str();
 }
@@ -82,9 +80,9 @@ string print(Json::Value const& _input, Json::StreamWriterBuilder const& _builde
 /// \param _json [out] resulting JSON object
 /// \param _errs [out] Formatted error messages
 /// \return \c true if the document was successfully parsed, \c false if an error occurred.
-bool parse(Json::CharReaderBuilder& _builder, string const& _input, Json::Value& _json, string* _errs)
+bool parse(Json::CharReaderBuilder& _builder, std::string const& _input, Json::Value& _json, std::string* _errs)
 {
-	unique_ptr<Json::CharReader> reader(_builder.newCharReader());
+	std::unique_ptr<Json::CharReader> reader(_builder.newCharReader());
 	return reader->parse(_input.c_str(), _input.c_str() + _input.length(), &_json, _errs);
 }
 
@@ -113,37 +111,52 @@ Json::Value removeNullMembers(Json::Value _json)
 	return _json;
 }
 
-string jsonPrettyPrint(Json::Value const& _input)
+std::string jsonPrettyPrint(Json::Value const& _input)
 {
 	return jsonPrint(_input, JsonFormat{ JsonFormat::Pretty });
 }
 
-string jsonCompactPrint(Json::Value const& _input)
+std::string jsonCompactPrint(Json::Value const& _input)
 {
 	return jsonPrint(_input, JsonFormat{ JsonFormat::Compact });
 }
 
-string jsonPrint(Json::Value const& _input, JsonFormat const& _format)
+std::string jsonPrint(Json::Value const& _input, JsonFormat const& _format)
 {
-	map<string, Json::Value> settings;
+	std::map<std::string, Json::Value> settings;
 	if (_format.format == JsonFormat::Pretty)
 	{
-		settings["indentation"] = string(_format.indent, ' ');
+		settings["indentation"] = std::string(_format.indent, ' ');
 		settings["enableYAMLCompatibility"] = true;
 	}
 	else
 		settings["indentation"] = "";
 	StreamWriterBuilder writerBuilder(settings);
-	string result = print(_input, writerBuilder);
+	std::string result = print(_input, writerBuilder);
 	if (_format.format == JsonFormat::Pretty)
 		boost::replace_all(result, " \n", "\n");
 	return result;
 }
 
-bool jsonParseStrict(string const& _input, Json::Value& _json, string* _errs /* = nullptr */)
+bool jsonParseStrict(std::string const& _input, Json::Value& _json, std::string* _errs /* = nullptr */)
 {
 	static StrictModeCharReaderBuilder readerBuilder;
 	return parse(readerBuilder, _input, _json, _errs);
 }
 
+std::optional<Json::Value> jsonValueByPath(Json::Value const& _node, std::string_view _jsonPath)
+{
+	if (!_node.isObject() || _jsonPath.empty())
+		return {};
+
+	std::string memberName = std::string(_jsonPath.substr(0, _jsonPath.find_first_of('.')));
+	if (!_node.isMember(memberName))
+		return {};
+
+	if (memberName == _jsonPath)
+		return _node[memberName];
+
+	return jsonValueByPath(_node[memberName], _jsonPath.substr(memberName.size() + 1));
+}
+
 } // namespace solidity::util
diff --git a/compiler/libsolutil/JSON.h b/compiler/libsolutil/JSON.h
index 43dddfd4..f368739e 100644
--- a/compiler/libsolutil/JSON.h
+++ b/compiler/libsolutil/JSON.h
@@ -26,6 +26,8 @@
 #include <json/json.h>
 
 #include <string>
+#include <string_view>
+#include <optional>
 
 namespace solidity::util
 {
@@ -67,4 +69,73 @@ std::string jsonPrint(Json::Value const& _input, JsonFormat const& _format);
 /// \return \c true if the document was successfully parsed, \c false if an error occurred.
 bool jsonParseStrict(std::string const& _input, Json::Value& _json, std::string* _errs = nullptr);
 
+/// Retrieves the value specified by @p _jsonPath by from a series of nested JSON dictionaries.
+/// @param _jsonPath A dot-separated series of dictionary keys.
+/// @param _node The node representing the start of the path.
+/// @returns The value of the last key on the path. @a nullptr if any node on the path descends
+/// into something that is not a dictionary or the key is not present.
+std::optional<Json::Value> jsonValueByPath(Json::Value const& _node, std::string_view _jsonPath);
+
+namespace detail
+{
+
+template<typename T>
+struct helper;
+
+template<typename T, bool(Json::Value::*checkMember)() const, T(Json::Value::*convertMember)() const>
+struct helper_impl
+{
+	static bool isOfType(Json::Value const& _input)
+	{
+		return (_input.*checkMember)();
+	}
+	static T get(Json::Value const& _input)
+	{
+		return (_input.*convertMember)();
+	}
+	static T getOrDefault(Json::Value const& _input, T _default = {})
+	{
+		T result = _default;
+		if (isOfType(_input))
+			result = (_input.*convertMember)();
+		return result;
+	}
+};
+
+template<> struct helper<float>: helper_impl<float, &Json::Value::isDouble, &Json::Value::asFloat> {};
+template<> struct helper<double>: helper_impl<double, &Json::Value::isDouble, &Json::Value::asDouble> {};
+template<> struct helper<std::string>: helper_impl<std::string, &Json::Value::isString, &Json::Value::asString> {};
+template<> struct helper<Json::Int>: helper_impl<Json::Int, &Json::Value::isInt, &Json::Value::asInt> {};
+template<> struct helper<Json::Int64>: helper_impl<Json::Int64, &Json::Value::isInt64, &Json::Value::asInt64> {};
+template<> struct helper<Json::UInt>: helper_impl<Json::UInt, &Json::Value::isUInt, &Json::Value::asUInt> {};
+template<> struct helper<Json::UInt64>: helper_impl<Json::UInt64, &Json::Value::isUInt64, &Json::Value::asUInt64> {};
+
+} // namespace detail
+
+template<typename T>
+bool isOfType(Json::Value const& _input)
+{
+	return detail::helper<T>::isOfType(_input);
+}
+
+template<typename T>
+bool isOfTypeIfExists(Json::Value const& _input, std::string const& _name)
+{
+	if (_input.isMember(_name))
+		return isOfType<T>(_input[_name]);
+	return true;
 }
+
+template<typename T>
+T get(Json::Value const& _input)
+{
+	return detail::helper<T>::get(_input);
+}
+
+template<typename T>
+T getOrDefault(Json::Value const& _input, T _default = {})
+{
+	return detail::helper<T>::getOrDefault(_input, _default);
+}
+
+} // namespace solidity::util
diff --git a/compiler/libsolutil/Keccak256.cpp b/compiler/libsolutil/Keccak256.cpp
index 21280490..c54dedab 100644
--- a/compiler/libsolutil/Keccak256.cpp
+++ b/compiler/libsolutil/Keccak256.cpp
@@ -25,8 +25,6 @@
 #include <cstdint>
 #include <cstring>
 
-using namespace std;
-
 namespace solidity::util
 {
 
diff --git a/compiler/libsolutil/Numeric.h b/compiler/libsolutil/Numeric.h
index c0f33e49..be9f0bea 100644
--- a/compiler/libsolutil/Numeric.h
+++ b/compiler/libsolutil/Numeric.h
@@ -25,9 +25,6 @@
 #include <libsolutil/CommonData.h>
 
 #include <boost/version.hpp>
-#if (BOOST_VERSION < 106500)
-#error "Unsupported Boost version. At least 1.65 required."
-#endif
 
 // TODO: do this only conditionally as soon as a boost version with gcc 12 support is released.
 #if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ >= 12)
diff --git a/compiler/libsolutil/StringUtils.cpp b/compiler/libsolutil/StringUtils.cpp
index a994b07c..f5d2bbfb 100644
--- a/compiler/libsolutil/StringUtils.cpp
+++ b/compiler/libsolutil/StringUtils.cpp
@@ -23,13 +23,17 @@
  */
 
 #include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string/trim.hpp>
+
+#include <sstream>
 #include <string>
 #include <vector>
 
-using namespace std;
+using namespace solidity;
 using namespace solidity::util;
 
-bool solidity::util::stringWithinDistance(string const& _str1, string const& _str2, size_t _maxDistance, size_t _lenThreshold)
+bool solidity::util::stringWithinDistance(std::string const& _str1, std::string const& _str2, size_t _maxDistance, size_t _lenThreshold)
 {
 	if (_str1 == _str2)
 		return true;
@@ -46,13 +50,13 @@ bool solidity::util::stringWithinDistance(string const& _str1, string const& _st
 	return distance <= _maxDistance && distance < n1 && distance < n2;
 }
 
-size_t solidity::util::stringDistance(string const& _str1, string const& _str2)
+size_t solidity::util::stringDistance(std::string const& _str1, std::string const& _str2)
 {
 	size_t n1 = _str1.size();
 	size_t n2 = _str2.size();
 	// Optimize by storing only last 2 rows and current row. So first index is considered modulo 3
 	// This is a two-dimensional array of size 3 x (n2 + 1).
-	vector<size_t> dp(3 * (n2 + 1));
+	std::vector<size_t> dp(3 * (n2 + 1));
 
 	// In this dp formulation of Damerau–Levenshtein distance we are assuming that the strings are 1-based to make base case storage easier.
 	// So index accesser to _name1 and _name2 have to be adjusted accordingly
@@ -60,25 +64,25 @@ size_t solidity::util::stringDistance(string const& _str1, string const& _str2)
 		for (size_t i2 = 0; i2 <= n2; ++i2)
 		{
 			size_t x = 0;
-			if (min(i1, i2) == 0) // base case
-				x = max(i1, i2);
+			if (std::min(i1, i2) == 0) // base case
+				x = std::max(i1, i2);
 			else
 			{
 				size_t left = dp[(i1 - 1) % 3 + i2 * 3];
 				size_t up = dp[(i1 % 3) + (i2 - 1) * 3];
 				size_t upleft = dp[((i1 - 1) % 3) + (i2 - 1) * 3];
 				// deletion and insertion
-				x = min(left + 1, up + 1);
+				x = std::min(left + 1, up + 1);
 				if (_str1[i1-1] == _str2[i2-1])
 					// same chars, can skip
-					x = min(x, upleft);
+					x = std::min(x, upleft);
 				else
 					// different chars so try substitution
-					x = min(x, upleft + 1);
+					x = std::min(x, upleft + 1);
 
 				// transposing
 				if (i1 > 1 && i2 > 1 && _str1[i1 - 1] == _str2[i2 - 2] && _str1[i1 - 2] == _str2[i2 - 1])
-					x = min(x, dp[((i1 - 2) % 3) + (i2 - 2) * 3] + 1);
+					x = std::min(x, dp[((i1 - 2) % 3) + (i2 - 2) * 3] + 1);
 			}
 			dp[(i1 % 3) + i2 * 3] = x;
 		}
@@ -86,9 +90,9 @@ size_t solidity::util::stringDistance(string const& _str1, string const& _str2)
 	return dp[(n1 % 3) + n2 * 3];
 }
 
-string solidity::util::quotedAlternativesList(vector<string> const& suggestions)
+std::string solidity::util::quotedAlternativesList(std::vector<std::string> const& suggestions)
 {
-	vector<string> quotedSuggestions;
+	std::vector<std::string> quotedSuggestions;
 
 	for (auto& suggestion: suggestions)
 		quotedSuggestions.emplace_back("\"" + suggestion + "\"");
@@ -96,20 +100,128 @@ string solidity::util::quotedAlternativesList(vector<string> const& suggestions)
 	return joinHumanReadable(quotedSuggestions, ", ", " or ");
 }
 
-string solidity::util::suffixedVariableNameList(string const& _baseName, size_t _startSuffix, size_t _endSuffix)
+std::string solidity::util::suffixedVariableNameList(std::string const& _baseName, size_t _startSuffix, size_t _endSuffix)
 {
-	string result;
+	std::string result;
 	if (_startSuffix < _endSuffix)
 	{
-		result = _baseName + to_string(_startSuffix++);
+		result = _baseName + std::to_string(_startSuffix++);
 		while (_startSuffix < _endSuffix)
-			result += ", " + _baseName + to_string(_startSuffix++);
+			result += ", " + _baseName + std::to_string(_startSuffix++);
 	}
 	else if (_endSuffix < _startSuffix)
 	{
-		result = _baseName + to_string(_endSuffix++);
+		result = _baseName + std::to_string(_endSuffix++);
 		while (_endSuffix < _startSuffix)
-			result = _baseName + to_string(_endSuffix++) + ", " + result;
+			result = _baseName + std::to_string(_endSuffix++) + ", " + result;
 	}
 	return result;
 }
+
+namespace
+{
+
+/// Try to format as N * 2**x
+std::optional<std::string> tryFormatPowerOfTwo(bigint const& _value)
+{
+	bigint prefix = _value;
+
+	// when multiple trailing zero bytes, format as N * 2**x
+	int i = 0;
+	for (; (prefix & 0xff) == 0; prefix >>= 8)
+		++i;
+	if (i <= 2)
+		return std::nullopt;
+
+	// 0x100 yields 2**8 (N is 1 and redundant)
+	if (prefix == 1)
+		return {fmt::format("2**{}", i * 8)};
+	else if ((prefix & (prefix - 1)) == 0)
+	{
+		int j = 0;
+		for (; (prefix & 0x1) == 0; prefix >>= 1)
+			j++;
+		return {fmt::format("2**{}", i * 8 + j)};
+	}
+	else
+		return {fmt::format(
+			"{} * 2**{}",
+			toHex(toCompactBigEndian(prefix), HexPrefix::Add, HexCase::Mixed),
+			i * 8
+		)};
+}
+
+}
+
+std::string solidity::util::formatNumberReadable(bigint const& _value, bool _useTruncation)
+{
+	bool const isNegative = _value < 0;
+	bigint const absValue = isNegative ? (bigint(-1) * _value) : bigint(_value);
+	std::string const sign = isNegative ? "-" : "";
+
+	// smaller numbers return as decimal
+	if (absValue <= 0x1000000)
+		return sign + absValue.str();
+
+	if (auto result = tryFormatPowerOfTwo(absValue))
+		return {sign + *result};
+	else if (auto result = tryFormatPowerOfTwo(absValue + 1))
+		return {sign + *result + (isNegative ? " + 1" : " - 1")};
+
+	std::string str = toHex(toCompactBigEndian(absValue), HexPrefix::Add, HexCase::Mixed);
+
+	if (_useTruncation)
+	{
+		// return as interior-truncated hex.
+		size_t len = str.size();
+
+		if (len < 24)
+			return sign + str;
+
+		size_t const initialChars = 6;
+		size_t const finalChars = 4;
+		size_t numSkipped = len - initialChars - finalChars;
+
+		return fmt::format(
+			"{}{}...{{+{} more}}...{}",
+			sign,
+			str.substr(0, initialChars),
+			numSkipped,
+			str.substr(len-finalChars, len)
+		);
+	}
+
+	return sign + str;
+}
+
+std::string solidity::util::prefixLines(
+	std::string const& _input,
+	std::string const& _prefix,
+	bool _trimPrefix
+)
+{
+	std::ostringstream output;
+	printPrefixed(output, _input, _prefix, _trimPrefix, false /* _ensureFinalNewline */);
+	return output.str();
+}
+
+void solidity::util::printPrefixed(
+	std::ostream& _output,
+	std::string const& _input,
+	std::string const& _prefix,
+	bool _trimPrefix,
+	bool _ensureFinalNewline
+)
+{
+	std::istringstream input(_input);
+	std::string line;
+	while (std::getline(input, line))
+	{
+		if (line.empty() && _trimPrefix)
+			_output << boost::trim_right_copy(_prefix);
+		else
+			_output << _prefix << line;
+		if (!input.eof() || _ensureFinalNewline)
+			_output << '\n';
+	}
+}
diff --git a/compiler/libsolutil/StringUtils.h b/compiler/libsolutil/StringUtils.h
index d7e12385..77ffe673 100644
--- a/compiler/libsolutil/StringUtils.h
+++ b/compiler/libsolutil/StringUtils.h
@@ -27,6 +27,8 @@
 #include <libsolutil/CommonData.h>
 #include <libsolutil/Numeric.h>
 
+#include <fmt/format.h>
+
 #include <algorithm>
 #include <limits>
 #include <locale>
@@ -101,110 +103,17 @@ std::string joinHumanReadablePrefixed
 		return _separator + joinHumanReadable(_list, _separator, _lastSeparator);
 }
 
-/// Same as @ref formatNumberReadable but only for unsigned numbers
-template <class T>
-inline std::string formatUnsignedNumberReadable (
-	T const& _value,
-	bool _useTruncation = false
-)
-{
-	static_assert(
-		std::is_same<bigint, T>::value || !std::numeric_limits<T>::is_signed,
-		"only unsigned types or bigint supported"
-	); //bigint does not carry sign bit on shift
-
-	// smaller numbers return as decimal
-	if (_value <= 0x1000000)
-		return _value.str();
-
-	HexCase hexcase = HexCase::Mixed;
-	HexPrefix prefix = HexPrefix::Add;
-
-	// when multiple trailing zero bytes, format as N * 2**x
-	int i = 0;
-	T v = _value;
-	for (; (v & 0xff) == 0; v >>= 8)
-		++i;
-	if (i > 2)
-	{
-		// 0x100 yields 2**8 (N is 1 and redundant)
-		if (v == 1)
-			return "2**" + std::to_string(i * 8);
-		return toHex(toCompactBigEndian(v), prefix, hexcase) +
-			" * 2**" +
-			std::to_string(i * 8);
-	}
-
-	// when multiple trailing FF bytes, format as N * 2**x - 1
-	i = 0;
-	for (v = _value; (v & 0xff) == 0xff; v >>= 8)
-		++i;
-	if (i > 2)
-	{
-		// 0xFF yields 2**8 - 1 (v is 0 in that case)
-		if (v == 0)
-			return "2**" + std::to_string(i * 8) + " - 1";
-		return toHex(toCompactBigEndian(T(v + 1)), prefix, hexcase) +
-			" * 2**" + std::to_string(i * 8) +
-			" - 1";
-	}
-
-	std::string str = toHex(toCompactBigEndian(_value), prefix, hexcase);
-	if (_useTruncation)
-	{
-		// return as interior-truncated hex.
-		size_t len = str.size();
-
-		if (len < 24)
-			return str;
-
-		size_t const initialChars = (prefix == HexPrefix::Add) ? 6 : 4;
-		size_t const finalChars = 4;
-		size_t numSkipped = len - initialChars - finalChars;
-
-		return str.substr(0, initialChars) +
-			"...{+" +
-			std::to_string(numSkipped) +
-			" more}..." +
-			str.substr(len-finalChars, len);
-	}
-
-	// otherwise, show whole value.
-	return str;
-}
-
 /// Formats large numbers to be easily readable by humans.
 /// Returns decimal representation for smaller numbers; hex for large numbers.
 /// "Special" numbers, powers-of-two and powers-of-two minus 1, are returned in
 /// formulaic form like 0x01 * 2**24 - 1.
-/// @a T can be any integer variable, will typically be u160, u256 or bigint.
+/// @a T can be any integer type, will typically be u160, u256 or bigint.
 /// @param _value to be formatted
 /// @param _useTruncation if true, internal truncation is also applied,
 /// like  0x5555...{+56 more}...5555
-/// @example formatNumberReadable((u256)0x7ffffff) = "0x08 * 2**24"
-/// @example formatNumberReadable(-57896044618658097711785492504343953926634992332820282019728792003956564819968) = -0x80 * 2**248
-template <class T>
-inline std::string formatNumberReadable(
-	T const& _value,
-	bool _useTruncation = false
-)
-{
-	static_assert(
-		std::numeric_limits<T>::is_integer,
-		"only integer numbers are supported"
-	);
-
-	if (_value >= 0)
-	{
-		bigint const _v = bigint(_value);
-		return formatUnsignedNumberReadable(_v, _useTruncation);
-	}
-	else
-	{
-		bigint const _abs_value = bigint(-1) * _value;
-		return "-" + formatUnsignedNumberReadable(_abs_value, _useTruncation);
-	}
-}
+/// @example formatNumberReadable((u256)0x7ffffff) = "2**27 - 1"
+/// @example formatNumberReadable(-57896044618658097711785492504343953926634992332820282019728792003956564819968) = -2**255
+std::string formatNumberReadable(bigint const& _value, bool _useTruncation = false);
 
 /// Safely converts an unsigned integer as string into an unsigned int type.
 ///
@@ -259,7 +168,7 @@ inline bool isDigit(char _c)
 	return isdigit(_c, std::locale::classic());
 }
 
-// Checks if character is printable using classic "C" locale
+/// Checks if character is printable using classic "C" locale
 /// @param _c character to be checked
 /// @return true if _c is a printable character, false otherwise.
 inline bool isPrint(char _c)
@@ -267,4 +176,36 @@ inline bool isPrint(char _c)
 	return isprint(_c, std::locale::classic());
 }
 
+/// Adds a prefix to every line in the input.
+/// @see printPrefixed()
+std::string prefixLines(
+	std::string const& _input,
+	std::string const& _prefix,
+	bool _trimPrefix = true
+);
+
+/// Prints to a stream, adding a prefix to every line in the input.
+/// Assumes \n as the line separator.
+/// @param _trimPrefix If true, the function avoids introducing trailing whitespace on empty lines.
+///     This is achieved by removing trailing spaces from the prefix on such lines.
+///     Note that tabs and newlines are not removed, only spaces are.
+/// @param _finalNewline If true, an extra \n will be printed at the end of @a _input if it does
+///     not already end with one.
+void printPrefixed(
+	std::ostream& _output,
+	std::string const& _input,
+	std::string const& _prefix,
+	bool _trimPrefix = true,
+	bool _ensureFinalNewline = true
+);
+
+/// Adds a standard indent of 4 spaces to every line in the input.
+/// Assumes \n as the line separator.
+/// @param _indentEmptyLines If true, the indent will be applied to empty lines as well, resulting
+///     such lines containing trailing whitespace.
+inline std::string indent(std::string const& _input, bool _indentEmptyLines = false)
+{
+	return prefixLines(_input, "    ", !_indentEmptyLines);
+}
+
 }
diff --git a/compiler/libsolutil/SwarmHash.cpp b/compiler/libsolutil/SwarmHash.cpp
index 32e798d1..cf47cb15 100644
--- a/compiler/libsolutil/SwarmHash.cpp
+++ b/compiler/libsolutil/SwarmHash.cpp
@@ -22,7 +22,6 @@
 
 #include <libsolutil/Keccak256.h>
 
-using namespace std;
 using namespace solidity;
 using namespace solidity::util;
 
@@ -42,7 +41,7 @@ h256 swarmHashSimple(bytesConstRef _data, size_t _size)
 	return keccak256(toLittleEndian(_size) + _data.toBytes());
 }
 
-h256 swarmHashIntermediate(string const& _input, size_t _offset, size_t _length)
+h256 swarmHashIntermediate(std::string const& _input, size_t _offset, size_t _length)
 {
 	bytesConstRef ref;
 	bytes innerNodes;
@@ -104,7 +103,7 @@ h256 chunkHash(bytesConstRef const _data, bool _forceHigherLevel = false)
 
 }
 
-h256 solidity::util::bzzr0Hash(string const& _input)
+h256 solidity::util::bzzr0Hash(std::string const& _input)
 {
 	return swarmHashIntermediate(_input, 0, _input.size());
 }
diff --git a/compiler/libsolutil/TemporaryDirectory.cpp b/compiler/libsolutil/TemporaryDirectory.cpp
new file mode 100644
index 00000000..ff450479
--- /dev/null
+++ b/compiler/libsolutil/TemporaryDirectory.cpp
@@ -0,0 +1,88 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+
+#include <regex>
+#include <iostream>
+
+using namespace solidity;
+using namespace solidity::util;
+
+namespace fs = boost::filesystem;
+
+TemporaryDirectory::TemporaryDirectory(std::string const& _prefix):
+	m_path(fs::temp_directory_path() / fs::unique_path(_prefix + "-%%%%-%%%%-%%%%-%%%%"))
+{
+	// Prefix should just be a file name and not contain anything that would make us step out of /tmp.
+	solAssert(fs::path(_prefix) == fs::path(_prefix).stem(), "");
+
+	fs::create_directory(m_path);
+}
+
+TemporaryDirectory::TemporaryDirectory(
+	std::vector<boost::filesystem::path> const& _subdirectories,
+	std::string const& _prefix
+):
+	TemporaryDirectory(_prefix)
+{
+	for (boost::filesystem::path const& subdirectory: _subdirectories)
+	{
+		solAssert(!subdirectory.is_absolute() && subdirectory.root_path() != "/", "");
+		solAssert(
+			m_path.lexically_relative(subdirectory).empty() ||
+			*m_path.lexically_relative(subdirectory).begin() != "..",
+			""
+		);
+		boost::filesystem::create_directories(m_path / subdirectory);
+	}
+}
+
+TemporaryDirectory::~TemporaryDirectory()
+{
+	// A few paranoid sanity checks just to be extra sure we're not deleting someone's homework.
+	solAssert(m_path.string().find(fs::temp_directory_path().string()) == 0, "");
+	solAssert(!fs::equivalent(m_path, fs::temp_directory_path()), "");
+	solAssert(!fs::equivalent(m_path, m_path.root_path()), "");
+	solAssert(!m_path.empty(), "");
+
+	boost::system::error_code errorCode;
+	uintmax_t numRemoved = fs::remove_all(m_path, errorCode);
+	if (errorCode.value() != boost::system::errc::success)
+	{
+		std::cerr << "Failed to completely remove temporary directory '" << m_path << "'. ";
+		std::cerr << "Only " << numRemoved << " files were actually removed." << std::endl;
+		std::cerr << "Reason: " << errorCode.message() << std::endl;
+	}
+}
+
+TemporaryWorkingDirectory::TemporaryWorkingDirectory(fs::path const& _newDirectory):
+	m_originalWorkingDirectory(fs::current_path())
+{
+	fs::current_path(_newDirectory);
+}
+
+TemporaryWorkingDirectory::~TemporaryWorkingDirectory()
+{
+	fs::current_path(m_originalWorkingDirectory);
+}
diff --git a/compiler/libsolutil/TemporaryDirectory.h b/compiler/libsolutil/TemporaryDirectory.h
new file mode 100644
index 00000000..4e42c6df
--- /dev/null
+++ b/compiler/libsolutil/TemporaryDirectory.h
@@ -0,0 +1,74 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Utilities for creating temporary directories and temporarily changing the working directory
+ * for use in tests.
+ */
+
+#pragma once
+
+#include <boost/filesystem.hpp>
+
+#include <string>
+#include <vector>
+
+namespace solidity::util
+{
+
+/**
+ * An object that creates a unique temporary directory and automatically deletes it and its
+ * content upon being destroyed.
+ *
+ * The directory is guaranteed to be newly created and empty. Directory names are generated
+ * randomly. If a directory with the same name already exists (very unlikely but possible) the
+ * object won't reuse it and will fail with an exception instead.
+ */
+class TemporaryDirectory
+{
+public:
+	TemporaryDirectory(std::string const& _prefix = "solidity");
+	TemporaryDirectory(
+		std::vector<boost::filesystem::path> const& _subdirectories,
+		std::string const& _prefix = "solidity"
+	);
+	~TemporaryDirectory();
+
+	boost::filesystem::path const& path() const { return m_path; }
+	operator boost::filesystem::path() const { return m_path; }
+
+private:
+	boost::filesystem::path m_path;
+};
+
+/**
+ * An object that changes current working directory and restores it upon destruction.
+ */
+class TemporaryWorkingDirectory
+{
+public:
+	TemporaryWorkingDirectory(boost::filesystem::path const& _newDirectory);
+	~TemporaryWorkingDirectory();
+
+	boost::filesystem::path const& originalWorkingDirectory() const { return m_originalWorkingDirectory; }
+	operator boost::filesystem::path() const { return boost::filesystem::current_path(); }
+
+private:
+	boost::filesystem::path m_originalWorkingDirectory;
+};
+
+}
diff --git a/compiler/libsolutil/Whiskers.cpp b/compiler/libsolutil/Whiskers.cpp
index 043f2dd7..1f026d94 100644
--- a/compiler/libsolutil/Whiskers.cpp
+++ b/compiler/libsolutil/Whiskers.cpp
@@ -28,15 +28,15 @@
 
 #include <regex>
 
-using namespace std;
 using namespace solidity::util;
 
-Whiskers::Whiskers(string _template):
+Whiskers::Whiskers(std::string _template):
 	m_template(std::move(_template))
 {
+	checkTemplateValid();
 }
 
-Whiskers& Whiskers::operator()(string _parameter, string _value)
+Whiskers& Whiskers::operator()(std::string _parameter, std::string _value)
 {
 	checkParameterValid(_parameter);
 	checkParameterUnknown(_parameter);
@@ -45,7 +45,7 @@ Whiskers& Whiskers::operator()(string _parameter, string _value)
 	return *this;
 }
 
-Whiskers& Whiskers::operator()(string _parameter, bool _value)
+Whiskers& Whiskers::operator()(std::string _parameter, bool _value)
 {
 	checkParameterValid(_parameter);
 	checkParameterUnknown(_parameter);
@@ -55,8 +55,8 @@ Whiskers& Whiskers::operator()(string _parameter, bool _value)
 }
 
 Whiskers& Whiskers::operator()(
-	string _listParameter,
-	vector<map<string, string>> _values
+	std::string _listParameter,
+	std::vector<std::map<std::string, std::string>> _values
 )
 {
 	checkParameterValid(_listParameter);
@@ -69,14 +69,25 @@ Whiskers& Whiskers::operator()(
 	return *this;
 }
 
-string Whiskers::render() const
+std::string Whiskers::render() const
 {
 	return replace(m_template, m_parameters, m_conditions, m_listParameters);
 }
 
-void Whiskers::checkParameterValid(string const& _parameter) const
+void Whiskers::checkTemplateValid() const
 {
-	static regex validParam("^" + paramRegex() + "$");
+	std::regex validTemplate("<[#?!\\/]\\+{0,1}[a-zA-Z0-9_$-]+(?:[^a-zA-Z0-9_$>-]|$)");
+	std::smatch match;
+	assertThrow(
+		!regex_search(m_template, match, validTemplate),
+		WhiskersError,
+		"Template contains an invalid/unclosed tag " + match.str()
+	);
+}
+
+void Whiskers::checkParameterValid(std::string const& _parameter) const
+{
+	static std::regex validParam("^" + paramRegex() + "$");
 	assertThrow(
 		regex_match(_parameter, validParam),
 		WhiskersError,
@@ -84,7 +95,7 @@ void Whiskers::checkParameterValid(string const& _parameter) const
 	);
 }
 
-void Whiskers::checkParameterUnknown(string const& _parameter) const
+void Whiskers::checkParameterUnknown(std::string const& _parameter) const
 {
 	assertThrow(
 		!m_parameters.count(_parameter),
@@ -103,13 +114,13 @@ void Whiskers::checkParameterUnknown(string const& _parameter) const
 	);
 }
 
-void Whiskers::checkTemplateContainsTags(string const& _parameter, vector<string> const& _prefixes) const
+void Whiskers::checkTemplateContainsTags(std::string const& _parameter, std::vector<std::string> const& _prefixes) const
 {
 	for (auto const& prefix: _prefixes)
 	{
-		string tag{"<" + prefix + _parameter + ">"};
+		std::string tag{"<" + prefix + _parameter + ">"};
 		assertThrow(
-			m_template.find(tag) != string::npos,
+			m_template.find(tag) != std::string::npos,
 			WhiskersError,
 			"Tag '" + tag + "' not found in template:\n" + m_template
 		);
@@ -119,17 +130,17 @@ void Whiskers::checkTemplateContainsTags(string const& _parameter, vector<string
 namespace
 {
 template<class ReplaceCallback>
-string regex_replace(
-	string const& _source,
-	regex const& _pattern,
+std::string regex_replace(
+	std::string const& _source,
+	std::regex const& _pattern,
 	ReplaceCallback _replace,
-	regex_constants::match_flag_type _flags = regex_constants::match_default
+	std::regex_constants::match_flag_type _flags = std::regex_constants::match_default
 )
 {
-	sregex_iterator curMatch(_source.begin(), _source.end(), _pattern, _flags);
-	sregex_iterator matchEnd;
-	string::const_iterator lastMatchedPos(_source.cbegin());
-	string result;
+	std::sregex_iterator curMatch(_source.begin(), _source.end(), _pattern, _flags);
+	std::sregex_iterator matchEnd;
+	std::string::const_iterator lastMatchedPos(_source.cbegin());
+	std::string result;
 	while (curMatch != matchEnd)
 	{
 		result.append(curMatch->prefix().first, curMatch->prefix().second);
@@ -142,23 +153,23 @@ string regex_replace(
 }
 }
 
-string Whiskers::replace(
-	string const& _template,
+std::string Whiskers::replace(
+	std::string const& _template,
 	StringMap const& _parameters,
-	map<string, bool> const& _conditions,
-	map<string, vector<StringMap>> const& _listParameters
+	std::map<std::string, bool> const& _conditions,
+	std::map<std::string, std::vector<StringMap>> const& _listParameters
 )
 {
-	static regex listOrTag(
+	static std::regex listOrTag(
 		"<(" + paramRegex() + ")>|"
 		"<#(" + paramRegex() + ")>((?:.|\\r|\\n)*?)</\\2>|"
 		"<\\?(\\+?" + paramRegex() + ")>((?:.|\\r|\\n)*?)(<!\\4>((?:.|\\r|\\n)*?))?</\\4>"
 	);
-	return regex_replace(_template, listOrTag, [&](match_results<string::const_iterator> _match) -> string
+	return regex_replace(_template, listOrTag, [&](std::match_results<std::string::const_iterator> _match) -> std::string
 	{
-		string tagName(_match[1]);
-		string listName(_match[2]);
-		string conditionName(_match[4]);
+		std::string tagName(_match[1]);
+		std::string listName(_match[2]);
+		std::string conditionName(_match[4]);
 		if (!tagName.empty())
 		{
 			assertThrow(
@@ -172,12 +183,12 @@ string Whiskers::replace(
 		}
 		else if (!listName.empty())
 		{
-			string templ(_match[3]);
+			std::string templ(_match[3]);
 			assertThrow(
 				_listParameters.count(listName),
 				WhiskersError, "List parameter " + listName + " not set."
 			);
-			string replacement;
+			std::string replacement;
 			for (auto const& parameters: _listParameters.at(listName))
 				replacement += replace(templ, joinMaps(_parameters, parameters), _conditions);
 			return replacement;
@@ -188,7 +199,7 @@ string Whiskers::replace(
 			bool conditionValue = false;
 			if (conditionName[0] == '+')
 			{
-				string tag = conditionName.substr(1);
+				std::string tag = conditionName.substr(1);
 
 				if (_parameters.count(tag))
 					conditionValue = !_parameters.at(tag).empty();
diff --git a/compiler/libsolutil/Whiskers.h b/compiler/libsolutil/Whiskers.h
index 7bbf74f0..e65e508a 100644
--- a/compiler/libsolutil/Whiskers.h
+++ b/compiler/libsolutil/Whiskers.h
@@ -92,6 +92,7 @@ class Whiskers
 private:
 	// Prevent implicit cast to bool
 	Whiskers& operator()(std::string _parameter, long long);
+	void checkTemplateValid() const;
 	void checkParameterValid(std::string const& _parameter) const;
 	void checkParameterUnknown(std::string const& _parameter) const;
 
diff --git a/compiler/libsolutil/vector_ref.h b/compiler/libsolutil/vector_ref.h
index 46901a46..56942b9a 100644
--- a/compiler/libsolutil/vector_ref.h
+++ b/compiler/libsolutil/vector_ref.h
@@ -28,7 +28,7 @@ class vector_ref
 	using iterator = T*;
 	using const_iterator = T const*;
 
-	static_assert(std::is_pod<value_type>::value, "vector_ref can only be used with PODs due to its low-level treatment of data.");
+	static_assert(std::is_standard_layout_v<value_type> && std::is_trivial_v<value_type>, "vector_ref can only be used with PODs due to its low-level treatment of data.");
 
 	vector_ref(): m_data(nullptr), m_count(0) {}
 	/// Creates a new vector_ref to point to @a _count elements starting at @a _data.
diff --git a/compiler/libstdlib/CMakeLists.txt b/compiler/libstdlib/CMakeLists.txt
new file mode 100644
index 00000000..65a3a1cd
--- /dev/null
+++ b/compiler/libstdlib/CMakeLists.txt
@@ -0,0 +1,18 @@
+# This will re-generate the headers if any file within src was modified.
+set_directory_properties(PROPERTY CMAKE_CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/stdlib/src/)
+
+set(STDLIB stub)
+set(GENERATED_STDLIB_HEADERS)
+foreach(src IN LISTS STDLIB)
+    set(STDLIB_FILE ${PROJECT_SOURCE_DIR}/libstdlib/src/${src}.sol)
+    file(READ ${STDLIB_FILE} STDLIB_FILE_CONTENT HEX)
+    string(REGEX MATCHALL ".." STDLIB_FILE_CONTENT "${STDLIB_FILE_CONTENT}")
+    list(REMOVE_ITEM STDLIB_FILE_CONTENT "0d")
+    string(REGEX REPLACE ";" ",\n\t0x" STDLIB_FILE_CONTENT "${STDLIB_FILE_CONTENT}")
+    set(STDLIB_FILE_CONTENT "0x${STDLIB_FILE_CONTENT}")
+    set(STDLIB_FILE_NAME ${src})
+    configure_file("${PROJECT_SOURCE_DIR}/libstdlib/stdlib.src.h.in" ${PROJECT_BINARY_DIR}/include/libstdlib/${src}.h NEWLINE_STYLE LF @ONLY)
+    list(APPEND GENERATED_STDLIB_HEADERS ${PROJECT_BINARY_DIR}/include/libstdlib/${src}.h)
+endforeach()
+
+configure_file("${PROJECT_SOURCE_DIR}/libstdlib/stdlib.h.in" ${PROJECT_BINARY_DIR}/include/libstdlib/stdlib.h NEWLINE_STYLE LF @ONLY)
diff --git a/compiler/libstdlib/src/stub.sol b/compiler/libstdlib/src/stub.sol
new file mode 100644
index 00000000..bd34e047
--- /dev/null
+++ b/compiler/libstdlib/src/stub.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.0;
+
+pragma experimental solidity;
+
+function identity()
+{
+}
diff --git a/compiler/libstdlib/stdlib.h.in b/compiler/libstdlib/stdlib.h.in
new file mode 100644
index 00000000..3b86029d
--- /dev/null
+++ b/compiler/libstdlib/stdlib.h.in
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "libstdlib/stub.h"
+
+namespace solidity::stdlib
+{
+
+static std::map<std::string, std::string> sources = {
+	{ "std.stub", stub }
+};
+
+} // namespace solidity::stdlib
diff --git a/compiler/libstdlib/stdlib.src.h.in b/compiler/libstdlib/stdlib.src.h.in
new file mode 100644
index 00000000..0407663d
--- /dev/null
+++ b/compiler/libstdlib/stdlib.src.h.in
@@ -0,0 +1,13 @@
+// The generation of this file is defined in stdlib/CMakeLists.txt.
+// This file was generated by using the content of stdlib/src/@STDLIB_FILE_NAME@.sol.
+
+#pragma once
+
+namespace solidity::stdlib
+{
+
+static char const @STDLIB_FILE_NAME@[] = {
+	@STDLIB_FILE_CONTENT@, 0
+};
+
+} // namespace solidity::stdlib
diff --git a/compiler/scripts/ASTImportTest.sh b/compiler/scripts/ASTImportTest.sh
index daf5a616..c7f50408 100755
--- a/compiler/scripts/ASTImportTest.sh
+++ b/compiler/scripts/ASTImportTest.sh
@@ -1,155 +1,393 @@
 #!/usr/bin/env bash
+# ------------------------------------------------------------------------------
+# vim:ts=4:et
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) solidity contributors.
+# ------------------------------------------------------------------------------
+# Bash script to test the import/exports.
+#
+# ast import/export tests:
+#   - first exporting a .sol file to JSON, then loading it into the compiler
+#     and exporting it again. The second JSON should be identical to the first.
+#
+# evm-assembly import/export tests:
+#   - first a .sol file will be compiled and the EVM Assembly will be exported
+#     to JSON format using --asm-json command-line option.
+#     The EVM Assembly JSON output is then imported with --import-asm-json
+#     and compiled again. The binary generated initially and after the import
+#     should be identical.
 
-set -e
+set -euo pipefail
 
-# Bash script to test the ast-import option of the compiler by
-# first exporting a .sol file to JSON, then loading it into the compiler
-# and exporting it again. The second JSON should be identical to the first
 READLINK=readlink
 if [[ "$OSTYPE" == "darwin"* ]]; then
     READLINK=greadlink
 fi
+EXPR="expr"
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    EXPR="gexpr"
+fi
+
 REPO_ROOT=$(${READLINK} -f "$(dirname "$0")"/..)
 SOLIDITY_BUILD_DIR=${SOLIDITY_BUILD_DIR:-${REPO_ROOT}/build}
-SOLC=${SOLIDITY_BUILD_DIR}/solc/solc
-SPLITSOURCES=${REPO_ROOT}/scripts/splitSources.py
+SOLC="${SOLIDITY_BUILD_DIR}/solc/solc"
+SPLITSOURCES="${REPO_ROOT}/scripts/splitSources.py"
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+function print_usage
+{
+    echo "Usage: ${0} ast|evm-assembly [--exit-on-error|--help]."
+}
+
+function print_used_commands
+{
+    local test_directory="$1"
+    local export_command="$2"
+    local import_command="$3"
+    echo
+    printError "You can find the files used for this test in ${test_directory}"
+    printError "Commands used in the test:"
+    printError "# export"
+    echo "$ ${export_command}" >&2
+    printError "# import"
+    echo "$ ${import_command}" >&2
+}
+
+function print_stderr_stdout
+{
+    local error_message="$1"
+    local stderr_file="$2"
+    local stdout_file="$3"
+    printError "$error_message"
+    printError ""
+    printError "stderr:"
+    cat "$stderr_file" >&2
+    printError ""
+    printError "stdout:"
+    cat "$stdout_file" >&2
+}
+
+function check_import_test_type_unset
+{
+    [[ -z "$IMPORT_TEST_TYPE" ]] || fail "ERROR: Import test type can only be set once. Aborting."
+}
+
+IMPORT_TEST_TYPE=
+EXIT_ON_ERROR=0
+for PARAM in "$@"
+do
+    case "$PARAM" in
+        ast) check_import_test_type_unset ; IMPORT_TEST_TYPE="ast" ;;
+        evm-assembly) check_import_test_type_unset ; IMPORT_TEST_TYPE="evm-assembly" ;;
+        --help) print_usage ; exit 0 ;;
+        --exit-on-error) EXIT_ON_ERROR=1 ;;
+        *) fail "Unknown option '$PARAM'. Aborting. $(print_usage)" ;;
+    esac
+done
 
 SYNTAXTESTS_DIR="${REPO_ROOT}/test/libsolidity/syntaxTests"
 ASTJSONTESTS_DIR="${REPO_ROOT}/test/libsolidity/ASTJSON"
-NSOURCES="$(find "$SYNTAXTESTS_DIR" -type f | wc -l)"
-
-# DEV_DIR="${REPO_ROOT}/../tmp/contracts/"
-# NSOURCES="$(find $DEV_DIR -type f | wc -l)" #TODO use find command
+SEMANTICTESTS_DIR="${REPO_ROOT}/test/libsolidity/semanticTests"
 
 FAILED=0
 UNCOMPILABLE=0
 TESTED=0
 
-if [[ "$(find . -maxdepth 0 -type d -empty)" == "" ]]; then
-    echo "Test directory not empty. Skipping!"
-    exit 1
-fi
+function test_ast_import_export_equivalence
+{
+    local sol_file="$1"
+    local input_files=( "${@:2}" )
 
-# function tests whether exporting and importing again leaves the JSON ast unchanged
-# Results are recorded by adding to FAILED or UNCOMPILABLE.
-# Also, in case of a mismatch a diff and the respective ASTs are printed
-# Expected parameters:
-# $1 name of the file to be exported and imported
-# $2 any files needed to do so that might be in parent directories
-function testImportExportEquivalence {
-    local nth_input_file="$1"
-    IFS=" " read -r -a all_input_files <<< "$2"
+    local export_command=("$SOLC" --combined-json ast --pretty-json --json-indent 4 "${input_files[@]}")
+    local import_command=("$SOLC" --import-ast --combined-json ast --pretty-json --json-indent 4 expected.json)
+    local import_via_standard_json_command=("$SOLC" --combined-json ast --pretty-json --json-indent 4 --standard-json standard_json_input.json)
 
-    if $SOLC "$nth_input_file" "${all_input_files[@]}" > /dev/null 2>&1
+    # export ast - save ast json as expected result (silently)
+    if ! "${export_command[@]}" > expected.json 2> stderr_export.txt
     then
-        ! [[ -e stderr.txt ]] || { echo "stderr.txt already exists. Refusing to overwrite."; exit 1; }
+        print_stderr_stdout "ERROR: AST reimport failed (export) for input file ${sol_file}." ./stderr_export.txt ./expected.json
+        print_used_commands "$(pwd)" "${export_command[*]} > expected.json" "${import_command[*]}"
+        return 1
+    fi
+
+    # (re)import ast - and export it again as obtained result (silently)
+    if ! "${import_command[@]}" > obtained.json 2> stderr_import.txt
+    then
+        print_stderr_stdout "ERROR: AST reimport failed (import) for input file ${sol_file}." ./stderr_import.txt ./obtained.json
+        print_used_commands "$(pwd)" "${export_command[*]} > expected.json" "${import_command[*]}"
+        return 1
+    fi
+
+    echo ". += {\"sources\":" > _ast_json.json
+    jq .sources expected.json >> _ast_json.json
+    echo "}" >> _ast_json.json
+    echo "{\"language\": \"SolidityAST\", \"settings\": {\"outputSelection\": {\"*\": {\"\": [\"ast\"]}}}}" > standard_json.json
+    jq --from-file _ast_json.json standard_json.json > standard_json_input.json
 
-        # save exported json as expected result (silently)
-        $SOLC --combined-json ast --pretty-json "$nth_input_file" "${all_input_files[@]}" > expected.json 2> /dev/null
-        # import it, and export it again as obtained result (silently)
-        if ! $SOLC --import-ast --combined-json ast --pretty-json expected.json > obtained.json 2> stderr.txt
+    # (re)import ast via standard json - and export it again as obtained result (silently)
+    if ! "${import_via_standard_json_command[@]}" > obtained_standard_json.json 2> stderr_import.txt
+    then
+        print_stderr_stdout "ERROR: AST reimport failed (import) for input file ${sol_file}." ./stderr_import.txt ./obtained_standard_json.json
+        print_used_commands "$(pwd)" "${export_command[*]} > expected.json" "${import_command[*]}"
+        return 1
+    fi
+
+    jq .sources expected.json > expected_standard_json.json
+    jq .sources obtained_standard_json.json >  obtained_standard_json_.json
+    jq 'walk(if type == "object" and has("ast") then .AST = .ast | del(.ast) else . end)' < obtained_standard_json_.json > obtained_standard_json.json
+    jq --sort-keys . < obtained_standard_json.json > obtained_standard_json_.json
+    mv obtained_standard_json_.json obtained_standard_json.json
+
+    # compare expected and obtained ASTs
+    if ! diff_files expected.json obtained.json || ! diff_files expected_standard_json.json obtained_standard_json.json
+    then
+        printError "ERROR: AST reimport failed for ${sol_file}"
+        if (( EXIT_ON_ERROR == 1 ))
         then
-            # For investigating, use exit 1 here so the script stops at the
-            # first failing test
-            # exit 1
-            FAILED=$((FAILED + 1))
-            echo -e "ERROR: AST reimport failed for input file $nth_input_file"
-            echo
-            echo "Compiler stderr:"
-            cat ./stderr.txt
-            echo
-            echo "Compiler stdout:"
-            cat ./obtained.json
+            print_used_commands "$(pwd)" "${export_command[*]}" "${import_command[*]}"
             return 1
         fi
-        DIFF="$(diff expected.json obtained.json)"
-        if [ "$DIFF" != "" ]
+        FAILED=$((FAILED + 1))
+    fi
+    TESTED=$((TESTED + 1))
+}
+
+function run_solc
+{
+    local parameters=( "${@}" )
+
+    if ! "${SOLC}" "${parameters[@]}" > /dev/null 2> solc_stderr
+    then
+        printError "ERROR: ${parameters[*]}"
+        printError "${PWD}"
+        # FIXME: EXIT_ON_ERROR seems to be ignored here and in some other places.
+        # We just exit unconditionally instead.
+        fail "$(cat solc_stderr)"
+    fi
+    rm solc_stderr
+}
+
+function run_solc_store_stdout
+{
+    local output_file=$1
+    local parameters=( "${@:2}" )
+
+    if ! "${SOLC}" "${parameters[@]}" > "${output_file}" 2> "${output_file}.error"
+    then
+        printError "ERROR: ${parameters[*]}"
+        printError "${PWD}"
+        fail "$(cat "${output_file}.error")"
+    fi
+    rm "${output_file}.error"
+}
+
+function test_evmjson_import_export_equivalence
+{
+    local sol_file="$1"
+    local input_files=( "${@:2}" )
+
+    # Generate bytecode and EVM assembly JSON through normal complication
+    mkdir -p export/
+    local export_options=(--bin --asm-json "${input_files[@]}" --output-dir export/)
+    run_solc "${export_options[@]}"
+
+    # NOTE: If there is no bytecode, the compiler produces a JSON file that contains just 'null'.
+    # This is not accepted by assembly import though so we must skip such contracts.
+    echo -n null > null
+    find export/ -name '*.json' -exec cmp --quiet --bytes=4 {} null \; -delete
+
+    find export/ -name '*.bin' -size 0 -delete
+
+    for asm_json_file in export/*.json
+    do
+        mv "${asm_json_file}" "${asm_json_file/_evm/}"
+    done
+
+    # Import EVM assembly JSON
+    mkdir -p import/
+    for asm_json_file in export/*.json
+    do
+        local bin_file_from_asm_import
+        bin_file_from_asm_import="import/$(basename "${asm_json_file}" .json).bin"
+
+        local import_options=(--bin --import-asm-json "${asm_json_file}")
+        run_solc_store_stdout "${bin_file_from_asm_import}" "${import_options[@]}"
+
+        stripCLIDecorations < "$bin_file_from_asm_import" > tmpfile
+        mv tmpfile "$bin_file_from_asm_import"
+    done
+
+    # Compare bytecode from compilation with bytecode from import
+    for bin_file in export/*.bin
+    do
+        local bin_file_from_asm_import=${bin_file/export/import}
+        if ! diff --strip-trailing-cr --ignore-all-space "${bin_file}" "${bin_file_from_asm_import}" > diff_error
         then
-            if [ "$DIFFVIEW" == "" ]
+            printError "ERROR: Bytecode from compilation (${bin_file}) differs from bytecode from EVM asm import (${bin_file_from_asm_import}):"
+            printError "    $(cat diff_error)"
+            if (( EXIT_ON_ERROR == 1 ))
             then
-                echo -e "ERROR: JSONS differ for $1: \n $DIFF \n"
-                echo "Expected:"
-                cat ./expected.json
-                echo "Obtained:"
-                cat ./obtained.json
-            else
-                # Use user supplied diff view binary
-                $DIFFVIEW expected.json obtained.json
+                # NOTE: The import_options we print here refers to the wrong file (the last one
+                # processed by the previous loop) - but it's still a good starting point for debugging ;)
+                print_used_commands "${PWD}" "${SOLC} ${export_options[*]}" "${SOLC} ${import_options[*]}"
+                return 1
             fi
             FAILED=$((FAILED + 1))
-            return 2
         fi
-        TESTED=$((TESTED + 1))
-        rm expected.json obtained.json
-        rm -f stderr.txt
+    done
+    TESTED=$((TESTED + 1))
+}
+
+# function tests whether exporting and importing again is equivalent.
+# Results are recorded by incrementing the FAILED or UNCOMPILABLE global variable.
+# Also, in case of a mismatch a diff is printed
+# Expected parameters:
+# $1 name of the file to be exported and imported
+# $2 any files needed to do so that might be in parent directories
+function test_import_export_equivalence {
+    local sol_file="$1"
+    local input_files=( "${@:2}" )
+    local output
+    local solc_return_code
+    local compile_test
+
+    case "$IMPORT_TEST_TYPE" in
+        ast) compile_test="--ast-compact-json" ;;
+        evm-assembly) compile_test="--bin" ;;
+        *) assertFail "Unknown import test type '${IMPORT_TEST_TYPE}'. Aborting." ;;
+    esac
+
+    set +e
+    output=$("$SOLC" "${compile_test}" "${input_files[@]}" 2>&1)
+    solc_return_code=$?
+    set -e
+
+    # if input files where compilable with success
+    if (( solc_return_code == 0 ))
+    then
+        case "$IMPORT_TEST_TYPE" in
+            ast) test_ast_import_export_equivalence "${sol_file}" "${input_files[@]}" ;;
+            evm-assembly) test_evmjson_import_export_equivalence "${sol_file}" "${input_files[@]}" ;;
+            *) assertFail "Unknown import test type '${IMPORT_TEST_TYPE}'. Aborting." ;;
+        esac
     else
-        # echo "contract $solfile could not be compiled "
         UNCOMPILABLE=$((UNCOMPILABLE + 1))
+
+        # solc will return exit code 2, if it was terminated by an uncaught exception.
+        # This should normally not happen, so we terminate the test execution here
+        # and print some details about the corresponding solc invocation.
+        if (( solc_return_code == 2 ))
+        then
+            # For the evm-assembly import/export tests, this script uses only the old code generator.
+            # Some semantic tests can only be compiled with --via-ir (some need to be additionally
+            # compiled with --optimize). The tests that are meant to be compiled with --via-ir are
+            # throwing an UnimplementedFeatureError exception, e.g.:
+            # "Copying of type struct C.S memory[] memory to storage not yet supported",
+            # "Copying nested calldata dynamic arrays to storage is not implemented in the old code generator".
+            # We will just ignore these kind of exceptions for now. However, any other exception
+            # will be treated as a fatal error and the script execution will be terminated with an error.
+            if [[ "${output}" != *"UnimplementedFeatureError"* ]]
+            then
+                fail "\n\nERROR: Uncaught exception while executing '${SOLC} ${compile_test} ${input_files[*]}':\n${output}\n"
+            fi
+        fi
     fi
-    # return 0
 }
-echo "Looking at $NSOURCES .sol files..."
 
-WORKINGDIR=$PWD
+command_available "$SOLC" --version
+command_available jq --version
+command_available "$EXPR" --version
+command_available "$READLINK" --version
+
+case "$IMPORT_TEST_TYPE" in
+    ast) TEST_DIRS=("${SYNTAXTESTS_DIR}" "${ASTJSONTESTS_DIR}") ;;
+    evm-assembly) TEST_DIRS=("${SEMANTICTESTS_DIR}") ;;
+    *) assertFail "Import test type not defined. $(print_usage)" ;;
+esac
 
-# for solfile in $(find $DEV_DIR -name *.sol)
 # boost_filesystem_bug specifically tests a local fix for a boost::filesystem
 # bug. Since the test involves a malformed path, there is no point in running
-# AST tests on it. See https://github.com/boostorg/filesystem/issues/176
-# shellcheck disable=SC2044
-for solfile in $(find "$SYNTAXTESTS_DIR" "$ASTJSONTESTS_DIR" -name "*.sol" -and -not -name "boost_filesystem_bug.sol")
+# tests on it. See https://github.com/boostorg/filesystem/issues/176
+# In addition, exclude all experimental Solidity tests (new type inference system)
+EXCLUDE_FILES=(
+  boost_filesystem_bug.sol
+  pragma_experimental_solidity.sol
+)
+EXCLUDE_FILES_JOINED=$(printf "! -name %s " "${EXCLUDE_FILES[@]}")
+# shellcheck disable=SC2086
+IMPORT_TEST_FILES=$(find "${TEST_DIRS[@]}" -name "*.sol" -and $EXCLUDE_FILES_JOINED -not -path "*/experimental/*")
+
+NSOURCES="$(echo "${IMPORT_TEST_FILES}" | wc -l)"
+echo "Looking at ${NSOURCES} .sol files..."
+
+COUNTER=0
+TEST_DIR=$(mktemp -d -t "import-export-test-XXXXXX")
+pushd "$TEST_DIR" > /dev/null
+
+for solfile in $IMPORT_TEST_FILES
 do
-    echo -n "."
-    # create a temporary sub-directory
-    FILETMP=$(mktemp -d)
-    cd "$FILETMP"
+    echo -n "·"
+
+    TEST_SUBDIR="$(printf "%05d" "$COUNTER")-$(basename "$solfile")"
+    mkdir "$TEST_SUBDIR"
+    pushd "$TEST_SUBDIR" > /dev/null
 
     set +e
     OUTPUT=$("$SPLITSOURCES" "$solfile")
     SPLITSOURCES_RC=$?
     set -e
-    if [ ${SPLITSOURCES_RC} == 0 ]
+
+    if (( SPLITSOURCES_RC == 0 ))
     then
-        # echo $OUTPUT
-        NSOURCES=$((NSOURCES - 1))
-        for i in $OUTPUT;
-        do
-            testImportExportEquivalence "$i" "$OUTPUT"
-            NSOURCES=$((NSOURCES + 1))
-        done
-    elif [ ${SPLITSOURCES_RC} == 1 ]
+        IFS=' ' read -ra OUTPUT_ARRAY <<< "$OUTPUT"
+        test_import_export_equivalence "$solfile" "${OUTPUT_ARRAY[@]}"
+    elif (( SPLITSOURCES_RC == 1 ))
     then
-        testImportExportEquivalence "$solfile"
-    elif [ ${SPLITSOURCES_RC} == 2 ]
+        test_import_export_equivalence "$solfile" "$solfile"
+    elif (( SPLITSOURCES_RC == 2 ))
     then
         # The script will exit with return code 2, if an UnicodeDecodeError occurred.
         # This is the case if e.g. some tests are using invalid utf-8 sequences. We will ignore
         # these errors, but print the actual output of the script.
-        echo -e "\n${OUTPUT}\n"
-        testImportExportEquivalence "$solfile"
+        printError "\n\n${OUTPUT}\n\n"
+        test_import_export_equivalence "$solfile" "$solfile"
     else
         # All other return codes will be treated as critical errors. The script will exit.
-        echo -e "\nGot unexpected return code ${SPLITSOURCES_RC} from ${SPLITSOURCES}. Aborting."
-        echo -e "\n${OUTPUT}\n"
-
-        cd "$WORKINGDIR"
-        # Delete temporary files
-        rm -rf "$FILETMP"
-
+        printError "\n\nGot unexpected return code ${SPLITSOURCES_RC} from '${SPLITSOURCES} ${solfile}'. Aborting."
+        printError "\n\n${OUTPUT}\n\n"
         exit 1
     fi
 
-    cd "$WORKINGDIR"
-    # Delete temporary files
-    rm -rf "$FILETMP"
+    popd > /dev/null
+    ((++COUNTER))
 done
 
-echo ""
+popd > /dev/null
+rm -r "$TEST_DIR"
+
+echo
 
-if [ "$FAILED" = 0 ]
+if (( FAILED == 0 ))
 then
-    echo "SUCCESS: $TESTED syntaxTests passed, $FAILED failed, $UNCOMPILABLE could not be compiled ($NSOURCES sources total)."
+    echo "SUCCESS: ${TESTED} tests passed, ${FAILED} failed, ${UNCOMPILABLE} could not be compiled (${NSOURCES} sources total)."
 else
-    echo "FAILURE: Out of $NSOURCES sources, $FAILED failed, ($UNCOMPILABLE could not be compiled)."
-    exit 1
+    fail "FAILURE: Out of ${NSOURCES} sources, ${FAILED} failed, (${UNCOMPILABLE} could not be compiled)."
 fi
diff --git a/compiler/scripts/build_emscripten.sh b/compiler/scripts/build_emscripten.sh
index 43a402fd..1b780a42 100755
--- a/compiler/scripts/build_emscripten.sh
+++ b/compiler/scripts/build_emscripten.sh
@@ -28,13 +28,14 @@
 
 set -e
 
-if test -z "$1"; then
-    BUILD_DIR="emscripten_build"
-else
-    BUILD_DIR="$1"
+params=""
+if (( $# != 0 )); then
+    params="$(printf "%q " "${@}")"
 fi
 
-# solbuildpackpusher/solidity-buildpack-deps:emscripten-13
+# solbuildpackpusher/solidity-buildpack-deps:emscripten-16
+# NOTE: Without `safe.directory` git would assume it's not safe to operate on /root/project since it's owned by a different user.
+# See https://github.blog/2022-04-12-git-security-vulnerability-announced/
 docker run -v "$(pwd):/root/project" -w /root/project \
-    solbuildpackpusher/solidity-buildpack-deps@sha256:f1c13f3450d1f2e53ea18ac1ac1a17e932573cb9a5ccd0fd9ef6dd44f6402fa9 \
-    ./scripts/ci/build_emscripten.sh "$BUILD_DIR"
+    solbuildpackpusher/solidity-buildpack-deps@sha256:19fcb5ac029bbc27ec36e10f7d14ea224d8010145f9690562ef084fd16146b0c \
+    /bin/bash -c "git config --global --add safe.directory /root/project && ./scripts/ci/build_emscripten.sh ${params}"
diff --git a/compiler/scripts/bytecodecompare/deploy_key.enc b/compiler/scripts/bytecodecompare/deploy_key.enc
deleted file mode 100644
index acab2a27..00000000
Binary files a/compiler/scripts/bytecodecompare/deploy_key.enc and /dev/null differ
diff --git a/compiler/scripts/bytecodecompare/prepare_report.js b/compiler/scripts/bytecodecompare/prepare_report.js
index 36acfbb3..821b5cb7 100755
--- a/compiler/scripts/bytecodecompare/prepare_report.js
+++ b/compiler/scripts/bytecodecompare/prepare_report.js
@@ -4,6 +4,12 @@ const fs = require('fs')
 
 const compiler = require('solc')
 
+SETTINGS_PRESETS = {
+    'legacy-optimize':    {optimize: true,  viaIR: false},
+    'legacy-no-optimize': {optimize: false, viaIR: false},
+    'via-ir-optimize':    {optimize: true,  viaIR: true},
+    'via-ir-no-optimize': {optimize: false, viaIR: true},
+}
 
 function loadSource(sourceFileName, stripSMTPragmas)
 {
@@ -23,96 +29,140 @@ function cleanString(string)
     return (string !== '' ? string : undefined)
 }
 
-
+let inputFiles = []
 let stripSMTPragmas = false
-let firstFileArgumentIndex = 2
+let presets = []
+let reportFilePath = undefined
 
-if (process.argv.length >= 3 && process.argv[2] === '--strip-smt-pragmas')
+for (let i = 2; i < process.argv.length; ++i)
 {
-    stripSMTPragmas = true
-    firstFileArgumentIndex = 3
-}
+    if (process.argv[i] === '--strip-smt-pragmas')
+        stripSMTPragmas = true
+    else if (process.argv[i] === '--preset')
+    {
+        if (i + 1 === process.argv.length)
+            throw Error("Option --preset was used, but no preset name given.")
 
-for (const optimize of [false, true])
-{
-    for (const filename of process.argv.slice(firstFileArgumentIndex))
+        presets.push(process.argv[i + 1])
+        ++i;
+    }
+    else if (process.argv[i] === '--report-file')
     {
-        if (filename !== undefined)
-        {
-            let input = {
-                language: 'Solidity',
-                sources: {
-                    [filename]: {content: loadSource(filename, stripSMTPragmas)}
-                },
-                settings: {
-                    optimizer: {enabled: optimize},
-                    outputSelection: {'*': {'*': ['evm.bytecode.object', 'metadata']}}
-                }
-            }
-            if (!stripSMTPragmas)
-                input['settings']['modelChecker'] = {engine: 'none'}
+        if (reportFilePath !== undefined)
+            throw Error("Option --report-file was specified multiple times.")
 
-            let serializedOutput
-            let result
-            const serializedInput = JSON.stringify(input)
+        if (i + 1 === process.argv.length)
+            throw Error("Option --report-file was used, but no file name given.")
 
-            let internalCompilerError = false
-            try
-            {
-                serializedOutput = compiler.compile(serializedInput)
-            }
-            catch (exception)
-            {
-                internalCompilerError = true
-            }
+        reportFilePath = process.argv[i + 1]
+        ++i;
+    }
+    else
+        inputFiles.push(process.argv[i])
+}
 
-            if (!internalCompilerError)
-            {
-                result = JSON.parse(serializedOutput)
-
-                if ('errors' in result)
-                    for (const error of result['errors'])
-                        // JSON interface still returns contract metadata in case of an internal compiler error while
-                        // CLI interface does not. To make reports comparable we must force this case to be detected as
-                        // an error in both cases.
-                        if (['UnimplementedFeatureError', 'CompilerError', 'CodeGenerationError'].includes(error['type']))
-                        {
-                            internalCompilerError = true
-                            break
-                        }
-            }
+if (reportFilePath === undefined)
+    throw Error("Use --report-file option to specify the report file path.")
 
-            if (
-                internalCompilerError ||
-                !('contracts' in result) ||
-                Object.keys(result['contracts']).length === 0 ||
-                Object.keys(result['contracts']).every(file => Object.keys(result['contracts'][file]).length === 0)
-            )
-                // NOTE: do not exit here because this may be run on source which cannot be compiled
-                console.log(filename + ': <ERROR>')
-            else
-                for (const contractFile in result['contracts'])
-                    for (const contractName in result['contracts'][contractFile])
-                    {
-                        const contractResults = result['contracts'][contractFile][contractName]
+let reportFile = fs.createWriteStream(reportFilePath, {flags : 'w'});
+
+if (presets.length === 0)
+    presets = ['legacy-no-optimize', 'legacy-optimize']
 
-                        let bytecode = '<NO BYTECODE>'
-                        let metadata = '<NO METADATA>'
+for (const preset of presets)
+    if (!(preset in SETTINGS_PRESETS))
+        throw Error(`Invalid preset name: ${preset}.`)
 
-                        if (
-                            'evm' in contractResults &&
-                            'bytecode' in contractResults['evm'] &&
-                            'object' in contractResults['evm']['bytecode'] &&
-                            cleanString(contractResults.evm.bytecode.object) !== undefined
-                        )
-                            bytecode = cleanString(contractResults.evm.bytecode.object)
+for (const preset of presets)
+{
+    settings = SETTINGS_PRESETS[preset]
+
+    for (const filename of inputFiles)
+    {
+        let input = {
+            language: 'Solidity',
+            sources: {
+                [filename]: {content: loadSource(filename, stripSMTPragmas)}
+            },
+            settings: {
+                optimizer: {enabled: settings.optimize},
+                // NOTE: We omit viaIR rather than set it to false to handle older versions that don't have it.
+                viaIR: settings.viaIR ? true : undefined,
+                outputSelection: {'*': {'*': ['evm.bytecode.object', 'metadata']}}
+            }
+        }
+        if (!stripSMTPragmas)
+            input['settings']['modelChecker'] = {engine: 'none'}
+
+        let serializedOutput
+        let result
+        const serializedInput = JSON.stringify(input)
 
-                        if ('metadata' in contractResults && cleanString(contractResults.metadata) !== undefined)
-                            metadata = contractResults.metadata
+        let internalCompilerError = false
+        try
+        {
+            serializedOutput = compiler.compile(serializedInput)
+        }
+        catch (exception)
+        {
+            internalCompilerError = true
+        }
 
-                        console.log(filename + ':' + contractName + ' ' + bytecode)
-                        console.log(filename + ':' + contractName + ' ' + metadata)
+        if (!internalCompilerError)
+        {
+            result = JSON.parse(serializedOutput)
+
+            if ('errors' in result)
+                for (const error of result['errors'])
+                    // JSON interface still returns contract metadata in case of an internal compiler error while
+                    // CLI interface does not. To make reports comparable we must force this case to be detected as
+                    // an error in both cases.
+                    if (['UnimplementedFeatureError', 'CompilerError', 'CodeGenerationError', 'YulException'].includes(error['type']))
+                    {
+                        internalCompilerError = true
+                        break
                     }
         }
+
+        if (
+            internalCompilerError ||
+            !('contracts' in result) ||
+            Object.keys(result['contracts']).length === 0 ||
+            Object.keys(result['contracts']).every(file => Object.keys(result['contracts'][file]).length === 0)
+        )
+        {
+            // NOTE: do not exit here because this may be run on source which cannot be compiled
+            reportFile.write(filename + ': <ERROR>\n')
+            process.stdout.write('E')
+        }
+        else
+            for (const contractFile in result['contracts'])
+                for (const contractName in result['contracts'][contractFile])
+                {
+                    const contractResults = result['contracts'][contractFile][contractName]
+
+                    let bytecode = '<NO BYTECODE>'
+                    let metadata = '<NO METADATA>'
+                    let progressIndicator = '.'
+
+                    if ('metadata' in contractResults && cleanString(contractResults.metadata) !== undefined)
+                        metadata = contractResults.metadata
+                    else
+                        progressIndicator = 'M'
+
+                    if (
+                        'evm' in contractResults &&
+                        'bytecode' in contractResults['evm'] &&
+                        'object' in contractResults['evm']['bytecode'] &&
+                        cleanString(contractResults.evm.bytecode.object) !== undefined
+                    )
+                        bytecode = cleanString(contractResults.evm.bytecode.object)
+                    else
+                        progressIndicator = 'B'
+
+                    reportFile.write(filename + ':' + contractName + ' ' + bytecode + '\n')
+                    reportFile.write(filename + ':' + contractName + ' ' + metadata + '\n')
+                    process.stdout.write(progressIndicator)
+                }
     }
 }
diff --git a/compiler/scripts/bytecodecompare/prepare_report.py b/compiler/scripts/bytecodecompare/prepare_report.py
index dd317735..938f5171 100755
--- a/compiler/scripts/bytecodecompare/prepare_report.py
+++ b/compiler/scripts/bytecodecompare/prepare_report.py
@@ -26,12 +26,39 @@ class CompilerInterface(Enum):
     STANDARD_JSON = 'standard-json'
 
 
+class ExecutionArchitecture(Enum):
+    NATIVE = 'native'
+    OSX_INTEL = 'osx_intel'
+
+
+class SettingsPreset(Enum):
+    LEGACY_OPTIMIZE = 'legacy-optimize'
+    LEGACY_NO_OPTIMIZE = 'legacy-no-optimize'
+    VIA_IR_OPTIMIZE = 'via-ir-optimize'
+    VIA_IR_NO_OPTIMIZE = 'via-ir-no-optimize'
+
+
 class SMTUse(Enum):
     PRESERVE = 'preserve'
     DISABLE = 'disable'
     STRIP_PRAGMAS = 'strip-pragmas'
 
 
+@dataclass(frozen=True)
+class CompilerSettings:
+    optimize: bool
+    via_ir: bool
+
+    @staticmethod
+    def from_preset(preset: SettingsPreset):
+        return {
+            SettingsPreset.LEGACY_OPTIMIZE:    CompilerSettings(optimize=True,  via_ir=False),
+            SettingsPreset.LEGACY_NO_OPTIMIZE: CompilerSettings(optimize=False, via_ir=False),
+            SettingsPreset.VIA_IR_OPTIMIZE:    CompilerSettings(optimize=True,  via_ir=True),
+            SettingsPreset.VIA_IR_NO_OPTIMIZE: CompilerSettings(optimize=False, via_ir=True),
+        }[preset]
+
+
 @dataclass(frozen=True)
 class ContractReport:
     contract_name: str
@@ -135,7 +162,7 @@ def parse_standard_json_output(source_file_name: Path, standard_json_output: str
     # CLI interface does not. To make reports comparable we must force this case to be detected as
     # an error in both cases.
     internal_compiler_error = any(
-        error['type'] in ['UnimplementedFeatureError', 'CompilerError', 'CodeGenerationError']
+        error['type'] in ['UnimplementedFeatureError', 'CompilerError', 'CodeGenerationError', 'YulException']
         for error in decoded_json_output.get('errors', {})
     )
 
@@ -161,7 +188,10 @@ def parse_standard_json_output(source_file_name: Path, standard_json_output: str
     return file_report
 
 
-def parse_cli_output(source_file_name: Path, cli_output: str) -> FileReport:
+def parse_cli_output(source_file_name: Path, cli_output: str, exit_code: int) -> FileReport:
+    if exit_code != 0:
+        return FileReport(file_name=source_file_name, contract_reports=None)
+
     # re.split() returns a list containing the text between pattern occurrences but also inserts the
     # content of matched groups in between. It also never omits the empty elements so the number of
     # list items is predictable (3 per match + the text before the first match)
@@ -189,14 +219,23 @@ def parse_cli_output(source_file_name: Path, cli_output: str) -> FileReport:
 
 def prepare_compiler_input(
     compiler_path: Path,
+    execution_arch: ExecutionArchitecture,
     source_file_name: Path,
-    optimize: bool,
     force_no_optimize_yul: bool,
     interface: CompilerInterface,
+    preset: SettingsPreset,
     smt_use: SMTUse,
     metadata_option_supported: bool,
 ) -> Tuple[List[str], str]:
 
+    settings = CompilerSettings.from_preset(preset)
+
+    command_line = []
+    if execution_arch == ExecutionArchitecture.OSX_INTEL:
+        command_line = ["/usr/bin/arch", "-64", "-x86_64"]
+    else:
+        assert execution_arch == ExecutionArchitecture.NATIVE
+
     if interface == CompilerInterface.STANDARD_JSON:
         json_input: dict = {
             'language': 'Solidity',
@@ -204,7 +243,9 @@ def prepare_compiler_input(
                 str(source_file_name): {'content': load_source(source_file_name, smt_use)}
             },
             'settings': {
-                'optimizer': {'enabled': optimize},
+                'optimizer': {'enabled': settings.optimize},
+                # NOTE: We omit viaIR rather than set it to false to handle older versions that don't have it.
+                **({'viaIR': True} if settings.via_ir else {}),
                 'outputSelection': {'*': {'*': ['evm.bytecode.object', 'metadata']}},
             }
         }
@@ -212,7 +253,7 @@ def prepare_compiler_input(
         if smt_use == SMTUse.DISABLE:
             json_input['settings']['modelChecker'] = {'engine': 'none'}
 
-        command_line = [str(compiler_path), '--standard-json']
+        command_line += [str(compiler_path), '--standard-json']
         compiler_input = json.dumps(json_input)
     else:
         assert interface == CompilerInterface.CLI
@@ -220,14 +261,16 @@ def prepare_compiler_input(
         compiler_options = [str(source_file_name), '--bin']
         if metadata_option_supported:
             compiler_options.append('--metadata')
-        if optimize:
+        if settings.optimize:
             compiler_options.append('--optimize')
         elif force_no_optimize_yul:
             compiler_options.append('--no-optimize-yul')
+        if settings.via_ir:
+            compiler_options.append('--via-ir')
         if smt_use == SMTUse.DISABLE:
             compiler_options += ['--model-checker-engine', 'none']
 
-        command_line = [str(compiler_path)] + compiler_options
+        command_line += [str(compiler_path)] + compiler_options
         compiler_input = load_source(source_file_name, smt_use)
 
     return (command_line, compiler_input)
@@ -251,30 +294,31 @@ def detect_metadata_cli_option_support(compiler_path: Path):
             f"Compiler output:\n{process.stderr}\n",
             file=sys.stderr
         )
-        raise Exception("Failed to determine if the compiler supports the --metadata option.")
+        raise RuntimeError("Failed to determine if the compiler supports the --metadata option.")
 
     return process.returncode == 0
 
 
 def run_compiler(
     compiler_path: Path,
+    execution_arch: ExecutionArchitecture,
     source_file_name: Path,
-    optimize: bool,
     force_no_optimize_yul: bool,
     interface: CompilerInterface,
+    preset: SettingsPreset,
     smt_use: SMTUse,
     metadata_option_supported: bool,
     tmp_dir: Path,
     exit_on_error: bool,
 ) -> FileReport:
-
     if interface == CompilerInterface.STANDARD_JSON:
         (command_line, compiler_input) = prepare_compiler_input(
             compiler_path,
+            execution_arch,
             Path(source_file_name.name),
-            optimize,
             force_no_optimize_yul,
             interface,
+            preset,
             smt_use,
             metadata_option_supported,
         )
@@ -284,7 +328,7 @@ def run_compiler(
             input=compiler_input,
             encoding='utf8',
             capture_output=True,
-            check=exit_on_error,
+            check=True,
         )
 
         return parse_standard_json_output(Path(source_file_name), process.stdout)
@@ -294,10 +338,11 @@ def run_compiler(
 
         (command_line, compiler_input) = prepare_compiler_input(
             compiler_path.absolute(),
+            execution_arch,
             Path(source_file_name.name),
-            optimize,
             force_no_optimize_yul,
             interface,
+            preset,
             smt_use,
             metadata_option_supported,
         )
@@ -317,13 +362,15 @@ def run_compiler(
             check=exit_on_error,
         )
 
-        return parse_cli_output(Path(source_file_name), process.stdout)
+        return parse_cli_output(Path(source_file_name), process.stdout, process.returncode)
 
 
 def generate_report(
     source_file_names: List[str],
     compiler_path: Path,
+    execution_arch: ExecutionArchitecture,
     interface: CompilerInterface,
+    presets: List[SettingsPreset],
     smt_use: SMTUse,
     force_no_optimize_yul: bool,
     report_file_path: Path,
@@ -335,16 +382,17 @@ def generate_report(
 
     try:
         with open(report_file_path, mode='w', encoding='utf8', newline='\n') as report_file:
-            for optimize in [False, True]:
+            for preset in presets:
                 with TemporaryDirectory(prefix='prepare_report-') as tmp_dir:
                     for source_file_name in sorted(source_file_names):
                         try:
                             report = run_compiler(
                                 compiler_path,
+                                execution_arch,
                                 Path(source_file_name),
-                                optimize,
                                 force_no_optimize_yul,
                                 interface,
+                                preset,
                                 smt_use,
                                 metadata_option_supported,
                                 Path(tmp_dir),
@@ -358,7 +406,7 @@ def generate_report(
                         except subprocess.CalledProcessError as exception:
                             print(
                                 f"\n\nInterrupted by an exception while processing file "
-                                f"'{source_file_name}' with optimize={optimize}\n\n"
+                                f"'{source_file_name}' with preset={preset}\n\n"
                                 f"COMPILER STDOUT:\n{exception.stdout}\n"
                                 f"COMPILER STDERR:\n{exception.stderr}\n",
                                 file=sys.stderr
@@ -367,7 +415,7 @@ def generate_report(
                         except:
                             print(
                                 f"\n\nInterrupted by an exception while processing file "
-                                f"'{source_file_name}' with optimize={optimize}\n",
+                                f"'{source_file_name}' with preset={preset}\n\n",
                                 file=sys.stderr
                             )
                             raise
@@ -390,6 +438,22 @@ def commandline_parser() -> ArgumentParser:
         choices=[c.value for c in CompilerInterface],
         help="Compiler interface to use.",
     )
+    parser.add_argument(
+        '--execution-arch',
+        dest='execution_arch',
+        default=ExecutionArchitecture.NATIVE.value,
+        choices=[c.value for c in ExecutionArchitecture],
+        help="Select the architecture of the universal binary that should be executed. (Only relevant for macOS)",
+    )
+    parser.add_argument(
+        '--preset',
+        dest='presets',
+        default=None,
+        nargs='+',
+        action='append',
+        choices=[p.value for p in SettingsPreset],
+        help="Predefined set of settings to pass to the compiler. More than one can be selected.",
+    )
     parser.add_argument(
         '--smt-use',
         dest='smt_use',
@@ -418,10 +482,20 @@ def commandline_parser() -> ArgumentParser:
 
 if __name__ == "__main__":
     options = commandline_parser().parse_args()
+
+    if options.presets is None:
+        # NOTE: Can't put it in add_argument()'s default because then it would be always present.
+        # See https://github.com/python/cpython/issues/60603
+        presets = [[SettingsPreset.LEGACY_NO_OPTIMIZE.value, SettingsPreset.LEGACY_OPTIMIZE.value]]
+    else:
+        presets = options.presets
+
     generate_report(
         glob("*.sol"),
         Path(options.compiler_path),
+        ExecutionArchitecture(options.execution_arch),
         CompilerInterface(options.interface),
+        [SettingsPreset(p) for preset_group in presets for p in preset_group],
         SMTUse(options.smt_use),
         options.force_no_optimize_yul,
         Path(options.report_file),
diff --git a/compiler/scripts/bytecodecompare/storebytecode.sh b/compiler/scripts/bytecodecompare/storebytecode.sh
deleted file mode 100755
index 2192960e..00000000
--- a/compiler/scripts/bytecodecompare/storebytecode.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-
-#------------------------------------------------------------------------------
-# Script used for cross-platform comparison of the bytecode generated by the compiler.
-# Splits all test source code into multiple files, generates bytecode and metadata
-# for each file and combines it into a single report.txt file.
-#
-# The script is meant to be executed in CI on all supported platforms. All generated
-# reports must be identical for a given compiler version.
-#
-# ------------------------------------------------------------------------------
-# This file is part of solidity.
-#
-# solidity is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# solidity is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with solidity.  If not, see <http://www.gnu.org/licenses/>
-#
-# (c) 2017 solidity contributors.
-#------------------------------------------------------------------------------
-
-set -e
-
-REPO_ROOT="$(dirname "$0")"/../..
-cd "$REPO_ROOT"
-REPO_ROOT=$(pwd) # make it absolute
-
-BUILD_DIR="${1:-${REPO_ROOT}/build}"
-
-echo "Compiling all test contracts into bytecode..."
-TMPDIR=$(mktemp -d)
-(
-    cd "$TMPDIR"
-
-    "$REPO_ROOT"/scripts/isolate_tests.py "$REPO_ROOT"/test/
-
-    if [[ "$SOLC_EMSCRIPTEN" = "On" ]]
-    then
-        echo "Installing solc-js..."
-        # npm install solc
-        git clone --depth 1 https://github.com/ethereum/solc-js.git solc-js
-        cp "$REPO_ROOT/emscripten_build/libsolc/soljson.js" solc-js/
-        pushd solc-js/
-        npm install
-        npm run build
-        popd
-
-        cp "$REPO_ROOT/scripts/bytecodecompare/prepare_report.js" .
-        npm install ./solc-js/dist
-
-        echo "Running the compiler..."
-        # shellcheck disable=SC2035
-        ./prepare_report.js *.sol > report.txt
-        echo "Finished running the compiler."
-    else
-        "$REPO_ROOT/scripts/bytecodecompare/prepare_report.py" "$BUILD_DIR/solc/solc"
-    fi
-
-    cp report.txt "$REPO_ROOT"
-)
-rm -rf "$TMPDIR"
-echo "Storebytecode finished."
diff --git a/compiler/scripts/check_style.sh b/compiler/scripts/check_style.sh
index d1ad6bb9..7bcd8cca 100755
--- a/compiler/scripts/check_style.sh
+++ b/compiler/scripts/check_style.sh
@@ -5,9 +5,10 @@ set -eu
 ERROR_LOG="$(mktemp -t check_style_XXXXXX.log)"
 
 EXCLUDE_FILES=(
+    # The line below is left unquoted to allow the shell globbing path expansion
+    test/cmdlineTests/*/{err,output}
     "libsolutil/picosha2.h"
     "test/cmdlineTests/strict_asm_only_cr/input.yul"
-    "test/cmdlineTests/strict_asm_only_cr/err"
     "test/libsolutil/UTF8.cpp"
     "test/libsolidity/syntaxTests/license/license_cr_endings.sol"
     "test/libsolidity/syntaxTests/license/license_crlf_endings.sol"
@@ -19,12 +20,44 @@ EXCLUDE_FILES=(
 EXCLUDE_FILES_JOINED=$(printf "%s\|" "${EXCLUDE_FILES[@]}")
 EXCLUDE_FILES_JOINED=${EXCLUDE_FILES_JOINED%??}
 
+NAMESPACE_STD_FREE_FILES=(
+    libevmasm/*
+    liblangutil/*
+    libsmtutil/*
+    libsolc/*
+    libsolidity/analysis/*
+    libsolidity/ast/*
+    libsolidity/codegen/ir/*
+    libsolidity/codegen/*
+    libsolidity/experimental/*
+    libsolidity/formal/*
+    libsolidity/interface/*
+    libsolidity/lsp/*
+    libsolidity/parsing/*
+    libsolutil/*
+    libyul/*
+    libyul/backends/evm/*
+    libyul/optimiser/*
+    solc/*
+    test/contracts/*
+    test/libevmasm/*
+    test/liblangutil/*
+    test/libsolutil/*
+    test/libsolidity/*
+    test/libsolidity/analysis/*
+    test/libsolidity/interface/*
+    test/libsolidity/util/*
+    test/libyul/*
+    test/solc/*
+    test/tools/yulInterpreter/*
+)
+
 (
 REPO_ROOT="$(dirname "$0")"/..
 cd "$REPO_ROOT" || exit 1
 
 WHITESPACE=$(git grep -n -I -E "^.*[[:space:]]+$" |
-    grep -v "test/libsolidity/ASTJSON\|test/libsolidity/ASTRecoveryTests\|test/compilationTests/zeppelin/LICENSE\|${EXCLUDE_FILES_JOINED}" || true
+    grep -v "test/libsolidity/ASTJSON\|test/compilationTests/zeppelin/LICENSE\|${EXCLUDE_FILES_JOINED}" || true
 )
 
 if [[ "$WHITESPACE" != "" ]]
@@ -54,15 +87,30 @@ FORMATERROR=$(
     preparedGrep "[a-zA-Z0-9_]\s*[&][a-zA-Z_]" | grep -E -v "return [&]" # right-aligned reference ampersand (needs to exclude return)
     # right-aligned reference pointer star (needs to exclude return and comments)
     preparedGrep "[a-zA-Z0-9_]\s*[*][a-zA-Z_]" | grep -E -v -e "return [*]" -e "^* [*]" -e "^*//.*"
-    # unqualified move check, i.e. make sure that std::move() is used instead of move()
+    # unqualified move()/forward() checks, i.e. make sure that std::move() and std::forward() are used instead of move() and forward()
     preparedGrep "move\(.+\)" | grep -v "std::move" | grep -E "[^a-z]move"
+    preparedGrep "forward\(.+\)" | grep -v "std::forward" | grep -E "[^a-z]forward"
 ) | grep -E -v -e "^[a-zA-Z\./]*:[0-9]*:\s*\/(\/|\*)" -e "^test/" || true
 )
 
-if [[ "$FORMATERROR" != "" ]]
+# Special error handling for `using namespace std;` exclusion, since said statement can be present in the test directory
+# and its subdirectories, but is excluded in the above ruleset. In order to have consistent codestyle with regards to
+# std namespace usage, test directory must also be covered.
+FORMATSTDERROR=$(
+(
+    # make sure `using namespace std` is not used in INCLUDE_DIRECTORIES
+    # shellcheck disable=SC2068,SC2068
+    grep -nIE -d skip "using namespace std;" ${NAMESPACE_STD_FREE_FILES[@]}
+) || true
+)
+
+# Merge errors into single string
+FORMATEDERRORS="$FORMATERROR$FORMATSTDERROR"
+
+if [[ "$FORMATEDERRORS" != "" ]]
 then
     echo "Coding style error:" | tee -a "$ERROR_LOG"
-    echo "$FORMATERROR" | tee -a "$ERROR_LOG"
+    echo "$FORMATEDERRORS" | tee -a "$ERROR_LOG"
     scripts/ci/post_style_errors_on_github.sh "$ERROR_LOG"
     exit 1
 fi
diff --git a/compiler/scripts/ci/build.sh b/compiler/scripts/ci/build.sh
index 87138fb0..d529b03c 100755
--- a/compiler/scripts/ci/build.sh
+++ b/compiler/scripts/ci/build.sh
@@ -2,17 +2,22 @@
 set -ex
 
 ROOTDIR="$(dirname "$0")/../.."
+# shellcheck source=scripts/common.sh
+source "${ROOTDIR}/scripts/common.sh"
+
+prerelease_source="${1:-ci}"
+
 cd "${ROOTDIR}"
 
 # shellcheck disable=SC2166
 if [ "$CIRCLE_BRANCH" = release -o -n "$CIRCLE_TAG" -o -n "$FORCE_RELEASE" ]
 then
-    echo -n "" >prerelease.txt
+    echo -n >prerelease.txt
 else
     # Use last commit date rather than build date to avoid ending up with builds for
     # different platforms having different version strings (and therefore producing different bytecode)
     # if the CI is triggered just before midnight.
-    TZ=UTC git show --quiet --date="format-local:%Y.%-m.%-d" --format="ci.%cd" >prerelease.txt
+    TZ=UTC git show --quiet --date="format-local:%Y.%-m.%-d" --format="${prerelease_source}.%cd" >prerelease.txt
 fi
 
 if [ -n "$CIRCLE_SHA1" ]
diff --git a/compiler/scripts/ci/build_emscripten.sh b/compiler/scripts/ci/build_emscripten.sh
index f2e475c2..04e16293 100755
--- a/compiler/scripts/ci/build_emscripten.sh
+++ b/compiler/scripts/ci/build_emscripten.sh
@@ -34,58 +34,93 @@
 
 set -ev
 
-if test -z "$1"; then
-	BUILD_DIR="emscripten_build"
-else
-	BUILD_DIR="$1"
-fi
+SCRIPT_DIR="$(realpath "$(dirname "$0")/..")"
+# shellcheck source=scripts/common.sh
+source "${SCRIPT_DIR}/common.sh"
 
-apt-get update
-apt-get install lz4 --no-install-recommends
+function build() {
+    local build_dir="$1"
+    local prerelease_source="${2:-ci}"
 
-WORKSPACE=/root/project
+    cd /root/project
 
-cd $WORKSPACE
+    # shellcheck disable=SC2166
+    if [[ "$CIRCLE_BRANCH" = release || -n "$CIRCLE_TAG" || -n "$FORCE_RELEASE" || "$(git tag --points-at HEAD 2>/dev/null)" == v* ]]
+    then
+        echo -n >prerelease.txt
+    else
+        # Use last commit date rather than build date to avoid ending up with builds for
+        # different platforms having different version strings (and therefore producing different bytecode)
+        # if the CI is triggered just before midnight.
+        TZ=UTC git show --quiet --date="format-local:%Y.%-m.%-d" --format="${prerelease_source}.%cd" >prerelease.txt
+    fi
+    if [ -n "$CIRCLE_SHA1" ]
+    then
+        echo -n "$CIRCLE_SHA1" >commit_hash.txt
+    fi
 
-# shellcheck disable=SC2166
-if [[ "$CIRCLE_BRANCH" = release || -n "$CIRCLE_TAG" || -n "$FORCE_RELEASE" || "$(git tag --points-at HEAD 2>/dev/null)" == v* ]]
-then
-	echo -n >prerelease.txt
-else
-	# Use last commit date rather than build date to avoid ending up with builds for
-	# different platforms having different version strings (and therefore producing different bytecode)
-	# if the CI is triggered just before midnight.
-	TZ=UTC git show --quiet --date="format-local:%Y.%-m.%-d" --format="ci.%cd" >prerelease.txt
-fi
-if [ -n "$CIRCLE_SHA1" ]
-then
-	echo -n "$CIRCLE_SHA1" >commit_hash.txt
-fi
+    # Disable warnings for unqualified `move()` calls, introduced and enabled by
+    # default in clang-16 which is what the emscripten docker image uses.
+    # Additionally, disable the warning for unknown warnings here, as this script is
+    # also used with earlier clang versions.
+    # TODO: This can be removed if and when all usages of `move()` in our codebase use the `std::` qualifier.
+    CMAKE_CXX_FLAGS="-Wno-unqualified-std-cast-call"
 
-# Disable warnings for unqualified `move()` calls, introduced and enabled by
-# default in clang-16 which is what the emscripten docker image uses.
-# Additionally, disable the warning for unknown warnings here, as this script is
-# also used with earlier clang versions.
-# TODO: This can be removed if and when all usages of `move()` in our codebase use the `std::` qualifier.
-CMAKE_CXX_FLAGS="-Wno-unqualified-std-cast-call"
+    mkdir -p "$build_dir"
+    cd "$build_dir"
+    emcmake cmake \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DBoost_USE_STATIC_LIBS=1 \
+        -DBoost_USE_STATIC_RUNTIME=1 \
+        -DCMAKE_CXX_FLAGS="${CMAKE_CXX_FLAGS}" \
+        -DTESTS=0 \
+    ..
+    make soljson
 
+    cd ..
+    mkdir -p upload
+    scripts/ci/pack_soljson.sh "$build_dir/libsolc/soljson.js" "$build_dir/libsolc/soljson.wasm" upload/soljson.js
+    cp upload/soljson.js ./
 
-mkdir -p "$BUILD_DIR"
-cd "$BUILD_DIR"
-emcmake cmake \
-	-DCMAKE_BUILD_TYPE=Release \
-	-DBoost_USE_STATIC_LIBS=1 \
-	-DBoost_USE_STATIC_RUNTIME=1 \
-	-DCMAKE_CXX_FLAGS="${CMAKE_CXX_FLAGS}" \
-	-DTESTS=0 \
-  ..
-make soljson
+    OUTPUT_SIZE=$(ls -la soljson.js)
 
-cd ..
-mkdir -p upload
-scripts/ci/pack_soljson.sh "$BUILD_DIR/libsolc/soljson.js" "$BUILD_DIR/libsolc/soljson.wasm" upload/soljson.js
-cp upload/soljson.js ./
+    echo "Emscripten output size: $OUTPUT_SIZE"
+}
 
-OUTPUT_SIZE=$(ls -la soljson.js)
+function show_help() {
+cat << EOF
+Usage: ${0##*/} [-h|--help] [--build-dir DIR] [--prerelease-source prerelease_source]
+Build Solidity emscripten binary
+    -h | --help          Display this help message
+    --build-dir          The emscripten build directory
+    --prerelease-source  The prerelease source string. E.g. 'nightly' or 'ci'.
+EOF
+}
 
-echo "Emscripten output size: $OUTPUT_SIZE"
+function main() {
+    local build_dir="emscripten_build"
+    local prerelease_source=""
+
+    while (( $# > 0 )); do
+        case "$1" in
+            -h|--help)
+                show_help
+                exit 0
+                ;;
+            --build-dir)
+                [[ -n "$2" ]] || fail "Option --build-dir cannot be empty"
+                build_dir="$2"
+                shift 2
+                ;;
+            --prerelease-source)
+                [[ -n "$2" ]] || fail "Option --prerelease-source cannot be empty"
+                prerelease_source="$2"
+                shift 2
+                ;;
+            *) fail "Invalid option: $1" ;;
+        esac
+    done
+    build "$build_dir" "$prerelease_source"
+}
+
+main "$@"
diff --git a/compiler/scripts/ci/buildpack-deps_test_ubuntu1604.clang.ossfuzz.sh b/compiler/scripts/ci/buildpack-deps_test_ubuntu.clang.ossfuzz.sh
similarity index 100%
rename from compiler/scripts/ci/buildpack-deps_test_ubuntu1604.clang.ossfuzz.sh
rename to compiler/scripts/ci/buildpack-deps_test_ubuntu.clang.ossfuzz.sh
diff --git a/compiler/scripts/ci/buildpack-deps_test_ubuntu2004.sh b/compiler/scripts/ci/buildpack-deps_test_ubuntu2004.sh
index c07a74de..feb6a592 120000
--- a/compiler/scripts/ci/buildpack-deps_test_ubuntu2004.sh
+++ b/compiler/scripts/ci/buildpack-deps_test_ubuntu2004.sh
@@ -1 +1 @@
-build.sh
\ No newline at end of file
+./build.sh
\ No newline at end of file
diff --git a/compiler/scripts/ci/buildpack-deps_test_ubuntu2004.clang.sh b/compiler/scripts/ci/buildpack-deps_test_ubuntu2204.clang.sh
similarity index 100%
rename from compiler/scripts/ci/buildpack-deps_test_ubuntu2004.clang.sh
rename to compiler/scripts/ci/buildpack-deps_test_ubuntu2204.clang.sh
diff --git a/compiler/scripts/ci/buildpack-deps_test_ubuntu2204.sh b/compiler/scripts/ci/buildpack-deps_test_ubuntu2204.sh
new file mode 120000
index 00000000..c07a74de
--- /dev/null
+++ b/compiler/scripts/ci/buildpack-deps_test_ubuntu2204.sh
@@ -0,0 +1 @@
+build.sh
\ No newline at end of file
diff --git a/compiler/scripts/ci/notification/matrix_notification.sh b/compiler/scripts/ci/notification/matrix_notification.sh
new file mode 100755
index 00000000..f7bd1949
--- /dev/null
+++ b/compiler/scripts/ci/notification/matrix_notification.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(dirname "$0")"
+
+function fail() {
+    printf '%s\n' "$1" >&2
+    exit 1
+}
+
+function notify() {
+    [[ -z "$1" ]] && fail "Event type not provided."
+    [[ "$1" != "failure" && "$1" != "success" && "$1" != "release" ]] && fail "Wrong event type."
+    local event="$1"
+    local formatted_message
+
+    # FIXME: Checking $CIRCLE_PULL_REQUEST would be better than hard-coding branch names
+    # but it's broken. CircleCI associates runs on develop/breaking with random old PRs.
+    [[ "$BRANCH" == "develop" || "$BRANCH" == "breaking" ]] || { echo "Running on a PR or a feature branch - notification skipped."; exit 0; }
+
+    # The release notification only makes sense on tagged commits. If the commit is untagged, just bail out.
+    [[ "$event" == "release" ]] && { [[ $TAG != "" ]] || { echo "Not a tagged commit - notification skipped."; exit 0; } }
+
+    formatted_message="$(format_predefined_message "$event")"
+
+    curl "https://${MATRIX_SERVER}/_matrix/client/v3/rooms/${MATRIX_NOTIFY_ROOM_ID}/send/m.room.message" \
+        --request POST \
+        --include \
+        --fail \
+        --header "Content-Type: application/json" \
+        --header "Accept: application/json" \
+        --header "Authorization: Bearer ${MATRIX_ACCESS_TOKEN}" \
+        --data "$formatted_message"
+}
+
+function circleci_workflow_name() {
+    # Workflow name is not exposed as an env variable. Has to be queried from the API.
+    # The name is not critical so if anything fails, use the raw workflow ID as a fallback.
+    local workflow_info
+    workflow_info=$(curl --silent "https://circleci.com/api/v2/workflow/${CIRCLE_WORKFLOW_ID}") || true
+    echo "$workflow_info" | grep -E '"\s*name"\s*:\s*".*"' | cut -d \" -f 4 || echo "$CIRCLE_WORKFLOW_ID"
+}
+
+function circleci_job_name() {
+    (( CIRCLE_NODE_TOTAL == 1 )) && echo "${CIRCLE_JOB}" && return
+    (( CIRCLE_NODE_TOTAL != 1 )) && echo "${CIRCLE_JOB} (run $((CIRCLE_NODE_INDEX + 1))/${CIRCLE_NODE_TOTAL})"
+}
+
+# Currently matrix only supports html formatted body,
+# see: https://spec.matrix.org/v1.6/client-server-api/#mtext
+#
+# Eventually, the matrix api will have support for better format options and `formatted_body` may not be necessary anymore:
+# https://github.com/matrix-org/matrix-spec-proposals/pull/1767
+function format_predefined_message() {
+    [[ -z "$1" ]] && fail "Event type not provided."
+    local event="$1"
+    local template
+
+    [[ "$event" == "failure" ]] && template="${SCRIPT_DIR}/templates/build_fail.json"
+    [[ "$event" == "success" ]] && template="${SCRIPT_DIR}/templates/build_success.json"
+    [[ "$event" == "release" ]] && template="${SCRIPT_DIR}/templates/build_release.json"
+
+    [[ -z "$template" ]] && fail "Message template for event [$event] not defined."
+
+    # shellcheck disable=SC2016
+    sed -e 's|${WORKFLOW_NAME}|'"${WORKFLOW_NAME}"'|' \
+        -e 's|${JOB}|'"${JOB}"'|' \
+        -e 's|${BRANCH}|'"${BRANCH}"'|' \
+        -e 's|${TAG}|'"${TAG}"'|' \
+        -e 's|${BUILD_URL}|'"${BUILD_URL}"'|' \
+        -e 's|${BUILD_NUM}|'"${BUILD_NUM}"'|' \
+        "$template"
+}
+
+# Set message environment variables based on CI backend
+if [[ "$CIRCLECI" = true ]] ; then
+    BRANCH="$CIRCLE_BRANCH"
+    TAG="${CIRCLE_TAG:-}"
+    BUILD_URL="$CIRCLE_BUILD_URL"
+    BUILD_NUM="$CIRCLE_BUILD_NUM"
+    WORKFLOW_NAME="$(circleci_workflow_name)"
+    JOB="$(circleci_job_name)"
+fi
+
+notify "$@"
diff --git a/compiler/scripts/ci/notification/templates/build_fail.json b/compiler/scripts/ci/notification/templates/build_fail.json
new file mode 100644
index 00000000..baf69aa4
--- /dev/null
+++ b/compiler/scripts/ci/notification/templates/build_fail.json
@@ -0,0 +1,6 @@
+{
+    "msgtype": "m.text",
+    "body": " ❌ [${WORKFLOW_NAME}] Job ${JOB} failed on ${BRANCH}. Please see ${BUILD_URL} for details.",
+    "format": "org.matrix.custom.html",
+    "formatted_body": " ❌ [${WORKFLOW_NAME}] Job <strong>${JOB}</strong> failed on <strong>${BRANCH}</strong>. Please see <a href=\"${BUILD_URL}\">build ${BUILD_NUM}</a> for details."
+}
diff --git a/compiler/scripts/ci/notification/templates/build_release.json b/compiler/scripts/ci/notification/templates/build_release.json
new file mode 100644
index 00000000..b7c538f8
--- /dev/null
+++ b/compiler/scripts/ci/notification/templates/build_release.json
@@ -0,0 +1,6 @@
+{
+    "msgtype": "m.text",
+    "body": " 📦 Release binaries for version ${TAG} are ready and attached as artifacts to ${BUILD_URL}. Please make sure the whole workflow succeeded before using them.",
+    "format": "org.matrix.custom.html",
+    "formatted_body": " 📦 Release binaries for version <strong>${TAG}</strong> are ready and attached as artifacts to <a href=\"${BUILD_URL}\">build ${BUILD_NUM}</a>. <strong>Please make sure the whole workflow succeeded before using them.</strong>"
+}
diff --git a/compiler/scripts/ci/notification/templates/build_success.json b/compiler/scripts/ci/notification/templates/build_success.json
new file mode 100644
index 00000000..170360fb
--- /dev/null
+++ b/compiler/scripts/ci/notification/templates/build_success.json
@@ -0,0 +1,6 @@
+{
+    "msgtype": "m.text",
+    "body": " ✅ [${WORKFLOW_NAME}] Job ${JOB} succeeded on ${BRANCH}. Please see ${BUILD_URL} for details.",
+    "format": "org.matrix.custom.html",
+    "formatted_body":" ✅ [${WORKFLOW_NAME}] Job <strong>${JOB}</strong> succeeded on <strong>${BRANCH}</strong>. Please see <a href=\"${BUILD_URL}\">build ${BUILD_NUM}</a> for details."
+}
diff --git a/compiler/scripts/common.sh b/compiler/scripts/common.sh
index 98f63ecb..d149253b 100644
--- a/compiler/scripts/common.sh
+++ b/compiler/scripts/common.sh
@@ -26,18 +26,18 @@ set -e
 # changes directory. The paths returned by `caller` are relative to it.
 _initial_work_dir=$(pwd)
 
-if [ "$CIRCLECI" ]
+if [[ -n ${CIRCLECI:-} ]]
 then
     export TERM="${TERM:-xterm}"
-    function printTask { echo "$(tput bold)$(tput setaf 2)$1$(tput setaf 7)"; }
-    function printError { >&2 echo "$(tput setaf 1)$1$(tput setaf 7)"; }
-    function printWarning { >&2 echo "$(tput setaf 11)$1$(tput setaf 7)"; }
-    function printLog { echo "$(tput setaf 3)$1$(tput setaf 7)"; }
+    function printTask { echo -e "$(tput bold)$(tput setaf 2)$1$(tput setaf 7)"; }
+    function printError { >&2 echo -e "$(tput setaf 1)$1$(tput setaf 7)"; }
+    function printWarning { >&2 echo -e "$(tput setaf 11)$1$(tput setaf 7)"; }
+    function printLog { echo -e "$(tput setaf 3)$1$(tput setaf 7)"; }
 else
-    function printTask { echo "$(tput bold)$(tput setaf 2)$1$(tput sgr0)"; }
-    function printError { >&2 echo "$(tput setaf 1)$1$(tput sgr0)"; }
-    function printWarning { >&2 echo "$(tput setaf 11)$1$(tput sgr0)"; }
-    function printLog { echo "$(tput setaf 3)$1$(tput sgr0)"; }
+    function printTask { echo -e "$(tput bold)$(tput setaf 2)$1$(tput sgr0)"; }
+    function printError { >&2 echo -e "$(tput setaf 1)$1$(tput sgr0)"; }
+    function printWarning { >&2 echo -e "$(tput setaf 11)$1$(tput sgr0)"; }
+    function printLog { echo -e "$(tput setaf 3)$1$(tput sgr0)"; }
 fi
 
 function checkDputEntries
@@ -75,9 +75,9 @@ function printStackTrace
         # `caller` returns something that could already be printed as a stacktrace but we can make
         # it more readable by rearranging the components.
         # NOTE: This assumes that paths do not contain spaces.
-        lineNumber=$(caller "$frame" | cut --delimiter " " --field 1)
-        function=$(caller "$frame" | cut --delimiter " " --field 2)
-        file=$(caller "$frame" | cut --delimiter " " --field 3)
+        lineNumber=$(caller "$frame" | cut -d " " -f 1)
+        function=$(caller "$frame" | cut -d " " -f 2)
+        file=$(caller "$frame" | cut -d " " -f 3)
 
         # Paths in the output from `caller` can be relative or absolute (depends on how the path
         # with which the script was invoked) and if they're relative, they're not necessarily
@@ -121,7 +121,7 @@ function assertFail
 
 function msg_on_error
 {
-    local error_message
+    local error_message=""
     local no_stdout=false
     local no_stderr=false
 
@@ -193,16 +193,42 @@ function msg_on_error
     fi
 }
 
+
 function diff_values
 {
     (( $# >= 2 )) || fail "diff_values requires at least 2 arguments."
 
     local value1="$1"
     local value2="$2"
-    shift
-    shift
+    shift 2
 
-    diff --unified=0 <(echo "$value1") <(echo "$value2") "$@"
+    if ! diff --unified=0 <(echo "$value1") <(echo "$value2") "$@"
+    then
+        if [[ -n ${DIFFVIEW:-} ]]
+        then
+            # Use user supplied diff view binary
+            "$DIFFVIEW" <(echo "$value1") <(echo "$value2")
+        fi
+        return 1
+    fi
+}
+
+function diff_files
+{
+    (( $# >= 2 )) || fail "diff_files requires at least 2 arguments."
+
+    local file1="$1"
+    local file2="$2"
+
+    if ! diff "${file1}" "${file2}"
+    then
+        if [[ -n ${DIFFVIEW:-} ]]
+        then
+            # Use user supplied diff view binary
+            "$DIFFVIEW" "${file1}" "${file2}"
+        fi
+        return 1
+    fi
 }
 
 function safe_kill
@@ -277,3 +303,24 @@ function split_on_empty_lines_into_numbered_files
 
     awk -v RS= "{print > (\"${path_prefix}_\"NR \"${path_suffix}\")}"
 }
+
+function command_available
+{
+    local program="$1"
+    local parameters=( "${@:2}" )
+    if ! "${program}" "${parameters[@]}" > /dev/null 2>&1
+    then
+        fail "'${program}' not found or not executed successfully with parameter(s) '${parameters[*]}'. aborting."
+    fi
+}
+
+function gnu_grep
+{
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        command_available ggrep --version
+        ggrep "$@"
+    else
+        command_available grep --version
+        grep "$@"
+    fi
+}
diff --git a/compiler/scripts/common/cmdline_helpers.py b/compiler/scripts/common/cmdline_helpers.py
new file mode 100644
index 00000000..ede9f938
--- /dev/null
+++ b/compiler/scripts/common/cmdline_helpers.py
@@ -0,0 +1,67 @@
+import os
+import subprocess
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp
+from textwrap import dedent
+from typing import List
+from typing import Optional
+
+from bytecodecompare.prepare_report import FileReport
+from bytecodecompare.prepare_report import parse_cli_output
+
+
+DEFAULT_PREAMBLE = dedent("""
+    // SPDX-License-Identifier: UNLICENSED
+    pragma solidity >=0.0;
+""")
+
+
+def inside_temporary_dir(prefix):
+    """
+    Creates a temporary directory, enters the directory and executes the function inside it.
+    Restores the previous working directory after executing the function.
+    """
+    def tmp_dir_decorator(fn):
+        previous_dir = os.getcwd()
+        def f(*args, **kwargs):
+            try:
+                tmp_dir = mkdtemp(prefix=prefix)
+                os.chdir(tmp_dir)
+                result = fn(*args, **kwargs)
+                rmtree(tmp_dir)
+                return result
+            finally:
+                os.chdir(previous_dir)
+        return f
+    return tmp_dir_decorator
+
+
+def solc_bin_report(solc_binary: str, input_files: List[Path], via_ir: bool) -> FileReport:
+    """
+    Runs the solidity compiler binary
+    """
+
+    output = subprocess.check_output(
+        [solc_binary, '--bin'] +
+        input_files +
+        (['--via-ir'] if via_ir else []),
+        encoding='utf8',
+    )
+    return parse_cli_output('', output, 0)
+
+
+def save_bytecode(bytecode_path: Path, reports: FileReport, contract: Optional[str] = None):
+    with open(bytecode_path, 'w', encoding='utf8') as f:
+        for report in reports.contract_reports:
+            if contract is None or report.contract_name == contract:
+                bytecode = report.bytecode if report.bytecode is not None else '<NO BYTECODE>'
+                f.write(f'{report.contract_name}: {bytecode}\n')
+
+
+def add_preamble(source_path: Path, preamble: str = DEFAULT_PREAMBLE):
+    for source in source_path.glob('**/*.sol'):
+        with open(source, 'r+', encoding='utf8') as f:
+            content = f.read()
+            f.seek(0, 0)
+            f.write(preamble + content)
diff --git a/compiler/scripts/common/git_helpers.py b/compiler/scripts/common/git_helpers.py
index bb5b1f61..f43a8619 100644
--- a/compiler/scripts/common/git_helpers.py
+++ b/compiler/scripts/common/git_helpers.py
@@ -1,4 +1,6 @@
 import subprocess
+from pathlib import Path
+from shutil import which
 
 
 def run_git_command(command):
@@ -17,3 +19,21 @@ def git_current_branch():
 
 def git_commit_hash(ref: str = 'HEAD'):
     return run_git_command(['git', 'rev-parse', '--verify', ref])
+
+
+def git_diff(file_a: Path, file_b: Path) -> int:
+    if which('git') is None:
+        raise RuntimeError('git not found.')
+
+    return subprocess.run([
+        'git',
+        'diff',
+        '--color',
+        '--word-diff=plain',
+        '--word-diff-regex=.',
+        '--ignore-space-change',
+        '--ignore-blank-lines',
+        '--exit-code',
+        file_a,
+        file_b,
+    ], encoding='utf8', check=False).returncode
diff --git a/compiler/scripts/common_cmdline.sh b/compiler/scripts/common_cmdline.sh
index d364f644..5e32a76d 100644
--- a/compiler/scripts/common_cmdline.sh
+++ b/compiler/scripts/common_cmdline.sh
@@ -103,3 +103,69 @@ function compileFull
         false
     fi
 }
+
+function singleContractOutputViaStandardJSON
+{
+    (( $# == 4 )) || assertFail
+    local language="$1"
+    local selected_output="$2"
+    local extra_settings="$3"
+    local input_file="$4"
+    [[ $selected_output != "*" ]] || assertFail
+
+    json_output=$(
+        "$SOLC" --standard-json --allow-paths "$(basename "$input_file")" - <<EOF
+        {
+            "language": "${language}",
+            "sources": {"${input_file}": {"urls": ["${input_file}"]}},
+            "settings": {
+                "outputSelection": {"*": { "*": ["${selected_output}"]}},
+                ${extra_settings}
+            }
+        }
+EOF
+    )
+
+    local error_list output has_contract_level_outputs
+
+    error_list=$(echo "$json_output" | jq '.errors[] | select(.severity=="error")')
+    [[ $error_list == '' ]] || \
+        fail "Failed to compile ${input_file} via Standard JSON. Errors: ${error_list}"
+
+    has_contract_level_outputs=$(echo "$json_output" | jq 'has("contracts")')
+    [[ $has_contract_level_outputs == true ]] || \
+        fail "Standard JSON output ${selected_output} was ignored by the compiler."
+
+    output=$(echo "$json_output" | jq --raw-output ".contracts[\"${input_file}\"][].${selected_output}")
+    [[ $output != null ]] || \
+        fail "Compiler failed to produce the ${selected_output} output when compiling ${input_file} via Standard JSON."
+
+    echo "$output"
+}
+
+function stripCLIDecorations
+{
+    sed -e '/^=======.*=======$/d' \
+        -e '/^Binary:$/d' \
+        -e '/^Binary of the runtime part:$/d' \
+        -e '/^Opcodes:$/d' \
+        -e '/^IR:$/d' \
+        -e '/^Optimized IR:$/d' \
+        -e '/^EVM assembly:$/d' \
+        -e '/^JSON AST (compact format):$/d' \
+        -e '/^Function signatures:$/d' \
+        -e '/^Contract Storage Layout:$/d' \
+        -e '/^Developer Documentation$/d' \
+        -e '/^User Documentation$/d' \
+        -e '/^Contract JSON ABI$/d' \
+        -e '/^Metadata:$/d' \
+        -e '/^EVM$/d' \
+        -e '/^Pretty printed source:$/d' \
+        -e '/^Text representation:$/d' \
+        -e '/^Binary representation:$/d'
+}
+
+function stripEmptyLines
+{
+    sed -e '/^\s*$/d'
+}
diff --git a/compiler/scripts/deps-ppa/static_z3.sh b/compiler/scripts/deps-ppa/static_z3.sh
index fa237ba0..67cb15ce 100755
--- a/compiler/scripts/deps-ppa/static_z3.sh
+++ b/compiler/scripts/deps-ppa/static_z3.sh
@@ -41,7 +41,7 @@ sourcePPAConfig
 # Sanity check
 checkDputEntries "\[cpp-build-deps\]"
 
-DISTRIBUTIONS="focal jammy kinetic"
+DISTRIBUTIONS="focal jammy lunar mantic"
 
 for distribution in $DISTRIBUTIONS
 do
@@ -89,7 +89,7 @@ Build-Depends: debhelper (>= 9.0.0),
                python3
 Standards-Version: 3.9.6
 Homepage: https://github.com/Z3Prover/z3
-Vcs-Git: git://github.com/Z3Prover/z3.git
+Vcs-Git: https://github.com/Z3Prover/z3.git
 Vcs-Browser: https://github.com/Z3Prover/z3
 
 Package: z3-static
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.emscripten b/compiler/scripts/docker/buildpack-deps/Dockerfile.emscripten
index ba36541e..c29fc699 100644
--- a/compiler/scripts/docker/buildpack-deps/Dockerfile.emscripten
+++ b/compiler/scripts/docker/buildpack-deps/Dockerfile.emscripten
@@ -33,16 +33,16 @@
 # Using $(em-config CACHE)/sysroot/usr seems to work, though, and still has cmake find the
 # dependencies automatically.
 FROM emscripten/emsdk:3.1.19 AS base
-LABEL version="13"
+LABEL version="16"
 
 ADD emscripten.jam /usr/src
 RUN set -ex && \
 	\
 	apt-get update && \
-	apt-get install lz4 --no-install-recommends && \
+	apt-get install lz4 sudo --no-install-recommends && \
 	\
 	cd /usr/src && \
-	git clone https://github.com/Z3Prover/z3.git -b z3-4.11.0 --depth 1 && \
+	git clone https://github.com/Z3Prover/z3.git -b z3-4.12.1 --depth 1 && \
 	cd z3 && \
 	mkdir build && \
 	cd build && \
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu.clang.ossfuzz b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu.clang.ossfuzz
new file mode 100644
index 00000000..fd98de73
--- /dev/null
+++ b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu.clang.ossfuzz
@@ -0,0 +1,143 @@
+# vim:syntax=dockerfile
+#------------------------------------------------------------------------------
+# Dockerfile for building and testing Solidity Compiler on CI
+# Target: Ubuntu ossfuzz Clang variant
+# URL: https://hub.docker.com/r/ethereum/solidity-buildpack-deps
+#
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2016-2021 solidity contributors.
+#------------------------------------------------------------------------------
+FROM gcr.io/oss-fuzz-base/base-clang:latest as base
+LABEL version="4"
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update; \
+	apt-get -qqy install --no-install-recommends \
+		automake libtool bison texinfo \
+		build-essential sudo \
+		software-properties-common \
+		ninja-build git wget \
+		libbz2-dev zlib1g-dev git curl uuid-dev \
+		pkg-config openjdk-8-jdk liblzma-dev unzip mlton m4 jq; \
+    apt-get install -qy python3-pip;
+
+# Install cmake 3.21.2 (minimum requirement is cmake 3.10)
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.21.2/cmake-3.21.2-Linux-x86_64.sh; \
+    test "$(sha256sum cmake-3.21.2-Linux-x86_64.sh)" = "3310362c6fe4d4b2dc00823835f3d4a7171bbd73deb7d059738494761f1c908c  cmake-3.21.2-Linux-x86_64.sh"; \
+    chmod +x cmake-3.21.2-Linux-x86_64.sh; \
+    ./cmake-3.21.2-Linux-x86_64.sh --skip-license --prefix="/usr"
+
+FROM base AS libraries
+
+# Boost
+RUN set -ex; \
+    cd /usr/src; \
+    wget -q 'https://boostorg.jfrog.io/artifactory/main/release/1.74.0/source/boost_1_74_0.tar.bz2' -O boost.tar.bz2; \
+    test "$(sha256sum boost.tar.bz2)" = "83bfc1507731a0906e387fc28b7ef5417d591429e51e788417fe9ff025e116b1  boost.tar.bz2" && \
+    tar -xf boost.tar.bz2; \
+    rm boost.tar.bz2; \
+    cd boost_1_74_0; \
+    CXXFLAGS="-stdlib=libc++ -pthread" LDFLAGS="-stdlib=libc++" ./bootstrap.sh --with-toolset=clang --prefix=/usr; \
+    ./b2 toolset=clang cxxflags="-stdlib=libc++ -pthread" linkflags="-stdlib=libc++ -pthread" headers; \
+    ./b2 toolset=clang cxxflags="-stdlib=libc++ -pthread" linkflags="-stdlib=libc++ -pthread" \
+        link=static variant=release runtime-link=static \
+        system filesystem unit_test_framework program_options \
+        install -j $(($(nproc)/2)); \
+    rm -rf /usr/src/boost_1_74_0
+
+# Z3
+RUN set -ex; \
+    git clone --depth 1 -b z3-4.12.1 https://github.com/Z3Prover/z3.git \
+    /usr/src/z3; \
+    cd /usr/src/z3; \
+    mkdir build; \
+    cd build; \
+    LDFLAGS=$CXXFLAGS cmake -DZ3_BUILD_LIBZ3_SHARED=OFF -DCMAKE_INSTALL_PREFIX=/usr \
+    -DCMAKE_BUILD_TYPE=Release ..; \
+    make libz3 -j; \
+    make install; \
+    rm -rf /usr/src/z3
+
+# OSSFUZZ: libprotobuf-mutator
+RUN set -ex; \
+	git clone https://github.com/google/libprotobuf-mutator.git \
+	    /usr/src/libprotobuf-mutator; \
+	cd /usr/src/libprotobuf-mutator; \
+	git checkout 3521f47a2828da9ace403e4ecc4aece1a84feb36; \
+	mkdir build; \
+	cd build; \
+	cmake .. -GNinja -DLIB_PROTO_MUTATOR_DOWNLOAD_PROTOBUF=ON \
+        -DLIB_PROTO_MUTATOR_TESTING=OFF -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX="/usr"; \
+	ninja; \
+	cp -vpr external.protobuf/bin/* /usr/bin/; \
+	cp -vpr external.protobuf/include/* /usr/include/; \
+	cp -vpr external.protobuf/lib/* /usr/lib/; \
+	ninja install/strip; \
+	rm -rf /usr/src/libprotobuf-mutator
+
+# EVMONE
+RUN set -ex; \
+	cd /usr/src; \
+	git clone --branch="v0.11.0" --recurse-submodules https://github.com/ethereum/evmone.git; \
+	cd evmone; \
+	mkdir build; \
+	cd build; \
+	CXX=clang++ cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX="/usr" ..; \
+	ninja; \
+	ninja install/strip; \
+	rm -rf /usr/src/evmone
+
+# gmp
+RUN set -ex; \
+    # Replace system installed libgmp static library
+    # with sanitized version. Do not perform apt
+    # remove because it removes mlton as well that
+    # we need for building libabicoder
+    cd /usr/src/; \
+    git clone --depth 1 --branch gmp-6.2.1 https://github.com/gmp-mirror/gmp-6.2 gmp/; \
+    rm -r gmp/.git/; \
+    test \
+        "$(tar --create gmp/ --sort=name --mtime=1970-01-01Z --owner=0 --group=0 --numeric-owner | sha256sum)" = \
+        "d606ff6a4ce98692f9920031e85ea8fcf4a65ce1426f6f0048b8794aefed174b  -"; \
+    # NOTE: This removes also libgmp.so, which git depends on
+    rm -f /usr/lib/x86_64-linux-gnu/libgmp.*; \
+    rm -f /usr/include/x86_64-linux-gnu/gmp.h; \
+    cd gmp/; \
+    autoreconf -i; \
+    ./configure --prefix=/usr --enable-static=yes --enable-maintainer-mode; \
+    make -j; \
+    make check; \
+    make install; \
+    rm -rf /usr/src/gmp/
+
+# libabicoder
+RUN set -ex; \
+    cd /usr/src; \
+    git clone https://github.com/ekpyron/Yul-Isabelle; \
+    cd Yul-Isabelle; \
+    cd libabicoder; \
+    CXX=clang++ CXXFLAGS="-stdlib=libc++ -pthread" make; \
+    cp libabicoder.a /usr/lib; \
+    cp abicoder.hpp /usr/include; \
+    rm -rf /usr/src/Yul-Isabelle
+
+FROM base
+COPY --from=libraries /usr/lib /usr/lib
+COPY --from=libraries /usr/bin /usr/bin
+COPY --from=libraries /usr/include /usr/include
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu1604.clang.ossfuzz b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu1604.clang.ossfuzz
deleted file mode 100644
index d5481604..00000000
--- a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu1604.clang.ossfuzz
+++ /dev/null
@@ -1,138 +0,0 @@
-# vim:syntax=dockerfile
-#------------------------------------------------------------------------------
-# Dockerfile for building and testing Solidity Compiler on CI
-# Target: Ubuntu 16.04 (Xenial Xerus) ossfuzz Clang variant
-# URL: https://hub.docker.com/r/ethereum/solidity-buildpack-deps
-#
-# This file is part of solidity.
-#
-# solidity is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# solidity is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with solidity.  If not, see <http://www.gnu.org/licenses/>
-#
-# (c) 2016-2021 solidity contributors.
-#------------------------------------------------------------------------------
-FROM gcr.io/oss-fuzz-base/base-clang:latest as base
-LABEL version="19"
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update; \
-	apt-get -qqy install --no-install-recommends \
-		build-essential \
-		software-properties-common \
-		ninja-build git wget \
-		libbz2-dev zlib1g-dev git curl uuid-dev \
-		pkg-config openjdk-8-jdk liblzma-dev unzip mlton m4 jq; \
-    apt-get install -qy python3-pip;
-
-# Install cmake 3.21.2 (minimum requirement is cmake 3.10)
-RUN wget https://github.com/Kitware/CMake/releases/download/v3.21.2/cmake-3.21.2-Linux-x86_64.sh; \
-    test "$(sha256sum cmake-3.21.2-Linux-x86_64.sh)" = "3310362c6fe4d4b2dc00823835f3d4a7171bbd73deb7d059738494761f1c908c  cmake-3.21.2-Linux-x86_64.sh"; \
-    chmod +x cmake-3.21.2-Linux-x86_64.sh; \
-    ./cmake-3.21.2-Linux-x86_64.sh --skip-license --prefix="/usr"
-
-FROM base AS libraries
-
-# Boost
-RUN set -ex; \
-    cd /usr/src; \
-    wget -q 'https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.tar.bz2' -O boost.tar.bz2; \
-    test "$(sha256sum boost.tar.bz2)" = "4eb3b8d442b426dc35346235c8733b5ae35ba431690e38c6a8263dce9fcbb402  boost.tar.bz2"; \
-    tar -xf boost.tar.bz2; \
-    rm boost.tar.bz2; \
-    cd boost_1_73_0; \
-    CXXFLAGS="-stdlib=libc++ -pthread" LDFLAGS="-stdlib=libc++" ./bootstrap.sh --with-toolset=clang --prefix=/usr; \
-    ./b2 toolset=clang cxxflags="-stdlib=libc++ -pthread" linkflags="-stdlib=libc++ -pthread" headers; \
-    ./b2 toolset=clang cxxflags="-stdlib=libc++ -pthread" linkflags="-stdlib=libc++ -pthread" \
-        link=static variant=release runtime-link=static \
-        system filesystem unit_test_framework program_options \
-        install -j $(($(nproc)/2)); \
-    rm -rf /usr/src/boost_1_73_0
-
-# Z3
-RUN set -ex; \
-    git clone --depth 1 -b z3-4.11.0 https://github.com/Z3Prover/z3.git \
-    /usr/src/z3; \
-    cd /usr/src/z3; \
-    mkdir build; \
-    cd build; \
-    LDFLAGS=$CXXFLAGS cmake -DZ3_BUILD_LIBZ3_SHARED=OFF -DCMAKE_INSTALL_PREFIX=/usr \
-    -DCMAKE_BUILD_TYPE=Release ..; \
-    make libz3 -j; \
-    make install; \
-    rm -rf /usr/src/z3
-
-# OSSFUZZ: libprotobuf-mutator
-RUN set -ex; \
-	git clone https://github.com/google/libprotobuf-mutator.git \
-	    /usr/src/libprotobuf-mutator; \
-	cd /usr/src/libprotobuf-mutator; \
-	git checkout 3521f47a2828da9ace403e4ecc4aece1a84feb36; \
-	mkdir build; \
-	cd build; \
-	cmake .. -GNinja -DLIB_PROTO_MUTATOR_DOWNLOAD_PROTOBUF=ON \
-        -DLIB_PROTO_MUTATOR_TESTING=OFF -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_INSTALL_PREFIX="/usr"; \
-	ninja; \
-	cp -vpr external.protobuf/bin/* /usr/bin/; \
-	cp -vpr external.protobuf/include/* /usr/include/; \
-	cp -vpr external.protobuf/lib/* /usr/lib/; \
-	ninja install/strip; \
-	rm -rf /usr/src/libprotobuf-mutator
-
-# EVMONE
-RUN set -ex; \
-	cd /usr/src; \
-	git clone --branch="v0.8.2" --recurse-submodules https://github.com/ethereum/evmone.git; \
-	cd evmone; \
-	mkdir build; \
-	cd build; \
-	cmake -G Ninja -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX="/usr" ..; \
-	ninja; \
-	ninja install/strip; \
-	rm -rf /usr/src/evmone
-
-# gmp
-RUN set -ex; \
-    # Replace system installed libgmp static library
-    # with sanitized version. Do not perform apt
-    # remove because it removes mlton as well that
-    # we need for building libabicoder
-    rm -f /usr/lib/x86_64-linux-gnu/libgmp.*; \
-    rm -f /usr/include/x86_64-linux-gnu/gmp.h; \
-    cd /usr/src; \
-    wget -q 'https://gmplib.org/download/gmp/gmp-6.2.1.tar.xz' -O gmp.tar.xz; \
-    test "$(sha256sum gmp.tar.xz)" = "fd4829912cddd12f84181c3451cc752be224643e87fac497b69edddadc49b4f2  gmp.tar.xz"; \
-    tar -xf gmp.tar.xz; \
-    cd gmp-6.2.1; \
-    ./configure --prefix=/usr --enable-static=yes; \
-    make -j; \
-    make install; \
-    rm -rf /usr/src/gmp-6.2.1; \
-    rm -f /usr/src/gmp.tar.xz
-
-# libabicoder
-RUN set -ex; \
-    cd /usr/src; \
-    git clone https://github.com/ekpyron/Yul-Isabelle; \
-    cd Yul-Isabelle; \
-    cd libabicoder; \
-    CXX=clang++ CXXFLAGS="-stdlib=libc++ -pthread" make; \
-    cp libabicoder.a /usr/lib; \
-    cp abicoder.hpp /usr/include; \
-    rm -rf /usr/src/Yul-Isabelle
-
-FROM base
-COPY --from=libraries /usr/lib /usr/lib
-COPY --from=libraries /usr/bin /usr/bin
-COPY --from=libraries /usr/include /usr/include
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004 b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004
index 6cac5cc8..6ff8d1bd 100644
--- a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004
+++ b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004
@@ -22,7 +22,7 @@
 # (c) 2016-2019 solidity contributors.
 #------------------------------------------------------------------------------
 FROM buildpack-deps:focal AS base
-LABEL version="14"
+LABEL version="21"
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -32,7 +32,7 @@ RUN set -ex; \
         apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
 	apt-get update; \
 	apt-get install -qqy --no-install-recommends \
-		build-essential \
+		build-essential sudo \
 		software-properties-common \
 		cmake ninja-build \
 		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
@@ -47,27 +47,11 @@ FROM base AS libraries
 
 # EVMONE
 RUN set -ex; \
-	cd /usr/src; \
-	git clone --branch="v0.8.0" --recurse-submodules https://github.com/ethereum/evmone.git; \
-	cd evmone; \
-	mkdir build; \
-	cd build; \
-	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
-	ninja; \
-	ninja install/strip; \
-	rm -rf /usr/src/evmone
-
-# HERA
-RUN set -ex; \
-	cd /usr/src; \
-	git clone --branch="v0.5.0" --depth 1 --recurse-submodules https://github.com/ewasm/hera.git; \
-	cd hera; \
-	mkdir build; \
-	cd build; \
-	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
-	ninja; \
-	ninja install/strip; \
-	rm -rf /usr/src/hera
+	wget -O /usr/src/evmone.tar.gz https://github.com/ethereum/evmone/releases/download/v0.11.0/evmone-0.11.0-linux-x86_64.tar.gz; \
+	test "$(sha256sum /usr/src/evmone.tar.gz)" = "051dbe523da165658ced63619ea2c05925516aac3061951da96d3f0962560719  /usr/src/evmone.tar.gz"; \
+	cd /usr; \
+	tar -xf /usr/src/evmone.tar.gz; \
+	rm -rf /usr/src/evmone.tar.gz
 
 FROM base
 COPY --from=libraries /usr/lib /usr/lib
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004.clang b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004.clang
deleted file mode 100644
index dc5acbcd..00000000
--- a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2004.clang
+++ /dev/null
@@ -1,77 +0,0 @@
-# vim:syntax=dockerfile
-#------------------------------------------------------------------------------
-# Dockerfile for building and testing Solidity Compiler on CI
-# Target: Ubuntu 19.04 (Disco Dingo) Clang variant
-# URL: https://hub.docker.com/r/ethereum/solidity-buildpack-deps
-#
-# This file is part of solidity.
-#
-# solidity is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# solidity is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with solidity.  If not, see <http://www.gnu.org/licenses/>
-#
-# (c) 2016-2019 solidity contributors.
-#------------------------------------------------------------------------------
-FROM buildpack-deps:focal AS base
-LABEL version="14"
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-RUN set -ex; \
-	dist=$(grep DISTRIB_CODENAME /etc/lsb-release | cut -d= -f2); \
-	echo "deb http://ppa.launchpad.net/ethereum/cpp-build-deps/ubuntu $dist main" >> /etc/apt/sources.list ; \
-	apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
-	apt-get update; \
-	apt-get install -qqy --no-install-recommends \
-		build-essential \
-		software-properties-common \
-		cmake ninja-build \
-		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
-		libboost-program-options-dev \
-		clang \
-		libz3-static-dev z3-static jq \
-		; \
-	rm -rf /var/lib/apt/lists/*
-
-FROM base AS libraries
-
-ENV CC clang
-ENV CXX clang++
-
-# EVMONE
-RUN set -ex; \
-	cd /usr/src; \
-	git clone --branch="v0.8.0" --recurse-submodules https://github.com/ethereum/evmone.git; \
-	cd evmone; \
-	mkdir build; \
-	cd build; \
-	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
-	ninja; \
-	ninja install/strip; \
-	rm -rf /usr/src/evmone
-
-# HERA
-RUN set -ex; \
-	cd /usr/src; \
-	git clone --branch="v0.5.0" --depth 1 --recurse-submodules https://github.com/ewasm/hera.git; \
-	cd hera; \
-	mkdir build; \
-	cd build; \
-	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
-	ninja; \
-	ninja install/strip; \
-	rm -rf /usr/src/hera
-
-FROM base
-COPY --from=libraries /usr/lib /usr/lib
-COPY --from=libraries /usr/bin /usr/bin
-COPY --from=libraries /usr/include /usr/include
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204 b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204
new file mode 100644
index 00000000..6908811f
--- /dev/null
+++ b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204
@@ -0,0 +1,63 @@
+# vim:syntax=dockerfile
+#------------------------------------------------------------------------------
+# Dockerfile for building and testing Solidity Compiler on CI
+# Target: Ubuntu 19.04 (Disco Dingo)
+# URL: https://hub.docker.com/r/ethereum/solidity-buildpack-deps
+#
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2016-2019 solidity contributors.
+#------------------------------------------------------------------------------
+FROM buildpack-deps:jammy AS base
+LABEL version="6"
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN set -ex; \
+        dist=$(grep DISTRIB_CODENAME /etc/lsb-release | cut -d= -f2); \
+        echo "deb http://ppa.launchpad.net/ethereum/cpp-build-deps/ubuntu $dist main" >> /etc/apt/sources.list ; \
+        apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
+	apt-get update; \
+	apt-get install -qqy --no-install-recommends \
+		build-essential sudo \
+		software-properties-common \
+		cmake ninja-build \
+		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
+		libboost-program-options-dev \
+		libcvc4-dev libz3-static-dev z3-static jq \
+		libcln-dev zip locales-all; \
+	apt-get install -qy python3-pip python3-sphinx; \
+	pip3 install codecov; \
+	rm -rf /var/lib/apt/lists/*
+
+FROM base AS libraries
+
+# EVMONE
+RUN set -ex; \
+	cd /usr/src; \
+	git clone --branch="v0.11.0" --recurse-submodules https://github.com/ethereum/evmone.git; \
+	cd evmone; \
+	mkdir build; \
+	cd build; \
+	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
+	ninja; \
+	ninja install/strip; \
+	rm -rf /usr/src/evmone
+
+FROM base
+COPY --from=libraries /usr/lib /usr/lib
+COPY --from=libraries /usr/bin /usr/bin
+COPY --from=libraries /usr/include /usr/include
diff --git a/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204.clang b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204.clang
new file mode 100644
index 00000000..a14bdc11
--- /dev/null
+++ b/compiler/scripts/docker/buildpack-deps/Dockerfile.ubuntu2204.clang
@@ -0,0 +1,65 @@
+# vim:syntax=dockerfile
+#------------------------------------------------------------------------------
+# Dockerfile for building and testing Solidity Compiler on CI
+# Target: Ubuntu 19.04 (Disco Dingo) Clang variant
+# URL: https://hub.docker.com/r/ethereum/solidity-buildpack-deps
+#
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2016-2019 solidity contributors.
+#------------------------------------------------------------------------------
+FROM buildpack-deps:jammy AS base
+LABEL version="5"
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN set -ex; \
+	dist=$(grep DISTRIB_CODENAME /etc/lsb-release | cut -d= -f2); \
+	echo "deb http://ppa.launchpad.net/ethereum/cpp-build-deps/ubuntu $dist main" >> /etc/apt/sources.list ; \
+	apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 1c52189c923f6ca9 ; \
+	apt-get update; \
+	apt-get install -qqy --no-install-recommends \
+		build-essential sudo \
+		software-properties-common \
+		cmake ninja-build \
+		libboost-filesystem-dev libboost-test-dev libboost-system-dev \
+		libboost-program-options-dev \
+		clang \
+		libz3-static-dev z3-static jq \
+		libcln-dev; \
+	rm -rf /var/lib/apt/lists/*
+
+FROM base AS libraries
+
+ENV CC clang
+ENV CXX clang++
+
+# EVMONE
+RUN set -ex; \
+	cd /usr/src; \
+	git clone --branch="v0.11.0" --recurse-submodules https://github.com/ethereum/evmone.git; \
+	cd evmone; \
+	mkdir build; \
+	cd build; \
+	cmake -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX="/usr" ..; \
+	ninja; \
+	ninja install/strip; \
+	rm -rf /usr/src/evmone
+
+FROM base
+COPY --from=libraries /usr/lib /usr/lib
+COPY --from=libraries /usr/bin /usr/bin
+COPY --from=libraries /usr/include /usr/include
diff --git a/compiler/scripts/docker/buildpack-deps/README.md b/compiler/scripts/docker/buildpack-deps/README.md
index 7f635258..15cb71f5 100644
--- a/compiler/scripts/docker/buildpack-deps/README.md
+++ b/compiler/scripts/docker/buildpack-deps/README.md
@@ -27,7 +27,7 @@ If the version check was successful, the docker image will be built using the Do
 
 The resulting docker image will be tested by executing the corresponding `scripts/ci/buildpack-deps_test_*` scripts.
 Some of these scripts are symlinked to `scripts/ci/build.sh`, except the following two:
- * `buildpack-deps-ubuntu1604.clang.ossfuzz` => `scripts/ci/build_ossfuzz.sh`
+ * `buildpack-deps-ubuntu.clang.ossfuzz` => `scripts/ci/build_ossfuzz.sh`
  * `buildpack-deps_test_emscripten.sh` => `scripts/ci/build_emscripten.sh`
 
 These scripts `scripts/ci/build.sh` and `scripts/ci/build_ossfuzz.sh` are also used by CircleCI, see `.circleci/config.yml`.
diff --git a/compiler/scripts/endToEndExtraction/create_traces.sh b/compiler/scripts/endToEndExtraction/create_traces.sh
deleted file mode 100755
index 3e1de467..00000000
--- a/compiler/scripts/endToEndExtraction/create_traces.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-set -eu
-
-BASE_PATH="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-
-mkdir -p build
-cd build
-cmake ../../../
-make soltest
-cd test/
-echo "running soltest on 'semanticTests/extracted'..."
-./soltest --color_output=false --log_level=test_suite -t semanticTests/extracted/ -- --testpath "${BASE_PATH}/../../test" --no-smt --evmonepath /Users/alex/evmone/lib/libevmone.dylib --show-messages --show-metadata > "${BASE_PATH}/extracted-tests.trace"
-echo "running soltest on 'semanticTests/extracted'... done"
-
-cd "$BASE_PATH"
-git clone git@github.com:ethereum/solidity.git solidity-develop
-cd solidity-develop
-mkdir -p build
-cd build
-cmake ..
-make soltest
-cd test/
-echo "running soltest on 'SolidityEndToEndTest'..."
-./soltest --color_output=false --log_level=test_suite -t SolidityEndToEndTest/ -- --testpath "${BASE_PATH}/solidity-develop/test" --no-smt --evmonepath /Users/alex/evmone/lib/libevmone.dylib --show-messages --show-metadata > "${BASE_PATH}/endToEndExtraction-tests.trace"
-echo "running soltest on 'SolidityEndToEndTest'... done"
diff --git a/compiler/scripts/endToEndExtraction/remove-testcases.py b/compiler/scripts/endToEndExtraction/remove-testcases.py
deleted file mode 100755
index ca9a6359..00000000
--- a/compiler/scripts/endToEndExtraction/remove-testcases.py
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=consider-using-enumerate, import-error
-
-import re
-import os
-import sys
-import getopt
-import tempfile
-from getkey import getkey
-
-
-def parse_call(call):
-    function = ''
-    arguments = ""
-    results = ""
-    search = re.search(r'// (.*):(.*)\s->\s(.*)', call, re.MULTILINE | re.DOTALL)
-    if search:
-        function = search.group(1)
-        arguments = search.group(2)
-        results = search.group(3)
-        if results.find("#") != -1:
-            results = results[:results.find("#")]
-    else:
-        search = re.search(r'// (.*)(.*)\s->\s(.*)', call, re.MULTILINE | re.DOTALL)
-        if search:
-            function = search.group(1)
-            arguments = search.group(2)
-            results = search.group(3)
-            if results.find("#") != -1:
-                results = results[:results.find("#")]
-    if function.find("wei") >= 0:
-        function = function[:function.find(",")]
-    return function.strip(), arguments.strip(), results.strip()
-
-
-def colorize(left, right, index):
-    red = "\x1b[31m"
-    yellow = "\x1b[33m"
-    reset = "\x1b[0m"
-    colors = [red, yellow]
-    color = colors[index % len(colors)]
-    function, _arguments, _results = parse_call(right)
-    left = left.replace("compileAndRun", color + "compileAndRun" + reset)
-    right = right.replace("constructor", color + "constructor" + reset)
-    if function:
-        left = left.replace(function, color + function + reset)
-        right = right.replace(function, color + function + reset)
-    if left.find(function):
-        bottom = " " * (left.find(function) - 4) + right
-    else:
-        bottom = " " + right
-    return "    " + left + "\n" + bottom  # " {:<90} {:<90}\n{}".format(left, right, bottom)
-
-
-def get_checks(content, sol_file_path):
-    constructors = []
-    checks = []
-    for line in content.split("\n"):
-        line = line.strip()
-        if line.startswith("compileAndRun"):
-            constructors.append(line)
-        if line.startswith("ABI_CHECK") or line.startswith("BOOST_REQUIRE"):
-            checks.append(line)
-    with open(sol_file_path, "r", encoding='utf8') as sol_file:
-        sol_constructors = []
-        sol_checks = []
-        inside_expectations = False
-        for line in sol_file.readlines():
-            if line.startswith("// constructor()"):
-                sol_constructors.append(line)
-            elif inside_expectations and line.startswith("// "):
-                sol_checks.append(line)
-            if line.startswith("// ----"):
-                inside_expectations = True
-        sol_file.close()
-        if len(constructors) == len(sol_constructors) == 1:
-            checks.insert(0, constructors[0])
-            sol_checks.insert(0, sol_constructors[0])
-        return checks, sol_checks
-
-
-def show_test(name, content, sol_file_path, current_test, test_count):
-    with tempfile.NamedTemporaryFile(delete=False) as cpp_file:
-        cpp_file.write(content.encode())
-        cpp_file.close()
-
-        os.system("clear")
-        print(str(current_test) + " / " + str(test_count) + " - " + name + "\n")
-        diff_env = os.getenv('DIFF', "/usr/local/bin/colordiff -a -d -w -y -W 200 ")
-        os.system(diff_env + " " + cpp_file.name + " " + sol_file_path)
-        os.unlink(cpp_file.name)
-        print("\n")
-
-        checks, sol_checks = get_checks(content, sol_file_path)
-
-        if len(checks) == len(sol_checks):
-            for i in range(0, len(checks)):
-                print(colorize(checks[i].strip(), sol_checks[i].strip(), i))
-        else:
-            print("warning: check count not matching. this should not happen!")
-
-        what = ""
-        print("\nContinue? (ENTER) Abort? (ANY OTHER KEY)")
-        while what != '\n':
-            what = getkey()
-            if what != '\n':
-                sys.exit(0)
-        print()
-
-
-def get_tests(e2e_path):
-    tests = []
-    for f in os.listdir(e2e_path):
-        if f.endswith(".sol"):
-            tests.append(f.replace(".sol", ""))
-    return tests
-
-
-def process_input_file(e2e_path, input_file, interactive):
-    tests = get_tests(e2e_path)
-    with open(input_file, "r", encoding='utf8') as cpp_file:
-        inside_test = False
-        test_name = ""
-        inside_extracted_test = False
-        new_lines = 0
-        count = 0
-        test_content = ""
-        for line in cpp_file.readlines():
-            test = re.search(r'BOOST_AUTO_TEST_CASE\((.*)\)', line, re.M | re.I)
-            if test:
-                test_name = test.group(1)
-                inside_test = True
-                inside_extracted_test = inside_test & (test_name in tests)
-                if inside_extracted_test:
-                    count = count + 1
-
-            if interactive and inside_extracted_test:
-                test_content = test_content + line
-
-            if not inside_extracted_test:
-                if line == "\n":
-                    new_lines = new_lines + 1
-                else:
-                    new_lines = 0
-                if not interactive and new_lines <= 1:
-                    sys.stdout.write(line)
-
-            if line == "}\n":
-                if interactive and inside_extracted_test:
-                    show_test(test_name, test_content.strip(), e2e_path + "/" + test_name + ".sol", count, len(tests))
-                    test_content = ""
-                inside_test = False
-        cpp_file.close()
-        sys.stdout.flush()
-
-
-def main(argv):
-    interactive = False
-    input_file = None
-    try:
-        opts, _args = getopt.getopt(argv, "if:")
-    except getopt.GetoptError:
-        print("./remove-testcases.py [-i] [-f <full path to SolidityEndToEndTest.cpp>]")
-        sys.exit(1)
-
-    for opt, arg in opts:
-        if opt == '-i':
-            interactive = True
-        elif opt in '-f':
-            input_file = arg
-
-    base_path = os.path.dirname(__file__)
-
-    if not input_file:
-        input_file = base_path + "/../../test/libsolidity/SolidityEndToEndTest.cpp"
-
-    e2e_path = base_path + "/../../test/libsolidity/semanticTests/extracted"
-
-    process_input_file(e2e_path, input_file, interactive)
-
-
-if __name__ == "__main__":
-    main(sys.argv[1:])
diff --git a/compiler/scripts/endToEndExtraction/verify-testcases.py b/compiler/scripts/endToEndExtraction/verify-testcases.py
deleted file mode 100755
index b0118704..00000000
--- a/compiler/scripts/endToEndExtraction/verify-testcases.py
+++ /dev/null
@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-#
-# - SolidityEndToEndTest.trace was created with soltest with the following command on
-#     ./soltest --color_output=false --log_level=test_suite -t SolidityEndToEndTest/ -- --no-smt
-#         --evmonepath /Users/alex/evmone/lib/libevmone.dylib --show-messages > SolidityEndToEndTest.trace
-# - a trace of the semantic tests can be created by using
-#     ./soltest --color_output=false --log_level=test_suite -t semanticTests/extracted/ -- --no-smt
-#         --evmonepath /Users/alex/evmone/lib/libevmone.dylib --show-messages > semanticTests.trace
-#
-# verify-testcases.py will compare both traces. If these traces are identical, the extracted tests were
-# identical with the tests specified in SolidityEndToEndTest.cpp.
-
-import re
-import os
-import sys
-import getopt
-import json
-
-
-class Trace:
-    def __init__(self, kind, parameter):
-        self.kind = kind
-        self.parameter = parameter
-        self._input = ""
-        self._output = ""
-        self.value = ""
-        self.result = ""
-        self.gas = ""
-
-    def get_input(self):
-        return self._input
-
-    def set_input(self, bytecode):
-        if self.kind == "create":
-            # remove cbor encoded metadata from bytecode
-            length = int(bytecode[-4:], 16) * 2
-            self._input = bytecode[:len(bytecode) - length - 4]
-
-    def get_output(self):
-        return self._output
-
-    def set_output(self, output):
-        if self.kind == "create":
-            # remove cbor encoded metadata from bytecode
-            length = int(output[-4:], 16) * 2
-            self._output = output[:len(output) - length - 4]
-
-    def __str__(self):
-        # we ignore the used gas
-        result = str(
-            "kind='" + self.kind + "' parameter='" + self.parameter + "' input='" + self._input +
-            "' output='" + self._output + "' value='" + self.value + "' result='" + self.result + "'"
-        )
-        return result
-
-
-class TestCase:
-    def __init__(self, name):
-        self.name = name
-        self.metadata = None
-        self.traces = []
-
-    def add_trace(self, kind, parameter):
-        trace = Trace(kind, parameter)
-        self.traces.append(trace)
-        return trace
-
-
-class TraceAnalyser:
-    def __init__(self, file):
-        self.file = file
-        self.tests = {}
-        self.ready = False
-
-    def analyse(self):
-        with open(self.file, "r", encoding='utf8') as trace_file:
-            trace = None
-            test_case = None
-            for line in trace_file.readlines():
-                test = re.search(r'Entering test case "(.*)"', line, re.M | re.I)
-                if test:
-                    test_name = test.group(1)
-                    test_case = TestCase(test_name)
-                    self.tests[test_name] = test_case
-
-                metadata = re.search(r'\s*metadata:\s*(.*)$', line, re.M | re.I)
-                if metadata:
-                    test_case.metadata = json.loads(metadata.group(1))
-                    del test_case.metadata["sources"]
-                    del test_case.metadata["compiler"]["version"]
-
-                create = re.search(r'CREATE\s*([a-fA-F0-9]*):', line, re.M | re.I)
-                if create:
-                    trace = test_case.add_trace("create", create.group(1))
-
-                call = re.search(r'CALL\s*([a-fA-F0-9]*)\s*->\s*([a-fA-F0-9]*):', line, re.M | re.I)
-                if call:
-                    trace = test_case.add_trace("call", call.group(1))  # + "->" + call.group(2))
-
-                if not create and not call:
-                    self.parse_parameters(line, trace)
-
-            trace_file.close()
-
-            print(self.file + ":", len(self.tests), "test-cases.")
-
-            self.ready = True
-
-    @staticmethod
-    def parse_parameters(line, trace):
-        input_match = re.search(r'\s*in:\s*([a-fA-F0-9]*)', line, re.M | re.I)
-        if input_match:
-            trace.input = input_match.group(1)
-        output_match = re.search(r'\s*out:\s*([a-fA-F0-9]*)', line, re.M | re.I)
-        if output_match:
-            trace.output = output_match.group(1)
-        result_match = re.search(r'\s*result:\s*([a-fA-F0-9]*)', line, re.M | re.I)
-        if result_match:
-            trace.result = result_match.group(1)
-        gas_used_match = re.search(r'\s*gas\sused:\s*([a-fA-F0-9]*)', line, re.M | re.I)
-        if gas_used_match:
-            trace.gas = gas_used_match.group(1)
-        value_match = re.search(r'\s*value:\s*([a-fA-F0-9]*)', line, re.M | re.I)
-        if value_match:
-            trace.value = value_match.group(1)
-
-    def diff(self, analyser):
-        if not self.ready:
-            self.analyse()
-        if not analyser.ready:
-            analyser.analyse()
-
-        intersection = set(self.tests.keys()) & set(analyser.tests.keys())
-        mismatches = set()
-
-        for test_name in intersection:
-            left = self.tests[test_name]
-            right = analyser.tests[test_name]
-            if json.dumps(left.metadata) != json.dumps(right.metadata):
-                mismatches.add(
-                    (test_name, "metadata where different: " + json.dumps(left.metadata) + " != " + json.dumps(
-                        right.metadata)))
-            if len(left.traces) != len(right.traces):
-                mismatches.add((test_name, "trace count are different: " + str(len(left.traces)) +
-                                " != " + str(len(right.traces))))
-            else:
-                self.check_traces(test_name, left, right, mismatches)
-
-        for mismatch in mismatches:
-            print(mismatch[0])
-            print(mismatch[1])
-
-        print(len(intersection), "test-cases - ", len(mismatches), " mismatche(s)")
-
-    @classmethod
-    def check_traces(cls, test_name, left, right, mismatches):
-        for trace_id, trace in enumerate(left.traces):
-            left_trace = trace
-            right_trace = right.traces[trace_id]
-            assert left_trace.kind == right_trace.kind
-            if str(left_trace) != str(right_trace):
-                mismatch_info = "    " + str(left_trace) + "\n"
-                mismatch_info += "    " + str(right_trace) + "\n"
-                mismatch_info += "    "
-                for ch in range(0, len(str(left_trace))):
-                    if ch < len(str(left_trace)) and ch < len(str(right_trace)):
-                        if str(left_trace)[ch] != str(right_trace)[ch]:
-                            mismatch_info += "|"
-                        else:
-                            mismatch_info += " "
-                    else:
-                        mismatch_info += "|"
-                mismatch_info += "\n"
-                mismatches.add((test_name, mismatch_info))
-
-
-def main(argv):
-    extracted_tests_trace_file = None
-    end_to_end_trace_file = None
-    try:
-        opts, _args = getopt.getopt(argv, "s:e:")
-    except getopt.GetoptError:
-        print("verify-testcases.py [-s <path to semantic-trace>] [-e <path to endToEndExtraction-trace>]")
-        sys.exit(2)
-
-    for opt, arg in opts:
-        if opt in '-s':
-            extracted_tests_trace_file = arg
-        elif opt in '-e':
-            end_to_end_trace_file = arg
-
-    base_path = os.path.dirname(__file__)
-    if not extracted_tests_trace_file:
-        extracted_tests_trace_file = base_path + "/extracted-tests.trace"
-    if not end_to_end_trace_file:
-        end_to_end_trace_file = base_path + "/endToEndExtraction-tests.trace"
-
-    for f in [extracted_tests_trace_file, end_to_end_trace_file]:
-        if not os.path.isfile(f):
-            print("trace file '" + f + "' not found. aborting.")
-            sys.exit(1)
-
-    if not os.path.isfile(extracted_tests_trace_file):
-        print("semantic trace file '" + extracted_tests_trace_file + "' not found. aborting.")
-        sys.exit(1)
-
-    semantic_trace = TraceAnalyser(extracted_tests_trace_file)
-    end_to_end_trace = TraceAnalyser(end_to_end_trace_file)
-
-    semantic_trace.diff(end_to_end_trace)
-
-
-if __name__ == "__main__":
-    main(sys.argv[1:])
diff --git a/compiler/scripts/error_codes.py b/compiler/scripts/error_codes.py
index 84ba08bc..d4e9e548 100755
--- a/compiler/scripts/error_codes.py
+++ b/compiler/scripts/error_codes.py
@@ -171,7 +171,7 @@ def print_ids_per_file(ids, id_to_file_names, top_dir):
 
 def examine_id_coverage(top_dir, source_id_to_file_names, new_ids_only=False):
     test_sub_dirs = [
-        path.join("test", "libsolidity", "errorRecoveryTests"),
+        path.join("test", "libsolidity", "natspecJSON"),
         path.join("test", "libsolidity", "smtCheckerTests"),
         path.join("test", "libsolidity", "syntaxTests"),
         path.join("test", "libyul", "yulSyntaxTests")
@@ -202,7 +202,12 @@ def examine_id_coverage(top_dir, source_id_to_file_names, new_ids_only=False):
         "4591", # "There are more than 256 warnings. Ignoring the rest."
                 # Due to 3805, the warning lists look different for different compiler builds.
         "1834", # Unimplemented feature error, as we do not test it anymore via cmdLineTests
-        "5430"  # basefee being used in inline assembly for EVMVersion < london
+        "6679", # blobbasefee being used in inline assembly for EVMVersion < cancun
+        "1180", # SMTChecker, covered by CL tests
+        "2339", # SMTChecker, covered by CL tests
+        "2961", # SMTChecker, covered by CL tests
+        "6240", # SMTChecker, covered by CL tests
+        "9576", # SMTChecker, covered by CL tests
     }
     assert len(test_ids & white_ids) == 0, "The sets are not supposed to intersect"
     test_ids |= white_ids
@@ -227,16 +232,109 @@ def examine_id_coverage(top_dir, source_id_to_file_names, new_ids_only=False):
             return False
 
     old_source_only_ids = {
-        "1584", "1823",
-        "1988", "2066", "2833", "3356",
-        "3893", "3996", "4010", "4802",
-        "5272", "5622", "7128", "7400",
-        "7589", "7593", "7649", "7710",
-        "8065", "8084", "8140", "8158",
-        "8312", "8592", "9134", "9609",
+        "1218",
+        "1584",
+        "1823",
+        "1988",
+        "2066",
+        "2833",
+        "3356",
+        "3893",
+        "3996",
+        "4010",
+        "4458",
+        "4802",
+        "4902",
+        "5272",
+        "5622",
+        "5798",
+        "5840",
+        "7128",
+        "7400",
+        "7589",
+        "7593",
+        "7649",
+        "7710",
+        "8065",
+        "8084",
+        "8140",
+        "8158",
+        "8312",
+        "8592",
+        "9134",
+        "9609",
     }
 
-    new_source_only_ids = source_only_ids - old_source_only_ids
+    # TODO Cover these with tests and remove from this list as the development of experimental
+    # TODO Solidity progresses. The aim should be to completely get rid of `experimental_source_only_ids`.
+    experimental_source_only_ids = {
+        "1017",
+        "1439",
+        "1723",
+        "1741",
+        "1801",
+        "1807",
+        "2015",
+        "2138",
+        "2345",
+        "2399",
+        "2599",
+        "2655",
+        "2658",
+        "2934",
+        "3101",
+        "3111",
+        "3195",
+        "3520",
+        "3570",
+        "3573",
+        "3654",
+        "4316",
+        "4337",
+        "4496",
+        "4504",
+        "4686",
+        "4767",
+        "4873",
+        "4955",
+        "5044",
+        "5094",
+        "5096",
+        "5104",
+        "5195",
+        "5262",
+        "5348",
+        "5360",
+        "5387",
+        "5577",
+        "5714",
+        "5731",
+        "5755",
+        "5904",
+        "6175",
+        "6387",
+        "6388",
+        "6460",
+        "6620",
+        "6739",
+        "6948",
+        "7341",
+        "7428",
+        "7531",
+        "8379",
+        "8809",
+        "8953",
+        "9159",
+        "9173",
+        "9282",
+        "9603",
+        "9658",
+        "9817",
+        "9831",
+        "9988",
+    }
+
+    new_source_only_ids = source_only_ids - old_source_only_ids - experimental_source_only_ids
     if len(new_source_only_ids) != 0:
         print("The following new error code(s), not covered by tests, found:")
         print_ids(new_source_only_ids)
diff --git a/compiler/scripts/externalTests/common.sh b/compiler/scripts/externalTests/common.sh
new file mode 100644
index 00000000..3bca968a
--- /dev/null
+++ b/compiler/scripts/externalTests/common.sh
@@ -0,0 +1,677 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+set -e
+
+# Requires $REPO_ROOT to be defined and "${REPO_ROOT}/scripts/common.sh" to be included before.
+
+CURRENT_EVM_VERSION=shanghai
+
+AVAILABLE_PRESETS=(
+    legacy-no-optimize
+    ir-no-optimize
+    legacy-optimize-evm-only
+    ir-optimize-evm-only
+    legacy-optimize-evm+yul
+    ir-optimize-evm+yul
+)
+
+function print_presets_or_exit
+{
+    local selected_presets="$1"
+
+    [[ $selected_presets != "" ]] || { printWarning "No presets to run. Exiting."; exit 0; }
+
+    printLog "Selected settings presets: ${selected_presets}"
+}
+
+function verify_input
+{
+    local binary_type="$1"
+    local binary_path="$2"
+    local selected_presets="$3"
+
+    (( $# >= 2 && $# <= 3 )) || fail "Usage: $0 native|solcjs <path to solc or soljson.js> [preset]"
+    [[ $binary_type == native || $binary_type == solcjs ]] || fail "Invalid binary type: '${binary_type}'. Must be either 'native' or 'solcjs'."
+    [[ -f "$binary_path" ]] || fail "The compiler binary does not exist at '${binary_path}'"
+
+    if [[ $selected_presets != "" ]]
+    then
+        for preset in $selected_presets
+        do
+            if [[ " ${AVAILABLE_PRESETS[*]} " != *" $preset "* ]]
+            then
+                fail "Preset '${preset}' does not exist. Available presets: ${AVAILABLE_PRESETS[*]}."
+            fi
+        done
+    fi
+}
+
+function setup_solc
+{
+    local test_dir="$1"
+    local binary_type="$2"
+    local binary_path="$3"
+    local solcjs_branch="${4:-master}"
+    local install_dir="${5:-solc/}"
+    local solcjs_dir="$6"
+
+    [[ $binary_type == native || $binary_type == solcjs ]] || assertFail
+    [[ $binary_type == solcjs || $solcjs_dir == "" ]] || assertFail
+
+    cd "$test_dir"
+
+    if [[ $binary_type == solcjs ]]
+    then
+        printLog "Setting up solc-js..."
+        if [[ $solcjs_dir == "" ]]; then
+            printLog "Cloning branch ${solcjs_branch}..."
+            git clone --depth 1 -b "$solcjs_branch" https://github.com/ethereum/solc-js.git "$install_dir"
+        else
+            printLog "Using local solc-js from ${solcjs_dir}..."
+            cp -ra "$solcjs_dir" solc
+        fi
+
+        pushd "$install_dir"
+        npm install
+        cp "$binary_path" soljson.js
+        npm run build
+        SOLCVERSION=$(dist/solc.js --version)
+        popd
+    else
+        printLog "Setting up solc..."
+        SOLCVERSION=$("$binary_path" --version | tail -n 1 | sed -n -E 's/^Version: (.*)$/\1/p')
+    fi
+
+    SOLCVERSION_SHORT=$(echo "$SOLCVERSION" | sed -En 's/^([0-9.]+).*\+commit\.[0-9a-f]+.*$/\1/p')
+    printLog "Using compiler version $SOLCVERSION"
+}
+
+function download_project
+{
+    local repo="$1"
+    local ref_type="$2"
+    local solcjs_ref="$3"
+    local test_dir="$4"
+
+    [[ $ref_type == commit || $ref_type == branch || $ref_type == tag ]] || assertFail
+
+    printLog "Cloning ${ref_type} ${solcjs_ref} of ${repo}..."
+    if [[ $ref_type == commit ]]; then
+        mkdir ext
+        cd ext
+        git init
+        git remote add origin "$repo"
+        git fetch --depth 1 origin "$solcjs_ref"
+        git reset --hard FETCH_HEAD
+    else
+        git clone --depth 1 "$repo" -b "$solcjs_ref" "$test_dir/ext"
+        cd ext
+    fi
+    echo "Current commit hash: $(git rev-parse HEAD)"
+}
+
+function force_truffle_version
+{
+    local version="$1"
+
+    sed -i 's/"truffle":\s*".*"/"truffle": "'"$version"'"/g' package.json
+}
+
+function replace_version_pragmas
+{
+    # Replace fixed-version pragmas (part of Consensys best practice).
+    # Include all directories to also cover node dependencies.
+    printLog "Replacing fixed-version pragmas..."
+    find . test -name '*.sol' -type f -print0 | xargs -0 sed -i -E -e 's/pragma solidity [^;]+;/pragma solidity >=0.0;/'
+}
+
+function neutralize_package_lock
+{
+    # Remove lock files (if they exist) to prevent them from overriding our changes in package.json
+    printLog "Removing package lock files..."
+    rm --force --verbose yarn.lock
+    rm --force --verbose package-lock.json
+}
+
+function neutralize_package_json_hooks
+{
+    printLog "Disabling package.json hooks..."
+    [[ -f package.json ]] || fail "package.json not found"
+    sed -i 's|"prepublish": *".*"|"prepublish": ""|g' package.json
+    sed -i 's|"prepare": *".*"|"prepare": ""|g' package.json
+}
+
+function neutralize_packaged_contracts
+{
+    # Frameworks will build contracts from any package that contains a configuration file.
+    # This is both unnecessary (any files imported from these packages will get compiled again as a
+    # part of the main project anyway) and trips up our version check because it won't use our
+    # custom compiler binary.
+    printLog "Removing framework config and artifacts from npm packages..."
+    find node_modules/ -type f '(' -name 'hardhat.config.*' -o -name 'truffle-config.*' ')' -delete
+
+    # Some npm packages also come packaged with pre-built artifacts.
+    find node_modules/ -path '*artifacts/build-info/*.json' -delete
+}
+
+function force_solc_modules
+{
+    local custom_solcjs_path="${1:-solc/}"
+
+    [[ -d node_modules/ ]] || assertFail
+
+    printLog "Replacing all installed solc-js with a link to the latest version..."
+    soljson_binaries=$(find node_modules -type f -path "*/solc/soljson.js")
+    for soljson_binary in $soljson_binaries
+    do
+        local solc_module_path
+        solc_module_path=$(dirname "$soljson_binary")
+
+        printLog "Found and replaced solc-js in $solc_module_path"
+        rm -r "$solc_module_path"
+        ln -s "$custom_solcjs_path" "$solc_module_path"
+    done
+}
+
+function force_truffle_compiler_settings
+{
+    local config_file="$1"
+    local binary_type="$2"
+    local solc_path="$3"
+    local preset="$4"
+    local evm_version="${5:-"$CURRENT_EVM_VERSION"}"
+    local extra_settings="$6"
+    local extra_optimizer_settings="$7"
+
+    [[ $binary_type == native || $binary_type == solcjs ]] || assertFail
+
+    [[ $binary_type == native ]] && local solc_path="native"
+
+    printLog "Forcing Truffle compiler settings..."
+    echo "-------------------------------------"
+    echo "Config file: $config_file"
+    echo "Binary type: $binary_type"
+    echo "Compiler path: $solc_path"
+    echo "Settings preset: ${preset}"
+    echo "Settings: $(settings_from_preset "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")"
+    echo "EVM version: $evm_version"
+    echo "Compiler version: ${SOLCVERSION_SHORT}"
+    echo "Compiler version (full): ${SOLCVERSION}"
+    echo "-------------------------------------"
+
+    local compiler_settings gas_reporter_settings
+    compiler_settings=$(truffle_compiler_settings "$solc_path" "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")
+    gas_reporter_settings=$(eth_gas_reporter_settings "$preset")
+
+    {
+        echo "require('eth-gas-reporter');"
+        echo "module.exports['mocha'] = {"
+        echo "    reporter: 'eth-gas-reporter',"
+        echo "    reporterOptions: ${gas_reporter_settings}"
+        echo "};"
+
+        echo "module.exports['compilers'] = ${compiler_settings};"
+    } >> "$config_file"
+}
+
+function name_hardhat_default_export
+{
+    local config_file="$1"
+    local import="import {HardhatUserConfig} from 'hardhat/types/config';"
+    local config="const config: HardhatUserConfig = {"
+    sed -i "s|^\s*export\s*default\s*{|${import}\n${config}|g" "$config_file"
+    echo "export default config;" >> "$config_file"
+}
+
+function force_hardhat_timeout
+{
+    local config_file="$1"
+    local config_var_name="$2"
+    local new_timeout="$3"
+
+    printLog "Configuring Hardhat..."
+    echo "-------------------------------------"
+    echo "Timeout: ${new_timeout}"
+    echo "-------------------------------------"
+
+    if [[ $config_file == *\.js ]]; then
+        [[ $config_var_name == "" ]] || assertFail
+        echo "module.exports.mocha = module.exports.mocha || {timeout: ${new_timeout}}"
+        echo "module.exports.mocha.timeout =  ${new_timeout}"
+    else
+        [[ $config_file == *\.ts ]] || assertFail
+        [[ $config_var_name != "" ]] || assertFail
+        echo "${config_var_name}.mocha = ${config_var_name}.mocha ?? {timeout: ${new_timeout}};"
+        echo "${config_var_name}.mocha!.timeout = ${new_timeout}"
+    fi >> "$config_file"
+}
+
+function force_hardhat_compiler_binary
+{
+    local config_file="$1"
+    local binary_type="$2"
+    local solc_path="$3"
+
+    printLog "Configuring Hardhat..."
+    echo "-------------------------------------"
+    echo "Config file: ${config_file}"
+    echo "Binary type: ${binary_type}"
+    echo "Compiler path: ${solc_path}"
+
+    local language="${config_file##*.}"
+    hardhat_solc_build_subtask "$SOLCVERSION_SHORT" "$SOLCVERSION" "$binary_type" "$solc_path" "$language" >> "$config_file"
+}
+
+function force_hardhat_unlimited_contract_size
+{
+    local config_file="$1"
+    local config_var_name="$2"
+
+    printLog "Configuring Hardhat..."
+    echo "-------------------------------------"
+    echo "Allow unlimited contract size: true"
+    echo "-------------------------------------"
+
+    if [[ $config_file == *\.js ]]; then
+        [[ $config_var_name == "" ]] || assertFail
+        echo "module.exports.networks.hardhat = module.exports.networks.hardhat || {allowUnlimitedContractSize: undefined}"
+        echo "module.exports.networks.hardhat.allowUnlimitedContractSize = true"
+    else
+        [[ $config_file == *\.ts ]] || assertFail
+        [[ $config_var_name != "" ]] || assertFail
+        echo "${config_var_name}.networks!.hardhat = ${config_var_name}.networks!.hardhat ?? {allowUnlimitedContractSize: undefined};"
+        echo "${config_var_name}.networks!.hardhat!.allowUnlimitedContractSize = true"
+    fi >> "$config_file"
+}
+
+function force_hardhat_compiler_settings
+{
+    local config_file="$1"
+    local preset="$2"
+    local config_var_name="$3"
+    local evm_version="${4:-"$CURRENT_EVM_VERSION"}"
+    local extra_settings="$5"
+    local extra_optimizer_settings="$6"
+
+    printLog "Configuring Hardhat..."
+    echo "-------------------------------------"
+    echo "Config file: ${config_file}"
+    echo "Settings preset: ${preset}"
+    echo "Settings: $(settings_from_preset "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")"
+    echo "EVM version: ${evm_version}"
+    echo "Compiler version: ${SOLCVERSION_SHORT}"
+    echo "Compiler version (full): ${SOLCVERSION}"
+    echo "-------------------------------------"
+
+    local compiler_settings gas_reporter_settings
+    compiler_settings=$(hardhat_compiler_settings "$SOLCVERSION_SHORT" "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")
+    gas_reporter_settings=$(eth_gas_reporter_settings "$preset")
+    if [[ $config_file == *\.js ]]; then
+        [[ $config_var_name == "" ]] || assertFail
+        echo "require('hardhat-gas-reporter');"
+        echo "module.exports.gasReporter = ${gas_reporter_settings};"
+        echo "module.exports.solidity = ${compiler_settings};"
+    else
+        [[ $config_file == *\.ts ]] || assertFail
+        [[ $config_var_name != "" ]] || assertFail
+        echo 'import "hardhat-gas-reporter";'
+        echo "${config_var_name}.gasReporter = ${gas_reporter_settings};"
+        echo "${config_var_name}.solidity = {compilers: [${compiler_settings}]};"
+    fi >> "$config_file"
+}
+
+function truffle_verify_compiler_version
+{
+    local solc_version="$1"
+    local full_solc_version="$2"
+
+    printLog "Verify that the correct version (${solc_version}/${full_solc_version}) of the compiler was used to compile the contracts..."
+    grep "$full_solc_version" --recursive --quiet build/contracts || fail "Wrong compiler version detected."
+}
+
+function hardhat_verify_compiler_version
+{
+    local solc_version="$1"
+    local full_solc_version="$2"
+
+    printLog "Verify that the correct version (${solc_version}/${full_solc_version}) of the compiler was used to compile the contracts..."
+    local build_info_files
+    build_info_files=$(find . -path '*artifacts/build-info/*.json')
+    for build_info_file in $build_info_files; do
+        grep '"solcVersion":[[:blank:]]*"'"${solc_version}"'"' --quiet "$build_info_file" || fail "Wrong compiler version detected in ${build_info_file}."
+        grep '"solcLongVersion":[[:blank:]]*"'"${full_solc_version}"'"' --quiet "$build_info_file" || fail "Wrong compiler version detected in ${build_info_file}."
+    done
+}
+
+function truffle_clean
+{
+    rm -rf build/
+}
+
+function hardhat_clean
+{
+    rm -rf build/ artifacts/ cache/
+}
+
+function settings_from_preset
+{
+    local preset="$1"
+    local evm_version="$2"
+    local extra_settings="$3"
+    local extra_optimizer_settings="$4"
+
+    [[ " ${AVAILABLE_PRESETS[*]} " == *" $preset "* ]] || assertFail
+
+    [[ $extra_settings == "" ]] || extra_settings="${extra_settings}, "
+    [[ $extra_optimizer_settings == "" ]] || extra_optimizer_settings="${extra_optimizer_settings}, "
+
+    case "$preset" in
+        # NOTE: Remember to update `parallelism` of `t_ems_ext` job in CI config if you add/remove presets
+        legacy-no-optimize)       echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: false, optimizer: {${extra_optimizer_settings}enabled: false}}" ;;
+        ir-no-optimize)           echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: true,  optimizer: {${extra_optimizer_settings}enabled: false}}" ;;
+        legacy-optimize-evm-only) echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: false, optimizer: {${extra_optimizer_settings}enabled: true, details: {yul: false}}}" ;;
+        ir-optimize-evm-only)     echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: true,  optimizer: {${extra_optimizer_settings}enabled: true, details: {yul: false}}}" ;;
+        legacy-optimize-evm+yul)  echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: false, optimizer: {${extra_optimizer_settings}enabled: true, details: {yul: true}}}" ;;
+        ir-optimize-evm+yul)      echo "{${extra_settings}evmVersion: '${evm_version}', viaIR: true,  optimizer: {${extra_optimizer_settings}enabled: true, details: {yul: true}}}" ;;
+        *)
+            fail "Unknown settings preset: '${preset}'."
+            ;;
+    esac
+}
+
+function replace_global_solc
+{
+    local solc_path="$1"
+
+    [[ ! -e solc ]] || fail "A file named 'solc' already exists in '${PWD}'."
+
+    ln -s "$solc_path" solc
+    export PATH="$PWD:$PATH"
+}
+
+function eth_gas_reporter_settings
+{
+    local preset="$1"
+
+    echo "{"
+    echo "    enabled: true,"
+    echo "    gasPrice: 1,"                           # Gas price does not matter to us at all. Set to whatever to avoid API call.
+    echo "    noColors: true,"
+    echo "    showTimeSpent: false,"                  # We're not interested in test timing
+    echo "    onlyCalledMethods: true,"               # Exclude entries with no gas for shorter report
+    echo "    showMethodSig: true,"                   # Should make diffs more stable if there are overloaded functions
+    echo "    outputFile: \"$(gas_report_path "$preset")\""
+    echo "}"
+}
+
+function truffle_compiler_settings
+{
+    local solc_path="$1"
+    local preset="$2"
+    local evm_version="$3"
+    local extra_settings="$4"
+    local extra_optimizer_settings="$5"
+
+    echo "{"
+    echo "    solc: {"
+    echo "        version: \"${solc_path}\","
+    echo "        settings: $(settings_from_preset "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")"
+    echo "    }"
+    echo "}"
+}
+
+function hardhat_solc_build_subtask {
+    local solc_version="$1"
+    local full_solc_version="$2"
+    local binary_type="$3"
+    local solc_path="$4"
+    local language="$5"
+
+    [[ $binary_type == native || $binary_type == solcjs ]] || assertFail
+
+    [[ $binary_type == native ]] && local is_solcjs=false
+    [[ $binary_type == solcjs ]] && local is_solcjs=true
+
+    if [[ $language == js ]]; then
+        echo "const {TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD} = require('hardhat/builtin-tasks/task-names');"
+        echo "const assert = require('assert');"
+        echo
+        echo "subtask(TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD, async (args, hre, runSuper) => {"
+    else
+        [[ $language == ts ]] || assertFail
+        echo "import {TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD} from 'hardhat/builtin-tasks/task-names';"
+        echo "import assert = require('assert');"
+        echo "import {subtask} from 'hardhat/config';"
+        echo
+        echo "subtask(TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD, async (args: any, _hre: any, _runSuper: any) => {"
+    fi
+
+    echo "    assert(args.solcVersion == '${solc_version}', 'Unexpected solc version: ' + args.solcVersion)"
+    echo "    return {"
+    echo "        compilerPath: '$(realpath "$solc_path")',"
+    echo "        isSolcJs: ${is_solcjs},"
+    echo "        version: args.solcVersion,"
+    echo "        longVersion: '${full_solc_version}'"
+    echo "    }"
+    echo "})"
+}
+
+function hardhat_compiler_settings {
+    local solc_version="$1"
+    local preset="$2"
+    local evm_version="$3"
+    local extra_settings="$4"
+    local extra_optimizer_settings="$5"
+
+    echo "{"
+    echo "    version: '${solc_version}',"
+    echo "    settings: $(settings_from_preset "$preset" "$evm_version" "$extra_settings" "$extra_optimizer_settings")"
+    echo "}"
+}
+
+function compile_and_run_test
+{
+    local compile_fn="$1"
+    local test_fn="$2"
+    local verify_fn="$3"
+    local preset="$4"
+    local compile_only_presets="$5"
+
+    [[ $preset != *" "* ]] || assertFail "Preset names must not contain spaces."
+
+    printLog "Running compile function..."
+    time $compile_fn
+    $verify_fn "$SOLCVERSION_SHORT" "$SOLCVERSION"
+
+    if [[ "$COMPILE_ONLY" == 1 || " $compile_only_presets " == *" $preset "* ]]; then
+        printLog "Skipping test function..."
+    else
+        printLog "Running test function..."
+        $test_fn
+    fi
+}
+
+function truffle_run_test
+{
+    local config_file="$1"
+    local binary_type="$2"
+    local solc_path="$3"
+    local preset="$4"
+    local compile_only_presets="$5"
+    local compile_fn="$6"
+    local test_fn="$7"
+    local extra_settings="$8"
+    local extra_optimizer_settings="$9"
+
+    truffle_clean
+    force_truffle_compiler_settings "$config_file" "$binary_type" "$solc_path" "$preset" "$CURRENT_EVM_VERSION" "$extra_settings" "$extra_optimizer_settings"
+    compile_and_run_test compile_fn test_fn truffle_verify_compiler_version "$preset" "$compile_only_presets"
+}
+
+function hardhat_run_test
+{
+    local config_file="$1"
+    local preset="$2"
+    local compile_only_presets="$3"
+    local compile_fn="$4"
+    local test_fn="$5"
+    local config_var_name="$6"
+    local extra_settings="$7"
+    local extra_optimizer_settings="$8"
+
+    hardhat_clean
+    force_hardhat_compiler_settings "$config_file" "$preset" "$config_var_name" "$CURRENT_EVM_VERSION" "$extra_settings" "$extra_optimizer_settings"
+    compile_and_run_test compile_fn test_fn hardhat_verify_compiler_version "$preset" "$compile_only_presets"
+}
+
+function external_test
+{
+    local name="$1"
+    local main_fn="$2"
+
+    printTask "Testing $name..."
+    echo "==========================="
+    DIR=$(mktemp -d -t "ext-test-${name}-XXXXXX")
+    (
+        [[ "$main_fn" != "" ]] || fail "Test main function not defined."
+        $main_fn
+    )
+    rm -rf "$DIR"
+    echo "Done."
+}
+
+function gas_report_path
+{
+    local preset="$1"
+
+    echo "${DIR}/gas-report-${preset}.rst"
+}
+
+function gas_report_to_json
+{
+    cat - | "${REPO_ROOT}/scripts/externalTests/parse_eth_gas_report.py" | jq '{gas: .}'
+}
+
+function detect_hardhat_artifact_dir
+{
+    if [[ -e build/ && -e artifacts/ ]]; then
+        fail "Cannot determine Hardhat artifact location. Both build/ and artifacts/ exist"
+    elif [[ -e build/ ]]; then
+        echo -n build/artifacts
+    elif [[ -e artifacts/ ]]; then
+        echo -n artifacts
+    else
+        fail "Hardhat build artifacts not found."
+    fi
+}
+
+function bytecode_size_json_from_truffle_artifacts
+{
+    # NOTE: The output of this function is a series of concatenated JSON dicts rather than a list.
+
+    for artifact in build/contracts/*.json; do
+        if [[ $(jq '. | has("unlinked_binary")' "$artifact") == false ]]; then
+            # Each artifact represents compilation output for a single contract. Some top-level keys contain
+            # bits of Standard JSON output while others are generated by Truffle. Process it into a dict
+            # of the form `{"<file>": {"<contract>": <size>}}`.
+            # NOTE: The `bytecode` field starts with 0x, which is why we subtract 1 from size.
+            jq '{
+                (.ast.absolutePath): {
+                    (.contractName): (.bytecode | length / 2 - 1)
+                }
+            }' "$artifact"
+        fi
+    done
+}
+
+function bytecode_size_json_from_hardhat_artifacts
+{
+    # NOTE: The output of this function is a series of concatenated JSON dicts rather than a list.
+
+    for artifact in "$(detect_hardhat_artifact_dir)"/build-info/*.json; do
+        # Each artifact contains Standard JSON output under the `output` key.
+        # Process it into a dict of the form `{"<file>": {"<contract>": <size>}}`,
+        # Note that one Hardhat artifact often represents multiple input files.
+        jq '.output.contracts | to_entries[] | {
+            "\(.key)": .value | to_entries[] | {
+                "\(.key)": (.value.evm.bytecode.object | length / 2)
+            }
+        }' "$artifact"
+    done
+}
+
+function combine_artifact_json
+{
+    # Combine all dicts into a list with `jq --slurp` and then use `reduce` to merge them into one
+    # big dict with keys of the form `"<file>:<contract>"`. Then run jq again to filter out items
+    # with zero size and put the rest under under a top-level `bytecode_size` key. Also add another
+    # key with total bytecode size.
+    # NOTE: The extra inner `bytecode_size` key is there only to make diffs more readable.
+    cat - |
+        jq --slurp 'reduce (.[] | to_entries[]) as {$key, $value} ({}; . + {
+            ($key + ":" + ($value | to_entries[].key)): {
+                bytecode_size: $value | to_entries[].value
+            }
+        })' |
+        jq --indent 4 --sort-keys '{
+            bytecode_size: [. | to_entries[] | select(.value.bytecode_size > 0)] | from_entries,
+            total_bytecode_size: (reduce (. | to_entries[]) as {$key, $value} (0; . + $value.bytecode_size))
+        }'
+}
+
+function project_info_json
+{
+    local project_url="$1"
+
+    echo "{"
+    echo "    \"project\": {"
+    # NOTE: Given that we clone with `--depth 1`, we'll only get useful output out of `git describe`
+    # if we directly check out a tag. Still better than nothing.
+    echo "        \"version\": \"$(git describe --always)\","
+    echo "        \"commit\": \"$(git rev-parse HEAD)\","
+    echo "        \"url\": \"${project_url}\""
+    echo "    }"
+    echo "}"
+}
+
+function store_benchmark_report
+{
+    local framework="$1"
+    local project_name="$2"
+    local project_url="$3"
+    local preset="$4"
+
+    [[ $framework == truffle || $framework == hardhat ]] || assertFail
+    [[ " ${AVAILABLE_PRESETS[*]} " == *" $preset "* ]] || assertFail
+
+    local report_dir="${REPO_ROOT}/reports/externalTests"
+    local output_file="${report_dir}/benchmark-${project_name}-${preset}.json"
+    mkdir -p "$report_dir"
+
+    {
+        if [[ -e $(gas_report_path "$preset") ]]; then
+            gas_report_to_json < "$(gas_report_path "$preset")"
+        fi
+
+        "bytecode_size_json_from_${framework}_artifacts" | combine_artifact_json
+        project_info_json "$project_url"
+    } | jq --slurp "{\"${project_name}\": {\"${preset}\": add}}" --indent 4 --sort-keys > "$output_file"
+}
diff --git a/compiler/scripts/externalTests/runners/base.py b/compiler/scripts/externalTests/runners/base.py
new file mode 100644
index 00000000..a79ed534
--- /dev/null
+++ b/compiler/scripts/externalTests/runners/base.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+# ------------------------------------------------------------------------------
+
+import os
+import subprocess
+from abc import ABCMeta
+from abc import abstractmethod
+from dataclasses import dataclass
+from dataclasses import field
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp
+from textwrap import dedent
+from typing import List
+from typing import Set
+
+from test_helpers import download_project
+from test_helpers import get_solc_short_version
+from test_helpers import parse_command_line
+from test_helpers import parse_custom_presets
+from test_helpers import parse_solc_version
+from test_helpers import replace_version_pragmas
+from test_helpers import settings_from_preset
+from test_helpers import SettingsPreset
+
+CURRENT_EVM_VERSION: str = "shanghai"
+
+@dataclass
+class TestConfig:
+    name: str
+    repo_url: str
+    ref_type: str
+    ref: str
+    compile_only_presets: List[SettingsPreset] = field(default_factory=list)
+    settings_presets: List[SettingsPreset] = field(default_factory=lambda: list(SettingsPreset))
+    evm_version: str = field(default=CURRENT_EVM_VERSION)
+
+    def selected_presets(self) -> Set[SettingsPreset]:
+        return set(self.compile_only_presets + self.settings_presets)
+
+
+class BaseRunner(metaclass=ABCMeta):
+    config: TestConfig
+    solc_binary_type: str
+    solc_binary_path: Path
+    presets: Set[SettingsPreset]
+
+    def __init__(self, argv, config: TestConfig):
+        args = parse_command_line(f"{config.name} external tests", argv)
+        self.config = config
+        self.solc_binary_type = args.solc_binary_type
+        self.solc_binary_path = args.solc_binary_path
+        self.presets = parse_custom_presets(args.selected_presets) if args.selected_presets else config.selected_presets()
+        self.env = os.environ.copy()
+        self.tmp_dir = mkdtemp(prefix=f"ext-test-{config.name}-")
+        self.test_dir = Path(self.tmp_dir) / "ext"
+
+    def setup_solc(self) -> str:
+        if self.solc_binary_type == "solcjs":
+            # TODO: add support to solc-js
+            raise NotImplementedError()
+        print("Setting up solc...")
+        solc_version_output = subprocess.check_output(
+            [self.solc_binary_path, "--version"],
+            shell=False,
+            encoding="utf-8"
+        ).split(":")[1]
+        return parse_solc_version(solc_version_output)
+
+    @staticmethod
+    def enter_test_dir(fn):
+        """Run a function inside the test directory"""
+
+        previous_dir = os.getcwd()
+        def f(self, *args, **kwargs):
+            try:
+                assert self.test_dir is not None
+                os.chdir(self.test_dir)
+                return fn(self, *args, **kwargs)
+            finally:
+                # Restore the previous directory after execute fn
+                os.chdir(previous_dir)
+        return f
+
+    def setup_environment(self):
+        """Configure the project build environment"""
+        print("Configuring Runner building environment...")
+        replace_version_pragmas(self.test_dir)
+
+    @enter_test_dir
+    def clean(self):
+        """Clean temporary directories"""
+        rmtree(self.tmp_dir)
+
+    @enter_test_dir
+    @abstractmethod
+    def configure(self):
+        raise NotImplementedError()
+
+    @enter_test_dir
+    @abstractmethod
+    def compile(self, preset: SettingsPreset):
+        raise NotImplementedError()
+
+    @enter_test_dir
+    @abstractmethod
+    def run_test(self):
+        raise NotImplementedError()
+
+def run_test(runner: BaseRunner):
+    print(f"Testing {runner.config.name}...\n===========================")
+    print(f"Selected settings presets: {' '.join(p.value for p in runner.presets)}")
+
+    # Configure solc compiler
+    solc_version = runner.setup_solc()
+    print(f"Using compiler version {solc_version}")
+
+    # Download project
+    download_project(runner.test_dir, runner.config.repo_url, runner.config.ref_type, runner.config.ref)
+
+    # Configure run environment
+    runner.setup_environment()
+
+    # Configure TestRunner instance
+    print(dedent(f"""\
+        Configuring runner's profiles with:
+        -------------------------------------
+        Binary type: {runner.solc_binary_type}
+        Compiler path: {runner.solc_binary_path}
+        -------------------------------------
+    """))
+    runner.configure()
+    for preset in runner.presets:
+        print("Running compile function...")
+        settings = settings_from_preset(preset, runner.config.evm_version)
+        print(dedent(f"""\
+            -------------------------------------
+            Settings preset: {preset.value}
+            Settings: {settings}
+            EVM version: {runner.config.evm_version}
+            Compiler version: {get_solc_short_version(solc_version)}
+            Compiler version (full): {solc_version}
+            -------------------------------------
+        """))
+        runner.compile(preset)
+        # TODO: COMPILE_ONLY should be a command-line option
+        if os.environ.get("COMPILE_ONLY") == "1" or preset in runner.config.compile_only_presets:
+            print("Skipping test function...")
+        else:
+            print("Running test function...")
+            runner.run_test()
+        # TODO: store_benchmark_report
+    runner.clean()
+    print("Done.")
diff --git a/compiler/scripts/externalTests/runners/foundry.py b/compiler/scripts/externalTests/runners/foundry.py
new file mode 100644
index 00000000..3d35f1ac
--- /dev/null
+++ b/compiler/scripts/externalTests/runners/foundry.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+# ------------------------------------------------------------------------------
+
+import os
+import re
+import subprocess
+from shutil import which
+from textwrap import dedent
+from typing import Optional
+
+from runners.base import BaseRunner
+from test_helpers import SettingsPreset
+from test_helpers import settings_from_preset
+
+def run_forge_command(command: str, env: Optional[dict] = None):
+    subprocess.run(
+        command.split(),
+        env=env if env is not None else os.environ.copy(),
+        check=True
+    )
+
+
+class FoundryRunner(BaseRunner):
+    """Configure and run Foundry-based projects"""
+
+    FOUNDRY_CONFIG_FILE = "foundry.toml"
+
+    def setup_environment(self):
+        super().setup_environment()
+        if which("forge") is None:
+            raise RuntimeError("Forge not found.")
+
+    @staticmethod
+    def profile_name(preset: SettingsPreset):
+        """Returns foundry profile name"""
+        # Replace - or + by underscore to avoid invalid toml syntax
+        return re.sub(r"(\-|\+)+", "_", preset.value)
+
+    @staticmethod
+    def profile_section(profile_fields: dict) -> str:
+        return dedent("""\
+            [profile.{name}]
+            gas_reports = ["*"]
+            auto_detect_solc = false
+            solc = "{solc}"
+            evm_version = "{evm_version}"
+            optimizer = {optimizer}
+            via_ir = {via_ir}
+
+            [profile.{name}.optimizer_details]
+            yul = {yul}
+        """).format(**profile_fields)
+
+    def setup_presets_profiles(self):
+        """Configure forge tests profiles"""
+
+        profiles = []
+        for preset in self.presets:
+            settings = settings_from_preset(preset, self.config.evm_version)
+            profiles.append(self.profile_section({
+                "name": self.profile_name(preset),
+                "solc": self.solc_binary_path,
+                "evm_version": self.config.evm_version,
+                "optimizer": str(settings["optimizer"]["enabled"]).lower(),
+                "via_ir": str(settings["viaIR"]).lower(),
+                "yul": str(settings["optimizer"]["details"]["yul"]).lower(),
+            }))
+
+        with open(
+            file=self.test_dir / self.FOUNDRY_CONFIG_FILE,
+            mode="a",
+            encoding="utf-8",
+        ) as f:
+            for profile in profiles:
+                f.write(profile)
+
+    @BaseRunner.enter_test_dir
+    def configure(self):
+        """Install project dependencies"""
+        self.setup_presets_profiles()
+        run_forge_command("forge install", self.env)
+
+    @BaseRunner.enter_test_dir
+    def compile(self, preset: SettingsPreset):
+        """Compile project"""
+
+        # Set the Foundry profile environment variable
+        self.env.update({"FOUNDRY_PROFILE": self.profile_name(preset)})
+        run_forge_command("forge build", self.env)
+
+    @BaseRunner.enter_test_dir
+    def run_test(self):
+        """Run project tests"""
+
+        run_forge_command("forge test --gas-report", self.env)
diff --git a/compiler/scripts/externalTests/test_helpers.py b/compiler/scripts/externalTests/test_helpers.py
new file mode 100644
index 00000000..9a573d50
--- /dev/null
+++ b/compiler/scripts/externalTests/test_helpers.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+# ------------------------------------------------------------------------------
+
+import os
+import re
+import subprocess
+import sys
+from argparse import ArgumentParser
+from enum import Enum
+from pathlib import Path
+from typing import List
+from typing import Set
+
+# Our scripts/ is not a proper Python package so we need to modify PYTHONPATH to import from it
+# pragma pylint: disable=import-error,wrong-import-position
+PROJECT_ROOT = Path(__file__).parents[2]
+sys.path.insert(0, f"{PROJECT_ROOT}/scripts/common")
+
+from git_helpers import git_commit_hash
+
+SOLC_FULL_VERSION_REGEX = re.compile(r"^[a-zA-Z: ]*(.*)$")
+SOLC_SHORT_VERSION_REGEX = re.compile(r"^([0-9.]+).*\+|\-$")
+
+
+class SettingsPreset(Enum):
+    LEGACY_NO_OPTIMIZE = 'legacy-no-optimize'
+    IR_NO_OPTIMIZE = 'ir-no-optimize'
+    LEGACY_OPTIMIZE_EVM_ONLY = 'legacy-optimize-evm-only'
+    IR_OPTIMIZE_EVM_ONLY = 'ir-optimize-evm-only'
+    LEGACY_OPTIMIZE_EVM_YUL = 'legacy-optimize-evm+yul'
+    IR_OPTIMIZE_EVM_YUL = 'ir-optimize-evm+yul'
+
+
+def compiler_settings(evm_version: str, via_ir: bool = False, optimizer: bool = False, yul: bool = False) -> dict:
+    return {
+        "optimizer": {"enabled": optimizer, "details": {"yul": yul}},
+        "evmVersion": evm_version,
+        "viaIR": via_ir,
+    }
+
+
+def settings_from_preset(preset: SettingsPreset, evm_version: str) -> dict:
+    return {
+        SettingsPreset.LEGACY_NO_OPTIMIZE:       compiler_settings(evm_version),
+        SettingsPreset.IR_NO_OPTIMIZE:           compiler_settings(evm_version, via_ir=True),
+        SettingsPreset.LEGACY_OPTIMIZE_EVM_ONLY: compiler_settings(evm_version, optimizer=True),
+        SettingsPreset.IR_OPTIMIZE_EVM_ONLY:     compiler_settings(evm_version, via_ir=True, optimizer=True),
+        SettingsPreset.LEGACY_OPTIMIZE_EVM_YUL:  compiler_settings(evm_version, optimizer=True, yul=True),
+        SettingsPreset.IR_OPTIMIZE_EVM_YUL:      compiler_settings(evm_version, via_ir=True, optimizer=True, yul=True),
+    }[preset]
+
+
+def parse_custom_presets(presets: List[str]) -> Set[SettingsPreset]:
+    return {SettingsPreset(p) for p in presets}
+
+def parse_command_line(description: str, args: List[str]):
+    arg_parser = ArgumentParser(description)
+    arg_parser.add_argument(
+        "solc_binary_type",
+        metavar="solc-binary-type",
+        type=str,
+        default="native",
+        choices=["native", "solcjs"],
+        help="""Solidity compiler binary type""",
+    )
+    arg_parser.add_argument(
+        "solc_binary_path",
+        metavar="solc-binary-path",
+        type=Path,
+        help="""Path to solc binary""",
+    )
+    arg_parser.add_argument(
+        "selected_presets",
+        metavar="selected-presets",
+        help="""List of compiler settings presets""",
+        nargs='*',
+    )
+    return arg_parser.parse_args(args)
+
+
+def download_project(test_dir: Path, repo_url: str, ref_type: str = "branch", ref: str = "master"):
+    assert ref_type in ("commit", "branch", "tag")
+
+    print(f"Cloning {ref_type} {ref} of {repo_url}...")
+    if ref_type == "commit":
+        os.mkdir(test_dir)
+        os.chdir(test_dir)
+        subprocess.run(["git", "init"], check=True)
+        subprocess.run(["git", "remote", "add", "origin", repo_url], check=True)
+        subprocess.run(["git", "fetch", "--depth", "1", "origin", ref], check=True)
+        subprocess.run(["git", "reset", "--hard", "FETCH_HEAD"], check=True)
+    else:
+        os.chdir(test_dir.parent)
+        subprocess.run(["git", "clone", "--no-progress", "--depth", "1", repo_url, "-b", ref, test_dir.resolve()], check=True)
+        if not test_dir.exists():
+            raise RuntimeError("Failed to clone the project.")
+        os.chdir(test_dir)
+
+    if (test_dir / ".gitmodules").exists():
+        subprocess.run(["git", "submodule", "update", "--init"], check=True)
+
+    print(f"Current commit hash: {git_commit_hash()}")
+
+
+def parse_solc_version(solc_version_string: str) -> str:
+    solc_version_match = re.search(SOLC_FULL_VERSION_REGEX, solc_version_string)
+    if solc_version_match is None:
+        raise RuntimeError(f"Solc version could not be found in: {solc_version_string}.")
+    return solc_version_match.group(1)
+
+
+def get_solc_short_version(solc_full_version: str) -> str:
+    solc_short_version_match = re.search(SOLC_SHORT_VERSION_REGEX, solc_full_version)
+    if solc_short_version_match is None:
+        raise RuntimeError(f"Error extracting short version string from: {solc_full_version}.")
+    return solc_short_version_match.group(1)
+
+
+def store_benchmark_report(self):
+    raise NotImplementedError()
+
+
+def replace_version_pragmas(test_dir: Path):
+    """
+    Replace fixed-version pragmas (part of Consensys best practice).
+    Include all directories to also cover node dependencies.
+    """
+    print("Replacing fixed-version pragmas...")
+    for source in test_dir.glob("**/*.sol"):
+        content = source.read_text(encoding="utf-8")
+        content = re.sub(r"pragma solidity [^;]+;", r"pragma solidity >=0.0;", content)
+        with open(source, "w", encoding="utf-8") as f:
+            f.write(content)
diff --git a/compiler/scripts/externalTests/update_external_repos.sh b/compiler/scripts/externalTests/update_external_repos.sh
index 2270691e..8a25f379 100755
--- a/compiler/scripts/externalTests/update_external_repos.sh
+++ b/compiler/scripts/externalTests/update_external_repos.sh
@@ -80,10 +80,9 @@ cd "$target_dir"
 clone_repo brinktrade        brink-core
 clone_repo dapphub           dappsys-monolithic
 clone_repo element-fi        elf-contracts
-clone_repo ensdomains        ens
 clone_repo ensdomains        ens-contracts
 clone_repo euler-xyz         euler-contracts
-clone_repo gnosis            gp-v2-contracts
+clone_repo cowprotocol       contracts                 gp2-contracts
 clone_repo gnosis            mock-contract
 clone_repo gnosis            util-contracts
 clone_repo JoinColony        colonyNetwork
@@ -102,10 +101,9 @@ clone_repo yieldprotocol     yield-liquidator-v2
 sync_branch brink-core                master
 sync_branch dappsys-monolithic        master
 sync_branch elf-contracts             main
-sync_branch ens                       master
 sync_branch ens-contracts             master
 sync_branch euler-contracts           master
-sync_branch gp-v2-contracts           main
+sync_branch gp2-contracts             main
 sync_branch mock-contract             master
 sync_branch util-contracts            main
 sync_branch colonyNetwork             develop
diff --git a/compiler/scripts/gas_diff_stats.py b/compiler/scripts/gas_diff_stats.py
index 56cd0cd4..234d42df 100755
--- a/compiler/scripts/gas_diff_stats.py
+++ b/compiler/scripts/gas_diff_stats.py
@@ -75,7 +75,7 @@ def collect_statistics(lines) -> (int, int, int, int, int, int):
 
     """
     if not lines:
-        raise Exception("Empty list")
+        raise RuntimeError("Empty list")
 
     def try_parse(line):
         try:
diff --git a/compiler/scripts/install_deps.ps1 b/compiler/scripts/install_deps.ps1
index e7726993..26a9e116 100644
--- a/compiler/scripts/install_deps.ps1
+++ b/compiler/scripts/install_deps.ps1
@@ -6,23 +6,26 @@ $progressPreference = "silentlyContinue"
 if ( -not (Test-Path "$PSScriptRoot\..\deps\boost") ) {
   New-Item -ItemType Directory -Force -Path "$PSScriptRoot\..\deps"
 
-  Invoke-WebRequest -URI "https://github.com/Kitware/CMake/releases/download/v3.18.2/cmake-3.18.2-win64-x64.zip" -OutFile cmake.zip
-  if ((Get-FileHash cmake.zip).Hash -ne "5f4ec834fbd9b62fbf73bc48ed459fa2ea6a86c403106c90fedc2ac76d51612d") {
+  Invoke-WebRequest -URI "https://github.com/Kitware/CMake/releases/download/v3.27.4/cmake-3.27.4-windows-x86_64.zip" -OutFile cmake.zip
+  if ((Get-FileHash cmake.zip).Hash -ne "e5e060756444d0b2070328a8821c1ceb62bd6d267aae61bfff06f96c7ec943a6") {
     throw 'Downloaded CMake source package has wrong checksum.'
   }
   tar -xf cmake.zip
-  mv cmake-3.18.2-win64-x64 "$PSScriptRoot\..\deps\cmake"
+  mv cmake-3.27.4-windows-x86_64 "$PSScriptRoot\..\deps\cmake"
+  Remove-Item cmake.zip
 
   # FIXME: The default user agent results in Artifactory treating Invoke-WebRequest as a browser
   # and serving it a page that requires JavaScript.
-  Invoke-WebRequest -URI "https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.zip" -OutFile boost.zip -UserAgent ""
-  if ((Get-FileHash boost.zip).Hash -ne "d2886ceff60c35fc6dc9120e8faa960c1e9535f2d7ce447469eae9836110ea77") {
+  Invoke-WebRequest -URI "https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.zip" -OutFile boost.zip -UserAgent ""
+  if ((Get-FileHash boost.zip).Hash -ne "c86bd9d9eef795b4b0d3802279419fde5221922805b073b9bd822edecb1ca28e") {
     throw 'Downloaded Boost source package has wrong checksum.'
   }
   tar -xf boost.zip
-  cd boost_1_77_0
+  Remove-Item boost.zip
+  cd boost_1_83_0
   .\bootstrap.bat
   .\b2 -j4 -d0 link=static runtime-link=static variant=release threading=multi address-model=64 --with-filesystem --with-system --with-program_options --with-test --prefix="$PSScriptRoot\..\deps\boost" install
   if ( -not $? ) { throw "Error building boost." }
   cd ..
+  Remove-Item -LiteralPath .\boost_1_83_0 -Force -Recurse
 }
diff --git a/compiler/scripts/install_evmone.ps1 b/compiler/scripts/install_evmone.ps1
index ace3e575..acbacdaf 100644
--- a/compiler/scripts/install_evmone.ps1
+++ b/compiler/scripts/install_evmone.ps1
@@ -3,7 +3,7 @@ $ErrorActionPreference = "Stop"
 # Needed for Invoke-WebRequest to work via CI.
 $progressPreference = "silentlyContinue"
 
-Invoke-WebRequest -URI "https://github.com/ethereum/evmone/releases/download/v0.8.0/evmone-0.8.0-windows-amd64.zip" -OutFile "evmone.zip"
+Invoke-WebRequest -URI "https://github.com/ethereum/evmone/releases/download/v0.11.0/evmone-0.11.0-windows-amd64.zip" -OutFile "evmone.zip"
 tar -xf evmone.zip "bin/evmone.dll"
 mkdir deps
 mv bin/evmone.dll deps
diff --git a/compiler/scripts/install_lib_variable.sh b/compiler/scripts/install_lib_variable.sh
deleted file mode 100755
index 08dec8d8..00000000
--- a/compiler/scripts/install_lib_variable.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-
-if [ -z "${TVM_LINKER_LIB_PATH}" ]; then
-    SCRIPTPATH="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
-    LIBPATH=$(dirname $(dirname $SCRIPTPATH))'/lib/stdlib_sol.tvm'
-    SET_LIBPATH='export TVM_LINKER_LIB_PATH='$LIBPATH
-    echo $SET_LIBPATH >> ~/.bashrc
-fi
\ No newline at end of file
diff --git a/compiler/scripts/install_obsolete_jsoncpp_1_7_4.sh b/compiler/scripts/install_obsolete_jsoncpp_1_7_4.sh
index 825d1a58..f9de0245 100755
--- a/compiler/scripts/install_obsolete_jsoncpp_1_7_4.sh
+++ b/compiler/scripts/install_obsolete_jsoncpp_1_7_4.sh
@@ -17,7 +17,7 @@ TEMPDIR=$(mktemp -d)
     cd "jsoncpp-${jsoncpp_version}"
     mkdir -p build
     cd build
-    cmake -DARCHIVE_INSTALL_DIR=. -G "Unix Makefiles" ..
+    cmake -DCMAKE_OSX_ARCHITECTURES:STRING="x86_64;arm64" -DARCHIVE_INSTALL_DIR=. -G "Unix Makefiles" ..
     make
     make install
 )
diff --git a/compiler/scripts/list_contributors.sh b/compiler/scripts/list_contributors.sh
new file mode 100755
index 00000000..4b8f06d7
--- /dev/null
+++ b/compiler/scripts/list_contributors.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# Creates a list containing names of people who contributed to the project, for use
+# in release notes. The names come from the author field on the commits between
+# the current revision and the one specified as argument.
+#
+# Note that the output often requires extra manual processing to remove entries
+# that refer to the same person (diacritics vs no diacritics, name vs nickname, etc.).
+#
+# Usage:
+#    <script name>.sh <revision>
+#
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -euo pipefail
+
+script_dir=$(dirname "$0")
+# shellcheck source=scripts/common.sh
+source "${script_dir}/common.sh"
+
+(( $# == 1)) || fail "Wrong number of arguments. Usage: $0 <revision>."
+
+revision="$1"
+
+# NOTE: Commas are removed from any names containing them. It would look confusing otherwise, given
+# that the list is delimited by commas. Hopefully no contributor uses a comma as their nickname.
+git shortlog --summary "${revision}..origin/develop" |
+    cut --field 2 |
+    tr --delete , |
+    sort |
+    uniq |
+    paste --serial --delimiter=, |
+    sed -e 's/,/, /g'
diff --git a/compiler/scripts/pylintrc b/compiler/scripts/pylintrc
index 3a2b8529..5ef5a6ef 100644
--- a/compiler/scripts/pylintrc
+++ b/compiler/scripts/pylintrc
@@ -23,6 +23,7 @@ disable=
     no-else-return,
     pointless-string-statement,
     redefined-outer-name,
+    superfluous-parens,
     too-few-public-methods,
     too-many-arguments,
     too-many-branches,
@@ -62,3 +63,7 @@ expected-line-ending-format=LF
 
 # Maximum number of characters on a single line.
 max-line-length=130
+
+[MISCELLANEOUS]
+
+notes=XXX,TMP
diff --git a/compiler/scripts/release_ppa.sh b/compiler/scripts/release_ppa.sh
index ac0a6898..252fd4c4 100755
--- a/compiler/scripts/release_ppa.sh
+++ b/compiler/scripts/release_ppa.sh
@@ -68,7 +68,7 @@ packagename=solc
 # This needs to be a still active release
 static_build_distribution=focal
 
-DISTRIBUTIONS="focal jammy kinetic"
+DISTRIBUTIONS="focal jammy lunar mantic"
 
 if is_release
 then
@@ -127,7 +127,7 @@ mv solidity solc
 mkdir -p ./solc/deps/downloads/ 2>/dev/null || true
 wget -O ./solc/deps/downloads/jsoncpp-1.9.3.tar.gz https://github.com/open-source-parsers/jsoncpp/archive/1.9.3.tar.gz
 wget -O ./solc/deps/downloads/range-v3-0.12.0.tar.gz https://github.com/ericniebler/range-v3/archive/0.12.0.tar.gz
-wget -O ./solc/deps/downloads/fmt-8.0.1.tar.gz https://github.com/fmtlib/fmt/archive/8.0.1.tar.gz
+wget -O ./solc/deps/downloads/fmt-9.1.0.tar.gz https://github.com/fmtlib/fmt/archive/9.1.0.tar.gz
 
 # Determine version
 cd solc
@@ -173,7 +173,7 @@ Build-Depends: ${SMTDEPENDENCY}debhelper (>= 9.0.0),
                scons
 Standards-Version: 3.9.5
 Homepage: https://ethereum.org
-Vcs-Git: git://github.com/ethereum/solidity.git
+Vcs-Git: https://github.com/ethereum/solidity.git
 Vcs-Browser: https://github.com/ethereum/solidity
 
 Package: solc
@@ -217,7 +217,7 @@ override_dh_shlibdeps:
 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
 
 override_dh_auto_configure:
-	dh_auto_configure -- -DTESTS=OFF ${CMAKE_OPTIONS}
+	dh_auto_configure -- -DTESTS=OFF -DFETCHCONTENT_FULLY_DISCONNECTED=OFF ${CMAKE_OPTIONS}
 EOF
 cat <<EOF > debian/copyright
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
diff --git a/compiler/scripts/solc-bin/bytecode_reports_for_modified_binaries.sh b/compiler/scripts/solc-bin/bytecode_reports_for_modified_binaries.sh
index 68ab995a..bd625191 100755
--- a/compiler/scripts/solc-bin/bytecode_reports_for_modified_binaries.sh
+++ b/compiler/scripts/solc-bin/bytecode_reports_for_modified_binaries.sh
@@ -104,6 +104,9 @@ tmp_dir=$(mktemp -d -t bytecode-reports-XXXXXX)
 solcjs_dir="$tmp_dir/solcjs"
 script_dir="$solidity_dir/scripts"
 
+# Set locale to C to prevent it from affecting glob sort order.
+export LC_ALL=C
+
 cd "$tmp_dir"
 
 git clone https://github.com/ethereum/solc-js.git "$solcjs_dir"
@@ -157,7 +160,7 @@ for binary_name in $platform_binaries; do
                 "$solidity_version_and_commit"
 
             # shellcheck disable=SC2035
-            ./prepare_report.js --strip-smt-pragmas *.sol > "${report_dir}/report-${binary_name}.txt"
+            ./prepare_report.js --strip-smt-pragmas *.sol --report-file "${report_dir}/report-${binary_name}.txt"
         else
             yul_optimizer_flags=()
             if [[ $solidity_version == 0.6.0 ]] || [[ $solidity_version == 0.6.1 ]]; then
diff --git a/compiler/scripts/splitSources.py b/compiler/scripts/splitSources.py
index d31202fb..5e783b2d 100755
--- a/compiler/scripts/splitSources.py
+++ b/compiler/scripts/splitSources.py
@@ -13,9 +13,6 @@
 import os
 import traceback
 
-hasMultipleSources = False
-createdSources = []
-
 
 def uncaught_exception_hook(exc_type, exc_value, exc_traceback):
     # The script `scripts/ASTImportTest.sh` will interpret return code 3
@@ -43,20 +40,18 @@ def writeSourceToFile(lines):
     if filePath:
         os.system("mkdir -p " + filePath)
     with open(srcName, mode='a+', encoding='utf8', newline='') as f:
-        createdSources.append(srcName)
         for idx, line in enumerate(lines[1:]):
             # write to file
             if line[:12] != "==== Source:":
-                f.write(line)
+                f.write(line + '\n')
 
             # recursive call if there is another source
             else:
-                writeSourceToFile(lines[1+idx:])
-                break
+                return [srcName] + writeSourceToFile(lines[1+idx:])
 
+    return [srcName]
 
-if __name__ == '__main__':
-    filePath = sys.argv[1]
+def split_sources(filePath, suppress_output = False):
     sys.excepthook = uncaught_exception_hook
 
     try:
@@ -64,20 +59,20 @@ def writeSourceToFile(lines):
         with open(filePath, mode='r', encoding='utf8', newline='') as f:
             lines = f.read().splitlines()
         if len(lines) >= 1 and lines[0][:12] == "==== Source:":
-            hasMultipleSources = True
-            writeSourceToFile(lines)
-
-        if hasMultipleSources:
             srcString = ""
-            for src in createdSources:
+            for src in writeSourceToFile(lines):
                 srcString += src + ' '
-            print(srcString)
-            sys.exit(0)
-        else:
-            sys.exit(1)
+            if not suppress_output:
+                print(srcString)
+            return 0
+        return 1
 
     except UnicodeDecodeError as ude:
         print("UnicodeDecodeError in '" + filePath + "': " + str(ude))
         print("This is expected for some tests containing invalid utf8 sequences. "
               "Exception will be ignored.")
-        sys.exit(2)
+        return 2
+
+
+if __name__ == '__main__':
+    sys.exit(split_sources(sys.argv[1]))
diff --git a/compiler/scripts/test_antlr_grammar.sh b/compiler/scripts/test_antlr_grammar.sh
index 5745f01b..5256b812 100755
--- a/compiler/scripts/test_antlr_grammar.sh
+++ b/compiler/scripts/test_antlr_grammar.sh
@@ -110,7 +110,7 @@ do
   SOL_FILES+=("$line")
 done < <(
   grep --include "*.sol" -riL -E \
-    "^\/\/ (Syntax|Type|Declaration)Error|^\/\/ ParserError (1684|2837|3716|3997|5333|6275|6281|6933|7319)|^==== Source:" \
+    "^\/\/ (Syntax|Type|Declaration)Error|^\/\/ ParserError (1684|2837|3716|3997|5333|6275|6281|6933|7319|8185|7637)|^==== Source:|^pragma experimental solidity;" \
     "${ROOT_DIR}/test/libsolidity/syntaxTests" \
     "${ROOT_DIR}/test/libsolidity/semanticTests" |
       # Skipping the unicode tests as I couldn't adapt the lexical grammar to recursively counting RLO/LRO/PDF's.
@@ -121,6 +121,18 @@ done < <(
       grep -v -E 'revertStatement/non_called.sol' |
       # Skipping a test with "let basefee := ..."
       grep -v -E 'inlineAssembly/basefee_berlin_function.sol' |
+      # Skipping a test with "let blobbasefee := ..."
+      grep -v -E 'inlineAssembly/blobbasefee_shanghai_function.sol' |
+      # Skipping a test with "let mcopy := ..."
+      grep -v -E 'inlineAssembly/mcopy_as_identifier_pre_cancun.sol' |
+      # Skipping tests with "let prevrandao := ..."
+      grep -v -E 'inlineAssembly/prevrandao_allowed_function_pre_paris.sol' |
+      grep -v -E 'inlineAssembly/prevrandao_disallowed_function_post_paris.sol' |
+      # Skipping a test with "let blobhash := ..."
+      grep -v -E 'inlineAssembly/blobhash_pre_cancun.sol' |
+      grep -v -E 'inlineAssembly/blobhash_pre_cancun_not_reserved.sol' |
+      # Skipping tests with "let tstore/tload := ..."
+      grep -v -E 'inlineAssembly/tload_tstore_not_reserved_before_cancun.sol' |
       # Skipping license error, unrelated to the grammar
       grep -v -E 'license/license_double5.sol' |
       grep -v -E 'license/license_hidden_unicode.sol' |
diff --git a/compiler/scripts/tests.sh b/compiler/scripts/tests.sh
index 80559f5e..9df40e38 100755
--- a/compiler/scripts/tests.sh
+++ b/compiler/scripts/tests.sh
@@ -105,7 +105,7 @@ EVM_VERSIONS="homestead byzantium"
 
 if [ -z "$CI" ]
 then
-    EVM_VERSIONS+=" constantinople petersburg istanbul berlin london"
+    EVM_VERSIONS+=" constantinople petersburg istanbul berlin london paris shanghai cancun"
 fi
 
 # And then run the Solidity unit-tests in the matrix combination of optimizer / no optimizer
@@ -115,9 +115,9 @@ do
     for vm in $EVM_VERSIONS
     do
         FORCE_ABIV1_RUNS="no"
-        if [[ "$vm" == "london" ]]
+        if [[ "$vm" == "shanghai" ]]
         then
-            FORCE_ABIV1_RUNS="no yes" # run both in london
+            FORCE_ABIV1_RUNS="no yes" # run both in paris
         fi
         for abiv1 in $FORCE_ABIV1_RUNS
         do
@@ -139,11 +139,8 @@ do
                 fi
             fi
 
-            EWASM_ARGS=""
-            [ "${vm}" = "byzantium" ] && [ "${optimize}" = "" ] && EWASM_ARGS="--ewasm"
-
             set +e
-            "${SOLIDITY_BUILD_DIR}"/test/soltest --show-progress "${log[@]}" -- ${EWASM_ARGS} --testpath "$REPO_ROOT"/test "$optimize" --evm-version "$vm" "${SMT_FLAGS[@]}" "${force_abiv1_flag[@]}"
+            "${SOLIDITY_BUILD_DIR}"/test/soltest --show-progress "${log[@]}" -- --testpath "$REPO_ROOT"/test "$optimize" --evm-version "$vm" "${SMT_FLAGS[@]}" "${force_abiv1_flag[@]}"
 
             if test "0" -ne "$?"; then
                 exit 1
diff --git a/compiler/solc/CommandLineInterface.cpp b/compiler/solc/CommandLineInterface.cpp
index a15c0f9b..7897678d 100644
--- a/compiler/solc/CommandLineInterface.cpp
+++ b/compiler/solc/CommandLineInterface.cpp
@@ -42,7 +42,6 @@
 
 
 #include <liblangutil/Exceptions.h>
-#include <liblangutil/Scanner.h>
 #include <liblangutil/SourceReferenceFormatter.h>
 
 #include <libsmtutil/Exceptions.h>
@@ -60,7 +59,6 @@
 
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/operations.hpp>
-#include <boost/range/adaptor/filtered.hpp>
 #include <boost/algorithm/string.hpp>
 
 #ifdef _WIN32 // windows
@@ -77,23 +75,32 @@
 	#define STDERR_FILENO 2
 #endif
 
-
-using namespace std;
+using namespace std::string_literals;
 using namespace solidity;
 using namespace solidity::util;
 using namespace solidity::langutil;
 
+namespace
+{
+
+std::set<frontend::InputMode> const CompilerInputModes{
+	frontend::InputMode::Compiler,
+	frontend::InputMode::CompilerWithASTImport,
+};
+
+} // anonymous namespace
+
 namespace solidity::frontend
 {
 
-ostream& CommandLineInterface::sout(bool _markAsUsed)
+std::ostream& CommandLineInterface::sout(bool _markAsUsed)
 {
 	if (_markAsUsed)
 		m_hasOutput = true;
 	return m_sout;
 }
 
-ostream& CommandLineInterface::serr(bool _markAsUsed)
+std::ostream& CommandLineInterface::serr(bool _markAsUsed)
 {
 	if (_markAsUsed)
 		m_hasOutput = true;
@@ -130,9 +137,9 @@ static bool coloredOutput(CommandLineOptions const& _options)
 		(_options.formatting.coloredOutput.has_value() && _options.formatting.coloredOutput.value());
 }
 
-void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contract)
+void CommandLineInterface::handleNatspec(bool _natspecDev, std::string const& _contract)
 {
-	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport, "");
+	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	bool enabled = false;
 	std::string suffix;
@@ -166,8 +173,8 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
 			createFile(m_compiler->filesystemFriendlyName(_contract) + suffix, output);
 		else
 		{
-			sout() << title << endl;
-			sout() << output << endl;
+			sout() << title << std::endl;
+			sout() << output << std::endl;
 		}
 
 	}
@@ -175,13 +182,18 @@ void CommandLineInterface::handleNatspec(bool _natspecDev, string const& _contra
 
 void CommandLineInterface::readInputFiles()
 {
-	solAssert(!m_standardJsonInput.has_value(), "");
+	solAssert(!m_standardJsonInput.has_value());
 
-	if (
-		m_options.input.mode == InputMode::Help ||
-		m_options.input.mode == InputMode::License ||
-		m_options.input.mode == InputMode::Version
-	)
+	if (m_options.input.noImportCallback)
+		m_universalCallback.resetImportCallback();
+
+	static std::set<frontend::InputMode> const noInputFiles{
+		frontend::InputMode::Help,
+		frontend::InputMode::License,
+		frontend::InputMode::Version
+	};
+
+	if (noInputFiles.count(m_options.input.mode) == 1)
 		return;
 
 	m_fileReader.setBasePath(m_options.input.basePath);
@@ -201,13 +213,13 @@ void CommandLineInterface::readInputFiles()
 	for (boost::filesystem::path const& allowedDirectory: m_options.input.allowedDirectories)
 		m_fileReader.allowDirectory(allowedDirectory);
 
-	map<std::string, set<boost::filesystem::path>> collisions =
+	std::map<std::string, std::set<boost::filesystem::path>> collisions =
 		m_fileReader.detectSourceUnitNameCollisions(m_options.input.paths);
 	if (!collisions.empty())
 	{
 		auto pathToQuotedString = [](boost::filesystem::path const& _path){ return "\"" + _path.string() + "\""; };
 
-		string message =
+		std::string message =
 			"Source unit name collision detected. "
 			"The specified values of base path and/or include paths would result in multiple "
 			"input files being assigned the same source unit name:\n";
@@ -228,7 +240,7 @@ void CommandLineInterface::readInputFiles()
 			if (!m_options.input.ignoreMissingFiles)
 				solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not found.");
 			else
-				serr() << infile << " is not found. Skipping." << endl;
+				report(Error::Severity::Info, fmt::format("\"{}\" is not found. Skipping.", infile.string()));
 
 			continue;
 		}
@@ -238,16 +250,16 @@ void CommandLineInterface::readInputFiles()
 			if (!m_options.input.ignoreMissingFiles)
 				solThrow(CommandLineValidationError, '"' + infile.string() + "\" is not a valid file.");
 			else
-				serr() << infile << " is not a valid file. Skipping." << endl;
+				report(Error::Severity::Info, fmt::format("\"{}\" is not a valid file. Skipping.", infile.string()));
 
 			continue;
 		}
 
 		// NOTE: we ignore the FileNotFound exception as we manually check above
-		string fileContent = readFileAsString(infile);
+		std::string fileContent = readFileAsString(infile);
 		if (m_options.input.mode == InputMode::StandardJson)
 		{
-			solAssert(!m_standardJsonInput.has_value(), "");
+			solAssert(!m_standardJsonInput.has_value());
 			m_standardJsonInput = std::move(fileContent);
 		}
 		else
@@ -261,7 +273,7 @@ void CommandLineInterface::readInputFiles()
 	{
 		if (m_options.input.mode == InputMode::StandardJson)
 		{
-			solAssert(!m_standardJsonInput.has_value(), "");
+			solAssert(!m_standardJsonInput.has_value());
 			m_standardJsonInput = readUntilEnd(m_sin);
 		}
 		else
@@ -276,12 +288,12 @@ void CommandLineInterface::readInputFiles()
 		solThrow(CommandLineValidationError, "All specified input files either do not exist or are not regular files.");
 }
 
-map<string, Json::Value> CommandLineInterface::parseAstFromInput()
+std::map<std::string, Json::Value> CommandLineInterface::parseAstFromInput()
 {
-	solAssert(m_options.input.mode == InputMode::CompilerWithASTImport, "");
+	solAssert(m_options.input.mode == InputMode::CompilerWithASTImport);
 
-	map<string, Json::Value> sourceJsons;
-	map<string, string> tmpSources;
+	std::map<std::string, Json::Value> sourceJsons;
+	std::map<std::string, std::string> tmpSources;
 
 	for (SourceCode const& sourceCode: m_fileReader.sourceUnits() | ranges::views::values)
 	{
@@ -306,22 +318,22 @@ map<string, Json::Value> CommandLineInterface::parseAstFromInput()
 	return sourceJsons;
 }
 
-void CommandLineInterface::createFile(string const& _fileName, string const& _data)
+void CommandLineInterface::createFile(std::string const& _fileName, std::string const& _data)
 {
 	namespace fs = boost::filesystem;
 
-	solAssert(!m_options.output.dir.empty(), "");
+	solAssert(!m_options.output.dir.empty());
 
 	// NOTE: create_directories() raises an exception if the path consists solely of '.' or '..'
 	// (or equivalent such as './././.'). Paths like 'a/b/.' and 'a/b/..' are fine though.
 	// The simplest workaround is to use an absolute path.
 	fs::create_directories(fs::absolute(m_options.output.dir));
 
-	string pathName = (m_options.output.dir / _fileName).string();
+	std::string pathName = (m_options.output.dir / _fileName).string();
 	if (fs::exists(pathName) && !m_options.output.overwriteFiles)
 		solThrow(CommandLineOutputError, "Refusing to overwrite existing file \"" + pathName + "\" (use --overwrite to force).");
 
-	ofstream outFile(pathName);
+	std::ofstream outFile(pathName);
 	outFile << _data;
 	if (!outFile)
 		solThrow(CommandLineOutputError, "Could not write to file \"" + pathName + "\".");
@@ -345,7 +357,7 @@ bool CommandLineInterface::run(int _argc, char const* const* _argv)
 		// There might be no message in the exception itself if the error output is bulky and has
 		// already been printed to stderr (this happens e.g. for compiler errors).
 		if (_exception.what() != ""s)
-			serr() << _exception.what() << endl;
+			report(Error::Severity::Error, _exception.what());
 
 		return false;
 	}
@@ -364,7 +376,19 @@ bool CommandLineInterface::parseArguments(int _argc, char const* const* _argv)
 		return false;
 	}
 
-	parser.parse(_argc, _argv);
+	try
+	{
+		parser.parse(_argc, _argv);
+	}
+	catch (...)
+	{
+		// Even if the overall CLI parsing fails, the --color/--no-color options may have been
+		// successfully parsed, and if so, should be taken into account when printing errors.
+		// If no value is present, it's possible that --no-color is still there but parsing failed
+		// due to other, unrecognized options so play it safe and disable color in that case.
+		m_options.formatting.coloredOutput = parser.options().formatting.coloredOutput.value_or(false);
+		throw;
+	}
 	m_options = parser.options();
 
 	return true;
@@ -372,6 +396,12 @@ bool CommandLineInterface::parseArguments(int _argc, char const* const* _argv)
 
 void CommandLineInterface::processInput()
 {
+	if (m_options.output.evmVersion < EVMVersion::constantinople())
+		report(
+			Error::Severity::Warning,
+			"Support for EVM versions older than constantinople is deprecated and will be removed in the future."
+		);
+
 	switch (m_options.input.mode)
 	{
 	case InputMode::Help:
@@ -385,10 +415,10 @@ void CommandLineInterface::processInput()
 		break;
 	case InputMode::StandardJson:
 	{
-		solAssert(m_standardJsonInput.has_value(), "");
+		solAssert(m_standardJsonInput.has_value());
 
-		StandardCompiler compiler(m_fileReader.reader(), m_options.formatting.json);
-		sout() << compiler.compile(std::move(m_standardJsonInput.value())) << endl;
+		StandardCompiler compiler(m_universalCallback.callback(), m_options.formatting.json);
+		sout() << compiler.compile(std::move(m_standardJsonInput.value())) << std::endl;
 		m_standardJsonInput.reset();
 		break;
 	}
@@ -405,27 +435,33 @@ void CommandLineInterface::processInput()
 	case InputMode::CompilerWithASTImport:
 		compile();
 		outputCompilationResults();
+		break;
+	case InputMode::EVMAssemblerJSON:
+		solUnimplemented("");
+		break;
 	}
 }
 
 void CommandLineInterface::printVersion()
 {
-	sout() << "solc, the solidity compiler commandline interface" << endl;
-	sout() << "Version: " << solidity::frontend::VersionString << endl;
+	sout() << "solc, the TVM solidity compiler commandline interface" << std::endl;
+	sout() << "Version: " << solidity::frontend::VersionString << std::endl;
 }
 
 void CommandLineInterface::printLicense()
 {
-	sout() << otherLicenses << endl;
+	sout() << otherLicenses << std::endl;
 	// This is a static variable generated by cmake from LICENSE.txt
-	sout() << licenseText << endl;
+	sout() << licenseText << std::endl;
 }
 
+
 void CommandLineInterface::compile()
 {
-	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport, "");
+	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
+	solAssert(!m_compiler);
 
-	m_compiler = make_unique<CompilerStack>(m_fileReader.reader());
+	m_compiler = std::make_unique<CompilerStack>(m_universalCallback.callback());
 
 	SourceReferenceFormatter formatter(serr(false), *m_compiler, coloredOutput(m_options), m_options.formatting.withErrorIds);
 
@@ -433,6 +469,7 @@ void CommandLineInterface::compile()
 	{
 		if (m_options.metadata.literalSources)
 			m_compiler->useMetadataLiteralSources(true);
+		m_compiler->setMetadataFormat(m_options.metadata.format);
 		m_compiler->setMetadataHash(m_options.metadata.hash);
 		m_compiler->setRemappings(m_options.input.remappings);
 		m_compiler->setLibraries(m_options.linker.libraries);
@@ -440,9 +477,12 @@ void CommandLineInterface::compile()
 		m_compiler->setEVMVersion(m_options.output.evmVersion);
 		m_compiler->setRevertStringBehaviour(m_options.output.revertStrings);
 		// TODO: Perhaps we should not compile unless requested
-
-		m_compiler->enableIRGeneration(m_options.compiler.outputs.ir || m_options.compiler.outputs.irOptimized);
-		m_compiler->enableEwasmGeneration(m_options.compiler.outputs.ewasm);
+		m_compiler->enableIRGeneration(
+			m_options.compiler.outputs.ir ||
+			m_options.compiler.outputs.irOptimized ||
+			m_options.compiler.outputs.irAstJson ||
+			m_options.compiler.outputs.irOptimizedAstJson
+		);
 		m_compiler->enableEvmBytecodeGeneration(
 			m_options.compiler.estimateGas ||
 			m_options.compiler.outputs.asmJson ||
@@ -489,7 +529,6 @@ void CommandLineInterface::compile()
 			solAssert(src.size() == 1, "");
 			m_compiler->setInputFile(src.begin()->first);
 			m_compiler->setSources(m_fileReader.sourceUnits());
-			m_compiler->setParserErrorRecovery(m_options.input.errorRecovery);
 		}
 
 		if (m_options.tvmParams.mainContract.has_value())
@@ -518,26 +557,29 @@ void CommandLineInterface::compile()
 			formatter.printErrorInformation(*error);
 		}
 
-		if (!successful && !m_options.input.errorRecovery)
+		if (!successful)
 			solThrow(CommandLineExecutionError, "");
 	}
 	catch (CompilerError const& _exception)
 	{
 		m_hasOutput = true;
-		formatter.printExceptionInformation(_exception, "Compiler error");
+		formatter.printExceptionInformation(
+			_exception,
+			Error::errorSeverity(Error::Type::CompilerError)
+		);
 		solThrow(CommandLineExecutionError, "");
 	}
 	catch (Error const& _error)
 	{
 		if (_error.type() == Error::Type::DocstringParsingError)
 		{
-			serr() << *boost::get_error_info<errinfo_comment>(_error);
+			report(Error::Severity::Error, *boost::get_error_info<errinfo_comment>(_error));
 			solThrow(CommandLineExecutionError, "Documentation parsing failed.");
 		}
 		else
 		{
 			m_hasOutput = true;
-			formatter.printExceptionInformation(_error, _error.typeName());
+			formatter.printErrorInformation(_error);
 			solThrow(CommandLineExecutionError, "");
 		}
 	}
@@ -545,12 +587,12 @@ void CommandLineInterface::compile()
 
 void CommandLineInterface::handleAst()
 {
-	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport, "");
+	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	if (!m_options.compiler.outputs.astCompactJson)
 		return;
 
-	vector<ASTNode const*> asts;
+	std::vector<ASTNode const*> asts;
 	for (auto const& sourceCode: m_fileReader.sourceUnits())
 		asts.push_back(&m_compiler->ast(sourceCode.first));
 
@@ -558,8 +600,8 @@ void CommandLineInterface::handleAst()
 	{
 		for (auto const& sourceCode: m_fileReader.sourceUnits())
 		{
-			stringstream data;
-			string postfix = "";
+			std::stringstream data;
+			std::string postfix = "";
 			ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(data, m_compiler->ast(sourceCode.first), m_options.formatting.json);
 			postfix += "_json";
 			boost::filesystem::path path(sourceCode.first);
@@ -571,7 +613,7 @@ void CommandLineInterface::handleAst()
 		for (auto const& sourceCode: m_fileReader.sourceUnits())
 		{
 			ASTJsonExporter(m_compiler->state(), m_compiler->sourceIndices()).print(sout(), m_compiler->ast(sourceCode.first), m_options.formatting.json);
-			sout() << endl;
+			sout() << std::endl;
 		}
 		m_hasOutput = true;
 	}
@@ -586,48 +628,50 @@ void CommandLineInterface::serveLSP()
 
 void CommandLineInterface::outputCompilationResults()
 {
-	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport, "");
+	solAssert(CompilerInputModes.count(m_options.input.mode) == 1);
 
 	// do we need AST output?
 	handleAst();
 
-	if (
-		!m_compiler->compilationSuccessful() &&
-		m_options.output.stopAfter == CompilerStack::State::CompilationSuccessful
-	)
-	{
-		serr() << endl << "Compilation halted after AST generation due to errors." << endl;
-		return;
-	}
-
-	vector<string> contracts = m_compiler->contractNames();
-	for (string const& contract: contracts)
+	CompilerOutputs astOutputSelection;
+	astOutputSelection.astCompactJson = true;
+	if (m_options.compiler.outputs != CompilerOutputs() && m_options.compiler.outputs != astOutputSelection)
 	{
-		if (needsHumanTargetedStdout(m_options))
-			sout() << endl << "======= " << contract << " =======" << endl;
+		// Currently AST is the only output allowed with --stop-after parsing. For all of the others
+		// we can safely assume that full compilation was performed and successful.
+		solAssert(m_options.output.stopAfter >= CompilerStack::State::CompilationSuccessful);
 
-		if (m_options.compiler.outputs.asmJson)
+		for (std::string const& contract: m_compiler->contractNames())
 		{
-			string ret;
-			if (m_options.compiler.outputs.asmJson)
-				ret = util::jsonPrint(removeNullMembers(m_compiler->assemblyJSON(contract)), m_options.formatting.json);
-			else
-				ret = m_compiler->assemblyString(contract, m_fileReader.sourceUnits());
+			if (needsHumanTargetedStdout(m_options))
+				sout() << std::endl << "======= " << contract << " =======" << std::endl;
 
-			if (!m_options.output.dir.empty())
-				createFile(m_compiler->filesystemFriendlyName(contract) + (m_options.compiler.outputs.asmJson ? "_evm.json" : ".evm"), ret);
-			else
-				sout() << "EVM assembly:" << endl << ret << endl;
-		}
-
-		handleNatspec(true, contract);
-		handleNatspec(false, contract);
-	} // end of contracts iteration
+			handleNatspec(true, contract);
+			handleNatspec(false, contract);
+		} // end of contracts iteration
+	}
 
 	if (!m_hasOutput)
 	{
-		serr() << "Compiler run successful, no output requested." << endl;
+		if (!m_options.output.dir.empty())
+			sout() << "Compiler run successful. Artifact(s) can be found in directory " << m_options.output.dir << "." << std::endl;
+		else if (m_compiler->contractNames().empty())
+			sout() << "Compiler run successful. No contracts to compile." << std::endl;
+		else
+			sout() << "Compiler run successful. No output generated." << std::endl;
 	}
 }
 
+void CommandLineInterface::report(langutil::Error::Severity _severity, std::string _message)
+{
+	SourceReferenceFormatter::printPrimaryMessage(
+		serr(),
+		_message,
+		_severity,
+		std::nullopt,
+		coloredOutput(m_options),
+		m_options.formatting.withErrorIds
+	);
+}
+
 }
diff --git a/compiler/solc/CommandLineInterface.h b/compiler/solc/CommandLineInterface.h
index fc52548a..2cb27531 100644
--- a/compiler/solc/CommandLineInterface.h
+++ b/compiler/solc/CommandLineInterface.h
@@ -31,6 +31,8 @@
 #include <boost/program_options.hpp>
 #include <boost/filesystem/path.hpp>
 #include <libsolidity/interface/FileReader.h>
+#include <libsolidity/interface/SMTSolverCommand.h>
+#include <libsolidity/interface/UniversalCallback.h>
 
 #include <iostream>
 #include <memory>
@@ -86,7 +88,6 @@ class CommandLineInterface
 	void printLicense();
 	void compile();
 	void serveLSP();
-
 	void outputCompilationResults();
 	void handleAst();
 	void handleNatspec(bool _natspecDev, std::string const& _contract);
@@ -111,11 +112,15 @@ class CommandLineInterface
 	/// stream has ever been used unless @arg _markAsUsed is set to false.
 	std::ostream& serr(bool _markAsUsed = true);
 
+	void report(langutil::Error::Severity _severity, std::string _message);
+
 	std::istream& m_sin;
 	std::ostream& m_sout;
 	std::ostream& m_serr;
 	bool m_hasOutput = false;
 	FileReader m_fileReader;
+	SMTSolverCommand m_solverCommand{"eld"};
+	UniversalCallback m_universalCallback{&m_fileReader, m_solverCommand};
 	std::optional<std::string> m_standardJsonInput;
 	std::unique_ptr<frontend::CompilerStack> m_compiler;
 	CommandLineOptions m_options;
diff --git a/compiler/solc/CommandLineParser.cpp b/compiler/solc/CommandLineParser.cpp
index dd20bee5..229192dd 100644
--- a/compiler/solc/CommandLineParser.cpp
+++ b/compiler/solc/CommandLineParser.cpp
@@ -29,70 +29,80 @@
 #include <range/v3/view/filter.hpp>
 #include <range/v3/range/conversion.hpp>
 
-using namespace std;
+#include <fmt/format.h>
+
 using namespace solidity::langutil;
+using namespace solidity::yul;
 
 namespace po = boost::program_options;
 
 namespace solidity::frontend
 {
 
-static string const g_strAllowPaths = "allow-paths";
-static string const g_strBasePath = "base-path";
-static string const g_strIncludePath = "include-path";
-static string const g_strAssemble = "assemble";
-static string const g_strCombinedJson = "combined-json";
-static string const g_strErrorRecovery = "error-recovery";
-static string const g_strEVM = "evm";
-static string const g_strEVMVersion = "evm-version";
-static string const g_strEwasm = "ewasm";
-static string const g_strViaIR = "via-ir";
-static string const g_strExperimentalViaIR = "experimental-via-ir";
-static string const g_strGas = "gas";
-static string const g_strHelp = "help";
-static string const g_strImportAst = "import-ast";
-static string const g_strInputFile = "input-file";
-static string const g_strYul = "yul";
-static string const g_strYulDialect = "yul-dialect";
-static string const g_strIPFS = "ipfs";
-static string const g_strLicense = "license";
-static string const g_strLibraries = "libraries";
-static string const g_strLink = "link";
-static string const g_strLSP = "lsp";
-static string const g_strMachine = "machine";
-static string const g_strMetadataHash = "metadata-hash";
-static string const g_strMetadataLiteral = "metadata-literal";
-static string const g_strModelCheckerContracts = "model-checker-contracts";
-static string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
-static string const g_strModelCheckerEngine = "model-checker-engine";
-static string const g_strModelCheckerInvariants = "model-checker-invariants";
-static string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
-static string const g_strModelCheckerSolvers = "model-checker-solvers";
-static string const g_strModelCheckerTargets = "model-checker-targets";
-static string const g_strModelCheckerTimeout = "model-checker-timeout";
-static string const g_strNone = "none";
-static string const g_strNoOptimizeYul = "no-optimize-yul";
-static string const g_strOptimize = "optimize";
-static string const g_strOptimizeYul = "optimize-yul";
-static string const g_strYulOptimizations = "yul-optimizations";
-static string const g_strOutputDir = "output-dir";
-static string const g_strOverwrite = "overwrite";
-static string const g_strRevertStrings = "revert-strings";
-static string const g_strStopAfter = "stop-after";
-static string const g_strParsing = "parsing";
-
-
-static string const g_strContract = "contract";
-static string const g_strOutputPrefix = "output-prefix";
-static string const g_strAsm = "asm";
-static string const g_strABI = "abi-json";
-static string const g_strFunctionIds = "function-ids";
-static string const g_strPrivateFunctionIds = "private-function-ids";
-static string const g_strTVMVersion = "tvm-version";
+static std::string const g_strAllowPaths = "allow-paths";
+static std::string const g_strBasePath = "base-path";
+static std::string const g_strIncludePath = "include-path";
+static std::string const g_strAssemble = "assemble";
+static std::string const g_strCombinedJson = "combined-json";
+static std::string const g_strEVM = "evm";
+static std::string const g_strEVMVersion = "evm-version";
+static std::string const g_strEOFVersion = "experimental-eof-version";
+static std::string const g_strViaIR = "via-ir";
+static std::string const g_strExperimentalViaIR = "experimental-via-ir";
+static std::string const g_strGas = "gas";
+static std::string const g_strHelp = "help";
+static std::string const g_strImportAst = "import-ast";
+static std::string const g_strImportEvmAssemblerJson = "import-asm-json";
+static std::string const g_strInputFile = "input-file";
+static std::string const g_strYul = "yul";
+static std::string const g_strYulDialect = "yul-dialect";
+static std::string const g_strDebugInfo = "debug-info";
+static std::string const g_strIPFS = "ipfs";
+static std::string const g_strLicense = "license";
+static std::string const g_strLibraries = "libraries";
+static std::string const g_strLink = "link";
+static std::string const g_strLSP = "lsp";
+static std::string const g_strMachine = "machine";
+static std::string const g_strNoCBORMetadata = "no-cbor-metadata";
+static std::string const g_strMetadataHash = "metadata-hash";
+static std::string const g_strMetadataLiteral = "metadata-literal";
+static std::string const g_strModelCheckerContracts = "model-checker-contracts";
+static std::string const g_strModelCheckerDivModNoSlacks = "model-checker-div-mod-no-slacks";
+static std::string const g_strModelCheckerEngine = "model-checker-engine";
+static std::string const g_strModelCheckerExtCalls = "model-checker-ext-calls";
+static std::string const g_strModelCheckerInvariants = "model-checker-invariants";
+static std::string const g_strModelCheckerPrintQuery = "model-checker-print-query";
+static std::string const g_strModelCheckerShowProvedSafe = "model-checker-show-proved-safe";
+static std::string const g_strModelCheckerShowUnproved = "model-checker-show-unproved";
+static std::string const g_strModelCheckerShowUnsupported = "model-checker-show-unsupported";
+static std::string const g_strModelCheckerSolvers = "model-checker-solvers";
+static std::string const g_strModelCheckerTargets = "model-checker-targets";
+static std::string const g_strModelCheckerTimeout = "model-checker-timeout";
+static std::string const g_strModelCheckerBMCLoopIterations = "model-checker-bmc-loop-iterations";
+static std::string const g_strNone = "none";
+static std::string const g_strNoOptimizeYul = "no-optimize-yul";
+static std::string const g_strNoImportCallback = "no-import-callback";
+static std::string const g_strOptimize = "optimize";
+static std::string const g_strOptimizeRuns = "optimize-runs";
+static std::string const g_strOptimizeYul = "optimize-yul";
+static std::string const g_strYulOptimizations = "yul-optimizations";
+static std::string const g_strOutputDir = "output-dir";
+static std::string const g_strOverwrite = "overwrite";
+static std::string const g_strRevertStrings = "revert-strings";
+static std::string const g_strStopAfter = "stop-after";
+static std::string const g_strParsing = "parsing";
+
+static std::string const g_strContract = "contract";
+static std::string const g_strOutputPrefix = "output-prefix";
+static std::string const g_strAsm = "asm";
+static std::string const g_strABI = "abi-json";
+static std::string const g_strFunctionIds = "function-ids";
+static std::string const g_strPrivateFunctionIds = "private-function-ids";
+static std::string const g_strTVMVersion = "tvm-version";
 
 
 /// Possible arguments to for --revert-strings
-static set<string> const g_revertStringsArgs
+static std::set<std::string> const g_revertStringsArgs
 {
 	revertStringsToString(RevertStrings::Default),
 	revertStringsToString(RevertStrings::Strip),
@@ -100,42 +110,40 @@ static set<string> const g_revertStringsArgs
 	revertStringsToString(RevertStrings::VerboseDebug)
 };
 
-static string const g_strSources = "sources";
-static string const g_strSourceList = "sourceList";
-static string const g_strStandardJSON = "standard-json";
-static string const g_strStrictAssembly = "strict-assembly";
-static string const g_strSwarm = "swarm";
-static string const g_strPrettyJson = "pretty-json";
-static string const g_strJsonIndent = "json-indent";
-static string const g_strVersion = "version";
-static string const g_strIgnoreMissingFiles = "ignore-missing";
-static string const g_strColor = "color";
-static string const g_strNoColor = "no-color";
-static string const g_strErrorIds = "error-codes";
+static std::string const g_strSources = "sources";
+static std::string const g_strSourceList = "sourceList";
+static std::string const g_strStandardJSON = "standard-json";
+static std::string const g_strStrictAssembly = "strict-assembly";
+static std::string const g_strSwarm = "swarm";
+static std::string const g_strPrettyJson = "pretty-json";
+static std::string const g_strJsonIndent = "json-indent";
+static std::string const g_strVersion = "version";
+static std::string const g_strIgnoreMissingFiles = "ignore-missing";
+static std::string const g_strColor = "color";
+static std::string const g_strNoColor = "no-color";
+static std::string const g_strErrorIds = "error-codes";
 
 /// Possible arguments to for --machine
-static set<string> const g_machineArgs
+static std::set<std::string> const g_machineArgs
 {
-	g_strEVM,
-	g_strEwasm
+	g_strEVM
 };
 
 /// Possible arguments to for --yul-dialect
-static set<string> const g_yulDialectArgs
+static std::set<std::string> const g_yulDialectArgs
 {
-	g_strEVM,
-	g_strEwasm
+	g_strEVM
 };
 
 /// Possible arguments to for --metadata-hash
-static set<string> const g_metadataHashArgs
+static std::set<std::string> const g_metadataHashArgs
 {
 	g_strIPFS,
 	g_strSwarm,
 	g_strNone
 };
 
-static map<InputMode, string> const g_inputModeName = {
+static std::map<InputMode, std::string> const g_inputModeName = {
 	{InputMode::Help, "help"},
 	{InputMode::License, "license"},
 	{InputMode::Version, "version"},
@@ -145,9 +153,10 @@ static map<InputMode, string> const g_inputModeName = {
 	{InputMode::StandardJson, "standard JSON"},
 	{InputMode::Linker, "linker"},
 	{InputMode::LanguageServer, "language server (LSP)"},
+	{InputMode::EVMAssemblerJSON, "EVM assembler (JSON format)"},
 };
 
-void CommandLineParser::checkMutuallyExclusive(vector<string> const& _optionNames)
+void CommandLineParser::checkMutuallyExclusive(std::vector<std::string> const& _optionNames)
 {
 	if (countEnabledOptions(_optionNames) > 1)
 	{
@@ -167,9 +176,9 @@ bool CompilerOutputs::operator==(CompilerOutputs const& _other) const noexcept
 	return true;
 }
 
-ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
+std::ostream& operator<<(std::ostream& _out, CompilerOutputs const& _selection)
 {
-	vector<string> serializedSelection;
+	std::vector<std::string> serializedSelection;
 	for (auto&& [componentName, component]: CompilerOutputs::componentMap())
 		if (_selection.*component)
 			serializedSelection.push_back(CompilerOutputs::componentName(component));
@@ -177,7 +186,7 @@ ostream& operator<<(ostream& _out, CompilerOutputs const& _selection)
 	return _out << util::joinHumanReadable(serializedSelection, ",");
 }
 
-string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
+std::string const& CompilerOutputs::componentName(bool CompilerOutputs::* _component)
 {
 	solAssert(_component, "");
 
@@ -198,9 +207,9 @@ bool CombinedJsonRequests::operator==(CombinedJsonRequests const& _other) const
 }
 
 
-ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
+std::ostream& operator<<(std::ostream& _out, CombinedJsonRequests const& _requests)
 {
-	vector<string> serializedRequests;
+	std::vector<std::string> serializedRequests;
 	for (auto&& [componentName, component]: CombinedJsonRequests::componentMap())
 		if (_requests.*component)
 			serializedRequests.push_back(CombinedJsonRequests::componentName(component));
@@ -208,7 +217,7 @@ ostream& operator<<(ostream& _out, CombinedJsonRequests const& _requests)
 	return _out << util::joinHumanReadable(serializedRequests, ",");
 }
 
-string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
+std::string const& CombinedJsonRequests::componentName(bool CombinedJsonRequests::* _component)
 {
 	solAssert(_component, "");
 
@@ -229,7 +238,7 @@ bool CommandLineOptions::operator==(CommandLineOptions const& _other) const noex
 		input.includePaths == _other.input.includePaths &&
 		input.allowedDirectories == _other.input.allowedDirectories &&
 		input.ignoreMissingFiles == _other.input.ignoreMissingFiles &&
-		input.errorRecovery == _other.input.errorRecovery &&
+		input.noImportCallback == _other.input.noImportCallback &&
 		output.dir == _other.output.dir &&
 		output.overwriteFiles == _other.output.overwriteFiles &&
 		output.evmVersion == _other.output.evmVersion &&
@@ -237,6 +246,7 @@ bool CommandLineOptions::operator==(CommandLineOptions const& _other) const noex
 		output.revertStrings == _other.output.revertStrings &&
 		output.debugInfoSelection == _other.output.debugInfoSelection &&
 		output.stopAfter == _other.output.stopAfter &&
+		output.eofVersion == _other.output.eofVersion &&
 		input.mode == _other.input.mode &&
 		linker.libraries == _other.linker.libraries &&
 		formatting.json == _other.formatting.json &&
@@ -245,11 +255,12 @@ bool CommandLineOptions::operator==(CommandLineOptions const& _other) const noex
 		compiler.outputs == _other.compiler.outputs &&
 		compiler.estimateGas == _other.compiler.estimateGas &&
 		compiler.combinedJsonRequests == _other.compiler.combinedJsonRequests &&
+		metadata.format == _other.metadata.format &&
 		metadata.hash == _other.metadata.hash &&
 		metadata.literalSources == _other.metadata.literalSources &&
-		optimizer.enabled == _other.optimizer.enabled &&
+		optimizer.optimizeEvmasm == _other.optimizer.optimizeEvmasm &&
+		optimizer.optimizeYul == _other.optimizer.optimizeYul &&
 		optimizer.expectedExecutionsPerDeployment == _other.optimizer.expectedExecutionsPerDeployment &&
-		optimizer.noOptimizeYul == _other.optimizer.noOptimizeYul &&
 		optimizer.yulSteps == _other.optimizer.yulSteps &&
 		modelChecker.initialize == _other.modelChecker.initialize;
 }
@@ -258,19 +269,31 @@ OptimiserSettings CommandLineOptions::optimiserSettings() const
 {
 	OptimiserSettings settings;
 
-	if (optimizer.enabled)
+	if (optimizer.optimizeEvmasm)
 		settings = OptimiserSettings::standard();
 	else
 		settings = OptimiserSettings::minimal();
 
-	if (optimizer.noOptimizeYul)
-		settings.runYulOptimiser = false;
+	settings.runYulOptimiser = optimizer.optimizeYul;
+	if (optimizer.optimizeYul)
+		// NOTE: Standard JSON disables optimizeStackAllocation by default when yul optimizer is disabled.
+		// --optimize --no-optimize-yul on the CLI does not have that effect.
+		settings.optimizeStackAllocation = true;
 
 	if (optimizer.expectedExecutionsPerDeployment.has_value())
 		settings.expectedExecutionsPerDeployment = optimizer.expectedExecutionsPerDeployment.value();
 
 	if (optimizer.yulSteps.has_value())
-		settings.yulOptimiserSteps = optimizer.yulSteps.value();
+	{
+		std::string const fullSequence = optimizer.yulSteps.value();
+		auto const delimiterPos = fullSequence.find(":");
+		settings.yulOptimiserSteps = fullSequence.substr(0, delimiterPos);
+
+		if (delimiterPos != std::string::npos)
+			settings.yulOptimiserCleanupSteps = fullSequence.substr(delimiterPos + 1);
+		else
+			solAssert(settings.yulOptimiserCleanupSteps == OptimiserSettings::DefaultYulOptimiserCleanupSteps);
+	}
 
 	return settings;
 }
@@ -286,11 +309,11 @@ void CommandLineParser::parseInputPathsAndRemappings()
 	m_options.input.ignoreMissingFiles = (m_args.count(g_strIgnoreMissingFiles) > 0);
 
 	if (m_args.count(g_strInputFile))
-		for (string const& positionalArg: m_args[g_strInputFile].as<vector<string>>())
+		for (std::string const& positionalArg: m_args[g_strInputFile].as<std::vector<std::string>>())
 		{
 			if (ImportRemapper::isRemapping(positionalArg))
 			{
-				optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
+				std::optional<ImportRemapper::Remapping> remapping = ImportRemapper::parseRemapping(positionalArg);
 				if (!remapping.has_value())
 					solThrow(CommandLineValidationError, "Invalid remapping: \"" + positionalArg + "\".");
 
@@ -348,10 +371,10 @@ void CommandLineParser::parseInputPathsAndRemappings()
 		);
 }
 
-void CommandLineParser::parseLibraryOption(string const& _input)
+void CommandLineParser::parseLibraryOption(std::string const& _input)
 {
 	namespace fs = boost::filesystem;
-	string data = _input;
+	std::string data = _input;
 	try
 	{
 		if (fs::is_regular_file(_input))
@@ -370,19 +393,19 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 		// Should not happen if `fs::is_regular_file` is correct.
 	}
 
-	vector<string> libraries;
+	std::vector<std::string> libraries;
 	boost::split(libraries, data, boost::is_space() || boost::is_any_of(","), boost::token_compress_on);
-	for (string const& lib: libraries)
+	for (std::string const& lib: libraries)
 		if (!lib.empty())
 		{
 			//search for equal sign or last colon in string as our binaries output placeholders in the form of file=Name or file:Name
 			//so we need to search for `=` or `:` in the string
 			auto separator = lib.rfind('=');
 			bool isSeparatorEqualSign = true;
-			if (separator == string::npos)
+			if (separator == std::string::npos)
 			{
 				separator = lib.rfind(':');
-				if (separator == string::npos)
+				if (separator == std::string::npos)
 					solThrow(
 						CommandLineValidationError,
 						"Equal sign separator missing in library address specifier \"" + lib + "\""
@@ -397,7 +420,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 						"Only one equal sign \"=\" is allowed in the address string \"" + lib + "\"."
 					);
 
-			string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
+			std::string libName(lib.begin(), lib.begin() + static_cast<ptrdiff_t>(separator));
 			boost::trim(libName);
 			if (m_options.linker.libraries.count(libName))
 				solThrow(
@@ -405,7 +428,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 					"Address specified more than once for library \"" + libName + "\"."
 				);
 
-			string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
+			std::string addrString(lib.begin() + static_cast<ptrdiff_t>(separator) + 1, lib.end());
 			boost::trim(addrString);
 			if (addrString.empty())
 				solThrow(
@@ -428,7 +451,7 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 				solThrow(
 					CommandLineValidationError,
 					"Invalid length for address for library \"" + libName + "\": " +
-					to_string(addrString.length()) + " instead of 40 characters."
+					std::to_string(addrString.length()) + " instead of 40 characters."
 				);
 			if (!util::passesAddressChecksum(addrString, false))
 				solThrow(
@@ -449,20 +472,24 @@ void CommandLineParser::parseLibraryOption(string const& _input)
 
 void CommandLineParser::parseOutputSelection()
 {
-	static auto outputSupported = [](InputMode _mode, string_view _outputName)
+	static auto outputSupported = [](InputMode _mode, std::string_view _outputName)
 	{
-		static set<string> const compilerModeOutputs = (
+		static std::set<std::string> const compilerModeOutputs = (
 			CompilerOutputs::componentMap() |
 			ranges::views::keys |
-			ranges::to<set>()
-		) - set<string>{CompilerOutputs::componentName(&CompilerOutputs::ewasmIR)};
-		static set<string> const assemblerModeOutputs = {
+			ranges::to<std::set>()
+		);
+		static std::set<std::string> const assemblerModeOutputs = {
 			CompilerOutputs::componentName(&CompilerOutputs::binary),
 			CompilerOutputs::componentName(&CompilerOutputs::irOptimized),
-			CompilerOutputs::componentName(&CompilerOutputs::ewasm),
-			CompilerOutputs::componentName(&CompilerOutputs::ewasmIR),
+			CompilerOutputs::componentName(&CompilerOutputs::astCompactJson),
+		};
+		static std::set<std::string> const evmAssemblyJsonImportModeOutputs = {
+			CompilerOutputs::componentName(&CompilerOutputs::binary),
+			CompilerOutputs::componentName(&CompilerOutputs::binaryRuntime),
+			CompilerOutputs::componentName(&CompilerOutputs::opcodes),
+			CompilerOutputs::componentName(&CompilerOutputs::asmJson),
 		};
-
 		switch (_mode)
 		{
 		case InputMode::Help:
@@ -473,6 +500,8 @@ void CommandLineParser::parseOutputSelection()
 		case InputMode::Compiler:
 		case InputMode::CompilerWithASTImport:
 			return util::contains(compilerModeOutputs, _outputName);
+		case InputMode::EVMAssemblerJSON:
+			return util::contains(evmAssemblyJsonImportModeOutputs, _outputName);
 		case InputMode::Assembler:
 			return util::contains(assemblerModeOutputs, _outputName);
 		case InputMode::StandardJson:
@@ -492,11 +521,9 @@ void CommandLineParser::parseOutputSelection()
 		// TODO: Remove this (must be done in a breaking release).
 		m_options.compiler.outputs.binary = true;
 		m_options.compiler.outputs.irOptimized = true;
-		m_options.compiler.outputs.ewasm = true;
-		m_options.compiler.outputs.ewasmIR = true;
 	}
 
-	vector<string> unsupportedOutputs;
+	std::vector<std::string> unsupportedOutputs;
 	for (auto&& [optionName, outputComponent]: CompilerOutputs::componentMap())
 		if (m_options.compiler.outputs.*outputComponent && !outputSupported(m_options.input.mode, optionName))
 			unsupportedOutputs.push_back(optionName);
@@ -507,9 +534,11 @@ void CommandLineParser::parseOutputSelection()
 			"The following outputs are not supported in " + g_inputModeName.at(m_options.input.mode) + " mode: " +
 			joinOptionNames(unsupportedOutputs) + "."
 		);
+
+	// TODO: restrict EOF version to correct EVM version.
 }
 
-po::options_description CommandLineParser::optionsDescription()
+po::options_description CommandLineParser::optionsDescription(bool /*_forHelp*/)
 {
 	// Declare the supported options.
 	po::options_description desc((R"(solc, the TVM Solidity commandline compiler.
@@ -519,8 +548,8 @@ are welcome to redistribute it under certain conditions. See 'solc --)" + g_strL
 for details.
 
 Usage: solc [options] input_file
-Compiles the given Solidity input file (or the standard input if none given or
-"-" is used as a file name) and outputs the components specified in the options
+Compiles the given Solidity input file
+and outputs the components specified in the options
 at standard output or in files in the output directory, if specified.
 Imports are automatically read from the filesystem, but it is also possible to
 remap paths using the context:prefix=path syntax.
@@ -541,17 +570,17 @@ General Information)").c_str(),
 	inputOptions.add_options()
 		(
 			(g_strContract + ",c").c_str(),
-			po::value<string>()->value_name("contractName"),
+			po::value<std::string>()->value_name("contractName"),
 			"Contract to build if sources define more than one contract."
 		)
 		(
 			g_strBasePath.c_str(),
-			po::value<string>()->value_name("path"),
+			po::value<std::string>()->value_name("path"),
 			"Use the given path as the root of the source tree instead of the root of the filesystem."
 		)
 		(
 			(g_strIncludePath + ",i").c_str(),
-			po::value<vector<string>>()->value_name("path"),
+			po::value<std::vector<std::string>>()->value_name("path"),
 			"Make an additional source directory available to the default import callback. "
 			"Use this option if you want to import contracts whose location is not fixed in relation "
 			"to your main source tree, e.g. third-party libraries installed using a package manager. "
@@ -560,7 +589,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strAllowPaths.c_str(),
-			po::value<string>()->value_name("path(s)"),
+			po::value<std::string>()->value_name("path(s)"),
 			"Allow a given path for imports. A list of paths can be supplied by separating them with a comma."
 		)
 	;
@@ -570,12 +599,12 @@ General Information)").c_str(),
 	outputOptions.add_options()
 		(
 			(g_strOutputPrefix + ",p").c_str(),
-			po::value<string>()->value_name("prefix"),
+			po::value<std::string>()->value_name("prefix"),
 			"Prefix for output files (by default, input file stem is used as prefix)"
 		)
 		(
 			(g_strOutputDir + ",o").c_str(),
-			po::value<string>()->value_name("path"),
+			po::value<std::string>()->value_name("path"),
 			"Output directory (by default, current directory is used)"
 		)
 		(
@@ -584,7 +613,7 @@ General Information)").c_str(),
 		)
 		(
 			g_strTVMVersion.c_str(),
-			po::value<string>()->value_name("version")->default_value(TVMVersion{}.name()),
+			po::value<std::string>()->value_name("version")->default_value(TVMVersion{}.name()),
 			"Select desired TVM version. Either ever, ton, gosh."
 		)
 	;
@@ -628,7 +657,7 @@ General Information)").c_str(),
 	;
 	desc.add(outputComponents);
 
-	desc.add_options()(g_strInputFile.c_str(), po::value<vector<string>>(), "input file");
+	desc.add_options()(g_strInputFile.c_str(), po::value<std::vector<std::string>>(), "input file");
 	return desc;
 }
 
@@ -645,6 +674,9 @@ void CommandLineParser::parseArgs(int _argc, char const* const* _argv)
 	po::options_description allOptions = optionsDescription();
 	po::positional_options_description filesPositions = positionalOptionsDescription();
 
+	m_options = {};
+	m_args = {};
+
 	// parse the compiler arguments
 	try
 	{
@@ -663,6 +695,11 @@ void CommandLineParser::parseArgs(int _argc, char const* const* _argv)
 
 void CommandLineParser::processArgs()
 {
+	if (m_args.count(g_strNoColor) > 0)
+		m_options.formatting.coloredOutput = false;
+	else if (m_args.count(g_strColor) > 0)
+		m_options.formatting.coloredOutput = true;
+
 	checkMutuallyExclusive({
 		g_strHelp,
 		g_strLicense,
@@ -673,7 +710,8 @@ void CommandLineParser::processArgs()
 		g_strStrictAssembly,
 		g_strYul,
 		g_strImportAst,
-		g_strLSP
+		g_strLSP,
+		g_strImportEvmAssemblerJson,
 	});
 
 	if (m_args.count(g_strHelp) > 0)
@@ -692,6 +730,8 @@ void CommandLineParser::processArgs()
 		m_options.input.mode = InputMode::Linker;
 	else if (m_args.count(g_strImportAst) > 0)
 		m_options.input.mode = InputMode::CompilerWithASTImport;
+	else if (m_args.count(g_strImportEvmAssemblerJson) > 0)
+		m_options.input.mode = InputMode::EVMAssemblerJSON;
 	else
 		m_options.input.mode = InputMode::Compiler;
 
@@ -702,23 +742,28 @@ void CommandLineParser::processArgs()
 	)
 		return;
 
-	map<string, set<InputMode>> validOptionInputModeCombinations = {
+	std::map<std::string, std::set<InputMode>> validOptionInputModeCombinations = {
 		// TODO: This should eventually contain all options.
-		{g_strErrorRecovery, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strExperimentalViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strViaIR, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strMetadataLiteral, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strNoCBORMetadata, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strMetadataHash, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
-		{g_strModelCheckerShowUnproved, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerContracts, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerDivModNoSlacks, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerEngine, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerInvariants, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerPrintQuery, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerShowProvedSafe, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerShowUnproved, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerShowUnsupported, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerSolvers, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerTimeout, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
+		{g_strModelCheckerBMCLoopIterations, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerContracts, {InputMode::Compiler, InputMode::CompilerWithASTImport}},
 		{g_strModelCheckerTargets, {InputMode::Compiler, InputMode::CompilerWithASTImport}}
 	};
-	vector<string> invalidOptionsForCurrentInputMode;
+	std::vector<std::string> invalidOptionsForCurrentInputMode;
 	for (auto const& [optionName, inputModes]: validOptionInputModeCombinations)
 	{
 		if (
@@ -740,28 +785,54 @@ void CommandLineParser::processArgs()
 		return;
 
 	checkMutuallyExclusive({g_strColor, g_strNoColor});
+	checkMutuallyExclusive({g_strStopAfter, g_strGas});
 
-	array<string, 9> const conflictingWithStopAfter{
-		CompilerOutputs::componentName(&CompilerOutputs::binary),
-		CompilerOutputs::componentName(&CompilerOutputs::ir),
-		CompilerOutputs::componentName(&CompilerOutputs::irOptimized),
-		CompilerOutputs::componentName(&CompilerOutputs::ewasm),
-		CompilerOutputs::componentName(&CompilerOutputs::ewasmIR),
-		g_strGas,
-		CompilerOutputs::componentName(&CompilerOutputs::asmJson),
-		CompilerOutputs::componentName(&CompilerOutputs::opcodes),
-	};
+	for (std::string const& option: CompilerOutputs::componentMap() | ranges::views::keys)
+		if (option != CompilerOutputs::componentName(&CompilerOutputs::astCompactJson))
+			checkMutuallyExclusive({g_strStopAfter, option});
+
+	if (m_options.input.mode == InputMode::EVMAssemblerJSON)
+	{
+		static std::set<std::string> const supportedByEvmAsmJsonImport{
+			g_strImportEvmAssemblerJson,
+			CompilerOutputs::componentName(&CompilerOutputs::binary),
+			CompilerOutputs::componentName(&CompilerOutputs::binaryRuntime),
+			CompilerOutputs::componentName(&CompilerOutputs::asmJson),
+			CompilerOutputs::componentName(&CompilerOutputs::opcodes),
+			g_strCombinedJson,
+			g_strInputFile,
+			g_strJsonIndent,
+			g_strPrettyJson,
+			"srcmap",
+			"srcmap-runtime",
+		};
 
-	for (auto& option: conflictingWithStopAfter)
-		checkMutuallyExclusive({g_strStopAfter, option});
+		for (auto const& [optionName, optionValue]: m_args)
+			if (!optionValue.defaulted() && !supportedByEvmAsmJsonImport.count(optionName))
+				solThrow(
+					CommandLineValidationError,
+					fmt::format(
+						"Option --{} is not supported with --{}.",
+						optionName,
+						g_strImportEvmAssemblerJson
+					)
+				);
+	}
 
 	if (
 		m_options.input.mode != InputMode::Compiler &&
 		m_options.input.mode != InputMode::CompilerWithASTImport &&
+		m_options.input.mode != InputMode::EVMAssemblerJSON &&
 		m_options.input.mode != InputMode::Assembler
 	)
 	{
-		for (string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
+		if (!m_args[g_strOptimizeRuns].defaulted())
+			solThrow(
+				CommandLineValidationError,
+				"Option --" + g_strOptimizeRuns + " is only valid in compiler and assembler modes."
+			);
+
+		for (std::string const& option: {g_strOptimize, g_strNoOptimizeYul, g_strOptimizeYul, g_strYulOptimizations})
 			if (m_args.count(option) > 0)
 				solThrow(
 					CommandLineValidationError,
@@ -769,16 +840,11 @@ void CommandLineParser::processArgs()
 				);
 	}
 
-	if (m_args.count(g_strColor) > 0)
-		m_options.formatting.coloredOutput = true;
-	else if (m_args.count(g_strNoColor) > 0)
-		m_options.formatting.coloredOutput = false;
-
 	m_options.formatting.withErrorIds = m_args.count(g_strErrorIds);
 
 	if (m_args.count(g_strRevertStrings))
 	{
-		string revertStringsString = m_args[g_strRevertStrings].as<string>();
+		std::string revertStringsString = m_args[g_strRevertStrings].as<std::string>();
 		std::optional<RevertStrings> revertStrings = revertStringsFromString(revertStringsString);
 		if (!revertStrings)
 			solThrow(
@@ -796,7 +862,7 @@ void CommandLineParser::processArgs()
 	parseCombinedJsonOption();
 
 	if (m_args.count(g_strOutputDir))
-		m_options.output.dir = m_args.at(g_strOutputDir).as<string>();
+		m_options.output.dir = m_args.at(g_strOutputDir).as<std::string>();
 
 	m_options.output.overwriteFiles = (m_args.count(g_strOverwrite) > 0);
 
@@ -815,14 +881,14 @@ void CommandLineParser::processArgs()
 	m_options.compiler.estimateGas = (m_args.count(g_strGas) > 0);
 
 	if (m_args.count(g_strBasePath))
-		m_options.input.basePath = m_args[g_strBasePath].as<string>();
+		m_options.input.basePath = m_args[g_strBasePath].as<std::string>();
 
 	if (m_args.count(g_strIncludePath) > 0)
 	{
 		if (m_options.input.basePath.empty())
 			solThrow(CommandLineValidationError, "--" + g_strIncludePath + " option requires a non-empty base path.");
 
-		for (string const& includePath: m_args[g_strIncludePath].as<vector<string>>())
+		for (std::string const& includePath: m_args[g_strIncludePath].as<std::vector<std::string>>())
 		{
 			if (includePath.empty())
 				solThrow(CommandLineValidationError, "Empty values are not allowed in --" + g_strIncludePath + ".");
@@ -831,17 +897,22 @@ void CommandLineParser::processArgs()
 		}
 	}
 
+	checkMutuallyExclusive({g_strNoImportCallback, g_strAllowPaths});
+
+	if (m_args.count(g_strNoImportCallback))
+		m_options.input.noImportCallback = true;
+
 	if (m_args.count(g_strAllowPaths))
 	{
-		vector<string> paths;
-		for (string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<string>(), boost::is_any_of(",")))
+		std::vector<std::string> paths;
+		for (std::string const& allowedPath: boost::split(paths, m_args[g_strAllowPaths].as<std::string>(), boost::is_any_of(",")))
 			if (!allowedPath.empty())
 				m_options.input.allowedDirectories.insert(allowedPath);
 	}
 
 	if (m_args.count(g_strStopAfter))
 	{
-		if (m_args[g_strStopAfter].as<string>() != "parsing")
+		if (m_args[g_strStopAfter].as<std::string>() != "parsing")
 			solThrow(CommandLineValidationError, "Valid options for --" + g_strStopAfter + " are: \"parsing\".\n");
 		else
 			m_options.output.stopAfter = CompilerStack::State::Parsed;
@@ -853,7 +924,7 @@ void CommandLineParser::processArgs()
 		return;
 
 	if (m_args.count(g_strLibraries))
-		for (string const& library: m_args[g_strLibraries].as<vector<string>>())
+		for (std::string const& library: m_args[g_strLibraries].as<std::vector<std::string>>())
 			parseLibraryOption(library);
 
 	if (m_options.input.mode == InputMode::Linker)
@@ -861,44 +932,48 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strEVMVersion))
 	{
-		string versionOptionStr = m_args[g_strEVMVersion].as<string>();
+		std::string versionOptionStr = m_args[g_strEVMVersion].as<std::string>();
 		std::optional<langutil::EVMVersion> versionOption = langutil::EVMVersion::fromString(versionOptionStr);
 		if (!versionOption)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strEVMVersion + ": " + versionOptionStr);
 		m_options.output.evmVersion = *versionOption;
 	}
 
-	m_options.optimizer.enabled = (m_args.count(g_strOptimize) > 0);
-	m_options.optimizer.noOptimizeYul = (m_args.count(g_strNoOptimizeYul) > 0);
-
-	if (m_args.count(g_strYulOptimizations))
+	if (m_args.count(g_strEOFVersion))
 	{
-		OptimiserSettings optimiserSettings = m_options.optimiserSettings();
-		if (!optimiserSettings.runYulOptimiser)
-			solThrow(CommandLineValidationError, "--" + g_strYulOptimizations + " is invalid if Yul optimizer is disabled");
-
-		m_options.optimizer.yulSteps = m_args[g_strYulOptimizations].as<string>();
+		// Request as uint64_t, since uint8_t will be parsed as character by boost.
+		uint64_t versionOption = m_args[g_strEOFVersion].as<uint64_t>();
+		if (versionOption != 1)
+			solThrow(CommandLineValidationError, "Invalid option for --" + g_strEOFVersion + ": " + std::to_string(versionOption));
+		m_options.output.eofVersion = 1;
 	}
 
+	if (m_args.count(g_strNoOptimizeYul) > 0 && m_args.count(g_strOptimizeYul) > 0)
+		solThrow(
+			CommandLineValidationError,
+			"Options --" + g_strOptimizeYul + " and --" + g_strNoOptimizeYul + " cannot be used together."
+		);
+
+	m_options.optimizer.optimizeEvmasm = (m_args.count(g_strOptimize) > 0);
+	m_options.optimizer.optimizeYul = (
+		(m_args.count(g_strOptimize) > 0 && m_args.count(g_strNoOptimizeYul) == 0) ||
+		m_args.count(g_strOptimizeYul) > 0
+	);
+
 	if (m_options.input.mode == InputMode::Assembler)
 	{
-		vector<string> const nonAssemblyModeOptions = {
+		std::vector<std::string> const nonAssemblyModeOptions = {
 			// TODO: The list is not complete. Add more.
 			g_strOutputDir,
 			g_strGas,
 			g_strCombinedJson,
-			g_strOptimizeYul,
-			g_strNoOptimizeYul,
 		};
 		if (countEnabledOptions(nonAssemblyModeOptions) >= 1)
 		{
-			auto optionEnabled = [&](string const& name){ return m_args.count(name) > 0; };
+			auto optionEnabled = [&](std::string const& name){ return m_args.count(name) > 0; };
 			auto enabledOptions = nonAssemblyModeOptions | ranges::views::filter(optionEnabled) | ranges::to_vector;
 
-			string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
-			if (m_args.count(g_strOptimizeYul) || m_args.count(g_strNoOptimizeYul))
-				message += " Optimization is disabled by default and can be enabled with --" + g_strOptimize + ".";
-
+			std::string message = "The following options are invalid in assembly mode: " + joinOptionNames(enabledOptions) + ".";
 			solThrow(CommandLineValidationError, message);
 		}
 
@@ -913,7 +988,7 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strMetadataHash))
 	{
-		string hashStr = m_args[g_strMetadataHash].as<string>();
+		std::string hashStr = m_args[g_strMetadataHash].as<std::string>();
 		if (hashStr == g_strIPFS)
 			m_options.metadata.hash = CompilerStack::MetadataHash::IPFS;
 		else if (hashStr == g_strSwarm)
@@ -926,8 +1001,8 @@ void CommandLineParser::processArgs()
 
 	if (m_args.count(g_strModelCheckerSolvers))
 	{
-		string solversStr = m_args[g_strModelCheckerSolvers].as<string>();
-		optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
+		std::string solversStr = m_args[g_strModelCheckerSolvers].as<std::string>();
+		std::optional<smtutil::SMTSolverChoice> solvers = smtutil::SMTSolverChoice::fromString(solversStr);
 		if (!solvers)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strModelCheckerSolvers + ": " + solversStr);
 	}
@@ -937,21 +1012,21 @@ void CommandLineParser::processArgs()
 		m_args.count(g_strModelCheckerContracts) ||
 		m_args.count(g_strModelCheckerDivModNoSlacks) ||
 		m_args.count(g_strModelCheckerEngine) ||
+		m_args.count(g_strModelCheckerExtCalls) ||
 		m_args.count(g_strModelCheckerInvariants) ||
+		m_args.count(g_strModelCheckerShowProvedSafe) ||
 		m_args.count(g_strModelCheckerShowUnproved) ||
+		m_args.count(g_strModelCheckerShowUnsupported) ||
 		m_args.count(g_strModelCheckerSolvers) ||
 		m_args.count(g_strModelCheckerTargets) ||
 		m_args.count(g_strModelCheckerTimeout);
 	m_options.output.viaIR = (m_args.count(g_strExperimentalViaIR) > 0 || m_args.count(g_strViaIR) > 0);
-	if (m_options.input.mode == InputMode::Compiler)
-		m_options.input.errorRecovery = (m_args.count(g_strErrorRecovery) > 0);
 
 	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport);
 
-
 	if (m_args.count(g_strTVMVersion))
 	{
-		string versionOptionStr = m_args[g_strTVMVersion].as<string>();
+		std::string versionOptionStr = m_args[g_strTVMVersion].as<std::string>();
 		std::optional<langutil::TVMVersion> versionOption = langutil::TVMVersion::fromString(versionOptionStr);
 		if (!versionOption)
 			solThrow(CommandLineValidationError, "Invalid option for --" + g_strTVMVersion + ": " + versionOptionStr);
@@ -959,9 +1034,9 @@ void CommandLineParser::processArgs()
 	}
 
 	if (m_args.count(g_strContract))
-		m_options.tvmParams.mainContract = m_args[g_strContract].as<string>();
+		m_options.tvmParams.mainContract = m_args[g_strContract].as<std::string>();
 	if (m_args.count(g_strOutputPrefix))
-		m_options.tvmParams.fileNamePrefix = m_args[g_strOutputPrefix].as<string>();
+		m_options.tvmParams.fileNamePrefix = m_args[g_strOutputPrefix].as<std::string>();
 	if (m_args.count(g_strABI))
 		m_options.tvmParams.abi = true;
 	if (m_args.count(g_strAsm))
@@ -984,6 +1059,12 @@ void CommandLineParser::processArgs()
 		m_options.tvmParams.code = true;
 		m_options.tvmParams.abi = true;
 	}
+	solAssert(
+		m_options.input.mode == InputMode::Compiler ||
+		m_options.input.mode == InputMode::CompilerWithASTImport ||
+		m_options.input.mode == InputMode::EVMAssemblerJSON,
+		"It's OK?"
+	);
 }
 
 void CommandLineParser::parseCombinedJsonOption()
@@ -991,29 +1072,57 @@ void CommandLineParser::parseCombinedJsonOption()
 	if (!m_args.count(g_strCombinedJson))
 		return;
 
-	set<string> requests;
-	for (string const& item: boost::split(requests, m_args[g_strCombinedJson].as<string>(), boost::is_any_of(",")))
+	std::set<std::string> requests;
+	for (std::string const& item: boost::split(requests, m_args[g_strCombinedJson].as<std::string>(), boost::is_any_of(",")))
 		if (CombinedJsonRequests::componentMap().count(item) == 0)
 			solThrow(CommandLineValidationError, "Invalid option to --" + g_strCombinedJson + ": " + item);
 
 	m_options.compiler.combinedJsonRequests = CombinedJsonRequests{};
 	for (auto&& [componentName, component]: CombinedJsonRequests::componentMap())
 		m_options.compiler.combinedJsonRequests.value().*component = (requests.count(componentName) > 0);
+
+	if (m_options.input.mode == InputMode::EVMAssemblerJSON && m_options.compiler.combinedJsonRequests.has_value())
+	{
+		static bool CombinedJsonRequests::* invalidOptions[]{
+			&CombinedJsonRequests::abi,
+			&CombinedJsonRequests::ast,
+			&CombinedJsonRequests::funDebug,
+			&CombinedJsonRequests::funDebugRuntime,
+			&CombinedJsonRequests::generatedSources,
+			&CombinedJsonRequests::generatedSourcesRuntime,
+			&CombinedJsonRequests::metadata,
+			&CombinedJsonRequests::natspecDev,
+			&CombinedJsonRequests::natspecUser,
+			&CombinedJsonRequests::signatureHashes,
+			&CombinedJsonRequests::storageLayout
+		};
+
+		for (auto const invalidOption: invalidOptions)
+			if (m_options.compiler.combinedJsonRequests.value().*invalidOption)
+				solThrow(
+					CommandLineValidationError,
+					fmt::format(
+						"The --{} {} output is not available in EVM assembly import mode.",
+						g_strCombinedJson,
+						CombinedJsonRequests::componentName(invalidOption)
+					)
+				);
+	}
 }
 
-size_t CommandLineParser::countEnabledOptions(vector<string> const& _optionNames) const
+size_t CommandLineParser::countEnabledOptions(std::vector<std::string> const& _optionNames) const
 {
 	size_t count = 0;
-	for (string const& _option: _optionNames)
+	for (std::string const& _option: _optionNames)
 		count += m_args.count(_option);
 
 	return count;
 }
 
-string CommandLineParser::joinOptionNames(vector<string> const& _optionNames, string _separator)
+std::string CommandLineParser::joinOptionNames(std::vector<std::string> const& _optionNames, std::string _separator)
 {
 	return util::joinHumanReadable(
-		_optionNames | ranges::views::transform([](string const& _option){ return "--" + _option; }),
+		_optionNames | ranges::views::transform([](std::string const& _option){ return "--" + _option; }),
 		_separator
 	);
 }
diff --git a/compiler/solc/CommandLineParser.h b/compiler/solc/CommandLineParser.h
index f4310a06..4b823b6a 100644
--- a/compiler/solc/CommandLineParser.h
+++ b/compiler/solc/CommandLineParser.h
@@ -55,7 +55,8 @@ enum class InputMode
 	StandardJson,
 	Linker,
 	Assembler,
-	LanguageServer
+	LanguageServer,
+	EVMAssemblerJSON
 };
 
 struct CompilerOutputs
@@ -75,9 +76,9 @@ struct CompilerOutputs
 			{"bin-runtime", &CompilerOutputs::binaryRuntime},
 			{"abi", &CompilerOutputs::abi},
 			{"ir", &CompilerOutputs::ir},
+			{"ir-ast-json", &CompilerOutputs::irAstJson},
 			{"ir-optimized", &CompilerOutputs::irOptimized},
-			{"ewasm", &CompilerOutputs::ewasm},
-			{"ewasm-ir", &CompilerOutputs::ewasmIR},
+			{"ir-optimized-ast-json", &CompilerOutputs::irOptimizedAstJson},
 			{"hashes", &CompilerOutputs::signatureHashes},
 			{"userdoc", &CompilerOutputs::natspecUser},
 			{"devdoc", &CompilerOutputs::natspecDev},
@@ -94,9 +95,9 @@ struct CompilerOutputs
 	bool binaryRuntime = false;
 	bool abi = false;
 	bool ir = false;
+	bool irAstJson = false;
 	bool irOptimized = false;
-	bool ewasm = false;
-	bool ewasmIR = false;
+	bool irOptimizedAstJson = false;
 	bool signatureHashes = false;
 	bool natspecUser = false;
 	bool natspecDev = false;
@@ -169,7 +170,7 @@ struct CommandLineOptions
 		std::vector<boost::filesystem::path> includePaths;
 		FileReader::FileSystemPathSet allowedDirectories;
 		bool ignoreMissingFiles = false;
-		bool errorRecovery = false;
+		bool noImportCallback = false;
 	} input;
 
 	struct
@@ -181,6 +182,7 @@ struct CommandLineOptions
 		RevertStrings revertStrings = RevertStrings::Default;
 		std::optional<langutil::DebugInfoSelection> debugInfoSelection;
 		CompilerStack::State stopAfter = CompilerStack::State::CompilationSuccessful;
+		std::optional<uint8_t> eofVersion;
 	} output;
 
 	struct
@@ -204,15 +206,16 @@ struct CommandLineOptions
 
 	struct
 	{
+		CompilerStack::MetadataFormat format = CompilerStack::defaultMetadataFormat();
 		CompilerStack::MetadataHash hash = CompilerStack::MetadataHash::IPFS;
 		bool literalSources = false;
 	} metadata;
 
 	struct
 	{
-		bool enabled = false;
+		bool optimizeEvmasm = false;
+		bool optimizeYul = false;
 		std::optional<unsigned> expectedExecutionsPerDeployment;
-		bool noOptimizeYul = false;
 		std::optional<std::string> yulSteps;
 	} optimizer;
 
@@ -245,12 +248,12 @@ class CommandLineParser
 
 	CommandLineOptions const& options() const { return m_options; }
 
-	static void printHelp(std::ostream& _out) { _out << optionsDescription(); }
+	static void printHelp(std::ostream& _out) { _out << optionsDescription(true /* _forHelp */); }
 
 private:
 	/// @returns a specification of all named command-line options accepted by the compiler.
 	/// The object can be used to parse command-line arguments or to generate the help screen.
-	static boost::program_options::options_description optionsDescription();
+	static boost::program_options::options_description optionsDescription(bool _forHelp = false);
 
 	/// @returns a specification of all positional command-line arguments accepted by the compiler.
 	/// The object can be used to parse command-line arguments or to generate the help screen.
@@ -292,4 +295,4 @@ class CommandLineParser
 	boost::program_options::variables_map m_args;
 };
 
-}
+} // namespace solidity::frontend
diff --git a/compiler/solc/main.cpp b/compiler/solc/main.cpp
index 50a6a8fc..4237f9ac 100644
--- a/compiler/solc/main.cpp
+++ b/compiler/solc/main.cpp
@@ -29,7 +29,6 @@
 
 #include <iostream>
 
-using namespace std;
 using namespace solidity;
 
 
@@ -37,43 +36,31 @@ int main(int argc, char** argv)
 {
 	try
 	{
-		solidity::frontend::CommandLineInterface cli(cin, cout, cerr);
+		solidity::frontend::CommandLineInterface cli(std::cin, std::cout, std::cerr);
 		return cli.run(argc, argv) ? 0 : 1;
 	}
 	catch (smtutil::SMTLogicError const& _exception)
 	{
-		cerr << "SMT logic error:" << endl;
-		cerr << boost::diagnostic_information(_exception);
-		return 1;
+		std::cerr << "SMT logic error:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
+		return 2;
 	}
 	catch (langutil::UnimplementedFeatureError const& _exception)
 	{
-		cerr << "Unimplemented feature:" << endl;
-		cerr << boost::diagnostic_information(_exception);
-		return 1;
+		std::cerr << "Unimplemented feature:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
+		return 2;
 	}
 	catch (langutil::InternalCompilerError const& _exception)
 	{
-		cerr << "Internal compiler error:" << endl;
-		cerr << boost::diagnostic_information(_exception);
-		return 1;
-	}
-	catch (boost::exception const& _exception)
-	{
-		cerr << "Uncaught exception:" << endl;
-		cerr << boost::diagnostic_information(_exception) << endl;
-		return 1;
-	}
-	catch (std::exception const& _exception)
-	{
-		cerr << "Uncaught exception:" << endl;
-		cerr << boost::diagnostic_information(_exception) << endl;
-		return 1;
+		std::cerr << "Internal compiler error:" << std::endl;
+		std::cerr << boost::diagnostic_information(_exception);
+		return 2;
 	}
 	catch (...)
 	{
-		cerr << "Uncaught exception" << endl;
-		cerr << boost::current_exception_diagnostic_information() << endl;
-		return 1;
+		std::cerr << "Uncaught exception:" << std::endl;
+		std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+		return 2;
 	}
 }
diff --git a/compiler/test/CMakeLists.txt b/compiler/test/CMakeLists.txt
new file mode 100644
index 00000000..d5435237
--- /dev/null
+++ b/compiler/test/CMakeLists.txt
@@ -0,0 +1,224 @@
+set(sources
+    soltest.cpp
+    Common.cpp
+    Common.h
+    CommonSyntaxTest.cpp
+    CommonSyntaxTest.h
+    EVMHost.cpp
+    EVMHost.h
+    ExecutionFramework.cpp
+    ExecutionFramework.h
+    FilesystemUtils.cpp
+    FilesystemUtils.h
+    InteractiveTests.h
+    Metadata.cpp
+    Metadata.h
+    TestCase.cpp
+    TestCase.h
+    TestCaseReader.cpp
+    TestCaseReader.h
+)
+detect_stray_source_files("${sources}" ".")
+
+set(contracts_sources
+    contracts/AuctionRegistrar.cpp
+    contracts/ContractInterface.h
+    contracts/Wallet.cpp
+)
+detect_stray_source_files("${contracts_sources}" "contracts/")
+
+set(libsolutil_sources
+    libsolutil/Checksum.cpp
+    libsolutil/CommonData.cpp
+    libsolutil/CommonIO.cpp
+    libsolutil/FixedHash.cpp
+    libsolutil/FunctionSelector.cpp
+    libsolutil/IpfsHash.cpp
+    libsolutil/IterateReplacing.cpp
+    libsolutil/JSON.cpp
+    libsolutil/Keccak256.cpp
+    libsolutil/LazyInit.cpp
+    libsolutil/LEB128.cpp
+    libsolutil/StringUtils.cpp
+    libsolutil/SwarmHash.cpp
+    libsolutil/TemporaryDirectoryTest.cpp
+    libsolutil/UTF8.cpp
+    libsolutil/Whiskers.cpp
+)
+detect_stray_source_files("${libsolutil_sources}" "libsolutil/")
+
+set(libevmasm_sources
+    libevmasm/Assembler.cpp
+    libevmasm/Optimiser.cpp
+)
+detect_stray_source_files("${libevmasm_sources}" "libevmasm/")
+
+set(liblangutil_sources
+    liblangutil/CharStream.cpp
+    liblangutil/Scanner.cpp
+    liblangutil/SourceLocation.cpp
+)
+detect_stray_source_files("${liblangutil_sources}" "liblangutil/")
+
+set(libsolidity_sources
+    libsolidity/ABIDecoderTests.cpp
+    libsolidity/ABIEncoderTests.cpp
+    libsolidity/ABIJsonTest.cpp
+    libsolidity/ABIJsonTest.h
+    libsolidity/ABITestsCommon.h
+    libsolidity/AnalysisFramework.cpp
+    libsolidity/AnalysisFramework.h
+    libsolidity/Assembly.cpp
+    libsolidity/ASTJSONTest.cpp
+    libsolidity/ASTJSONTest.h
+    libsolidity/ErrorCheck.cpp
+    libsolidity/ErrorCheck.h
+    libsolidity/FunctionDependencyGraphTest.cpp
+    libsolidity/FunctionDependencyGraphTest.h
+    libsolidity/GasCosts.cpp
+    libsolidity/GasMeter.cpp
+    libsolidity/GasTest.cpp
+    libsolidity/GasTest.h
+    libsolidity/Imports.cpp
+    libsolidity/InlineAssembly.cpp
+    libsolidity/LibSolc.cpp
+    libsolidity/Metadata.cpp
+    libsolidity/MemoryGuardTest.cpp
+    libsolidity/MemoryGuardTest.h
+    libsolidity/NatspecJSONTest.cpp
+    libsolidity/NatspecJSONTest.h
+    libsolidity/SemanticTest.cpp
+    libsolidity/SemanticTest.h
+    libsolidity/SemVerMatcher.cpp
+    libsolidity/SMTCheckerTest.cpp
+    libsolidity/SMTCheckerTest.h
+    libsolidity/SolidityCompiler.cpp
+    libsolidity/SolidityEndToEndTest.cpp
+    libsolidity/SolidityExecutionFramework.cpp
+    libsolidity/SolidityExecutionFramework.h
+    libsolidity/SolidityExpressionCompiler.cpp
+    libsolidity/SolidityNameAndTypeResolution.cpp
+    libsolidity/SolidityOptimizer.cpp
+    libsolidity/SolidityParser.cpp
+    libsolidity/SolidityTypes.cpp
+    libsolidity/StandardCompiler.cpp
+    libsolidity/SyntaxTest.cpp
+    libsolidity/SyntaxTest.h
+    libsolidity/ViewPureChecker.cpp
+    libsolidity/analysis/FunctionCallGraph.cpp
+    libsolidity/interface/FileReader.cpp
+    libsolidity/ASTPropertyTest.h
+    libsolidity/ASTPropertyTest.cpp
+)
+detect_stray_source_files("${libsolidity_sources}" "libsolidity/")
+
+set(libsolidity_util_sources
+    libsolidity/util/BytesUtils.cpp
+    libsolidity/util/BytesUtilsTests.cpp
+    libsolidity/util/BytesUtils.h
+    libsolidity/util/Common.cpp
+    libsolidity/util/Common.h
+    libsolidity/util/ContractABIUtils.cpp
+    libsolidity/util/ContractABIUtils.h
+    libsolidity/util/SoltestErrors.h
+    libsolidity/util/SoltestTypes.h
+    libsolidity/util/TestFileParser.cpp
+    libsolidity/util/TestFileParser.h
+    libsolidity/util/TestFileParserTests.cpp
+    libsolidity/util/TestFunctionCall.cpp
+    libsolidity/util/TestFunctionCall.h
+    libsolidity/util/TestFunctionCallTests.cpp
+)
+detect_stray_source_files("${libsolidity_util_sources}" "libsolidity/util/")
+
+set(libyul_sources
+    libyul/Common.cpp
+    libyul/Common.h
+    libyul/CompilabilityChecker.cpp
+    libyul/ControlFlowGraphTest.cpp
+    libyul/ControlFlowGraphTest.h
+    libyul/ControlFlowSideEffectsTest.cpp
+    libyul/ControlFlowSideEffectsTest.h
+    libyul/EVMCodeTransformTest.cpp
+    libyul/EVMCodeTransformTest.h
+    libyul/FunctionSideEffects.cpp
+    libyul/FunctionSideEffects.h
+    libyul/Inliner.cpp
+    libyul/KnowledgeBaseTest.cpp
+    libyul/Metrics.cpp
+    libyul/ObjectCompilerTest.cpp
+    libyul/ObjectCompilerTest.h
+    libyul/ObjectParser.cpp
+    libyul/Parser.cpp
+    libyul/StackLayoutGeneratorTest.cpp
+    libyul/StackLayoutGeneratorTest.h
+    libyul/StackShufflingTest.cpp
+    libyul/StackShufflingTest.h
+    libyul/SyntaxTest.h
+    libyul/SyntaxTest.cpp
+    libyul/YulInterpreterTest.cpp
+    libyul/YulInterpreterTest.h
+    libyul/YulOptimizerTest.cpp
+    libyul/YulOptimizerTest.h
+    libyul/YulOptimizerTestCommon.cpp
+    libyul/YulOptimizerTestCommon.h
+)
+detect_stray_source_files("${libyul_sources}" "libyul/")
+
+set(solcli_sources
+    solc/Common.cpp
+    solc/Common.h
+    solc/CommandLineInterface.cpp
+    solc/CommandLineInterfaceAllowPaths.cpp
+    solc/CommandLineParser.cpp
+)
+detect_stray_source_files("${solcli_sources}" "solc/")
+
+set(yul_phaser_sources
+    yulPhaser/TestHelpers.h
+    yulPhaser/TestHelpers.cpp
+    yulPhaser/TestHelpersTest.cpp
+    yulPhaser/Common.cpp
+    yulPhaser/Chromosome.cpp
+    yulPhaser/FitnessMetrics.cpp
+    yulPhaser/AlgorithmRunner.cpp
+    yulPhaser/GeneticAlgorithms.cpp
+    yulPhaser/Mutations.cpp
+    yulPhaser/PairSelections.cpp
+    yulPhaser/Phaser.cpp
+    yulPhaser/Population.cpp
+    yulPhaser/Program.cpp
+    yulPhaser/ProgramCache.cpp
+    yulPhaser/Selections.cpp
+    yulPhaser/SimulationRNG.cpp
+)
+detect_stray_source_files("${yul_phaser_sources}" "yulPhaser/")
+
+add_executable(soltest ${sources}
+    ${contracts_sources}
+    ${libsolutil_sources}
+    ${liblangutil_sources}
+    ${libevmasm_sources}
+    ${libyul_sources}
+    ${libsolidity_sources}
+    ${libsolidity_util_sources}
+    ${solcli_sources}
+    ${yul_phaser_sources}
+)
+target_link_libraries(soltest PRIVATE solcli libsolc yul solidity smtutil solutil phaser Boost::boost yulInterpreter evmasm Boost::filesystem Boost::program_options Boost::unit_test_framework evmc)
+
+
+# Special compilation flag for Visual Studio (version 2019 at least affected)
+# in order to compile SolidityEndToEndTest.cpp, which is quite huge.
+# We can remove this flag once we've extracted the tests.
+# TODO: Remove this option as soon as we have reduced the SLoC's in SolidityEndToEndTest.cpp
+if (MSVC)
+    target_compile_options(soltest PUBLIC "/bigobj")
+endif()
+
+if (NOT Boost_USE_STATIC_LIBS)
+    target_compile_definitions(soltest PUBLIC -DBOOST_TEST_DYN_LINK)
+endif()
+
+add_subdirectory(tools)
+add_subdirectory(evmc)
diff --git a/compiler/test/Common.cpp b/compiler/test/Common.cpp
new file mode 100644
index 00000000..6a3c5a2a
--- /dev/null
+++ b/compiler/test/Common.cpp
@@ -0,0 +1,316 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <stdexcept>
+#include <iostream>
+#include <test/Common.h>
+#include <test/EVMHost.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/Assertions.h>
+#include <libsolutil/StringUtils.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+#include <range/v3/all.hpp>
+
+namespace fs = boost::filesystem;
+namespace po = boost::program_options;
+
+using namespace std;
+
+namespace solidity::test
+{
+
+namespace
+{
+
+/// If non-empty returns the value of the env. variable ETH_TEST_PATH, otherwise
+/// it tries to find a path that contains the directories "libsolidity/syntaxTests"
+/// and returns it if found.
+/// The routine searches in the current directory, and inside the "test" directory
+/// starting from the current directory and up to three levels up.
+/// @returns the path of the first match or an empty path if not found.
+boost::filesystem::path testPath()
+{
+	if (auto path = getenv("ETH_TEST_PATH"))
+		return path;
+
+	auto const searchPath =
+	{
+		fs::current_path() / ".." / ".." / ".." / "test",
+		fs::current_path() / ".." / ".." / "test",
+		fs::current_path() / ".." / "test",
+		fs::current_path() / "test",
+		fs::current_path()
+	};
+	for (auto const& basePath: searchPath)
+	{
+		fs::path syntaxTestPath = basePath / "libsolidity" / "syntaxTests";
+		if (fs::exists(syntaxTestPath) && fs::is_directory(syntaxTestPath))
+			return basePath;
+	}
+	return {};
+}
+
+std::optional<fs::path> findInDefaultPath(std::string const& lib_name)
+{
+	auto const searchPath =
+	{
+		fs::current_path() / "deps",
+		fs::current_path() / "deps" / "lib",
+		fs::current_path() / ".." / "deps",
+		fs::current_path() / ".." / "deps" / "lib",
+		fs::current_path() / ".." / ".." / "deps",
+		fs::current_path() / ".." / ".." / "deps" / "lib",
+		fs::current_path()
+	};
+	for (auto const& basePath: searchPath)
+	{
+		fs::path p = basePath / lib_name;
+		if (fs::exists(p))
+			return p;
+	}
+	return std::nullopt;
+}
+
+}
+
+CommonOptions::CommonOptions(std::string _caption):
+	options(_caption,
+		po::options_description::m_default_line_length,
+		po::options_description::m_default_line_length - 23
+	)
+{
+
+}
+
+void CommonOptions::addOptions()
+{
+	options.add_options()
+		("evm-version", po::value(&evmVersionString), "which EVM version to use")
+		// "eof-version" is declared as uint64_t, since uint8_t will be parsed as character by boost.
+		("eof-version", po::value<uint64_t>()->implicit_value(1u), "which EOF version to use")
+		("testpath", po::value<fs::path>(&this->testPath)->default_value(solidity::test::testPath()), "path to test files")
+		("vm", po::value<std::vector<fs::path>>(&vmPaths), "path to evmc library, can be supplied multiple times.")
+		("batches", po::value<size_t>(&this->batches)->default_value(1), "set number of batches to split the tests into")
+		("selected-batch", po::value<size_t>(&this->selectedBatch)->default_value(0), "zero-based number of batch to execute")
+		("no-semantic-tests", po::bool_switch(&disableSemanticTests)->default_value(disableSemanticTests), "disable semantic tests")
+		("no-smt", po::bool_switch(&disableSMT)->default_value(disableSMT), "disable SMT checker")
+		("optimize", po::bool_switch(&optimize)->default_value(optimize), "enables optimization")
+		("enforce-gas-cost", po::value<bool>(&enforceGasTest)->default_value(enforceGasTest)->implicit_value(true), "Enforce checking gas cost in semantic tests.")
+		("enforce-gas-cost-min-value", po::value(&enforceGasTestMinValue)->default_value(enforceGasTestMinValue), "Threshold value to enforce adding gas checks to a test.")
+		("abiencoderv1", po::bool_switch(&useABIEncoderV1)->default_value(useABIEncoderV1), "enables abi encoder v1")
+		("show-messages", po::bool_switch(&showMessages)->default_value(showMessages), "enables message output")
+		("show-metadata", po::bool_switch(&showMetadata)->default_value(showMetadata), "enables metadata output");
+}
+
+void CommonOptions::validate() const
+{
+	assertThrow(
+		!testPath.empty(),
+		ConfigException,
+		"No test path specified. The --testpath argument must not be empty when given."
+	);
+	assertThrow(
+		fs::exists(testPath),
+		ConfigException,
+		"Invalid test path specified."
+	);
+	assertThrow(
+		batches > 0,
+		ConfigException,
+		"Batches needs to be at least 1."
+	);
+	assertThrow(
+		selectedBatch < batches,
+		ConfigException,
+		"Selected batch has to be less than number of batches."
+	);
+
+	if (enforceGasTest)
+	{
+		assertThrow(
+			evmVersion() == langutil::EVMVersion{},
+			ConfigException,
+			"Gas costs can only be enforced on latest evm version."
+		);
+		assertThrow(
+			useABIEncoderV1 == false,
+			ConfigException,
+			"Gas costs can only be enforced on abi encoder v2."
+		);
+	}
+}
+
+bool CommonOptions::parse(int argc, char const* const* argv)
+{
+	po::variables_map arguments;
+	addOptions();
+
+	try
+	{
+		po::command_line_parser cmdLineParser(argc, argv);
+		cmdLineParser.options(options);
+		auto parsedOptions = cmdLineParser.run();
+		po::store(parsedOptions, arguments);
+		po::notify(arguments);
+		if (arguments.count("eof-version"))
+		{
+			// Request as uint64_t, since uint8_t will be parsed as character by boost.
+			uint64_t eofVersion = arguments["eof-version"].as<uint64_t>();
+			if (eofVersion != 1)
+				BOOST_THROW_EXCEPTION(std::runtime_error("Invalid EOF version: " + to_string(eofVersion)));
+			m_eofVersion = 1;
+		}
+
+		for (auto const& parsedOption: parsedOptions.options)
+			if (parsedOption.position_key >= 0)
+			{
+				if (
+					parsedOption.original_tokens.empty() ||
+					(parsedOption.original_tokens.size() == 1 && parsedOption.original_tokens.front().empty())
+				)
+					continue; // ignore empty options
+				std::stringstream errorMessage;
+				errorMessage << "Unrecognized option: ";
+				for (auto const& token: parsedOption.original_tokens)
+					errorMessage << token;
+				BOOST_THROW_EXCEPTION(std::runtime_error(errorMessage.str()));
+			}
+	}
+	catch (po::error const& exception)
+	{
+		solThrow(ConfigException, exception.what());
+	}
+
+	if (vmPaths.empty())
+	{
+		if (auto envPath = getenv("ETH_EVMONE"))
+			vmPaths.emplace_back(envPath);
+		else if (auto repoPath = findInDefaultPath(evmoneFilename))
+			vmPaths.emplace_back(*repoPath);
+		else
+			vmPaths.emplace_back(evmoneFilename);
+	}
+
+	return true;
+}
+
+string CommonOptions::toString(vector<string> const& _selectedOptions) const
+{
+	if (_selectedOptions.empty())
+		return "";
+
+	auto boolToString = [](bool _value) -> string { return _value ? "true" : "false"; };
+	// Using std::map to avoid if-else/switch-case block
+	map<string, string> optionValueMap = {
+		{"evmVersion", evmVersion().name()},
+		{"optimize", boolToString(optimize)},
+		{"useABIEncoderV1", boolToString(useABIEncoderV1)},
+		{"batch", to_string(selectedBatch + 1) + "/" + to_string(batches)},
+		{"enforceGasTest", boolToString(enforceGasTest)},
+		{"enforceGasTestMinValue", enforceGasTestMinValue.str()},
+		{"disableSemanticTests", boolToString(disableSemanticTests)},
+		{"disableSMT", boolToString(disableSMT)},
+		{"showMessages", boolToString(showMessages)},
+		{"showMetadata", boolToString(showMetadata)}
+	};
+
+	soltestAssert(ranges::all_of(_selectedOptions, [&optionValueMap](string const& _option) { return optionValueMap.count(_option) > 0; }));
+
+	vector<string> optionsWithValues = _selectedOptions |
+		ranges::views::transform([&optionValueMap](string const& _option) { return _option + "=" + optionValueMap.at(_option); }) |
+		ranges::to<vector>();
+
+	return solidity::util::joinHumanReadable(optionsWithValues);
+}
+
+void CommonOptions::printSelectedOptions(ostream& _stream, string const& _linePrefix, vector<string> const& _selectedOptions) const
+{
+	_stream << _linePrefix << "Run Settings: " << toString(_selectedOptions) << endl;
+}
+
+langutil::EVMVersion CommonOptions::evmVersion() const
+{
+	if (!evmVersionString.empty())
+	{
+		auto version = langutil::EVMVersion::fromString(evmVersionString);
+		if (!version)
+			BOOST_THROW_EXCEPTION(std::runtime_error("Invalid EVM version: " + evmVersionString));
+		return *version;
+	}
+	else
+		return langutil::EVMVersion();
+}
+
+CommonOptions const& CommonOptions::get()
+{
+	if (!m_singleton)
+		BOOST_THROW_EXCEPTION(std::runtime_error("Options not yet constructed!"));
+
+	return *m_singleton;
+}
+
+void CommonOptions::setSingleton(std::unique_ptr<CommonOptions const>&& _instance)
+{
+	m_singleton = std::move(_instance);
+}
+
+std::unique_ptr<CommonOptions const> CommonOptions::m_singleton = nullptr;
+
+bool isValidSemanticTestPath(boost::filesystem::path const& _testPath)
+{
+	bool insideSemanticTests = false;
+	fs::path testPathPrefix;
+	for (auto const& element: _testPath)
+	{
+		testPathPrefix /= element;
+		if (boost::ends_with(canonical(testPathPrefix).generic_string(), "/test/libsolidity/semanticTests"))
+			insideSemanticTests = true;
+		if (insideSemanticTests && boost::starts_with(element.string(), "_"))
+			return false;
+	}
+	return true;
+}
+
+boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVersion _minEVMVersion)
+{
+	return [_minEVMVersion](boost::unit_test::test_unit_id) {
+		return test::CommonOptions::get().evmVersion() >= _minEVMVersion;
+	};
+}
+
+bool loadVMs(CommonOptions const& _options)
+{
+	if (_options.disableSemanticTests)
+		return true;
+
+	bool evmSupported = solidity::test::EVMHost::checkVmPaths(_options.vmPaths);
+	if (!_options.disableSemanticTests && !evmSupported)
+	{
+		std::cerr << "Unable to find " << solidity::test::evmoneFilename;
+		std::cerr << ". Please disable semantics tests with --no-semantic-tests or provide a path using --vm <path>." << std::endl;
+		std::cerr << "You can download it at" << std::endl;
+		std::cerr << solidity::test::evmoneDownloadLink << std::endl;
+		return false;
+	}
+	return true;
+}
+
+}
diff --git a/compiler/test/Common.h b/compiler/test/Common.h
new file mode 100644
index 00000000..b5963c88
--- /dev/null
+++ b/compiler/test/Common.h
@@ -0,0 +1,134 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolutil/Exceptions.h>
+#include <liblangutil/EVMVersion.h>
+#include <liblangutil/Exceptions.h>
+#include <libsolutil/Numeric.h>
+
+#include <test/evmc/evmc.h>
+
+#include <boost/filesystem/path.hpp>
+#include <boost/program_options.hpp>
+#include <boost/test/unit_test.hpp>
+
+namespace solidity::test
+{
+
+#ifdef _WIN32
+static constexpr auto evmoneFilename = "evmone.dll";
+static constexpr auto evmoneDownloadLink = "https://github.com/ethereum/evmone/releases/download/v0.11.0/evmone-0.11.0-windows-amd64.zip";
+#elif defined(__APPLE__)
+static constexpr auto evmoneFilename = "libevmone.dylib";
+static constexpr auto evmoneDownloadLink = "https://github.com/ethereum/evmone/releases/download/v0.11.0/evmone-0.11.0-darwin-x86_64.tar.gz";
+#else
+static constexpr auto evmoneFilename = "libevmone.so";
+static constexpr auto evmoneDownloadLink = "https://github.com/ethereum/evmone/releases/download/v0.11.0/evmone-0.11.0-linux-x86_64.tar.gz";
+#endif
+
+struct ConfigException: public util::Exception {};
+
+struct CommonOptions
+{
+	/// Noncopyable.
+	CommonOptions(CommonOptions const&) = delete;
+	CommonOptions& operator=(CommonOptions const&) = delete;
+
+	std::vector<boost::filesystem::path> vmPaths;
+	boost::filesystem::path testPath;
+	bool optimize = false;
+	bool enforceGasTest = false;
+	u256 enforceGasTestMinValue = 100000;
+	bool disableSemanticTests = false;
+	bool disableSMT = false;
+	bool useABIEncoderV1 = false;
+	bool showMessages = false;
+	bool showMetadata = false;
+	size_t batches = 1;
+	size_t selectedBatch = 0;
+
+	langutil::EVMVersion evmVersion() const;
+	std::optional<uint8_t> eofVersion() const { return m_eofVersion; }
+
+	virtual void addOptions();
+	// @returns true if the program should continue, false if it should exit immediately without
+	// reporting an error.
+	// Throws ConfigException or std::runtime_error if parsing fails.
+	virtual bool parse(int argc, char const* const* argv);
+	// Throws a ConfigException on error
+	virtual void validate() const;
+
+	/// @returns string with a key=value list of the options separated by comma
+	/// Ex.: "evmVersion=london, optimize=true, useABIEncoderV1=false"
+	virtual std::string toString(std::vector<std::string> const& _selectedOptions) const;
+	/// Helper to print the value of settings used
+	virtual void printSelectedOptions(std::ostream& _stream, std::string const& _linePrefix, std::vector<std::string> const& _selectedOptions) const;
+
+	static CommonOptions const& get();
+	static void setSingleton(std::unique_ptr<CommonOptions const>&& _instance);
+
+	CommonOptions(std::string caption = "");
+	virtual ~CommonOptions() {}
+
+protected:
+	boost::program_options::options_description options;
+
+private:
+	std::string evmVersionString;
+	std::optional<uint8_t> m_eofVersion;
+	static std::unique_ptr<CommonOptions const> m_singleton;
+};
+
+/// @return true if it is ok to treat the file located under the specified path as a semantic test.
+/// I.e. if the test is located in the semantic test directory and is not excluded due to being a part of external sources.
+/// Note: @p _testPath can be relative but must include at least the `/test/libsolidity/semanticTests/` part
+bool isValidSemanticTestPath(boost::filesystem::path const& _testPath);
+
+/// Helper that can be used to skip tests when the EVM version selected on the command line
+/// is older than @p _minEVMVersion.
+/// @return A predicate (function) that can be passed into @a boost::unit_test::precondition().
+boost::unit_test::precondition::predicate_t minEVMVersionCheck(langutil::EVMVersion _minEVMVersion);
+
+bool loadVMs(CommonOptions const& _options);
+
+/**
+ * Component to help with splitting up all tests into batches.
+ */
+class Batcher
+{
+public:
+	Batcher(size_t _offset, size_t _batches):
+		m_offset(_offset),
+		m_batches(_batches)
+	{
+		solAssert(m_batches > 0 && m_offset < m_batches);
+	}
+	Batcher(Batcher const&) = delete;
+	Batcher& operator=(Batcher const&) = delete;
+
+	bool checkAndAdvance() { return (m_counter++) % m_batches == m_offset; }
+
+private:
+	size_t const m_offset;
+	size_t const m_batches;
+	size_t m_counter = 0;
+};
+
+}
diff --git a/compiler/test/CommonSyntaxTest.cpp b/compiler/test/CommonSyntaxTest.cpp
new file mode 100644
index 00000000..0dedd1fb
--- /dev/null
+++ b/compiler/test/CommonSyntaxTest.cpp
@@ -0,0 +1,309 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/CommonSyntaxTest.h>
+#include <test/Common.h>
+#include <test/TestCase.h>
+
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <fstream>
+#include <memory>
+#include <stdexcept>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::util::formatting;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::test;
+using namespace boost::unit_test;
+namespace fs = boost::filesystem;
+
+namespace
+{
+
+int parseUnsignedInteger(string::iterator& _it, string::iterator _end)
+{
+	if (_it == _end || !util::isDigit(*_it))
+		BOOST_THROW_EXCEPTION(runtime_error("Invalid test expectation. Source location expected."));
+	int result = 0;
+	while (_it != _end && util::isDigit(*_it))
+	{
+		result *= 10;
+		result += *_it - '0';
+		++_it;
+	}
+	return result;
+}
+
+}
+
+CommonSyntaxTest::CommonSyntaxTest(string const& _filename, langutil::EVMVersion _evmVersion):
+	EVMVersionRestrictedTestCase(_filename),
+	m_sources(m_reader.sources()),
+	m_expectations(parseExpectations(m_reader.stream())),
+	m_evmVersion(_evmVersion)
+{
+}
+
+TestCase::TestResult CommonSyntaxTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
+{
+	parseCustomExpectations(m_reader.stream());
+	parseAndAnalyze();
+
+	return conclude(_stream, _linePrefix, _formatted);
+}
+
+TestCase::TestResult CommonSyntaxTest::conclude(ostream& _stream, string const& _linePrefix, bool _formatted)
+{
+	if (expectationsMatch())
+		return TestResult::Success;
+
+	printExpectationAndError(_stream, _linePrefix, _formatted);
+	return TestResult::Failure;
+}
+
+void CommonSyntaxTest::printExpectationAndError(ostream& _stream, string const& _linePrefix, bool _formatted)
+{
+	string nextIndentLevel = _linePrefix + "  ";
+	util::AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << endl;
+	printExpectedResult(_stream, nextIndentLevel, _formatted);
+	util::AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Obtained result:" << endl;
+	printObtainedResult(_stream, nextIndentLevel, _formatted);
+}
+
+void CommonSyntaxTest::printSource(ostream& _stream, string const& _linePrefix, bool _formatted) const
+{
+	if (m_sources.sources.empty())
+		return;
+
+	assert(m_sources.externalSources.empty());
+	bool outputSourceNames = (m_sources.sources.size() != 1 || !m_sources.sources.begin()->first.empty());
+
+	for (auto const& [name, source]: m_sources.sources)
+		if (_formatted)
+		{
+			if (source.empty())
+				continue;
+
+			if (outputSourceNames)
+				_stream << _linePrefix << util::formatting::CYAN << "==== Source: " << name << " ====" << util::formatting::RESET << endl;
+			vector<char const*> sourceFormatting(source.length(), util::formatting::RESET);
+			for (auto const& error: m_errorList)
+				if (error.sourceName == name && error.locationStart >= 0 && error.locationEnd >= 0)
+				{
+					assert(static_cast<size_t>(error.locationStart) <= source.length());
+					assert(static_cast<size_t>(error.locationEnd) <= source.length());
+					for (int i = error.locationStart; i < error.locationEnd; i++)
+					{
+						char const*& cellFormat = sourceFormatting[static_cast<size_t>(i)];
+						char const* infoBgColor = SourceReferenceFormatter::errorHighlightColor(Error::Severity::Info);
+
+						if (
+							(error.type != Error::Type::Warning && error.type != Error::Type::Info) ||
+							(error.type == Error::Type::Warning && (cellFormat == RESET || cellFormat == infoBgColor)) ||
+							(error.type == Error::Type::Info && cellFormat == RESET)
+						)
+							cellFormat = SourceReferenceFormatter::errorHighlightColor(Error::errorSeverity(error.type));
+					}
+				}
+
+			_stream << _linePrefix << sourceFormatting.front() << source.front();
+			for (size_t i = 1; i < source.length(); i++)
+			{
+				if (sourceFormatting[i] != sourceFormatting[i - 1])
+					_stream << sourceFormatting[i];
+				if (source[i] != '\n')
+					_stream << source[i];
+				else
+				{
+					_stream << util::formatting::RESET << endl;
+					if (i + 1 < source.length())
+						_stream << _linePrefix << sourceFormatting[i];
+				}
+			}
+			_stream << util::formatting::RESET;
+		}
+		else
+		{
+			if (outputSourceNames)
+				printPrefixed(_stream, "==== Source: " + name + " ====", _linePrefix);
+			printPrefixed(_stream, source, _linePrefix);
+		}
+}
+
+void CommonSyntaxTest::parseCustomExpectations(istream& _stream)
+{
+	string remainingExpectations = boost::trim_copy(readUntilEnd(_stream));
+	soltestAssert(
+		remainingExpectations.empty(),
+		"Found custom expectations not supported by the test case:\n" + remainingExpectations
+	);
+}
+
+bool CommonSyntaxTest::expectationsMatch()
+{
+	return m_expectations == m_errorList;
+}
+
+void CommonSyntaxTest::printExpectedResult(ostream& _stream, string const& _linePrefix, bool _formatted) const
+{
+	printErrorList(_stream, m_expectations, _linePrefix, _formatted);
+}
+
+void CommonSyntaxTest::printObtainedResult(ostream& _stream, string const& _linePrefix, bool _formatted) const
+{
+	printErrorList(_stream, m_errorList, _linePrefix, _formatted);
+}
+
+void CommonSyntaxTest::printErrorList(
+	ostream& _stream,
+	vector<SyntaxTestError> const& _errorList,
+	string const& _linePrefix,
+	bool _formatted
+)
+{
+	if (_errorList.empty())
+	{
+		if (_formatted)
+			util::AnsiColorized(_stream, _formatted, {BOLD, GREEN}) << _linePrefix << "Success" << endl;
+	}
+	else
+		for (auto const& error: _errorList)
+		{
+			{
+				util::AnsiColorized scope(
+					_stream,
+					_formatted,
+					{BOLD, SourceReferenceFormatter::errorTextColor(Error::errorSeverity(error.type))}
+				);
+				_stream << _linePrefix << Error::formatErrorType(error.type);
+				if (error.errorId.has_value())
+					_stream << ' ' << error.errorId->error;
+				_stream << ": ";
+			}
+			if (!error.sourceName.empty() || error.locationStart >= 0 || error.locationEnd >= 0)
+			{
+				_stream << "(";
+				if (!error.sourceName.empty())
+					_stream << error.sourceName << ":";
+				if (error.locationStart >= 0)
+					_stream << error.locationStart;
+				_stream << "-";
+				if (error.locationEnd >= 0)
+					_stream << error.locationEnd;
+				_stream << "): ";
+			}
+			_stream << error.message << endl;
+		}
+}
+
+string CommonSyntaxTest::errorMessage(util::Exception const& _e)
+{
+	if (_e.comment() && !_e.comment()->empty())
+		return boost::replace_all_copy(*_e.comment(), "\n", "\\n");
+	else
+		return "NONE";
+}
+
+vector<SyntaxTestError> CommonSyntaxTest::parseExpectations(istream& _stream)
+{
+	static string const customExpectationsDelimiter("// ----");
+
+	vector<SyntaxTestError> expectations;
+	string line;
+	while (getline(_stream, line))
+	{
+		auto it = line.begin();
+
+		// Anything below the delimiter is left up to the derived class to process in a custom way.
+		// The delimiter is optional and identical to the one that starts error expectations in
+		// TestCaseReader::parseSourcesAndSettingsWithLineNumber().
+		if (boost::algorithm::starts_with(line, customExpectationsDelimiter))
+			break;
+
+		skipSlashes(it, line.end());
+		skipWhitespace(it, line.end());
+
+		if (it == line.end()) continue;
+
+		auto typeBegin = it;
+		while (it != line.end() && isalpha(*it, locale::classic()))
+			++it;
+
+		string errorTypeStr(typeBegin, it);
+		optional<Error::Type> errorType = Error::parseErrorType(errorTypeStr);
+		if (!errorType.has_value())
+			BOOST_THROW_EXCEPTION(runtime_error("Invalid error type: " + errorTypeStr));
+
+		skipWhitespace(it, line.end());
+
+		optional<ErrorId> errorId;
+		if (it != line.end() && util::isDigit(*it))
+			errorId = ErrorId{static_cast<unsigned long long>(parseUnsignedInteger(it, line.end()))};
+
+		expect(it, line.end(), ':');
+		skipWhitespace(it, line.end());
+
+		int locationStart = -1;
+		int locationEnd = -1;
+		std::string sourceName;
+
+		if (it != line.end() && *it == '(')
+		{
+			++it;
+			if (it != line.end() && !util::isDigit(*it))
+			{
+				auto sourceNameStart = it;
+				while (it != line.end() && *it != ':')
+					++it;
+				sourceName = std::string(sourceNameStart, it);
+				expect(it, line.end(), ':');
+			}
+			locationStart = parseUnsignedInteger(it, line.end());
+			expect(it, line.end(), '-');
+			locationEnd = parseUnsignedInteger(it, line.end());
+			expect(it, line.end(), ')');
+			expect(it, line.end(), ':');
+		}
+
+		skipWhitespace(it, line.end());
+
+		string errorMessage(it, line.end());
+		expectations.emplace_back(SyntaxTestError{
+			errorType.value(),
+			std::move(errorId),
+			std::move(errorMessage),
+			std::move(sourceName),
+			locationStart,
+			locationEnd
+		});
+	}
+	return expectations;
+}
diff --git a/compiler/test/CommonSyntaxTest.h b/compiler/test/CommonSyntaxTest.h
new file mode 100644
index 00000000..fb46c37a
--- /dev/null
+++ b/compiler/test/CommonSyntaxTest.h
@@ -0,0 +1,104 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <test/TestCaseReader.h>
+#include <liblangutil/Exceptions.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::test
+{
+
+struct SyntaxTestError
+{
+	langutil::Error::Type type;
+	std::optional<langutil::ErrorId> errorId;
+	std::string message;
+	std::string sourceName;
+	int locationStart = -1;
+	int locationEnd = -1;
+	bool operator==(SyntaxTestError const& _rhs) const
+	{
+		return type == _rhs.type &&
+			errorId == _rhs.errorId &&
+			message == _rhs.message &&
+			sourceName == _rhs.sourceName &&
+			locationStart == _rhs.locationStart &&
+			locationEnd == _rhs.locationEnd;
+	}
+};
+
+
+class CommonSyntaxTest: public frontend::test::EVMVersionRestrictedTestCase
+{
+public:
+	CommonSyntaxTest(std::string const& _filename, langutil::EVMVersion _evmVersion);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false) override;
+
+	void printSource(std::ostream& _stream, std::string const &_linePrefix = "", bool _formatted = false) const override;
+	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const override
+	{
+		printObtainedResult(_stream, _linePrefix, false);
+	}
+
+	static std::string errorMessage(util::Exception const& _e);
+protected:
+	/// Should be implemented by those derived test cases that want to allow extra expectations
+	/// after the error/warning expectations. The default implementation does not allow them and
+	/// fails instead.
+	/// @param _stream Input stream positioned at the beginning of the extra expectations.
+	virtual void parseCustomExpectations(std::istream& _stream);
+
+	virtual void parseAndAnalyze() = 0;
+
+	/// Should return true if obtained values match expectations.
+	/// The default implementation only compares the error list. Derived classes that support
+	/// custom expectations should override this to include them in the comparison.
+	virtual bool expectationsMatch();
+
+	virtual void printExpectedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const;
+	virtual void printObtainedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const;
+
+	static void printErrorList(
+		std::ostream& _stream,
+		std::vector<SyntaxTestError> const& _errors,
+		std::string const& _linePrefix,
+		bool _formatted = false
+	);
+
+	TestResult conclude(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false);
+	void printExpectationAndError(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false);
+
+	static std::vector<SyntaxTestError> parseExpectations(std::istream& _stream);
+
+	frontend::test::SourceMap m_sources;
+	std::vector<SyntaxTestError> m_expectations;
+	std::vector<SyntaxTestError> m_errorList;
+	langutil::EVMVersion const m_evmVersion;
+};
+
+}
diff --git a/compiler/test/EVMHost.cpp b/compiler/test/EVMHost.cpp
new file mode 100644
index 00000000..7e05ceec
--- /dev/null
+++ b/compiler/test/EVMHost.cpp
@@ -0,0 +1,1274 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * EVM execution host, i.e. component that implements a simulated Ethereum blockchain
+ * for testing purposes.
+ */
+
+#include <test/EVMHost.h>
+
+#include <test/evmc/loader.h>
+
+#include <libevmasm/GasMeter.h>
+
+#include <libsolutil/Exceptions.h>
+#include <libsolutil/Assertions.h>
+#include <libsolutil/Keccak256.h>
+#include <libsolutil/picosha2.h>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::test;
+using namespace evmc::literals;
+
+evmc::VM& EVMHost::getVM(string const& _path)
+{
+	static evmc::VM NullVM{nullptr};
+	static map<string, unique_ptr<evmc::VM>> vms;
+	if (vms.count(_path) == 0)
+	{
+		evmc_loader_error_code errorCode = {};
+		auto vm = evmc::VM{evmc_load_and_configure(_path.c_str(), &errorCode)};
+		if (vm && errorCode == EVMC_LOADER_SUCCESS)
+		{
+			if (vm.get_capabilities() & (EVMC_CAPABILITY_EVM1))
+				vms[_path] = make_unique<evmc::VM>(evmc::VM(std::move(vm)));
+			else
+				cerr << "VM loaded does not support EVM1" << endl;
+		}
+		else
+		{
+			cerr << "Error loading VM from " << _path;
+			if (char const* errorMsg = evmc_last_error_msg())
+				cerr << ":" << endl << errorMsg;
+			cerr << endl;
+		}
+	}
+
+	if (vms.count(_path) > 0)
+		return *vms[_path];
+
+	return NullVM;
+}
+
+bool EVMHost::checkVmPaths(vector<boost::filesystem::path> const& _vmPaths)
+{
+	bool evmVmFound = false;
+	for (auto const& path: _vmPaths)
+	{
+		evmc::VM& vm = EVMHost::getVM(path.string());
+		if (!vm)
+			continue;
+
+		if (vm.has_capability(EVMC_CAPABILITY_EVM1))
+		{
+			if (evmVmFound)
+				BOOST_THROW_EXCEPTION(runtime_error("Multiple evm1 evmc vms defined. Please only define one evm1 evmc vm."));
+			evmVmFound = true;
+		}
+	}
+	return evmVmFound;
+}
+
+EVMHost::EVMHost(langutil::EVMVersion _evmVersion, evmc::VM& _vm):
+	m_vm(_vm),
+	m_evmVersion(_evmVersion)
+{
+	if (!m_vm)
+	{
+		cerr << "Unable to find evmone library" << endl;
+		assertThrow(false, Exception, "");
+	}
+
+	if (_evmVersion == langutil::EVMVersion::homestead())
+		m_evmRevision = EVMC_HOMESTEAD;
+	else if (_evmVersion == langutil::EVMVersion::tangerineWhistle())
+		m_evmRevision = EVMC_TANGERINE_WHISTLE;
+	else if (_evmVersion == langutil::EVMVersion::spuriousDragon())
+		m_evmRevision = EVMC_SPURIOUS_DRAGON;
+	else if (_evmVersion == langutil::EVMVersion::byzantium())
+		m_evmRevision = EVMC_BYZANTIUM;
+	else if (_evmVersion == langutil::EVMVersion::constantinople())
+		m_evmRevision = EVMC_CONSTANTINOPLE;
+	else if (_evmVersion == langutil::EVMVersion::petersburg())
+		m_evmRevision = EVMC_PETERSBURG;
+	else if (_evmVersion == langutil::EVMVersion::istanbul())
+		m_evmRevision = EVMC_ISTANBUL;
+	else if (_evmVersion == langutil::EVMVersion::berlin())
+		m_evmRevision = EVMC_BERLIN;
+	else if (_evmVersion == langutil::EVMVersion::london())
+		m_evmRevision = EVMC_LONDON;
+	else if (_evmVersion == langutil::EVMVersion::paris())
+		m_evmRevision = EVMC_PARIS;
+	else if (_evmVersion == langutil::EVMVersion::shanghai())
+		m_evmRevision = EVMC_SHANGHAI;
+	else if (_evmVersion == langutil::EVMVersion::cancun())
+		m_evmRevision = EVMC_CANCUN;
+	else
+		assertThrow(false, Exception, "Unsupported EVM version");
+
+	if (m_evmRevision >= EVMC_PARIS)
+		// This is the value from the merge block.
+		tx_context.block_prev_randao = 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777_bytes32;
+	else
+		tx_context.block_prev_randao = evmc::uint256be{200000000};
+	tx_context.block_gas_limit = 20000000;
+	tx_context.block_coinbase = 0x7878787878787878787878787878787878787878_address;
+	tx_context.tx_gas_price = evmc::uint256be{3000000000};
+	tx_context.tx_origin = 0x9292929292929292929292929292929292929292_address;
+	// Mainnet according to EIP-155
+	tx_context.chain_id = evmc::uint256be{1};
+	// The minimum value of basefee
+	tx_context.block_base_fee = evmc::bytes32{7};
+	// The minimum value of blobbasefee
+	tx_context.blob_base_fee = evmc::bytes32{1};
+
+	static evmc_bytes32 const blob_hashes_array[] = {
+		0x0100000000000000000000000000000000000000000000000000000000000001_bytes32,
+		0x0100000000000000000000000000000000000000000000000000000000000002_bytes32
+	};
+	tx_context.blob_hashes = blob_hashes_array;
+	tx_context.blob_hashes_count = sizeof(blob_hashes_array) / sizeof(blob_hashes_array[0]);
+
+	// Reserve space for recording calls.
+	if (!recorded_calls.capacity())
+		recorded_calls.reserve(max_recorded_calls);
+
+	reset();
+}
+
+void EVMHost::reset()
+{
+	accounts.clear();
+	// Clear self destruct records
+	recorded_selfdestructs.clear();
+	// Clear call records
+	recorded_calls.clear();
+	// Clear EIP-2929 account access indicator
+	recorded_account_accesses.clear();
+
+	// Mark all precompiled contracts as existing. Existing here means to have a balance (as per EIP-161).
+	// NOTE: keep this in sync with `EVMHost::call` below.
+	//
+	// A lot of precompile addresses had a balance before they became valid addresses for precompiles.
+	// For example all the precompile addresses allocated in Byzantium had a 1 wei balance sent to them
+	// roughly 22 days before the update went live.
+	for (unsigned precompiledAddress = 1; precompiledAddress <= 8; precompiledAddress++)
+	{
+		evmc::address address{precompiledAddress};
+		// 1wei
+		accounts[address].balance = evmc::uint256be{1};
+		// Set according to EIP-1052.
+		if (precompiledAddress < 5 || m_evmVersion >= langutil::EVMVersion::byzantium())
+			accounts[address].codehash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470_bytes32;
+	}
+}
+
+void EVMHost::newTransactionFrame()
+{
+	// Clear EIP-2929 account access indicator
+	recorded_account_accesses.clear();
+
+	for (auto& [address, account]: accounts)
+	{
+		for (auto& [slot, value]: account.storage)
+		{
+			value.access_status = EVMC_ACCESS_COLD; // Clear EIP-2929 storage access indicator
+			value.original = value.current;			// Clear EIP-2200 dirty slot
+		}
+
+		// Clear transient storage according to EIP 1153
+		account.transient_storage.clear();
+	}
+	// Process selfdestruct list
+	for (auto& [address, _]: recorded_selfdestructs)
+		if (m_evmVersion < langutil::EVMVersion::cancun() || newlyCreatedAccounts.count(address))
+			// EIP-6780: If SELFDESTRUCT is executed in a transaction different from the one
+			// in which it was created, we do NOT record it or clear any data.
+			// Otherwise, the previous behavior (pre-Cancun) is maintained.
+			accounts.erase(address);
+	newlyCreatedAccounts.clear();
+	recorded_selfdestructs.clear();
+}
+
+void EVMHost::transfer(evmc::MockedAccount& _sender, evmc::MockedAccount& _recipient, u256 const& _value) noexcept
+{
+	assertThrow(u256(convertFromEVMC(_sender.balance)) >= _value, Exception, "Insufficient balance for transfer");
+	_sender.balance = convertToEVMC(u256(convertFromEVMC(_sender.balance)) - _value);
+	_recipient.balance = convertToEVMC(u256(convertFromEVMC(_recipient.balance)) + _value);
+}
+
+bool EVMHost::selfdestruct(const evmc::address& _addr, const evmc::address& _beneficiary) noexcept
+{
+	// TODO actual selfdestruct is even more complicated.
+
+	// NOTE: EIP-6780: The transfer of the entire account balance to the beneficiary should still happen
+	// after cancun.
+	transfer(accounts[_addr], accounts[_beneficiary], convertFromEVMC(accounts[_addr].balance));
+
+	// Record self destructs. Clearing will be done in newTransactionFrame().
+	return MockedHost::selfdestruct(_addr, _beneficiary);
+}
+
+void EVMHost::recordCalls(evmc_message const& _message) noexcept
+{
+	if (recorded_calls.size() < max_recorded_calls)
+		recorded_calls.emplace_back(_message);
+}
+
+// NOTE: this is used for both internal and external calls.
+// External calls are triggered from ExecutionFramework and contain only EVMC_CREATE or EVMC_CALL.
+evmc::Result EVMHost::call(evmc_message const& _message) noexcept
+{
+	recordCalls(_message);
+	if (_message.recipient == 0x0000000000000000000000000000000000000001_address)
+		return precompileECRecover(_message);
+	else if (_message.recipient == 0x0000000000000000000000000000000000000002_address)
+		return precompileSha256(_message);
+	else if (_message.recipient == 0x0000000000000000000000000000000000000003_address)
+		return precompileRipeMD160(_message);
+	else if (_message.recipient == 0x0000000000000000000000000000000000000004_address)
+		return precompileIdentity(_message);
+	else if (_message.recipient == 0x0000000000000000000000000000000000000005_address && m_evmVersion >= langutil::EVMVersion::byzantium())
+		return precompileModExp(_message);
+	else if (_message.recipient == 0x0000000000000000000000000000000000000006_address && m_evmVersion >= langutil::EVMVersion::byzantium())
+	{
+		if (m_evmVersion <= langutil::EVMVersion::istanbul())
+			return precompileALTBN128G1Add<EVMC_ISTANBUL>(_message);
+		else
+			return precompileALTBN128G1Add<EVMC_LONDON>(_message);
+	}
+	else if (_message.recipient == 0x0000000000000000000000000000000000000007_address && m_evmVersion >= langutil::EVMVersion::byzantium())
+	{
+		if (m_evmVersion <= langutil::EVMVersion::istanbul())
+			return precompileALTBN128G1Mul<EVMC_ISTANBUL>(_message);
+		else
+			return precompileALTBN128G1Mul<EVMC_LONDON>(_message);
+	}
+	else if (_message.recipient == 0x0000000000000000000000000000000000000008_address && m_evmVersion >= langutil::EVMVersion::byzantium())
+	{
+		if (m_evmVersion <= langutil::EVMVersion::istanbul())
+			return precompileALTBN128PairingProduct<EVMC_ISTANBUL>(_message);
+		else
+			return precompileALTBN128PairingProduct<EVMC_LONDON>(_message);
+	}
+	else if (_message.recipient == 0x0000000000000000000000000000000000000009_address && m_evmVersion >= langutil::EVMVersion::istanbul())
+		return precompileBlake2f(_message);
+
+	auto const stateBackup = accounts;
+
+	u256 value{convertFromEVMC(_message.value)};
+	auto& sender = accounts[_message.sender];
+
+	evmc::bytes code;
+
+	evmc_message message = _message;
+	if (message.depth == 0)
+	{
+		message.gas -= message.kind == EVMC_CREATE ? evmasm::GasCosts::txCreateGas : evmasm::GasCosts::txGas;
+		for (size_t i = 0; i < message.input_size; ++i)
+			message.gas -= message.input_data[i] == 0 ? evmasm::GasCosts::txDataZeroGas : evmasm::GasCosts::txDataNonZeroGas(m_evmVersion);
+		if (message.gas < 0)
+		{
+			evmc::Result result;
+			result.status_code = EVMC_OUT_OF_GAS;
+			accounts = stateBackup;
+			return result;
+		}
+	}
+
+	if (message.kind == EVMC_CREATE)
+	{
+		// TODO is the nonce incremented on failure, too?
+		// NOTE: nonce for creation from contracts starts at 1
+		// TODO: check if sender is an EOA and do not pre-increment
+		sender.nonce++;
+
+		auto encodeRlpInteger = [](int value) -> bytes {
+			if (value == 0) {
+				return bytes{128};
+			} else if (value <= 127) {
+				return bytes{static_cast<uint8_t>(value)};
+			} else if (value <= 0xff) {
+				return bytes{128 + 1, static_cast<uint8_t>(value)};
+			} else if (value <= 0xffff) {
+				return bytes{128 + 55 + 2, static_cast<uint8_t>(value >> 8), static_cast<uint8_t>(value)};
+			} else {
+				assertThrow(false, Exception, "Can only encode RLP numbers <= 0xffff");
+			}
+		};
+
+		bytes encodedNonce = encodeRlpInteger(sender.nonce);
+
+		h160 createAddress(keccak256(
+			bytes{static_cast<uint8_t>(0xc0 + 21 + encodedNonce.size())} +
+			bytes{0x94} +
+			bytes(begin(message.sender.bytes), end(message.sender.bytes)) +
+			encodedNonce
+		), h160::AlignRight);
+
+		message.recipient = convertToEVMC(createAddress);
+		assertThrow(accounts.count(message.recipient) == 0, Exception, "Account cannot exist");
+
+		code = evmc::bytes(message.input_data, message.input_data + message.input_size);
+	}
+	else if (message.kind == EVMC_CREATE2)
+	{
+		h160 createAddress(keccak256(
+			bytes{0xff} +
+			bytes(begin(message.sender.bytes), end(message.sender.bytes)) +
+			bytes(begin(message.create2_salt.bytes), end(message.create2_salt.bytes)) +
+			keccak256(bytes(message.input_data, message.input_data + message.input_size)).asBytes()
+		), h160::AlignRight);
+
+		message.recipient = convertToEVMC(createAddress);
+		if (accounts.count(message.recipient) && (
+			accounts[message.recipient].nonce > 0 ||
+			!accounts[message.recipient].code.empty()
+		))
+		{
+			evmc::Result result;
+			result.status_code = EVMC_OUT_OF_GAS;
+			accounts = stateBackup;
+			return result;
+		}
+
+		code = evmc::bytes(message.input_data, message.input_data + message.input_size);
+	}
+	else
+		code = accounts[message.code_address].code;
+
+	auto& destination = accounts[message.recipient];
+	if (message.kind == EVMC_CREATE || message.kind == EVMC_CREATE2)
+		// Mark account as created if it is a CREATE or CREATE2 call
+		newlyCreatedAccounts.emplace(message.recipient);
+
+	if (value != 0 && message.kind != EVMC_DELEGATECALL && message.kind != EVMC_CALLCODE)
+	{
+		if (value > convertFromEVMC(sender.balance))
+		{
+			evmc::Result result;
+			result.status_code = EVMC_INSUFFICIENT_BALANCE;
+			accounts = stateBackup;
+			return result;
+		}
+		transfer(sender, destination, value);
+	}
+
+	// Populate the access access list (enabled since Berlin).
+	// Note, this will also properly touch the created address.
+	// TODO: support a user supplied access list too
+	if (m_evmRevision >= EVMC_BERLIN)
+	{
+		access_account(message.sender);
+		access_account(message.recipient);
+
+		// EIP-3651 rule
+		if (m_evmRevision >= EVMC_SHANGHAI)
+			access_account(tx_context.block_coinbase);
+	}
+
+	if (message.kind == EVMC_CREATE || message.kind == EVMC_CREATE2)
+	{
+		message.input_data = nullptr;
+		message.input_size = 0;
+	}
+	evmc::Result result = m_vm.execute(*this, m_evmRevision, message, code.data(), code.size());
+
+	if (message.kind == EVMC_CREATE || message.kind == EVMC_CREATE2)
+	{
+		result.gas_left -= static_cast<int64_t>(evmasm::GasCosts::createDataGas * result.output_size);
+		if (result.gas_left < 0)
+		{
+			result.gas_left = 0;
+			result.status_code = EVMC_OUT_OF_GAS;
+			// TODO clear some fields?
+		}
+		else
+		{
+			result.create_address = message.recipient;
+			destination.code = evmc::bytes(result.output_data, result.output_data + result.output_size);
+			destination.codehash = convertToEVMC(keccak256({result.output_data, result.output_size}));
+		}
+	}
+
+	if (result.status_code != EVMC_SUCCESS)
+		accounts = stateBackup;
+
+	return result;
+}
+
+evmc::bytes32 EVMHost::get_block_hash(int64_t _number) const noexcept
+{
+	return convertToEVMC(u256("0x3737373737373737373737373737373737373737373737373737373737373737") + _number);
+}
+
+h160 EVMHost::convertFromEVMC(evmc::address const& _addr)
+{
+	return h160(bytes(begin(_addr.bytes), end(_addr.bytes)));
+}
+
+evmc::address EVMHost::convertToEVMC(h160 const& _addr)
+{
+	evmc::address a;
+	for (unsigned i = 0; i < 20; ++i)
+		a.bytes[i] = _addr[i];
+	return a;
+}
+
+h256 EVMHost::convertFromEVMC(evmc::bytes32 const& _data)
+{
+	return h256(bytes(begin(_data.bytes), end(_data.bytes)));
+}
+
+evmc::bytes32 EVMHost::convertToEVMC(h256 const& _data)
+{
+	evmc::bytes32 d;
+	for (unsigned i = 0; i < 32; ++i)
+		d.bytes[i] = _data[i];
+	return d;
+}
+
+evmc::Result EVMHost::precompileECRecover(evmc_message const& _message) noexcept
+{
+	// NOTE this is a partial implementation for some inputs.
+
+	// Fixed cost of 3000 gas.
+	constexpr int64_t gas_cost = 3000;
+
+	static map<bytes, EVMPrecompileOutput> const inputOutput{
+		{
+			fromHex(
+				"18c547e4f7b0f325ad1e56f57e26c745b09a3e503d86e00e5255ff7f715d3d1c"
+				"000000000000000000000000000000000000000000000000000000000000001c"
+				"73b1693892219d736caba55bdb67216e485557ea6b6af75f37096c9aa6a5a75f"
+				"eeb940b1d03b21e36b0e47e79769f095fe2ab855bd91e3a38756b7d75a9c4549"
+			),
+			{
+				fromHex("000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"
+				"000000000000000000000000000000000000000000000000000000000000001c"
+				"debaaa0cddb321b2dcaaf846d39605de7b97e77ba6106587855b9106cb104215"
+				"61a22d94fa8b8a687ff9c911c844d1c016d1a685a9166858f9c7c1bc85128aca"
+			),
+			{
+				fromHex("0000000000000000000000008743523d96a1b2cbe0c6909653a56da18ed484af"),
+				gas_cost
+			}
+		}
+	};
+	evmc::Result result = precompileGeneric(_message, inputOutput);
+	// ECRecover will return success with empty response in case of failure
+	if (result.status_code != EVMC_SUCCESS && result.status_code != EVMC_OUT_OF_GAS)
+		return resultWithGas(_message.gas, gas_cost, {});
+	return result;
+}
+
+evmc::Result EVMHost::precompileSha256(evmc_message const& _message) noexcept
+{
+	// static data so that we do not need a release routine...
+	bytes static hash;
+	hash = picosha2::hash256(bytes(
+		_message.input_data,
+		_message.input_data + _message.input_size
+	));
+
+	// Base 60 gas + 12 gas / word.
+	int64_t gas_cost = 60 + 12 * ((static_cast<int64_t>(_message.input_size) + 31) / 32);
+
+	return resultWithGas(_message.gas, gas_cost, hash);
+}
+
+evmc::Result EVMHost::precompileRipeMD160(evmc_message const& _message) noexcept
+{
+	// NOTE this is a partial implementation for some inputs.
+
+	// Base 600 gas + 120 gas / word.
+	constexpr auto calc_cost = [](int64_t size) -> int64_t {
+		return 600 + 120 * ((size + 31) / 32);
+	};
+
+	static map<bytes, EVMPrecompileOutput> const inputOutput{
+		{
+			bytes{},
+			{
+				fromHex("0000000000000000000000009c1185a5c5e9fc54612808977ee8f548b2258d31"),
+				calc_cost(0)
+			}
+		},
+		{
+			fromHex("0000000000000000000000000000000000000000000000000000000000000004"),
+			{
+				fromHex("0000000000000000000000001b0f3c404d12075c68c938f9f60ebea4f74941a0"),
+				calc_cost(32)
+			}
+		},
+		{
+			fromHex("0000000000000000000000000000000000000000000000000000000000000005"),
+			{
+				fromHex("000000000000000000000000ee54aa84fc32d8fed5a5fe160442ae84626829d9"),
+				calc_cost(32)
+			}
+		},
+		{
+			fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+			{
+				fromHex("0000000000000000000000001cf4e77f5966e13e109703cd8a0df7ceda7f3dc3"),
+				calc_cost(32)
+			}
+		},
+		{
+			fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("000000000000000000000000f93175303eba2a7b372174fc9330237f5ad202fc"),
+				calc_cost(32)
+			}
+		},
+		{
+			fromHex(
+				"0800000000000000000000000000000000000000000000000000000000000000"
+				"0401000000000000000000000000000000000000000000000000000000000000"
+				"0000000400000000000000000000000000000000000000000000000000000000"
+				"00000100"
+			),
+			{
+				fromHex("000000000000000000000000f93175303eba2a7b372174fc9330237f5ad202fc"),
+				calc_cost(100)
+			}
+		},
+		{
+			fromHex(
+				"0800000000000000000000000000000000000000000000000000000000000000"
+				"0501000000000000000000000000000000000000000000000000000000000000"
+				"0000000500000000000000000000000000000000000000000000000000000000"
+				"00000100"
+			),
+			{
+				fromHex("0000000000000000000000004f4fc112e2bfbe0d38f896a46629e08e2fcfad5"),
+				calc_cost(100)
+			}
+		},
+		{
+			fromHex(
+				"08ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+				"ff010000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+				"ffffffff00000000000000000000000000000000000000000000000000000000"
+				"00000100"
+			),
+			{
+				fromHex("000000000000000000000000c0a2e4b1f3ff766a9a0089e7a410391730872495"),
+				calc_cost(100)
+			}
+		},
+		{
+			fromHex(
+				"6162636465666768696a6b6c6d6e6f707172737475767778797a414243444546"
+				"4748494a4b4c4d4e4f505152535455565758595a303132333435363738393f21"
+			),
+			{
+				fromHex("00000000000000000000000036c6b90a49e17d4c1e1b0e634ec74124d9b207da"),
+				calc_cost(64)
+			}
+		},
+		{
+			fromHex("6162636465666768696a6b6c6d6e6f707172737475767778797a414243444546"),
+			{
+				fromHex("000000000000000000000000ac5ab22e07b0fb80c69b6207902f725e2507e546"),
+				calc_cost(32)
+			}
+		}
+	};
+	return precompileGeneric(_message, inputOutput);
+}
+
+evmc::Result EVMHost::precompileIdentity(evmc_message const& _message) noexcept
+{
+	// static data so that we do not need a release routine...
+	bytes static data;
+	data = bytes(_message.input_data, _message.input_data + _message.input_size);
+
+	// Base 15 gas + 3 gas / word.
+	int64_t gas_cost = 15 + 3 * ((static_cast<int64_t>(_message.input_size) + 31) / 32);
+
+	return resultWithGas(_message.gas, gas_cost, data);
+}
+
+evmc::Result EVMHost::precompileModExp(evmc_message const&) noexcept
+{
+	// TODO implement
+	return resultWithFailure();
+}
+
+template <evmc_revision Revision>
+evmc::Result EVMHost::precompileALTBN128G1Add(evmc_message const& _message) noexcept
+{
+	// NOTE this is a partial implementation for some inputs.
+
+	// Fixed 500 or 150 gas.
+	int64_t gas_cost = (Revision < EVMC_ISTANBUL) ? 500 : 150;
+
+	static map<bytes, EVMPrecompileOutput> const inputOutput{
+		{
+			fromHex(
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"1385281136ff5b2c326807ff0a824b6ca4f21fcc7c8764e9801bc4ad497d5012"
+				"02254594be8473dcf018a2aa66ea301e38fc865823acf75a9901721d1fc6bf4c"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"1385281136ff5b2c326807ff0a824b6ca4f21fcc7c8764e9801bc4ad497d5012"
+					"02254594be8473dcf018a2aa66ea301e38fc865823acf75a9901721d1fc6bf4c"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"0000000000000000000000000000000000000000000000000000000000000002"
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"0000000000000000000000000000000000000000000000000000000000000002"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"030644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd3"
+					"15ed738c0e0a7c92e7845f96b2ae9c0a68a6a449e3538fc7ff3ebf7a5a18a2c4"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"0000000000000000000000000000000000000000000000000000000000000002"
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd45"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"0000000000000000000000000000000000000000000000000000000000000000"
+					"0000000000000000000000000000000000000000000000000000000000000000"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"10b4876441e14a6be92a7fe66550848c01c676a12ac31d7cc13b21f49c4307c8"
+				"09f5528bdb0ef9354837a0f4b4c9da973bd5b805d359976f719ab0b74e0a7368"
+				"28d3c57516712e7843a5b3cfa7d7274a037943f5bd57c227620ad207728e4283"
+				"2795fa9df21d4b8b329a45bae120f1fd9df9049ecacaa9dd1eca18bc6a55cd2f"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"16aed5ed486df6b2fb38015ded41400009ed4f34bef65b87b1f90f47052f8d94"
+					"16dabf21b3f25b9665269d98dc17b1da6118251dc0b403ae50e96dfe91239375"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"1385281136ff5b2c326807ff0a824b6ca4f21fcc7c8764e9801bc4ad497d5012"
+				"02254594be8473dcf018a2aa66ea301e38fc865823acf75a9901721d1fc6bf4c"
+				"1644e84fef7b7fdc98254f0654580173307a3bc44db990581e7ab55a22446dcf"
+				"28c2916b7e875692b195831945805438fcd30d2693d8a80cf8c88ec6ef4c315d"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"1e018816fc9bbd91313301ae9c254bb7d64d6cd54f3b49b92925e43e256b5faa"
+					"1d1f2259c715327bedb42c095af6c0267e4e1be836b4e04b3f0502552f93cca9"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"16aed5ed486df6b2fb38015ded41400009ed4f34bef65b87b1f90f47052f8d94"
+				"16dabf21b3f25b9665269d98dc17b1da6118251dc0b403ae50e96dfe91239375"
+				"25ff95a3abccf32adc6a4c3c8caddca67723d8ada802e9b9f612e3ddb40b2005"
+				"0d82b09bb4ec927bbf182bdc402790429322b7e2f285f2aad8ea135cbf7143d8"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"29d160febeef9770d47a32ee3b763850eb0594844fa57dd31b8ed02c78fdb797"
+					"2c7cdf62c2498486fd52646e577a06723ce97737b3c958262d78c4a413661e8a"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"18014701594179c6b9ccae848e3d15c1f76f8a68b8092578296520e46c9bae0c"
+				"1b5ed0e9e8f3ff35589ea81a45cf63887d4a92c099a3be1d97b26f0db96323dd"
+				"16a1d378d1a98cf5383cdc512011234287ca43b6a078d1842d5c58c5b1f475cc"
+				"1309377a7026d08ca1529eab74381a7e0d3a4b79d80bacec207cd52fc8e3769c"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"2583ed10e418133e44619c336f1be5ddae9e20d634a7683d9661401c750d7df4"
+					"0185fbba22de9e698262925665735dbc4d6e8288bc3fc39fae10ca58e16e77f7"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"1c76476f4def4bb94541d57ebba1193381ffa7aa76ada664dd31c16024c43f59"
+				"3034dd2920f673e204fee2811c678745fc819b55d3e9d294e45c9b03a76aef41"
+				"0f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd2"
+				"16da2f5cb6be7a0aa72c440c53c9bbdfec6c36c7d515536431b3a865468acbba"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"1496064626ba8bffeb7805f0d16143a65649bb0850333ea512c03fcdaf31e254"
+					"07b4f210ab542533f1ee5633ae4406cd16c63494b537ce3f1cf4afff6f76a48f"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"1e018816fc9bbd91313301ae9c254bb7d64d6cd54f3b49b92925e43e256b5faa"
+				"1d1f2259c715327bedb42c095af6c0267e4e1be836b4e04b3f0502552f93cca9"
+				"2364294faf6b89fedeede9986aa777c4f6c2f5c4a4559ee93dfec9b7b94ef80b"
+				"05aeae62655ea23865ae6661ae371a55c12098703d0f2301f4223e708c92efc6"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"2801b21090cbc48409e352647f3857134d373f81741f9d5e3d432f336d76f517"
+					"13cf106acf943c2a331de21c7d5e3351354e7412f2dba2918483a6593a6828d4"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"2583ed10e418133e44619c336f1be5ddae9e20d634a7683d9661401c750d7df4"
+				"0185fbba22de9e698262925665735dbc4d6e8288bc3fc39fae10ca58e16e77f7"
+				"258f1faa356e470cca19c928afa5ceed6215c756912af5725b8db5777cc8f3b6"
+				"175ced8a58d0c132c2b95ba14c16dde93e7f7789214116ff69da6f44daa966e6"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"10b4876441e14a6be92a7fe66550848c01c676a12ac31d7cc13b21f49c4307c8"
+					"09f5528bdb0ef9354837a0f4b4c9da973bd5b805d359976f719ab0b74e0a7368"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"26dcfbc2e0bc9d82efb4acd73cb3e99730e27e10177fcfb78b6399a4bfcdf391"
+				"27c440dbd5053253a3a692f9bf89b9b6e9612127cf97db1e11ffa9679acc933b"
+				"1496064626ba8bffeb7805f0d16143a65649bb0850333ea512c03fcdaf31e254"
+				"07b4f210ab542533f1ee5633ae4406cd16c63494b537ce3f1cf4afff6f76a48f"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"186bac5188a98c45e6016873d107f5cd131f3a3e339d0375e58bd6219347b008"
+					"1e396bc242de0214898b0f68035f53ad5a6f96c6c8390ac56ed6ec9561d23159"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"26dcfbc2e0bc9d82efb4acd73cb3e99730e27e10177fcfb78b6399a4bfcdf391"
+				"27c440dbd5053253a3a692f9bf89b9b6e9612127cf97db1e11ffa9679acc933b"
+				"1c76476f4def4bb94541d57ebba1193381ffa7aa76ada664dd31c16024c43f59"
+				"3034dd2920f673e204fee2811c678745fc819b55d3e9d294e45c9b03a76aef41"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"20a754d2071d4d53903e3b31a7e98ad6882d58aec240ef981fdf0a9d22c5926a"
+					"29c853fcea789887315916bbeb89ca37edb355b4f980c9a12a94f30deeed3021"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"27231d5cdd0011259ff75678cf5a8f7840c22cb71d52b25e21e071205e8d9bc4"
+				"26dd3d225c9a71476db0cf834232eba84020f3073c6d20c519963e0b98f235e1"
+				"2174f0221490cd9c15b0387f3251ec3d49517a51c37a8076eac12afb4a95a707"
+				"1d1c3fcd3161e2a417b4df0955f02db1fffa9005210fb30c5aa3755307e9d1f5"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"18014701594179c6b9ccae848e3d15c1f76f8a68b8092578296520e46c9bae0c"
+					"1b5ed0e9e8f3ff35589ea81a45cf63887d4a92c099a3be1d97b26f0db96323dd"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"2801b21090cbc48409e352647f3857134d373f81741f9d5e3d432f336d76f517"
+				"13cf106acf943c2a331de21c7d5e3351354e7412f2dba2918483a6593a6828d4"
+				"2a49621e12910cd90f3e731083d454255bf1c533d6e15b8699156778d0f27f5d"
+				"2590ee31824548d159aa2d22296bf149d564c0872f41b89b7dc5c6e6e3cd1c4d"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"27231d5cdd0011259ff75678cf5a8f7840c22cb71d52b25e21e071205e8d9bc4"
+					"26dd3d225c9a71476db0cf834232eba84020f3073c6d20c519963e0b98f235e1"
+				),
+				gas_cost
+			}
+		},
+		{
+			fromHex(
+				"29d160febeef9770d47a32ee3b763850eb0594844fa57dd31b8ed02c78fdb797"
+				"2c7cdf62c2498486fd52646e577a06723ce97737b3c958262d78c4a413661e8a"
+				"0aee46a7ea6e80a3675026dfa84019deee2a2dedb1bbe11d7fe124cb3efb4b5a"
+				"044747b6e9176e13ede3a4dfd0d33ccca6321b9acd23bf3683a60adc0366ebaf"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+				"0000000000000000000000000000000000000000000000000000000000000000"
+			),
+			{
+				fromHex(
+					"26dcfbc2e0bc9d82efb4acd73cb3e99730e27e10177fcfb78b6399a4bfcdf391"
+					"27c440dbd5053253a3a692f9bf89b9b6e9612127cf97db1e11ffa9679acc933b"
+				),
+				gas_cost
+			}
+		}
+	};
+	return precompileGeneric(_message, inputOutput);
+}
+
+template <evmc_revision Revision>
+evmc::Result EVMHost::precompileALTBN128G1Mul(evmc_message const& _message) noexcept
+{
+	// NOTE this is a partial implementation for some inputs.
+
+	// Fixed 40000 or 6000 gas.
+	int64_t gas_cost = (Revision < EVMC_ISTANBUL) ? 40000 : 6000;
+
+	static map<bytes, EVMPrecompileOutput> const inputOutput{
+		{
+			fromHex("0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("030644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd315ed738c0e0a7c92e7845f96b2ae9c0a68a6a449e3538fc7ff3ebf7a5a18a2c4"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("17c139df0efee0f766bc0204762b774362e4ded88953a39ce849a8a7fa163fa901e0559bacb160664764a357af8a9fe70baa9258e0b959273ffc5718c6d4cc7c"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("09b54f111d3b2d1b2fe1ae9669b3db3d7bf93b70f00647e65c849275de6dc7fe18b2e77c63a3e400d6d1f1fbc6e1a1167bbca603d34d03edea231eb0ab7b14b4030f7b0c405c888aff922307ea2cd1c70f64664bab76899500341f4260a209290000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("16a1d378d1a98cf5383cdc512011234287ca43b6a078d1842d5c58c5b1f475cc1309377a7026d08ca1529eab74381a7e0d3a4b79d80bacec207cd52fc8e3769c"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("0a6de0e2240aa253f46ce0da883b61976e3588146e01c9d8976548c145fe6e4a04fbaa3a4aed4bb77f30ebb07a3ec1c7d77a7f2edd75636babfeff97b1ea686e1551dcd4965285ef049512d2d30cbfc1a91acd5baad4a6e19e22e93176197f170000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("28d3c57516712e7843a5b3cfa7d7274a037943f5bd57c227620ad207728e42832795fa9df21d4b8b329a45bae120f1fd9df9049ecacaa9dd1eca18bc6a55cd2f"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("0c54b42137b67cc268cbb53ac62b00ecead23984092b494a88befe58445a244a18e3723d37fae9262d58b548a0575f59d9c3266db7afb4d5739555837f6b8b3e0c692b41f1acc961f6ea83bae2c3a1a55c54f766c63ba76989f52c149c17b5e70000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("258f1faa356e470cca19c928afa5ceed6215c756912af5725b8db5777cc8f3b6175ced8a58d0c132c2b95ba14c16dde93e7f7789214116ff69da6f44daa966e6"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("0f103f14a584d4203c27c26155b2c955f8dfa816980b24ba824e1972d6486a5d0c4165133b9f5be17c804203af781bcf168da7386620479f9b885ecbcd27b17b0ea71d0abb524cac7cfff5323e1d0b14ab705842426c978f96753ccce258ed930000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("2a49621e12910cd90f3e731083d454255bf1c533d6e15b8699156778d0f27f5d2590ee31824548d159aa2d22296bf149d564c0872f41b89b7dc5c6e6e3cd1c4d"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("111e2e2a5f8828f80ddad08f9f74db56dac1cc16c1cb278036f79a84cf7a116f1d7d62e192b219b9808faa906c5ced871788f6339e8d91b83ac1343e20a16b3000000000000000000000000000000000000000e40800000000000000008cdcbc0000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("25ff95a3abccf32adc6a4c3c8caddca67723d8ada802e9b9f612e3ddb40b20050d82b09bb4ec927bbf182bdc402790429322b7e2f285f2aad8ea135cbf7143d8"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("17d5d09b4146424bff7e6fb01487c477bbfcd0cdbbc92d5d6457aae0b6717cc502b5636903efbf46db9235bbe74045d21c138897fda32e079040db1a16c1a7a11887420878c0c8e37605291c626585eabbec8d8b97a848fe8d58a37b004583510000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("2364294faf6b89fedeede9986aa777c4f6c2f5c4a4559ee93dfec9b7b94ef80b05aeae62655ea23865ae6661ae371a55c12098703d0f2301f4223e708c92efc6"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("1c36e713d4d54e3a9644dffca1fc524be4868f66572516025a61ca542539d43f042dcc4525b82dfb242b09cb21909d5c22643dcdbe98c4d082cc2877e96b24db016086cc934d5cab679c6991a4efcedbab26d7e4fb23b6a1ad4e6b5c2fb59ce50000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("1644e84fef7b7fdc98254f0654580173307a3bc44db990581e7ab55a22446dcf28c2916b7e875692b195831945805438fcd30d2693d8a80cf8c88ec6ef4c315d"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("1e39e9f0f91fa7ff8047ffd90de08785777fe61c0e3434e728fce4cf35047ddc2e0b64d75ebfa86d7f8f8e08abbe2e7ae6e0a1c0b34d028f19fa56e9450527cb1eec35a0e955cad4bee5846ae0f1d0b742d8636b278450c534e38e06a60509f90000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("1385281136ff5b2c326807ff0a824b6ca4f21fcc7c8764e9801bc4ad497d501202254594be8473dcf018a2aa66ea301e38fc865823acf75a9901721d1fc6bf4c"),
+				gas_cost
+			}
+		},
+		{
+			fromHex("232063b584fb76c8d07995bee3a38fa7565405f3549c6a918ddaa90ab971e7f82ac9b135a81d96425c92d02296322ad56ffb16299633233e4880f95aafa7fda70689c3dc4311426ee11707866b2cbdf9751dacd07245bf99d2113d3f5a8cac470000000000000000000000000000000000000000000000000000000000000000"),
+			{
+				fromHex("2174f0221490cd9c15b0387f3251ec3d49517a51c37a8076eac12afb4a95a7071d1c3fcd3161e2a417b4df0955f02db1fffa9005210fb30c5aa3755307e9d1f5"),
+				gas_cost
+			}
+		}
+	};
+	return precompileGeneric(_message, inputOutput);
+}
+
+template <evmc_revision Revision>
+evmc::Result EVMHost::precompileALTBN128PairingProduct(evmc_message const& _message) noexcept
+{
+	// Base + per pairing gas.
+	constexpr auto calc_cost = [](unsigned points) -> int64_t {
+		// Number of 192-byte points.
+		return (Revision < EVMC_ISTANBUL) ?
+			(100000 + 80000 * points):
+			(45000 + 34000 * points);
+	};
+
+	// NOTE this is a partial implementation for some inputs.
+	static map<bytes, EVMPrecompileOutput> const inputOutput{
+		{
+			fromHex(
+				"17c139df0efee0f766bc0204762b774362e4ded88953a39ce849a8a7fa163fa9"
+				"01e0559bacb160664764a357af8a9fe70baa9258e0b959273ffc5718c6d4cc7c"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd45"
+				"0a09ccf561b55fd99d1c1208dee1162457b57ac5af3759d50671e510e428b2a1"
+				"2e539c423b302d13f4e5773c603948eaf5db5df8ae8a9a9113708390a06410d8"
+				"19b763513924a736e4eebd0d78c91c1bc1d657fee4214057d21414011cfcc763"
+				"2f8d9f9ab83727c77a2fec063cb7b6e5eb23044ccf535ad49d46d394fb6f6bf6"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(2)
+			}
+		},
+		{
+			fromHex(
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"0000000000000000000000000000000000000000000000000000000000000002"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+				"0000000000000000000000000000000000000000000000000000000000000001"
+				"30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd45"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(2)
+			}
+		},
+		{
+			fromHex(
+				"1c76476f4def4bb94541d57ebba1193381ffa7aa76ada664dd31c16024c43f59"
+				"3034dd2920f673e204fee2811c678745fc819b55d3e9d294e45c9b03a76aef41"
+				"209dd15ebff5d46c4bd888e51a93cf99a7329636c63514396b4a452003a35bf7"
+				"04bf11ca01483bfa8b34b43561848d28905960114c8ac04049af4b6315a41678"
+				"2bb8324af6cfc93537a2ad1a445cfd0ca2a71acd7ac41fadbf933c2a51be344d"
+				"120a2a4cf30c1bf9845f20c6fe39e07ea2cce61f0c9bb048165fe5e4de877550"
+				"111e129f1cf1097710d41c4ac70fcdfa5ba2023c6ff1cbeac322de49d1b6df7c"
+				"2032c61a830e3c17286de9462bf242fca2883585b93870a73853face6a6bf411"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(2)
+			}
+		},
+		{
+			fromHex(
+				"2eca0c7238bf16e83e7a1e6c5d49540685ff51380f309842a98561558019fc02"
+				"03d3260361bb8451de5ff5ecd17f010ff22f5c31cdf184e9020b06fa5997db84"
+				"1213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee"
+				"2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f"
+				"21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237"
+				"096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f"
+				"06967a1237ebfeca9aaae0d6d0bab8e28c198c5a339ef8a2407e31cdac516db9"
+				"22160fa257a5fd5b280642ff47b65eca77e626cb685c84fa6d3b6882a283ddd1"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(2)
+			}
+		},
+		{
+			fromHex(
+				"0f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd2"
+				"16da2f5cb6be7a0aa72c440c53c9bbdfec6c36c7d515536431b3a865468acbba"
+				"2e89718ad33c8bed92e210e81d1853435399a271913a6520736a4729cf0d51eb"
+				"01a9e2ffa2e92599b68e44de5bcf354fa2642bd4f26b259daa6f7ce3ed57aeb3"
+				"14a9a87b789a58af499b314e13c3d65bede56c07ea2d418d6874857b70763713"
+				"178fb49a2d6cd347dc58973ff49613a20757d0fcc22079f9abd10c3baee24590"
+				"1b9e027bd5cfc2cb5db82d4dc9677ac795ec500ecd47deee3b5da006d6d049b8"
+				"11d7511c78158de484232fc68daf8a45cf217d1c2fae693ff5871e8752d73b21"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(2)
+			}
+		},
+		{
+			fromHex(
+				"2f2ea0b3da1e8ef11914acf8b2e1b32d99df51f5f4f206fc6b947eae860eddb6"
+				"068134ddb33dc888ef446b648d72338684d678d2eb2371c61a50734d78da4b72"
+				"25f83c8b6ab9de74e7da488ef02645c5a16a6652c3c71a15dc37fe3a5dcb7cb1"
+				"22acdedd6308e3bb230d226d16a105295f523a8a02bfc5e8bd2da135ac4c245d"
+				"065bbad92e7c4e31bf3757f1fe7362a63fbfee50e7dc68da116e67d600d9bf68"
+				"06d302580dc0661002994e7cd3a7f224e7ddc27802777486bf80f40e4ca3cfdb"
+				"186bac5188a98c45e6016873d107f5cd131f3a3e339d0375e58bd6219347b008"
+				"122ae2b09e539e152ec5364e7e2204b03d11d3caa038bfc7cd499f8176aacbee"
+				"1f39e4e4afc4bc74790a4a028aff2c3d2538731fb755edefd8cb48d6ea589b5e"
+				"283f150794b6736f670d6a1033f9b46c6f5204f50813eb85c8dc4b59db1c5d39"
+				"140d97ee4d2b36d99bc49974d18ecca3e7ad51011956051b464d9e27d46cc25e"
+				"0764bb98575bd466d32db7b15f582b2d5c452b36aa394b789366e5e3ca5aabd4"
+				"15794ab061441e51d01e94640b7e3084a07e02c78cf3103c542bc5b298669f21"
+				"1b88da1679b0b64a63b7e0e7bfe52aae524f73a55be7fe70c7e9bfc94b4cf0da"
+				"1213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee"
+				"2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f"
+				"21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237"
+				"096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(3)
+			}
+		},
+		{
+			fromHex(
+				"20a754d2071d4d53903e3b31a7e98ad6882d58aec240ef981fdf0a9d22c5926a"
+				"29c853fcea789887315916bbeb89ca37edb355b4f980c9a12a94f30deeed3021"
+				"1213d2149b006137fcfb23036606f848d638d576a120ca981b5b1a5f9300b3ee"
+				"2276cf730cf493cd95d64677bbb75fc42db72513a4c1e387b476d056f80aa75f"
+				"21ee6226d31426322afcda621464d0611d226783262e21bb3bc86b537e986237"
+				"096df1f82dff337dd5972e32a8ad43e28a78a96a823ef1cd4debe12b6552ea5f"
+				"1abb4a25eb9379ae96c84fff9f0540abcfc0a0d11aeda02d4f37e4baf74cb0c1"
+				"1073b3ff2cdbb38755f8691ea59e9606696b3ff278acfc098fa8226470d03869"
+				"217cee0a9ad79a4493b5253e2e4e3a39fc2df38419f230d341f60cb064a0ac29"
+				"0a3d76f140db8418ba512272381446eb73958670f00cf46f1d9e64cba057b53c"
+				"26f64a8ec70387a13e41430ed3ee4a7db2059cc5fc13c067194bcc0cb49a9855"
+				"2fd72bd9edb657346127da132e5b82ab908f5816c826acb499e22f2412d1a2d7"
+				"0f25929bcb43d5a57391564615c9e70a992b10eafa4db109709649cf48c50dd2"
+				"198a1f162a73261f112401aa2db79c7dab1533c9935c77290a6ce3b191f2318d"
+				"198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2"
+				"1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed"
+				"090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b"
+				"12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa"
+			),
+			{
+				fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+				calc_cost(3)
+			}
+		}
+	};
+	return precompileGeneric(_message, inputOutput);
+}
+
+evmc::Result EVMHost::precompileBlake2f(evmc_message const&) noexcept
+{
+	// TODO implement
+	return resultWithFailure();
+}
+
+evmc::Result EVMHost::precompileGeneric(
+	evmc_message const& _message,
+	map<bytes, EVMPrecompileOutput> const& _inOut) noexcept
+{
+	bytes input(_message.input_data, _message.input_data + _message.input_size);
+	if (_inOut.count(input))
+	{
+		auto const& ret = _inOut.at(input);
+		return resultWithGas(_message.gas, ret.gas_used, ret.output);
+	}
+	else
+		return resultWithFailure();
+}
+
+evmc::Result EVMHost::resultWithFailure() noexcept
+{
+	evmc::Result result;
+	result.status_code = EVMC_FAILURE;
+	return result;
+}
+
+evmc::Result EVMHost::resultWithGas(
+	int64_t gas_limit,
+	int64_t gas_required,
+	bytes const& _data
+) noexcept
+{
+	evmc::Result result;
+	if (gas_limit < gas_required)
+	{
+		result.status_code = EVMC_OUT_OF_GAS;
+		result.gas_left = 0;
+	}
+	else
+	{
+		result.status_code = EVMC_SUCCESS;
+		result.gas_left = gas_limit - gas_required;
+	}
+	result.output_data = _data.empty() ? nullptr : _data.data();
+	result.output_size = _data.size();
+	return result;
+}
+
+StorageMap const& EVMHost::get_address_storage(evmc::address const& _addr)
+{
+	assertThrow(account_exists(_addr), Exception, "Account does not exist.");
+	return accounts[_addr].storage;
+}
+
+string EVMHostPrinter::state()
+{
+	// Print state and execution trace.
+	if (m_host.account_exists(m_account))
+	{
+		storage();
+		balance();
+	}
+	else
+		selfdestructRecords();
+
+	callRecords();
+	return m_stateStream.str();
+}
+
+void EVMHostPrinter::storage()
+{
+	for (auto const& [slot, value]: m_host.get_address_storage(m_account))
+		if (m_host.get_storage(m_account, slot))
+			m_stateStream << "  "
+				<< m_host.convertFromEVMC(slot)
+				<< ": "
+				<< m_host.convertFromEVMC(value.current)
+				<< endl;
+}
+
+void EVMHostPrinter::balance()
+{
+	m_stateStream << "BALANCE "
+		<< m_host.convertFromEVMC(m_host.get_balance(m_account))
+		<< endl;
+}
+
+void EVMHostPrinter::selfdestructRecords()
+{
+	for (auto const& record: m_host.recorded_selfdestructs)
+		for (auto const& beneficiary: record.second)
+			m_stateStream << "SELFDESTRUCT"
+				<< " BENEFICIARY "
+				<< m_host.convertFromEVMC(beneficiary)
+				<< endl;
+}
+
+void EVMHostPrinter::callRecords()
+{
+	static auto constexpr callKind = [](evmc_call_kind _kind) -> string
+	{
+		switch (_kind)
+		{
+			case evmc_call_kind::EVMC_CALL:
+				return "CALL";
+			case evmc_call_kind::EVMC_DELEGATECALL:
+				return "DELEGATECALL";
+			case evmc_call_kind::EVMC_CALLCODE:
+				return "CALLCODE";
+			case evmc_call_kind::EVMC_CREATE:
+				return "CREATE";
+			case evmc_call_kind::EVMC_CREATE2:
+				return "CREATE2";
+			default:
+				assertThrow(false, Exception, "Invalid call kind.");
+		}
+	};
+
+	for (auto const& record: m_host.recorded_calls)
+		m_stateStream << callKind(record.kind)
+			<< " VALUE "
+			<< m_host.convertFromEVMC(record.value)
+			<< endl;
+}
diff --git a/compiler/test/EVMHost.h b/compiler/test/EVMHost.h
new file mode 100644
index 00000000..144596e0
--- /dev/null
+++ b/compiler/test/EVMHost.h
@@ -0,0 +1,167 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * EVM execution host, i.e. component that implements a simulated Ethereum blockchain
+ * for testing purposes.
+ */
+
+#pragma once
+
+#include <test/evmc/mocked_host.hpp>
+#include <test/evmc/evmc.hpp>
+#include <test/evmc/evmc.h>
+
+#include <liblangutil/EVMVersion.h>
+
+#include <libsolutil/FixedHash.h>
+
+#include <boost/filesystem.hpp>
+
+#include<unordered_set>
+
+namespace solidity::test
+{
+using Address = util::h160;
+using StorageMap = std::map<evmc::bytes32, evmc::StorageValue>;
+
+struct EVMPrecompileOutput {
+	bytes const output;
+	int64_t gas_used;
+};
+
+class EVMHost: public evmc::MockedHost
+{
+public:
+	// Verbatim features of MockedHost.
+	using MockedHost::account_exists;
+	using MockedHost::get_storage;
+	using MockedHost::set_storage;
+	using MockedHost::get_balance;
+	using MockedHost::get_code_size;
+	using MockedHost::get_code_hash;
+	using MockedHost::copy_code;
+	using MockedHost::get_tx_context;
+	using MockedHost::emit_log;
+	using MockedHost::access_account;
+	using MockedHost::access_storage;
+
+	// Modified features of MockedHost.
+	bool selfdestruct(evmc::address const& _addr, evmc::address const& _beneficiary) noexcept final;
+	evmc::Result call(evmc_message const& _message) noexcept final;
+	evmc::bytes32 get_block_hash(int64_t number) const noexcept final;
+
+	// Solidity testing specific features.
+
+	/// Tries to dynamically load an evmc vm supporting evm1 and caches the loaded VM.
+	/// @returns vmc::VM(nullptr) on failure.
+	static evmc::VM& getVM(std::string const& _path = {});
+
+	/// Tries to load all defined evmc vm shared libraries.
+	/// @param _vmPaths paths to multiple evmc shared libraries.
+	/// @throw Exception if multiple evm1 vms where loaded.
+	/// @returns true, if an evmc vm supporting evm1 was loaded properly,
+	static bool checkVmPaths(std::vector<boost::filesystem::path> const& _vmPaths);
+
+	explicit EVMHost(langutil::EVMVersion _evmVersion, evmc::VM& _vm);
+
+	/// Reset entire state (including accounts).
+	void reset();
+
+	/// Start new block.
+	void newBlock()
+	{
+		tx_context.block_number++;
+		tx_context.block_timestamp += 15;
+		recorded_logs.clear();
+		newTransactionFrame();
+	}
+
+	/// @returns contents of storage at @param _addr.
+	StorageMap const& get_address_storage(evmc::address const& _addr);
+
+	static Address convertFromEVMC(evmc::address const& _addr);
+	static evmc::address convertToEVMC(Address const& _addr);
+	static util::h256 convertFromEVMC(evmc::bytes32 const& _data);
+	static evmc::bytes32 convertToEVMC(util::h256 const& _data);
+private:
+	/// Transfer value between accounts. Checks for sufficient balance.
+	void transfer(evmc::MockedAccount& _sender, evmc::MockedAccount& _recipient, u256 const& _value) noexcept;
+
+	/// Start a new transaction frame.
+	/// This will perform selfdestructs, apply storage status changes across all accounts,
+	/// and clear account/storage access indicator for EIP-2929.
+	void newTransactionFrame();
+
+	/// Records calls made via @param _message.
+	void recordCalls(evmc_message const& _message) noexcept;
+
+	static evmc::Result precompileECRecover(evmc_message const& _message) noexcept;
+	static evmc::Result precompileSha256(evmc_message const& _message) noexcept;
+	static evmc::Result precompileRipeMD160(evmc_message const& _message) noexcept;
+	static evmc::Result precompileIdentity(evmc_message const& _message) noexcept;
+	static evmc::Result precompileModExp(evmc_message const& _message) noexcept;
+	template <evmc_revision Revision>
+	static evmc::Result precompileALTBN128G1Add(evmc_message const& _message) noexcept;
+	template <evmc_revision Revision>
+	static evmc::Result precompileALTBN128G1Mul(evmc_message const& _message) noexcept;
+	template <evmc_revision Revision>
+	static evmc::Result precompileALTBN128PairingProduct(evmc_message const& _message) noexcept;
+	static evmc::Result precompileBlake2f(evmc_message const& _message) noexcept;
+	static evmc::Result precompileGeneric(evmc_message const& _message, std::map<bytes, EVMPrecompileOutput> const& _inOut) noexcept;
+	/// @returns a result object with gas usage and result data taken from @a _data.
+	/// The outcome will be a failure if the limit < required.
+	/// @note The return value is only valid as long as @a _data is alive!
+	static evmc::Result resultWithGas(int64_t gas_limit, int64_t gas_required, bytes const& _data) noexcept;
+	static evmc::Result resultWithFailure() noexcept;
+
+	/// Store the accounts that have been created in the current transaction.
+	std::unordered_set<evmc::address> newlyCreatedAccounts;
+
+	evmc::VM& m_vm;
+	/// EVM version requested by the testing tool
+	langutil::EVMVersion m_evmVersion;
+	/// EVM version requested from EVMC (matches the above)
+	evmc_revision m_evmRevision;
+};
+
+class EVMHostPrinter
+{
+public:
+	/// Constructs a host printer object for state at @param _address.
+	explicit EVMHostPrinter(EVMHost& _host, evmc::address _address):
+		m_host(_host),
+		m_account(_address)
+	{}
+	/// @returns state at account maintained by host.
+	std::string state();
+private:
+	/// Outputs storage at account to stateStream.
+	void storage();
+	/// Outputs call records for account to stateStream.
+	void callRecords();
+	/// Outputs balance of account to stateStream.
+	void balance();
+	/// Outputs self-destruct record for account to stateStream.
+	void selfdestructRecords();
+
+	std::ostringstream m_stateStream;
+	EVMHost& m_host;
+	evmc::address m_account;
+};
+
+}
diff --git a/compiler/test/ExecutionFramework.cpp b/compiler/test/ExecutionFramework.cpp
new file mode 100644
index 00000000..a18a73de
--- /dev/null
+++ b/compiler/test/ExecutionFramework.cpp
@@ -0,0 +1,307 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2016
+ * Framework for executing contracts and testing them using RPC.
+ */
+
+#include <test/ExecutionFramework.h>
+
+#include <test/EVMHost.h>
+
+#include <test/evmc/evmc.hpp>
+
+#include <test/libsolidity/util/SoltestTypes.h>
+
+#include <libsolutil/CommonIO.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <boost/test/framework.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <range/v3/range.hpp>
+#include <range/v3/view/transform.hpp>
+
+#include <cstdlib>
+#include <limits>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::test;
+using namespace solidity::frontend::test;
+
+ExecutionFramework::ExecutionFramework():
+	ExecutionFramework(solidity::test::CommonOptions::get().evmVersion(), solidity::test::CommonOptions::get().vmPaths)
+{
+}
+
+ExecutionFramework::ExecutionFramework(langutil::EVMVersion _evmVersion, vector<boost::filesystem::path> const& _vmPaths):
+	m_evmVersion(_evmVersion),
+	m_optimiserSettings(solidity::frontend::OptimiserSettings::minimal()),
+	m_showMessages(solidity::test::CommonOptions::get().showMessages),
+	m_vmPaths(_vmPaths)
+{
+	if (solidity::test::CommonOptions::get().optimize)
+		m_optimiserSettings = solidity::frontend::OptimiserSettings::standard();
+	selectVM(evmc_capabilities::EVMC_CAPABILITY_EVM1);
+}
+
+void ExecutionFramework::selectVM(evmc_capabilities _cap)
+{
+	m_evmcHost.reset();
+	for (auto const& path: m_vmPaths)
+	{
+		evmc::VM& vm = EVMHost::getVM(path.string());
+		if (vm.has_capability(_cap))
+		{
+			m_evmcHost = make_unique<EVMHost>(m_evmVersion, vm);
+			break;
+		}
+	}
+	solAssert(m_evmcHost != nullptr, "");
+	reset();
+}
+
+void ExecutionFramework::reset()
+{
+	m_evmcHost->reset();
+	for (size_t i = 0; i < 10; i++)
+		m_evmcHost->accounts[EVMHost::convertToEVMC(account(i))].balance =
+			EVMHost::convertToEVMC(u256(1) << 100);
+}
+
+std::pair<bool, string> ExecutionFramework::compareAndCreateMessage(
+	bytes const& _result,
+	bytes const& _expectation
+)
+{
+	if (_result == _expectation)
+		return std::make_pair(true, std::string{});
+	std::string message =
+			"Invalid encoded data\n"
+			"   Result                                                           Expectation\n";
+	auto resultHex = boost::replace_all_copy(util::toHex(_result), "0", ".");
+	auto expectedHex = boost::replace_all_copy(util::toHex(_expectation), "0", ".");
+	for (size_t i = 0; i < std::max(resultHex.size(), expectedHex.size()); i += 0x40)
+	{
+		std::string result{i >= resultHex.size() ? string{} : resultHex.substr(i, 0x40)};
+		std::string expected{i > expectedHex.size() ? string{} : expectedHex.substr(i, 0x40)};
+		message +=
+			(result == expected ? "   " : " X ") +
+			result +
+			std::string(0x41 - result.size(), ' ') +
+			expected +
+			"\n";
+	}
+	return make_pair(false, message);
+}
+
+bytes ExecutionFramework::panicData(util::PanicCode _code)
+{
+	return
+		m_evmVersion.supportsReturndata() ?
+		toCompactBigEndian(selectorFromSignatureU32("Panic(uint256)"), 4) + encode(u256(static_cast<unsigned>(_code))) :
+		bytes();
+}
+
+u256 ExecutionFramework::gasLimit() const
+{
+	return {m_evmcHost->tx_context.block_gas_limit};
+}
+
+u256 ExecutionFramework::gasPrice() const
+{
+	// here and below we use "return u256{....}" instead of just "return {....}"
+	// to please MSVC and avoid unexpected
+	// warning C4927 : illegal conversion; more than one user - defined conversion has been implicitly applied
+	return u256{EVMHost::convertFromEVMC(m_evmcHost->tx_context.tx_gas_price)};
+}
+
+u256 ExecutionFramework::blockHash(u256 const& _number) const
+{
+	return u256{EVMHost::convertFromEVMC(
+		m_evmcHost->get_block_hash(static_cast<int64_t>(_number & numeric_limits<uint64_t>::max()))
+	)};
+}
+
+u256 ExecutionFramework::blockNumber() const
+{
+	return m_evmcHost->tx_context.block_number;
+}
+
+void ExecutionFramework::sendMessage(bytes const& _data, bool _isCreation, u256 const& _value)
+{
+	m_evmcHost->newBlock();
+
+	if (m_showMessages)
+	{
+		if (_isCreation)
+			cout << "CREATE " << m_sender.hex() << ":" << endl;
+		else
+			cout << "CALL   " << m_sender.hex() << " -> " << m_contractAddress.hex() << ":" << endl;
+		if (_value > 0)
+			cout << " value: " << _value << endl;
+		cout << " in:      " << util::toHex(_data) << endl;
+	}
+	evmc_message message{};
+	message.input_data = _data.data();
+	message.input_size = _data.size();
+	message.sender = EVMHost::convertToEVMC(m_sender);
+	message.value = EVMHost::convertToEVMC(_value);
+
+	if (_isCreation)
+	{
+		message.kind = EVMC_CREATE;
+		message.recipient = {};
+		message.code_address = {};
+	}
+	else
+	{
+		message.kind = EVMC_CALL;
+		message.recipient = EVMHost::convertToEVMC(m_contractAddress);
+		message.code_address = message.recipient;
+	}
+
+	message.gas = InitialGas.convert_to<int64_t>();
+
+	evmc::Result result = m_evmcHost->call(message);
+
+	m_output = bytes(result.output_data, result.output_data + result.output_size);
+	if (_isCreation)
+		m_contractAddress = EVMHost::convertFromEVMC(result.create_address);
+
+	unsigned const refundRatio = (m_evmVersion >= langutil::EVMVersion::london() ? 5 : 2);
+	auto const totalGasUsed = InitialGas - result.gas_left;
+	auto const gasRefund = min(u256(result.gas_refund), totalGasUsed / refundRatio);
+
+	m_gasUsed = totalGasUsed - gasRefund;
+	m_transactionSuccessful = (result.status_code == EVMC_SUCCESS);
+
+	if (m_showMessages)
+	{
+		cout << " out:                       " << util::toHex(m_output) << endl;
+		cout << " result:                    " << static_cast<size_t>(result.status_code) << endl;
+		cout << " gas used:                  " << m_gasUsed.str() << endl;
+		cout << " gas used (without refund): " << totalGasUsed.str() << endl;
+		cout << " gas refund (total):        " << result.gas_refund << endl;
+		cout << " gas refund (bound):        " << gasRefund.str() << endl;
+	}
+}
+
+void ExecutionFramework::sendEther(h160 const& _addr, u256 const& _amount)
+{
+	m_evmcHost->newBlock();
+
+	if (m_showMessages)
+	{
+		cout << "SEND_ETHER   " << m_sender.hex() << " -> " << _addr.hex() << ":" << endl;
+		if (_amount > 0)
+			cout << " value: " << _amount << endl;
+	}
+	evmc_message message{};
+	message.sender = EVMHost::convertToEVMC(m_sender);
+	message.value = EVMHost::convertToEVMC(_amount);
+	message.kind = EVMC_CALL;
+	message.recipient = EVMHost::convertToEVMC(_addr);
+	message.code_address = message.recipient;
+	message.gas = InitialGas.convert_to<int64_t>();
+
+	m_evmcHost->call(message);
+}
+
+size_t ExecutionFramework::currentTimestamp()
+{
+	return static_cast<size_t>(m_evmcHost->tx_context.block_timestamp);
+}
+
+size_t ExecutionFramework::blockTimestamp(u256 _block)
+{
+	if (_block > blockNumber())
+		return 0;
+	else
+		return static_cast<size_t>((currentTimestamp() / blockNumber()) * _block);
+}
+
+h160 ExecutionFramework::account(size_t _idx)
+{
+	return h160(h256(u256{"0x1212121212121212121212121212120000000012"} + _idx * 0x1000), h160::AlignRight);
+}
+
+bool ExecutionFramework::addressHasCode(h160 const& _addr) const
+{
+	return m_evmcHost->get_code_size(EVMHost::convertToEVMC(_addr)) != 0;
+}
+
+size_t ExecutionFramework::numLogs() const
+{
+	return m_evmcHost->recorded_logs.size();
+}
+
+size_t ExecutionFramework::numLogTopics(size_t _logIdx) const
+{
+	return m_evmcHost->recorded_logs.at(_logIdx).topics.size();
+}
+
+h256 ExecutionFramework::logTopic(size_t _logIdx, size_t _topicIdx) const
+{
+	return EVMHost::convertFromEVMC(m_evmcHost->recorded_logs.at(_logIdx).topics.at(_topicIdx));
+}
+
+h160 ExecutionFramework::logAddress(size_t _logIdx) const
+{
+	return EVMHost::convertFromEVMC(m_evmcHost->recorded_logs.at(_logIdx).creator);
+}
+
+bytes ExecutionFramework::logData(size_t _logIdx) const
+{
+	auto const& data = m_evmcHost->recorded_logs.at(_logIdx).data;
+	// TODO: Return a copy of log data, because this is expected from REQUIRE_LOG_DATA(),
+	//       but reference type like string_view would be preferable.
+	return {data.begin(), data.end()};
+}
+
+u256 ExecutionFramework::balanceAt(h160 const& _addr) const
+{
+	return u256(EVMHost::convertFromEVMC(m_evmcHost->get_balance(EVMHost::convertToEVMC(_addr))));
+}
+
+bool ExecutionFramework::storageEmpty(h160 const& _addr) const
+{
+	const auto it = m_evmcHost->accounts.find(EVMHost::convertToEVMC(_addr));
+	if (it != m_evmcHost->accounts.end())
+	{
+		for (auto const& entry: it->second.storage)
+			if (entry.second.current != evmc::bytes32{})
+				return false;
+	}
+	return true;
+}
+
+vector<solidity::frontend::test::LogRecord> ExecutionFramework::recordedLogs() const
+{
+	vector<LogRecord> logs;
+	for (evmc::MockedHost::log_record const& logRecord: m_evmcHost->recorded_logs)
+		logs.emplace_back(
+			EVMHost::convertFromEVMC(logRecord.creator),
+			bytes{logRecord.data.begin(), logRecord.data.end()},
+			logRecord.topics | ranges::views::transform([](evmc::bytes32 _bytes) { return EVMHost::convertFromEVMC(_bytes); }) | ranges::to<vector>
+		);
+	return logs;
+}
diff --git a/compiler/test/ExecutionFramework.h b/compiler/test/ExecutionFramework.h
new file mode 100644
index 00000000..27ceb4f2
--- /dev/null
+++ b/compiler/test/ExecutionFramework.h
@@ -0,0 +1,315 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Framework for executing contracts and testing them using RPC.
+ */
+
+#pragma once
+
+#include <test/Common.h>
+#include <test/EVMHost.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+#include <libsolidity/interface/DebugSettings.h>
+
+#include <liblangutil/EVMVersion.h>
+
+#include <libsolutil/FunctionSelector.h>
+#include <libsolutil/ErrorCodes.h>
+
+#include <functional>
+
+#include <boost/rational.hpp>
+#include <boost/test/unit_test.hpp>
+
+namespace solidity::frontend::test
+{
+struct LogRecord;
+} // namespace solidity::frontend::test
+
+namespace solidity::test
+{
+using rational = boost::rational<bigint>;
+
+// The ether and gwei denominations; here for ease of use where needed within code.
+static u256 const gwei = u256(1) << 9;
+static u256 const ether = u256(1) << 18;
+class ExecutionFramework
+{
+
+public:
+	ExecutionFramework();
+	ExecutionFramework(langutil::EVMVersion _evmVersion, std::vector<boost::filesystem::path> const& _vmPaths);
+	virtual ~ExecutionFramework() = default;
+
+	virtual bytes const& compileAndRunWithoutCheck(
+		std::map<std::string, std::string> const& _sourceCode,
+		u256 const& _value = 0,
+		std::string const& _contractName = "",
+		bytes const& _arguments = {},
+		std::map<std::string, util::h160> const& _libraryAddresses = {},
+		std::optional<std::string> const& _sourceName = std::nullopt
+	) = 0;
+
+	bytes const& compileAndRun(
+		std::string const& _sourceCode,
+		u256 const& _value = 0,
+		std::string const& _contractName = "",
+		bytes const& _arguments = {},
+		std::map<std::string, util::h160> const& _libraryAddresses = {}
+	)
+	{
+		compileAndRunWithoutCheck(
+			{{"", _sourceCode}},
+			_value,
+			_contractName,
+			_arguments,
+			_libraryAddresses
+		);
+		BOOST_REQUIRE(m_transactionSuccessful);
+		BOOST_REQUIRE(!m_output.empty());
+		return m_output;
+	}
+
+	bytes const& callFallbackWithValue(u256 const& _value)
+	{
+		sendMessage(bytes(), false, _value);
+		return m_output;
+	}
+
+	bytes const & callFallback()
+	{
+		return callFallbackWithValue(0);
+	}
+
+	bytes const& callLowLevel(bytes const& _data, u256 const& _value)
+	{
+		sendMessage(_data, false, _value);
+		return m_output;
+	}
+
+	bytes const& callContractFunctionWithValueNoEncoding(std::string _sig, u256 const& _value, bytes const& _arguments)
+	{
+		sendMessage(util::selectorFromSignatureH32(_sig).asBytes() + _arguments, false, _value);
+		return m_output;
+	}
+
+	bytes const& callContractFunctionNoEncoding(std::string _sig, bytes const& _arguments)
+	{
+		return callContractFunctionWithValueNoEncoding(_sig, 0, _arguments);
+	}
+
+	template <class... Args>
+	bytes const& callContractFunctionWithValue(std::string _sig, u256 const& _value, Args const&... _arguments)
+	{
+		return callContractFunctionWithValueNoEncoding(_sig, _value, encodeArgs(_arguments...));
+	}
+
+	template <class... Args>
+	bytes const& callContractFunction(std::string _sig, Args const&... _arguments)
+	{
+		return callContractFunctionWithValue(_sig, 0, _arguments...);
+	}
+
+	template <class CppFunction, class... Args>
+	void testContractAgainstCpp(std::string _sig, CppFunction const& _cppFunction, Args const&... _arguments)
+	{
+		bytes contractResult = callContractFunction(_sig, _arguments...);
+		bytes cppResult = callCppAndEncodeResult(_cppFunction, _arguments...);
+		BOOST_CHECK_MESSAGE(
+			contractResult == cppResult,
+			"Computed values do not match.\nContract: " +
+				util::toHex(contractResult) +
+				"\nC++:      " +
+				util::toHex(cppResult)
+		);
+	}
+
+	template <class CppFunction, class... Args>
+	void testContractAgainstCppOnRange(std::string _sig, CppFunction const& _cppFunction, u256 const& _rangeStart, u256 const& _rangeEnd)
+	{
+		for (u256 argument = _rangeStart; argument < _rangeEnd; ++argument)
+		{
+			bytes contractResult = callContractFunction(_sig, argument);
+			bytes cppResult = callCppAndEncodeResult(_cppFunction, argument);
+			BOOST_CHECK_MESSAGE(
+				contractResult == cppResult,
+				"Computed values do not match.\nContract: " +
+					util::toHex(contractResult) +
+					"\nC++:      " +
+					util::toHex(cppResult) +
+					"\nArgument: " +
+					util::toHex(encode(argument))
+			);
+		}
+	}
+
+	static std::pair<bool, std::string> compareAndCreateMessage(bytes const& _result, bytes const& _expectation);
+
+	static bytes encode(bool _value) { return encode(uint8_t(_value)); }
+	static bytes encode(int _value) { return encode(u256(_value)); }
+	static bytes encode(size_t _value) { return encode(u256(_value)); }
+	static bytes encode(char const* _value) { return encode(std::string(_value)); }
+	static bytes encode(uint8_t _value) { return bytes(31, 0) + bytes{_value}; }
+	static bytes encode(u256 const& _value) { return toBigEndian(_value); }
+	/// @returns the fixed-point encoding of a rational number with a given
+	/// number of fractional bits.
+	static bytes encode(std::pair<rational, int> const& _valueAndPrecision)
+	{
+		rational const& value = _valueAndPrecision.first;
+		int fractionalBits = _valueAndPrecision.second;
+		return encode(u256((value.numerator() << fractionalBits) / value.denominator()));
+	}
+	static bytes encode(util::h256 const& _value) { return _value.asBytes(); }
+	static bytes encode(util::h160 const& _value) { return encode(util::h256(_value, util::h256::AlignRight)); }
+	static bytes encode(bytes const& _value, bool _padLeft = true)
+	{
+		bytes padding = bytes((32 - _value.size() % 32) % 32, 0);
+		return _padLeft ? padding + _value : _value + padding;
+	}
+	static bytes encode(std::string const& _value) { return encode(util::asBytes(_value), false); }
+	template <class T>
+	static bytes encode(std::vector<T> const& _value)
+	{
+		bytes ret;
+		for (auto const& v: _value)
+			ret += encode(v);
+		return ret;
+	}
+
+	template <class FirstArg, class... Args>
+	static bytes encodeArgs(FirstArg const& _firstArg, Args const&... _followingArgs)
+	{
+		return encode(_firstArg) + encodeArgs(_followingArgs...);
+	}
+	static bytes encodeArgs()
+	{
+		return bytes();
+	}
+	/// @returns error returndata corresponding to the Panic(uint256) error code,
+	/// if REVERT is supported by the current EVM version and the empty string otherwise.
+	bytes panicData(util::PanicCode _code);
+
+	//@todo might be extended in the future
+	template <class Arg>
+	static bytes encodeDyn(Arg const& _arg)
+	{
+		return encodeArgs(u256(0x20), u256(_arg.size()), _arg);
+	}
+
+	u256 gasLimit() const;
+	u256 gasPrice() const;
+	u256 blockHash(u256 const& _blockNumber) const;
+	u256 blockNumber() const;
+
+	template<typename Range>
+	static bytes encodeArray(bool _dynamicallySized, bool _dynamicallyEncoded, Range const& _elements)
+	{
+		bytes result;
+		if (_dynamicallySized)
+			result += encode(u256(_elements.size()));
+		if (_dynamicallyEncoded)
+		{
+			u256 offset = u256(_elements.size()) * 32;
+			std::vector<bytes> subEncodings;
+			for (auto const& element: _elements)
+			{
+				result += encode(offset);
+				subEncodings.emplace_back(encode(element));
+				offset += subEncodings.back().size();
+			}
+			for (auto const& subEncoding: subEncodings)
+				result += subEncoding;
+		}
+		else
+			for (auto const& element: _elements)
+				result += encode(element);
+		return result;
+	}
+
+	util::h160 setAccount(size_t _accountNumber)
+	{
+		m_sender = account(_accountNumber);
+		return m_sender;
+	}
+
+	size_t numLogs() const;
+	size_t numLogTopics(size_t _logIdx) const;
+	util::h256 logTopic(size_t _logIdx, size_t _topicIdx) const;
+	util::h160 logAddress(size_t _logIdx) const;
+	bytes logData(size_t _logIdx) const;
+
+private:
+	template <class CppFunction, class... Args>
+	auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
+	-> typename std::enable_if<std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
+	{
+		_cppFunction(_arguments...);
+		return bytes();
+	}
+	template <class CppFunction, class... Args>
+	auto callCppAndEncodeResult(CppFunction const& _cppFunction, Args const&... _arguments)
+	-> typename std::enable_if<!std::is_void<decltype(_cppFunction(_arguments...))>::value, bytes>::type
+	{
+		return encode(_cppFunction(_arguments...));
+	}
+
+protected:
+	u256 const InitialGas = 100000000;
+
+	void selectVM(evmc_capabilities _cap = evmc_capabilities::EVMC_CAPABILITY_EVM1);
+	void reset();
+
+	void sendMessage(bytes const& _data, bool _isCreation, u256 const& _value = 0);
+	void sendEther(util::h160 const& _to, u256 const& _value);
+	size_t currentTimestamp();
+	size_t blockTimestamp(u256 _number);
+
+	/// @returns the (potentially newly created) _ith address.
+	util::h160 account(size_t _i);
+
+	u256 balanceAt(util::h160 const& _addr) const;
+	bool storageEmpty(util::h160 const& _addr) const;
+	bool addressHasCode(util::h160 const& _addr) const;
+
+	std::vector<frontend::test::LogRecord> recordedLogs() const;
+
+	langutil::EVMVersion m_evmVersion;
+	solidity::frontend::RevertStrings m_revertStrings = solidity::frontend::RevertStrings::Default;
+	solidity::frontend::OptimiserSettings m_optimiserSettings = solidity::frontend::OptimiserSettings::minimal();
+	bool m_showMessages = false;
+	std::unique_ptr<EVMHost> m_evmcHost;
+
+	std::vector<boost::filesystem::path> m_vmPaths;
+
+	bool m_transactionSuccessful = true;
+	util::h160 m_sender = account(0);
+	util::h160 m_contractAddress;
+	bytes m_output;
+	u256 m_gasUsed;
+};
+
+#define ABI_CHECK(result, expectation) do { \
+	auto abiCheckResult = ExecutionFramework::compareAndCreateMessage((result), (expectation)); \
+	BOOST_CHECK_MESSAGE(abiCheckResult.first, abiCheckResult.second); \
+} while (0)
+
+
+} // end namespaces
diff --git a/compiler/test/InteractiveTests.h b/compiler/test/InteractiveTests.h
new file mode 100644
index 00000000..2519fa86
--- /dev/null
+++ b/compiler/test/InteractiveTests.h
@@ -0,0 +1,87 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+#include <test/libsolidity/ABIJsonTest.h>
+#include <test/libsolidity/ASTJSONTest.h>
+#include <test/libsolidity/ASTPropertyTest.h>
+#include <libsolidity/FunctionDependencyGraphTest.h>
+#include <test/libsolidity/GasTest.h>
+#include <test/libsolidity/MemoryGuardTest.h>
+#include <test/libsolidity/NatspecJSONTest.h>
+#include <test/libsolidity/SyntaxTest.h>
+#include <test/libsolidity/SemanticTest.h>
+#include <test/libsolidity/SMTCheckerTest.h>
+#include <test/libyul/ControlFlowGraphTest.h>
+#include <test/libyul/EVMCodeTransformTest.h>
+#include <test/libyul/YulOptimizerTest.h>
+#include <test/libyul/YulInterpreterTest.h>
+#include <test/libyul/ObjectCompilerTest.h>
+#include <test/libyul/ControlFlowSideEffectsTest.h>
+#include <test/libyul/FunctionSideEffects.h>
+#include <test/libyul/StackLayoutGeneratorTest.h>
+#include <test/libyul/StackShufflingTest.h>
+#include <test/libyul/SyntaxTest.h>
+
+#include <boost/filesystem.hpp>
+
+namespace solidity::frontend::test
+{
+
+/** Container for all information regarding a testsuite */
+struct Testsuite
+{
+	char const* title;
+	boost::filesystem::path const path;
+	boost::filesystem::path const subpath;
+	bool smt;
+	bool needsVM;
+	TestCase::TestCaseCreator testCaseCreator;
+	std::vector<std::string> labels{};
+};
+
+
+/// Array of testsuits that can be run interactively as well as automatically
+Testsuite const g_interactiveTestsuites[] = {
+/*
+	Title                   		Path           Subpath                			SMT   NeedsVM Creator function */
+	{"Yul Optimizer",          		"libyul",      "yulOptimizerTests",     		false, false, &yul::test::YulOptimizerTest::create},
+	{"Yul Interpreter",        		"libyul",      "yulInterpreterTests",   		false, false, &yul::test::YulInterpreterTest::create},
+	{"Yul Object Compiler",    		"libyul",      "objectCompiler",        		false, false, &yul::test::ObjectCompilerTest::create},
+	{"Yul Control Flow Graph", 		"libyul",      "yulControlFlowGraph",   		false, false, &yul::test::ControlFlowGraphTest::create},
+	{"Yul Stack Layout",       		"libyul",      "yulStackLayout",        		false, false, &yul::test::StackLayoutGeneratorTest::create},
+	{"Yul Stack Shuffling",    		"libyul",      "yulStackShuffling",     		false, false, &yul::test::StackShufflingTest::create},
+	{"Control Flow Side Effects",	"libyul",      "controlFlowSideEffects",		false, false, &yul::test::ControlFlowSideEffectsTest::create},
+	{"Function Side Effects",  		"libyul",      "functionSideEffects",   		false, false, &yul::test::FunctionSideEffects::create},
+	{"Yul Syntax",             		"libyul",      "yulSyntaxTests",        		false, false, &yul::test::SyntaxTest::create},
+	{"EVM Code Transform",     		"libyul",      "evmCodeTransform",      		false, false, &yul::test::EVMCodeTransformTest::create, {"nooptions"}},
+	{"Syntax",                 		"libsolidity", "syntaxTests",           		false, false, &SyntaxTest::create},
+	{"Semantic",               		"libsolidity", "semanticTests",         		false, true,  &SemanticTest::create},
+	{"JSON AST",               		"libsolidity", "ASTJSON",               		false, false, &ASTJSONTest::create},
+	{"JSON ABI",               		"libsolidity", "ABIJson",               		false, false, &ABIJsonTest::create},
+	{"JSON Natspec",           		"libsolidity", "natspecJSON",           		false, false, &NatspecJSONTest::create},
+	{"SMT Checker",            		"libsolidity", "smtCheckerTests",       		true,  false, &SMTCheckerTest::create},
+	{"Gas Estimates",          		"libsolidity", "gasTests",              		false, false, &GasTest::create},
+	{"Memory Guard",           		"libsolidity", "memoryGuardTests",      		false, false, &MemoryGuardTest::create},
+	{"AST Properties",         		"libsolidity", "astPropertyTests",      		false, false, &ASTPropertyTest::create},
+	{"Function Dependency Graph",   "libsolidity", "functionDependencyGraphTests",	false, false, &FunctionDependencyGraphTest::create},
+};
+
+}
diff --git a/compiler/test/TestCase.cpp b/compiler/test/TestCase.cpp
new file mode 100644
index 00000000..51608bd4
--- /dev/null
+++ b/compiler/test/TestCase.cpp
@@ -0,0 +1,142 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/Common.h>
+#include <test/TestCase.h>
+
+#include <libsolutil/AnsiColorized.h>
+#include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <iostream>
+#include <stdexcept>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::util;
+
+void TestCase::printSettings(ostream& _stream, const string& _linePrefix, const bool)
+{
+	auto& settings = m_reader.settings();
+	if (settings.empty())
+		return;
+
+	_stream << _linePrefix << "// ====" << endl;
+	for (auto const& setting: settings)
+		_stream << _linePrefix << "// " << setting.first << ": " << setting.second << endl;
+}
+
+void TestCase::printUpdatedSettings(std::ostream& _stream, std::string const& _linePrefix)
+{
+	printSettings(_stream, _linePrefix);
+}
+
+bool TestCase::isTestFilename(boost::filesystem::path const& _filename)
+{
+	string extension = _filename.extension().string();
+	return (extension == ".sol" || extension == ".yul" || extension == ".stack") &&
+		   !boost::starts_with(_filename.string(), "~") &&
+			!boost::starts_with(_filename.string(), ".");
+}
+
+bool TestCase::shouldRun()
+{
+	m_reader.ensureAllSettingsRead();
+	return m_shouldRun;
+}
+
+void TestCase::expect(string::iterator& _it, string::iterator _end, string::value_type _c)
+{
+	if (_it == _end || *_it != _c)
+		BOOST_THROW_EXCEPTION(runtime_error(string("Invalid test expectation. Expected: \"") + _c + "\"."));
+	++_it;
+}
+
+void TestCase::printSource(ostream& _stream, string const& _linePrefix, bool const) const
+{
+	printPrefixed(_stream, m_source, _linePrefix);
+}
+
+void TestCase::printUpdatedExpectations(ostream& _stream, string const& _linePrefix) const
+{
+	printPrefixed(_stream, m_obtainedResult, _linePrefix);
+}
+
+TestCase::TestResult TestCase::checkResult(std::ostream& _stream, const std::string& _linePrefix, bool const _formatted)
+{
+	if (m_expectation != m_obtainedResult)
+	{
+		string nextIndentLevel = _linePrefix + "  ";
+		util::AnsiColorized(_stream, _formatted, {util::formatting::BOLD, util::formatting::CYAN})
+			<< _linePrefix << "Expected result:" << endl;
+		// TODO could compute a simple diff with highlighted lines
+		printPrefixed(_stream, m_expectation, nextIndentLevel);
+		util::AnsiColorized(_stream, _formatted, {util::formatting::BOLD, util::formatting::CYAN})
+			<< _linePrefix << "Obtained result:" << endl;
+		printPrefixed(_stream, m_obtainedResult, nextIndentLevel);
+		return TestResult::Failure;
+	}
+	return TestResult::Success;
+}
+
+EVMVersionRestrictedTestCase::EVMVersionRestrictedTestCase(string const& _filename):
+	TestCase(_filename)
+{
+	string versionString = m_reader.stringSetting("EVMVersion", "any");
+	if (versionString == "any")
+		return;
+
+	string comparator;
+	size_t versionBegin = 0;
+	for (auto character: versionString)
+		if (!isalpha(character, locale::classic()))
+		{
+			comparator += character;
+			versionBegin++;
+		}
+		else
+			break;
+
+	versionString = versionString.substr(versionBegin);
+	std::optional<langutil::EVMVersion> version = langutil::EVMVersion::fromString(versionString);
+	if (!version)
+		BOOST_THROW_EXCEPTION(runtime_error{"Invalid EVM version: \"" + versionString + "\""});
+
+	langutil::EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	bool comparisonResult;
+	if (comparator == ">")
+		comparisonResult = evmVersion > version;
+	else if (comparator == ">=")
+		comparisonResult = evmVersion >= version;
+	else if (comparator == "<")
+		comparisonResult = evmVersion < version;
+	else if (comparator == "<=")
+		comparisonResult = evmVersion <= version;
+	else if (comparator == "=")
+		comparisonResult = evmVersion == version;
+	else if (comparator == "!")
+		comparisonResult = !(evmVersion == version);
+	else
+		BOOST_THROW_EXCEPTION(runtime_error{"Invalid EVM comparator: \"" + comparator + "\""});
+
+	if (!comparisonResult)
+		m_shouldRun = false;
+}
diff --git a/compiler/test/TestCase.h b/compiler/test/TestCase.h
new file mode 100644
index 00000000..301dbfb6
--- /dev/null
+++ b/compiler/test/TestCase.h
@@ -0,0 +1,119 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCaseReader.h>
+
+#include <liblangutil/EVMVersion.h>
+
+#include <boost/filesystem.hpp>
+
+#include <string>
+
+namespace solidity::frontend::test
+{
+
+/**
+ * Common superclass of anything that can be run via isoltest.
+ */
+class TestCase
+{
+public:
+	struct Config
+	{
+		std::string filename;
+		langutil::EVMVersion evmVersion;
+		std::optional<uint8_t> eofVersion;
+		std::vector<boost::filesystem::path> vmPaths;
+		bool enforceGasCost = false;
+		u256 enforceGasCostMinValue;
+	};
+
+	enum class TestResult { Success, Failure, FatalError };
+
+	using TestCaseCreator = std::unique_ptr<TestCase>(*)(Config const&);
+
+	virtual ~TestCase() = default;
+
+	/// Runs the test case.
+	/// Outputs error messages to @arg _stream. Each line of output is prefixed with @arg _linePrefix.
+	/// Optionally, color-coding can be enabled (if @arg _formatted is set to true).
+	/// @returns true, if the test case succeeds, false otherwise
+	virtual TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) = 0;
+
+	/// Outputs the test contract to @arg _stream.
+	/// Each line of output is prefixed with @arg _linePrefix.
+	/// If @arg _formatted is true, color-coding may be used to indicate
+	/// error locations in the contract, if applicable.
+	virtual void printSource(std::ostream &_stream, std::string const &_linePrefix = "", bool const _formatted = false) const;
+	/// Outputs settings.
+	virtual void printSettings(std::ostream &_stream, std::string const &_linePrefix = "", bool const _formatted = false);
+	/// Outputs updated settings
+	virtual void printUpdatedSettings(std::ostream& _stream, std::string const& _linePrefix = "");
+	/// Outputs test expectations to @arg _stream that match the actual results of the test.
+	/// Each line of output is prefixed with @arg _linePrefix.
+	virtual void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const;
+
+	static bool isTestFilename(boost::filesystem::path const& _filename);
+
+	/// Returns true, if the test case is supported in the current environment and false
+	/// otherwise which causes this test to be skipped.
+	/// This might check e.g. for restrictions on the EVM version.
+	/// The function throws an exception if there are unread settings.
+	bool shouldRun();
+
+protected:
+	// Used by ASTJSONTest, the only TestCase class with a custom parser of the test files.
+	TestCase() = default;
+
+	TestCase(std::string const& _filename): m_reader(_filename) {}
+
+	static void expect(std::string::iterator& _it, std::string::iterator _end, std::string::value_type _c);
+
+	template<typename IteratorType>
+	static void skipWhitespace(IteratorType& _it, IteratorType _end)
+	{
+		while (_it != _end && std::isspace<char>(*_it, std::locale::classic()))
+			++_it;
+	}
+
+	template<typename IteratorType>
+	static void skipSlashes(IteratorType& _it, IteratorType _end)
+	{
+		while (_it != _end && *_it == '/')
+			++_it;
+	}
+
+	TestCase::TestResult checkResult(std::ostream& _stream, const std::string& _linePrefix, bool const _formatted);
+
+	std::string m_source;
+	std::string m_obtainedResult;
+	std::string m_expectation;
+
+	TestCaseReader m_reader;
+	bool m_shouldRun = true;
+};
+
+class EVMVersionRestrictedTestCase: public TestCase
+{
+protected:
+	EVMVersionRestrictedTestCase(std::string const& _filename);
+};
+
+}
diff --git a/compiler/test/TestCaseReader.cpp b/compiler/test/TestCaseReader.cpp
new file mode 100644
index 00000000..7ad752ef
--- /dev/null
+++ b/compiler/test/TestCaseReader.cpp
@@ -0,0 +1,214 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/TestCaseReader.h>
+
+#include <libsolutil/CommonIO.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+
+using namespace std;
+using namespace solidity::frontend::test;
+
+namespace fs = boost::filesystem;
+
+TestCaseReader::TestCaseReader(string const& _filename): m_fileStream(_filename), m_fileName(_filename)
+{
+	if (!m_fileStream)
+		BOOST_THROW_EXCEPTION(runtime_error("Cannot open file: \"" + _filename + "\"."));
+	m_fileStream.exceptions(ios::badbit);
+
+	tie(m_sources, m_lineNumber) = parseSourcesAndSettingsWithLineNumber(m_fileStream);
+	m_unreadSettings = m_settings;
+}
+
+TestCaseReader::TestCaseReader(istringstream const& _str)
+{
+	tie(m_sources, m_lineNumber) = parseSourcesAndSettingsWithLineNumber(
+		static_cast<istream&>(const_cast<istringstream&>(_str))
+	);
+}
+
+string const& TestCaseReader::source() const
+{
+	if (m_sources.sources.size() != 1)
+		BOOST_THROW_EXCEPTION(runtime_error("Expected single source definition, but got multiple sources."));
+	return m_sources.sources.at(m_sources.mainSourceFile);
+}
+
+string TestCaseReader::simpleExpectations()
+{
+	return parseSimpleExpectations(m_fileStream);
+}
+
+bool TestCaseReader::boolSetting(std::string const& _name, bool _defaultValue)
+{
+	if (m_settings.count(_name) == 0)
+		return _defaultValue;
+
+	m_unreadSettings.erase(_name);
+	string value = m_settings.at(_name);
+	if (value == "false")
+		return false;
+	if (value == "true")
+		return true;
+
+	BOOST_THROW_EXCEPTION(runtime_error("Invalid Boolean value: " + value + "."));
+}
+
+size_t TestCaseReader::sizetSetting(std::string const& _name, size_t _defaultValue)
+{
+	if (m_settings.count(_name) == 0)
+		return _defaultValue;
+
+	m_unreadSettings.erase(_name);
+
+	static_assert(sizeof(unsigned long) <= sizeof(size_t));
+	return stoul(m_settings.at(_name));
+}
+
+string TestCaseReader::stringSetting(string const& _name, string const& _defaultValue)
+{
+	if (m_settings.count(_name) == 0)
+		return _defaultValue;
+
+	m_unreadSettings.erase(_name);
+	return m_settings.at(_name);
+}
+
+void TestCaseReader::ensureAllSettingsRead() const
+{
+	if (!m_unreadSettings.empty())
+		BOOST_THROW_EXCEPTION(runtime_error(
+			"Unknown setting(s): " +
+			util::joinHumanReadable(m_unreadSettings | ranges::views::keys)
+		));
+}
+
+pair<SourceMap, size_t> TestCaseReader::parseSourcesAndSettingsWithLineNumber(istream& _stream)
+{
+	map<string, string> sources;
+	map<string, boost::filesystem::path> externalSources;
+	string currentSourceName;
+	string currentSource;
+	string line;
+	size_t lineNumber = 1;
+	static string const externalSourceDelimiterStart("==== ExternalSource:");
+	static string const sourceDelimiterStart("==== Source:");
+	static string const sourceDelimiterEnd("====");
+	static string const comment("// ");
+	static string const settingsDelimiter("// ====");
+	static string const expectationsDelimiter("// ----");
+	bool sourcePart = true;
+	while (getline(_stream, line))
+	{
+		lineNumber++;
+
+		// Anything below the delimiter is left up to the test case to process in a custom way.
+		if (boost::algorithm::starts_with(line, expectationsDelimiter))
+			break;
+
+		if (boost::algorithm::starts_with(line, settingsDelimiter))
+			sourcePart = false;
+		else if (sourcePart)
+		{
+			if (boost::algorithm::starts_with(line, sourceDelimiterStart) && boost::algorithm::ends_with(line, sourceDelimiterEnd))
+			{
+				if (!(currentSourceName.empty() && currentSource.empty()))
+					sources[currentSourceName] = std::move(currentSource);
+				currentSource = {};
+				currentSourceName = boost::trim_copy(line.substr(
+					sourceDelimiterStart.size(),
+					line.size() - sourceDelimiterEnd.size() - sourceDelimiterStart.size()
+				));
+				if (sources.count(currentSourceName))
+					BOOST_THROW_EXCEPTION(runtime_error("Multiple definitions of test source \"" + currentSourceName + "\"."));
+			}
+			else if (boost::algorithm::starts_with(line, externalSourceDelimiterStart) && boost::algorithm::ends_with(line, sourceDelimiterEnd))
+			{
+				string externalSourceString = boost::trim_copy(line.substr(
+					externalSourceDelimiterStart.size(),
+					line.size() - sourceDelimiterEnd.size() - externalSourceDelimiterStart.size()
+				));
+
+				string externalSourceName;
+				size_t remappingPos = externalSourceString.find('=');
+				// Does the external source define a remapping?
+				if (remappingPos != string::npos)
+				{
+					externalSourceName = boost::trim_copy(externalSourceString.substr(0, remappingPos));
+					externalSourceString = boost::trim_copy(externalSourceString.substr(remappingPos + 1));
+				}
+				else
+					externalSourceName = externalSourceString;
+
+				soltestAssert(!externalSourceName.empty(), "");
+				fs::path externalSourceTarget(externalSourceString);
+				fs::path testCaseParentDir = m_fileName.parent_path();
+				if (!externalSourceTarget.is_relative() || !externalSourceTarget.root_path().empty())
+					// NOTE: UNC paths (ones starting with // or \\) are considered relative by Boost
+					// since they have an empty root directory (but non-empty root name).
+					BOOST_THROW_EXCEPTION(runtime_error("External Source paths need to be relative to the location of the test case."));
+				fs::path externalSourceFullPath = testCaseParentDir / externalSourceTarget;
+				string externalSourceContent;
+				if (!fs::exists(externalSourceFullPath))
+					BOOST_THROW_EXCEPTION(runtime_error("External Source '" + externalSourceTarget.string() + "' not found."));
+				else
+					externalSourceContent = util::readFileAsString(externalSourceFullPath);
+
+				if (sources.count(externalSourceName))
+					BOOST_THROW_EXCEPTION(runtime_error("Multiple definitions of test source \"" + externalSourceName + "\"."));
+				sources[externalSourceName] = externalSourceContent;
+				externalSources[externalSourceName] = externalSourceTarget;
+			}
+			else
+				currentSource += line + "\n";
+		}
+		else if (boost::algorithm::starts_with(line, comment))
+		{
+			size_t colon = line.find(':');
+			if (colon == string::npos)
+				BOOST_THROW_EXCEPTION(runtime_error(string("Expected \":\" inside setting.")));
+			string key = line.substr(comment.size(), colon - comment.size());
+			string value = line.substr(colon + 1);
+			boost::algorithm::trim(key);
+			boost::algorithm::trim(value);
+			m_settings[key] = value;
+		}
+		else
+			BOOST_THROW_EXCEPTION(runtime_error(string("Expected \"//\" or \"// ---\" to terminate settings and source.")));
+	}
+	// Register the last source as the main one
+	sources[currentSourceName] = currentSource;
+	return {{std::move(sources), std::move(externalSources), std::move(currentSourceName)}, lineNumber};
+}
+
+string TestCaseReader::parseSimpleExpectations(istream& _file)
+{
+	string result;
+	string line;
+	while (getline(_file, line))
+		if (boost::algorithm::starts_with(line, "// "))
+			result += line.substr(3) + "\n";
+		else if (line == "//")
+			result += "\n";
+		else
+			BOOST_THROW_EXCEPTION(runtime_error("Test expectations must start with \"// \"."));
+	return result;
+}
diff --git a/compiler/test/benchmarks/OptimizorClub.sol b/compiler/test/benchmarks/OptimizorClub.sol
new file mode 100644
index 00000000..c21d42e6
--- /dev/null
+++ b/compiler/test/benchmarks/OptimizorClub.sol
@@ -0,0 +1,782 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Compressed form of https://github.com/OptimizorClub/optimizor and its dependencies
+
+library Base64 {
+    bytes private constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    function encode(bytes memory data) internal pure returns (string memory result) {
+        uint256 len = data.length;
+        if (len == 0) return "";
+        uint256 encodedLen;
+        unchecked {
+            encodedLen = 4 * ((len + 2) / 3);
+        }
+        unchecked {
+            result = new string(encodedLen + 32);
+        }
+        bytes memory table = TABLE;
+        assembly ("memory-safe") {
+            let tablePtr := add(table, 1)
+            let resultPtr := add(result, 32)
+            for { let i := 0 } lt(i, len) {} {
+                i := add(i, 3)
+                let input := and(mload(add(data, i)), 0xffffff)
+                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
+                out := shl(8, out)
+                out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
+                out := shl(8, out)
+                out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
+                out := shl(8, out)
+                out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
+                out := shl(224, out)
+                mstore(resultPtr, out)
+                resultPtr := add(resultPtr, 4)
+            }
+            switch mod(len, 3)
+            case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
+            case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
+            mstore(result, encodedLen)
+        }
+        return result;
+    }
+}
+library Puretea {
+    function isMutating(bytes memory code) internal pure returns (bool) {
+        return check(code, 0xe43f0000000000000000001fffffffffffffffff0fff01ffffff00013fff0fff);
+    }
+    function isView(bytes memory code) internal pure returns (bool) {
+        return check(code, 0x640800000000000000000000ffffffffffffffff0fdf01ffffff00013fff0fff);
+    }
+    function isPureGlobal(bytes memory code) internal pure returns (bool) {
+        return check(code, 0x600800000000000000000000ffffffffffffffff0fdf01ff67ff00013fff0fff);
+    }
+    function isPureLocal(bytes memory code) internal pure returns (bool) {
+        return check(code, 0x600800000000000000000000ffffffffffffffff0fcf01ffffff00013fff0fff);
+    }
+    function check(bytes memory _code, uint256 _mask) internal pure returns (bool satisfied) {
+        assembly ("memory-safe") {
+            function matchesMask(mask, opcode) -> ret {
+                ret := and(mask, shl(opcode, 1))
+            }
+            function isPush(opcode) -> ret {
+                ret := and(gt(opcode, 0x5f), lt(opcode, 0x80))
+            }
+            function perform(mask, code) -> ret {
+                for {
+                    let offset := add(code, 32)
+                    let end := add(offset, mload(code ))
+                } lt(offset, end) {
+                    offset := add(offset, 1)
+                } {
+                    let opcode := byte(0, mload(offset))
+                    if iszero(matchesMask(mask, opcode)) {
+                        leave
+                    }
+                    if isPush(opcode) {
+                        let immLen := sub(opcode, 0x5f)
+                        offset := add(offset, immLen)
+                        if iszero(lt(offset, end)) {
+                            leave
+                        }
+                    }
+                }
+                ret := 1
+            }
+            satisfied := perform(_mask, _code)
+        }
+    }
+}
+abstract contract PurityChecker {
+    uint256 private constant acceptedOpcodesMask = 0x600800000000000000000000ffffffffffffffff0fdf01ff67ff00013fff0fff;
+    function check(address account) external view returns (bool) {
+        return Puretea.check(account.code, acceptedOpcodesMask);
+    }
+}
+interface IChallenge {
+    function run(address target, uint256 seed) external view returns (uint32);
+    function svg(uint256 tokenId) external view returns (string memory);
+    function name() external view returns (string memory);
+    function description() external view returns (string memory);
+}
+struct TokenDetails {
+    uint256 challengeId;
+    IChallenge challenge;
+    uint32 leaderGas;
+    uint32 leaderSolutionId;
+    address leaderSolver;
+    address leaderOwner;
+    address leaderSubmission;
+    uint32 gas;
+    uint32 solutionId;
+    uint32 rank;
+    uint32 improvementPercentage;
+    address solver;
+    address owner;
+    address submission;
+}
+library HexString {
+    error HexLengthInsufficient();
+    bytes16 private constant ALPHABET = "0123456789abcdef";
+    function toHexStringNoPrefix(uint256 value, uint256 length) internal pure returns (string memory) {
+        bytes memory buffer = new bytes(2 * length);
+        unchecked {
+            for (uint256 i = buffer.length; i > 0; --i) {
+                buffer[i - 1] = ALPHABET[value & 0xf];
+                value >>= 4;
+            }
+        }
+        if (value != 0) revert HexLengthInsufficient();
+        return string(buffer);
+    }
+    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
+        bytes memory buffer = new bytes(2 * length + 2);
+        buffer[0] = "0";
+        buffer[1] = "x";
+        unchecked {
+            for (uint256 i = 2 * length + 1; i > 1; --i) {
+                buffer[i] = ALPHABET[value & 0xf];
+                value >>= 4;
+            }
+        }
+        if (value != 0) revert HexLengthInsufficient();
+        return string(buffer);
+    }
+}
+function packTokenId(uint256 challengeId, uint32 solutionId) pure returns (uint256) {
+    return (challengeId << 32) | solutionId;
+}
+function unpackTokenId(uint256 tokenId) pure returns (uint256 challengeId, uint32 solutionId) {
+    challengeId = tokenId >> 32;
+    solutionId = uint32(tokenId);
+}
+library NFTSVG {
+    struct SVGParams {
+        string projectName;
+        string challengeName;
+        string solverAddr;
+        string challengeAddr;
+        uint256 gasUsed;
+        uint256 gasOpti;
+        uint256 tokenId;
+        uint32 rank;
+        uint32 participants;
+        string color;
+        uint256 x1;
+        uint256 y1;
+        uint256 x2;
+        uint256 y2;
+        uint256 x3;
+        uint256 y3;
+    }
+    function generateSVG(SVGParams memory params, string memory challengeSVG)
+        internal
+        pure
+        returns (string memory svg)
+    {
+        return string.concat(
+            generateSVGDefs(params),
+            generateSVGBorderText(params.projectName, params.challengeName, params.solverAddr, params.challengeAddr),
+            generateSVGCardMantle(params.challengeName, params.rank, params.participants),
+            generateRankBorder(params.rank),
+            generateSvgCurve(challengeSVG),
+            generateSVGPositionDataAndLocationCurve(LibString.toString(params.tokenId), params.gasUsed, params.gasOpti),
+            generateOptimizorIcon(),
+            "</svg>"
+        );
+    }
+    function generateSVGDefs(SVGParams memory params) private pure returns (string memory svg) {
+        svg = string.concat(
+            '<svg width="290" height="500" viewBox="0 0 290 500" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">'
+            "<defs>"
+            '<filter id="icon"><feImage result="icon" xlink:href="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTY2LjU5NyIgaGVpZ2h0PSIxMjguOTQxIiB2aWV3Qm94PSIwIDAgNDQuMDc5IDM0LjExNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMjAuNzkzIDEzLjMyMWgtLjYyM1YxMi43aC02LjIyNXYuNjIyaC42MjJ2LjYyM2gtLjYyMnYuNjIyaC0uNjIzdi0uNjIySDEyLjd2Ni4yMjVoLjYyMnYuNjIzaC42MjN2LjYyMmg2LjIyNXYtLjYyMmguNjIzdi0uNjIzaC42MjJ2LTYuMjI1aC0uNjIyem0tMy43MzUgNS42MDN2LTQuMzU4aDEuODY3djQuMzU4em0xMy42OTgtNi4yMjVoLTYuODQ4di42MjJoLjYyM3YuNjIzaC0uNjIzdi42MjJoLS42MjJ2LS42MjJoLS42MjN2Ni4yMjVoLjYyM3YuNjIzaC42MjJ2LjYyMmg2Ljg0OHYtLjYyMmguNjIydi0xLjI0NWgtLjYyMnYtLjYyM0gyNy4wMnYtNC4zNThoMy43MzV2LS42MjJoLjYyMnYtLjYyM2gtLjYyMnoiIHN0eWxlPSJmaWxsOiM2NjYiLz48L3N2Zz4="/></filter>'
+            '<filter id="f1"><feImage result="p0" xlink:href="data:image/svg+xml;base64,',
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><rect width='290' height='500' fill='#",
+                        params.color,
+                        "'/></svg>"
+                    )
+                )
+            ),
+            '"/><feImage result="p1" xlink:href="data:image/svg+xml;base64,',
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                        LibString.toString(params.x1),
+                        "' cy='",
+                        LibString.toString(params.y1),
+                        "' r='120' fill='#",
+                        params.color,
+                        "'/></svg>"
+                    )
+                )
+            ),
+            '"/><feImage result="p2" xlink:href="data:image/svg+xml;base64,',
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                        LibString.toString(params.x2),
+                        "' cy='",
+                        LibString.toString(params.y2),
+                        "' r='120' fill='#",
+                        params.color,
+                        "'/></svg>"
+                    )
+                )
+            ),
+            '" />',
+            '<feImage result="p3" xlink:href="data:image/svg+xml;base64,',
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        "<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='",
+                        LibString.toString(params.x3),
+                        "' cy='",
+                        LibString.toString(params.y3),
+                        "' r='100' fill='#",
+                        params.color,
+                        "'/></svg>"
+                    )
+                )
+            ),
+            '"/><feBlend mode="overlay" in="p0" in2="p1"/><feBlend mode="exclusion" in2="p2"/><feBlend mode="overlay" in2="p3" result="blendOut"/><feGaussianBlur '
+            'in="blendOut" stdDeviation="42"/></filter><clipPath id="corners"><rect width="290" height="500" rx="42" ry="42"/></clipPath>'
+            '<path id="text-path-a" d="M40 12 H250 A28 28 0 0 1 278 40 V460 A28 28 0 0 1 250 488 H40 A28 28 0 0 1 12 460 V40 A28 28 0 0 1 40 12 z"/>'
+            '<path id="minimap" d="M234 444C234 457.949 242.21 463 253 463"/>'
+            '<filter id="top-region-blur"><feGaussianBlur in="SourceGraphic" stdDeviation="24"/></filter>'
+            '<linearGradient id="grad-up" x1="1" x2="0" y1="1" y2="0"><stop offset="0.0" stop-color="#fff" stop-opacity="1"/>'
+            '<stop offset=".9" stop-color="#fff" stop-opacity="0"/></linearGradient>'
+            '<linearGradient id="grad-down" x1="0" x2="1" y1="0" y2="1"><stop offset="0.0" stop-color="#fff" stop-opacity="1"/><stop offset="0.9" stop-color="#fff" stop-opacity="0"/></linearGradient>'
+            '<mask id="fade-up" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-up)"/></mask>'
+            '<mask id="fade-down" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-down)"/></mask>'
+            '<mask id="none" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="#fff"/></mask>'
+            '<linearGradient id="grad-symbol"><stop offset="0.7" stop-color="#fff" stop-opacity="1"/><stop offset=".95" stop-color="#fff" stop-opacity="0"/></linearGradient>'
+            '<mask id="fade-symbol" maskContentUnits="userSpaceOnUse"><rect width="290" height="200" fill="url(#grad-symbol)"/></mask></defs>'
+            '<g clip-path="url(#corners)">' '<rect fill="',
+            params.color,
+            '" x="0" y="0" width="290" height="500"/>'
+            '<rect style="filter: url(#f1)" x="0" y="0" width="290" height="500"/>'
+            '<g style="filter:url(#top-region-blur); transform:scale(1.5); transform-origin:center top;">'
+            '<rect fill="none" x="0" y="0" width="290" height="500"/>'
+            '<ellipse cx="50%" cy="0" rx="180" ry="120" fill="#000" opacity="0.85"/></g>'
+            '<rect x="0" y="0" width="290" height="500" rx="42" ry="42" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)"/></g>'
+        );
+    }
+    function generateSVGBorderText(
+        string memory projectName,
+        string memory challengeName,
+        string memory solverAddr,
+        string memory challengeAddr
+    ) private pure returns (string memory svg) {
+        svg = string.concat(
+            '<text text-rendering="optimizeSpeed">'
+            '<textPath startOffset="-100%" fill="#fff" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+            challengeName,
+            unicode" • ",
+            challengeAddr,
+            '<animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite"/>'
+            '</textPath> <textPath startOffset="0%" fill="#fff" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+            challengeName,
+            unicode" • ",
+            challengeAddr,
+            '<animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite"/></textPath>'
+            '<textPath startOffset="50%" fill="#fff" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+            projectName,
+            unicode" • ",
+            solverAddr,
+            '<animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s"'
+            ' repeatCount="indefinite"/></textPath><textPath startOffset="-50%" fill="#fff" font-family="\'Courier New\', monospace" font-size="10px" xlink:href="#text-path-a">',
+            projectName,
+            unicode" • ",
+            solverAddr,
+            '<animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite"/></textPath></text>'
+        );
+    }
+    function generateSVGCardMantle(string memory challengeName, uint32 rank, uint32 participants)
+        private
+        pure
+        returns (string memory svg)
+    {
+        svg = string.concat(
+            '<g mask="url(#fade-symbol)"><rect fill="none" x="0" y="0" width="290" height="200"/><text y="70" x="32" fill="#fff" font-family="\'Courier New\', monospace" font-weight="200" font-size="28px">',
+            challengeName,
+            '</text><text y="115" x="32" fill="#fff" font-family="\'Courier New\', monospace" font-weight="200" font-size="20px">'
+            "Rank ",
+            LibString.toString(rank),
+            " of ",
+            LibString.toString(participants),
+            "</text></g>"
+        );
+    }
+    function generateRankBorder(uint32 rank) private pure returns (string memory svg) {
+        string memory color;
+        if (rank == 1) {
+            color = "rgba(255,215,0,1.0)";
+        } else if (rank == 2) {
+            color = "rgba(255,255,255,1.0)";
+        } else if (rank == 3) {
+            color = "rgba(205,127,50,1.0)";
+        } else {
+            color = "rgba(255,255,255,0.2)";
+        }
+        svg = string.concat(
+            '<rect x="16" y="16" width="258" height="468" rx="26" ry="26" fill="rgba(0,0,0,0)" stroke="', color, '"/>'
+        );
+    }
+    function generateSvgCurve(string memory challengeSVG) private pure returns (string memory svg) {
+        svg = string.concat('<g mask="url(#none)"', ' style="transform:translate(30px,130px)">', challengeSVG, "</g>");
+    }
+    function generateSVGPositionDataAndLocationCurve(string memory tokenId, uint256 gasUsed, uint256 gasOpti)
+        private
+        pure
+        returns (string memory svg)
+    {
+        string memory gasUsedStr = LibString.toString(gasUsed);
+        string memory gasOptiStr = LibString.toString(gasOpti);
+        uint256 str1length = bytes(tokenId).length + 4;
+        uint256 str2length = bytes(gasUsedStr).length + 10;
+        uint256 str3length = bytes(gasOptiStr).length + 14;
+        svg = string.concat(
+            '<g font-family="\'Courier New\', monospace" font-size="12" fill="#fff">'
+            '<g style="transform:translate(29px, 384px)">' '<rect width="',
+            LibString.toString(uint256(7 * (str1length + 4))),
+            string.concat('" height="26" rx="8" ry="8" fill="rgba(0,0,0,0.6)"/>' '<text x="12" y="17"><tspan fill="#999">ID: </tspan>'),
+            tokenId,
+            "</text></g>" '<g style="transform:translate(29px, 414px)">' '<rect width="',
+            LibString.toString(uint256(7 * (str2length + 4))),
+            '" height="26" rx="8" ry="8" fill="rgba(0,0,0,0.6)"/>'
+            '<text x="12" y="17"><tspan fill="#999">Gas used: </tspan>',
+            gasUsedStr,
+            "</text></g>" '<g style="transform:translate(29px, 444px)">' '<rect width="',
+            LibString.toString(uint256(7 * (str3length + 4))),
+            '" height="26" rx="8" ry="8" fill="rgba(0,0,0,0.6)"/>'
+            '<text x="12" y="17"><tspan fill="#999">Improvement: </tspan>',
+            gasOptiStr,
+            "%" "</text></g></g>"
+        );
+    }
+    function generateOptimizorIcon() private pure returns (string memory svg) {
+        return
+        '<g style="transform:translate(180px, 365px)"><rect style="filter: url(#icon)" x="0" y="0" width="83" height="64"/></g>';
+    }
+    function getCircleCoord(address tokenAddress, uint256 offset, uint256 tokenId) internal pure returns (uint8) {
+        unchecked {
+            return uint8((((uint256(uint160(tokenAddress)) >> offset) & 0xFF) * tokenId) % 255);
+        }
+    }
+}
+library LibString {
+    function toString(uint256 value) internal pure returns (string memory str) {
+        assembly {
+            let newFreeMemoryPointer := add(mload(0x40), 160)
+            mstore(0x40, newFreeMemoryPointer)
+            str := sub(newFreeMemoryPointer, 32)
+            mstore(str, 0)
+            let end := str
+            for { let temp := value } 1 {} {
+                str := sub(str, 1)
+                mstore8(str, add(48, mod(temp, 10)))
+                temp := div(temp, 10)
+                if iszero(temp) { break }
+            }
+            let length := sub(end, str)
+            str := sub(str, 32)
+            mstore(str, length)
+        }
+    }
+}
+abstract contract Owned {
+    event OwnershipTransferred(address indexed user, address indexed newOwner);
+    address public owner;
+    modifier onlyOwner() virtual {
+        require(msg.sender == owner, "UNAUTHORIZED");
+        _;
+    }
+    constructor(address _owner) {
+        owner = _owner;
+        emit OwnershipTransferred(address(0), _owner);
+    }
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        owner = newOwner;
+        emit OwnershipTransferred(msg.sender, newOwner);
+    }
+}
+abstract contract ERC721 {
+    event Transfer(address indexed from, address indexed to, uint256 indexed id);
+    event Approval(address indexed owner, address indexed spender, uint256 indexed id);
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+    string public name;
+    string public symbol;
+    function tokenURI(uint256 id) public view virtual returns (string memory);
+    mapping(uint256 => address) internal _ownerOf;
+    mapping(address => uint256) internal _balanceOf;
+    function ownerOf(uint256 id) public view virtual returns (address owner) {
+        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
+    }
+    function balanceOf(address owner) public view virtual returns (uint256) {
+        require(owner != address(0), "ZERO_ADDRESS");
+        return _balanceOf[owner];
+    }
+    mapping(uint256 => address) public getApproved;
+    mapping(address => mapping(address => bool)) public isApprovedForAll;
+    constructor(string memory _name, string memory _symbol) {
+        name = _name;
+        symbol = _symbol;
+    }
+    function approve(address spender, uint256 id) public virtual {
+        address owner = _ownerOf[id];
+        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
+        getApproved[id] = spender;
+        emit Approval(owner, spender, id);
+    }
+    function setApprovalForAll(address operator, bool approved) public virtual {
+        isApprovedForAll[msg.sender][operator] = approved;
+        emit ApprovalForAll(msg.sender, operator, approved);
+    }
+    function transferFrom(
+        address from,
+        address to,
+        uint256 id
+    ) public virtual {
+        require(from == _ownerOf[id], "WRONG_FROM");
+        require(to != address(0), "INVALID_RECIPIENT");
+        require(
+            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
+            "NOT_AUTHORIZED"
+        );
+        unchecked {
+            _balanceOf[from]--;
+            _balanceOf[to]++;
+        }
+        _ownerOf[id] = to;
+        delete getApproved[id];
+        emit Transfer(from, to, id);
+    }
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id
+    ) public virtual {
+        transferFrom(from, to, id);
+        require(
+            to.code.length == 0 ||
+                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
+                ERC721TokenReceiver.onERC721Received.selector,
+            "UNSAFE_RECIPIENT"
+        );
+    }
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id,
+        bytes calldata data
+    ) public virtual {
+        transferFrom(from, to, id);
+        require(
+            to.code.length == 0 ||
+                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
+                ERC721TokenReceiver.onERC721Received.selector,
+            "UNSAFE_RECIPIENT"
+        );
+    }
+    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
+        return
+            interfaceId == 0x01ffc9a7 ||
+            interfaceId == 0x80ac58cd ||
+            interfaceId == 0x5b5e139f;
+    }
+    function _mint(address to, uint256 id) internal virtual {
+        require(to != address(0), "INVALID_RECIPIENT");
+        require(_ownerOf[id] == address(0), "ALREADY_MINTED");
+        unchecked {
+            _balanceOf[to]++;
+        }
+        _ownerOf[id] = to;
+        emit Transfer(address(0), to, id);
+    }
+    function _burn(uint256 id) internal virtual {
+        address owner = _ownerOf[id];
+        require(owner != address(0), "NOT_MINTED");
+        unchecked {
+            _balanceOf[owner]--;
+        }
+        delete _ownerOf[id];
+        delete getApproved[id];
+        emit Transfer(owner, address(0), id);
+    }
+    function _safeMint(address to, uint256 id) internal virtual {
+        _mint(to, id);
+        require(
+            to.code.length == 0 ||
+                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
+                ERC721TokenReceiver.onERC721Received.selector,
+            "UNSAFE_RECIPIENT"
+        );
+    }
+    function _safeMint(
+        address to,
+        uint256 id,
+        bytes memory data
+    ) internal virtual {
+        _mint(to, id);
+        require(
+            to.code.length == 0 ||
+                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
+                ERC721TokenReceiver.onERC721Received.selector,
+            "UNSAFE_RECIPIENT"
+        );
+    }
+}
+abstract contract ERC721TokenReceiver {
+    function onERC721Received(
+        address,
+        address,
+        uint256,
+        bytes calldata
+    ) external virtual returns (bytes4) {
+        return ERC721TokenReceiver.onERC721Received.selector;
+    }
+}
+abstract contract OptimizorNFT is ERC721 {
+    error InvalidSolutionId(uint256 challengeId, uint32 solutionId);
+    error ChallengeNotFound(uint256 challengeId);
+    struct ChallengeInfo {
+        IChallenge target;
+        uint32 solutions;
+    }
+    struct ExtraDetails {
+        address code;
+        address solver;
+        uint32 gas;
+    }
+    mapping(uint256 => ChallengeInfo) public challenges;
+    mapping(uint256 => ExtraDetails) public extraDetails;
+    constructor() ERC721("Optimizor Club", "OC") {}
+    function contractURI() external pure returns (string memory) {
+        return
+        "data:application/json;base64,eyJuYW1lIjoiT3B0aW1pem9yIENsdWIiLCJkZXNjcmlwdGlvbiI6IlRoZSBPcHRpbWl6b3IgQ2x1YiBORlQgY29sbGVjdGlvbiByZXdhcmRzIGdhcyBlZmZpY2llbnQgcGVvcGxlIGFuZCBtYWNoaW5lcyBieSBtaW50aW5nIG5ldyBpdGVtcyB3aGVuZXZlciBhIGNoZWFwZXIgc29sdXRpb24gaXMgc3VibWl0dGVkIGZvciBhIGNlcnRhaW4gY2hhbGxlbmdlLiIsImltYWdlIjoiZGF0YTppbWFnZS9zdmcreG1sO2Jhc2U2NCxQSE4yWnlCM2FXUjBhRDBpTVRZMkxqVTVOeUlnYUdWcFoyaDBQU0l4TWpndU9UUXhJaUIyYVdWM1FtOTRQU0l3SURBZ05EUXVNRGM1SURNMExqRXhOaUlnZUcxc2JuTTlJbWgwZEhBNkx5OTNkM2N1ZHpNdWIzSm5Mekl3TURBdmMzWm5JajQ4Y0dGMGFDQmtQU0pOTWpBdU56a3pJREV6TGpNeU1XZ3RMall5TTFZeE1pNDNhQzAyTGpJeU5YWXVOakl5YUM0Mk1qSjJMall5TTJndExqWXlNbll1TmpJeWFDMHVOakl6ZGkwdU5qSXlTREV5TGpkMk5pNHlNalZvTGpZeU1uWXVOakl6YUM0Mk1qTjJMall5TW1nMkxqSXlOWFl0TGpZeU1tZ3VOakl6ZGkwdU5qSXphQzQyTWpKMkxUWXVNakkxYUMwdU5qSXllbTB0TXk0M016VWdOUzQyTUROMkxUUXVNelU0YURFdU9EWTNkalF1TXpVNGVtMHhNeTQyT1RndE5pNHlNalZvTFRZdU9EUTRkaTQyTWpKb0xqWXlNM1l1TmpJemFDMHVOakl6ZGk0Mk1qSm9MUzQyTWpKMkxTNDJNakpvTFM0Mk1qTjJOaTR5TWpWb0xqWXlNM1l1TmpJemFDNDJNakoyTGpZeU1tZzJMamcwT0hZdExqWXlNbWd1TmpJeWRpMHhMakkwTldndExqWXlNbll0TGpZeU0wZ3lOeTR3TW5ZdE5DNHpOVGhvTXk0M016VjJMUzQyTWpKb0xqWXlNbll0TGpZeU0yZ3RMall5TW5vaUlITjBlV3hsUFNKbWFXeHNPaU0yTmpZaUx6NDhMM04yWno0PSIsImV4dGVybmFsX2xpbmsiOiJodHRwczovL29wdGltaXpvci5jbHViLyJ9";
+    }
+    function tokenDetails(uint256 tokenId) public view returns (TokenDetails memory) {
+        (uint256 challengeId, uint32 solutionId) = unpackTokenId(tokenId);
+        if (solutionId == 0) revert InvalidSolutionId(challengeId, solutionId);
+        ChallengeInfo storage chl = challenges[challengeId];
+        if (address(chl.target) == address(0)) revert ChallengeNotFound(challengeId);
+        if (solutionId > chl.solutions) revert InvalidSolutionId(challengeId, solutionId);
+        ExtraDetails storage details = extraDetails[tokenId];
+        uint256 leaderTokenId = packTokenId(challengeId, chl.solutions);
+        ExtraDetails storage leaderDetails = extraDetails[leaderTokenId];
+        uint32 leaderSolutionId = chl.solutions;
+        uint32 rank = leaderSolutionId - solutionId + 1;
+        uint32 percentage = 0;
+        if (solutionId > 1) {
+            ExtraDetails storage prevDetails = extraDetails[tokenId - 1];
+            percentage = (details.gas * 100) / prevDetails.gas;
+        }
+        return TokenDetails({
+            challengeId: challengeId,
+            challenge: chl.target,
+            leaderGas: leaderDetails.gas,
+            leaderSolutionId: leaderSolutionId,
+            leaderSolver: leaderDetails.solver,
+            leaderOwner: _ownerOf[leaderTokenId],
+            leaderSubmission: leaderDetails.code,
+            gas: details.gas,
+            solutionId: solutionId,
+            rank: rank,
+            improvementPercentage: percentage,
+            solver: details.solver,
+            owner: _ownerOf[tokenId],
+            submission: details.code
+        });
+    }
+    function tokenURI(uint256 tokenId) public view override returns (string memory) {
+        TokenDetails memory details = tokenDetails(tokenId);
+        string memory description = string.concat(details.challenge.description(), "\\n\\n", leaderboardString(tokenId));
+        return string.concat(
+            "data:application/json;base64,",
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        '{"name":"Optimizor Club: ',
+                        details.challenge.name(),
+                        '","description":"',
+                        description,
+                        '","attributes":',
+                        attributesJSON(details),
+                        ',"image":"data:image/svg+xml;base64,',
+                        Base64.encode(bytes(svg(tokenId, details))),
+                        '"}'
+                    )
+                )
+            )
+        );
+    }
+    function leaderboard(uint256 tokenId) public view returns (address[] memory board) {
+        (uint256 challengeId,) = unpackTokenId(tokenId);
+        uint32 winners = challenges[challengeId].solutions;
+        board = new address[](winners);
+        unchecked {
+            for (uint32 i = 1; i <= winners; ++i) {
+                ExtraDetails storage details = extraDetails[packTokenId(challengeId, i)];
+                board[i - 1] = details.solver;
+            }
+        }
+    }
+    function leaderboardString(uint256 tokenId) private view returns (string memory) {
+        address[] memory leaders = leaderboard(tokenId);
+        string memory leadersStr = "";
+        uint256 lIdx = leaders.length;
+        unchecked {
+            for (uint256 i = 0; i < leaders.length; ++i) {
+                leadersStr = string.concat(
+                    "\\n",
+                    LibString.toString(lIdx),
+                    ". ",
+                    HexString.toHexString(uint256(uint160(leaders[i])), 20),
+                    leadersStr
+                );
+                --lIdx;
+            }
+        }
+        return string.concat("Leaderboard:\\n", leadersStr);
+    }
+    function attributesJSON(TokenDetails memory details) private view returns (string memory attributes) {
+        uint32 rank = details.rank;
+        attributes = string.concat(
+            '[{"trait_type":"Challenge","value":"',
+            details.challenge.name(),
+            '"},{"trait_type":"Gas used","value":',
+            LibString.toString(details.gas),
+            ',"display_type":"number"},{"trait_type":"Code size","value":',
+            LibString.toString(details.submission.code.length),
+            ',"display_type":"number"},{"trait_type":"Improvement percentage","value":"',
+            LibString.toString(details.improvementPercentage),
+            '%"},{"trait_type":"Solver","value":"',
+            HexString.toHexString(uint256(uint160(details.solver)), 20),
+            '"},{"trait_type":"Rank","value":',
+            LibString.toString(rank),
+            ',"display_type":"number"},{"trait_type":"Leader","value":"',
+            (rank == 1) ? "Yes" : "No",
+            '"},{"trait_type":"Top 3","value":"',
+            (rank <= 3) ? "Yes" : "No",
+            '"},{"trait_type":"Top 10","value":"',
+            (rank <= 10) ? "Yes" : "No",
+            '"}]'
+        );
+    }
+    function scale(uint8 value, uint256 minOut, uint256 maxOut) private pure returns (uint256) {
+        unchecked {
+            return ((uint256(value) * (maxOut - minOut)) / 255) + minOut;
+        }
+    }
+    function svg(uint256 tokenId, TokenDetails memory details) private view returns (string memory) {
+        uint256 gradRgb = 0;
+        if (details.rank > 10) {
+            gradRgb = 0xbebebe;
+        } else if (details.rank > 3) {
+            uint256 fRank;
+            uint256 init = 40;
+            uint256 factor = 15;
+            unchecked {
+                fRank = init + details.rank * factor;
+            }
+            gradRgb = (uint256(fRank) << 16) | (uint256(fRank) << 8) | uint256(fRank);
+        }
+        NFTSVG.SVGParams memory svgParams = NFTSVG.SVGParams({
+            projectName: "Optimizor Club",
+            challengeName: details.challenge.name(),
+            solverAddr: HexString.toHexString(uint256(uint160(address(details.owner))), 20),
+            challengeAddr: HexString.toHexString(uint256(uint160(address(details.challenge))), 20),
+            gasUsed: details.gas,
+            gasOpti: details.improvementPercentage,
+            tokenId: tokenId,
+            rank: details.rank,
+            participants: details.leaderSolutionId,
+            color: HexString.toHexStringNoPrefix(gradRgb, 3),
+            x1: scale(NFTSVG.getCircleCoord(address(details.challenge), 16, tokenId), 16, 274),
+            y1: scale(NFTSVG.getCircleCoord(address(details.solver), 16, tokenId), 100, 484),
+            x2: scale(NFTSVG.getCircleCoord(address(details.challenge), 32, tokenId), 16, 274),
+            y2: scale(NFTSVG.getCircleCoord(address(details.solver), 32, tokenId), 100, 484),
+            x3: scale(NFTSVG.getCircleCoord(address(details.challenge), 48, tokenId), 16, 274),
+            y3: scale(NFTSVG.getCircleCoord(address(details.solver), 48, tokenId), 100, 484)
+        });
+        return NFTSVG.generateSVG(svgParams, details.challenge.svg(tokenId));
+    }
+}
+abstract contract OptimizorAdmin is OptimizorNFT, Owned {
+    PurityChecker public purityChecker;
+    error ChallengeExists(uint256 challengeId);
+    event PurityCheckerUpdated(PurityChecker newPurityChecker);
+    event ChallengeAdded(uint256 challengeId, IChallenge);
+    constructor(PurityChecker _purityChecker) Owned(msg.sender) {
+        updatePurityChecker(_purityChecker);
+    }
+    function updatePurityChecker(PurityChecker _purityChecker) public onlyOwner {
+        purityChecker = _purityChecker;
+        emit PurityCheckerUpdated(_purityChecker);
+    }
+    function addChallenge(uint256 id, IChallenge challenge) external onlyOwner {
+        ChallengeInfo storage chl = challenges[id];
+        if (address(chl.target) != address(0)) {
+            revert ChallengeExists(id);
+        }
+        chl.target = challenge;
+        emit ChallengeAdded(id, challenge);
+    }
+}
+uint256 constant EPOCH = 64;
+contract Optimizor is OptimizorAdmin {
+    struct Submission {
+        address sender;
+        uint96 blockNumber;
+    }
+    mapping(bytes32 => Submission) public submissions;
+    error CodeAlreadySubmitted();
+    error TooEarlyToChallenge();
+    error InvalidRecipient();
+    error CodeNotSubmitted();
+    error NotPure();
+    error NotOptimizor();
+    constructor(PurityChecker _purityChecker) OptimizorAdmin(_purityChecker) {}
+    function commit(bytes32 key) external {
+        if (submissions[key].sender != address(0)) {
+            revert CodeAlreadySubmitted();
+        }
+        submissions[key] = Submission({sender: msg.sender, blockNumber: uint96(block.number)});
+    }
+    function challenge(uint256 id, address target, address recipient, uint256 salt) external {
+        ChallengeInfo storage chl = challenges[id];
+        bytes32 key = keccak256(abi.encode(msg.sender, target.codehash, salt));
+        if (submissions[key].blockNumber + EPOCH >= block.number) {
+            revert TooEarlyToChallenge();
+        }
+        if (submissions[key].sender == address(0)) {
+            revert CodeNotSubmitted();
+        }
+        if (address(chl.target) == address(0)) {
+            revert ChallengeNotFound(id);
+        }
+        if (recipient == address(0)) {
+            revert InvalidRecipient();
+        }
+        if (!purityChecker.check(target)) {
+            revert NotPure();
+        }
+        uint32 gas = chl.target.run(target, block.difficulty);
+        uint256 leaderTokenId = packTokenId(id, chl.solutions);
+        uint32 leaderGas = extraDetails[leaderTokenId].gas;
+        if ((leaderGas != 0) && (leaderGas <= gas)) {
+            revert NotOptimizor();
+        }
+        unchecked {
+            ++chl.solutions;
+        }
+        uint256 tokenId = packTokenId(id, chl.solutions);
+        ERC721._mint(recipient, tokenId);
+        extraDetails[tokenId] = ExtraDetails(target, recipient, gas);
+    }
+}
\ No newline at end of file
diff --git a/compiler/test/benchmarks/chains.sol b/compiler/test/benchmarks/chains.sol
new file mode 100644
index 00000000..344cfff2
--- /dev/null
+++ b/compiler/test/benchmarks/chains.sol
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// This is an adapted version of StdCheats by foundry:
+// https://github.com/foundry-rs/forge-std/blob/master/src/StdCheats.sol
+contract StdCheatsSafe {
+    struct Chain {
+        string name;
+        uint256 chainId;
+        string rpcUrl;
+    }
+
+    struct Chains {
+        Chain Anvil;
+        Chain Hardhat;
+        Chain Mainnet;
+        Chain Goerli;
+        Chain Sepolia;
+        Chain Optimism;
+        Chain OptimismGoerli;
+        Chain ArbitrumOne;
+        Chain ArbitrumOneGoerli;
+        Chain ArbitrumNova;
+        Chain Polygon;
+        Chain PolygonMumbai;
+        Chain Avalanche;
+        Chain AvalancheFuji;
+        Chain BnbSmartChain;
+        Chain BnbSmartChainTestnet;
+        Chain GnosisChain;
+    }
+
+    Chains stdChains;
+
+    function f(string[2][] memory rpcs) public returns (uint256) {
+        stdChains = Chains({
+            Anvil: Chain("Anvil", 31337, "http://127.0.0.1:8545"),
+            Hardhat: Chain("Hardhat", 31337, "http://127.0.0.1:8545"),
+            Mainnet: Chain("Mainnet", 1, "https://api.mycryptoapi.com/eth"),
+            Goerli: Chain("Goerli", 5, "https://goerli.infura.io/v3/84842078b09946638c03157f83405213"),
+            Sepolia: Chain("Sepolia", 11155111, "https://rpc.sepolia.dev"),
+            Optimism: Chain("Optimism", 10, "https://mainnet.optimism.io"),
+            OptimismGoerli: Chain("OptimismGoerli", 420, "https://goerli.optimism.io"),
+            ArbitrumOne: Chain("ArbitrumOne", 42161, "https://arb1.arbitrum.io/rpc"),
+            ArbitrumOneGoerli: Chain("ArbitrumOneGoerli", 421613, "https://goerli-rollup.arbitrum.io/rpc"),
+            ArbitrumNova: Chain("ArbitrumNova", 42170, "https://nova.arbitrum.io/rpc"),
+            Polygon: Chain("Polygon", 137, "https://polygon-rpc.com"),
+            PolygonMumbai: Chain("PolygonMumbai", 80001, "https://rpc-mumbai.matic.today"),
+            Avalanche: Chain("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"),
+            AvalancheFuji: Chain("AvalancheFuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc"),
+            BnbSmartChain: Chain("BnbSmartChain", 56, "https://bsc-dataseed1.binance.org"),
+            BnbSmartChainTestnet: Chain("BnbSmartChainTestnet", 97, "https://data-seed-prebsc-1-s1.binance.org:8545"),
+            GnosisChain: Chain("GnosisChain", 100, "https://rpc.gnosischain.com")
+        });
+
+        for (uint256 i = 0; i < rpcs.length; i++) {
+            (string memory name, string memory rpcUrl) = (rpcs[i][0], rpcs[i][1]);
+            // forgefmt: disable-start
+            if (isEqual(name, "anvil")) stdChains.Anvil.rpcUrl = rpcUrl;
+            else if (isEqual(name, "hardhat")) stdChains.Hardhat.rpcUrl = rpcUrl;
+            else if (isEqual(name, "mainnet")) stdChains.Mainnet.rpcUrl = rpcUrl;
+            else if (isEqual(name, "goerli")) stdChains.Goerli.rpcUrl = rpcUrl;
+            else if (isEqual(name, "sepolia")) stdChains.Sepolia.rpcUrl = rpcUrl;
+            else if (isEqual(name, "optimism")) stdChains.Optimism.rpcUrl = rpcUrl;
+            else if (isEqual(name, "optimism_goerli", "optimism-goerli")) stdChains.OptimismGoerli.rpcUrl = rpcUrl;
+            else if (isEqual(name, "arbitrum_one", "arbitrum-one")) stdChains.ArbitrumOne.rpcUrl = rpcUrl;
+            else if (isEqual(name, "arbitrum_one_goerli", "arbitrum-one-goerli")) stdChains.ArbitrumOneGoerli.rpcUrl = rpcUrl;
+            else if (isEqual(name, "arbitrum_nova", "arbitrum-nova")) stdChains.ArbitrumNova.rpcUrl = rpcUrl;
+            else if (isEqual(name, "polygon")) stdChains.Polygon.rpcUrl = rpcUrl;
+            else if (isEqual(name, "polygon_mumbai", "polygon-mumbai")) stdChains.PolygonMumbai.rpcUrl = rpcUrl;
+            else if (isEqual(name, "avalanche")) stdChains.Avalanche.rpcUrl = rpcUrl;
+            else if (isEqual(name, "avalanche_fuji", "avalanche-fuji")) stdChains.AvalancheFuji.rpcUrl = rpcUrl;
+            else if (isEqual(name, "bnb_smart_chain", "bnb-smart-chain")) stdChains.BnbSmartChain.rpcUrl = rpcUrl;
+            else if (isEqual(name, "bnb_smart_chain_testnet", "bnb-smart-chain-testnet")) stdChains.BnbSmartChainTestnet.rpcUrl = rpcUrl;
+            else if (isEqual(name, "gnosis_chain", "gnosis-chain")) stdChains.GnosisChain.rpcUrl = rpcUrl;
+            // forgefmt: disable-end
+        }
+        return 0;
+    }
+
+    function isEqual(string memory a, string memory b) private pure returns (bool) {
+        return keccak256(abi.encode(a)) == keccak256(abi.encode(b));
+    }
+
+    function isEqual(string memory a, string memory b, string memory c) private pure returns (bool) {
+        return keccak256(abi.encode(a)) == keccak256(abi.encode(b))
+            || keccak256(abi.encode(a)) == keccak256(abi.encode(c));
+    }
+}
+
+
diff --git a/compiler/test/benchmarks/run.sh b/compiler/test/benchmarks/run.sh
new file mode 100755
index 00000000..ef1c146f
--- /dev/null
+++ b/compiler/test/benchmarks/run.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+
+#------------------------------------------------------------------------------
+# Bash script to run optimizer performance tests.
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -euo pipefail
+
+REPO_ROOT=$(cd "$(dirname "$0")/../../" && pwd)
+SOLIDITY_BUILD_DIR=${SOLIDITY_BUILD_DIR:-${REPO_ROOT}/build}
+
+output_dir=$(mktemp -d -t solc-benchmark-XXXXXX)
+result_legacy_file="${output_dir}/benchmark-legacy.txt"
+result_via_ir_file="${output_dir}/benchmark-via-ir.txt"
+warnings_and_errors_file="${output_dir}/benchmark-warn-err.txt"
+
+function cleanup() {
+    rm -r "${output_dir}"
+    exit
+}
+
+trap cleanup SIGINT SIGTERM
+
+solc="${SOLIDITY_BUILD_DIR}/solc/solc"
+benchmarks_dir="${REPO_ROOT}/test/benchmarks"
+benchmarks=("chains.sol" "OptimizorClub.sol" "verifier.sol")
+time_bin_path=$(type -P time)
+
+for input_file in "${benchmarks[@]}"
+do
+    input_path="${benchmarks_dir}/${input_file}"
+
+    solc_command_legacy=("${solc}" --optimize --bin --color "${input_path}")
+    solc_command_via_ir=("${solc}" --via-ir --optimize --bin --color "${input_path}")
+
+    # Legacy can fail.
+    "${time_bin_path}" --output "${result_legacy_file}" --format "%e" "${solc_command_legacy[@]}" >/dev/null 2>>"${warnings_and_errors_file}"
+    "${time_bin_path}" --output "${result_via_ir_file}" --format "%e" "${solc_command_via_ir[@]}" >/dev/null 2>>"${warnings_and_errors_file}"
+
+    time_legacy=$(<"${result_legacy_file}")
+    time_via_ir=$(<"${result_via_ir_file}")
+
+    echo "======================================================="
+    echo "            ${input_file}"
+    echo "-------------------------------------------------------"
+    echo "legacy pipeline took ${time_legacy} seconds to execute."
+    echo "via-ir pipeline took ${time_via_ir} seconds to execute."
+    echo "======================================================="
+done
+
+echo
+echo "======================================================="
+echo "Warnings and errors generated during run:"
+echo "======================================================="
+echo "$(<"${warnings_and_errors_file}")"
+
+cleanup
+
diff --git a/compiler/test/benchmarks/verifier.sol b/compiler/test/benchmarks/verifier.sol
new file mode 100644
index 00000000..dcfc97ab
--- /dev/null
+++ b/compiler/test/benchmarks/verifier.sol
@@ -0,0 +1,208 @@
+// This file is MIT Licensed.
+//
+// Copyright 2017 Christian Reitwiessner
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+pragma solidity ^0.8.0;
+library Pairing {
+    struct G1Point {
+        uint X;
+        uint Y;
+    }
+    // Encoding of field elements is: X[0] * z + X[1]
+    struct G2Point {
+        uint[2] X;
+        uint[2] Y;
+    }
+    /// @return the generator of G1
+    function P1() pure internal returns (G1Point memory) {
+        return G1Point(1, 2);
+    }
+    /// @return the generator of G2
+    function P2() pure internal returns (G2Point memory) {
+        return G2Point(
+            [10857046999023057135944570762232829481370756359578518086990519993285655852781,
+             11559732032986387107991004021392285783925812861821192530917403151452391805634],
+            [8495653923123431417604973247489272438418190587263600148770280649306958101930,
+             4082367875863433681332203403145435568316851327593401208105741076214120093531]
+        );
+    }
+    /// @return the negation of p, i.e. p.addition(p.negate()) should be zero.
+    function negate(G1Point memory p) pure internal returns (G1Point memory) {
+        // The prime q in the base field F_q for G1
+        uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+        if (p.X == 0 && p.Y == 0)
+            return G1Point(0, 0);
+        return G1Point(p.X, q - (p.Y % q));
+    }
+    /// @return r the sum of two points of G1
+    function addition(G1Point memory p1, G1Point memory p2) internal view returns (G1Point memory r) {
+        uint[4] memory input;
+        input[0] = p1.X;
+        input[1] = p1.Y;
+        input[2] = p2.X;
+        input[3] = p2.Y;
+        bool success;
+        assembly {
+            success := staticcall(sub(gas(), 2000), 6, input, 0xc0, r, 0x60)
+            // Use "invalid" to make gas estimation work
+            switch success case 0 { invalid() }
+        }
+        require(success);
+    }
+
+
+    /// @return r the product of a point on G1 and a scalar, i.e.
+    /// p == p.scalar_mul(1) and p.addition(p) == p.scalar_mul(2) for all points p.
+    function scalar_mul(G1Point memory p, uint s) internal view returns (G1Point memory r) {
+        uint[3] memory input;
+        input[0] = p.X;
+        input[1] = p.Y;
+        input[2] = s;
+        bool success;
+        assembly {
+            success := staticcall(sub(gas(), 2000), 7, input, 0x80, r, 0x60)
+            // Use "invalid" to make gas estimation work
+            switch success case 0 { invalid() }
+        }
+        require (success);
+    }
+    /// @return the result of computing the pairing check
+    /// e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
+    /// For example pairing([P1(), P1().negate()], [P2(), P2()]) should
+    /// return true.
+    function pairing(G1Point[] memory p1, G2Point[] memory p2) internal view returns (bool) {
+        require(p1.length == p2.length);
+        uint elements = p1.length;
+        uint inputSize = elements * 6;
+        uint[] memory input = new uint[](inputSize);
+        for (uint i = 0; i < elements; i++)
+        {
+            input[i * 6 + 0] = p1[i].X;
+            input[i * 6 + 1] = p1[i].Y;
+            input[i * 6 + 2] = p2[i].X[1];
+            input[i * 6 + 3] = p2[i].X[0];
+            input[i * 6 + 4] = p2[i].Y[1];
+            input[i * 6 + 5] = p2[i].Y[0];
+        }
+        uint[1] memory out;
+        bool success;
+        assembly {
+            success := staticcall(sub(gas(), 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
+            // Use "invalid" to make gas estimation work
+            switch success case 0 { invalid() }
+        }
+        require(success);
+        return out[0] != 0;
+    }
+    /// Convenience method for a pairing check for two pairs.
+    function pairingProd2(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2) internal view returns (bool) {
+        G1Point[] memory p1 = new G1Point[](2);
+        G2Point[] memory p2 = new G2Point[](2);
+        p1[0] = a1;
+        p1[1] = b1;
+        p2[0] = a2;
+        p2[1] = b2;
+        return pairing(p1, p2);
+    }
+    /// Convenience method for a pairing check for three pairs.
+    function pairingProd3(
+            G1Point memory a1, G2Point memory a2,
+            G1Point memory b1, G2Point memory b2,
+            G1Point memory c1, G2Point memory c2
+    ) internal view returns (bool) {
+        G1Point[] memory p1 = new G1Point[](3);
+        G2Point[] memory p2 = new G2Point[](3);
+        p1[0] = a1;
+        p1[1] = b1;
+        p1[2] = c1;
+        p2[0] = a2;
+        p2[1] = b2;
+        p2[2] = c2;
+        return pairing(p1, p2);
+    }
+    /// Convenience method for a pairing check for four pairs.
+    function pairingProd4(
+            G1Point memory a1, G2Point memory a2,
+            G1Point memory b1, G2Point memory b2,
+            G1Point memory c1, G2Point memory c2,
+            G1Point memory d1, G2Point memory d2
+    ) internal view returns (bool) {
+        G1Point[] memory p1 = new G1Point[](4);
+        G2Point[] memory p2 = new G2Point[](4);
+        p1[0] = a1;
+        p1[1] = b1;
+        p1[2] = c1;
+        p1[3] = d1;
+        p2[0] = a2;
+        p2[1] = b2;
+        p2[2] = c2;
+        p2[3] = d2;
+        return pairing(p1, p2);
+    }
+}
+
+contract Verifier {
+    using Pairing for *;
+    struct VerifyingKey {
+        Pairing.G1Point alpha;
+        Pairing.G2Point beta;
+        Pairing.G2Point gamma;
+        Pairing.G2Point delta;
+        Pairing.G1Point[] gamma_abc;
+    }
+    struct Proof {
+        Pairing.G1Point a;
+        Pairing.G2Point b;
+        Pairing.G1Point c;
+    }
+    function verifyingKey() pure internal returns (VerifyingKey memory vk) {
+        vk.alpha = Pairing.G1Point(uint256(0x1e19a8a58ad52243374aeded373b7e89656ea339b9fa8ace98dd5fb221885ea2), uint256(0x2e66a9a67f1a9060a51da039c91c3402d1f46b71bbf10c7348ac4f13c3906736));
+        vk.beta = Pairing.G2Point([uint256(0x1ca3e556290187c64a1057061f419a078dc71353f6af1066c03d7e1448bbc119), uint256(0x2bbc1b80e59743b489ec811b4ebf30a1ff540c2c37ced63d360b94f92f0a41fb)], [uint256(0x07eceb98d2fb10fa7363b45f51aa3d3ef3d511b482790645039a2562e2070f30), uint256(0x1c3e076d2aaf914abd6a49b72c4205669d3d1cbe4a4bf97b9ee49ac0fbbdbda9)]);
+        vk.gamma = Pairing.G2Point([uint256(0x222c0019521d3e52881431be17cacaf8a7379398dd0833f60a2ac45f1c3fcd42), uint256(0x1018dbb94cd920bd55af4e2b12a9f740c6b38748a163b5dbd37c5ef6cf74708f)], [uint256(0x18bf34dc86b549a92f316f7a32070a3ce45a0f38fa45dda1162c4b6498baf286), uint256(0x12848d5a670b6102d5bd45d2b8250d50361001ea335ff6a1405a52504c22b8ac)]);
+        vk.delta = Pairing.G2Point([uint256(0x13b8e16c40a6a299ea42107a97f881f9fa89986dcd5234ecb6919caf756ac1cb), uint256(0x25b64e4978690cd7cb531dbab0119148c96f5fc0c984c0cafb290bb75f033a09)], [uint256(0x1758eaa970929deff5e96e5852d21790c32591dbb13bc63e3df046f0271479a4), uint256(0x14d0b4222ad1710c6330e4bd8ad8f0d7b8f4cff0a37793d53001800e49f41192)]);
+        vk.gamma_abc = new Pairing.G1Point[](9);
+        vk.gamma_abc[0] = Pairing.G1Point(uint256(0x0925dc800d3a577859439a049f8ed0ae7a37dcd36652de478d662c08907a7626), uint256(0x1f7f76e299220ebf3da17bb415d25e6574e142391972dbd1513cf81341975cb5));
+        vk.gamma_abc[1] = Pairing.G1Point(uint256(0x0e67dddfd91adad72376c56cbd98d5cfa4df5217d6115ff26ec741d0154f0bd8), uint256(0x0b97b2ddfdf4c31916d98e384bee3b24bfa0fc59a21ab489153f4dcd1a9a48ca));
+        vk.gamma_abc[2] = Pairing.G1Point(uint256(0x1416b354665883cbbc5f5541012d1f8dd87ebb4415b3ee431be0804fff290bbf), uint256(0x1a284dd2eff43e6cb5aaea43dd9bee022ef0c91d90d0803cf5f7e4677e94a271));
+        vk.gamma_abc[3] = Pairing.G1Point(uint256(0x2526852e7f009b4afa1fe0e1d30334c6e516fac223866b81a830b472164bdfe7), uint256(0x28adf6fbe54ba40afa91555c18477ad3a2f0a460f68d55a15b4e0c264b9c11c2));
+        vk.gamma_abc[4] = Pairing.G1Point(uint256(0x22feae4a12bfb751638cd76b2373e84884ba4adef575ea14ed50c5954d31d410), uint256(0x108c3da0ffd7eda1fe7789e41693146beb979bd1644b19bbd517742ca3841348));
+        vk.gamma_abc[5] = Pairing.G1Point(uint256(0x081477a5c52f41533cf6ca4f778ab922d59ba44b5a5e3fbdbf34ed8dc1a47a8d), uint256(0x0f2624780bd75b9f6c47f7bee582d02f1f983529b8aa9493ca848e38f2ec8447));
+        vk.gamma_abc[6] = Pairing.G1Point(uint256(0x0603e7413c605d1e9b9352a62f0208e2bbd247d3cf3b3721f72c3a9407d679b9), uint256(0x0ce2d2dca8ae14ac4fd2f3fd89e602cdb45de815cf3ba183a25a47d877d9f6f5));
+        vk.gamma_abc[7] = Pairing.G1Point(uint256(0x05bbe6b58285021fb843123971f8e2cfdd207b02c0aef5923ffe7ac841ee0cc9), uint256(0x2da1d3c2049546a7b46aaf89a8a7de493470087ce9af8ba37673f5ee8c35eb1b));
+        vk.gamma_abc[8] = Pairing.G1Point(uint256(0x2c721270df9ba8884d309140f3a4b150a8e53a6c9d09bd8fc7c9aa3c4901aa8d), uint256(0x0de2cb1684759e693e855711fa1c381ae737e463447c3817df507a02064b470f));
+    }
+    function verify(uint[] memory input, Proof memory proof) internal view returns (uint) {
+        uint256 snark_scalar_field = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+        VerifyingKey memory vk = verifyingKey();
+        require(input.length + 1 == vk.gamma_abc.length);
+        // Compute the linear combination vk_x
+        Pairing.G1Point memory vk_x = Pairing.G1Point(0, 0);
+        for (uint i = 0; i < input.length; i++) {
+            require(input[i] < snark_scalar_field);
+            vk_x = Pairing.addition(vk_x, Pairing.scalar_mul(vk.gamma_abc[i + 1], input[i]));
+        }
+        vk_x = Pairing.addition(vk_x, vk.gamma_abc[0]);
+        if(!Pairing.pairingProd4(
+             proof.a, proof.b,
+             Pairing.negate(vk_x), vk.gamma,
+             Pairing.negate(proof.c), vk.delta,
+             Pairing.negate(vk.alpha), vk.beta)) return 1;
+        return 0;
+    }
+    function verifyTx(
+            Proof memory proof, uint[8] memory input
+        ) public view returns (bool r) {
+        uint[] memory inputValues = new uint[](8);
+
+        for(uint i = 0; i < input.length; i++){
+            inputValues[i] = input[i];
+        }
+        if (verify(inputValues, proof) == 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests.sh b/compiler/test/cmdlineTests.sh
new file mode 100755
index 00000000..3166cd6b
--- /dev/null
+++ b/compiler/test/cmdlineTests.sh
@@ -0,0 +1,425 @@
+#!/usr/bin/env bash
+
+#------------------------------------------------------------------------------
+# Bash script to run commandline Solidity tests.
+#
+# The documentation for solidity is hosted at:
+#
+#     https://docs.soliditylang.org
+#
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2016 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -eo pipefail
+
+## GLOBAL VARIABLES
+
+REPO_ROOT=$(cd "$(dirname "$0")/.." && pwd)
+SOLIDITY_BUILD_DIR=${SOLIDITY_BUILD_DIR:-${REPO_ROOT}/build}
+export REPO_ROOT SOLIDITY_BUILD_DIR
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+pushd "${REPO_ROOT}/test/cmdlineTests" > /dev/null
+autoupdate=false
+no_smt=false
+declare -a included_test_patterns
+declare -a excluded_test_patterns
+while [[ $# -gt 0 ]]
+do
+    case "$1" in
+        --update)
+            autoupdate=true
+            shift
+            ;;
+        --no-smt)
+            no_smt=true
+            shift
+            ;;
+        --exclude)
+            [[ $2 != '' ]] || fail "No pattern given to --exclude option or the pattern is empty."
+            excluded_test_patterns+=("$2")
+            shift
+            shift
+            ;;
+        *)
+            included_test_patterns+=("$1")
+            shift
+            ;;
+    esac
+done
+
+(( ${#included_test_patterns[@]} > 0 )) || included_test_patterns+=('*')
+
+test_name_filter=('(' -name "${included_test_patterns[0]}")
+for pattern in "${included_test_patterns[@]:1}"
+do
+    test_name_filter+=(-or -name "$pattern")
+done
+test_name_filter+=(')')
+
+for pattern in "${excluded_test_patterns[@]}"
+do
+    test_name_filter+=(-and -not -name "$pattern")
+done
+
+# NOTE: We want leading symbols in names to affect the sort order but without
+# LC_COLLATE=C sort seems to ignore them.
+# shellcheck disable=SC2207 # We do not support test names containing spaces.
+selected_tests=($(find . -mindepth 1 -maxdepth 1 -type d "${test_name_filter[@]}" | cut -c 3- | LC_COLLATE=C sort))
+
+if (( ${#selected_tests[@]} == 0 ))
+then
+    printWarning "The pattern '${test_name_filter[*]}' did not match any tests."
+    exit 0;
+else
+    test_count=$(find . -mindepth 1 -maxdepth 1 -type d | wc -l)
+    printLog "Selected ${#selected_tests[@]} out of ${test_count} tests."
+fi
+
+popd > /dev/null
+
+case "$OSTYPE" in
+    msys)
+        SOLC="${SOLIDITY_BUILD_DIR}/solc/Release/solc.exe"
+
+        # prevents msys2 path translation for a remapping test
+        export MSYS2_ARG_CONV_EXCL="="
+        ;;
+    *)
+        SOLC="${SOLIDITY_BUILD_DIR}/solc/solc"
+        ;;
+esac
+echo "Using solc binary at ${SOLC}"
+export SOLC
+
+INTERACTIVE=true
+if ! tty -s || [ "$CI" ]
+then
+    INTERACTIVE=false
+fi
+
+# extend stack size in case we run via ASAN
+if [[ -n "${CIRCLECI}" ]] || [[ -n "$CI" ]]
+then
+    ulimit -s 16384
+    ulimit -a
+fi
+
+## FUNCTIONS
+
+function update_expectation {
+    local newExpectation="${1}"
+    local expectationFile="${2}"
+
+    if [[ $newExpectation == '' || $newExpectation == '0' && $expectationFile == */exit ]]
+    then
+        if [[ -f $expectationFile ]]
+        then
+            rm "$expectationFile"
+        fi
+        return
+    fi
+
+    echo "$newExpectation" > "$expectationFile"
+    printLog "File $expectationFile updated to match the expectation."
+}
+
+function ask_expectation_update
+{
+    if [[ $INTERACTIVE == true ]]
+    then
+        local newExpectation="${1}"
+        local expectationFile="${2}"
+
+        if [[ $autoupdate == true ]]
+        then
+            update_expectation "$newExpectation" "$expectationFile"
+        else
+            local editor="${FCEDIT:-${VISUAL:-${EDITOR:-vi}}}"
+
+            while true
+            do
+                read -r -n 1 -p "(e)dit/(u)pdate expectations/(s)kip/(q)uit? "
+                echo
+                case $REPLY in
+                    e*) "$editor" "$expectationFile"; break;;
+                    u*) update_expectation "$newExpectation" "$expectationFile"; break;;
+                    s*) return;;
+                    q*) fail;;
+                esac
+            done
+        fi
+    else
+        [[ $INTERACTIVE == false ]] || assertFail
+        fail
+    fi
+}
+
+# General helper function for testing SOLC behaviour, based on file name, compile opts, exit code, stdout and stderr.
+# An failure is expected.
+function test_solc_behaviour
+{
+    local filename="${1}"
+    local solc_args
+    IFS=" " read -r -a solc_args <<< "${2}"
+    local solc_stdin="${3}"
+    [ -z "$solc_stdin"  ] && solc_stdin="/dev/stdin"
+    local stdout_expected="${4}"
+    local exit_code_expected="${5}"
+    local exit_code_expectation_file="${6}"
+    local stderr_expected="${7}"
+    local stdout_expectation_file="${8}" # the file to write to when user chooses to update stdout expectation
+    local stderr_expectation_file="${9}" # the file to write to when user chooses to update stderr expectation
+    local stdout_path; stdout_path=$(mktemp -t "cmdline-test-stdout-XXXXXX")
+    local stderr_path; stderr_path=$(mktemp -t "cmdline-test-stderr-XXXXXX")
+
+    # shellcheck disable=SC2064
+    trap "rm -f $stdout_path $stderr_path" EXIT
+
+    if [[ "$exit_code_expected" = "" ]]
+    then
+        exit_code_expected="0"
+    fi
+
+    [[ $filename == "" ]] || solc_args+=("$filename")
+
+    local solc_command="$SOLC ${solc_args[*]} <$solc_stdin"
+    set +e
+    "$SOLC" "${solc_args[@]}" <"$solc_stdin" >"$stdout_path" 2>"$stderr_path"
+    exitCode=$?
+    set -e
+
+    if [[ " ${solc_args[*]} " == *" --standard-json "* ]] && [[ -s $stdout_path ]]
+    then
+        python3 - <<EOF
+import re, sys
+json = open("$stdout_path", "r").read()
+json = re.sub(r"{[^{}]*Warning: This is a pre-release compiler version[^{}]*},?", "", json)
+json = re.sub(r"\"errors\":\s*\[\s*\],?","\n" if json[1] == " " else "",json)       # Remove "errors" array if it's not empty
+json = re.sub("\n\\s*\n", "\n", json)                                               # Remove trailing whitespace
+json = re.sub(r"},(\n{0,1})\n*(\s*(]|}))", r"}\1\2", json)                          # Remove trailing comma
+open("$stdout_path", "w").write(json)
+EOF
+        sed -i.bak -E -e 's/ Consider adding \\"pragma solidity \^[0-9.]*;\\"//g' "$stdout_path"
+        sed -i.bak -E -e 's/\"opcodes\":[[:space:]]*\"[^"]+\"/\"opcodes\":\"<OPCODES REMOVED>\"/g' "$stdout_path"
+        sed -i.bak -E -e 's/\"sourceMap\":[[:space:]]*\"[0-9:;-]+\"/\"sourceMap\":\"<SOURCEMAP REMOVED>\"/g' "$stdout_path"
+
+        # Remove bytecode (but not linker references).
+        sed -i.bak -E -e 's/(\"object\":[[:space:]]*\")[0-9a-f]+([^"]*\")/\1<BYTECODE REMOVED>\2/g' "$stdout_path"
+        # shellcheck disable=SC2016
+        sed -i.bak -E -e 's/(\"object\":[[:space:]]*\"[^"]+\$__)[0-9a-f]+(\")/\1<BYTECODE REMOVED>\2/g' "$stdout_path"
+        # shellcheck disable=SC2016
+        sed -i.bak -E -e 's/([0-9a-f]{34}\$__)[0-9a-f]+(__\$[0-9a-f]{17})/\1<BYTECODE REMOVED>\2/g' "$stdout_path"
+        # Remove metadata in assembly output (see below about the magic numbers)
+        sed -i.bak -E -e 's/"[0-9a-f]+64697066735822[0-9a-f]+64736f6c63[0-9a-f]+/"<BYTECODE REMOVED>/g' "$stdout_path"
+
+        # Replace escaped newlines by actual newlines for readability
+        # shellcheck disable=SC1003
+        sed -i.bak -E -e 's/\\n/\'$'\n/g' "$stdout_path"
+        sed -i.bak -e 's/\(^[ ]*auxdata:[[:space:]]\)0x[0-9a-f]*$/\1<AUXDATA REMOVED>/' "$stdout_path"
+        sed -i.bak -e 's/\(\\"version\\":[ ]*\\"\)[^"\\]*\(\\"\)/\1<VERSION REMOVED>\2/' "$stdout_path"
+        rm "$stdout_path.bak"
+    else
+        sed -i.bak -e '/^Warning: This is a pre-release compiler version, please do not use it in production./,+1d' "$stderr_path"
+        sed -i.bak -e '/^Compiler run successful, no output requested\.$/d' "$stderr_path"
+        sed -i.bak -e '/^Warning (3805): This is a pre-release compiler version, please do not use it in production./,+1d' "$stderr_path"
+        sed -i.bak -e 's/\(^[ ]*auxdata: \)0x[0-9a-f]*$/\1<AUXDATA REMOVED>/' "$stdout_path"
+        sed -i.bak -e 's/ Consider adding "pragma .*$//' "$stderr_path"
+        sed -i.bak -e 's/\(Unimplemented feature error.* in \).*$/\1<FILENAME REMOVED>/' "$stderr_path"
+        sed -i.bak -e 's/"version":[ ]*"[^"]*"/"version": "<VERSION REMOVED>"/' "$stdout_path"
+    if [[ $stdout_expectation_file != "" &&  $stderr_expectation_file != "" ]]
+    then
+        sed -i.bak -e '/^Compiler run successful\. No contracts to compile\.$/d' "$stdout_path"
+        sed -i.bak -e '/^Compiler run successful\. No output generated\.$/d' "$stdout_path"
+    fi
+
+        # Remove bytecode (but not linker references). Since non-JSON output is unstructured,
+        # use metadata markers for detection to have some confidence that it's actually bytecode
+        # and not some random word.
+        # 64697066735822 = hex encoding of 0x64 'i' 'p' 'f' 's' 0x58 0x22
+        # 64736f6c63     = hex encoding of 0x64 's' 'o' 'l' 'c'
+        sed -i.bak -E -e 's/[0-9a-f]*64697066735822[0-9a-f]+64736f6c63[0-9a-f]+/<BYTECODE REMOVED>/g' "$stdout_path"
+        # shellcheck disable=SC2016
+        sed -i.bak -E -e 's/([0-9a-f]{17}\$__)[0-9a-f]+(__\$[0-9a-f]{17})/\1<BYTECODE REMOVED>\2/g' "$stdout_path"
+        # shellcheck disable=SC2016
+        sed -i.bak -E -e 's/[0-9a-f]+((__\$[0-9a-f]{34}\$__)*<BYTECODE REMOVED>)/<BYTECODE REMOVED>\1/g' "$stdout_path"
+
+        # Remove trailing empty lines. Needs a line break to make OSX sed happy.
+        sed -i.bak -e '1{/^$/d
+}' "$stderr_path"
+        rm "$stderr_path.bak" "$stdout_path.bak"
+    fi
+    # Remove path to cpp file
+    sed -i.bak -e 's/^\(Exception while assembling:\).*/\1/' "$stderr_path"
+    # Remove exception class name.
+    sed -i.bak -e 's/^\(Dynamic exception type:\).*/\1/' "$stderr_path"
+    rm "$stderr_path.bak"
+
+    if [[ $exitCode -ne "$exit_code_expected" ]]
+    then
+        printError "Incorrect exit code. Expected $exit_code_expected but got $exitCode."
+
+        [[ $exit_code_expectation_file != "" ]] && ask_expectation_update "$exitCode" "$exit_code_expectation_file"
+        [[ $exit_code_expectation_file == "" ]] && fail
+    fi
+
+    if [[ "$(cat "$stdout_path")" != "${stdout_expected}" ]]
+    then
+        printError "Incorrect output on stdout received. Expected:"
+        echo -e "${stdout_expected}"
+
+        printError "But got:"
+        echo -e "$(cat "$stdout_path")"
+
+        printError "When running $solc_command"
+
+        [[ $stdout_expectation_file != "" ]] && ask_expectation_update "$(cat "$stdout_path")" "$stdout_expectation_file"
+        [[ $stdout_expectation_file == "" ]] && fail
+    fi
+
+    if [[ "$(cat "$stderr_path")" != "${stderr_expected}" ]]
+    then
+        printError "Incorrect output on stderr received. Expected:"
+        echo -e "${stderr_expected}"
+
+        printError "But got:"
+        echo -e "$(cat "$stderr_path")"
+
+        printError "When running $solc_command"
+
+        [[ $stderr_expectation_file != "" ]] && ask_expectation_update "$(cat "$stderr_path")" "$stderr_expectation_file"
+        [[ $stderr_expectation_file == "" ]] && fail
+    fi
+
+    rm "$stdout_path" "$stderr_path"
+}
+
+
+## RUN
+
+printTask "Testing passing files that are not found..."
+test_solc_behaviour "file_not_found.sol" "" "" "" 1 "" "Error: \"file_not_found.sol\" is not found." "" ""
+
+printTask "Testing passing files that are not files..."
+test_solc_behaviour "." "" "" "" 1 "" "Error: \".\" is not a valid file." "" ""
+
+printTask "Testing passing empty remappings..."
+test_solc_behaviour "${0}" "=/some/remapping/target" "" "" 1 "" "Error: Invalid remapping: \"=/some/remapping/target\"." "" ""
+test_solc_behaviour "${0}" "ctx:=/some/remapping/target" "" "" 1 "" "Error: Invalid remapping: \"ctx:=/some/remapping/target\"." "" ""
+
+printTask "Running general commandline tests..."
+(
+    cd "$REPO_ROOT"/test/cmdlineTests/
+    for tdir in "${selected_tests[@]}"
+    do
+        if ! [[ -d $tdir ]]
+        then
+            fail "Test directory not found: $tdir"
+        fi
+
+        printTask " - ${tdir}"
+
+        if [[ $(ls -A "$tdir") == "" ]]
+        then
+            printWarning "   ---> skipped (test dir empty)"
+            continue
+        fi
+
+        # Strip trailing slash from $tdir.
+        tdir=$(basename "${tdir}")
+        if [[ $no_smt == true ]]
+        then
+            if [[ $tdir =~ .*model_checker_.* ]]
+            then
+                printWarning "   ---> skipped (SMT test)"
+                continue
+            fi
+        fi
+
+        scriptFiles="$(ls -1 "${tdir}/test."* 2> /dev/null || true)"
+        scriptCount="$(echo "${scriptFiles}" | wc -w)"
+
+        inputFiles="$(ls -1 "${tdir}/input."* 2> /dev/null || true)"
+        inputCount="$(echo "${inputFiles}" | wc -w)"
+        (( inputCount <= 1 )) || fail "Ambiguous input. Found input files in multiple formats:"$'\n'"${inputFiles}"
+        (( scriptCount <= 1 )) || fail "Ambiguous input. Found script files in multiple formats:"$'\n'"${scriptFiles}"
+        (( inputCount == 0 || scriptCount == 0 )) || fail "Ambiguous input. Found both input and script files:"$'\n'"${inputFiles}"$'\n'"${scriptFiles}"
+
+        if (( scriptCount == 1 ))
+        then
+            if ! "$scriptFiles"
+            then
+                fail "Test script ${scriptFiles} failed."
+            fi
+
+            continue
+        fi
+
+        # Use printf to get rid of the trailing newline
+        inputFile=$(printf "%s" "${inputFiles}")
+
+        if [ "${inputFile}" = "${tdir}/input.json" ]
+        then
+            ! [ -e "${tdir}/stdin" ] || fail "Found a file called 'stdin' but redirecting standard input in JSON mode is not allowed."
+
+            stdin="${inputFile}"
+            inputFile=""
+            stdout="$(cat "${tdir}/output.json" 2>/dev/null || true)"
+            stdoutExpectationFile="${tdir}/output.json"
+            prettyPrintFlags=""
+            if [[ ! -f "${tdir}/no-pretty-print" ]]
+            then
+                prettyPrintFlags="--pretty-json --json-indent 4"
+            fi
+
+            command_args="--standard-json ${prettyPrintFlags} "$(cat "${tdir}/args" 2>/dev/null || true)
+        else
+            if [ -e "${tdir}/stdin" ]
+            then
+                stdin="${tdir}/stdin"
+                [ -f "${tdir}/stdin" ] || fail "'stdin' is not a regular file."
+            else
+                stdin=""
+            fi
+
+            stdout="$(cat "${tdir}/output" 2>/dev/null || true)"
+            stdoutExpectationFile="${tdir}/output"
+            command_args=$(cat "${tdir}/args" 2>/dev/null || true)
+        fi
+        exitCodeExpectationFile="${tdir}/exit"
+        exitCode=$(cat "$exitCodeExpectationFile" 2>/dev/null || true)
+        err="$(cat "${tdir}/err" 2>/dev/null || true)"
+        stderrExpectationFile="${tdir}/err"
+        test_solc_behaviour "$inputFile" \
+                            "$command_args" \
+                            "$stdin" \
+                            "$stdout" \
+                            "$exitCode" \
+                            "$exitCodeExpectationFile" \
+                            "$err" \
+                            "$stdoutExpectationFile" \
+                            "$stderrExpectationFile"
+    done
+)
+
+echo "Commandline tests successful."
diff --git a/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/args b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/args
new file mode 100644
index 00000000..e6010eac
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/args
@@ -0,0 +1 @@
+--pretty-json --json-indent 4 --combined-json bin,bin-runtime,opcodes,asm,srcmap,srcmap-runtime --asm --bin --bin-runtime --asm-json --import-asm-json -
diff --git a/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/output b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/output
new file mode 100644
index 00000000..7b8aa029
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/output
@@ -0,0 +1,91 @@
+{
+    "contracts":
+    {
+        "<stdin>":
+        {
+            "asm":
+            {
+                ".code":
+                [
+                    {
+                        "begin": 0,
+                        "end": 0,
+                        "name": "PUSH",
+                        "source": -1,
+                        "value": "0"
+                    }
+                ],
+                ".data":
+                {
+                    "0":
+                    {
+                        ".code":
+                        [
+                            {
+                                "begin": 0,
+                                "end": 0,
+                                "name": "PUSH",
+                                "source": -1,
+                                "value": "1"
+                            }
+                        ]
+                    }
+                },
+                "sourceList":
+                [
+                    "contract.sol",
+                    "#utility.yul"
+                ]
+            },
+            "bin": "5ffe",
+            "bin-runtime": "6001",
+            "opcodes": "PUSH0 INVALID ",
+            "srcmap": "0:0::-:0",
+            "srcmap-runtime": "0:0::-:0"
+        }
+    },
+    "sourceList":
+    [
+        "contract.sol",
+        "#utility.yul"
+    ],
+    "version": "<VERSION REMOVED>"
+}
+Binary:
+5ffe
+Binary of the runtime part:
+6001
+EVM assembly:
+{
+    ".code":
+    [
+        {
+            "begin": 0,
+            "end": 0,
+            "name": "PUSH",
+            "source": -1,
+            "value": "0"
+        }
+    ],
+    ".data":
+    {
+        "0":
+        {
+            ".code":
+            [
+                {
+                    "begin": 0,
+                    "end": 0,
+                    "name": "PUSH",
+                    "source": -1,
+                    "value": "1"
+                }
+            ]
+        }
+    },
+    "sourceList":
+    [
+        "contract.sol",
+        "#utility.yul"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/stdin b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/stdin
new file mode 100644
index 00000000..1a707b78
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_all_valid_flags/stdin
@@ -0,0 +1,22 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "0": {
+            ".code": [
+                {
+                    "name": "PUSH",
+                    "value": "1"
+                }
+            ]
+        }
+    },
+    "sourceList": [
+        "contract.sol",
+        "#utility.yul"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/args b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/output b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/output
new file mode 100644
index 00000000..3d19f83d
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/output
@@ -0,0 +1,6 @@
+Opcodes:
+PREVRANDAO PREVRANDAO 
+EVM assembly:
+    /*   */
+  prevrandao
+  prevrandao
diff --git a/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/stdin b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/stdin
new file mode 100644
index 00000000..f6cc5466
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_difficulty_prevrandao/stdin
@@ -0,0 +1,6 @@
+{
+    ".code": [
+        {"name": "DIFFICULTY"},
+        {"name": "PREVRANDAO"}
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/args b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/output b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/output
new file mode 100644
index 00000000..873465aa
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/output
@@ -0,0 +1,57 @@
+Opcodes:
+PUSH0 INVALID 
+EVM assembly:
+    /*   */
+  0x00
+stop
+
+sub_0: assembly {
+}
+
+sub_1: assembly {
+}
+
+sub_2: assembly {
+}
+
+sub_3: assembly {
+}
+
+sub_4: assembly {
+}
+
+sub_5: assembly {
+}
+
+sub_6: assembly {
+}
+
+sub_7: assembly {
+}
+
+sub_8: assembly {
+}
+
+sub_9: assembly {
+}
+
+sub_10: assembly {
+}
+
+sub_11: assembly {
+}
+
+sub_12: assembly {
+}
+
+sub_13: assembly {
+}
+
+sub_14: assembly {
+}
+
+sub_15: assembly {
+}
+
+sub_16: assembly {
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/stdin b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/stdin
new file mode 100644
index 00000000..70c89a23
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_hex_subassembly_indices/stdin
@@ -0,0 +1,27 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "0": {".code": []},
+        "1": {".code": []},
+        "2": {".code": []},
+        "3": {".code": []},
+        "4": {".code": []},
+        "5": {".code": []},
+        "6": {".code": []},
+        "7": {".code": []},
+        "8": {".code": []},
+        "9": {".code": []},
+        "a": {".code": []},
+        "b": {".code": []},
+        "c": {".code": []},
+        "d": {".code": []},
+        "e": {".code": []},
+        "f": {".code": []},
+        "10": {".code": []}
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/args b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/err b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/err
new file mode 100644
index 00000000..8e3458bd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: The value for key '0' inside '.data' is not a valid hexadecimal string.
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/exit b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/stdin b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/stdin
new file mode 100644
index 00000000..6c167369
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_hex/stdin
@@ -0,0 +1,11 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "0": "no-hex-string"
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/args b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/err b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/err
new file mode 100644
index 00000000..ddcfeca7
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: The value of key '0' inside '.data' is neither a hex string nor an object.
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/exit b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/stdin b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/stdin
new file mode 100644
index 00000000..29cc24aa
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_data_not_object/stdin
@@ -0,0 +1,11 @@
+{
+    ".code": [
+        {
+          "name": "PUSH",
+          "value": "0"
+        }
+    ],
+    ".data": {
+        "0": [0, 1, 2, 3]
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/args b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/err b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/err
new file mode 100644
index 00000000..e553029e
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Member 'jumpType' set on instruction different from JUMP or JUMPI (was set on instruction 'PUSH')
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/exit b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/stdin b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/stdin
new file mode 100644
index 00000000..2df5445d
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_jumptype_instruction/stdin
@@ -0,0 +1,9 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0",
+            "jumpType": "[in]"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_value/args b/compiler/test/cmdlineTests/asm_json_import_invalid_value/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_value/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_value/err b/compiler/test/cmdlineTests/asm_json_import_invalid_value/err
new file mode 100644
index 00000000..67723f82
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_value/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Member 'value' defined for instruction 'DIFFICULTY', but the instruction does not need a value.
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_value/exit b/compiler/test/cmdlineTests/asm_json_import_invalid_value/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_value/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_invalid_value/stdin b/compiler/test/cmdlineTests/asm_json_import_invalid_value/stdin
new file mode 100644
index 00000000..6252ff69
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_invalid_value/stdin
@@ -0,0 +1,8 @@
+{
+    ".code": [
+        {
+            "name": "DIFFICULTY",
+            "value": "0"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/args b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/err b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/err
new file mode 100644
index 00000000..1decd6dd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Invalid subassembly indices in '.data'. Not all numbers between 0 and 8 are present.
diff --git a/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/exit b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/stdin b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/stdin
new file mode 100644
index 00000000..6832823e
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_missing_subobject_indices/stdin
@@ -0,0 +1,19 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "2": {".code": []},
+        "0": {".code": []},
+        "4": {".code": []},
+        "5": {".code": []},
+        "7": {".code": []},
+        "6": {".code": []},
+        "9": {".code": []},
+        "1": {".code": []},
+        "8": {".code": []}
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_no_value/args b/compiler/test/cmdlineTests/asm_json_import_no_value/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_no_value/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_no_value/err b/compiler/test/cmdlineTests/asm_json_import_no_value/err
new file mode 100644
index 00000000..02428d99
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_no_value/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Member 'value' is missing for instruction 'PUSH', but the instruction needs a value.
diff --git a/compiler/test/cmdlineTests/asm_json_import_no_value/exit b/compiler/test/cmdlineTests/asm_json_import_no_value/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_no_value/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_no_value/stdin b/compiler/test/cmdlineTests/asm_json_import_no_value/stdin
new file mode 100644
index 00000000..99ab122c
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_no_value/stdin
@@ -0,0 +1,5 @@
+{
+    ".code": [
+        {"name": "PUSH"}
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/args b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/args
new file mode 100644
index 00000000..d27cc7bb
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/args
@@ -0,0 +1 @@
+--asm-json --import-asm-json -
diff --git a/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/err b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/err
new file mode 100644
index 00000000..78eadfc0
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Items in 'sourceList' array are not unique.
diff --git a/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/exit b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/stdin b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/stdin
new file mode 100644
index 00000000..431d5a64
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_non_unique_sources/stdin
@@ -0,0 +1,23 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "0": {
+          ".code": [
+              {
+                  "name": "PUSH",
+                  "value": "1"
+              }
+          ]
+        }
+    },
+    "sourceList": [
+        "contract.sol",
+        "contract.sol",
+        "#utility.yul"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/args b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/args
new file mode 100644
index 00000000..f649e974
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/args
@@ -0,0 +1 @@
+--optimize --import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/err b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/err
new file mode 100644
index 00000000..8f42dca7
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/err
@@ -0,0 +1 @@
+Error: Option --optimize is not supported with --import-asm-json.
diff --git a/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/exit b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/stdin b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/stdin
new file mode 100644
index 00000000..f6cc5466
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_optimize_not_supported/stdin
@@ -0,0 +1,6 @@
+{
+    ".code": [
+        {"name": "DIFFICULTY"},
+        {"name": "PREVRANDAO"}
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/args b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/err b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/err
new file mode 100644
index 00000000..08c766c3
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: The key '18446744073709551615' inside '.data' is out of the supported integer range.
diff --git a/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/exit b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/stdin b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/stdin
new file mode 100644
index 00000000..3e8f8897
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_out_of_range_data_index/stdin
@@ -0,0 +1,13 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "18446744073709551615": {
+            ".code": []
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/args b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/output b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/output
new file mode 100644
index 00000000..b23848e5
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/output
@@ -0,0 +1,35 @@
+Opcodes:
+PUSH0 INVALID 
+EVM assembly:
+    /*   */
+  0x00
+stop
+
+sub_0: assembly {
+}
+
+sub_1: assembly {
+    stop
+
+    sub_0: assembly {
+    }
+
+    sub_1: assembly {
+    }
+
+    sub_2: assembly {
+    }
+}
+
+sub_2: assembly {
+    stop
+
+    sub_0: assembly {
+    }
+
+    sub_1: assembly {
+    }
+}
+
+sub_3: assembly {
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/stdin b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/stdin
new file mode 100644
index 00000000..c695de5c
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_random_order_data_index/stdin
@@ -0,0 +1,27 @@
+{
+    ".code": [
+        {
+            "name": "PUSH",
+            "value": "0"
+        }
+    ],
+    ".data": {
+        "2": {
+            ".code": [],
+            ".data": {
+                "1": {".code": []},
+                "0": {".code": []}
+            }
+        },
+        "0": {".code": []},
+        "1": {
+            ".code": [],
+            ".data": {
+                "1": {".code": []},
+                "2": {".code": []},
+                "0": {".code": []}
+            }
+        },
+        "3": {".code": []}
+    }
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/args b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/err b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/err
new file mode 100644
index 00000000..35b7fc9f
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: Unknown member '_name'. Valid members are: begin, end, jumpType, modifierDepth, name, source, value.
diff --git a/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/exit b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/stdin b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/stdin
new file mode 100644
index 00000000..c1dc7cd8
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_unrecognized_field/stdin
@@ -0,0 +1,5 @@
+{
+    ".code": [
+        {"_name": "DIFFICULTY"}
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/args b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/err b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/err
new file mode 100644
index 00000000..f31c32fe
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/err
@@ -0,0 +1 @@
+Error: Assembly Import Error: JUMPDEST instruction without a tag
diff --git a/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/exit b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/stdin b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/stdin
new file mode 100644
index 00000000..beaa19be
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_untagged_jumpdest/stdin
@@ -0,0 +1,10 @@
+{
+    ".code": [
+        {
+            "name": "tag",
+            "value": "0x00"
+        },
+        {"name": "JUMPDEST"},
+        {"name": "JUMPDEST"}
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_verbatim/args b/compiler/test/cmdlineTests/asm_json_import_verbatim/args
new file mode 100644
index 00000000..2b4b3a15
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_verbatim/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes --asm
diff --git a/compiler/test/cmdlineTests/asm_json_import_verbatim/output b/compiler/test/cmdlineTests/asm_json_import_verbatim/output
new file mode 100644
index 00000000..50b8a4ce
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_verbatim/output
@@ -0,0 +1,58 @@
+Opcodes:
+PUSH0 CALLDATALOAD PUSH1 0x14 DUP1 DUP3 SSTORE PUSH1 0x20 CALLDATALOAD ISZERO PUSH1 0x1C JUMPI DUP1 DUP3 SSTORE PUSH0 DUP1 PUSH0 DUP1 PUSH0 DUP1 STATICCALL POP PUSH25 0x797A5B80825550500000000000000000000000000000000000 
+EVM assembly:
+    /* "<stdin>":28:29    */
+  0x00
+    /* "<stdin>":15:30  [... */
+  calldataload
+    /* "<stdin>":44:46  n" */
+  0x14
+    /* "<stdin>":61:62    */
+  dup1
+    /* "<stdin>":58:59    */
+  dup3
+    /* "<stdin>":51:63  ... */
+  sstore
+    /* "<stdin>":84:86     */
+  0x20
+    /* "<stdin>":71:87  29,... */
+  calldataload
+    /* "<stdin>":68:188  ": 29,... */
+  iszero
+  tag_1
+  jumpi
+    /* "<stdin>":108:109    */
+  dup1
+    /* "<stdin>":105:106    */
+  dup3
+    /* "<stdin>":98:110  SH",... */
+  sstore
+    /* "<stdin>":149:150  " */
+  0x00
+    /* "<stdin>":146:147  " */
+  dup1
+    /* "<stdin>":143:144  l */
+  0x00
+    /* "<stdin>":140:141  " */
+  dup1
+    /* "<stdin>":137:138    */
+  0x00
+    /* "<stdin>":134:135    */
+  dup1
+    /* "<stdin>":123:151  : 0,... */
+  staticcall
+    /* "<stdin>":119:152  rce": 0,... */
+  pop
+    /* "<stdin>":161:182  },... */
+  verbatimbytecode_78797a
+    /* "<stdin>":68:188  ": 29,... */
+tag_1:
+    /* "<stdin>":203:204    */
+  dup1
+    /* "<stdin>":200:201    */
+  dup3
+    /* "<stdin>":193:205  : 15,... */
+  sstore
+    /* "<stdin>":0:207  {... */
+  pop
+  pop
diff --git a/compiler/test/cmdlineTests/asm_json_import_verbatim/stdin b/compiler/test/cmdlineTests/asm_json_import_verbatim/stdin
new file mode 100644
index 00000000..df4b0ce0
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_verbatim/stdin
@@ -0,0 +1,196 @@
+{
+    ".code": [
+        {
+            "begin": 28,
+            "end": 29,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 15,
+            "end": 30,
+            "name": "CALLDATALOAD",
+            "source": 0
+        },
+        {
+            "begin": 44,
+            "end": 46,
+            "name": "PUSH",
+            "source": 0,
+            "value": "14"
+        },
+        {
+            "begin": 61,
+            "end": 62,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 58,
+            "end": 59,
+            "name": "DUP3",
+            "source": 0
+        },
+        {
+            "begin": 51,
+            "end": 63,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 84,
+            "end": 86,
+            "name": "PUSH",
+            "source": 0,
+            "value": "20"
+        },
+        {
+            "begin": 71,
+            "end": 87,
+            "name": "CALLDATALOAD",
+            "source": 0
+        },
+        {
+            "begin": 68,
+            "end": 188,
+            "name": "ISZERO",
+            "source": 0
+        },
+        {
+            "begin": 68,
+            "end": 188,
+            "name": "PUSH [tag]",
+            "source": 0,
+            "value": "1"
+        },
+        {
+            "begin": 68,
+            "end": 188,
+            "name": "JUMPI",
+            "source": 0
+        },
+        {
+            "begin": 108,
+            "end": 109,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 105,
+            "end": 106,
+            "name": "DUP3",
+            "source": 0
+        },
+        {
+            "begin": 98,
+            "end": 110,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 149,
+            "end": 150,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 146,
+            "end": 147,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 143,
+            "end": 144,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 140,
+            "end": 141,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 137,
+            "end": 138,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 134,
+            "end": 135,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 123,
+            "end": 151,
+            "name": "STATICCALL",
+            "source": 0
+        },
+        {
+            "begin": 119,
+            "end": 152,
+            "name": "POP",
+            "source": 0
+        },
+        {
+            "begin": 161,
+            "end": 182,
+            "name": "VERBATIM",
+            "source": 0,
+            "value": "78797a"
+        },
+        {
+            "begin": 68,
+            "end": 188,
+            "name": "tag",
+            "source": 0,
+            "value": "1"
+        },
+        {
+            "begin": 68,
+            "end": 188,
+            "name": "JUMPDEST",
+            "source": 0
+        },
+        {
+            "begin": 203,
+            "end": 204,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 200,
+            "end": 201,
+            "name": "DUP3",
+            "source": 0
+        },
+        {
+            "begin": 193,
+            "end": 205,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 0,
+            "end": 207,
+            "name": "POP",
+            "source": 0
+        },
+        {
+            "begin": 0,
+            "end": 207,
+            "name": "POP",
+            "source": 0
+        }
+    ],
+    "sourceList": [
+        "<stdin>"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/args b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/args
new file mode 100644
index 00000000..58dfc8cc
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/output b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/output
new file mode 100644
index 00000000..81aa5b93
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/output
@@ -0,0 +1,2 @@
+Opcodes:
+PUSH1 0x1E PUSH0 SSTORE PUSH1 0x1A PUSH1 0x1 SSTORE PUSH1 0x15 PUSH1 0x2 SSTORE PUSH1 0x1 PUSH1 0x3 SSTORE PUSH1 0x1 PUSH1 0x4 SSTORE PUSH1 0x1 PUSH1 0x5 SSTORE INVALID 
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/stdin b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/stdin
new file mode 100644
index 00000000..1820bcf5
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_more_subobjects/stdin
@@ -0,0 +1,348 @@
+{
+    ".code": [
+        {
+            "begin": 37,
+            "end": 51,
+            "name": "PUSHSIZE",
+            "source": 0
+        },
+        {
+            "begin": 34,
+            "end": 35,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 27,
+            "end": 52,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 67,
+            "end": 81,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+        },
+        {
+            "begin": 64,
+            "end": 65,
+            "name": "PUSH",
+            "source": 0,
+            "value": "1"
+        },
+        {
+            "begin": 57,
+            "end": 82,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 97,
+            "end": 114,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+        },
+        {
+            "begin": 94,
+            "end": 95,
+            "name": "PUSH",
+            "source": 0,
+            "value": "2"
+        },
+        {
+            "begin": 87,
+            "end": 115,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 130,
+            "end": 152,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffe"
+        },
+        {
+            "begin": 127,
+            "end": 128,
+            "name": "PUSH",
+            "source": 0,
+            "value": "3"
+        },
+        {
+            "begin": 120,
+            "end": 153,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 168,
+            "end": 190,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffd"
+        },
+        {
+            "begin": 165,
+            "end": 166,
+            "name": "PUSH",
+            "source": 0,
+            "value": "4"
+        },
+        {
+            "begin": 158,
+            "end": 191,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 206,
+            "end": 228,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffc"
+        },
+        {
+            "begin": 203,
+            "end": 204,
+            "name": "PUSH",
+            "source": 0,
+            "value": "5"
+        },
+        {
+            "begin": 196,
+            "end": 229,
+            "name": "SSTORE",
+            "source": 0
+        }
+    ],
+    ".data": {
+        "0": {
+            ".code": [
+                {
+                    "begin": 278,
+                    "end": 292,
+                    "name": "PUSHSIZE",
+                    "source": 0
+                },
+                {
+                    "begin": 275,
+                    "end": 276,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "6"
+                },
+                {
+                    "begin": 268,
+                    "end": 293,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 310,
+                    "end": 324,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                },
+                {
+                    "begin": 307,
+                    "end": 308,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "7"
+                },
+                {
+                    "begin": 300,
+                    "end": 325,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 342,
+                    "end": 361,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+                },
+                {
+                    "begin": 339,
+                    "end": 340,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "8"
+                },
+                {
+                    "begin": 332,
+                    "end": 362,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 379,
+                    "end": 398,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "000000000000000000000000000000000000000000000000fffffffffffffffe"
+                },
+                {
+                    "begin": 376,
+                    "end": 377,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "9"
+                },
+                {
+                    "begin": 369,
+                    "end": 399,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 417,
+                    "end": 436,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "000000000000000000000000000000000000000000000000fffffffffffffffd"
+                },
+                {
+                    "begin": 413,
+                    "end": 415,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "A"
+                },
+                {
+                    "begin": 406,
+                    "end": 437,
+                    "name": "SSTORE",
+                    "source": 0
+                }
+            ],
+            ".data": {
+                "0": {
+                    ".code": [
+                        {
+                            "begin": 494,
+                            "end": 508,
+                            "name": "PUSHSIZE",
+                            "source": 0
+                        },
+                        {
+                            "begin": 490,
+                            "end": 492,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "B"
+                        },
+                        {
+                            "begin": 483,
+                            "end": 509,
+                            "name": "SSTORE",
+                            "source": 0
+                        },
+                        {
+                            "begin": 529,
+                            "end": 545,
+                            "name": "PUSH #[$]",
+                            "source": 0,
+                            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                        },
+                        {
+                            "begin": 525,
+                            "end": 527,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "C"
+                        },
+                        {
+                            "begin": 518,
+                            "end": 546,
+                            "name": "SSTORE",
+                            "source": 0
+                        },
+                        {
+                            "begin": 566,
+                            "end": 582,
+                            "name": "PUSH #[$]",
+                            "source": 0,
+                            "value": "0000000000000000000000000000000000000000000000000000000000000001"
+                        },
+                        {
+                            "begin": 562,
+                            "end": 564,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "D"
+                        },
+                        {
+                            "begin": 555,
+                            "end": 583,
+                            "name": "SSTORE",
+                            "source": 0
+                        },
+                        {
+                            "begin": 603,
+                            "end": 619,
+                            "name": "PUSH #[$]",
+                            "source": 0,
+                            "value": "0000000000000000000000000000000000000000000000000000000000000002"
+                        },
+                        {
+                            "begin": 599,
+                            "end": 601,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "E"
+                        },
+                        {
+                            "begin": 592,
+                            "end": 620,
+                            "name": "SSTORE",
+                            "source": 0
+                        }
+                    ],
+                    ".data": {
+                        "0": {
+                            ".code": [
+                                {
+                                    "begin": 676,
+                                    "end": 685,
+                                    "name": "INVALID",
+                                    "source": 0
+                                }
+                            ]
+                        },
+                        "1": {
+                            ".code": [
+                                {
+                                    "begin": 751,
+                                    "end": 760,
+                                    "name": "INVALID",
+                                    "source": 0
+                                }
+                            ]
+                        },
+                        "2": {
+                            ".code": [
+                                {
+                                    "begin": 826,
+                                    "end": 835,
+                                    "name": "INVALID",
+                                    "source": 0
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sourceList": [
+        "<stdin>"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/args b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/args
new file mode 100644
index 00000000..58dfc8cc
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/args
@@ -0,0 +1 @@
+--import-asm-json - --opcodes
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/output b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/output
new file mode 100644
index 00000000..6aa2d0f6
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/output
@@ -0,0 +1,2 @@
+Opcodes:
+PUSH0 DUP1 SSTORE PUSH1 0x6A PUSH1 0x1 SSTORE PUSH1 0x31 PUSH1 0x2 SSTORE PUSH1 0x2C PUSH1 0x3 SSTORE PUSH1 0x5E PUSH1 0x4 SSTORE PUSH1 0xC PUSH1 0x5 SSTORE PUSH1 0x5D PUSH1 0x6 SSTORE PUSH1 0x1 PUSH1 0x7 SSTORE PUSH1 0x5D PUSH1 0x8 SSTORE PUSH1 0x1 PUSH1 0x9 SSTORE INVALID PUSH1 0x1F PUSH1 0xA SSTORE PUSH1 0xC PUSH1 0xB SSTORE PUSH1 0x2B PUSH1 0xC SSTORE PUSH1 0x1 PUSH1 0xD SSTORE PUSH1 0x2B PUSH1 0xE SSTORE PUSH1 0x1 PUSH1 0xF SSTORE INVALID PUSH1 0xB PUSH1 0x10 SSTORE PUSH1 0x1 PUSH1 0x11 SSTORE INVALID INVALID INVALID INVALID PUSH1 0xB PUSH1 0x10 SSTORE PUSH1 0x1 PUSH1 0x11 SSTORE INVALID INVALID 
diff --git a/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/stdin b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/stdin
new file mode 100644
index 00000000..0c8cdcf4
--- /dev/null
+++ b/compiler/test/cmdlineTests/asm_json_import_yul_subobjects/stdin
@@ -0,0 +1,400 @@
+{
+    ".code": [
+        {
+            "begin": 36,
+            "end": 51,
+            "name": "PUSH",
+            "source": 0,
+            "value": "0"
+        },
+        {
+            "begin": 33,
+            "end": 34,
+            "name": "DUP1",
+            "source": 0
+        },
+        {
+            "begin": 26,
+            "end": 52,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 67,
+            "end": 80,
+            "name": "PUSHSIZE",
+            "source": 0
+        },
+        {
+            "begin": 64,
+            "end": 65,
+            "name": "PUSH",
+            "source": 0,
+            "value": "1"
+        },
+        {
+            "begin": 57,
+            "end": 81,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 96,
+            "end": 111,
+            "name": "PUSH [$]",
+            "source": 0,
+            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+        },
+        {
+            "begin": 93,
+            "end": 94,
+            "name": "PUSH",
+            "source": 0,
+            "value": "2"
+        },
+        {
+            "begin": 86,
+            "end": 112,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 127,
+            "end": 140,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+        },
+        {
+            "begin": 124,
+            "end": 125,
+            "name": "PUSH",
+            "source": 0,
+            "value": "3"
+        },
+        {
+            "begin": 117,
+            "end": 141,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 156,
+            "end": 173,
+            "name": "PUSH [$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+        },
+        {
+            "begin": 153,
+            "end": 154,
+            "name": "PUSH",
+            "source": 0,
+            "value": "4"
+        },
+        {
+            "begin": 146,
+            "end": 174,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 189,
+            "end": 204,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+        },
+        {
+            "begin": 186,
+            "end": 187,
+            "name": "PUSH",
+            "source": 0,
+            "value": "5"
+        },
+        {
+            "begin": 179,
+            "end": 205,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 220,
+            "end": 237,
+            "name": "PUSH [$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffe"
+        },
+        {
+            "begin": 217,
+            "end": 218,
+            "name": "PUSH",
+            "source": 0,
+            "value": "6"
+        },
+        {
+            "begin": 210,
+            "end": 238,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 253,
+            "end": 268,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffe"
+        },
+        {
+            "begin": 250,
+            "end": 251,
+            "name": "PUSH",
+            "source": 0,
+            "value": "7"
+        },
+        {
+            "begin": 243,
+            "end": 269,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 284,
+            "end": 303,
+            "name": "PUSH [$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffd"
+        },
+        {
+            "begin": 281,
+            "end": 282,
+            "name": "PUSH",
+            "source": 0,
+            "value": "8"
+        },
+        {
+            "begin": 274,
+            "end": 304,
+            "name": "SSTORE",
+            "source": 0
+        },
+        {
+            "begin": 319,
+            "end": 336,
+            "name": "PUSH #[$]",
+            "source": 0,
+            "value": "000000000000000000000000000000000000000000000000fffffffffffffffd"
+        },
+        {
+            "begin": 316,
+            "end": 317,
+            "name": "PUSH",
+            "source": 0,
+            "value": "9"
+        },
+        {
+            "begin": 309,
+            "end": 337,
+            "name": "SSTORE",
+            "source": 0
+        }
+    ],
+    ".data": {
+        "0": {
+            ".code": [
+                {
+                    "begin": 418,
+                    "end": 433,
+                    "name": "PUSH [$]",
+                    "source": 0,
+                    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                },
+                {
+                    "begin": 414,
+                    "end": 416,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "A"
+                },
+                {
+                    "begin": 407,
+                    "end": 434,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 452,
+                    "end": 465,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                },
+                {
+                    "begin": 448,
+                    "end": 450,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "B"
+                },
+                {
+                    "begin": 441,
+                    "end": 466,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 484,
+                    "end": 499,
+                    "name": "PUSH [$]",
+                    "source": 0,
+                    "value": "0000000000000000000000000000000000000000000000000000000000000001"
+                },
+                {
+                    "begin": 480,
+                    "end": 482,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "C"
+                },
+                {
+                    "begin": 473,
+                    "end": 500,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 518,
+                    "end": 531,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "0000000000000000000000000000000000000000000000000000000000000001"
+                },
+                {
+                    "begin": 514,
+                    "end": 516,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "D"
+                },
+                {
+                    "begin": 507,
+                    "end": 532,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 550,
+                    "end": 567,
+                    "name": "PUSH [$]",
+                    "source": 0,
+                    "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+                },
+                {
+                    "begin": 546,
+                    "end": 548,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "E"
+                },
+                {
+                    "begin": 539,
+                    "end": 568,
+                    "name": "SSTORE",
+                    "source": 0
+                },
+                {
+                    "begin": 586,
+                    "end": 601,
+                    "name": "PUSH #[$]",
+                    "source": 0,
+                    "value": "000000000000000000000000000000000000000000000000ffffffffffffffff"
+                },
+                {
+                    "begin": 582,
+                    "end": 584,
+                    "name": "PUSH",
+                    "source": 0,
+                    "value": "F"
+                },
+                {
+                    "begin": 575,
+                    "end": 602,
+                    "name": "SSTORE",
+                    "source": 0
+                }
+            ],
+            ".data": {
+                "0": {
+                    ".code": [
+                        {
+                            "begin": 658,
+                            "end": 673,
+                            "name": "PUSH [$]",
+                            "source": 0,
+                            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                        },
+                        {
+                            "begin": 654,
+                            "end": 656,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "10"
+                        },
+                        {
+                            "begin": 647,
+                            "end": 674,
+                            "name": "SSTORE",
+                            "source": 0
+                        },
+                        {
+                            "begin": 694,
+                            "end": 707,
+                            "name": "PUSH #[$]",
+                            "source": 0,
+                            "value": "0000000000000000000000000000000000000000000000000000000000000000"
+                        },
+                        {
+                            "begin": 690,
+                            "end": 692,
+                            "name": "PUSH",
+                            "source": 0,
+                            "value": "11"
+                        },
+                        {
+                            "begin": 683,
+                            "end": 708,
+                            "name": "SSTORE",
+                            "source": 0
+                        }
+                    ],
+                    ".data": {
+                        "0": {
+                            ".code": [
+                                {
+                                    "begin": 761,
+                                    "end": 770,
+                                    "name": "INVALID",
+                                    "source": 0
+                                }
+                            ]
+                        }
+                    }
+                },
+                "1": {
+                    ".code": [
+                        {
+                            "begin": 833,
+                            "end": 842,
+                            "name": "INVALID",
+                            "source": 0
+                        }
+                    ]
+                }
+            }
+        },
+        "ACAF3289D7B601CBD114FB36C4D29C85BBFD5E133F14CB355C3FD8D99367964F": "48656c6c6f2c20576f726c6421"
+    },
+    "sourceList": [
+        "<stdin>"
+    ]
+}
diff --git a/compiler/test/cmdlineTests/ast_compact_json_no_pretty_json/output b/compiler/test/cmdlineTests/ast_compact_json_no_pretty_json/output
new file mode 100644
index 00000000..fb79fd52
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_compact_json_no_pretty_json/output
@@ -0,0 +1,5 @@
+JSON AST (compact format):
+
+
+======= ast_compact_json_no_pretty_json/input.sol =======
+{"absolutePath":"ast_compact_json_no_pretty_json/input.sol","exportedSymbols":{"C":[2]},"id":3,"license":"GPL-3.0","nodeType":"SourceUnit","nodes":[{"id":1,"literals":["solidity",">=","0.0"],"nodeType":"PragmaDirective","src":"36:22:0"},{"abstract":false,"baseContracts":[],"canonicalName":"C","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"id":2,"linearizedBaseContracts":[2],"name":"C","nameLocation":"69:1:0","nodeType":"ContractDefinition","nodes":[],"scope":3,"src":"60:13:0","usedErrors":[],"usedEvents":[]}],"src":"36:38:0"}
diff --git a/compiler/test/cmdlineTests/ast_compact_json_with_base_path/output b/compiler/test/cmdlineTests/ast_compact_json_with_base_path/output
new file mode 100644
index 00000000..5c5c6ffd
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_compact_json_with_base_path/output
@@ -0,0 +1,94 @@
+JSON AST (compact format):
+
+
+======= ast_compact_json_with_base_path/c.sol =======
+{
+  "absolutePath": "ast_compact_json_with_base_path/c.sol",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 4,
+      "literals":
+      [
+        "solidity",
+        ">=",
+        "0.0"
+      ],
+      "nodeType": "PragmaDirective",
+      "src": "36:22:0"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "69:1:0",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 6,
+      "src": "60:13:0",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "36:38:0"
+}
+======= ast_compact_json_with_base_path/input.sol =======
+{
+  "absolutePath": "ast_compact_json_with_base_path/input.sol",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 3,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 1,
+      "literals":
+      [
+        "solidity",
+        ">=",
+        "0.0"
+      ],
+      "nodeType": "PragmaDirective",
+      "src": "36:22:1"
+    },
+    {
+      "absolutePath": "ast_compact_json_with_base_path/c.sol",
+      "file": "./c.sol",
+      "id": 2,
+      "nameLocation": "-1:-1:-1",
+      "nodeType": "ImportDirective",
+      "scope": 3,
+      "sourceUnit": 6,
+      "src": "60:17:1",
+      "symbolAliases": [],
+      "unitAlias": ""
+    }
+  ],
+  "src": "36:42:1"
+}
diff --git a/compiler/test/cmdlineTests/ast_ir/args b/compiler/test/cmdlineTests/ast_ir/args
new file mode 100644
index 00000000..d254bff8
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_ir/args
@@ -0,0 +1 @@
+--ir-ast-json --ir-optimized-ast-json --optimize --pretty-json --json-indent 4
diff --git a/compiler/test/cmdlineTests/ast_ir/input.sol b/compiler/test/cmdlineTests/ast_ir/input.sol
new file mode 100644
index 00000000..f123f6c8
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_ir/input.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/ast_ir/output b/compiler/test/cmdlineTests/ast_ir/output
new file mode 100644
index 00000000..cca31349
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_ir/output
@@ -0,0 +1,1078 @@
+IR AST:
+{
+    "code":
+    {
+        "block":
+        {
+            "nativeSrc": "59:790:0",
+            "nodeType": "YulBlock",
+            "src": "-1:-1:0",
+            "statements":
+            [
+                {
+                    "expression":
+                    {
+                        "arguments":
+                        [
+                            {
+                                "kind": "number",
+                                "nativeSrc": "118:2:0",
+                                "nodeType": "YulLiteral",
+                                "src": "60:13:0",
+                                "type": "",
+                                "value": "64"
+                            },
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "134:3:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "128"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "memoryguard",
+                                    "nativeSrc": "122:11:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "122:16:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            }
+                        ],
+                        "functionName":
+                        {
+                            "name": "mstore",
+                            "nativeSrc": "111:6:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "111:28:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "nativeSrc": "111:28:0",
+                    "nodeType": "YulExpressionStatement",
+                    "src": "60:13:0"
+                },
+                {
+                    "body":
+                    {
+                        "nativeSrc": "163:83:0",
+                        "nodeType": "YulBlock",
+                        "src": "60:13:0",
+                        "statements":
+                        [
+                            {
+                                "expression":
+                                {
+                                    "arguments": [],
+                                    "functionName":
+                                    {
+                                        "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                                        "nativeSrc": "165:77:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    },
+                                    "nativeSrc": "165:79:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "165:79:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "60:13:0"
+                            }
+                        ]
+                    },
+                    "condition":
+                    {
+                        "arguments": [],
+                        "functionName":
+                        {
+                            "name": "callvalue",
+                            "nativeSrc": "151:9:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "151:11:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "nativeSrc": "148:98:0",
+                    "nodeType": "YulIf",
+                    "src": "60:13:0"
+                },
+                {
+                    "expression":
+                    {
+                        "arguments": [],
+                        "functionName":
+                        {
+                            "name": "constructor_C_2",
+                            "nativeSrc": "256:15:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "256:17:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "nativeSrc": "256:17:0",
+                    "nodeType": "YulExpressionStatement",
+                    "src": "60:13:0"
+                },
+                {
+                    "nativeSrc": "283:30:0",
+                    "nodeType": "YulVariableDeclaration",
+                    "src": "60:13:0",
+                    "value":
+                    {
+                        "arguments": [],
+                        "functionName":
+                        {
+                            "name": "allocate_unbounded",
+                            "nativeSrc": "293:18:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "293:20:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "variables":
+                    [
+                        {
+                            "name": "_1",
+                            "nativeSrc": "287:2:0",
+                            "nodeType": "YulTypedName",
+                            "src": "60:13:0",
+                            "type": ""
+                        }
+                    ]
+                },
+                {
+                    "expression":
+                    {
+                        "arguments":
+                        [
+                            {
+                                "name": "_1",
+                                "nativeSrc": "331:2:0",
+                                "nodeType": "YulIdentifier",
+                                "src": "60:13:0"
+                            },
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "hexValue": "435f325f6465706c6f796564",
+                                        "kind": "string",
+                                        "nativeSrc": "346:14:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "C_2_deployed"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "dataoffset",
+                                    "nativeSrc": "335:10:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "335:26:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "hexValue": "435f325f6465706c6f796564",
+                                        "kind": "string",
+                                        "nativeSrc": "372:14:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "C_2_deployed"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "datasize",
+                                    "nativeSrc": "363:8:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "363:24:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            }
+                        ],
+                        "functionName":
+                        {
+                            "name": "codecopy",
+                            "nativeSrc": "322:8:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "322:66:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "nativeSrc": "322:66:0",
+                    "nodeType": "YulExpressionStatement",
+                    "src": "60:13:0"
+                },
+                {
+                    "expression":
+                    {
+                        "arguments":
+                        [
+                            {
+                                "name": "_1",
+                                "nativeSrc": "405:2:0",
+                                "nodeType": "YulIdentifier",
+                                "src": "60:13:0"
+                            },
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "hexValue": "435f325f6465706c6f796564",
+                                        "kind": "string",
+                                        "nativeSrc": "418:14:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "C_2_deployed"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "datasize",
+                                    "nativeSrc": "409:8:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "409:24:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            }
+                        ],
+                        "functionName":
+                        {
+                            "name": "return",
+                            "nativeSrc": "398:6:0",
+                            "nodeType": "YulIdentifier",
+                            "src": "60:13:0"
+                        },
+                        "nativeSrc": "398:36:0",
+                        "nodeType": "YulFunctionCall",
+                        "src": "60:13:0"
+                    },
+                    "nativeSrc": "398:36:0",
+                    "nodeType": "YulExpressionStatement",
+                    "src": "60:13:0"
+                },
+                {
+                    "body":
+                    {
+                        "nativeSrc": "484:43:0",
+                        "nodeType": "YulBlock",
+                        "src": "60:13:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "498:19:0",
+                                "nodeType": "YulAssignment",
+                                "src": "60:13:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "514:2:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "60:13:0",
+                                            "type": "",
+                                            "value": "64"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "mload",
+                                        "nativeSrc": "508:5:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    },
+                                    "nativeSrc": "508:9:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "60:13:0"
+                                },
+                                "variableNames":
+                                [
+                                    {
+                                        "name": "memPtr",
+                                        "nativeSrc": "498:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    "name": "allocate_unbounded",
+                    "nativeSrc": "444:83:0",
+                    "nodeType": "YulFunctionDefinition",
+                    "returnVariables":
+                    [
+                        {
+                            "name": "memPtr",
+                            "nativeSrc": "477:6:0",
+                            "nodeType": "YulTypedName",
+                            "src": "60:13:0",
+                            "type": ""
+                        }
+                    ],
+                    "src": "60:13:0"
+                },
+                {
+                    "body":
+                    {
+                        "nativeSrc": "626:36:0",
+                        "nodeType": "YulBlock",
+                        "src": "60:13:0",
+                        "statements":
+                        [
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "647:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "60:13:0",
+                                            "type": "",
+                                            "value": "0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "650:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "60:13:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "revert",
+                                        "nativeSrc": "640:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    },
+                                    "nativeSrc": "640:12:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "640:12:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "60:13:0"
+                            }
+                        ]
+                    },
+                    "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                    "nativeSrc": "537:125:0",
+                    "nodeType": "YulFunctionDefinition",
+                    "src": "60:13:0"
+                },
+                {
+                    "body":
+                    {
+                        "nativeSrc": "741:59:0",
+                        "nodeType": "YulBlock",
+                        "src": "60:13:0",
+                        "statements": []
+                    },
+                    "name": "constructor_C_2",
+                    "nativeSrc": "714:86:0",
+                    "nodeType": "YulFunctionDefinition",
+                    "src": "60:13:0"
+                }
+            ]
+        },
+        "nodeType": "YulCode"
+    },
+    "name": "C_2",
+    "nodeType": "YulObject",
+    "subObjects":
+    [
+        {
+            "code":
+            {
+                "block":
+                {
+                    "nativeSrc": "929:588:0",
+                    "nodeType": "YulBlock",
+                    "src": "-1:-1:0",
+                    "statements":
+                    [
+                        {
+                            "expression":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "996:2:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "64"
+                                    },
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "kind": "number",
+                                                "nativeSrc": "1012:3:0",
+                                                "nodeType": "YulLiteral",
+                                                "src": "60:13:0",
+                                                "type": "",
+                                                "value": "128"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "memoryguard",
+                                            "nativeSrc": "1000:11:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "60:13:0"
+                                        },
+                                        "nativeSrc": "1000:16:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "60:13:0"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "mstore",
+                                    "nativeSrc": "989:6:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "989:28:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "989:28:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:13:0"
+                        },
+                        {
+                            "expression":
+                            {
+                                "arguments": [],
+                                "functionName":
+                                {
+                                    "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                                    "nativeSrc": "1031:77:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "1031:79:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "1031:79:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:13:0"
+                        },
+                        {
+                            "body":
+                            {
+                                "nativeSrc": "1177:77:0",
+                                "nodeType": "YulBlock",
+                                "src": "60:13:0",
+                                "statements":
+                                [
+                                    {
+                                        "nativeSrc": "1195:44:0",
+                                        "nodeType": "YulAssignment",
+                                        "src": "60:13:0",
+                                        "value":
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "1228:3:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "224"
+                                                },
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "1233:5:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "60:13:0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "shr",
+                                                "nativeSrc": "1224:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            },
+                                            "nativeSrc": "1224:15:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "60:13:0"
+                                        },
+                                        "variableNames":
+                                        [
+                                            {
+                                                "name": "newValue",
+                                                "nativeSrc": "1195:8:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            }
+                                        ]
+                                    }
+                                ]
+                            },
+                            "name": "shift_right_224_unsigned",
+                            "nativeSrc": "1124:130:0",
+                            "nodeType": "YulFunctionDefinition",
+                            "parameters":
+                            [
+                                {
+                                    "name": "value",
+                                    "nativeSrc": "1158:5:0",
+                                    "nodeType": "YulTypedName",
+                                    "src": "60:13:0",
+                                    "type": ""
+                                }
+                            ],
+                            "returnVariables":
+                            [
+                                {
+                                    "name": "newValue",
+                                    "nativeSrc": "1168:8:0",
+                                    "nodeType": "YulTypedName",
+                                    "src": "60:13:0",
+                                    "type": ""
+                                }
+                            ],
+                            "src": "60:13:0"
+                        },
+                        {
+                            "body":
+                            {
+                                "nativeSrc": "1308:51:0",
+                                "nodeType": "YulBlock",
+                                "src": "60:13:0",
+                                "statements":
+                                [
+                                    {
+                                        "nativeSrc": "1326:19:0",
+                                        "nodeType": "YulAssignment",
+                                        "src": "60:13:0",
+                                        "value":
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "1342:2:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "64"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "mload",
+                                                "nativeSrc": "1336:5:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            },
+                                            "nativeSrc": "1336:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "60:13:0"
+                                        },
+                                        "variableNames":
+                                        [
+                                            {
+                                                "name": "memPtr",
+                                                "nativeSrc": "1326:6:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            }
+                                        ]
+                                    }
+                                ]
+                            },
+                            "name": "allocate_unbounded",
+                            "nativeSrc": "1268:91:0",
+                            "nodeType": "YulFunctionDefinition",
+                            "returnVariables":
+                            [
+                                {
+                                    "name": "memPtr",
+                                    "nativeSrc": "1301:6:0",
+                                    "nodeType": "YulTypedName",
+                                    "src": "60:13:0",
+                                    "type": ""
+                                }
+                            ],
+                            "src": "60:13:0"
+                        },
+                        {
+                            "body":
+                            {
+                                "nativeSrc": "1462:44:0",
+                                "nodeType": "YulBlock",
+                                "src": "60:13:0",
+                                "statements":
+                                [
+                                    {
+                                        "expression":
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "1487:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "1490:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "revert",
+                                                "nativeSrc": "1480:6:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            },
+                                            "nativeSrc": "1480:12:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "60:13:0"
+                                        },
+                                        "nativeSrc": "1480:12:0",
+                                        "nodeType": "YulExpressionStatement",
+                                        "src": "60:13:0"
+                                    }
+                                ]
+                            },
+                            "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                            "nativeSrc": "1373:133:0",
+                            "nodeType": "YulFunctionDefinition",
+                            "src": "60:13:0"
+                        }
+                    ]
+                },
+                "nodeType": "YulCode"
+            },
+            "name": "C_2_deployed",
+            "nodeType": "YulObject",
+            "subObjects":
+            [
+                {
+                    "nodeType": "YulData",
+                    "value": "<BYTECODE REMOVED>"
+                }
+            ]
+        }
+    ]
+}
+Optimized IR AST:
+{
+    "code":
+    {
+        "block":
+        {
+            "nativeSrc": "59:790:0",
+            "nodeType": "YulBlock",
+            "src": "-1:-1:0",
+            "statements":
+            [
+                {
+                    "nativeSrc": "59:790:0",
+                    "nodeType": "YulBlock",
+                    "src": "-1:-1:0",
+                    "statements":
+                    [
+                        {
+                            "nativeSrc": "122:16:0",
+                            "nodeType": "YulVariableDeclaration",
+                            "src": "60:13:0",
+                            "value":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "134:3:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "0x80"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "memoryguard",
+                                    "nativeSrc": "122:11:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "122:16:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "variables":
+                            [
+                                {
+                                    "name": "_1",
+                                    "nativeSrc": "122:16:0",
+                                    "nodeType": "YulTypedName",
+                                    "src": "60:13:0",
+                                    "type": ""
+                                }
+                            ]
+                        },
+                        {
+                            "expression":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "118:2:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "64"
+                                    },
+                                    {
+                                        "name": "_1",
+                                        "nativeSrc": "122:16:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "mstore",
+                                    "nativeSrc": "111:6:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "111:28:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "111:28:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:13:0"
+                        },
+                        {
+                            "body":
+                            {
+                                "nativeSrc": "163:83:0",
+                                "nodeType": "YulBlock",
+                                "src": "60:13:0",
+                                "statements":
+                                [
+                                    {
+                                        "expression":
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "650:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "650:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "60:13:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "revert",
+                                                "nativeSrc": "640:6:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "60:13:0"
+                                            },
+                                            "nativeSrc": "640:12:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "60:13:0"
+                                        },
+                                        "nativeSrc": "640:12:0",
+                                        "nodeType": "YulExpressionStatement",
+                                        "src": "60:13:0"
+                                    }
+                                ]
+                            },
+                            "condition":
+                            {
+                                "arguments": [],
+                                "functionName":
+                                {
+                                    "name": "callvalue",
+                                    "nativeSrc": "151:9:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "151:11:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "148:98:0",
+                            "nodeType": "YulIf",
+                            "src": "60:13:0"
+                        },
+                        {
+                            "nativeSrc": "363:24:0",
+                            "nodeType": "YulVariableDeclaration",
+                            "src": "60:13:0",
+                            "value":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "hexValue": "435f325f6465706c6f796564",
+                                        "kind": "string",
+                                        "nativeSrc": "372:14:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:13:0",
+                                        "type": "",
+                                        "value": "C_2_deployed"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "datasize",
+                                    "nativeSrc": "363:8:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "363:24:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "variables":
+                            [
+                                {
+                                    "name": "_2",
+                                    "nativeSrc": "363:24:0",
+                                    "nodeType": "YulTypedName",
+                                    "src": "60:13:0",
+                                    "type": ""
+                                }
+                            ]
+                        },
+                        {
+                            "expression":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "name": "_1",
+                                        "nativeSrc": "331:2:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    },
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "hexValue": "435f325f6465706c6f796564",
+                                                "kind": "string",
+                                                "nativeSrc": "346:14:0",
+                                                "nodeType": "YulLiteral",
+                                                "src": "60:13:0",
+                                                "type": "",
+                                                "value": "C_2_deployed"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "dataoffset",
+                                            "nativeSrc": "335:10:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "60:13:0"
+                                        },
+                                        "nativeSrc": "335:26:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "60:13:0"
+                                    },
+                                    {
+                                        "name": "_2",
+                                        "nativeSrc": "363:24:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "codecopy",
+                                    "nativeSrc": "322:8:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "322:66:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "322:66:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:13:0"
+                        },
+                        {
+                            "expression":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "name": "_1",
+                                        "nativeSrc": "405:2:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    },
+                                    {
+                                        "name": "_2",
+                                        "nativeSrc": "409:24:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "60:13:0"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "return",
+                                    "nativeSrc": "398:6:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:13:0"
+                                },
+                                "nativeSrc": "398:36:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:13:0"
+                            },
+                            "nativeSrc": "398:36:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:13:0"
+                        }
+                    ]
+                }
+            ]
+        },
+        "nodeType": "YulCode"
+    },
+    "name": "C_2",
+    "nodeType": "YulObject",
+    "subObjects":
+    [
+        {
+            "code":
+            {
+                "block":
+                {
+                    "nativeSrc": "929:588:0",
+                    "nodeType": "YulBlock",
+                    "src": "-1:-1:0",
+                    "statements":
+                    [
+                        {
+                            "nativeSrc": "929:588:0",
+                            "nodeType": "YulBlock",
+                            "src": "-1:-1:0",
+                            "statements":
+                            [
+                                {
+                                    "expression":
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "kind": "number",
+                                                "nativeSrc": "1490:1:0",
+                                                "nodeType": "YulLiteral",
+                                                "src": "60:13:0",
+                                                "type": "",
+                                                "value": "0"
+                                            },
+                                            {
+                                                "kind": "number",
+                                                "nativeSrc": "1490:1:0",
+                                                "nodeType": "YulLiteral",
+                                                "src": "60:13:0",
+                                                "type": "",
+                                                "value": "0"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "revert",
+                                            "nativeSrc": "1480:6:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "60:13:0"
+                                        },
+                                        "nativeSrc": "1480:12:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "60:13:0"
+                                    },
+                                    "nativeSrc": "1480:12:0",
+                                    "nodeType": "YulExpressionStatement",
+                                    "src": "60:13:0"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                "nodeType": "YulCode"
+            },
+            "name": "C_2_deployed",
+            "nodeType": "YulObject",
+            "subObjects":
+            [
+                {
+                    "nodeType": "YulData",
+                    "value": "<BYTECODE REMOVED>"
+                }
+            ]
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/ast_json_import_wrong_evmVersion/err b/compiler/test/cmdlineTests/ast_json_import_wrong_evmVersion/err
new file mode 100644
index 00000000..b969e349
--- /dev/null
+++ b/compiler/test/cmdlineTests/ast_json_import_wrong_evmVersion/err
@@ -0,0 +1,2 @@
+Warning: Support for EVM versions older than constantinople is deprecated and will be removed in the future.
+Error: Failed to import AST: Imported tree evm version differs from configured evm version!
diff --git a/compiler/test/cmdlineTests/combined_json_generated_sources/output b/compiler/test/cmdlineTests/combined_json_generated_sources/output
new file mode 100644
index 00000000..5ef9078d
--- /dev/null
+++ b/compiler/test/cmdlineTests/combined_json_generated_sources/output
@@ -0,0 +1,1080 @@
+{
+  "contracts":
+  {
+    "combined_json_generated_sources/input.sol:C":
+    {
+      "generated-sources": [],
+      "generated-sources-runtime":
+      [
+        {
+          "ast":
+          {
+            "nativeSrc": "0:1856:1",
+            "nodeType": "YulBlock",
+            "src": "0:1856:1",
+            "statements":
+            [
+              {
+                "body":
+                {
+                  "nativeSrc": "47:35:1",
+                  "nodeType": "YulBlock",
+                  "src": "47:35:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "57:19:1",
+                      "nodeType": "YulAssignment",
+                      "src": "57:19:1",
+                      "value":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "73:2:1",
+                            "nodeType": "YulLiteral",
+                            "src": "73:2:1",
+                            "type": "",
+                            "value": "64"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "mload",
+                          "nativeSrc": "67:5:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "67:5:1"
+                        },
+                        "nativeSrc": "67:9:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "67:9:1"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "memPtr",
+                          "nativeSrc": "57:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "57:6:1"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "name": "allocate_unbounded",
+                "nativeSrc": "7:75:1",
+                "nodeType": "YulFunctionDefinition",
+                "returnVariables":
+                [
+                  {
+                    "name": "memPtr",
+                    "nativeSrc": "40:6:1",
+                    "nodeType": "YulTypedName",
+                    "src": "40:6:1",
+                    "type": ""
+                  }
+                ],
+                "src": "7:75:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "177:28:1",
+                  "nodeType": "YulBlock",
+                  "src": "177:28:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "194:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "194:1:1",
+                            "type": "",
+                            "value": "0"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "197:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "197:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "revert",
+                          "nativeSrc": "187:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "187:6:1"
+                        },
+                        "nativeSrc": "187:12:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "187:12:1"
+                      },
+                      "nativeSrc": "187:12:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "187:12:1"
+                    }
+                  ]
+                },
+                "name": "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b",
+                "nativeSrc": "88:117:1",
+                "nodeType": "YulFunctionDefinition",
+                "src": "88:117:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "300:28:1",
+                  "nodeType": "YulBlock",
+                  "src": "300:28:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "317:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "317:1:1",
+                            "type": "",
+                            "value": "0"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "320:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "320:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "revert",
+                          "nativeSrc": "310:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "310:6:1"
+                        },
+                        "nativeSrc": "310:12:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "310:12:1"
+                      },
+                      "nativeSrc": "310:12:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "310:12:1"
+                    }
+                  ]
+                },
+                "name": "revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db",
+                "nativeSrc": "211:117:1",
+                "nodeType": "YulFunctionDefinition",
+                "src": "211:117:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "423:28:1",
+                  "nodeType": "YulBlock",
+                  "src": "423:28:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "440:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "440:1:1",
+                            "type": "",
+                            "value": "0"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "443:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "443:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "revert",
+                          "nativeSrc": "433:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "433:6:1"
+                        },
+                        "nativeSrc": "433:12:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "433:12:1"
+                      },
+                      "nativeSrc": "433:12:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "433:12:1"
+                    }
+                  ]
+                },
+                "name": "revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d",
+                "nativeSrc": "334:117:1",
+                "nodeType": "YulFunctionDefinition",
+                "src": "334:117:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "546:28:1",
+                  "nodeType": "YulBlock",
+                  "src": "546:28:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "563:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "563:1:1",
+                            "type": "",
+                            "value": "0"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "566:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "566:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "revert",
+                          "nativeSrc": "556:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "556:6:1"
+                        },
+                        "nativeSrc": "556:12:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "556:12:1"
+                      },
+                      "nativeSrc": "556:12:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "556:12:1"
+                    }
+                  ]
+                },
+                "name": "revert_error_15abf5612cd996bc235ba1e55a4a30ac60e6bb601ff7ba4ad3f179b6be8d0490",
+                "nativeSrc": "457:117:1",
+                "nodeType": "YulFunctionDefinition",
+                "src": "457:117:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "669:28:1",
+                  "nodeType": "YulBlock",
+                  "src": "669:28:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "kind": "number",
+                            "nativeSrc": "686:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "686:1:1",
+                            "type": "",
+                            "value": "0"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "689:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "689:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "revert",
+                          "nativeSrc": "679:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "679:6:1"
+                        },
+                        "nativeSrc": "679:12:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "679:12:1"
+                      },
+                      "nativeSrc": "679:12:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "679:12:1"
+                    }
+                  ]
+                },
+                "name": "revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef",
+                "nativeSrc": "580:117:1",
+                "nodeType": "YulFunctionDefinition",
+                "src": "580:117:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "810:478:1",
+                  "nodeType": "YulBlock",
+                  "src": "810:478:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "859:83:1",
+                        "nodeType": "YulBlock",
+                        "src": "859:83:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments": [],
+                              "functionName":
+                              {
+                                "name": "revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d",
+                                "nativeSrc": "861:77:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "861:77:1"
+                              },
+                              "nativeSrc": "861:79:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "861:79:1"
+                            },
+                            "nativeSrc": "861:79:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "861:79:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "arguments":
+                            [
+                              {
+                                "arguments":
+                                [
+                                  {
+                                    "name": "offset",
+                                    "nativeSrc": "838:6:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "838:6:1"
+                                  },
+                                  {
+                                    "kind": "number",
+                                    "nativeSrc": "846:4:1",
+                                    "nodeType": "YulLiteral",
+                                    "src": "846:4:1",
+                                    "type": "",
+                                    "value": "0x1f"
+                                  }
+                                ],
+                                "functionName":
+                                {
+                                  "name": "add",
+                                  "nativeSrc": "834:3:1",
+                                  "nodeType": "YulIdentifier",
+                                  "src": "834:3:1"
+                                },
+                                "nativeSrc": "834:17:1",
+                                "nodeType": "YulFunctionCall",
+                                "src": "834:17:1"
+                              },
+                              {
+                                "name": "end",
+                                "nativeSrc": "853:3:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "853:3:1"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "slt",
+                              "nativeSrc": "830:3:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "830:3:1"
+                            },
+                            "nativeSrc": "830:27:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "830:27:1"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "iszero",
+                          "nativeSrc": "823:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "823:6:1"
+                        },
+                        "nativeSrc": "823:35:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "823:35:1"
+                      },
+                      "nativeSrc": "820:122:1",
+                      "nodeType": "YulIf",
+                      "src": "820:122:1"
+                    },
+                    {
+                      "nativeSrc": "951:30:1",
+                      "nodeType": "YulAssignment",
+                      "src": "951:30:1",
+                      "value":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "name": "offset",
+                            "nativeSrc": "974:6:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "974:6:1"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "calldataload",
+                          "nativeSrc": "961:12:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "961:12:1"
+                        },
+                        "nativeSrc": "961:20:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "961:20:1"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "length",
+                          "nativeSrc": "951:6:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "951:6:1"
+                        }
+                      ]
+                    },
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "1024:83:1",
+                        "nodeType": "YulBlock",
+                        "src": "1024:83:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments": [],
+                              "functionName":
+                              {
+                                "name": "revert_error_15abf5612cd996bc235ba1e55a4a30ac60e6bb601ff7ba4ad3f179b6be8d0490",
+                                "nativeSrc": "1026:77:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1026:77:1"
+                              },
+                              "nativeSrc": "1026:79:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "1026:79:1"
+                            },
+                            "nativeSrc": "1026:79:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "1026:79:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "name": "length",
+                            "nativeSrc": "996:6:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "996:6:1"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "1004:18:1",
+                            "nodeType": "YulLiteral",
+                            "src": "1004:18:1",
+                            "type": "",
+                            "value": "0xffffffffffffffff"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "gt",
+                          "nativeSrc": "993:2:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "993:2:1"
+                        },
+                        "nativeSrc": "993:30:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "993:30:1"
+                      },
+                      "nativeSrc": "990:117:1",
+                      "nodeType": "YulIf",
+                      "src": "990:117:1"
+                    },
+                    {
+                      "nativeSrc": "1116:29:1",
+                      "nodeType": "YulAssignment",
+                      "src": "1116:29:1",
+                      "value":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "name": "offset",
+                            "nativeSrc": "1132:6:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "1132:6:1"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "1140:4:1",
+                            "nodeType": "YulLiteral",
+                            "src": "1140:4:1",
+                            "type": "",
+                            "value": "0x20"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "add",
+                          "nativeSrc": "1128:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "1128:3:1"
+                        },
+                        "nativeSrc": "1128:17:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "1128:17:1"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "arrayPos",
+                          "nativeSrc": "1116:8:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "1116:8:1"
+                        }
+                      ]
+                    },
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "1199:83:1",
+                        "nodeType": "YulBlock",
+                        "src": "1199:83:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments": [],
+                              "functionName":
+                              {
+                                "name": "revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef",
+                                "nativeSrc": "1201:77:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1201:77:1"
+                              },
+                              "nativeSrc": "1201:79:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "1201:79:1"
+                            },
+                            "nativeSrc": "1201:79:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "1201:79:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "arguments":
+                            [
+                              {
+                                "name": "arrayPos",
+                                "nativeSrc": "1164:8:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1164:8:1"
+                              },
+                              {
+                                "arguments":
+                                [
+                                  {
+                                    "name": "length",
+                                    "nativeSrc": "1178:6:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "1178:6:1"
+                                  },
+                                  {
+                                    "kind": "number",
+                                    "nativeSrc": "1186:4:1",
+                                    "nodeType": "YulLiteral",
+                                    "src": "1186:4:1",
+                                    "type": "",
+                                    "value": "0x20"
+                                  }
+                                ],
+                                "functionName":
+                                {
+                                  "name": "mul",
+                                  "nativeSrc": "1174:3:1",
+                                  "nodeType": "YulIdentifier",
+                                  "src": "1174:3:1"
+                                },
+                                "nativeSrc": "1174:17:1",
+                                "nodeType": "YulFunctionCall",
+                                "src": "1174:17:1"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "add",
+                              "nativeSrc": "1160:3:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1160:3:1"
+                            },
+                            "nativeSrc": "1160:32:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "1160:32:1"
+                          },
+                          {
+                            "name": "end",
+                            "nativeSrc": "1194:3:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "1194:3:1"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "gt",
+                          "nativeSrc": "1157:2:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "1157:2:1"
+                        },
+                        "nativeSrc": "1157:41:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "1157:41:1"
+                      },
+                      "nativeSrc": "1154:128:1",
+                      "nodeType": "YulIf",
+                      "src": "1154:128:1"
+                    }
+                  ]
+                },
+                "name": "abi_decode_t_array$_t_uint256_$dyn_calldata_ptr",
+                "nativeSrc": "720:568:1",
+                "nodeType": "YulFunctionDefinition",
+                "parameters":
+                [
+                  {
+                    "name": "offset",
+                    "nativeSrc": "777:6:1",
+                    "nodeType": "YulTypedName",
+                    "src": "777:6:1",
+                    "type": ""
+                  },
+                  {
+                    "name": "end",
+                    "nativeSrc": "785:3:1",
+                    "nodeType": "YulTypedName",
+                    "src": "785:3:1",
+                    "type": ""
+                  }
+                ],
+                "returnVariables":
+                [
+                  {
+                    "name": "arrayPos",
+                    "nativeSrc": "793:8:1",
+                    "nodeType": "YulTypedName",
+                    "src": "793:8:1",
+                    "type": ""
+                  },
+                  {
+                    "name": "length",
+                    "nativeSrc": "803:6:1",
+                    "nodeType": "YulTypedName",
+                    "src": "803:6:1",
+                    "type": ""
+                  }
+                ],
+                "src": "720:568:1"
+              },
+              {
+                "body":
+                {
+                  "nativeSrc": "1395:458:1",
+                  "nodeType": "YulBlock",
+                  "src": "1395:458:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "1441:83:1",
+                        "nodeType": "YulBlock",
+                        "src": "1441:83:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments": [],
+                              "functionName":
+                              {
+                                "name": "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b",
+                                "nativeSrc": "1443:77:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1443:77:1"
+                              },
+                              "nativeSrc": "1443:79:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "1443:79:1"
+                            },
+                            "nativeSrc": "1443:79:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "1443:79:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "arguments":
+                            [
+                              {
+                                "name": "dataEnd",
+                                "nativeSrc": "1416:7:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1416:7:1"
+                              },
+                              {
+                                "name": "headStart",
+                                "nativeSrc": "1425:9:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1425:9:1"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "sub",
+                              "nativeSrc": "1412:3:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1412:3:1"
+                            },
+                            "nativeSrc": "1412:23:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "1412:23:1"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "1437:2:1",
+                            "nodeType": "YulLiteral",
+                            "src": "1437:2:1",
+                            "type": "",
+                            "value": "32"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "slt",
+                          "nativeSrc": "1408:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "1408:3:1"
+                        },
+                        "nativeSrc": "1408:32:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "1408:32:1"
+                      },
+                      "nativeSrc": "1405:119:1",
+                      "nodeType": "YulIf",
+                      "src": "1405:119:1"
+                    },
+                    {
+                      "nativeSrc": "1534:312:1",
+                      "nodeType": "YulBlock",
+                      "src": "1534:312:1",
+                      "statements":
+                      [
+                        {
+                          "nativeSrc": "1549:45:1",
+                          "nodeType": "YulVariableDeclaration",
+                          "src": "1549:45:1",
+                          "value":
+                          {
+                            "arguments":
+                            [
+                              {
+                                "arguments":
+                                [
+                                  {
+                                    "name": "headStart",
+                                    "nativeSrc": "1580:9:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "1580:9:1"
+                                  },
+                                  {
+                                    "kind": "number",
+                                    "nativeSrc": "1591:1:1",
+                                    "nodeType": "YulLiteral",
+                                    "src": "1591:1:1",
+                                    "type": "",
+                                    "value": "0"
+                                  }
+                                ],
+                                "functionName":
+                                {
+                                  "name": "add",
+                                  "nativeSrc": "1576:3:1",
+                                  "nodeType": "YulIdentifier",
+                                  "src": "1576:3:1"
+                                },
+                                "nativeSrc": "1576:17:1",
+                                "nodeType": "YulFunctionCall",
+                                "src": "1576:17:1"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "calldataload",
+                              "nativeSrc": "1563:12:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1563:12:1"
+                            },
+                            "nativeSrc": "1563:31:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "1563:31:1"
+                          },
+                          "variables":
+                          [
+                            {
+                              "name": "offset",
+                              "nativeSrc": "1553:6:1",
+                              "nodeType": "YulTypedName",
+                              "src": "1553:6:1",
+                              "type": ""
+                            }
+                          ]
+                        },
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "1641:83:1",
+                            "nodeType": "YulBlock",
+                            "src": "1641:83:1",
+                            "statements":
+                            [
+                              {
+                                "expression":
+                                {
+                                  "arguments": [],
+                                  "functionName":
+                                  {
+                                    "name": "revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db",
+                                    "nativeSrc": "1643:77:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "1643:77:1"
+                                  },
+                                  "nativeSrc": "1643:79:1",
+                                  "nodeType": "YulFunctionCall",
+                                  "src": "1643:79:1"
+                                },
+                                "nativeSrc": "1643:79:1",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "1643:79:1"
+                              }
+                            ]
+                          },
+                          "condition":
+                          {
+                            "arguments":
+                            [
+                              {
+                                "name": "offset",
+                                "nativeSrc": "1613:6:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1613:6:1"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "1621:18:1",
+                                "nodeType": "YulLiteral",
+                                "src": "1621:18:1",
+                                "type": "",
+                                "value": "0xffffffffffffffff"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "gt",
+                              "nativeSrc": "1610:2:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1610:2:1"
+                            },
+                            "nativeSrc": "1610:30:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "1610:30:1"
+                          },
+                          "nativeSrc": "1607:117:1",
+                          "nodeType": "YulIf",
+                          "src": "1607:117:1"
+                        },
+                        {
+                          "nativeSrc": "1738:98:1",
+                          "nodeType": "YulAssignment",
+                          "src": "1738:98:1",
+                          "value":
+                          {
+                            "arguments":
+                            [
+                              {
+                                "arguments":
+                                [
+                                  {
+                                    "name": "headStart",
+                                    "nativeSrc": "1808:9:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "1808:9:1"
+                                  },
+                                  {
+                                    "name": "offset",
+                                    "nativeSrc": "1819:6:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "1819:6:1"
+                                  }
+                                ],
+                                "functionName":
+                                {
+                                  "name": "add",
+                                  "nativeSrc": "1804:3:1",
+                                  "nodeType": "YulIdentifier",
+                                  "src": "1804:3:1"
+                                },
+                                "nativeSrc": "1804:22:1",
+                                "nodeType": "YulFunctionCall",
+                                "src": "1804:22:1"
+                              },
+                              {
+                                "name": "dataEnd",
+                                "nativeSrc": "1828:7:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "1828:7:1"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "abi_decode_t_array$_t_uint256_$dyn_calldata_ptr",
+                              "nativeSrc": "1756:47:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1756:47:1"
+                            },
+                            "nativeSrc": "1756:80:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "1756:80:1"
+                          },
+                          "variableNames":
+                          [
+                            {
+                              "name": "value0",
+                              "nativeSrc": "1738:6:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1738:6:1"
+                            },
+                            {
+                              "name": "value1",
+                              "nativeSrc": "1746:6:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "1746:6:1"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "name": "abi_decode_tuple_t_array$_t_uint256_$dyn_calldata_ptr",
+                "nativeSrc": "1294:559:1",
+                "nodeType": "YulFunctionDefinition",
+                "parameters":
+                [
+                  {
+                    "name": "headStart",
+                    "nativeSrc": "1357:9:1",
+                    "nodeType": "YulTypedName",
+                    "src": "1357:9:1",
+                    "type": ""
+                  },
+                  {
+                    "name": "dataEnd",
+                    "nativeSrc": "1368:7:1",
+                    "nodeType": "YulTypedName",
+                    "src": "1368:7:1",
+                    "type": ""
+                  }
+                ],
+                "returnVariables":
+                [
+                  {
+                    "name": "value0",
+                    "nativeSrc": "1380:6:1",
+                    "nodeType": "YulTypedName",
+                    "src": "1380:6:1",
+                    "type": ""
+                  },
+                  {
+                    "name": "value1",
+                    "nativeSrc": "1388:6:1",
+                    "nodeType": "YulTypedName",
+                    "src": "1388:6:1",
+                    "type": ""
+                  }
+                ],
+                "src": "1294:559:1"
+              }
+            ]
+          },
+          "contents": "{\n\n    function allocate_unbounded() -> memPtr {\n        memPtr := mload(64)\n    }\n\n    function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {\n        revert(0, 0)\n    }\n\n    function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {\n        revert(0, 0)\n    }\n\n    function revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d() {\n        revert(0, 0)\n    }\n\n    function revert_error_15abf5612cd996bc235ba1e55a4a30ac60e6bb601ff7ba4ad3f179b6be8d0490() {\n        revert(0, 0)\n    }\n\n    function revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef() {\n        revert(0, 0)\n    }\n\n    // uint256[]\n    function abi_decode_t_array$_t_uint256_$dyn_calldata_ptr(offset, end) -> arrayPos, length {\n        if iszero(slt(add(offset, 0x1f), end)) { revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d() }\n        length := calldataload(offset)\n        if gt(length, 0xffffffffffffffff) { revert_error_15abf5612cd996bc235ba1e55a4a30ac60e6bb601ff7ba4ad3f179b6be8d0490() }\n        arrayPos := add(offset, 0x20)\n        if gt(add(arrayPos, mul(length, 0x20)), end) { revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef() }\n    }\n\n    function abi_decode_tuple_t_array$_t_uint256_$dyn_calldata_ptr(headStart, dataEnd) -> value0, value1 {\n        if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }\n\n        {\n\n            let offset := calldataload(add(headStart, 0))\n            if gt(offset, 0xffffffffffffffff) { revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() }\n\n            value0, value1 := abi_decode_t_array$_t_uint256_$dyn_calldata_ptr(add(headStart, offset), dataEnd)\n        }\n\n    }\n\n}\n",
+          "id": 1,
+          "language": "Yul",
+          "name": "#utility.yul"
+        }
+      ]
+    }
+  },
+  "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/combined_json_stop_after_parsing/args b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/args
new file mode 100644
index 00000000..692bfd79
--- /dev/null
+++ b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/args
@@ -0,0 +1 @@
+--pretty-json --json-indent 4 --stop-after parsing --combined-json abi,asm,ast,bin,bin-runtime,devdoc,function-debug,function-debug-runtime,generated-sources,generated-sources-runtime,hashes,metadata,opcodes,srcmap,srcmap-runtime,storage-layout,userdoc
diff --git a/compiler/test/cmdlineTests/combined_json_stop_after_parsing/input.sol b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/input.sol
new file mode 100644
index 00000000..a3a86cc8
--- /dev/null
+++ b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/input.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/combined_json_stop_after_parsing/output b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/output
new file mode 100644
index 00000000..32cdd019
--- /dev/null
+++ b/compiler/test/cmdlineTests/combined_json_stop_after_parsing/output
@@ -0,0 +1,53 @@
+{
+    "contracts":
+    {
+        "combined_json_stop_after_parsing/input.sol:C": {}
+    },
+    "sourceList":
+    [
+        "combined_json_stop_after_parsing/input.sol"
+    ],
+    "sources":
+    {
+        "combined_json_stop_after_parsing/input.sol":
+        {
+            "AST":
+            {
+                "absolutePath": "combined_json_stop_after_parsing/input.sol",
+                "id": 3,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            "*"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:18:0"
+                    },
+                    {
+                        "abstract": false,
+                        "baseContracts": [],
+                        "contractDependencies": [],
+                        "contractKind": "contract",
+                        "id": 2,
+                        "name": "C",
+                        "nameLocation": "65:1:0",
+                        "nodeType": "ContractDefinition",
+                        "nodes": [],
+                        "src": "56:13:0",
+                        "usedErrors": [],
+                        "usedEvents": []
+                    }
+                ],
+                "src": "36:34:0"
+            },
+            "id": 0
+        }
+    },
+    "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/combined_json_with_base_path/output b/compiler/test/cmdlineTests/combined_json_with_base_path/output
new file mode 100644
index 00000000..ec9bbcbc
--- /dev/null
+++ b/compiler/test/cmdlineTests/combined_json_with_base_path/output
@@ -0,0 +1,114 @@
+{
+  "contracts":
+  {
+    "combined_json_with_base_path/c.sol:C": {}
+  },
+  "sourceList":
+  [
+    "combined_json_with_base_path/c.sol",
+    "combined_json_with_base_path/input.sol"
+  ],
+  "sources":
+  {
+    "combined_json_with_base_path/c.sol":
+    {
+      "AST":
+      {
+        "absolutePath": "combined_json_with_base_path/c.sol",
+        "exportedSymbols":
+        {
+          "C":
+          [
+            5
+          ]
+        },
+        "id": 6,
+        "license": "GPL-3.0",
+        "nodeType": "SourceUnit",
+        "nodes":
+        [
+          {
+            "id": 4,
+            "literals":
+            [
+              "solidity",
+              ">=",
+              "0.0"
+            ],
+            "nodeType": "PragmaDirective",
+            "src": "36:22:0"
+          },
+          {
+            "abstract": false,
+            "baseContracts": [],
+            "canonicalName": "C",
+            "contractDependencies": [],
+            "contractKind": "contract",
+            "fullyImplemented": true,
+            "id": 5,
+            "linearizedBaseContracts":
+            [
+              5
+            ],
+            "name": "C",
+            "nameLocation": "69:1:0",
+            "nodeType": "ContractDefinition",
+            "nodes": [],
+            "scope": 6,
+            "src": "60:13:0",
+            "usedErrors": [],
+            "usedEvents": []
+          }
+        ],
+        "src": "36:38:0"
+      },
+      "id": 0
+    },
+    "combined_json_with_base_path/input.sol":
+    {
+      "AST":
+      {
+        "absolutePath": "combined_json_with_base_path/input.sol",
+        "exportedSymbols":
+        {
+          "C":
+          [
+            5
+          ]
+        },
+        "id": 3,
+        "license": "GPL-3.0",
+        "nodeType": "SourceUnit",
+        "nodes":
+        [
+          {
+            "id": 1,
+            "literals":
+            [
+              "solidity",
+              ">=",
+              "0.0"
+            ],
+            "nodeType": "PragmaDirective",
+            "src": "36:22:1"
+          },
+          {
+            "absolutePath": "combined_json_with_base_path/c.sol",
+            "file": "./c.sol",
+            "id": 2,
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "ImportDirective",
+            "scope": 3,
+            "sourceUnit": 6,
+            "src": "60:17:1",
+            "symbolAliases": [],
+            "unitAlias": ""
+          }
+        ],
+        "src": "36:42:1"
+      },
+      "id": 1
+    }
+  },
+  "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output
new file mode 100644
index 00000000..a232fed8
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all/output
@@ -0,0 +1,204 @@
+
+======= debug_info_in_yul_and_evm_asm_print_all/input.sol:C =======
+EVM assembly:
+    /* "debug_info_in_yul_and_evm_asm_print_all/input.sol":60:101  contract C {... */
+  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+        /* "debug_info_in_yul_and_evm_asm_print_all/input.sol":60:101  contract C {... */
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+        /* "debug_info_in_yul_and_evm_asm_print_all/input.sol":77:99  function f() public {} */
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+
+IR:
+
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_all/input.sol"
+object "C_6" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("C_6_deployed"), datasize("C_6_deployed"))
+
+        return(_1, datasize("C_6_deployed"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:60:101  "contract C {..."
+        function constructor_C_6() {
+
+            /// @src 0:60:101  "contract C {..."
+
+        }
+        /// @src 0:60:101  "contract C {..."
+
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_all/input.sol"
+    object "C_6_deployed" {
+        code {
+            /// @src 0:60:101  "contract C {..."
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            /// @ast-id 5
+            /// @src 0:77:99  "function f() public {}"
+            function fun_f_5() {
+
+            }
+            /// @src 0:60:101  "contract C {..."
+
+        }
+
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+
+}
+
+
+Optimized IR:
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_all/input.sol"
+object "C_6" {
+    code {
+        {
+            /// @src 0:60:101  "contract C {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_6_deployed")
+            codecopy(_1, dataoffset("C_6_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_all/input.sol"
+    object "C_6_deployed" {
+        code {
+            {
+                /// @src 0:60:101  "contract C {..."
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all_and_none/err b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all_and_none/err
new file mode 100644
index 00000000..ce13452c
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_all_and_none/err
@@ -0,0 +1 @@
+Error: Invalid value for --debug-info option: location,all,none
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output
new file mode 100644
index 00000000..00a6b290
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_location_only/output
@@ -0,0 +1,203 @@
+
+======= debug_info_in_yul_and_evm_asm_print_location_only/input.sol:C =======
+EVM assembly:
+    /* "debug_info_in_yul_and_evm_asm_print_location_only/input.sol":60:101 */
+  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+        /* "debug_info_in_yul_and_evm_asm_print_location_only/input.sol":60:101 */
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+        /* "debug_info_in_yul_and_evm_asm_print_location_only/input.sol":77:99 */
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+
+IR:
+
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_location_only/input.sol"
+object "C_6" {
+    code {
+        /// @src 0:60:101
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("C_6_deployed"), datasize("C_6_deployed"))
+
+        return(_1, datasize("C_6_deployed"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:60:101
+        function constructor_C_6() {
+
+            /// @src 0:60:101
+
+        }
+        /// @src 0:60:101
+
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_location_only/input.sol"
+    object "C_6_deployed" {
+        code {
+            /// @src 0:60:101
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            /// @src 0:77:99
+            function fun_f_5() {
+
+            }
+            /// @src 0:60:101
+
+        }
+
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+
+}
+
+
+Optimized IR:
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_location_only/input.sol"
+object "C_6" {
+    code {
+        {
+            /// @src 0:60:101
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_6_deployed")
+            codecopy(_1, dataoffset("C_6_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_location_only/input.sol"
+    object "C_6_deployed" {
+        code {
+            {
+                /// @src 0:60:101
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output
new file mode 100644
index 00000000..c8715df1
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_none/output
@@ -0,0 +1,192 @@
+
+======= debug_info_in_yul_and_evm_asm_print_none/input.sol:C =======
+EVM assembly:
+  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+
+IR:
+
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_none/input.sol"
+object "C_6" {
+    code {
+
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("C_6_deployed"), datasize("C_6_deployed"))
+
+        return(_1, datasize("C_6_deployed"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        function constructor_C_6() {
+
+        }
+
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_none/input.sol"
+    object "C_6_deployed" {
+        code {
+
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function fun_f_5() {
+
+            }
+
+        }
+
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+
+}
+
+
+Optimized IR:
+/// @use-src 0:"debug_info_in_yul_and_evm_asm_print_none/input.sol"
+object "C_6" {
+    code {
+        {
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_6_deployed")
+            codecopy(_1, dataoffset("C_6_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"debug_info_in_yul_and_evm_asm_print_none/input.sol"
+    object "C_6_deployed" {
+        code {
+            {
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_snippet_only/err b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_snippet_only/err
new file mode 100644
index 00000000..e4abc612
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_and_evm_asm_print_snippet_only/err
@@ -0,0 +1 @@
+Error: To use 'snippet' with --debug-info you must select also 'location'.
diff --git a/compiler/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output b/compiler/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output
new file mode 100644
index 00000000..94dfb864
--- /dev/null
+++ b/compiler/test/cmdlineTests/debug_info_in_yul_snippet_escaping/output
@@ -0,0 +1,527 @@
+IR:
+
+/// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+object "C_2" {
+    code {
+        /// @src 0:265:278  "contract C {}"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_2()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("C_2_deployed"), datasize("C_2_deployed"))
+
+        return(_1, datasize("C_2_deployed"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:265:278  "contract C {}"
+        function constructor_C_2() {
+
+            /// @src 0:265:278  "contract C {}"
+
+        }
+        /// @src 0:265:278  "contract C {}"
+
+    }
+    /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+    object "C_2_deployed" {
+        code {
+            /// @src 0:265:278  "contract C {}"
+            mstore(64, memoryguard(128))
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+        }
+
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+
+}
+
+
+Optimized IR:
+/// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+object "C_2" {
+    code {
+        {
+            /// @src 0:265:278  "contract C {}"
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_2_deployed")
+            codecopy(_1, dataoffset("C_2_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+    object "C_2_deployed" {
+        code {
+            {
+                /// @src 0:265:278  "contract C {}"
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
+
+IR:
+
+/// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+object "D_27" {
+    code {
+        /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_D_27()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("D_27_deployed"), datasize("D_27_deployed"))
+
+        return(_1, datasize("D_27_deployed"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+        function constructor_D_27() {
+
+            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+
+        }
+        /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+
+    }
+    /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+    object "D_27_deployed" {
+        code {
+            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_26()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function array_length_t_string_memory_ptr(value) -> length {
+
+                length := mload(value)
+
+            }
+
+            function array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length) -> updated_pos {
+                mstore(pos, length)
+                updated_pos := add(pos, 0x20)
+            }
+
+            function copy_memory_to_memory_with_cleanup(src, dst, length) {
+                let i := 0
+                for { } lt(i, length) { i := add(i, 32) }
+                {
+                    mstore(add(dst, i), mload(add(src, i)))
+                }
+                mstore(add(dst, length), 0)
+            }
+
+            function round_up_to_mul_of_32(value) -> result {
+                result := and(add(value, 31), not(31))
+            }
+
+            function abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value, pos) -> end {
+                let length := array_length_t_string_memory_ptr(value)
+                pos := array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length)
+                copy_memory_to_memory_with_cleanup(add(value, 0x20), pos, length)
+                end := add(pos, round_up_to_mul_of_32(length))
+            }
+
+            function abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                mstore(add(headStart, 0), sub(tail, headStart))
+                tail := abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value0,  tail)
+
+            }
+
+            function external_fun_f_26() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_26()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_string_memory_ptr() -> ret {
+                ret := 96
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function revert_forward_1() {
+                let pos := allocate_unbounded()
+                returndatacopy(pos, 0, returndatasize())
+                revert(pos, returndatasize())
+            }
+
+            function finalize_allocation(memPtr, size) {
+                let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+                // protect against overflow
+                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+                mstore(64, newFreePtr)
+            }
+
+            function allocate_memory(size) -> memPtr {
+                memPtr := allocate_unbounded()
+                finalize_allocation(memPtr, size)
+            }
+
+            function array_allocation_size_t_string_memory_ptr(length) -> size {
+                // Make sure we can allocate memory without overflow
+                if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
+
+                size := round_up_to_mul_of_32(length)
+
+                // add length slot
+                size := add(size, 0x20)
+
+            }
+
+            function allocate_memory_array_t_string_memory_ptr(length) -> memPtr {
+                let allocSize := array_allocation_size_t_string_memory_ptr(length)
+                memPtr := allocate_memory(allocSize)
+
+                mstore(memPtr, length)
+
+            }
+
+            function store_literal_in_memory_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50(memPtr) {
+
+                mstore(add(memPtr, 0), "/*")
+
+            }
+
+            function copy_literal_to_memory_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50() -> memPtr {
+                memPtr := allocate_memory_array_t_string_memory_ptr(2)
+                store_literal_in_memory_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50(add(memPtr, 32))
+            }
+
+            function convert_t_stringliteral_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50_to_t_string_memory_ptr() -> converted {
+                converted := copy_literal_to_memory_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50()
+            }
+
+            function store_literal_in_memory_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b(memPtr) {
+
+                mstore(add(memPtr, 0), 0x2f2a2a204073726320303a39363a313635202022636f6e74726163742044207b)
+
+                mstore(add(memPtr, 32), 0x2e2e2e22202a2f00000000000000000000000000000000000000000000000000)
+
+            }
+
+            function copy_literal_to_memory_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b() -> memPtr {
+                memPtr := allocate_memory_array_t_string_memory_ptr(39)
+                store_literal_in_memory_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b(add(memPtr, 32))
+            }
+
+            function convert_t_stringliteral_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b_to_t_string_memory_ptr() -> converted {
+                converted := copy_literal_to_memory_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b()
+            }
+
+            /// @ast-id 26
+            /// @src 0:336:597  "function f() /* @use-src 0:\"input.sol\", 1:\"#utility.yul\" @ast-id 15 *\/ public returns (string memory) { C c = new /// @src 0:149:156  \"new C()\"..."
+            function fun_f_26() -> var__5_mpos {
+                /// @src 0:423:436  "string memory"
+                let zero_t_string_memory_ptr_1_mpos := zero_value_for_split_t_string_memory_ptr()
+                var__5_mpos := zero_t_string_memory_ptr_1_mpos
+
+                /// @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..."
+                let _2 := allocate_unbounded()
+                let _3 := add(_2, datasize("C_2"))
+                if or(gt(_3, 0xffffffffffffffff), lt(_3, _2)) { panic_error_0x41() }
+                datacopy(_2, dataoffset("C_2"), datasize("C_2"))
+                _3 := abi_encode_tuple__to__fromStack(_3)
+
+                let expr_13_address := create(0, _2, sub(_3, _2))
+
+                if iszero(expr_13_address) { revert_forward_1() }
+
+                /// @src 0:440:491  "C c = new /// @src 0:149:156  \"new C()\"..."
+                let var_c_9_address := expr_13_address
+                /// @src 0:493:494  "c"
+                let _4_address := var_c_9_address
+                let expr_15_address := _4_address
+                /// @src 0:504:526  "string memory s = \"/*\""
+                let var_s_18_mpos := convert_t_stringliteral_c077635d0709aa1fd7cea2045028c270f982d687d1647e48e759eec32ec54a50_to_t_string_memory_ptr()
+                /// @src 0:528:529  "s"
+                let _5_mpos := var_s_18_mpos
+                let expr_21_mpos := _5_mpos
+                /// @src 0:531:581  "return \"/** @src 0:96:165  \\\"contract D {...\\\" *\/\""
+                var__5_mpos := convert_t_stringliteral_5bde9a896e3f09acac1496d16642fcdd887d2a000bf1ab18bdff3f17b91e320b_to_t_string_memory_ptr()
+                leave
+
+            }
+            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+
+        }
+
+        /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+        object "C_2" {
+            code {
+                /// @src 0:265:278  "contract C {}"
+                mstore(64, memoryguard(128))
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+                constructor_C_2()
+
+                let _1 := allocate_unbounded()
+                codecopy(_1, dataoffset("C_2_deployed"), datasize("C_2_deployed"))
+
+                return(_1, datasize("C_2_deployed"))
+
+                function allocate_unbounded() -> memPtr {
+                    memPtr := mload(64)
+                }
+
+                function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                    revert(0, 0)
+                }
+
+                /// @src 0:265:278  "contract C {}"
+                function constructor_C_2() {
+
+                    /// @src 0:265:278  "contract C {}"
+
+                }
+                /// @src 0:265:278  "contract C {}"
+
+            }
+            /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+            object "C_2_deployed" {
+                code {
+                    /// @src 0:265:278  "contract C {}"
+                    mstore(64, memoryguard(128))
+
+                    revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+                    function shift_right_224_unsigned(value) -> newValue {
+                        newValue :=
+
+                        shr(224, value)
+
+                    }
+
+                    function allocate_unbounded() -> memPtr {
+                        memPtr := mload(64)
+                    }
+
+                    function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                        revert(0, 0)
+                    }
+
+                }
+
+                data ".metadata" hex"<BYTECODE REMOVED>"
+            }
+
+        }
+
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+
+}
+
+
+Optimized IR:
+/// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+object "D_27" {
+    code {
+        {
+            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("D_27_deployed")
+            codecopy(_1, dataoffset("D_27_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+    object "D_27_deployed" {
+        code {
+            {
+                /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+                let _1 := memoryguard(0x80)
+                let _2 := 64
+                mstore(_2, _1)
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        /// @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..."
+                        let _3 := datasize("C_2")
+                        let _4 := add(_1, _3)
+                        let _5 := 0xffffffffffffffff
+                        if or(gt(_4, _5), lt(_4, _1))
+                        {
+                            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x41)
+                            revert(0, 0x24)
+                        }
+                        /// @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..."
+                        datacopy(_1, dataoffset("C_2"), _3)
+                        if iszero(create(/** @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..." */ 0, /** @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..." */ _1, sub(_4, _1)))
+                        {
+                            /// @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..."
+                            let pos := mload(_2)
+                            returndatacopy(pos, 0, returndatasize())
+                            revert(pos, returndatasize())
+                        }
+                        let memPtr := mload(_2)
+                        let newFreePtr := add(memPtr, _2)
+                        if or(gt(newFreePtr, /** @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..." */ _5), /** @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..." */ lt(newFreePtr, memPtr))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x41)
+                            revert(0, 0x24)
+                        }
+                        mstore(_2, newFreePtr)
+                        mstore(memPtr, 2)
+                        let _6 := 32
+                        mstore(add(memPtr, _6), "/*")
+                        let memPtr_1 := mload(_2)
+                        let newFreePtr_1 := add(memPtr_1, 96)
+                        if or(gt(newFreePtr_1, /** @src 0:446:491  "new /// @src 0:149:156  \"new C()\"..." */ _5), /** @src 0:279:599  "contract D /** @src 0:96:165  \"contract D {...\" *\/ {..." */ lt(newFreePtr_1, memPtr_1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x41)
+                            revert(0, 0x24)
+                        }
+                        mstore(_2, newFreePtr_1)
+                        mstore(memPtr_1, 39)
+                        mstore(add(memPtr_1, _6), 0x2f2a2a204073726320303a39363a313635202022636f6e74726163742044207b)
+                        mstore(add(memPtr_1, _2), shl(200, 0x2e2e2e22202a2f))
+                        let memPos := mload(_2)
+                        mstore(memPos, _6)
+                        let length := mload(memPtr_1)
+                        mstore(add(memPos, _6), length)
+                        let i := 0
+                        for { } lt(i, length) { i := add(i, _6) }
+                        {
+                            mstore(add(add(memPos, i), _2), mload(add(add(memPtr_1, i), _6)))
+                        }
+                        mstore(add(add(memPos, length), _2), 0)
+                        return(memPos, add(sub(add(memPos, and(add(length, 31), not(31))), memPos), _2))
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+        object "C_2" {
+            code {
+                {
+                    /// @src 0:265:278  "contract C {}"
+                    let _1 := memoryguard(0x80)
+                    mstore(64, _1)
+                    if callvalue() { revert(0, 0) }
+                    let _2 := datasize("C_2_deployed")
+                    codecopy(_1, dataoffset("C_2_deployed"), _2)
+                    return(_1, _2)
+                }
+            }
+            /// @use-src 0:"debug_info_in_yul_snippet_escaping/input.sol"
+            object "C_2_deployed" {
+                code {
+                    {
+                        /// @src 0:265:278  "contract C {}"
+                        revert(0, 0)
+                    }
+                }
+                data ".metadata" hex"<BYTECODE REMOVED>"
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/events_in_abi/args b/compiler/test/cmdlineTests/events_in_abi/args
new file mode 100644
index 00000000..d27d3ef1
--- /dev/null
+++ b/compiler/test/cmdlineTests/events_in_abi/args
@@ -0,0 +1 @@
+--abi --pretty-json --json-indent 4
diff --git a/compiler/test/cmdlineTests/events_in_abi/input.sol b/compiler/test/cmdlineTests/events_in_abi/input.sol
new file mode 100644
index 00000000..a0d91d2e
--- /dev/null
+++ b/compiler/test/cmdlineTests/events_in_abi/input.sol
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+library L {
+    event e1(uint b);
+}
+
+function f() {
+    emit L.e1(5);
+}
+
+contract C {
+    event e1(uint indexed a);
+    function g() public {
+        f();
+    }
+}
diff --git a/compiler/test/cmdlineTests/events_in_abi/output b/compiler/test/cmdlineTests/events_in_abi/output
new file mode 100644
index 00000000..6c18a175
--- /dev/null
+++ b/compiler/test/cmdlineTests/events_in_abi/output
@@ -0,0 +1,59 @@
+
+======= events_in_abi/input.sol:C =======
+Contract JSON ABI
+[
+    {
+        "anonymous": false,
+        "inputs":
+        [
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "b",
+                "type": "uint256"
+            }
+        ],
+        "name": "e1",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs":
+        [
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "a",
+                "type": "uint256"
+            }
+        ],
+        "name": "e1",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "g",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]
+
+======= events_in_abi/input.sol:L =======
+Contract JSON ABI
+[
+    {
+        "anonymous": false,
+        "inputs":
+        [
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "b",
+                "type": "uint256"
+            }
+        ],
+        "name": "e1",
+        "type": "event"
+    }
+]
diff --git a/compiler/test/cmdlineTests/evm_version_byzantium/args b/compiler/test/cmdlineTests/evm_version_byzantium/args
new file mode 100644
index 00000000..3a732cc0
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_byzantium/args
@@ -0,0 +1 @@
+--evm-version byzantium
diff --git a/compiler/test/cmdlineTests/evm_version_byzantium/err b/compiler/test/cmdlineTests/evm_version_byzantium/err
new file mode 100644
index 00000000..accbb596
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_byzantium/err
@@ -0,0 +1,3 @@
+Warning: Support for EVM versions older than constantinople is deprecated and will be removed in the future.
+Warning: Source file does not specify required compiler version!
+--> evm_version_byzantium/input.sol
diff --git a/compiler/test/cmdlineTests/evm_version_byzantium/input.sol b/compiler/test/cmdlineTests/evm_version_byzantium/input.sol
new file mode 100644
index 00000000..ea448e28
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_byzantium/input.sol
@@ -0,0 +1 @@
+// SPDX-License-Identifier: GPL-3.0
diff --git a/compiler/test/cmdlineTests/evm_version_constantinople/args b/compiler/test/cmdlineTests/evm_version_constantinople/args
new file mode 100644
index 00000000..fa2c596e
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_constantinople/args
@@ -0,0 +1 @@
+--evm-version constantinople
diff --git a/compiler/test/cmdlineTests/evm_version_constantinople/err b/compiler/test/cmdlineTests/evm_version_constantinople/err
new file mode 100644
index 00000000..69f328f5
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_constantinople/err
@@ -0,0 +1,2 @@
+Warning: Source file does not specify required compiler version!
+--> evm_version_constantinople/input.sol
diff --git a/compiler/test/cmdlineTests/evm_version_constantinople/input.sol b/compiler/test/cmdlineTests/evm_version_constantinople/input.sol
new file mode 100644
index 00000000..ea448e28
--- /dev/null
+++ b/compiler/test/cmdlineTests/evm_version_constantinople/input.sol
@@ -0,0 +1 @@
+// SPDX-License-Identifier: GPL-3.0
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/args b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/args
new file mode 100644
index 00000000..a0588fcf
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/args
@@ -0,0 +1 @@
+--no-cbor-metadata --via-ir --optimize --opcodes --asm --debug-info none --evm-version paris
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/err b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/err
new file mode 100644
index 00000000..d8210184
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/err
@@ -0,0 +1,5 @@
+Warning: Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+ --> evmasm_difficulty_post_paris/input.sol:6:21:
+  |
+6 |         uint256 x = block.difficulty;
+  |                     ^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/input.sol b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/input.sol
new file mode 100644
index 00000000..e81c034e
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/input.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0.0;
+
+contract C {
+    constructor() payable {
+        uint256 x = block.difficulty;
+        assembly {
+            sstore(0, x)
+            stop()
+        }
+    }
+
+    fallback() external payable {
+        assembly {
+            stop()
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/output b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/output
new file mode 100644
index 00000000..f8c1611e
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_post_paris/output
@@ -0,0 +1,13 @@
+
+======= evmasm_difficulty_post_paris/input.sol:C =======
+EVM assembly:
+  sstore(0x00, prevrandao)
+  stop
+stop
+
+sub_0: assembly {
+      stop
+}
+
+Opcodes:
+PREVRANDAO PUSH1 0x0 SSTORE STOP INVALID 
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/args b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/args
new file mode 100644
index 00000000..67d6f9a6
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/args
@@ -0,0 +1 @@
+--no-cbor-metadata --via-ir --optimize --opcodes --asm --debug-info none --evm-version london
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/input.sol b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/input.sol
new file mode 100644
index 00000000..e81c034e
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/input.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0.0;
+
+contract C {
+    constructor() payable {
+        uint256 x = block.difficulty;
+        assembly {
+            sstore(0, x)
+            stop()
+        }
+    }
+
+    fallback() external payable {
+        assembly {
+            stop()
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/output b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/output
new file mode 100644
index 00000000..ad75355f
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_difficulty_pre_paris/output
@@ -0,0 +1,13 @@
+
+======= evmasm_difficulty_pre_paris/input.sol:C =======
+EVM assembly:
+  sstore(0x00, difficulty)
+  stop
+stop
+
+sub_0: assembly {
+      stop
+}
+
+Opcodes:
+DIFFICULTY PUSH1 0x0 SSTORE STOP INVALID 
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/args b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/args
new file mode 100644
index 00000000..a0588fcf
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/args
@@ -0,0 +1 @@
+--no-cbor-metadata --via-ir --optimize --opcodes --asm --debug-info none --evm-version paris
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/input.sol b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/input.sol
new file mode 100644
index 00000000..707d12d7
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/input.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0.0;
+
+contract C {
+    constructor() payable {
+        uint256 x = block.prevrandao;
+        assembly {
+            sstore(0, x)
+            stop()
+        }
+    }
+
+    fallback() external payable {
+        assembly {
+            stop()
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/output b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/output
new file mode 100644
index 00000000..47c85bb5
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_post_paris/output
@@ -0,0 +1,13 @@
+
+======= evmasm_prevrandao_post_paris/input.sol:C =======
+EVM assembly:
+  sstore(0x00, prevrandao)
+  stop
+stop
+
+sub_0: assembly {
+      stop
+}
+
+Opcodes:
+PREVRANDAO PUSH1 0x0 SSTORE STOP INVALID 
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/args b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/args
new file mode 100644
index 00000000..67d6f9a6
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/args
@@ -0,0 +1 @@
+--no-cbor-metadata --via-ir --optimize --opcodes --asm --debug-info none --evm-version london
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/err b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/err
new file mode 100644
index 00000000..5970ec20
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/err
@@ -0,0 +1,5 @@
+Warning: "prevrandao" is not supported by the VM version and will be treated as "difficulty".
+ --> evmasm_prevrandao_pre_paris/input.sol:6:21:
+  |
+6 |         uint256 x = block.prevrandao;
+  |                     ^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/input.sol b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/input.sol
new file mode 100644
index 00000000..707d12d7
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/input.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0.0;
+
+contract C {
+    constructor() payable {
+        uint256 x = block.prevrandao;
+        assembly {
+            sstore(0, x)
+            stop()
+        }
+    }
+
+    fallback() external payable {
+        assembly {
+            stop()
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/output b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/output
new file mode 100644
index 00000000..e41148a8
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_prevrandao_pre_paris/output
@@ -0,0 +1,13 @@
+
+======= evmasm_prevrandao_pre_paris/input.sol:C =======
+EVM assembly:
+  sstore(0x00, difficulty)
+  stop
+stop
+
+sub_0: assembly {
+      stop
+}
+
+Opcodes:
+DIFFICULTY PUSH1 0x0 SSTORE STOP INVALID 
diff --git a/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/args b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/args
new file mode 100644
index 00000000..552cea1c
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/args
@@ -0,0 +1 @@
+--evm-version cancun --no-cbor-metadata --via-ir --optimize --opcodes --asm --debug-info none
diff --git a/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/err b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/err
new file mode 100644
index 00000000..a6cd5626
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/err
@@ -0,0 +1,5 @@
+Warning: Transient storage as defined by EIP-1153 can break the composability of smart contracts: Since transient storage is cleared only at the end of the transaction and not at the end of the outermost call frame to the contract within a transaction, your contract may unintentionally misbehave when invoked multiple times in a complex transaction. To avoid this, be sure to clear all transient storage at the end of any call to your contract. The use of transient storage for reentrancy guards that are cleared at the end of the call is safe.
+ --> evmasm_transient_storage_opcodes/input.sol:7:13:
+  |
+7 |             tstore(0, 0)
+  |             ^^^^^^
diff --git a/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/input.sol b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/input.sol
new file mode 100644
index 00000000..94914ac4
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/input.sol
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0.0;
+
+contract C {
+    fallback() external {
+        assembly {
+            tstore(0, 0)
+            sstore(0, tload(0))
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/output b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/output
new file mode 100644
index 00000000..3d1eddc9
--- /dev/null
+++ b/compiler/test/cmdlineTests/evmasm_transient_storage_opcodes/output
@@ -0,0 +1,36 @@
+
+======= evmasm_transient_storage_opcodes/input.sol:C =======
+EVM assembly:
+  0x80
+  dup1
+  0x40
+  mstore
+  jumpi(tag_1, callvalue)
+  dataSize(sub_0)
+  swap1
+  dup2
+  dataOffset(sub_0)
+  dup3
+  codecopy
+  return
+tag_1:
+  0x00
+  dup1
+  revert
+stop
+
+sub_0: assembly {
+      jumpi(tag_1, callvalue)
+      0x00
+      dup1
+      tstore
+      sstore(0x00, tload(0x00))
+      stop
+    tag_1:
+      0x00
+      dup1
+      revert
+}
+
+Opcodes:
+PUSH1 0x80 DUP1 PUSH1 0x40 MSTORE CALLVALUE PUSH1 0x13 JUMPI PUSH1 0x10 SWAP1 DUP2 PUSH1 0x18 DUP3 CODECOPY RETURN JUMPDEST PUSH0 DUP1 REVERT INVALID CALLVALUE PUSH1 0xC JUMPI PUSH0 DUP1 TSTORE PUSH0 TLOAD PUSH0 SSTORE STOP JUMPDEST PUSH0 DUP1 REVERT 
diff --git a/compiler/test/cmdlineTests/function_debug_info/output b/compiler/test/cmdlineTests/function_debug_info/output
new file mode 100644
index 00000000..b9ca3f3c
--- /dev/null
+++ b/compiler/test/cmdlineTests/function_debug_info/output
@@ -0,0 +1,63 @@
+{
+  "contracts":
+  {
+    "function_debug_info/input.sol:C":
+    {
+      "function-debug":
+      {
+        "@_34":
+        {
+          "id": 34,
+          "parameterSlots": 1,
+          "returnSlots": 0
+        },
+        "abi_decode_tuple_t_uint256_fromMemory":
+        {
+          "entryPoint": 92,
+          "parameterSlots": 2,
+          "returnSlots": 1
+        }
+      },
+      "function-debug-runtime":
+      {
+        "@f_14":
+        {
+          "entryPoint": 124,
+          "id": 14,
+          "parameterSlots": 2,
+          "returnSlots": 1
+        },
+        "@t_22":
+        {
+          "id": 22,
+          "parameterSlots": 0,
+          "returnSlots": 0
+        },
+        "abi_decode_tuple_t_array$_t_uint256_$dyn_calldata_ptr":
+        {
+          "entryPoint": 158,
+          "parameterSlots": 2,
+          "returnSlots": 2
+        },
+        "abi_decode_tuple_t_uint256":
+        {
+          "entryPoint": 269,
+          "parameterSlots": 2,
+          "returnSlots": 1
+        },
+        "abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed":
+        {
+          "parameterSlots": 2,
+          "returnSlots": 1
+        },
+        "panic_error_0x32":
+        {
+          "entryPoint": 292,
+          "parameterSlots": 0,
+          "returnSlots": 0
+        }
+      }
+    }
+  },
+  "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/inline_assembly_function_name_clash/output b/compiler/test/cmdlineTests/inline_assembly_function_name_clash/output
new file mode 100644
index 00000000..8becb87a
--- /dev/null
+++ b/compiler/test/cmdlineTests/inline_assembly_function_name_clash/output
@@ -0,0 +1,210 @@
+{
+    "contracts":
+    {
+        "inline_assembly_function_name_clash/input.sol:C":
+        {
+            "function-debug-runtime":
+            {
+                "abi_decode":
+                {
+                    "entryPoint": 80,
+                    "parameterSlots": 2,
+                    "returnSlots": 0
+                },
+                "abi_encode_uint256":
+                {
+                    "entryPoint": 111,
+                    "parameterSlots": 2,
+                    "returnSlots": 1
+                },
+                "abi_encode_uint256_to_uint256":
+                {
+                    "entryPoint": 98,
+                    "parameterSlots": 2,
+                    "returnSlots": 0
+                },
+                "allocate_unbounded":
+                {
+                    "entryPoint": 66,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "cleanup_uint256":
+                {
+                    "entryPoint": 95,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "convert_uint256_to_uint256":
+                {
+                    "entryPoint": 276,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "external_fun_f":
+                {
+                    "entryPoint": 132,
+                    "parameterSlots": 0,
+                    "returnSlots": 0
+                },
+                "external_fun_g":
+                {
+                    "entryPoint": 185,
+                    "parameterSlots": 0,
+                    "returnSlots": 0
+                },
+                "fun_f":
+                {
+                    "entryPoint": 442,
+                    "id": 25,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "fun_f_inner":
+                {
+                    "entryPoint": 430,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "fun_g":
+                {
+                    "entryPoint": 564,
+                    "id": 36,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "fun_g_inner":
+                {
+                    "entryPoint": 552,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "identity":
+                {
+                    "entryPoint": 273,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "modifier_m":
+                {
+                    "entryPoint": 509,
+                    "id": 14,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "modifier_m_17":
+                {
+                    "entryPoint": 344,
+                    "id": 14,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "modifier_m_19":
+                {
+                    "entryPoint": 387,
+                    "id": 14,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "modifier_m_28":
+                {
+                    "entryPoint": 466,
+                    "id": 14,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "prepare_store_uint256":
+                {
+                    "entryPoint": 304,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74":
+                {
+                    "entryPoint": 238,
+                    "parameterSlots": 0,
+                    "returnSlots": 0
+                },
+                "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb":
+                {
+                    "entryPoint": 72,
+                    "parameterSlots": 0,
+                    "returnSlots": 0
+                },
+                "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b":
+                {
+                    "entryPoint": 76,
+                    "parameterSlots": 0,
+                    "returnSlots": 0
+                },
+                "shift_left":
+                {
+                    "entryPoint": 246,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "shift_right_unsigned":
+                {
+                    "entryPoint": 60,
+                    "parameterSlots": 1,
+                    "returnSlots": 1
+                },
+                "update_byte_slice_shift":
+                {
+                    "entryPoint": 251,
+                    "parameterSlots": 2,
+                    "returnSlots": 1
+                },
+                "update_storage_value_offsett_uint256_to_uint256":
+                {
+                    "entryPoint": 307,
+                    "parameterSlots": 2,
+                    "returnSlots": 0
+                },
+                "usr$f":
+                {
+                    "entryPoint": 339,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "usr$f_17":
+                {
+                    "entryPoint": 382,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "usr$f_22":
+                {
+                    "entryPoint": 425,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "usr$f_26":
+                {
+                    "entryPoint": 461,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "usr$f_32":
+                {
+                    "entryPoint": 504,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "usr$f_37":
+                {
+                    "entryPoint": 547,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                },
+                "zero_value_for_split_uint256":
+                {
+                    "entryPoint": 242,
+                    "parameterSlots": 0,
+                    "returnSlots": 1
+                }
+            }
+        }
+    },
+    "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/ir_compiler_subobjects/output b/compiler/test/cmdlineTests/ir_compiler_subobjects/output
new file mode 100644
index 00000000..39ef53f5
--- /dev/null
+++ b/compiler/test/cmdlineTests/ir_compiler_subobjects/output
@@ -0,0 +1,105 @@
+Optimized IR:
+/// @use-src 0:"ir_compiler_subobjects/input.sol"
+object "C_3" {
+    code {
+        {
+            /// @src 0:82:95  "contract C {}"
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_3_deployed")
+            codecopy(_1, dataoffset("C_3_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"ir_compiler_subobjects/input.sol"
+    object "C_3_deployed" {
+        code {
+            {
+                /// @src 0:82:95  "contract C {}"
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
+
+Optimized IR:
+/// @use-src 0:"ir_compiler_subobjects/input.sol"
+object "D_16" {
+    code {
+        {
+            /// @src 0:96:165  "contract D {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("D_16_deployed")
+            codecopy(_1, dataoffset("D_16_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"ir_compiler_subobjects/input.sol"
+    object "D_16_deployed" {
+        code {
+            {
+                /// @src 0:96:165  "contract D {..."
+                let _1 := memoryguard(0x80)
+                mstore(64, _1)
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        /// @src 0:149:156  "new C()"
+                        let _2 := datasize("C_3")
+                        let _3 := add(_1, _2)
+                        if or(gt(_3, 0xffffffffffffffff), lt(_3, _1))
+                        {
+                            /// @src 0:96:165  "contract D {..."
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x41)
+                            revert(0, 0x24)
+                        }
+                        /// @src 0:149:156  "new C()"
+                        datacopy(_1, dataoffset("C_3"), _2)
+                        if iszero(create(/** @src 0:96:165  "contract D {..." */ 0, /** @src 0:149:156  "new C()" */ _1, sub(_3, _1)))
+                        {
+                            /// @src 0:96:165  "contract D {..."
+                            let pos := mload(64)
+                            returndatacopy(pos, 0, returndatasize())
+                            revert(pos, returndatasize())
+                        }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        /// @use-src 0:"ir_compiler_subobjects/input.sol"
+        object "C_3" {
+            code {
+                {
+                    /// @src 0:82:95  "contract C {}"
+                    let _1 := memoryguard(0x80)
+                    mstore(64, _1)
+                    if callvalue() { revert(0, 0) }
+                    let _2 := datasize("C_3_deployed")
+                    codecopy(_1, dataoffset("C_3_deployed"), _2)
+                    return(_1, _2)
+                }
+            }
+            /// @use-src 0:"ir_compiler_subobjects/input.sol"
+            object "C_3_deployed" {
+                code {
+                    {
+                        /// @src 0:82:95  "contract C {}"
+                        revert(0, 0)
+                    }
+                }
+                data ".metadata" hex"<BYTECODE REMOVED>"
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output b/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output
new file mode 100644
index 00000000..5c822949
--- /dev/null
+++ b/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_creation/output
@@ -0,0 +1,32 @@
+Optimized IR:
+/// @use-src 0:"ir_with_assembly_no_memoryguard_creation/input.sol"
+object "D_12" {
+    code {
+        {
+            /// @src 0:82:175  "contract D {..."
+            if callvalue() { revert(0, 0) }
+            let _1 := datasize("D_12_deployed")
+            codecopy(128, dataoffset("D_12_deployed"), _1)
+            return(128, _1)
+        }
+    }
+    /// @use-src 0:"ir_with_assembly_no_memoryguard_creation/input.sol"
+    object "D_12_deployed" {
+        code {
+            {
+                /// @src 0:82:175  "contract D {..."
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output b/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output
new file mode 100644
index 00000000..f6be1493
--- /dev/null
+++ b/compiler/test/cmdlineTests/ir_with_assembly_no_memoryguard_runtime/output
@@ -0,0 +1,34 @@
+Optimized IR:
+/// @use-src 0:"ir_with_assembly_no_memoryguard_runtime/input.sol"
+object "D_8" {
+    code {
+        {
+            /// @src 0:82:166  "contract D {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("D_8_deployed")
+            codecopy(_1, dataoffset("D_8_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"ir_with_assembly_no_memoryguard_runtime/input.sol"
+    object "D_8_deployed" {
+        code {
+            {
+                /// @src 0:82:166  "contract D {..."
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/linker_mode_invalid_option_no_optimize_yul/err b/compiler/test/cmdlineTests/linker_mode_invalid_option_no_optimize_yul/err
new file mode 100644
index 00000000..1205089d
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_invalid_option_no_optimize_yul/err
@@ -0,0 +1 @@
+Error: Option --no-optimize-yul is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize/err b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize/err
new file mode 100644
index 00000000..da724d56
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize/err
@@ -0,0 +1 @@
+Error: Option --optimize is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_runs/err b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_runs/err
new file mode 100644
index 00000000..a625ad49
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_runs/err
@@ -0,0 +1 @@
+Error: Option --optimize-runs is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_yul/err b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_yul/err
new file mode 100644
index 00000000..6d3a9306
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_invalid_option_optimize_yul/err
@@ -0,0 +1 @@
+Error: Option --optimize-yul is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/linker_mode_invalid_option_yul_optimizations/err b/compiler/test/cmdlineTests/linker_mode_invalid_option_yul_optimizations/err
new file mode 100644
index 00000000..f0db47ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_invalid_option_yul_optimizations/err
@@ -0,0 +1 @@
+Error: Option --yul-optimizations is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/args b/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/args
new file mode 100644
index 00000000..6c5b1680
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/args
@@ -0,0 +1 @@
+--link --asm --asm-json --opcodes --bin --bin-runtime --abi --ir --ir-optimized --hashes --userdoc --devdoc --metadata --storage-layout
diff --git a/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/err b/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/err
new file mode 100644
index 00000000..5ca74978
--- /dev/null
+++ b/compiler/test/cmdlineTests/linker_mode_output_selection_invalid/err
@@ -0,0 +1 @@
+Error: The following outputs are not supported in linker mode: --abi, --asm, --asm-json, --bin, --bin-runtime, --devdoc, --hashes, --ir, --ir-optimized, --metadata, --opcodes, --storage-layout, --userdoc.
diff --git a/compiler/test/cmdlineTests/linking_standard_solidity/output.json b/compiler/test/cmdlineTests/linking_standard_solidity/output.json
new file mode 100644
index 00000000..83813d80
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_solidity/output.json
@@ -0,0 +1,26 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_standard_solidity_quote_in_file_name/output.json b/compiler/test/cmdlineTests/linking_standard_solidity_quote_in_file_name/output.json
new file mode 100644
index 00000000..38e0a1b5
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_solidity_quote_in_file_name/output.json
@@ -0,0 +1,26 @@
+{
+    "contracts":
+    {
+        "A\"B":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A\"B":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_standard_solidity_unresolved_references/output.json b/compiler/test/cmdlineTests/linking_standard_solidity_unresolved_references/output.json
new file mode 100644
index 00000000..169e9996
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_solidity_unresolved_references/output.json
@@ -0,0 +1,42 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences":
+                        {
+                            "A":
+                            {
+                                "L2":
+                                [
+                                    {
+                                        "length": 20,
+                                        "start": 174
+                                    },
+                                    {
+                                        "length": 20,
+                                        "start": 350
+                                    }
+                                ]
+                            }
+                        },
+                        "object": "<BYTECODE REMOVED>__$622b2f540b6a16ff5db7bea656ad8fcf4f$__<BYTECODE REMOVED>__$622b2f540b6a16ff5db7bea656ad8fcf4f$__<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_standard_yul/output.json b/compiler/test/cmdlineTests/linking_standard_yul/output.json
new file mode 100644
index 00000000..b9059bdf
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_yul/output.json
@@ -0,0 +1,19 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "a":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_standard_yul_quote_in_file_name/output.json b/compiler/test/cmdlineTests/linking_standard_yul_quote_in_file_name/output.json
new file mode 100644
index 00000000..b9059bdf
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_yul_quote_in_file_name/output.json
@@ -0,0 +1,19 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "a":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_standard_yul_unresolved_references/output.json b/compiler/test/cmdlineTests/linking_standard_yul_unresolved_references/output.json
new file mode 100644
index 00000000..ac1250cd
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_standard_yul_unresolved_references/output.json
@@ -0,0 +1,31 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "a":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "linkReferences":
+                        {
+                            "contract/test.sol":
+                            {
+                                "L2":
+                                [
+                                    {
+                                        "length": 20,
+                                        "start": 22
+                                    }
+                                ]
+                            }
+                        },
+                        "object": "<BYTECODE REMOVED>__$fb58009a6b1ecea3b9d99bedd645df4ec3$__<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly/output b/compiler/test/cmdlineTests/linking_strict_assembly/output
new file mode 100644
index 00000000..29a8abdf
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly/output
@@ -0,0 +1,26 @@
+
+======= linking_strict_assembly/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr := linkersymbol("contract/test.sol:L")
+            sstore(0, addr)
+        }
+    }
+}
+
+
+Binary representation:
+7312345678901234567890123456789012345678905f5500
+
+Text representation:
+    /* "linking_strict_assembly/input.yul":44:79   */
+  linkerSymbol("f919ba91ac99f96129544b80b9516b27a80e376b9dc693819d0b18b7e0395612")
+    /* "linking_strict_assembly/input.yul":95:96   */
+  0x00
+    /* "linking_strict_assembly/input.yul":88:103   */
+  sstore
+    /* "linking_strict_assembly/input.yul":22:109   */
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_duplicate_library_name/err b/compiler/test/cmdlineTests/linking_strict_assembly_duplicate_library_name/err
new file mode 100644
index 00000000..9d4ca2c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_duplicate_library_name/err
@@ -0,0 +1 @@
+Error: Address specified more than once for library "library.sol:L".
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_qualified_reference/output b/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_qualified_reference/output
new file mode 100644
index 00000000..e4fa4fcb
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_qualified_reference/output
@@ -0,0 +1,22 @@
+
+======= linking_strict_assembly_qualified_library_qualified_reference/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr := linkersymbol(":L")
+            sstore(0, addr)
+        }
+    }
+}
+
+
+Binary representation:
+7312345678901234567890123456789012345678905f5500
+
+Text representation:
+  linkerSymbol("20a18a9bf97d889dcf77111b674da319a4e9e3e05d3f4df9e0bf5c588dd4f0f8")
+  0x00
+  sstore
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_unqualified_reference/output b/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_unqualified_reference/output
new file mode 100644
index 00000000..ebf7f654
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_qualified_library_unqualified_reference/output
@@ -0,0 +1,22 @@
+
+======= linking_strict_assembly_qualified_library_unqualified_reference/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr := linkersymbol("L")
+            sstore(0, addr)
+        }
+    }
+}
+
+
+Binary representation:
+73__$8aa64f937099b65a4febc243a5ae0f2d64$__5f5500
+
+Text representation:
+  linkerSymbol("8aa64f937099b65a4febc243a5ae0f2d6416bb9e473c30dd29c1ee498fb7c5a8")
+  0x00
+  sstore
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files/output b/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files/output
new file mode 100644
index 00000000..4aecfc6b
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files/output
@@ -0,0 +1,36 @@
+
+======= linking_strict_assembly_same_library_name_different_files/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr1 := linkersymbol("library1.sol:L")
+            let addr2 := linkersymbol("library2.sol:L")
+            sstore(0, addr1)
+            sstore(1, addr2)
+        }
+    }
+}
+
+
+Binary representation:
+731111111111111111111111111111111111111111732222222222222222222222222222222222222222905f5560015500
+
+Text representation:
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":45:75   */
+  linkerSymbol("f3ffc10c396a7cc41ae954b050792839d20947bf73497d30c49a9fda1ea477ec")
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":97:127   */
+  linkerSymbol("c3523432985587641d17c68161d2f700c57aaf4ed21cda4f25d76193c831f97f")
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":136:152   */
+  swap1
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":143:144   */
+  0x00
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":136:152   */
+  sstore
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":168:169   */
+  0x01
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":161:177   */
+  sstore
+    /* "linking_strict_assembly_same_library_name_different_files/input.yul":22:183   */
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files_in_link_references/output b/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files_in_link_references/output
new file mode 100644
index 00000000..10a7fe7f
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_same_library_name_different_files_in_link_references/output
@@ -0,0 +1,36 @@
+
+======= linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr1 := linkersymbol("library1.sol:L")
+            let addr2 := linkersymbol("library2.sol:L")
+            sstore(0, addr1)
+            sstore(1, addr2)
+        }
+    }
+}
+
+
+Binary representation:
+73123456789012345678901234567890123456789073__$c3523432985587641d17c68161d2f700c5$__905f5560015500
+
+Text representation:
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":45:75   */
+  linkerSymbol("f3ffc10c396a7cc41ae954b050792839d20947bf73497d30c49a9fda1ea477ec")
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":97:127   */
+  linkerSymbol("c3523432985587641d17c68161d2f700c57aaf4ed21cda4f25d76193c831f97f")
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":136:152   */
+  swap1
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":143:144   */
+  0x00
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":136:152   */
+  sstore
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":168:169   */
+  0x01
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":161:177   */
+  sstore
+    /* "linking_strict_assembly_same_library_name_different_files_in_link_references/input.yul":22:183   */
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_qualified_reference/output b/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_qualified_reference/output
new file mode 100644
index 00000000..aaf03d07
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_qualified_reference/output
@@ -0,0 +1,22 @@
+
+======= linking_strict_assembly_unqualified_library_qualified_reference/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr := linkersymbol(":L")
+            sstore(0, addr)
+        }
+    }
+}
+
+
+Binary representation:
+73__$20a18a9bf97d889dcf77111b674da319a4$__5f5500
+
+Text representation:
+  linkerSymbol("20a18a9bf97d889dcf77111b674da319a4e9e3e05d3f4df9e0bf5c588dd4f0f8")
+  0x00
+  sstore
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_unqualified_reference/output b/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_unqualified_reference/output
new file mode 100644
index 00000000..d91d89f5
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_unqualified_library_unqualified_reference/output
@@ -0,0 +1,22 @@
+
+======= linking_strict_assembly_unqualified_library_unqualified_reference/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr := linkersymbol("L")
+            sstore(0, addr)
+        }
+    }
+}
+
+
+Binary representation:
+7312345678901234567890123456789012345678905f5500
+
+Text representation:
+  linkerSymbol("8aa64f937099b65a4febc243a5ae0f2d6416bb9e473c30dd29c1ee498fb7c5a8")
+  0x00
+  sstore
+  stop
diff --git a/compiler/test/cmdlineTests/linking_strict_assembly_unresolved_references/output b/compiler/test/cmdlineTests/linking_strict_assembly_unresolved_references/output
new file mode 100644
index 00000000..a110db5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/linking_strict_assembly_unresolved_references/output
@@ -0,0 +1,36 @@
+
+======= linking_strict_assembly_unresolved_references/input.yul (EVM) =======
+
+Pretty printed source:
+object "a" {
+    code {
+        {
+            let addr1 := linkersymbol("contract/test.sol:L1")
+            let addr2 := linkersymbol("contract/test.sol:L2")
+            sstore(0, addr1)
+            sstore(1, addr2)
+        }
+    }
+}
+
+
+Binary representation:
+73123456789012345678901234567890123456789073__$fb58009a6b1ecea3b9d99bedd645df4ec3$__905f5560015500
+
+Text representation:
+    /* "linking_strict_assembly_unresolved_references/input.yul":45:81   */
+  linkerSymbol("05b0326038374a21e0895480a58bda0768cdcc04c8d18f154362d1ca5223d245")
+    /* "linking_strict_assembly_unresolved_references/input.yul":103:139   */
+  linkerSymbol("fb58009a6b1ecea3b9d99bedd645df4ec308f17bc0087e5f39d078f77f809177")
+    /* "linking_strict_assembly_unresolved_references/input.yul":148:164   */
+  swap1
+    /* "linking_strict_assembly_unresolved_references/input.yul":155:156   */
+  0x00
+    /* "linking_strict_assembly_unresolved_references/input.yul":148:164   */
+  sstore
+    /* "linking_strict_assembly_unresolved_references/input.yul":180:181   */
+  0x01
+    /* "linking_strict_assembly_unresolved_references/input.yul":173:189   */
+  sstore
+    /* "linking_strict_assembly_unresolved_references/input.yul":22:195   */
+  stop
diff --git a/compiler/test/cmdlineTests/metadata/args b/compiler/test/cmdlineTests/metadata/args
new file mode 100644
index 00000000..5cbfceb4
--- /dev/null
+++ b/compiler/test/cmdlineTests/metadata/args
@@ -0,0 +1 @@
+--metadata
diff --git a/compiler/test/cmdlineTests/metadata/input.sol b/compiler/test/cmdlineTests/metadata/input.sol
new file mode 100644
index 00000000..a3a86cc8
--- /dev/null
+++ b/compiler/test/cmdlineTests/metadata/input.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/metadata/output b/compiler/test/cmdlineTests/metadata/output
new file mode 100644
index 00000000..bf1e750c
--- /dev/null
+++ b/compiler/test/cmdlineTests/metadata/output
@@ -0,0 +1,4 @@
+
+======= metadata/input.sol:C =======
+Metadata:
+{"compiler":{"version": "<VERSION REMOVED>"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"metadata/input.sol":"C"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"metadata/input.sol":{"keccak256":"0x5cf617b1707a484e3c4bd59643013dec76ab7d75900b46855214729ae3e0ceb0","license":"GPL-3.0","urls":["bzz-raw://ac418a02dfadf87234150d3568f33269e3f49460345cb39300e017a6d755eff2","dweb:/ipfs/QmQq3owBu25x2WV46HB1WyKzJpxiAPecU7eMKqtXCF7eeS"]}},"version":1}
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/args b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/args
new file mode 100644
index 00000000..3761421e
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-bmc-loop-iterations 3
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/err b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/err
new file mode 100644
index 00000000..cbb2b0f9
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/err
@@ -0,0 +1,11 @@
+Warning: BMC: Assertion violation happens here.
+  --> model_checker_bmc_loop_iterations/input.sol:10:3:
+   |
+10 | 		assert(x == 3);
+   | 		^^^^^^^^^^^^^^
+Note: Counterexample:
+  x = 2
+
+Note: Callstack:
+Note: False negatives are possible when unrolling loops.
+This is due to the possibility that the BMC loop iteration setting is smaller than the actual number of iterations needed to complete a loop.
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/input.sol b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/input.sol
new file mode 100644
index 00000000..3722e46c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations/input.sol
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		do {
+			++x;
+		} while (x < 2);
+		assert(x == 3);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/args b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/args
new file mode 100644
index 00000000..32b6eb05
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-bmc-loop-iterations bmc
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/err b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/err
new file mode 100644
index 00000000..fb880043
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/err
@@ -0,0 +1 @@
+Error: the argument ('bmc') for option '--model-checker-bmc-loop-iterations' is invalid
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/exit b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/exit
new file mode 100644
index 00000000..56a6051c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/exit
@@ -0,0 +1 @@
+1
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/input.sol b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_invalid_arg/input.sol
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/args b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/args
new file mode 100644
index 00000000..aad7e026
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-bmc-loop-iterations
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/err b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/err
new file mode 100644
index 00000000..1bd45b6c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/err
@@ -0,0 +1 @@
+Error: the argument ('model_checker_bmc_loop_iterations_no_argument/input.sol') for option '--model-checker-bmc-loop-iterations' is invalid
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/exit b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/exit
new file mode 100644
index 00000000..56a6051c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/exit
@@ -0,0 +1 @@
+1
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/input.sol b/compiler/test/cmdlineTests/model_checker_bmc_loop_iterations_no_argument/input.sol
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_contract_missing/err b/compiler/test/cmdlineTests/model_checker_contracts_contract_missing/err
new file mode 100644
index 00000000..08587a81
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_contract_missing/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-contracts: model_checker_contracts_inexistent_contract/input.sol:
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_empty_contract/err b/compiler/test/cmdlineTests/model_checker_contracts_empty_contract/err
new file mode 100644
index 00000000..2d6a6502
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_empty_contract/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-contracts: a.sol:
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_empty_source/err b/compiler/test/cmdlineTests/model_checker_contracts_empty_source/err
new file mode 100644
index 00000000..8357fbd8
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_empty_source/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-contracts: :A
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_inexistent_contract/err b/compiler/test/cmdlineTests/model_checker_contracts_inexistent_contract/err
new file mode 100644
index 00000000..00b97763
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_inexistent_contract/err
@@ -0,0 +1,27 @@
+Warning: Requested contract "C" does not exist in source "model_checker_contracts_inexistent_contract/input.sol".
+
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+B.constructor()
+B.f(0)
+ --> model_checker_contracts_inexistent_contract/input.sol:5:3:
+  |
+5 | 		assert(x > 0);
+  | 		^^^^^^^^^^^^^
+
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+A.constructor()
+A.g(0)
+  --> model_checker_contracts_inexistent_contract/input.sol:10:3:
+   |
+10 | 		assert(y > 0);
+   | 		^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_one_contract_missing/err b/compiler/test/cmdlineTests/model_checker_contracts_one_contract_missing/err
new file mode 100644
index 00000000..d4e93bcd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_one_contract_missing/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-contracts: model_checker_contracts_all_explicit/input.sol:,model_checker_contracts_all_explicit/input.sol:A
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_only_one/err b/compiler/test/cmdlineTests/model_checker_contracts_only_one/err
new file mode 100644
index 00000000..2088e19c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_only_one/err
@@ -0,0 +1,25 @@
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+B.constructor()
+B.f(0)
+ --> model_checker_contracts_only_one/input.sol:5:3:
+  |
+5 | 		assert(x > 0);
+  | 		^^^^^^^^^^^^^
+
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+A.constructor()
+A.g(0)
+  --> model_checker_contracts_only_one/input.sol:10:3:
+   |
+10 | 		assert(y > 0);
+   | 		^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_contracts_source_missing/err b/compiler/test/cmdlineTests/model_checker_contracts_source_missing/err
new file mode 100644
index 00000000..a6baa3ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_contracts_source_missing/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-contracts: :C
diff --git a/compiler/test/cmdlineTests/model_checker_divModSlacks_default_all/err b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_all/err
new file mode 100644
index 00000000..4ad4ce38
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_all/err
@@ -0,0 +1 @@
+Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_divModSlacks_default_bmc/err b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_bmc/err
new file mode 100644
index 00000000..d849d45f
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_bmc/err
@@ -0,0 +1 @@
+Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_divModSlacks_default_chc/err b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_chc/err
new file mode 100644
index 00000000..4ad4ce38
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_divModSlacks_default_chc/err
@@ -0,0 +1 @@
+Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_divModSlacks_false_all/err b/compiler/test/cmdlineTests/model_checker_divModSlacks_false_all/err
new file mode 100644
index 00000000..8de36b1e
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_divModSlacks_false_all/err
@@ -0,0 +1,15 @@
+Warning: CHC: Error trying to invoke SMT solver.
+ --> model_checker_divModSlacks_false_all/input.sol:6:11:
+  |
+6 | 		return (a / b, a % b);
+  | 		        ^^^^^
+
+Warning: CHC: Error trying to invoke SMT solver.
+ --> model_checker_divModSlacks_false_all/input.sol:6:18:
+  |
+6 | 		return (a / b, a % b);
+  | 		               ^^^^^
+
+Warning: CHC: 2 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_divModSlacks_false_bmc/err b/compiler/test/cmdlineTests/model_checker_divModSlacks_false_bmc/err
new file mode 100644
index 00000000..d849d45f
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_divModSlacks_false_bmc/err
@@ -0,0 +1 @@
+Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/args b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/args
new file mode 100644
index 00000000..b0c065ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-ext-calls
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/err b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/err
new file mode 100644
index 00000000..e530a206
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/err
@@ -0,0 +1 @@
+Error: No input files given. If you wish to use the standard input please specify "-" explicitly.
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/exit b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/input.sol b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/input.sol
new file mode 100644
index 00000000..bd341cea
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_empty_arg/input.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract Ext {
+	function f() public view returns (uint) {
+		return 42;
+	}
+}
+
+contract test {
+	function g(Ext e) public view {
+		uint x = e.f();
+		assert(x == 42);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/args b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/args
new file mode 100644
index 00000000..a6240ee1
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-ext-calls trusted
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/err b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/err
new file mode 100644
index 00000000..e9c2d70a
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/err
@@ -0,0 +1,7 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_ext_calls_trusted_chc/input.sol:5:2:
+  |
+5 | 	function f() public view returns (uint) {
+  | 	^ (Relevant source part starts here and spans across multiple lines).
+
+Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/input.sol b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/input.sol
new file mode 100644
index 00000000..bd341cea
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_trusted_chc/input.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract Ext {
+	function f() public view returns (uint) {
+		return 42;
+	}
+}
+
+contract test {
+	function g(Ext e) public view {
+		uint x = e.f();
+		assert(x == 42);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/args b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/args
new file mode 100644
index 00000000..e249f025
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-ext-calls untrusted
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/err b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/err
new file mode 100644
index 00000000..b06333e4
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/err
@@ -0,0 +1,14 @@
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+e = 0
+x = 1
+
+Transaction trace:
+test.constructor()
+test.g(0)
+    e.f() -- untrusted external call
+  --> model_checker_ext_calls_untrusted_chc/input.sol:11:3:
+   |
+11 | 		assert(x == 0);
+   | 		^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/input.sol b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/input.sol
new file mode 100644
index 00000000..0d28d1c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_untrusted_chc/input.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+abstract contract Ext {
+	function f() virtual public view returns (uint);
+}
+
+contract test {
+	function g(Ext e) public view {
+		uint x = e.f();
+		assert(x == 0);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/args b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/args
new file mode 100644
index 00000000..478aa5e1
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-ext-calls what
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/err b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/err
new file mode 100644
index 00000000..ec664c28
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-ext-calls: what
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/exit b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/input.sol b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/input.sol
new file mode 100644
index 00000000..bd341cea
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_ext_calls_wrong_arg/input.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract Ext {
+	function f() public view returns (uint) {
+		return 42;
+	}
+}
+
+contract test {
+	function g(Ext e) public view {
+		uint x = e.f();
+		assert(x == 42);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_invariants_all/err b/compiler/test/cmdlineTests/model_checker_invariants_all/err
new file mode 100644
index 00000000..347f4032
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_invariants_all/err
@@ -0,0 +1,14 @@
+Warning: Return value of low-level calls not used.
+ --> model_checker_invariants_all/input.sol:6:3:
+  |
+6 | 		_a.call("");
+  | 		^^^^^^^^^^^
+
+Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
+Info: Contract invariant(s) for model_checker_invariants_all/input.sol:test:
+(!(x >= 1) || true)
+Reentrancy property(ies) for model_checker_invariants_all/input.sol:test:
+(((!(x <= 0) || !(x' >= 1)) && (!(x <= 0) || !(<errorCode> >= 1))) || true)
+<errorCode> = 0 -> no errors
+<errorCode> = 1 -> Assertion failed at assert(x == 0)
diff --git a/compiler/test/cmdlineTests/model_checker_invariants_contract/err b/compiler/test/cmdlineTests/model_checker_invariants_contract/err
new file mode 100644
index 00000000..f6b01e9b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_invariants_contract/err
@@ -0,0 +1,4 @@
+Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
+Info: Contract invariant(s) for model_checker_invariants_contract/input.sol:test:
+(!(x >= 1) || true)
diff --git a/compiler/test/cmdlineTests/model_checker_invariants_contract_reentrancy/err b/compiler/test/cmdlineTests/model_checker_invariants_contract_reentrancy/err
new file mode 100644
index 00000000..c6d149f1
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_invariants_contract_reentrancy/err
@@ -0,0 +1,14 @@
+Warning: Return value of low-level calls not used.
+ --> model_checker_invariants_contract_reentrancy/input.sol:6:3:
+  |
+6 | 		_a.call("");
+  | 		^^^^^^^^^^^
+
+Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
+Info: Contract invariant(s) for model_checker_invariants_contract_reentrancy/input.sol:test:
+(!(x >= 1) || true)
+Reentrancy property(ies) for model_checker_invariants_contract_reentrancy/input.sol:test:
+(((!(x <= 0) || !(x' >= 1)) && (!(x <= 0) || !(<errorCode> >= 1))) || true)
+<errorCode> = 0 -> no errors
+<errorCode> = 1 -> Assertion failed at assert(x == 0)
diff --git a/compiler/test/cmdlineTests/model_checker_invariants_reentrancy/err b/compiler/test/cmdlineTests/model_checker_invariants_reentrancy/err
new file mode 100644
index 00000000..bdd19fa1
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_invariants_reentrancy/err
@@ -0,0 +1,12 @@
+Warning: Return value of low-level calls not used.
+ --> model_checker_invariants_reentrancy/input.sol:6:3:
+  |
+6 | 		_a.call("");
+  | 		^^^^^^^^^^^
+
+Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
+Info: Reentrancy property(ies) for model_checker_invariants_reentrancy/input.sol:test:
+(((!(x <= 0) || !(x' >= 1)) && (!(x <= 0) || !(<errorCode> >= 1))) || true)
+<errorCode> = 0 -> no errors
+<errorCode> = 1 -> Assertion failed at assert(x < 10)
diff --git a/compiler/test/cmdlineTests/model_checker_invariants_wrong/err b/compiler/test/cmdlineTests/model_checker_invariants_wrong/err
new file mode 100644
index 00000000..a9ed1d37
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_invariants_wrong/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-invariants: what
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_all/args b/compiler/test/cmdlineTests/model_checker_print_query_all/args
new file mode 100644
index 00000000..d0b07d5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_all/args
@@ -0,0 +1 @@
+--model-checker-engine all --model-checker-print-query --model-checker-solvers smtlib2 --model-checker-timeout 1000
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_all/err b/compiler/test/cmdlineTests/model_checker_print_query_all/err
new file mode 100644
index 00000000..1a04042c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_all/err
@@ -0,0 +1,165 @@
+Info: CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+
+
+Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Warning: CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.
+
+Info: BMC: Requested query:
+(set-option :produce-models true)
+(set-option :timeout 1000)
+(set-logic ALL)
+(declare-fun |x_5_3| () Int)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_4| () Int)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+
+
+Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Warning: BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_all/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_all/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_all/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_bmc/args b/compiler/test/cmdlineTests/model_checker_print_query_bmc/args
new file mode 100644
index 00000000..d13bdc43
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-print-query --model-checker-solvers smtlib2
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_bmc/err b/compiler/test/cmdlineTests/model_checker_print_query_bmc/err
new file mode 100644
index 00000000..1a59f87b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_bmc/err
@@ -0,0 +1,32 @@
+Info: BMC: Requested query:
+(set-option :produce-models true)
+(set-logic ALL)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+
+
+Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Warning: BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_bmc/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_bmc/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_chc/args b/compiler/test/cmdlineTests/model_checker_print_query_chc/args
new file mode 100644
index 00000000..752709ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-print-query --model-checker-solvers smtlib2 --model-checker-timeout 1000
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_chc/err b/compiler/test/cmdlineTests/model_checker_print_query_chc/err
new file mode 100644
index 00000000..1dd7f0c9
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_chc/err
@@ -0,0 +1,129 @@
+Info: CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+
+
+Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Warning: CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_chc/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_chc/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_chc/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/args b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/args
new file mode 100644
index 00000000..12b7c324
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-print-query --model-checker-solvers z3
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/err b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/err
new file mode 100644
index 00000000..1e229644
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/err
@@ -0,0 +1 @@
+Error: Only SMTLib2 solver can be enabled to print queries
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/exit b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_bmc/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/args b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/args
new file mode 100644
index 00000000..e3a8c32d
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-print-query --model-checker-solvers z3
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/err b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/err
new file mode 100644
index 00000000..1e229644
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/err
@@ -0,0 +1 @@
+Error: Only SMTLib2 solver can be enabled to print queries
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/exit b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_no_smtlib2_solver_chc/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/args b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/args
new file mode 100644
index 00000000..64e5d887
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-print-query --model-checker-solvers z3,smtlib2
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/err b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/err
new file mode 100644
index 00000000..1e229644
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/err
@@ -0,0 +1 @@
+Error: Only SMTLib2 solver can be enabled to print queries
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/exit b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/input.sol b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/input.sol
new file mode 100644
index 00000000..eb4cd572
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_print_query_superflous_solver/input.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		assert(x == 0);
+	}
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/args
new file mode 100644
index 00000000..5aeb1490
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/args
@@ -0,0 +1 @@
+--model-checker-engine all
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/err
new file mode 100644
index 00000000..b896b21b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/err
@@ -0,0 +1,7 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_default_all_engines/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_all_engines/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/args
new file mode 100644
index 00000000..549f2023
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/err
new file mode 100644
index 00000000..f4a2d33e
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/err
@@ -0,0 +1,7 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_default_bmc/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_bmc/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/args
new file mode 100644
index 00000000..7458a47d
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/err
new file mode 100644
index 00000000..ab73c6bf
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/err
@@ -0,0 +1,7 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_default_chc/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_default_chc/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/args
new file mode 100644
index 00000000..ea8cde3e
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/args
@@ -0,0 +1 @@
+--model-checker-engine all --model-checker-show-proved-safe
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/err
new file mode 100644
index 00000000..297eb497
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/err
@@ -0,0 +1,17 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_true_all_engines/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: CHC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_all_engines/input.sol:5:9:
+  |
+5 |         assert(x >= 0);
+  |         ^^^^^^^^^^^^^^
+
+Info: CHC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_all_engines/input.sol:6:9:
+  |
+6 |         assert(x < 1000);
+  |         ^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_all_engines/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/args
new file mode 100644
index 00000000..83385f6b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-show-proved-safe
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/err
new file mode 100644
index 00000000..bcec557f
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/err
@@ -0,0 +1,17 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_true_bmc/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: BMC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_bmc/input.sol:5:9:
+  |
+5 |         assert(x >= 0);
+  |         ^^^^^^^^^^^^^^
+
+Info: BMC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_bmc/input.sol:6:9:
+  |
+6 |         assert(x < 1000);
+  |         ^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_bmc/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/args b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/args
new file mode 100644
index 00000000..b49ef31b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-show-proved-safe
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/err b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/err
new file mode 100644
index 00000000..fc14f494
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/err
@@ -0,0 +1,17 @@
+Warning: Function state mutability can be restricted to pure
+ --> model_checker_show_proved_safe_true_chc/input.sol:4:5:
+  |
+4 |     function f(uint8 x) public {
+  |     ^ (Relevant source part starts here and spans across multiple lines).
+
+Info: CHC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_chc/input.sol:5:9:
+  |
+5 |         assert(x >= 0);
+  |         ^^^^^^^^^^^^^^
+
+Info: CHC: Assertion violation check is safe!
+ --> model_checker_show_proved_safe_true_chc/input.sol:6:9:
+  |
+6 |         assert(x < 1000);
+  |         ^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/input.sol b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/input.sol
new file mode 100644
index 00000000..ea739702
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_proved_safe_true_chc/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f(uint8 x) public {
+        assert(x >= 0);
+        assert(x < 1000);
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/args
new file mode 100644
index 00000000..5aeb1490
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/args
@@ -0,0 +1 @@
+--model-checker-engine all
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/err
new file mode 100644
index 00000000..578846b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/err
@@ -0,0 +1 @@
+Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option "show unsupported" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_all_engines/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/args
new file mode 100644
index 00000000..549f2023
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/err
new file mode 100644
index 00000000..578846b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/err
@@ -0,0 +1 @@
+Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option "show unsupported" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_bmc/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/args
new file mode 100644
index 00000000..7458a47d
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/err
new file mode 100644
index 00000000..578846b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/err
@@ -0,0 +1 @@
+Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option "show unsupported" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_default_chc/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/args
new file mode 100644
index 00000000..c0e87674
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/args
@@ -0,0 +1 @@
+--model-checker-engine all --model-checker-show-unsupported
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/err
new file mode 100644
index 00000000..53c664ff
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/err
@@ -0,0 +1,5 @@
+Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> model_checker_show_unsupported_true_all_engines/input.sol:5:9:
+  |
+5 |         assembly {}
+  |         ^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_all_engines/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/args
new file mode 100644
index 00000000..ab152ae2
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/args
@@ -0,0 +1 @@
+--model-checker-engine bmc --model-checker-show-unsupported
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/err
new file mode 100644
index 00000000..013a7b0f
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/err
@@ -0,0 +1,5 @@
+Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> model_checker_show_unsupported_true_bmc/input.sol:5:9:
+  |
+5 |         assembly {}
+  |         ^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_bmc/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/args b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/args
new file mode 100644
index 00000000..16821838
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/args
@@ -0,0 +1 @@
+--model-checker-engine chc --model-checker-show-unsupported
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/err b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/err
new file mode 100644
index 00000000..8dad0cc6
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/err
@@ -0,0 +1,5 @@
+Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> model_checker_show_unsupported_true_chc/input.sol:5:9:
+  |
+5 |         assembly {}
+  |         ^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/input.sol b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/input.sol
new file mode 100644
index 00000000..72a8049c
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_show_unsupported_true_chc/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract C {
+    function f() external pure {
+        assembly {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/model_checker_solvers_wrong/err b/compiler/test/cmdlineTests/model_checker_solvers_wrong/err
new file mode 100644
index 00000000..3493055a
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_solvers_wrong/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-solvers: ultraSolver
diff --git a/compiler/test/cmdlineTests/model_checker_solvers_wrong2/err b/compiler/test/cmdlineTests/model_checker_solvers_wrong2/err
new file mode 100644
index 00000000..a3f12108
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_solvers_wrong2/err
@@ -0,0 +1 @@
+Error: "smtlib2" is not found.
diff --git a/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/args b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/args
new file mode 100644
index 00000000..5aeb1490
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/args
@@ -0,0 +1 @@
+--model-checker-engine all
diff --git a/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/err b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/err
new file mode 100644
index 00000000..98d61828
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/err
@@ -0,0 +1,12 @@
+Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+test.constructor()
+test.f(0)
+ --> model_checker_solvers_z3_implicit/input.sol:5:3:
+  |
+5 | 		assert(x > 0);
+  | 		^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/input.sol b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/input.sol
new file mode 100644
index 00000000..7d05ef6e
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_solvers_z3_implicit/input.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+contract test {
+	function f(uint x) public pure {
+		assert(x > 0);
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/model_checker_targets_error/err b/compiler/test/cmdlineTests/model_checker_targets_error/err
new file mode 100644
index 00000000..63fa000a
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_targets_error/err
@@ -0,0 +1 @@
+Error: Invalid option for --model-checker-targets: aaa,bbb
diff --git a/compiler/test/cmdlineTests/model_checker_timeout_all/err b/compiler/test/cmdlineTests/model_checker_timeout_all/err
new file mode 100644
index 00000000..651dc83b
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_timeout_all/err
@@ -0,0 +1,5 @@
+Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Info: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
+Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
diff --git a/compiler/test/cmdlineTests/model_checker_timeout_bmc/err b/compiler/test/cmdlineTests/model_checker_timeout_bmc/err
new file mode 100644
index 00000000..eb20e7ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_timeout_bmc/err
@@ -0,0 +1,3 @@
+Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Info: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/model_checker_timeout_chc/err b/compiler/test/cmdlineTests/model_checker_timeout_chc/err
new file mode 100644
index 00000000..f6ca5c2a
--- /dev/null
+++ b/compiler/test/cmdlineTests/model_checker_timeout_chc/err
@@ -0,0 +1,3 @@
+Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option "show unproved" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+Info: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/cmdlineTests/name_simplifier/output b/compiler/test/cmdlineTests/name_simplifier/output
new file mode 100644
index 00000000..ed4c6e5c
--- /dev/null
+++ b/compiler/test/cmdlineTests/name_simplifier/output
@@ -0,0 +1,125 @@
+Optimized IR:
+/// @use-src 0:"name_simplifier/input.sol"
+object "C_59" {
+    code {
+        {
+            /// @src 0:346:625  "contract C {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_59_deployed")
+            codecopy(_1, dataoffset("C_59_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"name_simplifier/input.sol"
+    object "C_59_deployed" {
+        code {
+            {
+                /// @src 0:346:625  "contract C {..."
+                let _1 := memoryguard(0x80)
+                let _2 := 4
+                if iszero(lt(calldatasize(), _2))
+                {
+                    if eq(0xf8eddcc6, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        let _3 := 32
+                        if slt(add(calldatasize(), not(3)), _3) { revert(0, 0) }
+                        let offset := calldataload(_2)
+                        let _4 := 0xffffffffffffffff
+                        if gt(offset, _4) { revert(0, 0) }
+                        if iszero(slt(add(offset, 35), calldatasize())) { revert(0, 0) }
+                        let _5 := calldataload(add(_2, offset))
+                        let _6 := 36
+                        if gt(_5, _4)
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(_2, 0x41)
+                            revert(0, _6)
+                        }
+                        let _7 := shl(5, _5)
+                        let _8 := not(31)
+                        let newFreePtr := add(_1, and(add(_7, 63), _8))
+                        if or(gt(newFreePtr, _4), lt(newFreePtr, _1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(_2, 0x41)
+                            revert(0, _6)
+                        }
+                        let _9 := 64
+                        mstore(_9, newFreePtr)
+                        let dst := _1
+                        mstore(_1, _5)
+                        dst := add(_1, _3)
+                        let dst_1 := dst
+                        let srcEnd := add(add(offset, _7), _6)
+                        if gt(srcEnd, calldatasize()) { revert(0, 0) }
+                        let src := add(offset, _6)
+                        for { } lt(src, srcEnd) { src := add(src, _3) }
+                        {
+                            if slt(sub(calldatasize(), src), _3) { revert(0, 0) }
+                            let memPtr := mload(_9)
+                            let newFreePtr_1 := add(memPtr, _3)
+                            if or(gt(newFreePtr_1, _4), lt(newFreePtr_1, memPtr))
+                            {
+                                mstore(0, shl(224, 0x4e487b71))
+                                mstore(_2, 0x41)
+                                revert(0, _6)
+                            }
+                            mstore(_9, newFreePtr_1)
+                            mstore(memPtr, calldataload(src))
+                            mstore(dst, memPtr)
+                            dst := add(dst, _3)
+                        }
+                        if iszero(mload(_1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(_2, 0x32)
+                            revert(0, _6)
+                        }
+                        sstore(0, mload(/** @src 0:469:474  "_s[0]" */ mload(dst_1)))
+                        /// @src 0:346:625  "contract C {..."
+                        if iszero(lt(/** @src 0:492:493  "1" */ 0x01, /** @src 0:346:625  "contract C {..." */ mload(_1)))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(_2, 0x32)
+                            revert(0, _6)
+                        }
+                        let _10 := mload(/** @src 0:489:494  "_s[1]" */ mload(/** @src 0:346:625  "contract C {..." */ add(_1, _9)))
+                        sstore(0x02, _10)
+                        let memPtr_1 := mload(_9)
+                        let newFreePtr_2 := add(memPtr_1, 160)
+                        if or(gt(newFreePtr_2, _4), lt(newFreePtr_2, memPtr_1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(_2, 0x41)
+                            revert(0, _6)
+                        }
+                        mstore(_9, newFreePtr_2)
+                        mstore(memPtr_1, 100)
+                        mstore(add(memPtr_1, _3), "longstringlongstringlongstringlo")
+                        mstore(add(memPtr_1, _9), "ngstringlongstringlongstringlong")
+                        let _11 := 96
+                        mstore(add(memPtr_1, 96), "stringlongstringlongstringlongst")
+                        mstore(add(memPtr_1, 128), "ring")
+                        let memPos := mload(_9)
+                        mstore(memPos, _10)
+                        mstore(add(memPos, _3), _9)
+                        let length := mload(memPtr_1)
+                        mstore(add(memPos, _9), length)
+                        let i := 0
+                        for { } lt(i, length) { i := add(i, _3) }
+                        {
+                            mstore(add(add(memPos, i), _11), mload(add(add(memPtr_1, i), _3)))
+                        }
+                        mstore(add(add(memPos, length), 96), 0)
+                        return(memPos, add(sub(add(memPos, and(add(length, 31), _8)), memPos), 96))
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata/args b/compiler/test/cmdlineTests/no_cbor_metadata/args
new file mode 100644
index 00000000..428810db
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata/args
@@ -0,0 +1 @@
+--no-cbor-metadata --bin --via-ir --optimize
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata/input.sol b/compiler/test/cmdlineTests/no_cbor_metadata/input.sol
new file mode 100644
index 00000000..4ed3a245
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata/input.sol
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >= 0.0.0;
+
+// NOTE: The expected output would be the binary with no metadata.
+// The commandline tests would replace bytecode with metadata in it with
+// <BYTECODE REMOVED>
+// Therefore, not having that means success!
+
+contract C {
+}
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata/output b/compiler/test/cmdlineTests/no_cbor_metadata/output
new file mode 100644
index 00000000..0328ece3
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata/output
@@ -0,0 +1,4 @@
+
+======= no_cbor_metadata/input.sol:C =======
+Binary:
+608080604052346013576003908160188239f35b5f80fdfe5f80fd
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/args b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/args
new file mode 100644
index 00000000..eb524931
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/args
@@ -0,0 +1 @@
+--no-cbor-metadata --metadata-hash ipfs
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/err b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/err
new file mode 100644
index 00000000..fc5787c5
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/err
@@ -0,0 +1 @@
+Error: Cannot specify a metadata hashing method when --no-cbor-metadata is set.
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/exit b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/input.sol b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/input.sol
new file mode 100644
index 00000000..f22a20f1
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_cbor_metadata_with_metadata_hash/input.sol
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >= 0.0.0;
+
+contract Empty {}
+
+contract C {
+    function f() external returns (bytes memory, bytes memory){
+        return (type(Empty).creationCode, type(Empty).runtimeCode);
+    }
+}
diff --git a/compiler/test/cmdlineTests/no_contract_combined_json/args b/compiler/test/cmdlineTests/no_contract_combined_json/args
new file mode 100644
index 00000000..8d81d1c0
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_contract_combined_json/args
@@ -0,0 +1 @@
+--combined-json ast --pretty-json --json-indent 4
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/no_contract_combined_json/input.sol b/compiler/test/cmdlineTests/no_contract_combined_json/input.sol
new file mode 100644
index 00000000..b926e926
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_contract_combined_json/input.sol
@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/no_contract_combined_json/output b/compiler/test/cmdlineTests/no_contract_combined_json/output
new file mode 100644
index 00000000..e0caa6fa
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_contract_combined_json/output
@@ -0,0 +1,37 @@
+{
+    "sourceList":
+    [
+        "no_contract_combined_json/input.sol"
+    ],
+    "sources":
+    {
+        "no_contract_combined_json/input.sol":
+        {
+            "AST":
+            {
+                "absolutePath": "no_contract_combined_json/input.sol",
+                "exportedSymbols": {},
+                "id": 2,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            ">=",
+                            "0.0"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:22:0"
+                    }
+                ],
+                "src": "36:22:0"
+            },
+            "id": 0
+        }
+    },
+    "version": "<VERSION REMOVED>"
+}
diff --git a/compiler/test/cmdlineTests/no_import_callback/args b/compiler/test/cmdlineTests/no_import_callback/args
new file mode 100644
index 00000000..e816120d
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_import_callback/args
@@ -0,0 +1 @@
+--no-import-callback no_import_callback/contract_1.sol
diff --git a/compiler/test/cmdlineTests/no_import_callback/contract_1.sol b/compiler/test/cmdlineTests/no_import_callback/contract_1.sol
new file mode 100644
index 00000000..36b2470c
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_import_callback/contract_1.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+import "contract_2.sol";
diff --git a/compiler/test/cmdlineTests/no_import_callback/contract_2.sol b/compiler/test/cmdlineTests/no_import_callback/contract_2.sol
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/no_import_callback/err b/compiler/test/cmdlineTests/no_import_callback/err
new file mode 100644
index 00000000..45690e34
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_import_callback/err
@@ -0,0 +1,5 @@
+Error: Source "contract_2.sol" not found: No import callback.
+ --> no_import_callback/contract_1.sol:4:1:
+  |
+4 | import "contract_2.sol";
+  | ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/compiler/test/cmdlineTests/no_import_callback/exit b/compiler/test/cmdlineTests/no_import_callback/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/no_import_callback/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/object_compiler/output b/compiler/test/cmdlineTests/object_compiler/output
new file mode 100644
index 00000000..5dd57227
--- /dev/null
+++ b/compiler/test/cmdlineTests/object_compiler/output
@@ -0,0 +1,65 @@
+
+======= object_compiler/input.yul (EVM) =======
+
+Pretty printed source:
+object "MyContract" {
+    code {
+        {
+            sstore(0, caller())
+            let _1 := datasize("Runtime")
+            datacopy(0, dataoffset("Runtime"), _1)
+            return(0, _1)
+        }
+    }
+    object "Runtime" {
+        code {
+            {
+                mstore(0, sload(0))
+                return(0, 0x20)
+            }
+        }
+    }
+}
+
+
+Binary representation:
+335f55600880600d5f395ff3fe5f545f5260205ff3
+
+Text representation:
+    /* "object_compiler/input.yul":128:136   */
+  caller
+    /* "object_compiler/input.yul":125:126   */
+  0x00
+    /* "object_compiler/input.yul":118:137   */
+  sstore
+    /* "object_compiler/input.yul":240:259   */
+  dataSize(sub_0)
+    /* "object_compiler/input.yul":217:238   */
+  dup1
+  dataOffset(sub_0)
+    /* "object_compiler/input.yul":125:126   */
+  0x00
+    /* "object_compiler/input.yul":205:260   */
+  codecopy
+    /* "object_compiler/input.yul":125:126   */
+  0x00
+    /* "object_compiler/input.yul":265:295   */
+  return
+stop
+
+sub_0: assembly {
+        /* "object_compiler/input.yul":397:398   */
+      0x00
+        /* "object_compiler/input.yul":391:399   */
+      sload
+        /* "object_compiler/input.yul":397:398   */
+      0x00
+        /* "object_compiler/input.yul":381:400   */
+      mstore
+        /* "object_compiler/input.yul":417:421   */
+      0x20
+        /* "object_compiler/input.yul":397:398   */
+      0x00
+        /* "object_compiler/input.yul":407:422   */
+      return
+}
diff --git a/compiler/test/cmdlineTests/optimizer_array_sload/output b/compiler/test/cmdlineTests/optimizer_array_sload/output
new file mode 100644
index 00000000..b32d421d
--- /dev/null
+++ b/compiler/test/cmdlineTests/optimizer_array_sload/output
@@ -0,0 +1,65 @@
+Optimized IR:
+/// @use-src 0:"optimizer_array_sload/input.sol"
+object "Arraysum_34" {
+    code {
+        {
+            /// @src 0:80:429  "contract Arraysum {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("Arraysum_34_deployed")
+            codecopy(_1, dataoffset("Arraysum_34_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"optimizer_array_sload/input.sol"
+    object "Arraysum_34_deployed" {
+        code {
+            {
+                /// @src 0:80:429  "contract Arraysum {..."
+                mstore(64, memoryguard(0x80))
+                let _1 := 4
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x81d73423, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let var_sum := 0
+                        /// @src 0:368:378  "uint i = 0"
+                        let var_i := /** @src 0:80:429  "contract Arraysum {..." */ 0
+                        let _2 := sload(0)
+                        /// @src 0:364:423  "for(uint i = 0; i < values.length; i++)..."
+                        for { }
+                        /** @src 0:380:397  "i < values.length" */ lt(var_i, _2)
+                        /// @src 0:368:378  "uint i = 0"
+                        {
+                            /// @src 0:399:402  "i++"
+                            var_i := /** @src 0:80:429  "contract Arraysum {..." */ add(/** @src 0:399:402  "i++" */ var_i, /** @src 0:80:429  "contract Arraysum {..." */ 1)
+                        }
+                        /// @src 0:399:402  "i++"
+                        {
+                            /// @src 0:80:429  "contract Arraysum {..."
+                            mstore(0, 0)
+                            let sum := add(var_sum, sload(add(18569430475105882587588266137607568536673111973893317399460219858819262702947, var_i)))
+                            if gt(var_sum, sum)
+                            {
+                                mstore(0, shl(224, 0x4e487b71))
+                                mstore(_1, 0x11)
+                                revert(0, 0x24)
+                            }
+                            /// @src 0:407:423  "sum += values[i]"
+                            var_sum := sum
+                        }
+                        /// @src 0:80:429  "contract Arraysum {..."
+                        let memPos := mload(64)
+                        mstore(memPos, var_sum)
+                        return(memPos, 32)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/args b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/args
new file mode 100644
index 00000000..ce566d3e
--- /dev/null
+++ b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/args
@@ -0,0 +1 @@
+--optimize-yul --no-optimize-yul
diff --git a/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/err b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/err
new file mode 100644
index 00000000..b8fc3914
--- /dev/null
+++ b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/err
@@ -0,0 +1 @@
+Error: Options --optimize-yul and --no-optimize-yul cannot be used together.
diff --git a/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/exit b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/input.sol b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/input.sol
new file mode 100644
index 00000000..a32f63f7
--- /dev/null
+++ b/compiler/test/cmdlineTests/optimizer_enabled_invalid_yul_optimizer_enabled_and_disabled/input.sol
@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
diff --git a/compiler/test/cmdlineTests/output_selection_all_A1/output.json b/compiler/test/cmdlineTests/output_selection_all_A1/output.json
new file mode 100644
index 00000000..b21b632b
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_all_A1/output.json
@@ -0,0 +1,42 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        },
+        "b.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_all_A2/output.json b/compiler/test/cmdlineTests/output_selection_all_A2/output.json
new file mode 100644
index 00000000..c33941c2
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_all_A2/output.json
@@ -0,0 +1,29 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A2":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_all_blank/output.json b/compiler/test/cmdlineTests/output_selection_all_blank/output.json
new file mode 100644
index 00000000..b4c60911
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_all_blank/output.json
@@ -0,0 +1,13 @@
+{
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_all_star/output.json b/compiler/test/cmdlineTests/output_selection_all_star/output.json
new file mode 100644
index 00000000..f7096362
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_all_star/output.json
@@ -0,0 +1,62 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            },
+            "A2":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        },
+        "b.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            },
+            "B2":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_single_A1/output.json b/compiler/test/cmdlineTests/output_selection_single_A1/output.json
new file mode 100644
index 00000000..ab44a2d5
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_single_A1/output.json
@@ -0,0 +1,29 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_single_B1/output.json b/compiler/test/cmdlineTests/output_selection_single_B1/output.json
new file mode 100644
index 00000000..ffaf266b
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_single_B1/output.json
@@ -0,0 +1,29 @@
+{
+    "contracts":
+    {
+        "b.sol":
+        {
+            "B2":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/output_selection_single_all/output.json b/compiler/test/cmdlineTests/output_selection_single_all/output.json
new file mode 100644
index 00000000..52d04cb1
--- /dev/null
+++ b/compiler/test/cmdlineTests/output_selection_single_all/output.json
@@ -0,0 +1,39 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A1":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            },
+            "A2":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        },
+        "b.sol":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/pretty_json_indent_only/no-pretty-print b/compiler/test/cmdlineTests/pretty_json_indent_only/no-pretty-print
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/pretty_json_standard/no-pretty-print b/compiler/test/cmdlineTests/pretty_json_standard/no-pretty-print
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/pretty_json_standard_indent/no-pretty-print b/compiler/test/cmdlineTests/pretty_json_standard_indent/no-pretty-print
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/args b/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/args
new file mode 100644
index 00000000..691b7fa5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/args
@@ -0,0 +1 @@
+--ast-compact-json --asm --asm-json --opcodes --bin --bin-runtime --abi --ir --ir-optimized --hashes --userdoc --devdoc --metadata --storage-layout
diff --git a/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/err b/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/err
new file mode 100644
index 00000000..cdbcdd15
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_cli_output_selection_invalid/err
@@ -0,0 +1 @@
+Error: The following outputs are not supported in standard JSON mode: --abi, --asm, --asm-json, --ast-compact-json, --bin, --bin-runtime, --devdoc, --hashes, --ir, --ir-optimized, --metadata, --opcodes, --storage-layout, --userdoc.
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json b/compiler/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json
new file mode 100644
index 00000000..143ad92c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json
@@ -0,0 +1,730 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"C\":79:428  contract C... */
+  0xa0
+  jumpi(tag_5, callvalue)
+  0x1f
+  bytecodeSize
+  codesize
+  dup2
+  swap1
+  sub
+  swap2
+  dup3
+  add
+  not(0x1f)
+  and
+  dup4
+  add
+  swap2
+  sub(shl(0x40, 0x01), 0x01)
+  dup4
+  gt
+  dup5
+  dup5
+  lt
+  or
+  tag_3
+  jumpi
+  dup1
+  dup5
+  swap3
+  0x20
+  swap5
+  0x40
+  mstore
+  dup4
+  codecopy
+  dup2
+  add
+  sub
+  slt
+  tag_5
+  jumpi
+  mload
+    /* \"C\":147:149  42 */
+  mstore(0x80, 0x2a)
+  0x00
+    /* \"C\":79:428  contract C... */
+  sstore
+  mload(0x40)
+  dataSize(sub_0)
+  swap1
+  dup2
+  dataOffset(sub_0)
+  dup3
+  codecopy
+    /* \"C\":147:149  42 */
+  0x80
+    /* \"C\":79:428  contract C... */
+  mload
+  dup2
+  assignImmutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+  return
+tag_5:
+  0x00
+  dup1
+  revert
+tag_3:
+  mstore(0x00, shl(0xe0, 0x4e487b71))
+  mstore(0x04, 0x41)
+  revert(0x00, 0x24)
+stop
+
+sub_0: assembly {
+        /* \"C\":79:428  contract C... */
+      0x80
+      0x40
+      swap1
+      dup1
+      dup3
+      mstore
+      jumpi(tag_2, iszero(lt(calldatasize, 0x04)))
+      0x00
+      dup1
+      revert
+    tag_2:
+      shr(0xe0, calldataload(0x00))
+      swap1
+      dup2
+      0x26121ff0
+      eq
+      tag_4
+      jumpi
+      pop
+      dup1
+      0x793816ec
+      eq
+      tag_6
+      jumpi
+      0x9942ec6f
+      eq
+      tag_8
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_8:
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+      sload(0x00)
+      sub(shl(0xff, 0x01), 0x01)
+      dup2
+      eq
+      tag_14
+      jumpi
+      0x01
+      add
+      0x00
+      dup2
+      swap1
+      sstore
+      dup2
+      mload
+      shl(0xe4, 0x026121ff)
+        /* \"C\":403:411  this.f() */
+      dup2
+      mstore
+        /* \"C\":79:428  contract C... */
+      swap2
+      swap1
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"C\":79:428  contract C... */
+      dup4
+      0x04
+      dup2
+        /* \"C\":403:407  this */
+      address
+        /* \"C\":403:411  this.f() */
+      gas
+      staticcall
+      swap3
+      dup4
+      iszero
+      tag_16
+      jumpi
+        /* \"C\":79:428  contract C... */
+      0x00
+        /* \"C\":403:411  this.f() */
+      swap4
+      tag_18
+      jumpi
+        /* \"C\":79:428  contract C... */
+    tag_19:
+        /* \"C\":392:411  stateVar + this.f() */
+      pop
+      tag_20
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"C\":392:411  stateVar + this.f() */
+      swap4
+        /* \"C\":392:422  stateVar + this.f() + immutVar */
+      tag_21
+        /* \"C\":392:411  stateVar + this.f() */
+      swap3
+      tag_1
+      jump\t// in
+    tag_20:
+        /* \"C\":414:422  immutVar */
+      immutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+        /* \"C\":392:422  stateVar + this.f() + immutVar */
+      swap1
+      tag_1
+      jump\t// in
+    tag_21:
+        /* \"C\":79:428  contract C... */
+      swap1
+      mload
+      swap1
+      dup2
+      mstore
+      return
+        /* \"C\":403:411  this.f() */
+    tag_18:
+      swap3
+      pop
+      0x20
+      jumpi(tag_22, gt(0x20, returndatasize))
+    tag_23:
+        /* \"C\":79:428  contract C... */
+      0x1f
+      dup2
+      add
+      not(0x1f)
+      and
+      dup5
+      add
+      0xffffffffffffffff
+      dup2
+      gt
+      dup6
+      dup3
+      lt
+      or
+      tag_24
+      jumpi
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"C\":79:428  contract C... */
+      swap2
+      dup6
+      swap2
+      dup6
+      mstore
+        /* \"C\":403:411  this.f() */
+      dup2
+      add
+        /* \"C\":79:428  contract C... */
+      sub
+      slt
+      tag_26
+      jumpi
+      swap2
+      mload
+      swap2
+        /* \"C\":392:411  stateVar + this.f() */
+      tag_20
+        /* \"C\":403:411  this.f() */
+      jump(tag_19)
+        /* \"C\":79:428  contract C... */
+    tag_26:
+      0x00
+      dup1
+      revert
+    tag_24:
+        /* \"C\":117:119  41 */
+      shl(0xe0, 0x4e487b71)
+        /* \"C\":79:428  contract C... */
+      0x00
+      mstore
+      mstore(0x04, 0x41)
+      revert(0x00, 0x24)
+        /* \"C\":403:411  this.f() */
+    tag_22:
+      pop
+      returndatasize
+      jump(tag_23)
+    tag_16:
+        /* \"C\":79:428  contract C... */
+      dup3
+      mload
+      returndatasize
+      0x00
+      dup3
+      returndatacopy
+      returndatasize
+      swap1
+      revert
+    tag_14:
+        /* \"C\":117:119  41 */
+      shl(0xe0, 0x4e487b71)
+        /* \"C\":79:428  contract C... */
+      0x00
+        /* \"C\":117:119  41 */
+      mstore
+      0x11
+        /* \"C\":79:428  contract C... */
+      0x04
+        /* \"C\":117:119  41 */
+      mstore
+      0x24
+        /* \"C\":79:428  contract C... */
+      0x00
+        /* \"C\":117:119  41 */
+      revert
+        /* \"C\":79:428  contract C... */
+    tag_6:
+      pop
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+      0x20
+      swap1
+      sload(0x00)
+      swap1
+      mload
+      swap1
+      dup2
+      mstore
+      return
+    tag_4:
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+        /* \"C\":290:298  immutVar */
+      immutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+        /* \"C\":117:119  41 */
+      swap1
+      dup2
+      0x29
+      add
+      swap2
+      dup3
+      slt
+      0x01
+      and
+      tag_14
+      jumpi
+        /* \"C\":79:428  contract C... */
+      0x20
+      swap2
+      dup2
+      mstore
+      return
+        /* \"C\":117:119  41 */
+    tag_1:
+      swap2
+      swap1
+      swap2
+      0x00
+      dup4
+      dup3
+      add
+      swap4
+      dup5
+      slt
+      swap2
+      slt
+      swap1
+      dup1
+      iszero
+      dup3
+      and
+      swap2
+      iszero
+      and
+      or
+      tag_14
+      jumpi
+      jump\t// out
+
+    auxdata: <AUXDATA REMOVED>
+}
+"
+                }
+            }
+        },
+        "D":
+        {
+            "D":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"D\":91:166  contract D is C(3)... */
+  0xa0
+  jumpi(tag_5, callvalue)
+  0x1f
+  bytecodeSize
+  codesize
+  dup2
+  swap1
+  sub
+  swap2
+  dup3
+  add
+  not(0x1f)
+  and
+  dup4
+  add
+  swap2
+  sub(shl(0x40, 0x01), 0x01)
+  dup4
+  gt
+  dup5
+  dup5
+  lt
+  or
+  tag_3
+  jumpi
+  dup1
+  dup5
+  swap3
+  0x20
+  swap5
+  0x40
+  mstore
+  dup4
+  codecopy
+  dup2
+  add
+  sub
+  slt
+  tag_5
+  jumpi
+  mload
+    /* \"C\":147:149  42 */
+  mstore(0x80, 0x2a)
+    /* \"D\":91:166  contract D is C(3)... */
+  dup1
+    /* \"D\":107:108  3 */
+  0x03
+    /* \"D\":91:166  contract D is C(3)... */
+  add
+  swap1
+  dup2
+  slt
+  0x01
+  and
+  tag_7
+  jumpi
+  0x00
+  sstore
+  mload(0x40)
+  dataSize(sub_0)
+  swap1
+  dup2
+  dataOffset(sub_0)
+  dup3
+  codecopy
+    /* \"C\":147:149  42 */
+  0x80
+    /* \"D\":91:166  contract D is C(3)... */
+  mload
+  dup2
+  assignImmutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+  return
+tag_7:
+  mstore(0x00, shl(0xe0, 0x4e487b71))
+  mstore(0x04, 0x11)
+  revert(0x00, 0x24)
+tag_5:
+  0x00
+  dup1
+  revert
+tag_3:
+  mstore(0x00, shl(0xe0, 0x4e487b71))
+  mstore(0x04, 0x41)
+  revert(0x00, 0x24)
+stop
+
+sub_0: assembly {
+        /* \"D\":91:166  contract D is C(3)... */
+      0x80
+      0x40
+      swap1
+      dup1
+      dup3
+      mstore
+      jumpi(tag_2, iszero(lt(calldatasize, 0x04)))
+      0x00
+      dup1
+      revert
+    tag_2:
+      shr(0xe0, calldataload(0x00))
+      swap1
+      dup2
+      0x26121ff0
+      eq
+      tag_4
+      jumpi
+      pop
+      dup1
+      0x793816ec
+      eq
+      tag_6
+      jumpi
+      0x9942ec6f
+      eq
+      tag_8
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_8:
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+      sload(0x00)
+      sub(shl(0xff, 0x01), 0x01)
+      dup2
+      eq
+      tag_14
+      jumpi
+      0x01
+      add
+      0x00
+      dup2
+      swap1
+      sstore
+      dup2
+      mload
+      shl(0xe4, 0x026121ff)
+        /* \"C\":403:411  this.f() */
+      dup2
+      mstore
+        /* \"D\":91:166  contract D is C(3)... */
+      swap2
+      swap1
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"D\":91:166  contract D is C(3)... */
+      dup4
+      0x04
+      dup2
+        /* \"C\":403:407  this */
+      address
+        /* \"C\":403:411  this.f() */
+      gas
+      staticcall
+      swap3
+      dup4
+      iszero
+      tag_16
+      jumpi
+        /* \"D\":91:166  contract D is C(3)... */
+      0x00
+        /* \"C\":403:411  this.f() */
+      swap4
+      tag_18
+      jumpi
+        /* \"D\":91:166  contract D is C(3)... */
+    tag_19:
+        /* \"C\":392:411  stateVar + this.f() */
+      pop
+      tag_20
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"C\":392:411  stateVar + this.f() */
+      swap4
+        /* \"C\":392:422  stateVar + this.f() + immutVar */
+      tag_21
+        /* \"C\":392:411  stateVar + this.f() */
+      swap3
+      tag_1
+      jump\t// in
+    tag_20:
+        /* \"C\":414:422  immutVar */
+      immutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+        /* \"C\":392:422  stateVar + this.f() + immutVar */
+      swap1
+      tag_1
+      jump\t// in
+    tag_21:
+        /* \"D\":91:166  contract D is C(3)... */
+      swap1
+      mload
+      swap1
+      dup2
+      mstore
+      return
+        /* \"C\":403:411  this.f() */
+    tag_18:
+      swap3
+      pop
+      0x20
+      jumpi(tag_22, gt(0x20, returndatasize))
+    tag_23:
+        /* \"D\":91:166  contract D is C(3)... */
+      0x1f
+      dup2
+      add
+      not(0x1f)
+      and
+      dup5
+      add
+      0xffffffffffffffff
+      dup2
+      gt
+      dup6
+      dup3
+      lt
+      or
+      tag_24
+      jumpi
+        /* \"C\":403:411  this.f() */
+      0x20
+        /* \"D\":91:166  contract D is C(3)... */
+      swap2
+      dup6
+      swap2
+      dup6
+      mstore
+        /* \"C\":403:411  this.f() */
+      dup2
+      add
+        /* \"D\":91:166  contract D is C(3)... */
+      sub
+      slt
+      tag_26
+      jumpi
+      swap2
+      mload
+      swap2
+        /* \"C\":392:411  stateVar + this.f() */
+      tag_20
+        /* \"C\":403:411  this.f() */
+      jump(tag_19)
+        /* \"D\":91:166  contract D is C(3)... */
+    tag_26:
+      0x00
+      dup1
+      revert
+    tag_24:
+        /* \"C\":117:119  41 */
+      shl(0xe0, 0x4e487b71)
+        /* \"D\":91:166  contract D is C(3)... */
+      0x00
+      mstore
+      mstore(0x04, 0x41)
+      revert(0x00, 0x24)
+        /* \"C\":403:411  this.f() */
+    tag_22:
+      pop
+      returndatasize
+      jump(tag_23)
+    tag_16:
+        /* \"D\":91:166  contract D is C(3)... */
+      dup3
+      mload
+      returndatasize
+      0x00
+      dup3
+      returndatacopy
+      returndatasize
+      swap1
+      revert
+    tag_14:
+        /* \"C\":117:119  41 */
+      shl(0xe0, 0x4e487b71)
+        /* \"D\":91:166  contract D is C(3)... */
+      0x00
+        /* \"C\":117:119  41 */
+      mstore
+      0x11
+        /* \"D\":91:166  contract D is C(3)... */
+      0x04
+        /* \"C\":117:119  41 */
+      mstore
+      0x24
+        /* \"D\":91:166  contract D is C(3)... */
+      0x00
+        /* \"C\":117:119  41 */
+      revert
+        /* \"D\":91:166  contract D is C(3)... */
+    tag_6:
+      pop
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+      0x20
+      swap1
+      sload(0x00)
+      swap1
+      mload
+      swap1
+      dup2
+      mstore
+      return
+    tag_4:
+      jumpi(tag_26, callvalue)
+      jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00))
+        /* \"C\":290:298  immutVar */
+      immutable(\"0xe4b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10\")
+        /* \"C\":117:119  41 */
+      swap1
+      dup2
+      0x29
+      add
+      swap2
+      dup3
+      slt
+      0x01
+      and
+      tag_14
+      jumpi
+        /* \"D\":91:166  contract D is C(3)... */
+      0x20
+      swap2
+      dup2
+      mstore
+      return
+        /* \"C\":117:119  41 */
+    tag_1:
+      swap2
+      swap1
+      swap2
+      0x00
+      dup4
+      dup3
+      add
+      swap4
+      dup5
+      slt
+      swap2
+      slt
+      swap1
+      dup1
+      iszero
+      dup3
+      and
+      swap2
+      iszero
+      and
+      or
+      tag_14
+      jumpi
+      jump\t// out
+
+    auxdata: <AUXDATA REMOVED>
+}
+"
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        },
+        "D":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/args b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json
new file mode 100644
index 00000000..ee958b55
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_all/output.json
@@ -0,0 +1,221 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"C\":60:101  contract C {... */
+  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+        /* \"C\":60:101  contract C {... */
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+        /* \"C\":77:99  function f() public {} */
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+"
+                },
+                "ir": "
+/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+        /// @src 0:60:101  \"contract C {...\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_6_deployed\"), datasize(\"C_6_deployed\"))
+
+        return(_1, datasize(\"C_6_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:60:101  \"contract C {...\"
+        function constructor_C_6() {
+
+            /// @src 0:60:101  \"contract C {...\"
+
+        }
+        /// @src 0:60:101  \"contract C {...\"
+
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+            /// @src 0:60:101  \"contract C {...\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            /// @ast-id 5
+            /// @src 0:77:99  \"function f() public {}\"
+            function fun_f_5() {
+
+            }
+            /// @src 0:60:101  \"contract C {...\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+",
+                "irOptimized": "/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+        {
+            /// @src 0:60:101  \"contract C {...\"
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize(\"C_6_deployed\")
+            codecopy(_1, dataoffset(\"C_6_deployed\"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+            {
+                /// @src 0:60:101  \"contract C {...\"
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/args b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json
new file mode 100644
index 00000000..007b7fc6
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_location_only/output.json
@@ -0,0 +1,220 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"C\":60:101 */
+  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+        /* \"C\":60:101 */
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+        /* \"C\":77:99 */
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+"
+                },
+                "ir": "
+/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+        /// @src 0:60:101
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_6_deployed\"), datasize(\"C_6_deployed\"))
+
+        return(_1, datasize(\"C_6_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:60:101
+        function constructor_C_6() {
+
+            /// @src 0:60:101
+
+        }
+        /// @src 0:60:101
+
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+            /// @src 0:60:101
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            /// @src 0:77:99
+            function fun_f_5() {
+
+            }
+            /// @src 0:60:101
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+",
+                "irOptimized": "/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+        {
+            /// @src 0:60:101
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize(\"C_6_deployed\")
+            codecopy(_1, dataoffset(\"C_6_deployed\"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+            {
+                /// @src 0:60:101
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/args b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json
new file mode 100644
index 00000000..884da9eb
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_none/output.json
@@ -0,0 +1,209 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "assembly": "  mstore(0x40, 0x80)
+  callvalue
+  dup1
+  iszero
+  tag_1
+  jumpi
+  0x00
+  dup1
+  revert
+tag_1:
+  pop
+  dataSize(sub_0)
+  dup1
+  dataOffset(sub_0)
+  0x00
+  codecopy
+  0x00
+  return
+stop
+
+sub_0: assembly {
+      mstore(0x40, 0x80)
+      callvalue
+      dup1
+      iszero
+      tag_1
+      jumpi
+      0x00
+      dup1
+      revert
+    tag_1:
+      pop
+      jumpi(tag_2, lt(calldatasize, 0x04))
+      shr(0xe0, calldataload(0x00))
+      dup1
+      0x26121ff0
+      eq
+      tag_3
+      jumpi
+    tag_2:
+      0x00
+      dup1
+      revert
+    tag_3:
+      stop
+
+    auxdata: <AUXDATA REMOVED>
+}
+"
+                },
+                "ir": "
+/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_6()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_6_deployed\"), datasize(\"C_6_deployed\"))
+
+        return(_1, datasize(\"C_6_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        function constructor_C_6() {
+
+        }
+
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function fun_f_5() {
+
+            }
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+",
+                "irOptimized": "/// @use-src 0:\"C\"
+object \"C_6\" {
+    code {
+        {
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize(\"C_6_deployed\")
+            codecopy(_1, dataoffset(\"C_6_deployed\"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:\"C\"
+    object \"C_6_deployed\" {
+        code {
+            {
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_snippet_only/args b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_snippet_only/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_and_evm_asm_print_snippet_only/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_debug_info_in_yul_location/output.json b/compiler/test/cmdlineTests/standard_debug_info_in_yul_location/output.json
new file mode 100644
index 00000000..26711627
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_debug_info_in_yul_location/output.json
@@ -0,0 +1,1629 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"C\"
+object \"C_54\" {
+    code {
+        /// @src 0:79:435  \"contract C...\"
+        mstore(64, memoryguard(160))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        let _1 := copy_arguments_for_constructor_20_object_C_54()
+        constructor_C_54(_1)
+
+        let _2 := allocate_unbounded()
+        codecopy(_2, dataoffset(\"C_54_deployed\"), datasize(\"C_54_deployed\"))
+
+        setimmutable(_2, \"8\", mload(128))
+
+        return(_2, datasize(\"C_54_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        function round_up_to_mul_of_32(value) -> result {
+            result := and(add(value, 31), not(31))
+        }
+
+        function panic_error_0x41() {
+            mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+            mstore(4, 0x41)
+            revert(0, 0x24)
+        }
+
+        function finalize_allocation(memPtr, size) {
+            let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+            // protect against overflow
+            if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+            mstore(64, newFreePtr)
+        }
+
+        function allocate_memory(size) -> memPtr {
+            memPtr := allocate_unbounded()
+            finalize_allocation(memPtr, size)
+        }
+
+        function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+            revert(0, 0)
+        }
+
+        function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {
+            revert(0, 0)
+        }
+
+        function cleanup_t_int256(value) -> cleaned {
+            cleaned := value
+        }
+
+        function validator_revert_t_int256(value) {
+            if iszero(eq(value, cleanup_t_int256(value))) { revert(0, 0) }
+        }
+
+        function abi_decode_t_int256_fromMemory(offset, end) -> value {
+            value := mload(offset)
+            validator_revert_t_int256(value)
+        }
+
+        function abi_decode_tuple_t_int256_fromMemory(headStart, dataEnd) -> value0 {
+            if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            {
+
+                let offset := 0
+
+                value0 := abi_decode_t_int256_fromMemory(add(headStart, offset), dataEnd)
+            }
+
+        }
+
+        function copy_arguments_for_constructor_20_object_C_54() -> ret_param_0 {
+            let programSize := datasize(\"C_54\")
+            let argSize := sub(codesize(), programSize)
+
+            let memoryDataOffset := allocate_memory(argSize)
+            codecopy(memoryDataOffset, programSize, argSize)
+
+            ret_param_0 := abi_decode_tuple_t_int256_fromMemory(memoryDataOffset, add(memoryDataOffset, argSize))
+        }
+
+        function cleanup_t_rational_42_by_1(value) -> cleaned {
+            cleaned := value
+        }
+
+        function identity(value) -> ret {
+            ret := value
+        }
+
+        function convert_t_rational_42_by_1_to_t_int256(value) -> converted {
+            converted := cleanup_t_int256(identity(cleanup_t_rational_42_by_1(value)))
+        }
+
+        function shift_left_0(value) -> newValue {
+            newValue :=
+
+            shl(0, value)
+
+        }
+
+        function update_byte_slice_32_shift_0(value, toInsert) -> result {
+            let mask := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+            toInsert := shift_left_0(toInsert)
+            value := and(value, not(mask))
+            result := or(value, and(toInsert, mask))
+        }
+
+        function convert_t_int256_to_t_int256(value) -> converted {
+            converted := cleanup_t_int256(identity(cleanup_t_int256(value)))
+        }
+
+        function prepare_store_t_int256(value) -> ret {
+            ret := value
+        }
+
+        function update_storage_value_offset_0t_int256_to_t_int256(slot, value_0) {
+            let convertedValue_0 := convert_t_int256_to_t_int256(value_0)
+            sstore(slot, update_byte_slice_32_shift_0(sload(slot), prepare_store_t_int256(convertedValue_0)))
+        }
+
+        /// @ast-id 20
+        /// @src 0:182:230  \"constructor(int _init)...\"
+        function constructor_C_54(var__init_12) {
+
+            /// @src 0:182:230  \"constructor(int _init)...\"
+
+            /// @src 0:154:156  \"42\"
+            let expr_7 := 0x2a
+            let _3 := convert_t_rational_42_by_1_to_t_int256(expr_7)
+            mstore(128, _3)
+
+            /// @src 0:221:226  \"_init\"
+            let _4 := var__init_12
+            let expr_16 := _4
+            /// @src 0:210:226  \"stateVar = _init\"
+            update_storage_value_offset_0t_int256_to_t_int256(0x00, expr_16)
+            let expr_17 := expr_16
+
+        }
+        /// @src 0:79:435  \"contract C...\"
+
+    }
+    /// @use-src 0:\"C\"
+    object \"C_54_deployed\" {
+        code {
+            /// @src 0:79:435  \"contract C...\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_30()
+                }
+
+                case 0x793816ec
+                {
+                    // stateVar()
+
+                    external_fun_stateVar_10()
+                }
+
+                case 0x9942ec6f
+                {
+                    // f2()
+
+                    external_fun_f2_53()
+                }
+
+                case 0xa00b982b
+                {
+                    // constVar()
+
+                    external_fun_constVar_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function cleanup_t_int256(value) -> cleaned {
+                cleaned := value
+            }
+
+            function abi_encode_t_int256_to_t_int256_fromStack(value, pos) {
+                mstore(pos, cleanup_t_int256(value))
+            }
+
+            function abi_encode_tuple_t_int256__to_t_int256__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                abi_encode_t_int256_to_t_int256_fromStack(value0,  add(headStart, 0))
+
+            }
+
+            function external_fun_f_30() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_30()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function shift_right_unsigned_dynamic(bits, value) -> newValue {
+                newValue :=
+
+                shr(bits, value)
+
+            }
+
+            function cleanup_from_storage_t_int256(value) -> cleaned {
+                cleaned := value
+            }
+
+            function extract_from_storage_value_dynamict_int256(slot_value, offset) -> value {
+                value := cleanup_from_storage_t_int256(shift_right_unsigned_dynamic(mul(offset, 8), slot_value))
+            }
+
+            function read_from_storage_split_dynamic_t_int256(slot, offset) -> value {
+                value := extract_from_storage_value_dynamict_int256(sload(slot), offset)
+
+            }
+
+            /// @ast-id 10
+            /// @src 0:159:178  \"int public stateVar\"
+            function getter_fun_stateVar_10() -> ret {
+
+                let slot := 0
+                let offset := 0
+
+                ret := read_from_storage_split_dynamic_t_int256(slot, offset)
+
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+            function external_fun_stateVar_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  getter_fun_stateVar_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function external_fun_f2_53() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f2_53()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function cleanup_t_rational_41_by_1(value) -> cleaned {
+                cleaned := value
+            }
+
+            function identity(value) -> ret {
+                ret := value
+            }
+
+            function convert_t_rational_41_by_1_to_t_int256(value) -> converted {
+                converted := cleanup_t_int256(identity(cleanup_t_rational_41_by_1(value)))
+            }
+
+            /// @src 0:93:126  \"int public constant constVar = 41\"
+            function constant_constVar_5() -> ret {
+                /// @src 0:124:126  \"41\"
+                let expr_4 := 0x29
+                let _1 := convert_t_rational_41_by_1_to_t_int256(expr_4)
+
+                ret := _1
+            }
+
+            /// @ast-id 5
+            /// @src 0:93:126  \"int public constant constVar = 41\"
+            function getter_fun_constVar_5() -> ret_0 {
+                ret_0 := constant_constVar_5()
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+            function external_fun_constVar_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  getter_fun_constVar_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_int256() -> ret {
+                ret := 0
+            }
+
+            function panic_error_0x11() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x11)
+                revert(0, 0x24)
+            }
+
+            function checked_add_t_int256(x, y) -> sum {
+                x := cleanup_t_int256(x)
+                y := cleanup_t_int256(y)
+                sum := add(x, y)
+
+                // overflow, if x >= 0 and sum < y
+                // underflow, if x < 0 and sum >= y
+                if or(
+                    and(iszero(slt(x, 0)), slt(sum, y)),
+                    and(slt(x, 0), iszero(slt(sum, y)))
+                ) { panic_error_0x11() }
+
+            }
+
+            /// @ast-id 30
+            /// @src 0:233:309  \"function f() external pure returns (int)...\"
+            function fun_f_30() -> var__23 {
+                /// @src 0:269:272  \"int\"
+                let zero_t_int256_2 := zero_value_for_split_t_int256()
+                var__23 := zero_t_int256_2
+
+                /// @src 0:286:294  \"constVar\"
+                let expr_25 := constant_constVar_5()
+                /// @src 0:297:305  \"immutVar\"
+                let _3 := loadimmutable(\"8\")
+                let expr_26 := _3
+                /// @src 0:286:305  \"constVar + immutVar\"
+                let expr_27 := checked_add_t_int256(expr_25, expr_26)
+
+                /// @src 0:279:305  \"return constVar + immutVar\"
+                var__23 := expr_27
+                leave
+
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+            function shift_right_0_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(0, value)
+
+            }
+
+            function extract_from_storage_value_offset_0t_int256(slot_value) -> value {
+                value := cleanup_from_storage_t_int256(shift_right_0_unsigned(slot_value))
+            }
+
+            function read_from_storage_split_offset_0_t_int256(slot) -> value {
+                value := extract_from_storage_value_offset_0t_int256(sload(slot))
+
+            }
+
+            function increment_t_int256(value) -> ret {
+                value := cleanup_t_int256(value)
+                if eq(value, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { panic_error_0x11() }
+                ret := add(value, 1)
+            }
+
+            function shift_left_0(value) -> newValue {
+                newValue :=
+
+                shl(0, value)
+
+            }
+
+            function update_byte_slice_32_shift_0(value, toInsert) -> result {
+                let mask := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+                toInsert := shift_left_0(toInsert)
+                value := and(value, not(mask))
+                result := or(value, and(toInsert, mask))
+            }
+
+            function convert_t_int256_to_t_int256(value) -> converted {
+                converted := cleanup_t_int256(identity(cleanup_t_int256(value)))
+            }
+
+            function prepare_store_t_int256(value) -> ret {
+                ret := value
+            }
+
+            function update_storage_value_offset_0t_int256_to_t_int256(slot, value_0) {
+                let convertedValue_0 := convert_t_int256_to_t_int256(value_0)
+                sstore(slot, update_byte_slice_32_shift_0(sload(slot), prepare_store_t_int256(convertedValue_0)))
+            }
+
+            /// @ast-id 37
+            /// @src 0:311:348  \"modifier m()...\"
+            function modifier_m_40(var__42) -> _5 {
+                _5 := var__42
+
+                /// @src 0:329:339  \"stateVar++\"
+                let _7 := read_from_storage_split_offset_0_t_int256(0x00)
+                let _6 := increment_t_int256(_7)
+                update_storage_value_offset_0t_int256_to_t_int256(0x00, _6)
+                let expr_33 := _7
+                /// @src 0:343:344  \"_\"
+                _5 := fun_f2_53_inner(var__42)
+
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+            function cleanup_t_uint160(value) -> cleaned {
+                cleaned := and(value, 0xffffffffffffffffffffffffffffffffffffffff)
+            }
+
+            function convert_t_uint160_to_t_uint160(value) -> converted {
+                converted := cleanup_t_uint160(identity(cleanup_t_uint160(value)))
+            }
+
+            function convert_t_uint160_to_t_address(value) -> converted {
+                converted := convert_t_uint160_to_t_uint160(value)
+            }
+
+            function convert_t_contract$_C_$54_to_t_address(value) -> converted {
+                converted := convert_t_uint160_to_t_address(value)
+            }
+
+            function revert_error_0cc013b6b3b6beabea4e3a74a6d380f0df81852ca99887912475e1f66b2a2c20() {
+                revert(0, 0)
+            }
+
+            function round_up_to_mul_of_32(value) -> result {
+                result := and(add(value, 31), not(31))
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function finalize_allocation(memPtr, size) {
+                let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+                // protect against overflow
+                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+                mstore(64, newFreePtr)
+            }
+
+            function shift_left_224(value) -> newValue {
+                newValue :=
+
+                shl(224, value)
+
+            }
+
+            function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {
+                revert(0, 0)
+            }
+
+            function validator_revert_t_int256(value) {
+                if iszero(eq(value, cleanup_t_int256(value))) { revert(0, 0) }
+            }
+
+            function abi_decode_t_int256_fromMemory(offset, end) -> value {
+                value := mload(offset)
+                validator_revert_t_int256(value)
+            }
+
+            function abi_decode_tuple_t_int256_fromMemory(headStart, dataEnd) -> value0 {
+                if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+                {
+
+                    let offset := 0
+
+                    value0 := abi_decode_t_int256_fromMemory(add(headStart, offset), dataEnd)
+                }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function revert_forward_1() {
+                let pos := allocate_unbounded()
+                returndatacopy(pos, 0, returndatasize())
+                revert(pos, returndatasize())
+            }
+
+            /// @src 0:350:433  \"function f2() m public returns (int)...\"
+            function fun_f2_53_inner(_8) -> var__42 {
+                var__42 := _8
+
+                /// @src 0:399:407  \"stateVar\"
+                let _9 := read_from_storage_split_offset_0_t_int256(0x00)
+                let expr_44 := _9
+                /// @src 0:410:414  \"this\"
+                let expr_45_address := address()
+                /// @src 0:410:416  \"this.f\"
+                let expr_46_address := convert_t_contract$_C_$54_to_t_address(expr_45_address)
+                let expr_46_functionSelector := 0x26121ff0
+                /// @src 0:410:418  \"this.f()\"
+
+                // storage for arguments and returned data
+                let _10 := allocate_unbounded()
+                mstore(_10, shift_left_224(expr_46_functionSelector))
+                let _11 := abi_encode_tuple__to__fromStack(add(_10, 4) )
+
+                let _12 := staticcall(gas(), expr_46_address,  _10, sub(_11, _10), _10, 32)
+
+                if iszero(_12) { revert_forward_1() }
+
+                let expr_47
+                if _12 {
+
+                    let _13 := 32
+
+                    if gt(_13, returndatasize()) {
+                        _13 := returndatasize()
+                    }
+
+                    // update freeMemoryPointer according to dynamic return size
+                    finalize_allocation(_10, _13)
+
+                    // decode return parameters from external try-call into retVars
+                    expr_47 :=  abi_decode_tuple_t_int256_fromMemory(_10, add(_10, _13))
+                }
+                /// @src 0:399:418  \"stateVar + this.f()\"
+                let expr_48 := checked_add_t_int256(expr_44, expr_47)
+
+                /// @src 0:421:429  \"immutVar\"
+                let _14 := loadimmutable(\"8\")
+                let expr_49 := _14
+                /// @src 0:399:429  \"stateVar + this.f() + immutVar\"
+                let expr_50 := checked_add_t_int256(expr_48, expr_49)
+
+                /// @src 0:392:429  \"return stateVar + this.f() + immutVar\"
+                var__42 := expr_50
+                leave
+
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+            /// @ast-id 53
+            /// @src 0:350:433  \"function f2() m public returns (int)...\"
+            function fun_f2_53() -> var__42 {
+                /// @src 0:382:385  \"int\"
+                let zero_t_int256_4 := zero_value_for_split_t_int256()
+                var__42 := zero_t_int256_4
+
+                var__42 := modifier_m_40(var__42)
+            }
+            /// @src 0:79:435  \"contract C...\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+",
+                "irOptimized": "/// @use-src 0:\"C\"
+object \"C_54\" {
+    code {
+        {
+            /// @src 0:79:435  \"contract C...\"
+            let _1 := memoryguard(0xa0)
+            if callvalue() { revert(0, 0) }
+            let programSize := datasize(\"C_54\")
+            let argSize := sub(codesize(), programSize)
+            let newFreePtr := add(_1, and(add(argSize, 31), not(31)))
+            if or(gt(newFreePtr, sub(shl(64, 1), 1)), lt(newFreePtr, _1))
+            {
+                mstore(/** @src -1:-1:-1 */ 0, /** @src 0:79:435  \"contract C...\" */ shl(224, 0x4e487b71))
+                mstore(4, 0x41)
+                revert(/** @src -1:-1:-1 */ 0, /** @src 0:79:435  \"contract C...\" */ 0x24)
+            }
+            mstore(64, newFreePtr)
+            codecopy(_1, programSize, argSize)
+            if slt(sub(add(_1, argSize), _1), 32)
+            {
+                revert(/** @src -1:-1:-1 */ 0, 0)
+            }
+            /// @src 0:79:435  \"contract C...\"
+            let value := mload(_1)
+            /// @src 0:154:156  \"42\"
+            mstore(128, 0x2a)
+            /// @src 0:79:435  \"contract C...\"
+            sstore(/** @src -1:-1:-1 */ 0, /** @src 0:79:435  \"contract C...\" */ value)
+            let _2 := mload(64)
+            let _3 := datasize(\"C_54_deployed\")
+            codecopy(_2, dataoffset(\"C_54_deployed\"), _3)
+            setimmutable(_2, \"8\", mload(/** @src 0:154:156  \"42\" */ 128))
+            /// @src 0:79:435  \"contract C...\"
+            return(_2, _3)
+        }
+    }
+    /// @use-src 0:\"C\"
+    object \"C_54_deployed\" {
+        code {
+            {
+                /// @src 0:79:435  \"contract C...\"
+                let _1 := memoryguard(0x80)
+                let _2 := 64
+                mstore(_2, _1)
+                if iszero(lt(calldatasize(), 4))
+                {
+                    switch shr(224, calldataload(0))
+                    case 0x26121ff0 {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        /// @src 0:297:305  \"immutVar\"
+                        let _3 := loadimmutable(\"8\")
+                        /// @src 0:79:435  \"contract C...\"
+                        let sum := add(/** @src 0:124:126  \"41\" */ 0x29, /** @src 0:79:435  \"contract C...\" */ _3)
+                        if and(1, slt(sum, _3))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x11)
+                            revert(0, 0x24)
+                        }
+                        mstore(_1, sum)
+                        return(_1, 32)
+                    }
+                    case 0x793816ec {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let _4 := sload(0)
+                        let memPos := mload(_2)
+                        mstore(memPos, _4)
+                        return(memPos, 32)
+                    }
+                    case 0x9942ec6f {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let _5 := sload(0)
+                        if eq(_5, sub(shl(255, 1), 1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x11)
+                            revert(0, 0x24)
+                        }
+                        let ret := add(_5, 1)
+                        sstore(0, ret)
+                        /// @src 0:410:418  \"this.f()\"
+                        let _6 := /** @src 0:79:435  \"contract C...\" */ mload(_2)
+                        /// @src 0:410:418  \"this.f()\"
+                        mstore(_6, /** @src 0:79:435  \"contract C...\" */ shl(228, 0x026121ff))
+                        /// @src 0:410:418  \"this.f()\"
+                        let _7 := staticcall(gas(), /** @src 0:410:414  \"this\" */ address(), /** @src 0:410:418  \"this.f()\" */ _6, /** @src 0:79:435  \"contract C...\" */ 4, /** @src 0:410:418  \"this.f()\" */ _6, 32)
+                        if iszero(_7)
+                        {
+                            /// @src 0:79:435  \"contract C...\"
+                            let pos := mload(_2)
+                            returndatacopy(pos, 0, returndatasize())
+                            revert(pos, returndatasize())
+                        }
+                        /// @src 0:410:418  \"this.f()\"
+                        let expr := /** @src 0:79:435  \"contract C...\" */ 0
+                        /// @src 0:410:418  \"this.f()\"
+                        if _7
+                        {
+                            let _8 := 32
+                            if gt(32, returndatasize()) { _8 := returndatasize() }
+                            /// @src 0:79:435  \"contract C...\"
+                            let newFreePtr := add(_6, and(add(_8, 31), not(31)))
+                            if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, _6))
+                            {
+                                mstore(0, shl(224, 0x4e487b71))
+                                mstore(4, 0x41)
+                                revert(0, 0x24)
+                            }
+                            mstore(_2, newFreePtr)
+                            if slt(sub(/** @src 0:410:418  \"this.f()\" */ add(_6, _8), /** @src 0:79:435  \"contract C...\" */ _6), /** @src 0:410:418  \"this.f()\" */ 32)
+                            /// @src 0:79:435  \"contract C...\"
+                            { revert(0, 0) }
+                            /// @src 0:410:418  \"this.f()\"
+                            expr := /** @src 0:79:435  \"contract C...\" */ mload(_6)
+                        }
+                        /// @src 0:399:418  \"stateVar + this.f()\"
+                        let expr_1 := checked_add_int256(ret, expr)
+                        /// @src 0:392:429  \"return stateVar + this.f() + immutVar\"
+                        let var := /** @src 0:399:429  \"stateVar + this.f() + immutVar\" */ checked_add_int256(expr_1, /** @src 0:421:429  \"immutVar\" */ loadimmutable(\"8\"))
+                        /// @src 0:79:435  \"contract C...\"
+                        let memPos_1 := mload(_2)
+                        mstore(memPos_1, var)
+                        return(memPos_1, /** @src 0:410:418  \"this.f()\" */ 32)
+                    }
+                    case /** @src 0:79:435  \"contract C...\" */ 0xa00b982b {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let memPos_2 := mload(_2)
+                        mstore(memPos_2, /** @src 0:124:126  \"41\" */ 0x29)
+                        /// @src 0:79:435  \"contract C...\"
+                        return(memPos_2, 32)
+                    }
+                }
+                revert(0, 0)
+            }
+            function checked_add_int256(x, y) -> sum
+            {
+                sum := add(x, y)
+                let _1 := slt(sum, y)
+                let _2 := slt(x, 0)
+                if or(and(iszero(_2), _1), and(_2, iszero(_1)))
+                {
+                    mstore(0, shl(224, 0x4e487b71))
+                    mstore(4, 0x11)
+                    revert(0, 0x24)
+                }
+            }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        },
+        "D":
+        {
+            "D":
+            {
+                "ir": "
+/// @use-src 0:\"C\", 1:\"D\"
+object \"D_72\" {
+    code {
+        /// @src 1:91:166  \"contract D is C(3)...\"
+        mstore(64, memoryguard(160))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        let _1 := copy_arguments_for_constructor_71_object_D_72()
+        constructor_D_72(_1)
+
+        let _2 := allocate_unbounded()
+        codecopy(_2, dataoffset(\"D_72_deployed\"), datasize(\"D_72_deployed\"))
+
+        setimmutable(_2, \"8\", mload(128))
+
+        return(_2, datasize(\"D_72_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        function round_up_to_mul_of_32(value) -> result {
+            result := and(add(value, 31), not(31))
+        }
+
+        function panic_error_0x41() {
+            mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+            mstore(4, 0x41)
+            revert(0, 0x24)
+        }
+
+        function finalize_allocation(memPtr, size) {
+            let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+            // protect against overflow
+            if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+            mstore(64, newFreePtr)
+        }
+
+        function allocate_memory(size) -> memPtr {
+            memPtr := allocate_unbounded()
+            finalize_allocation(memPtr, size)
+        }
+
+        function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+            revert(0, 0)
+        }
+
+        function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {
+            revert(0, 0)
+        }
+
+        function cleanup_t_int256(value) -> cleaned {
+            cleaned := value
+        }
+
+        function validator_revert_t_int256(value) {
+            if iszero(eq(value, cleanup_t_int256(value))) { revert(0, 0) }
+        }
+
+        function abi_decode_t_int256_fromMemory(offset, end) -> value {
+            value := mload(offset)
+            validator_revert_t_int256(value)
+        }
+
+        function abi_decode_tuple_t_int256_fromMemory(headStart, dataEnd) -> value0 {
+            if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            {
+
+                let offset := 0
+
+                value0 := abi_decode_t_int256_fromMemory(add(headStart, offset), dataEnd)
+            }
+
+        }
+
+        function copy_arguments_for_constructor_71_object_D_72() -> ret_param_0 {
+            let programSize := datasize(\"D_72\")
+            let argSize := sub(codesize(), programSize)
+
+            let memoryDataOffset := allocate_memory(argSize)
+            codecopy(memoryDataOffset, programSize, argSize)
+
+            ret_param_0 := abi_decode_tuple_t_int256_fromMemory(memoryDataOffset, add(memoryDataOffset, argSize))
+        }
+
+        function cleanup_t_rational_3_by_1(value) -> cleaned {
+            cleaned := value
+        }
+
+        function identity(value) -> ret {
+            ret := value
+        }
+
+        function convert_t_rational_3_by_1_to_t_int256(value) -> converted {
+            converted := cleanup_t_int256(identity(cleanup_t_rational_3_by_1(value)))
+        }
+
+        function shift_right_0_unsigned(value) -> newValue {
+            newValue :=
+
+            shr(0, value)
+
+        }
+
+        function cleanup_from_storage_t_int256(value) -> cleaned {
+            cleaned := value
+        }
+
+        function extract_from_storage_value_offset_0t_int256(slot_value) -> value {
+            value := cleanup_from_storage_t_int256(shift_right_0_unsigned(slot_value))
+        }
+
+        function read_from_storage_split_offset_0_t_int256(slot) -> value {
+            value := extract_from_storage_value_offset_0t_int256(sload(slot))
+
+        }
+
+        function panic_error_0x11() {
+            mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+            mstore(4, 0x11)
+            revert(0, 0x24)
+        }
+
+        function checked_add_t_int256(x, y) -> sum {
+            x := cleanup_t_int256(x)
+            y := cleanup_t_int256(y)
+            sum := add(x, y)
+
+            // overflow, if x >= 0 and sum < y
+            // underflow, if x < 0 and sum >= y
+            if or(
+                and(iszero(slt(x, 0)), slt(sum, y)),
+                and(slt(x, 0), iszero(slt(sum, y)))
+            ) { panic_error_0x11() }
+
+        }
+
+        function shift_left_0(value) -> newValue {
+            newValue :=
+
+            shl(0, value)
+
+        }
+
+        function update_byte_slice_32_shift_0(value, toInsert) -> result {
+            let mask := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+            toInsert := shift_left_0(toInsert)
+            value := and(value, not(mask))
+            result := or(value, and(toInsert, mask))
+        }
+
+        function convert_t_int256_to_t_int256(value) -> converted {
+            converted := cleanup_t_int256(identity(cleanup_t_int256(value)))
+        }
+
+        function prepare_store_t_int256(value) -> ret {
+            ret := value
+        }
+
+        function update_storage_value_offset_0t_int256_to_t_int256(slot, value_0) {
+            let convertedValue_0 := convert_t_int256_to_t_int256(value_0)
+            sstore(slot, update_byte_slice_32_shift_0(sload(slot), prepare_store_t_int256(convertedValue_0)))
+        }
+
+        /// @ast-id 71
+        /// @src 1:113:164  \"constructor(int _init2)...\"
+        function constructor_D_72(var__init2_63) {
+            /// @src 1:107:108  \"3\"
+            let expr_60 := 0x03
+            let _3 := convert_t_rational_3_by_1_to_t_int256(expr_60)
+
+            /// @src 1:113:164  \"constructor(int _init2)...\"
+            constructor_C_54(_3)
+
+            /// @src 1:154:160  \"_init2\"
+            let _4 := var__init2_63
+            let expr_67 := _4
+            /// @src 1:142:160  \"stateVar += _init2\"
+            let _5 := read_from_storage_split_offset_0_t_int256(0x00)
+            let expr_68 := checked_add_t_int256(_5, expr_67)
+
+            update_storage_value_offset_0t_int256_to_t_int256(0x00, expr_68)
+
+        }
+        /// @src 1:91:166  \"contract D is C(3)...\"
+
+        function cleanup_t_rational_42_by_1(value) -> cleaned {
+            cleaned := value
+        }
+
+        function convert_t_rational_42_by_1_to_t_int256(value) -> converted {
+            converted := cleanup_t_int256(identity(cleanup_t_rational_42_by_1(value)))
+        }
+
+        /// @ast-id 20
+        /// @src 0:182:230  \"constructor(int _init)...\"
+        function constructor_C_54(var__init_12) {
+
+            /// @src 0:182:230  \"constructor(int _init)...\"
+
+            /// @src 0:154:156  \"42\"
+            let expr_7 := 0x2a
+            let _6 := convert_t_rational_42_by_1_to_t_int256(expr_7)
+            mstore(128, _6)
+
+            /// @src 0:221:226  \"_init\"
+            let _7 := var__init_12
+            let expr_16 := _7
+            /// @src 0:210:226  \"stateVar = _init\"
+            update_storage_value_offset_0t_int256_to_t_int256(0x00, expr_16)
+            let expr_17 := expr_16
+
+        }
+        /// @src 1:91:166  \"contract D is C(3)...\"
+
+    }
+    /// @use-src 0:\"C\", 1:\"D\"
+    object \"D_72_deployed\" {
+        code {
+            /// @src 1:91:166  \"contract D is C(3)...\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_30()
+                }
+
+                case 0x793816ec
+                {
+                    // stateVar()
+
+                    external_fun_stateVar_10()
+                }
+
+                case 0x9942ec6f
+                {
+                    // f2()
+
+                    external_fun_f2_53()
+                }
+
+                case 0xa00b982b
+                {
+                    // constVar()
+
+                    external_fun_constVar_5()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function cleanup_t_int256(value) -> cleaned {
+                cleaned := value
+            }
+
+            function abi_encode_t_int256_to_t_int256_fromStack(value, pos) {
+                mstore(pos, cleanup_t_int256(value))
+            }
+
+            function abi_encode_tuple_t_int256__to_t_int256__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                abi_encode_t_int256_to_t_int256_fromStack(value0,  add(headStart, 0))
+
+            }
+
+            function external_fun_f_30() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_30()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function shift_right_unsigned_dynamic(bits, value) -> newValue {
+                newValue :=
+
+                shr(bits, value)
+
+            }
+
+            function cleanup_from_storage_t_int256(value) -> cleaned {
+                cleaned := value
+            }
+
+            function extract_from_storage_value_dynamict_int256(slot_value, offset) -> value {
+                value := cleanup_from_storage_t_int256(shift_right_unsigned_dynamic(mul(offset, 8), slot_value))
+            }
+
+            function read_from_storage_split_dynamic_t_int256(slot, offset) -> value {
+                value := extract_from_storage_value_dynamict_int256(sload(slot), offset)
+
+            }
+
+            /// @ast-id 10
+            /// @src 0:159:178  \"int public stateVar\"
+            function getter_fun_stateVar_10() -> ret {
+
+                let slot := 0
+                let offset := 0
+
+                ret := read_from_storage_split_dynamic_t_int256(slot, offset)
+
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+            function external_fun_stateVar_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  getter_fun_stateVar_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function external_fun_f2_53() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f2_53()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function cleanup_t_rational_41_by_1(value) -> cleaned {
+                cleaned := value
+            }
+
+            function identity(value) -> ret {
+                ret := value
+            }
+
+            function convert_t_rational_41_by_1_to_t_int256(value) -> converted {
+                converted := cleanup_t_int256(identity(cleanup_t_rational_41_by_1(value)))
+            }
+
+            /// @src 0:93:126  \"int public constant constVar = 41\"
+            function constant_constVar_5() -> ret {
+                /// @src 0:124:126  \"41\"
+                let expr_4 := 0x29
+                let _1 := convert_t_rational_41_by_1_to_t_int256(expr_4)
+
+                ret := _1
+            }
+
+            /// @ast-id 5
+            /// @src 0:93:126  \"int public constant constVar = 41\"
+            function getter_fun_constVar_5() -> ret_0 {
+                ret_0 := constant_constVar_5()
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+            function external_fun_constVar_5() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  getter_fun_constVar_5()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_int256__to_t_int256__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_int256() -> ret {
+                ret := 0
+            }
+
+            function panic_error_0x11() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x11)
+                revert(0, 0x24)
+            }
+
+            function checked_add_t_int256(x, y) -> sum {
+                x := cleanup_t_int256(x)
+                y := cleanup_t_int256(y)
+                sum := add(x, y)
+
+                // overflow, if x >= 0 and sum < y
+                // underflow, if x < 0 and sum >= y
+                if or(
+                    and(iszero(slt(x, 0)), slt(sum, y)),
+                    and(slt(x, 0), iszero(slt(sum, y)))
+                ) { panic_error_0x11() }
+
+            }
+
+            /// @ast-id 30
+            /// @src 0:233:309  \"function f() external pure returns (int)...\"
+            function fun_f_30() -> var__23 {
+                /// @src 0:269:272  \"int\"
+                let zero_t_int256_2 := zero_value_for_split_t_int256()
+                var__23 := zero_t_int256_2
+
+                /// @src 0:286:294  \"constVar\"
+                let expr_25 := constant_constVar_5()
+                /// @src 0:297:305  \"immutVar\"
+                let _3 := loadimmutable(\"8\")
+                let expr_26 := _3
+                /// @src 0:286:305  \"constVar + immutVar\"
+                let expr_27 := checked_add_t_int256(expr_25, expr_26)
+
+                /// @src 0:279:305  \"return constVar + immutVar\"
+                var__23 := expr_27
+                leave
+
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+            function shift_right_0_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(0, value)
+
+            }
+
+            function extract_from_storage_value_offset_0t_int256(slot_value) -> value {
+                value := cleanup_from_storage_t_int256(shift_right_0_unsigned(slot_value))
+            }
+
+            function read_from_storage_split_offset_0_t_int256(slot) -> value {
+                value := extract_from_storage_value_offset_0t_int256(sload(slot))
+
+            }
+
+            function increment_t_int256(value) -> ret {
+                value := cleanup_t_int256(value)
+                if eq(value, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { panic_error_0x11() }
+                ret := add(value, 1)
+            }
+
+            function shift_left_0(value) -> newValue {
+                newValue :=
+
+                shl(0, value)
+
+            }
+
+            function update_byte_slice_32_shift_0(value, toInsert) -> result {
+                let mask := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+                toInsert := shift_left_0(toInsert)
+                value := and(value, not(mask))
+                result := or(value, and(toInsert, mask))
+            }
+
+            function convert_t_int256_to_t_int256(value) -> converted {
+                converted := cleanup_t_int256(identity(cleanup_t_int256(value)))
+            }
+
+            function prepare_store_t_int256(value) -> ret {
+                ret := value
+            }
+
+            function update_storage_value_offset_0t_int256_to_t_int256(slot, value_0) {
+                let convertedValue_0 := convert_t_int256_to_t_int256(value_0)
+                sstore(slot, update_byte_slice_32_shift_0(sload(slot), prepare_store_t_int256(convertedValue_0)))
+            }
+
+            /// @ast-id 37
+            /// @src 0:311:348  \"modifier m()...\"
+            function modifier_m_40(var__42) -> _5 {
+                _5 := var__42
+
+                /// @src 0:329:339  \"stateVar++\"
+                let _7 := read_from_storage_split_offset_0_t_int256(0x00)
+                let _6 := increment_t_int256(_7)
+                update_storage_value_offset_0t_int256_to_t_int256(0x00, _6)
+                let expr_33 := _7
+                /// @src 0:343:344  \"_\"
+                _5 := fun_f2_53_inner(var__42)
+
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+            function cleanup_t_uint160(value) -> cleaned {
+                cleaned := and(value, 0xffffffffffffffffffffffffffffffffffffffff)
+            }
+
+            function convert_t_uint160_to_t_uint160(value) -> converted {
+                converted := cleanup_t_uint160(identity(cleanup_t_uint160(value)))
+            }
+
+            function convert_t_uint160_to_t_address(value) -> converted {
+                converted := convert_t_uint160_to_t_uint160(value)
+            }
+
+            function convert_t_contract$_C_$54_to_t_address(value) -> converted {
+                converted := convert_t_uint160_to_t_address(value)
+            }
+
+            function revert_error_0cc013b6b3b6beabea4e3a74a6d380f0df81852ca99887912475e1f66b2a2c20() {
+                revert(0, 0)
+            }
+
+            function round_up_to_mul_of_32(value) -> result {
+                result := and(add(value, 31), not(31))
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function finalize_allocation(memPtr, size) {
+                let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+                // protect against overflow
+                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+                mstore(64, newFreePtr)
+            }
+
+            function shift_left_224(value) -> newValue {
+                newValue :=
+
+                shl(224, value)
+
+            }
+
+            function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {
+                revert(0, 0)
+            }
+
+            function validator_revert_t_int256(value) {
+                if iszero(eq(value, cleanup_t_int256(value))) { revert(0, 0) }
+            }
+
+            function abi_decode_t_int256_fromMemory(offset, end) -> value {
+                value := mload(offset)
+                validator_revert_t_int256(value)
+            }
+
+            function abi_decode_tuple_t_int256_fromMemory(headStart, dataEnd) -> value0 {
+                if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+                {
+
+                    let offset := 0
+
+                    value0 := abi_decode_t_int256_fromMemory(add(headStart, offset), dataEnd)
+                }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function revert_forward_1() {
+                let pos := allocate_unbounded()
+                returndatacopy(pos, 0, returndatasize())
+                revert(pos, returndatasize())
+            }
+
+            /// @src 0:350:433  \"function f2() m public returns (int)...\"
+            function fun_f2_53_inner(_8) -> var__42 {
+                var__42 := _8
+
+                /// @src 0:399:407  \"stateVar\"
+                let _9 := read_from_storage_split_offset_0_t_int256(0x00)
+                let expr_44 := _9
+                /// @src 0:410:414  \"this\"
+                let expr_45_address := address()
+                /// @src 0:410:416  \"this.f\"
+                let expr_46_address := convert_t_contract$_C_$54_to_t_address(expr_45_address)
+                let expr_46_functionSelector := 0x26121ff0
+                /// @src 0:410:418  \"this.f()\"
+
+                // storage for arguments and returned data
+                let _10 := allocate_unbounded()
+                mstore(_10, shift_left_224(expr_46_functionSelector))
+                let _11 := abi_encode_tuple__to__fromStack(add(_10, 4) )
+
+                let _12 := staticcall(gas(), expr_46_address,  _10, sub(_11, _10), _10, 32)
+
+                if iszero(_12) { revert_forward_1() }
+
+                let expr_47
+                if _12 {
+
+                    let _13 := 32
+
+                    if gt(_13, returndatasize()) {
+                        _13 := returndatasize()
+                    }
+
+                    // update freeMemoryPointer according to dynamic return size
+                    finalize_allocation(_10, _13)
+
+                    // decode return parameters from external try-call into retVars
+                    expr_47 :=  abi_decode_tuple_t_int256_fromMemory(_10, add(_10, _13))
+                }
+                /// @src 0:399:418  \"stateVar + this.f()\"
+                let expr_48 := checked_add_t_int256(expr_44, expr_47)
+
+                /// @src 0:421:429  \"immutVar\"
+                let _14 := loadimmutable(\"8\")
+                let expr_49 := _14
+                /// @src 0:399:429  \"stateVar + this.f() + immutVar\"
+                let expr_50 := checked_add_t_int256(expr_48, expr_49)
+
+                /// @src 0:392:429  \"return stateVar + this.f() + immutVar\"
+                var__42 := expr_50
+                leave
+
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+            /// @ast-id 53
+            /// @src 0:350:433  \"function f2() m public returns (int)...\"
+            function fun_f2_53() -> var__42 {
+                /// @src 0:382:385  \"int\"
+                let zero_t_int256_4 := zero_value_for_split_t_int256()
+                var__42 := zero_t_int256_4
+
+                var__42 := modifier_m_40(var__42)
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+",
+                "irOptimized": "/// @use-src 0:\"C\", 1:\"D\"
+object \"D_72\" {
+    code {
+        {
+            /// @src 1:91:166  \"contract D is C(3)...\"
+            let _1 := memoryguard(0xa0)
+            if callvalue() { revert(0, 0) }
+            let programSize := datasize(\"D_72\")
+            let argSize := sub(codesize(), programSize)
+            let newFreePtr := add(_1, and(add(argSize, 31), not(31)))
+            if or(gt(newFreePtr, sub(shl(64, 1), 1)), lt(newFreePtr, _1))
+            {
+                mstore(/** @src -1:-1:-1 */ 0, /** @src 1:91:166  \"contract D is C(3)...\" */ shl(224, 0x4e487b71))
+                mstore(4, 0x41)
+                revert(/** @src -1:-1:-1 */ 0, /** @src 1:91:166  \"contract D is C(3)...\" */ 0x24)
+            }
+            mstore(64, newFreePtr)
+            codecopy(_1, programSize, argSize)
+            if slt(sub(add(_1, argSize), _1), 32)
+            {
+                revert(/** @src -1:-1:-1 */ 0, 0)
+            }
+            /// @src 1:91:166  \"contract D is C(3)...\"
+            let value := mload(_1)
+            /// @src 0:154:156  \"42\"
+            mstore(128, 0x2a)
+            /// @src 1:91:166  \"contract D is C(3)...\"
+            let sum := add(/** @src 1:107:108  \"3\" */ 0x03, /** @src 1:91:166  \"contract D is C(3)...\" */ value)
+            if and(1, slt(sum, value))
+            {
+                mstore(/** @src -1:-1:-1 */ 0, /** @src 1:91:166  \"contract D is C(3)...\" */ shl(224, 0x4e487b71))
+                mstore(4, 0x11)
+                revert(/** @src -1:-1:-1 */ 0, /** @src 1:91:166  \"contract D is C(3)...\" */ 0x24)
+            }
+            sstore(/** @src -1:-1:-1 */ 0, /** @src 1:91:166  \"contract D is C(3)...\" */ sum)
+            let _2 := mload(64)
+            let _3 := datasize(\"D_72_deployed\")
+            codecopy(_2, dataoffset(\"D_72_deployed\"), _3)
+            setimmutable(_2, \"8\", mload(/** @src 0:154:156  \"42\" */ 128))
+            /// @src 1:91:166  \"contract D is C(3)...\"
+            return(_2, _3)
+        }
+    }
+    /// @use-src 0:\"C\", 1:\"D\"
+    object \"D_72_deployed\" {
+        code {
+            {
+                /// @src 1:91:166  \"contract D is C(3)...\"
+                let _1 := memoryguard(0x80)
+                let _2 := 64
+                mstore(_2, _1)
+                if iszero(lt(calldatasize(), 4))
+                {
+                    switch shr(224, calldataload(0))
+                    case 0x26121ff0 {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        /// @src 0:297:305  \"immutVar\"
+                        let _3 := loadimmutable(\"8\")
+                        /// @src 1:91:166  \"contract D is C(3)...\"
+                        let sum := add(/** @src 0:124:126  \"41\" */ 0x29, /** @src 1:91:166  \"contract D is C(3)...\" */ _3)
+                        if and(1, slt(sum, _3))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x11)
+                            revert(0, 0x24)
+                        }
+                        mstore(_1, sum)
+                        return(_1, 32)
+                    }
+                    case 0x793816ec {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let _4 := sload(0)
+                        let memPos := mload(_2)
+                        mstore(memPos, _4)
+                        return(memPos, 32)
+                    }
+                    case 0x9942ec6f {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let _5 := sload(0)
+                        if eq(_5, sub(shl(255, 1), 1))
+                        {
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x11)
+                            revert(0, 0x24)
+                        }
+                        let ret := add(_5, 1)
+                        sstore(0, ret)
+                        /// @src 0:410:418  \"this.f()\"
+                        let _6 := /** @src 1:91:166  \"contract D is C(3)...\" */ mload(_2)
+                        /// @src 0:410:418  \"this.f()\"
+                        mstore(_6, /** @src 1:91:166  \"contract D is C(3)...\" */ shl(228, 0x026121ff))
+                        /// @src 0:410:418  \"this.f()\"
+                        let _7 := staticcall(gas(), /** @src 0:410:414  \"this\" */ address(), /** @src 0:410:418  \"this.f()\" */ _6, /** @src 1:91:166  \"contract D is C(3)...\" */ 4, /** @src 0:410:418  \"this.f()\" */ _6, 32)
+                        if iszero(_7)
+                        {
+                            /// @src 1:91:166  \"contract D is C(3)...\"
+                            let pos := mload(_2)
+                            returndatacopy(pos, 0, returndatasize())
+                            revert(pos, returndatasize())
+                        }
+                        /// @src 0:410:418  \"this.f()\"
+                        let expr := /** @src 1:91:166  \"contract D is C(3)...\" */ 0
+                        /// @src 0:410:418  \"this.f()\"
+                        if _7
+                        {
+                            let _8 := 32
+                            if gt(32, returndatasize()) { _8 := returndatasize() }
+                            /// @src 1:91:166  \"contract D is C(3)...\"
+                            let newFreePtr := add(_6, and(add(_8, 31), not(31)))
+                            if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, _6))
+                            {
+                                mstore(0, shl(224, 0x4e487b71))
+                                mstore(4, 0x41)
+                                revert(0, 0x24)
+                            }
+                            mstore(_2, newFreePtr)
+                            if slt(sub(/** @src 0:410:418  \"this.f()\" */ add(_6, _8), /** @src 1:91:166  \"contract D is C(3)...\" */ _6), /** @src 0:410:418  \"this.f()\" */ 32)
+                            /// @src 1:91:166  \"contract D is C(3)...\"
+                            { revert(0, 0) }
+                            /// @src 0:410:418  \"this.f()\"
+                            expr := /** @src 1:91:166  \"contract D is C(3)...\" */ mload(_6)
+                        }
+                        /// @src 0:399:418  \"stateVar + this.f()\"
+                        let expr_1 := checked_add_int256(ret, expr)
+                        /// @src 0:392:429  \"return stateVar + this.f() + immutVar\"
+                        let var := /** @src 0:399:429  \"stateVar + this.f() + immutVar\" */ checked_add_int256(expr_1, /** @src 0:421:429  \"immutVar\" */ loadimmutable(\"8\"))
+                        /// @src 1:91:166  \"contract D is C(3)...\"
+                        let memPos_1 := mload(_2)
+                        mstore(memPos_1, var)
+                        return(memPos_1, /** @src 0:410:418  \"this.f()\" */ 32)
+                    }
+                    case /** @src 1:91:166  \"contract D is C(3)...\" */ 0xa00b982b {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        let memPos_2 := mload(_2)
+                        mstore(memPos_2, /** @src 0:124:126  \"41\" */ 0x29)
+                        /// @src 1:91:166  \"contract D is C(3)...\"
+                        return(memPos_2, 32)
+                    }
+                }
+                revert(0, 0)
+            }
+            function checked_add_int256(x, y) -> sum
+            {
+                sum := add(x, y)
+                let _1 := slt(sum, y)
+                let _2 := slt(x, 0)
+                if or(and(iszero(_2), _1), and(_2, iszero(_1)))
+                {
+                    mstore(0, shl(224, 0x4e487b71))
+                    mstore(4, 0x11)
+                    revert(0, 0x24)
+                }
+            }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        },
+        "D":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_default_success/output.json b/compiler/test/cmdlineTests/standard_default_success/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_default_success/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_empty_file_name/output.json b/compiler/test/cmdlineTests/standard_empty_file_name/output.json
new file mode 100644
index 00000000..4e4d84c4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_empty_file_name/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2904",
+            "formattedMessage": "DeclarationError: Declaration \"A\" not found in \"\" (referenced as \".\").
+
+",
+            "message": "Declaration \"A\" not found in \"\" (referenced as \".\").",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 79,
+                "file": "",
+                "start": 59
+            },
+            "type": "DeclarationError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_evm_version_byzantium/input.json b/compiler/test/cmdlineTests/standard_evm_version_byzantium/input.json
new file mode 100644
index 00000000..9f9c06f8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_evm_version_byzantium/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"input.sol": {"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity *;"}
+	},
+	"settings": {
+		"evmVersion": "byzantium"
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_evm_version_byzantium/output.json b/compiler/test/cmdlineTests/standard_evm_version_byzantium/output.json
new file mode 100644
index 00000000..b2428b10
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_evm_version_byzantium/output.json
@@ -0,0 +1,19 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "message": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "input.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_evm_version_constantinople/input.json b/compiler/test/cmdlineTests/standard_evm_version_constantinople/input.json
new file mode 100644
index 00000000..965c3897
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_evm_version_constantinople/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"input.sol": {"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity *;"}
+	},
+	"settings": {
+		"evmVersion": "constantinople"
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_evm_version_constantinople/output.json b/compiler/test/cmdlineTests/standard_evm_version_constantinople/output.json
new file mode 100644
index 00000000..1ce414a4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_evm_version_constantinople/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "input.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_file_not_found/err b/compiler/test/cmdlineTests/standard_file_not_found/err
new file mode 100644
index 00000000..2ae0ecf4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_file_not_found/err
@@ -0,0 +1 @@
+Error: "input.sol" is not found.
diff --git a/compiler/test/cmdlineTests/standard_function_debug_info/output.json b/compiler/test/cmdlineTests/standard_function_debug_info/output.json
new file mode 100644
index 00000000..bbbb6b96
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_function_debug_info/output.json
@@ -0,0 +1,185 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {}
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData":
+                        {
+                            "@f_19":
+                            {
+                                "entryPoint": 93,
+                                "id": 19,
+                                "parameterSlots": 1,
+                                "returnSlots": 1
+                            },
+                            "abi_decode_available_length_t_array$_t_uint256_$dyn_memory_ptr":
+                            {
+                                "entryPoint": 421,
+                                "id": null,
+                                "parameterSlots": 3,
+                                "returnSlots": 1
+                            },
+                            "abi_decode_t_array$_t_uint256_$dyn_memory_ptr":
+                            {
+                                "entryPoint": 525,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 1
+                            },
+                            "abi_decode_t_uint256":
+                            {
+                                "entryPoint": 401,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 1
+                            },
+                            "abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptr":
+                            {
+                                "entryPoint": 570,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 1
+                            },
+                            "abi_encode_t_uint256_to_t_uint256_fromStack":
+                            {
+                                "entryPoint": 641,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 0
+                            },
+                            "abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed":
+                            {
+                                "entryPoint": 656,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 1
+                            },
+                            "allocate_memory":
+                            {
+                                "entryPoint": 297,
+                                "id": null,
+                                "parameterSlots": 1,
+                                "returnSlots": 1
+                            },
+                            "allocate_unbounded":
+                            {
+                                "entryPoint": 166,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 1
+                            },
+                            "array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr":
+                            {
+                                "entryPoint": 323,
+                                "id": null,
+                                "parameterSlots": 1,
+                                "returnSlots": 1
+                            },
+                            "checked_add_t_uint256":
+                            {
+                                "entryPoint": 771,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 1
+                            },
+                            "cleanup_t_uint256":
+                            {
+                                "entryPoint": 370,
+                                "id": null,
+                                "parameterSlots": 1,
+                                "returnSlots": 1
+                            },
+                            "finalize_allocation":
+                            {
+                                "entryPoint": 248,
+                                "id": null,
+                                "parameterSlots": 2,
+                                "returnSlots": 0
+                            },
+                            "panic_error_0x11":
+                            {
+                                "entryPoint": 726,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "panic_error_0x32":
+                            {
+                                "entryPoint": 681,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "panic_error_0x41":
+                            {
+                                "entryPoint": 203,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d":
+                            {
+                                "entryPoint": 183,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef":
+                            {
+                                "entryPoint": 366,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db":
+                            {
+                                "entryPoint": 179,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b":
+                            {
+                                "entryPoint": 175,
+                                "id": null,
+                                "parameterSlots": 0,
+                                "returnSlots": 0
+                            },
+                            "round_up_to_mul_of_32":
+                            {
+                                "entryPoint": 187,
+                                "id": null,
+                                "parameterSlots": 1,
+                                "returnSlots": 1
+                            },
+                            "validator_revert_t_uint256":
+                            {
+                                "entryPoint": 379,
+                                "id": null,
+                                "parameterSlots": 1,
+                                "returnSlots": 0
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_generatedSources/output.json b/compiler/test/cmdlineTests/standard_generatedSources/output.json
new file mode 100644
index 00000000..350d1089
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_generatedSources/output.json
@@ -0,0 +1,2873 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "generatedSources": [],
+                        "object": "<BYTECODE REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "generatedSources":
+                        [
+                            {
+                                "ast":
+                                {
+                                    "nativeSrc": "0:3989:1",
+                                    "nodeType": "YulBlock",
+                                    "src": "0:3989:1",
+                                    "statements":
+                                    [
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "47:35:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "47:35:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "57:19:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "57:19:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "73:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "73:2:1",
+                                                                    "type": "",
+                                                                    "value": "64"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mload",
+                                                                "nativeSrc": "67:5:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "67:5:1"
+                                                            },
+                                                            "nativeSrc": "67:9:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "67:9:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "memPtr",
+                                                                "nativeSrc": "57:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "57:6:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "allocate_unbounded",
+                                            "nativeSrc": "7:75:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "memPtr",
+                                                    "nativeSrc": "40:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "40:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "7:75:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "177:28:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "177:28:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "194:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "194:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "197:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "197:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "187:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "187:6:1"
+                                                            },
+                                                            "nativeSrc": "187:12:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "187:12:1"
+                                                        },
+                                                        "nativeSrc": "187:12:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "187:12:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b",
+                                            "nativeSrc": "88:117:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "88:117:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "300:28:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "300:28:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "317:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "317:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "320:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "320:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "310:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "310:6:1"
+                                                            },
+                                                            "nativeSrc": "310:12:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "310:12:1"
+                                                        },
+                                                        "nativeSrc": "310:12:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "310:12:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db",
+                                            "nativeSrc": "211:117:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "211:117:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "423:28:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "423:28:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "440:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "440:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "443:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "443:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "433:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "433:6:1"
+                                                            },
+                                                            "nativeSrc": "433:12:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "433:12:1"
+                                                        },
+                                                        "nativeSrc": "433:12:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "433:12:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d",
+                                            "nativeSrc": "334:117:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "334:117:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "505:54:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "505:54:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "515:38:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "515:38:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "value",
+                                                                            "nativeSrc": "533:5:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "533:5:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "540:2:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "540:2:1",
+                                                                            "type": "",
+                                                                            "value": "31"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "add",
+                                                                        "nativeSrc": "529:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "529:3:1"
+                                                                    },
+                                                                    "nativeSrc": "529:14:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "529:14:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "549:2:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "549:2:1",
+                                                                            "type": "",
+                                                                            "value": "31"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "not",
+                                                                        "nativeSrc": "545:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "545:3:1"
+                                                                    },
+                                                                    "nativeSrc": "545:7:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "545:7:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "and",
+                                                                "nativeSrc": "525:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "525:3:1"
+                                                            },
+                                                            "nativeSrc": "525:28:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "525:28:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "result",
+                                                                "nativeSrc": "515:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "515:6:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "round_up_to_mul_of_32",
+                                            "nativeSrc": "457:102:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "488:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "488:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "result",
+                                                    "nativeSrc": "498:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "498:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "457:102:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "593:152:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "593:152:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "610:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "610:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "613:77:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "613:77:1",
+                                                                    "type": "",
+                                                                    "value": "35408467139433450592217433187231851964531694900788300625387963629091585785856"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "603:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "603:6:1"
+                                                            },
+                                                            "nativeSrc": "603:88:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "603:88:1"
+                                                        },
+                                                        "nativeSrc": "603:88:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "603:88:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "707:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "707:1:1",
+                                                                    "type": "",
+                                                                    "value": "4"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "710:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "710:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x41"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "700:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "700:6:1"
+                                                            },
+                                                            "nativeSrc": "700:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "700:15:1"
+                                                        },
+                                                        "nativeSrc": "700:15:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "700:15:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "731:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "731:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "734:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "734:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x24"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "724:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "724:6:1"
+                                                            },
+                                                            "nativeSrc": "724:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "724:15:1"
+                                                        },
+                                                        "nativeSrc": "724:15:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "724:15:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "panic_error_0x41",
+                                            "nativeSrc": "565:180:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "565:180:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "794:238:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "794:238:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "804:58:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "804:58:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "memPtr",
+                                                                    "nativeSrc": "826:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "826:6:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "size",
+                                                                            "nativeSrc": "856:4:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "856:4:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "round_up_to_mul_of_32",
+                                                                        "nativeSrc": "834:21:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "834:21:1"
+                                                                    },
+                                                                    "nativeSrc": "834:27:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "834:27:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "822:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "822:3:1"
+                                                            },
+                                                            "nativeSrc": "822:40:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "822:40:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "newFreePtr",
+                                                                "nativeSrc": "808:10:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "808:10:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "973:22:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "973:22:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "panic_error_0x41",
+                                                                            "nativeSrc": "975:16:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "975:16:1"
+                                                                        },
+                                                                        "nativeSrc": "975:18:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "975:18:1"
+                                                                    },
+                                                                    "nativeSrc": "975:18:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "975:18:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "newFreePtr",
+                                                                            "nativeSrc": "916:10:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "916:10:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "928:18:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "928:18:1",
+                                                                            "type": "",
+                                                                            "value": "0xffffffffffffffff"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "gt",
+                                                                        "nativeSrc": "913:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "913:2:1"
+                                                                    },
+                                                                    "nativeSrc": "913:34:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "913:34:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "newFreePtr",
+                                                                            "nativeSrc": "952:10:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "952:10:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "memPtr",
+                                                                            "nativeSrc": "964:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "964:6:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "lt",
+                                                                        "nativeSrc": "949:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "949:2:1"
+                                                                    },
+                                                                    "nativeSrc": "949:22:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "949:22:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "or",
+                                                                "nativeSrc": "910:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "910:2:1"
+                                                            },
+                                                            "nativeSrc": "910:62:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "910:62:1"
+                                                        },
+                                                        "nativeSrc": "907:88:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "907:88:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1011:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1011:2:1",
+                                                                    "type": "",
+                                                                    "value": "64"
+                                                                },
+                                                                {
+                                                                    "name": "newFreePtr",
+                                                                    "nativeSrc": "1015:10:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1015:10:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "1004:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1004:6:1"
+                                                            },
+                                                            "nativeSrc": "1004:22:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1004:22:1"
+                                                        },
+                                                        "nativeSrc": "1004:22:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "1004:22:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "finalize_allocation",
+                                            "nativeSrc": "751:281:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "memPtr",
+                                                    "nativeSrc": "780:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "780:6:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "size",
+                                                    "nativeSrc": "788:4:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "788:4:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "751:281:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1079:88:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1079:88:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1089:30:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1089:30:1",
+                                                        "value":
+                                                        {
+                                                            "arguments": [],
+                                                            "functionName":
+                                                            {
+                                                                "name": "allocate_unbounded",
+                                                                "nativeSrc": "1099:18:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1099:18:1"
+                                                            },
+                                                            "nativeSrc": "1099:20:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1099:20:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "memPtr",
+                                                                "nativeSrc": "1089:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1089:6:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "memPtr",
+                                                                    "nativeSrc": "1148:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1148:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "size",
+                                                                    "nativeSrc": "1156:4:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1156:4:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "finalize_allocation",
+                                                                "nativeSrc": "1128:19:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1128:19:1"
+                                                            },
+                                                            "nativeSrc": "1128:33:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1128:33:1"
+                                                        },
+                                                        "nativeSrc": "1128:33:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "1128:33:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "allocate_memory",
+                                            "nativeSrc": "1038:129:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "size",
+                                                    "nativeSrc": "1063:4:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1063:4:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "memPtr",
+                                                    "nativeSrc": "1072:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1072:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1038:129:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1255:229:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1255:229:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "1360:22:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1360:22:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "panic_error_0x41",
+                                                                            "nativeSrc": "1362:16:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1362:16:1"
+                                                                        },
+                                                                        "nativeSrc": "1362:18:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1362:18:1"
+                                                                    },
+                                                                    "nativeSrc": "1362:18:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "1362:18:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "length",
+                                                                    "nativeSrc": "1332:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1332:6:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1340:18:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1340:18:1",
+                                                                    "type": "",
+                                                                    "value": "0xffffffffffffffff"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "gt",
+                                                                "nativeSrc": "1329:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1329:2:1"
+                                                            },
+                                                            "nativeSrc": "1329:30:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1329:30:1"
+                                                        },
+                                                        "nativeSrc": "1326:56:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "1326:56:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "1392:25:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1392:25:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "length",
+                                                                    "nativeSrc": "1404:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1404:6:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1412:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1412:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mul",
+                                                                "nativeSrc": "1400:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1400:3:1"
+                                                            },
+                                                            "nativeSrc": "1400:17:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1400:17:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "size",
+                                                                "nativeSrc": "1392:4:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1392:4:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "1454:23:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1454:23:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "size",
+                                                                    "nativeSrc": "1466:4:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1466:4:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1472:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1472:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "1462:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1462:3:1"
+                                                            },
+                                                            "nativeSrc": "1462:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1462:15:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "size",
+                                                                "nativeSrc": "1454:4:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1454:4:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr",
+                                            "nativeSrc": "1173:311:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "length",
+                                                    "nativeSrc": "1239:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1239:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "size",
+                                                    "nativeSrc": "1250:4:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1250:4:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1173:311:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1579:28:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1579:28:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1596:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1596:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1599:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1599:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "1589:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1589:6:1"
+                                                            },
+                                                            "nativeSrc": "1589:12:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1589:12:1"
+                                                        },
+                                                        "nativeSrc": "1589:12:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "1589:12:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef",
+                                            "nativeSrc": "1490:117:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "1490:117:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1658:32:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1658:32:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1668:16:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1668:16:1",
+                                                        "value":
+                                                        {
+                                                            "name": "value",
+                                                            "nativeSrc": "1679:5:1",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "1679:5:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "cleaned",
+                                                                "nativeSrc": "1668:7:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1668:7:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "cleanup_t_uint256",
+                                            "nativeSrc": "1613:77:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "1640:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1640:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "cleaned",
+                                                    "nativeSrc": "1650:7:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1650:7:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1613:77:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1739:79:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1739:79:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "1796:16:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1796:16:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "1805:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "1805:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "1808:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "1808:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert",
+                                                                            "nativeSrc": "1798:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1798:6:1"
+                                                                        },
+                                                                        "nativeSrc": "1798:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1798:12:1"
+                                                                    },
+                                                                    "nativeSrc": "1798:12:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "1798:12:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "value",
+                                                                            "nativeSrc": "1762:5:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1762:5:1"
+                                                                        },
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "value",
+                                                                                    "nativeSrc": "1787:5:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "1787:5:1"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "cleanup_t_uint256",
+                                                                                "nativeSrc": "1769:17:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1769:17:1"
+                                                                            },
+                                                                            "nativeSrc": "1769:24:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "1769:24:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "eq",
+                                                                        "nativeSrc": "1759:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "1759:2:1"
+                                                                    },
+                                                                    "nativeSrc": "1759:35:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "1759:35:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "iszero",
+                                                                "nativeSrc": "1752:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1752:6:1"
+                                                            },
+                                                            "nativeSrc": "1752:43:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1752:43:1"
+                                                        },
+                                                        "nativeSrc": "1749:63:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "1749:63:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "validator_revert_t_uint256",
+                                            "nativeSrc": "1696:122:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "1732:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1732:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1696:122:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1876:87:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1876:87:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1886:29:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1886:29:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "offset",
+                                                                    "nativeSrc": "1908:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1908:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "calldataload",
+                                                                "nativeSrc": "1895:12:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1895:12:1"
+                                                            },
+                                                            "nativeSrc": "1895:20:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1895:20:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "value",
+                                                                "nativeSrc": "1886:5:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1886:5:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "value",
+                                                                    "nativeSrc": "1951:5:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1951:5:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "validator_revert_t_uint256",
+                                                                "nativeSrc": "1924:26:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1924:26:1"
+                                                            },
+                                                            "nativeSrc": "1924:33:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1924:33:1"
+                                                        },
+                                                        "nativeSrc": "1924:33:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "1924:33:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_decode_t_uint256",
+                                            "nativeSrc": "1824:139:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "offset",
+                                                    "nativeSrc": "1854:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1854:6:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "end",
+                                                    "nativeSrc": "1862:3:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1862:3:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "1870:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1870:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1824:139:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "2088:608:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "2088:608:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "2098:90:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "2098:90:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "length",
+                                                                            "nativeSrc": "2180:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2180:6:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr",
+                                                                        "nativeSrc": "2123:56:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "2123:56:1"
+                                                                    },
+                                                                    "nativeSrc": "2123:64:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "2123:64:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "allocate_memory",
+                                                                "nativeSrc": "2107:15:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2107:15:1"
+                                                            },
+                                                            "nativeSrc": "2107:81:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2107:81:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "array",
+                                                                "nativeSrc": "2098:5:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2098:5:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "2197:16:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "2197:16:1",
+                                                        "value":
+                                                        {
+                                                            "name": "array",
+                                                            "nativeSrc": "2208:5:1",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "2208:5:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "dst",
+                                                                "nativeSrc": "2201:3:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "2201:3:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "array",
+                                                                    "nativeSrc": "2230:5:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2230:5:1"
+                                                                },
+                                                                {
+                                                                    "name": "length",
+                                                                    "nativeSrc": "2237:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2237:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "2223:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2223:6:1"
+                                                            },
+                                                            "nativeSrc": "2223:21:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2223:21:1"
+                                                        },
+                                                        "nativeSrc": "2223:21:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "2223:21:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "2253:23:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "2253:23:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "array",
+                                                                    "nativeSrc": "2264:5:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2264:5:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "2271:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "2271:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x20"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "2260:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2260:3:1"
+                                                            },
+                                                            "nativeSrc": "2260:16:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2260:16:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "dst",
+                                                                "nativeSrc": "2253:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2253:3:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "2286:44:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "2286:44:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "offset",
+                                                                    "nativeSrc": "2304:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2304:6:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "length",
+                                                                            "nativeSrc": "2316:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2316:6:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "2324:4:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "2324:4:1",
+                                                                            "type": "",
+                                                                            "value": "0x20"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "mul",
+                                                                        "nativeSrc": "2312:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "2312:3:1"
+                                                                    },
+                                                                    "nativeSrc": "2312:17:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "2312:17:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "2300:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2300:3:1"
+                                                            },
+                                                            "nativeSrc": "2300:30:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2300:30:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "srcEnd",
+                                                                "nativeSrc": "2290:6:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "2290:6:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "2358:103:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "2358:103:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef",
+                                                                            "nativeSrc": "2372:77:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2372:77:1"
+                                                                        },
+                                                                        "nativeSrc": "2372:79:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "2372:79:1"
+                                                                    },
+                                                                    "nativeSrc": "2372:79:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "2372:79:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "srcEnd",
+                                                                    "nativeSrc": "2345:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2345:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "end",
+                                                                    "nativeSrc": "2353:3:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2353:3:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "gt",
+                                                                "nativeSrc": "2342:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2342:2:1"
+                                                            },
+                                                            "nativeSrc": "2342:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2342:15:1"
+                                                        },
+                                                        "nativeSrc": "2339:122:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "2339:122:1"
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "2546:144:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "2546:144:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "nativeSrc": "2561:21:1",
+                                                                    "nodeType": "YulVariableDeclaration",
+                                                                    "src": "2561:21:1",
+                                                                    "value":
+                                                                    {
+                                                                        "name": "src",
+                                                                        "nativeSrc": "2579:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "2579:3:1"
+                                                                    },
+                                                                    "variables":
+                                                                    [
+                                                                        {
+                                                                            "name": "elementPos",
+                                                                            "nativeSrc": "2565:10:1",
+                                                                            "nodeType": "YulTypedName",
+                                                                            "src": "2565:10:1",
+                                                                            "type": ""
+                                                                        }
+                                                                    ]
+                                                                },
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "dst",
+                                                                                "nativeSrc": "2603:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "2603:3:1"
+                                                                            },
+                                                                            {
+                                                                                "arguments":
+                                                                                [
+                                                                                    {
+                                                                                        "name": "elementPos",
+                                                                                        "nativeSrc": "2629:10:1",
+                                                                                        "nodeType": "YulIdentifier",
+                                                                                        "src": "2629:10:1"
+                                                                                    },
+                                                                                    {
+                                                                                        "name": "end",
+                                                                                        "nativeSrc": "2641:3:1",
+                                                                                        "nodeType": "YulIdentifier",
+                                                                                        "src": "2641:3:1"
+                                                                                    }
+                                                                                ],
+                                                                                "functionName":
+                                                                                {
+                                                                                    "name": "abi_decode_t_uint256",
+                                                                                    "nativeSrc": "2608:20:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "2608:20:1"
+                                                                                },
+                                                                                "nativeSrc": "2608:37:1",
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "2608:37:1"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "mstore",
+                                                                            "nativeSrc": "2596:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2596:6:1"
+                                                                        },
+                                                                        "nativeSrc": "2596:50:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "2596:50:1"
+                                                                    },
+                                                                    "nativeSrc": "2596:50:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "2596:50:1"
+                                                                },
+                                                                {
+                                                                    "nativeSrc": "2659:21:1",
+                                                                    "nodeType": "YulAssignment",
+                                                                    "src": "2659:21:1",
+                                                                    "value":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "dst",
+                                                                                "nativeSrc": "2670:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "2670:3:1"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "2675:4:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "2675:4:1",
+                                                                                "type": "",
+                                                                                "value": "0x20"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "add",
+                                                                            "nativeSrc": "2666:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2666:3:1"
+                                                                        },
+                                                                        "nativeSrc": "2666:14:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "2666:14:1"
+                                                                    },
+                                                                    "variableNames":
+                                                                    [
+                                                                        {
+                                                                            "name": "dst",
+                                                                            "nativeSrc": "2659:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2659:3:1"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "src",
+                                                                    "nativeSrc": "2499:3:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2499:3:1"
+                                                                },
+                                                                {
+                                                                    "name": "srcEnd",
+                                                                    "nativeSrc": "2504:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2504:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "lt",
+                                                                "nativeSrc": "2496:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2496:2:1"
+                                                            },
+                                                            "nativeSrc": "2496:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2496:15:1"
+                                                        },
+                                                        "nativeSrc": "2470:220:1",
+                                                        "nodeType": "YulForLoop",
+                                                        "post":
+                                                        {
+                                                            "nativeSrc": "2512:25:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "2512:25:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "nativeSrc": "2514:21:1",
+                                                                    "nodeType": "YulAssignment",
+                                                                    "src": "2514:21:1",
+                                                                    "value":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "src",
+                                                                                "nativeSrc": "2525:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "2525:3:1"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "2530:4:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "2530:4:1",
+                                                                                "type": "",
+                                                                                "value": "0x20"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "add",
+                                                                            "nativeSrc": "2521:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2521:3:1"
+                                                                        },
+                                                                        "nativeSrc": "2521:14:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "2521:14:1"
+                                                                    },
+                                                                    "variableNames":
+                                                                    [
+                                                                        {
+                                                                            "name": "src",
+                                                                            "nativeSrc": "2514:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2514:3:1"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            ]
+                                                        },
+                                                        "pre":
+                                                        {
+                                                            "nativeSrc": "2474:21:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "2474:21:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "nativeSrc": "2476:17:1",
+                                                                    "nodeType": "YulVariableDeclaration",
+                                                                    "src": "2476:17:1",
+                                                                    "value":
+                                                                    {
+                                                                        "name": "offset",
+                                                                        "nativeSrc": "2487:6:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "2487:6:1"
+                                                                    },
+                                                                    "variables":
+                                                                    [
+                                                                        {
+                                                                            "name": "src",
+                                                                            "nativeSrc": "2480:3:1",
+                                                                            "nodeType": "YulTypedName",
+                                                                            "src": "2480:3:1",
+                                                                            "type": ""
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            ]
+                                                        },
+                                                        "src": "2470:220:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_decode_available_length_t_array$_t_uint256_$dyn_memory_ptr",
+                                            "nativeSrc": "1986:710:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "offset",
+                                                    "nativeSrc": "2058:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2058:6:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "length",
+                                                    "nativeSrc": "2066:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2066:6:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "end",
+                                                    "nativeSrc": "2074:3:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2074:3:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "array",
+                                                    "nativeSrc": "2082:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2082:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1986:710:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "2796:293:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "2796:293:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "2845:83:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "2845:83:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d",
+                                                                            "nativeSrc": "2847:77:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2847:77:1"
+                                                                        },
+                                                                        "nativeSrc": "2847:79:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "2847:79:1"
+                                                                    },
+                                                                    "nativeSrc": "2847:79:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "2847:79:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "offset",
+                                                                                    "nativeSrc": "2824:6:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "2824:6:1"
+                                                                                },
+                                                                                {
+                                                                                    "kind": "number",
+                                                                                    "nativeSrc": "2832:4:1",
+                                                                                    "nodeType": "YulLiteral",
+                                                                                    "src": "2832:4:1",
+                                                                                    "type": "",
+                                                                                    "value": "0x1f"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "add",
+                                                                                "nativeSrc": "2820:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "2820:3:1"
+                                                                            },
+                                                                            "nativeSrc": "2820:17:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "2820:17:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "end",
+                                                                            "nativeSrc": "2839:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "2839:3:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "slt",
+                                                                        "nativeSrc": "2816:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "2816:3:1"
+                                                                    },
+                                                                    "nativeSrc": "2816:27:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "2816:27:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "iszero",
+                                                                "nativeSrc": "2809:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2809:6:1"
+                                                            },
+                                                            "nativeSrc": "2809:35:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2809:35:1"
+                                                        },
+                                                        "nativeSrc": "2806:122:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "2806:122:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "2937:34:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "2937:34:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "offset",
+                                                                    "nativeSrc": "2964:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "2964:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "calldataload",
+                                                                "nativeSrc": "2951:12:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2951:12:1"
+                                                            },
+                                                            "nativeSrc": "2951:20:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2951:20:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "length",
+                                                                "nativeSrc": "2941:6:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "2941:6:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "2980:103:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "2980:103:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "offset",
+                                                                            "nativeSrc": "3056:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3056:6:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "3064:4:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "3064:4:1",
+                                                                            "type": "",
+                                                                            "value": "0x20"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "add",
+                                                                        "nativeSrc": "3052:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3052:3:1"
+                                                                    },
+                                                                    "nativeSrc": "3052:17:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3052:17:1"
+                                                                },
+                                                                {
+                                                                    "name": "length",
+                                                                    "nativeSrc": "3071:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "3071:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "end",
+                                                                    "nativeSrc": "3079:3:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "3079:3:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "abi_decode_available_length_t_array$_t_uint256_$dyn_memory_ptr",
+                                                                "nativeSrc": "2989:62:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2989:62:1"
+                                                            },
+                                                            "nativeSrc": "2989:94:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "2989:94:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "array",
+                                                                "nativeSrc": "2980:5:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "2980:5:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_decode_t_array$_t_uint256_$dyn_memory_ptr",
+                                            "nativeSrc": "2719:370:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "offset",
+                                                    "nativeSrc": "2774:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2774:6:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "end",
+                                                    "nativeSrc": "2782:3:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2782:3:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "array",
+                                                    "nativeSrc": "2790:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "2790:5:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "2719:370:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "3186:448:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "3186:448:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "3232:83:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "3232:83:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b",
+                                                                            "nativeSrc": "3234:77:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3234:77:1"
+                                                                        },
+                                                                        "nativeSrc": "3234:79:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "3234:79:1"
+                                                                    },
+                                                                    "nativeSrc": "3234:79:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "3234:79:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "dataEnd",
+                                                                            "nativeSrc": "3207:7:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3207:7:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "headStart",
+                                                                            "nativeSrc": "3216:9:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3216:9:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "sub",
+                                                                        "nativeSrc": "3203:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3203:3:1"
+                                                                    },
+                                                                    "nativeSrc": "3203:23:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3203:23:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "3228:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "3228:2:1",
+                                                                    "type": "",
+                                                                    "value": "32"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "slt",
+                                                                "nativeSrc": "3199:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "3199:3:1"
+                                                            },
+                                                            "nativeSrc": "3199:32:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "3199:32:1"
+                                                        },
+                                                        "nativeSrc": "3196:119:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "3196:119:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "3325:302:1",
+                                                        "nodeType": "YulBlock",
+                                                        "src": "3325:302:1",
+                                                        "statements":
+                                                        [
+                                                            {
+                                                                "nativeSrc": "3340:45:1",
+                                                                "nodeType": "YulVariableDeclaration",
+                                                                "src": "3340:45:1",
+                                                                "value":
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "headStart",
+                                                                                    "nativeSrc": "3371:9:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "3371:9:1"
+                                                                                },
+                                                                                {
+                                                                                    "kind": "number",
+                                                                                    "nativeSrc": "3382:1:1",
+                                                                                    "nodeType": "YulLiteral",
+                                                                                    "src": "3382:1:1",
+                                                                                    "type": "",
+                                                                                    "value": "0"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "add",
+                                                                                "nativeSrc": "3367:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "3367:3:1"
+                                                                            },
+                                                                            "nativeSrc": "3367:17:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "3367:17:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "calldataload",
+                                                                        "nativeSrc": "3354:12:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3354:12:1"
+                                                                    },
+                                                                    "nativeSrc": "3354:31:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3354:31:1"
+                                                                },
+                                                                "variables":
+                                                                [
+                                                                    {
+                                                                        "name": "offset",
+                                                                        "nativeSrc": "3344:6:1",
+                                                                        "nodeType": "YulTypedName",
+                                                                        "src": "3344:6:1",
+                                                                        "type": ""
+                                                                    }
+                                                                ]
+                                                            },
+                                                            {
+                                                                "body":
+                                                                {
+                                                                    "nativeSrc": "3432:83:1",
+                                                                    "nodeType": "YulBlock",
+                                                                    "src": "3432:83:1",
+                                                                    "statements":
+                                                                    [
+                                                                        {
+                                                                            "expression":
+                                                                            {
+                                                                                "arguments": [],
+                                                                                "functionName":
+                                                                                {
+                                                                                    "name": "revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db",
+                                                                                    "nativeSrc": "3434:77:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "3434:77:1"
+                                                                                },
+                                                                                "nativeSrc": "3434:79:1",
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "3434:79:1"
+                                                                            },
+                                                                            "nativeSrc": "3434:79:1",
+                                                                            "nodeType": "YulExpressionStatement",
+                                                                            "src": "3434:79:1"
+                                                                        }
+                                                                    ]
+                                                                },
+                                                                "condition":
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "offset",
+                                                                            "nativeSrc": "3404:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3404:6:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "3412:18:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "3412:18:1",
+                                                                            "type": "",
+                                                                            "value": "0xffffffffffffffff"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "gt",
+                                                                        "nativeSrc": "3401:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3401:2:1"
+                                                                    },
+                                                                    "nativeSrc": "3401:30:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3401:30:1"
+                                                                },
+                                                                "nativeSrc": "3398:117:1",
+                                                                "nodeType": "YulIf",
+                                                                "src": "3398:117:1"
+                                                            },
+                                                            {
+                                                                "nativeSrc": "3529:88:1",
+                                                                "nodeType": "YulAssignment",
+                                                                "src": "3529:88:1",
+                                                                "value":
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "headStart",
+                                                                                    "nativeSrc": "3589:9:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "3589:9:1"
+                                                                                },
+                                                                                {
+                                                                                    "name": "offset",
+                                                                                    "nativeSrc": "3600:6:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "3600:6:1"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "add",
+                                                                                "nativeSrc": "3585:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "3585:3:1"
+                                                                            },
+                                                                            "nativeSrc": "3585:22:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "3585:22:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "dataEnd",
+                                                                            "nativeSrc": "3609:7:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3609:7:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "abi_decode_t_array$_t_uint256_$dyn_memory_ptr",
+                                                                        "nativeSrc": "3539:45:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3539:45:1"
+                                                                    },
+                                                                    "nativeSrc": "3539:78:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3539:78:1"
+                                                                },
+                                                                "variableNames":
+                                                                [
+                                                                    {
+                                                                        "name": "value0",
+                                                                        "nativeSrc": "3529:6:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3529:6:1"
+                                                                    }
+                                                                ]
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptr",
+                                            "nativeSrc": "3095:539:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "headStart",
+                                                    "nativeSrc": "3156:9:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3156:9:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "dataEnd",
+                                                    "nativeSrc": "3167:7:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3167:7:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "value0",
+                                                    "nativeSrc": "3179:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3179:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "3095:539:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "3705:53:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "3705:53:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "pos",
+                                                                    "nativeSrc": "3722:3:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "3722:3:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "value",
+                                                                            "nativeSrc": "3745:5:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3745:5:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "cleanup_t_uint256",
+                                                                        "nativeSrc": "3727:17:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3727:17:1"
+                                                                    },
+                                                                    "nativeSrc": "3727:24:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3727:24:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "3715:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "3715:6:1"
+                                                            },
+                                                            "nativeSrc": "3715:37:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "3715:37:1"
+                                                        },
+                                                        "nativeSrc": "3715:37:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "3715:37:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_encode_t_uint256_to_t_uint256_fromStack",
+                                            "nativeSrc": "3640:118:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "3693:5:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3693:5:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "pos",
+                                                    "nativeSrc": "3700:3:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3700:3:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "3640:118:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "3862:124:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "3862:124:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "3872:26:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "3872:26:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "headStart",
+                                                                    "nativeSrc": "3884:9:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "3884:9:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "3895:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "3895:2:1",
+                                                                    "type": "",
+                                                                    "value": "32"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "3880:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "3880:3:1"
+                                                            },
+                                                            "nativeSrc": "3880:18:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "3880:18:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "tail",
+                                                                "nativeSrc": "3872:4:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "3872:4:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "value0",
+                                                                    "nativeSrc": "3952:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "3952:6:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "headStart",
+                                                                            "nativeSrc": "3965:9:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "3965:9:1"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "3976:1:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "3976:1:1",
+                                                                            "type": "",
+                                                                            "value": "0"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "add",
+                                                                        "nativeSrc": "3961:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "3961:3:1"
+                                                                    },
+                                                                    "nativeSrc": "3961:17:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "3961:17:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "abi_encode_t_uint256_to_t_uint256_fromStack",
+                                                                "nativeSrc": "3908:43:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "3908:43:1"
+                                                            },
+                                                            "nativeSrc": "3908:71:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "3908:71:1"
+                                                        },
+                                                        "nativeSrc": "3908:71:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "3908:71:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed",
+                                            "nativeSrc": "3764:222:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "headStart",
+                                                    "nativeSrc": "3834:9:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3834:9:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "value0",
+                                                    "nativeSrc": "3846:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3846:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "tail",
+                                                    "nativeSrc": "3857:4:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "3857:4:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "3764:222:1"
+                                        }
+                                    ]
+                                },
+                                "contents": "{
+
+    function allocate_unbounded() -> memPtr {
+        memPtr := mload(64)
+    }
+
+    function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+        revert(0, 0)
+    }
+
+    function revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() {
+        revert(0, 0)
+    }
+
+    function revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d() {
+        revert(0, 0)
+    }
+
+    function round_up_to_mul_of_32(value) -> result {
+        result := and(add(value, 31), not(31))
+    }
+
+    function panic_error_0x41() {
+        mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+        mstore(4, 0x41)
+        revert(0, 0x24)
+    }
+
+    function finalize_allocation(memPtr, size) {
+        let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+        // protect against overflow
+        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+        mstore(64, newFreePtr)
+    }
+
+    function allocate_memory(size) -> memPtr {
+        memPtr := allocate_unbounded()
+        finalize_allocation(memPtr, size)
+    }
+
+    function array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr(length) -> size {
+        // Make sure we can allocate memory without overflow
+        if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
+
+        size := mul(length, 0x20)
+
+        // add length slot
+        size := add(size, 0x20)
+
+    }
+
+    function revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef() {
+        revert(0, 0)
+    }
+
+    function cleanup_t_uint256(value) -> cleaned {
+        cleaned := value
+    }
+
+    function validator_revert_t_uint256(value) {
+        if iszero(eq(value, cleanup_t_uint256(value))) { revert(0, 0) }
+    }
+
+    function abi_decode_t_uint256(offset, end) -> value {
+        value := calldataload(offset)
+        validator_revert_t_uint256(value)
+    }
+
+    // uint256[]
+    function abi_decode_available_length_t_array$_t_uint256_$dyn_memory_ptr(offset, length, end) -> array {
+        array := allocate_memory(array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr(length))
+        let dst := array
+
+        mstore(array, length)
+        dst := add(array, 0x20)
+
+        let srcEnd := add(offset, mul(length, 0x20))
+        if gt(srcEnd, end) {
+            revert_error_81385d8c0b31fffe14be1da910c8bd3a80be4cfa248e04f42ec0faea3132a8ef()
+        }
+        for { let src := offset } lt(src, srcEnd) { src := add(src, 0x20) }
+        {
+
+            let elementPos := src
+
+            mstore(dst, abi_decode_t_uint256(elementPos, end))
+            dst := add(dst, 0x20)
+        }
+    }
+
+    // uint256[]
+    function abi_decode_t_array$_t_uint256_$dyn_memory_ptr(offset, end) -> array {
+        if iszero(slt(add(offset, 0x1f), end)) { revert_error_1b9f4a0a5773e33b91aa01db23bf8c55fce1411167c872835e7fa00a4f17d46d() }
+        let length := calldataload(offset)
+        array := abi_decode_available_length_t_array$_t_uint256_$dyn_memory_ptr(add(offset, 0x20), length, end)
+    }
+
+    function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptr(headStart, dataEnd) -> value0 {
+        if slt(sub(dataEnd, headStart), 32) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+        {
+
+            let offset := calldataload(add(headStart, 0))
+            if gt(offset, 0xffffffffffffffff) { revert_error_c1322bf8034eace5e0b5c7295db60986aa89aae5e0ea0873e4689e076861a5db() }
+
+            value0 := abi_decode_t_array$_t_uint256_$dyn_memory_ptr(add(headStart, offset), dataEnd)
+        }
+
+    }
+
+    function abi_encode_t_uint256_to_t_uint256_fromStack(value, pos) {
+        mstore(pos, cleanup_t_uint256(value))
+    }
+
+    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart , value0) -> tail {
+        tail := add(headStart, 32)
+
+        abi_encode_t_uint256_to_t_uint256_fromStack(value0,  add(headStart, 0))
+
+    }
+
+}
+",
+                                "id": 1,
+                                "language": "Yul",
+                                "name": "#utility.yul"
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3420",
+            "formattedMessage": "Warning: Source file does not specify required compiler version!
+--> a.sol
+
+",
+            "message": "Source file does not specify required compiler version!",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": -1,
+                "file": "a.sol",
+                "start": -1
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_immutable_references/output.json b/compiler/test/cmdlineTests/standard_immutable_references/output.json
new file mode 100644
index 00000000..e25a911f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_immutable_references/output.json
@@ -0,0 +1,34 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A":
+            {
+                "evm":
+                {
+                    "deployedBytecode":
+                    {
+                        "immutableReferences":
+                        {
+                            "6":
+                            [
+                                {
+                                    "length": 32,
+                                    "start": 75
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_ast/input.json b/compiler/test/cmdlineTests/standard_import_ast/input.json
new file mode 100644
index 00000000..5ae7a529
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_ast/input.json
@@ -0,0 +1,94 @@
+{
+	"language": "SolidityAST",
+	"sources": {
+		"A": {
+			"ast": {
+				"absolutePath": "A",
+				"exportedSymbols": {
+					"C": [
+						6
+					]
+				},
+				"id": 7,
+				"license": "GPL-3.0",
+				"nodeType": "SourceUnit",
+				"nodes": [
+					{
+						"id": 1,
+						"literals": [
+							"solidity",
+							">=",
+							"0.0"
+						],
+						"nodeType": "PragmaDirective",
+						"src": "36:22:0"
+					},
+					{
+						"abstract": false,
+						"baseContracts": [],
+						"canonicalName": "C",
+						"contractDependencies": [],
+						"contractKind": "contract",
+						"fullyImplemented": true,
+						"id": 6,
+						"linearizedBaseContracts": [
+							6
+						],
+						"name": "C",
+						"nameLocation": "68:1:0",
+						"nodeType": "ContractDefinition",
+						"nodes": [
+							{
+								"body": {
+									"id": 4,
+									"nodeType": "Block",
+									"src": "97:2:0",
+									"statements": []
+								},
+								"functionSelector": "26121ff0",
+								"id": 5,
+								"implemented": true,
+								"kind": "function",
+								"modifiers": [],
+								"name": "f",
+								"nameLocation": "81:1:0",
+								"nodeType": "FunctionDefinition",
+								"parameters": {
+									"id": 2,
+									"nodeType": "ParameterList",
+									"parameters": [],
+									"src": "82:2:0"
+								},
+								"returnParameters": {
+									"id": 3,
+									"nodeType": "ParameterList",
+									"parameters": [],
+									"src": "97:0:0"
+								},
+								"scope": 6,
+								"src": "72:27:0",
+								"stateMutability": "pure",
+								"virtual": false,
+								"visibility": "public"
+							}
+						],
+						"scope": 7,
+						"src": "59:42:0",
+						"usedErrors": []
+					}
+				],
+				"src": "36:65:0"
+			},
+			"id": 0
+		}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {
+				"": [
+					"ast"
+				]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_import_ast/output.json b/compiler/test/cmdlineTests/standard_import_ast/output.json
new file mode 100644
index 00000000..6ecac5ca
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_ast/output.json
@@ -0,0 +1,97 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "absolutePath": "A",
+                "exportedSymbols":
+                {
+                    "C":
+                    [
+                        6
+                    ]
+                },
+                "id": 7,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            ">=",
+                            "0.0"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:22:0"
+                    },
+                    {
+                        "abstract": false,
+                        "baseContracts": [],
+                        "canonicalName": "C",
+                        "contractDependencies": [],
+                        "contractKind": "contract",
+                        "fullyImplemented": true,
+                        "id": 6,
+                        "linearizedBaseContracts":
+                        [
+                            6
+                        ],
+                        "name": "C",
+                        "nameLocation": "68:1:0",
+                        "nodeType": "ContractDefinition",
+                        "nodes":
+                        [
+                            {
+                                "body":
+                                {
+                                    "id": 4,
+                                    "nodeType": "Block",
+                                    "src": "97:2:0",
+                                    "statements": []
+                                },
+                                "functionSelector": "26121ff0",
+                                "id": 5,
+                                "implemented": true,
+                                "kind": "function",
+                                "modifiers": [],
+                                "name": "f",
+                                "nameLocation": "81:1:0",
+                                "nodeType": "FunctionDefinition",
+                                "parameters":
+                                {
+                                    "id": 2,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "82:2:0"
+                                },
+                                "returnParameters":
+                                {
+                                    "id": 3,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "97:0:0"
+                                },
+                                "scope": 6,
+                                "src": "72:27:0",
+                                "stateMutability": "pure",
+                                "virtual": false,
+                                "visibility": "public"
+                            }
+                        ],
+                        "scope": 7,
+                        "src": "59:42:0",
+                        "usedErrors": [],
+                        "usedEvents": []
+                    }
+                ],
+                "src": "36:65:0"
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/input.json b/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/input.json
new file mode 100644
index 00000000..6458cb7e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/input.json
@@ -0,0 +1,50 @@
+{
+  "language": "SolidityAST",
+  "sources": {
+    "A": {
+      "ast": {
+        "absolutePath": "empty_contract.sol",
+        "exportedSymbols": {
+          "test": [
+            1
+          ]
+        },
+        "id": 2,
+        "nodeType": "SourceUnit",
+        "nodes": [
+          {
+            "abstract": false,
+            "baseContracts": [],
+            "canonicalName": "test",
+            "contractDependencies": [],
+            "contractKind": "contract",
+            "fullyImplemented": true,
+            "id": 1,
+            "linearizedBaseContracts": [
+              1
+            ],
+            "name": "test",
+            "nameLocation": "9:4:0",
+            "nodeType": "ContractDefinition",
+            "nodes": [],
+            "scope": 2,
+            "src": "0:17:0",
+            "usedErrors": []
+          }
+        ],
+        "src": "0:124:0"
+      },
+      "id": 0
+    }
+  },
+  "settings": {
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.bytecode.sourceMap"
+        ]
+      }
+    }
+  }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/output.json b/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/output.json
new file mode 100644
index 00000000..0fca3f27
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_ast_select_bytecode/output.json
@@ -0,0 +1,30 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "test":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm/input.json b/compiler/test/cmdlineTests/standard_import_evmasm/input.json
new file mode 100644
index 00000000..112f4804
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm/input.json
@@ -0,0 +1,28 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "PUSH",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["*"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm/output.json b/compiler/test/cmdlineTests/standard_import_evmasm/output.json
new file mode 100644
index 00000000..5b7cdf3b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm/output.json
@@ -0,0 +1,51 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"<stdin>\":36:51   */
+  0x00
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData": {},
+                        "immutableReferences": {},
+                        "linkReferences": {},
+                        "object": "",
+                        "opcodes": "",
+                        "sourceMap": ""
+                    },
+                    "legacyAssembly":
+                    {
+                        ".code":
+                        [
+                            {
+                                "begin": 36,
+                                "end": 51,
+                                "name": "PUSH",
+                                "source": 0,
+                                "value": "0"
+                            }
+                        ],
+                        "sourceList":
+                        [
+                            "<stdin>"
+                        ]
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/input.json
new file mode 100644
index 00000000..0619f8d0
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/input.json
@@ -0,0 +1,46 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 59,
+                        "end": 159,
+                        "name": "ASSIGNIMMUTABLE",
+                        "source": 0,
+                        "value": "6"
+                    }
+                ],
+                ".data": {
+                    "0": {
+                        ".auxdata": "a2646970667358221220762f49087b0990aeaac25050c4a08d9057732db3cac345579ad648d92458e09e64736f6c63430008170033",
+                        ".code": [
+                            {
+                                "begin": 153,
+                                "end": 154,
+                                "name": "PUSHIMMUTABLE",
+                                "source": 0,
+                                "value": "6"
+                            }
+                        ]
+                    }
+                },
+                "sourceList": [
+                    "test.sol",
+                    "#utility.yul"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": [
+                    "evm.bytecode",
+                    "evm.deployedBytecode"
+                ]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/output.json
new file mode 100644
index 00000000..05a6ff7d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_immutable_references/output.json
@@ -0,0 +1,40 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData": {},
+                        "immutableReferences":
+                        {
+                            "6":
+                            [
+                                {
+                                    "length": 32,
+                                    "start": 1
+                                }
+                            ]
+                        },
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/input.json
new file mode 100644
index 00000000..7da583b8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/input.json
@@ -0,0 +1,15 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": []
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/output.json
new file mode 100644
index 00000000..2a075efd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_input_array/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "message": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/input.json
new file mode 100644
index 00000000..e697565d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/input.json
@@ -0,0 +1,28 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "invalidAssemblyJsonObject": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "PUSH",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/output.json
new file mode 100644
index 00000000..2a075efd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_inside_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "message": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/input.json
new file mode 100644
index 00000000..c627b34c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/input.json
@@ -0,0 +1,29 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "keccak256": "0x1234",
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "PUSH",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/output.json
new file mode 100644
index 00000000..2a075efd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_key_other_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "message": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/input.json
new file mode 100644
index 00000000..01cfc88a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/input.json
@@ -0,0 +1,12 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/output.json
new file mode 100644
index 00000000..3495a741
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_no_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "No input sources specified.",
+            "message": "No input sources specified.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/input.json
new file mode 100644
index 00000000..2e3e22cc
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/input.json
@@ -0,0 +1,28 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "INVALID_OPCODE",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/output.json
new file mode 100644
index 00000000..6314f8b0
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_opcode/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Assembly import error: InvalidOpcode",
+            "message": "Assembly import error: InvalidOpcode",
+            "severity": "error",
+            "type": "Exception"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/input.json
new file mode 100644
index 00000000..b5a668c0
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/input.json
@@ -0,0 +1,20 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {}
+        },
+        "B": {
+            "assemblyJson": {}
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": [
+                    "evm.bytecode"
+                ]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/output.json
new file mode 100644
index 00000000..affe4c34
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_invalid_two_sources/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "EVMAssembly import only supports exactly one input file.",
+            "message": "EVMAssembly import only supports exactly one input file.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_link_references/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_link_references/input.json
new file mode 100644
index 00000000..47693fa1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_link_references/input.json
@@ -0,0 +1,38 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [],
+                ".data": {
+                    "0": {
+                        ".auxdata": "a264697066735822122049fc8a5c547ec9ab3b6a5804732f6ef55e87fdb28a3a8826c23cdeb89c034e3d64736f6c63430008170033",
+                        ".code": [
+                            {
+                                "begin": 133,
+                                "end": 134,
+                                "name": "PUSHLIB",
+                                "source": 0,
+                                "value": "test.sol:L"
+                            }
+                        ]
+                    }
+                },
+                "sourceList": [
+                    "test.sol",
+                    "#utility.yul"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": [
+                    "evm.bytecode",
+                    "evm.deployedBytecode"
+                ]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_link_references/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_link_references/output.json
new file mode 100644
index 00000000..864f65a5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_link_references/output.json
@@ -0,0 +1,43 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap": ""
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData": {},
+                        "immutableReferences": {},
+                        "linkReferences":
+                        {
+                            "test.sol":
+                            {
+                                "L":
+                                [
+                                    {
+                                        "length": 20,
+                                        "start": 1
+                                    }
+                                ]
+                            }
+                        },
+                        "object": "<BYTECODE REMOVED>__$d553ddd21b3d8da0d69a6510c170f4a77b$__<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/input.json
new file mode 100644
index 00000000..0a8a5988
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/input.json
@@ -0,0 +1,32 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "PUSH",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            },
+            "urls":
+            [
+                "bzzr://56ab..."
+            ]
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": ["evm.bytecode"]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/output.json
new file mode 100644
index 00000000..2a075efd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_multiple_keys_inside_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "message": "Invalid input source specified. Expected exactly one object, named 'assemblyJson', inside $.sources.A",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/input.json b/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/input.json
new file mode 100644
index 00000000..1cd9c3c7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/input.json
@@ -0,0 +1,29 @@
+{
+    "language": "EVMAssembly",
+    "sources": {
+        "A": {
+            "assemblyJson": {
+                ".code": [
+                    {
+                        "begin": 36,
+                        "end": 51,
+                        "name": "PUSH",
+                        "source": 0,
+                        "value": "0"
+                    }
+                ],
+                "sourceList": [
+                    "<stdin>"
+                ]
+            }
+        }
+    },
+    "settings": {
+        "outputSelection": {
+            "*": {
+                "": [
+                ]
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/output.json b/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/output.json
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_import_evmasm_no_output_selection/output.json
@@ -0,0 +1 @@
+{}
diff --git a/compiler/test/cmdlineTests/standard_invalid_option_no_optimize_yul/err b/compiler/test/cmdlineTests/standard_invalid_option_no_optimize_yul/err
new file mode 100644
index 00000000..1205089d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_invalid_option_no_optimize_yul/err
@@ -0,0 +1 @@
+Error: Option --no-optimize-yul is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/standard_invalid_option_optimize/err b/compiler/test/cmdlineTests/standard_invalid_option_optimize/err
new file mode 100644
index 00000000..da724d56
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_invalid_option_optimize/err
@@ -0,0 +1 @@
+Error: Option --optimize is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/standard_invalid_option_optimize_runs/err b/compiler/test/cmdlineTests/standard_invalid_option_optimize_runs/err
new file mode 100644
index 00000000..a625ad49
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_invalid_option_optimize_runs/err
@@ -0,0 +1 @@
+Error: Option --optimize-runs is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/standard_invalid_option_optimize_yul/err b/compiler/test/cmdlineTests/standard_invalid_option_optimize_yul/err
new file mode 100644
index 00000000..6d3a9306
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_invalid_option_optimize_yul/err
@@ -0,0 +1 @@
+Error: Option --optimize-yul is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/standard_invalid_option_yul_optimizations/err b/compiler/test/cmdlineTests/standard_invalid_option_yul_optimizations/err
new file mode 100644
index 00000000..f0db47ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_invalid_option_yul_optimizations/err
@@ -0,0 +1 @@
+Error: Option --yul-optimizations is only valid in compiler and assembler modes.
diff --git a/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/in.sol b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/in.sol
new file mode 100644
index 00000000..a3a86cc8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/in.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/input.json b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/input.json
new file mode 100644
index 00000000..fd169830
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_irOptimized_ast_requested/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {"*": {"*": ["irOptimizedAst"]}}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/output.json b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/output.json
new file mode 100644
index 00000000..200b653f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_irOptimized_ast_requested/output.json
@@ -0,0 +1,571 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "irOptimizedAst":
+                {
+                    "code":
+                    {
+                        "block":
+                        {
+                            "nativeSrc": "44:790:0",
+                            "nodeType": "YulBlock",
+                            "src": "-1:-1:0",
+                            "statements":
+                            [
+                                {
+                                    "nativeSrc": "44:790:0",
+                                    "nodeType": "YulBlock",
+                                    "src": "-1:-1:0",
+                                    "statements":
+                                    [
+                                        {
+                                            "expression":
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "kind": "number",
+                                                        "nativeSrc": "103:2:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "64"
+                                                    },
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "kind": "number",
+                                                                "nativeSrc": "119:3:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "0x80"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "memoryguard",
+                                                            "nativeSrc": "107:11:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "107:16:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "mstore",
+                                                    "nativeSrc": "96:6:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "96:28:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "96:28:0",
+                                            "nodeType": "YulExpressionStatement",
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "148:83:0",
+                                                "nodeType": "YulBlock",
+                                                "src": "56:13:0",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments": [],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                                                                "nativeSrc": "150:77:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            },
+                                                            "nativeSrc": "150:79:0",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "150:79:0",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ]
+                                            },
+                                            "condition":
+                                            {
+                                                "arguments": [],
+                                                "functionName":
+                                                {
+                                                    "name": "callvalue",
+                                                    "nativeSrc": "136:9:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "136:11:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "133:98:0",
+                                            "nodeType": "YulIf",
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "nativeSrc": "268:30:0",
+                                            "nodeType": "YulVariableDeclaration",
+                                            "src": "56:13:0",
+                                            "value":
+                                            {
+                                                "arguments": [],
+                                                "functionName":
+                                                {
+                                                    "name": "allocate_unbounded",
+                                                    "nativeSrc": "278:18:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "278:20:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "variables":
+                                            [
+                                                {
+                                                    "name": "_1",
+                                                    "nativeSrc": "272:2:0",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "56:13:0",
+                                                    "type": ""
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "expression":
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "name": "_1",
+                                                        "nativeSrc": "316:2:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "hexValue": "435f325f6465706c6f796564",
+                                                                "kind": "string",
+                                                                "nativeSrc": "331:14:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "C_2_deployed"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "dataoffset",
+                                                            "nativeSrc": "320:10:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "320:26:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "hexValue": "435f325f6465706c6f796564",
+                                                                "kind": "string",
+                                                                "nativeSrc": "357:14:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "C_2_deployed"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "datasize",
+                                                            "nativeSrc": "348:8:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "348:24:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "codecopy",
+                                                    "nativeSrc": "307:8:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "307:66:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "307:66:0",
+                                            "nodeType": "YulExpressionStatement",
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "expression":
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "name": "_1",
+                                                        "nativeSrc": "390:2:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "hexValue": "435f325f6465706c6f796564",
+                                                                "kind": "string",
+                                                                "nativeSrc": "403:14:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "C_2_deployed"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "datasize",
+                                                            "nativeSrc": "394:8:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "394:24:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "return",
+                                                    "nativeSrc": "383:6:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "383:36:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "383:36:0",
+                                            "nodeType": "YulExpressionStatement",
+                                            "src": "56:13:0"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "469:43:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements":
+                                        [
+                                            {
+                                                "nativeSrc": "483:19:0",
+                                                "nodeType": "YulAssignment",
+                                                "src": "56:13:0",
+                                                "value":
+                                                {
+                                                    "arguments":
+                                                    [
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "499:2:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "64"
+                                                        }
+                                                    ],
+                                                    "functionName":
+                                                    {
+                                                        "name": "mload",
+                                                        "nativeSrc": "493:5:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "493:9:0",
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "56:13:0"
+                                                },
+                                                "variableNames":
+                                                [
+                                                    {
+                                                        "name": "memPtr",
+                                                        "nativeSrc": "483:6:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "name": "allocate_unbounded",
+                                    "nativeSrc": "429:83:0",
+                                    "nodeType": "YulFunctionDefinition",
+                                    "returnVariables":
+                                    [
+                                        {
+                                            "name": "memPtr",
+                                            "nativeSrc": "462:6:0",
+                                            "nodeType": "YulTypedName",
+                                            "src": "56:13:0",
+                                            "type": ""
+                                        }
+                                    ],
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "611:36:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements":
+                                        [
+                                            {
+                                                "expression":
+                                                {
+                                                    "arguments":
+                                                    [
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "632:1:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "635:1:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        }
+                                                    ],
+                                                    "functionName":
+                                                    {
+                                                        "name": "revert",
+                                                        "nativeSrc": "625:6:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "625:12:0",
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "625:12:0",
+                                                "nodeType": "YulExpressionStatement",
+                                                "src": "56:13:0"
+                                            }
+                                        ]
+                                    },
+                                    "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                                    "nativeSrc": "522:125:0",
+                                    "nodeType": "YulFunctionDefinition",
+                                    "src": "56:13:0"
+                                }
+                            ]
+                        },
+                        "nodeType": "YulCode"
+                    },
+                    "name": "C_2",
+                    "nodeType": "YulObject",
+                    "subObjects":
+                    [
+                        {
+                            "code":
+                            {
+                                "block":
+                                {
+                                    "nativeSrc": "899:588:0",
+                                    "nodeType": "YulBlock",
+                                    "src": "-1:-1:0",
+                                    "statements":
+                                    [
+                                        {
+                                            "nativeSrc": "899:588:0",
+                                            "nodeType": "YulBlock",
+                                            "src": "-1:-1:0",
+                                            "statements":
+                                            [
+                                                {
+                                                    "expression":
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "kind": "number",
+                                                                "nativeSrc": "966:2:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "64"
+                                                            },
+                                                            {
+                                                                "arguments":
+                                                                [
+                                                                    {
+                                                                        "kind": "number",
+                                                                        "nativeSrc": "982:3:0",
+                                                                        "nodeType": "YulLiteral",
+                                                                        "src": "56:13:0",
+                                                                        "type": "",
+                                                                        "value": "0x80"
+                                                                    }
+                                                                ],
+                                                                "functionName":
+                                                                {
+                                                                    "name": "memoryguard",
+                                                                    "nativeSrc": "970:11:0",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "56:13:0"
+                                                                },
+                                                                "nativeSrc": "970:16:0",
+                                                                "nodeType": "YulFunctionCall",
+                                                                "src": "56:13:0"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "mstore",
+                                                            "nativeSrc": "959:6:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "959:28:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "959:28:0",
+                                                    "nodeType": "YulExpressionStatement",
+                                                    "src": "56:13:0"
+                                                },
+                                                {
+                                                    "expression":
+                                                    {
+                                                        "arguments": [],
+                                                        "functionName":
+                                                        {
+                                                            "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                                                            "nativeSrc": "1001:77:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "1001:79:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "1001:79:0",
+                                                    "nodeType": "YulExpressionStatement",
+                                                    "src": "56:13:0"
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1432:44:0",
+                                                "nodeType": "YulBlock",
+                                                "src": "56:13:0",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1457:1:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1460:1:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "1450:6:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            },
+                                                            "nativeSrc": "1450:12:0",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "1450:12:0",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                                            "nativeSrc": "1343:133:0",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "56:13:0"
+                                        }
+                                    ]
+                                },
+                                "nodeType": "YulCode"
+                            },
+                            "name": "C_2_deployed",
+                            "nodeType": "YulObject",
+                            "subObjects":
+                            [
+                                {
+                                    "nodeType": "YulData",
+                                    "value": "<BYTECODE REMOVED>"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_irOptimized_requested/output.json b/compiler/test/cmdlineTests/standard_irOptimized_requested/output.json
new file mode 100644
index 00000000..88ce6489
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_irOptimized_requested/output.json
@@ -0,0 +1,87 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "irOptimized": "/// @use-src 0:\"A\"
+object \"C_7\" {
+    code {
+        {
+            /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+            mstore(64, memoryguard(0x80))
+            if callvalue()
+            {
+                revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            }
+            let _1 := allocate_unbounded()
+            codecopy(_1, dataoffset(\"C_7_deployed\"), datasize(\"C_7_deployed\"))
+            return(_1, datasize(\"C_7_deployed\"))
+        }
+        function allocate_unbounded() -> memPtr
+        { memPtr := mload(64) }
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+        { revert(0, 0) }
+    }
+    /// @use-src 0:\"A\"
+    object \"C_7_deployed\" {
+        code {
+            {
+                /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+                mstore(64, memoryguard(0x80))
+                if iszero(lt(calldatasize(), 4))
+                {
+                    let selector := shift_right_unsigned(calldataload(0))
+                    switch selector
+                    case 0x26121ff0 { external_fun_f() }
+                    default { }
+                }
+                revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            }
+            function shift_right_unsigned(value) -> newValue
+            { newValue := shr(224, value) }
+            function allocate_unbounded() -> memPtr
+            { memPtr := mload(64) }
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            { revert(0, 0) }
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+            { revert(0, 0) }
+            function abi_decode(headStart, dataEnd)
+            {
+                if slt(sub(dataEnd, headStart), 0)
+                {
+                    revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+                }
+            }
+            function abi_encode_tuple(headStart) -> tail
+            { tail := add(headStart, 0) }
+            function external_fun_f()
+            {
+                if callvalue()
+                {
+                    revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+                }
+                abi_decode(4, calldatasize())
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple(memPos)
+                return(memPos, sub(memEnd, memPos))
+            }
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            { revert(0, 0) }
+        }
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_ir_ast_requested/in.sol b/compiler/test/cmdlineTests/standard_ir_ast_requested/in.sol
new file mode 100644
index 00000000..a3a86cc8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_ir_ast_requested/in.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/standard_ir_ast_requested/input.json b/compiler/test/cmdlineTests/standard_ir_ast_requested/input.json
new file mode 100644
index 00000000..1cb1083a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_ir_ast_requested/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_ir_ast_requested/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {"*": {"*": ["irAst"]}}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_ir_ast_requested/output.json b/compiler/test/cmdlineTests/standard_ir_ast_requested/output.json
new file mode 100644
index 00000000..f949d7b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_ir_ast_requested/output.json
@@ -0,0 +1,729 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "irAst":
+                {
+                    "code":
+                    {
+                        "block":
+                        {
+                            "nativeSrc": "44:790:0",
+                            "nodeType": "YulBlock",
+                            "src": "-1:-1:0",
+                            "statements":
+                            [
+                                {
+                                    "expression":
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "kind": "number",
+                                                "nativeSrc": "103:2:0",
+                                                "nodeType": "YulLiteral",
+                                                "src": "56:13:0",
+                                                "type": "",
+                                                "value": "64"
+                                            },
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "kind": "number",
+                                                        "nativeSrc": "119:3:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "128"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "memoryguard",
+                                                    "nativeSrc": "107:11:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "107:16:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "mstore",
+                                            "nativeSrc": "96:6:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "96:28:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "nativeSrc": "96:28:0",
+                                    "nodeType": "YulExpressionStatement",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "148:83:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements":
+                                        [
+                                            {
+                                                "expression":
+                                                {
+                                                    "arguments": [],
+                                                    "functionName":
+                                                    {
+                                                        "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                                                        "nativeSrc": "150:77:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "150:79:0",
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "150:79:0",
+                                                "nodeType": "YulExpressionStatement",
+                                                "src": "56:13:0"
+                                            }
+                                        ]
+                                    },
+                                    "condition":
+                                    {
+                                        "arguments": [],
+                                        "functionName":
+                                        {
+                                            "name": "callvalue",
+                                            "nativeSrc": "136:9:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "136:11:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "nativeSrc": "133:98:0",
+                                    "nodeType": "YulIf",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "expression":
+                                    {
+                                        "arguments": [],
+                                        "functionName":
+                                        {
+                                            "name": "constructor_C_2",
+                                            "nativeSrc": "241:15:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "241:17:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "nativeSrc": "241:17:0",
+                                    "nodeType": "YulExpressionStatement",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "nativeSrc": "268:30:0",
+                                    "nodeType": "YulVariableDeclaration",
+                                    "src": "56:13:0",
+                                    "value":
+                                    {
+                                        "arguments": [],
+                                        "functionName":
+                                        {
+                                            "name": "allocate_unbounded",
+                                            "nativeSrc": "278:18:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "278:20:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "variables":
+                                    [
+                                        {
+                                            "name": "_1",
+                                            "nativeSrc": "272:2:0",
+                                            "nodeType": "YulTypedName",
+                                            "src": "56:13:0",
+                                            "type": ""
+                                        }
+                                    ]
+                                },
+                                {
+                                    "expression":
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "name": "_1",
+                                                "nativeSrc": "316:2:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "56:13:0"
+                                            },
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "hexValue": "435f325f6465706c6f796564",
+                                                        "kind": "string",
+                                                        "nativeSrc": "331:14:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "C_2_deployed"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "dataoffset",
+                                                    "nativeSrc": "320:10:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "320:26:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "hexValue": "435f325f6465706c6f796564",
+                                                        "kind": "string",
+                                                        "nativeSrc": "357:14:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "C_2_deployed"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "datasize",
+                                                    "nativeSrc": "348:8:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "348:24:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "codecopy",
+                                            "nativeSrc": "307:8:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "307:66:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "nativeSrc": "307:66:0",
+                                    "nodeType": "YulExpressionStatement",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "expression":
+                                    {
+                                        "arguments":
+                                        [
+                                            {
+                                                "name": "_1",
+                                                "nativeSrc": "390:2:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "56:13:0"
+                                            },
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "hexValue": "435f325f6465706c6f796564",
+                                                        "kind": "string",
+                                                        "nativeSrc": "403:14:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "C_2_deployed"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "datasize",
+                                                    "nativeSrc": "394:8:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "394:24:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            }
+                                        ],
+                                        "functionName":
+                                        {
+                                            "name": "return",
+                                            "nativeSrc": "383:6:0",
+                                            "nodeType": "YulIdentifier",
+                                            "src": "56:13:0"
+                                        },
+                                        "nativeSrc": "383:36:0",
+                                        "nodeType": "YulFunctionCall",
+                                        "src": "56:13:0"
+                                    },
+                                    "nativeSrc": "383:36:0",
+                                    "nodeType": "YulExpressionStatement",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "469:43:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements":
+                                        [
+                                            {
+                                                "nativeSrc": "483:19:0",
+                                                "nodeType": "YulAssignment",
+                                                "src": "56:13:0",
+                                                "value":
+                                                {
+                                                    "arguments":
+                                                    [
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "499:2:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "64"
+                                                        }
+                                                    ],
+                                                    "functionName":
+                                                    {
+                                                        "name": "mload",
+                                                        "nativeSrc": "493:5:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "493:9:0",
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "56:13:0"
+                                                },
+                                                "variableNames":
+                                                [
+                                                    {
+                                                        "name": "memPtr",
+                                                        "nativeSrc": "483:6:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    },
+                                    "name": "allocate_unbounded",
+                                    "nativeSrc": "429:83:0",
+                                    "nodeType": "YulFunctionDefinition",
+                                    "returnVariables":
+                                    [
+                                        {
+                                            "name": "memPtr",
+                                            "nativeSrc": "462:6:0",
+                                            "nodeType": "YulTypedName",
+                                            "src": "56:13:0",
+                                            "type": ""
+                                        }
+                                    ],
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "611:36:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements":
+                                        [
+                                            {
+                                                "expression":
+                                                {
+                                                    "arguments":
+                                                    [
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "632:1:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        },
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "635:1:0",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "56:13:0",
+                                                            "type": "",
+                                                            "value": "0"
+                                                        }
+                                                    ],
+                                                    "functionName":
+                                                    {
+                                                        "name": "revert",
+                                                        "nativeSrc": "625:6:0",
+                                                        "nodeType": "YulIdentifier",
+                                                        "src": "56:13:0"
+                                                    },
+                                                    "nativeSrc": "625:12:0",
+                                                    "nodeType": "YulFunctionCall",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "625:12:0",
+                                                "nodeType": "YulExpressionStatement",
+                                                "src": "56:13:0"
+                                            }
+                                        ]
+                                    },
+                                    "name": "revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb",
+                                    "nativeSrc": "522:125:0",
+                                    "nodeType": "YulFunctionDefinition",
+                                    "src": "56:13:0"
+                                },
+                                {
+                                    "body":
+                                    {
+                                        "nativeSrc": "726:59:0",
+                                        "nodeType": "YulBlock",
+                                        "src": "56:13:0",
+                                        "statements": []
+                                    },
+                                    "name": "constructor_C_2",
+                                    "nativeSrc": "699:86:0",
+                                    "nodeType": "YulFunctionDefinition",
+                                    "src": "56:13:0"
+                                }
+                            ]
+                        },
+                        "nodeType": "YulCode"
+                    },
+                    "name": "C_2",
+                    "nodeType": "YulObject",
+                    "subObjects":
+                    [
+                        {
+                            "code":
+                            {
+                                "block":
+                                {
+                                    "nativeSrc": "899:588:0",
+                                    "nodeType": "YulBlock",
+                                    "src": "-1:-1:0",
+                                    "statements":
+                                    [
+                                        {
+                                            "expression":
+                                            {
+                                                "arguments":
+                                                [
+                                                    {
+                                                        "kind": "number",
+                                                        "nativeSrc": "966:2:0",
+                                                        "nodeType": "YulLiteral",
+                                                        "src": "56:13:0",
+                                                        "type": "",
+                                                        "value": "64"
+                                                    },
+                                                    {
+                                                        "arguments":
+                                                        [
+                                                            {
+                                                                "kind": "number",
+                                                                "nativeSrc": "982:3:0",
+                                                                "nodeType": "YulLiteral",
+                                                                "src": "56:13:0",
+                                                                "type": "",
+                                                                "value": "128"
+                                                            }
+                                                        ],
+                                                        "functionName":
+                                                        {
+                                                            "name": "memoryguard",
+                                                            "nativeSrc": "970:11:0",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "970:16:0",
+                                                        "nodeType": "YulFunctionCall",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ],
+                                                "functionName":
+                                                {
+                                                    "name": "mstore",
+                                                    "nativeSrc": "959:6:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "959:28:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "959:28:0",
+                                            "nodeType": "YulExpressionStatement",
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "expression":
+                                            {
+                                                "arguments": [],
+                                                "functionName":
+                                                {
+                                                    "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                                                    "nativeSrc": "1001:77:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "56:13:0"
+                                                },
+                                                "nativeSrc": "1001:79:0",
+                                                "nodeType": "YulFunctionCall",
+                                                "src": "56:13:0"
+                                            },
+                                            "nativeSrc": "1001:79:0",
+                                            "nodeType": "YulExpressionStatement",
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1147:77:0",
+                                                "nodeType": "YulBlock",
+                                                "src": "56:13:0",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1165:44:0",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "56:13:0",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1198:3:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "224"
+                                                                },
+                                                                {
+                                                                    "name": "value",
+                                                                    "nativeSrc": "1203:5:0",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "56:13:0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "shr",
+                                                                "nativeSrc": "1194:3:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            },
+                                                            "nativeSrc": "1194:15:0",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "newValue",
+                                                                "nativeSrc": "1165:8:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "shift_right_224_unsigned",
+                                            "nativeSrc": "1094:130:0",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "value",
+                                                    "nativeSrc": "1128:5:0",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "56:13:0",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "newValue",
+                                                    "nativeSrc": "1138:8:0",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "56:13:0",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1278:51:0",
+                                                "nodeType": "YulBlock",
+                                                "src": "56:13:0",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1296:19:0",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "56:13:0",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1312:2:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "64"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mload",
+                                                                "nativeSrc": "1306:5:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            },
+                                                            "nativeSrc": "1306:9:0",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "memPtr",
+                                                                "nativeSrc": "1296:6:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "allocate_unbounded",
+                                            "nativeSrc": "1238:91:0",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "memPtr",
+                                                    "nativeSrc": "1271:6:0",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "56:13:0",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "56:13:0"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1432:44:0",
+                                                "nodeType": "YulBlock",
+                                                "src": "56:13:0",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1457:1:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1460:1:0",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "56:13:0",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "1450:6:0",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:13:0"
+                                                            },
+                                                            "nativeSrc": "1450:12:0",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:13:0"
+                                                        },
+                                                        "nativeSrc": "1450:12:0",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "56:13:0"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74",
+                                            "nativeSrc": "1343:133:0",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "56:13:0"
+                                        }
+                                    ]
+                                },
+                                "nodeType": "YulCode"
+                            },
+                            "name": "C_2_deployed",
+                            "nodeType": "YulObject",
+                            "subObjects":
+                            [
+                                {
+                                    "nodeType": "YulData",
+                                    "value": "<BYTECODE REMOVED>"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_ir_requested/output.json b/compiler/test/cmdlineTests/standard_ir_requested/output.json
new file mode 100644
index 00000000..ab38f0a5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_ir_requested/output.json
@@ -0,0 +1,132 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_7\" {
+    code {
+        /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_7()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_7_deployed\"), datasize(\"C_7_deployed\"))
+
+        return(_1, datasize(\"C_7_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+        function constructor_C_7() {
+
+            /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+
+        }
+        /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_7_deployed\" {
+        code {
+            /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_6()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_6() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_6()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            /// @ast-id 6
+            /// @src 0:92:119  \"function f() public pure {}\"
+            function fun_f_6() {
+
+            }
+            /// @src 0:79:121  \"contract C { function f() public pure {} }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_json_no_pretty_print/no-pretty-print b/compiler/test/cmdlineTests/standard_json_no_pretty_print/no-pretty-print
new file mode 100644
index 00000000..e69de29b
diff --git a/compiler/test/cmdlineTests/standard_metadata/args b/compiler/test/cmdlineTests/standard_metadata/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_metadata/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_metadata/in.sol b/compiler/test/cmdlineTests/standard_metadata/in.sol
new file mode 100644
index 00000000..a3a86cc8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_metadata/in.sol
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/standard_metadata/input.json b/compiler/test/cmdlineTests/standard_metadata/input.json
new file mode 100644
index 00000000..ae4bfe8f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_metadata/input.json
@@ -0,0 +1,11 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_metadata/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {"*": ["metadata"]}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_metadata/output.json b/compiler/test/cmdlineTests/standard_metadata/output.json
new file mode 100644
index 00000000..44294666
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_metadata/output.json
@@ -0,0 +1,19 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "metadata": "{\"compiler\":{\"version\":\"<VERSION REMOVED>\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"C\":\"C\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"C\":{\"keccak256\":\"0x5cf617b1707a484e3c4bd59643013dec76ab7d75900b46855214729ae3e0ceb0\",\"license\":\"GPL-3.0\",\"urls\":[\"bzz-raw://ac418a02dfadf87234150d3568f33269e3f49460345cb39300e017a6d755eff2\",\"dweb:/ipfs/QmQq3owBu25x2WV46HB1WyKzJpxiAPecU7eMKqtXCF7eeS\"]}},\"version\":1}"
+            }
+        }
+    },
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_method_identifiers_requested/output.json b/compiler/test/cmdlineTests/standard_method_identifiers_requested/output.json
new file mode 100644
index 00000000..35d4f500
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_method_identifiers_requested/output.json
@@ -0,0 +1,25 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "methodIdentifiers":
+                    {
+                        "f()": "26121ff0"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_method_identifiers_requested_empty/output.json b/compiler/test/cmdlineTests/standard_method_identifiers_requested_empty/output.json
new file mode 100644
index 00000000..f90a3335
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_method_identifiers_requested_empty/output.json
@@ -0,0 +1,22 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "methodIdentifiers": {}
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_missing_key_useLiteralContent/output.json b/compiler/test/cmdlineTests/standard_missing_key_useLiteralContent/output.json
new file mode 100644
index 00000000..f3a09c9e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_missing_key_useLiteralContent/output.json
@@ -0,0 +1,19 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "message": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/input.json b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/input.json
new file mode 100644
index 00000000..e7d2d09b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/input.json
@@ -0,0 +1,29 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"Source":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0
+			pragma solidity >=0.0;
+			contract C
+			{
+				function f(uint x) public pure {
+					require(x == 0);
+					do {
+						++x;
+					} while (x < 2);
+					assert(x == 2);
+				}
+			}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+            "bmcLoopIterations": 3
+		}
+	}
+}
\ No newline at end of file
diff --git a/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/output.json b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/output.json
new file mode 100644
index 00000000..139b0825
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/input.json b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/input.json
new file mode 100644
index 00000000..8c5fa65c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/input.json
@@ -0,0 +1,29 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"Source":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0
+			pragma solidity >=0.0;
+			contract C
+			{
+				function f(uint x) public pure {
+					require(x == 0);
+					do {
+						++x;
+					} while (x < 2);
+					assert(x == 2);
+				}
+			}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+            "bmcLoopIterations": "bmc"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/output.json b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/output.json
new file mode 100644
index 00000000..971973d8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_bmc_loop_iterations_invalid_arg/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.bmcLoopIterations must be an unsigned integer.",
+            "message": "settings.modelChecker.bmcLoopIterations must be an unsigned integer.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_all/output.json
new file mode 100644
index 00000000..b4bfd66b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_all/output.json
@@ -0,0 +1,80 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)
+ --> Source:5:7:
+  |
+5 | \t\t\t\t\t\tassert(y > 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 137,
+                "file": "Source",
+                "start": 124
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)
+  --> Source:10:7:
+   |
+10 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 231,
+                "file": "Source",
+                "start": 218
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_all_explicit/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_all_explicit/output.json
new file mode 100644
index 00000000..b4bfd66b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_all_explicit/output.json
@@ -0,0 +1,80 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)
+ --> Source:5:7:
+  |
+5 | \t\t\t\t\t\tassert(y > 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 137,
+                "file": "Source",
+                "start": 124
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)
+  --> Source:10:7:
+   |
+10 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 231,
+                "file": "Source",
+                "start": 218
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_array/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_array/output.json
new file mode 100644
index 00000000..ada440ad
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_array/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Source contracts must be a non-empty array.",
+            "message": "Source contracts must be a non-empty array.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_contract/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_contract/output.json
new file mode 100644
index 00000000..c3b171e9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_contract/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Contract name cannot be empty.",
+            "message": "Contract name cannot be empty.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_source/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_source/output.json
new file mode 100644
index 00000000..98dcc1af
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_empty_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Source name cannot be empty.",
+            "message": "Source name cannot be empty.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_inexistent_contract/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_inexistent_contract/output.json
new file mode 100644
index 00000000..7ff30950
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_inexistent_contract/output.json
@@ -0,0 +1,90 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7400",
+            "formattedMessage": "Warning: Requested contract \"C\" does not exist in source \"Source\".
+
+",
+            "message": "Requested contract \"C\" does not exist in source \"Source\".",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)
+ --> Source:5:7:
+  |
+5 | \t\t\t\t\t\tassert(y > 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 137,
+                "file": "Source",
+                "start": 124
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)
+  --> Source:10:7:
+   |
+10 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 231,
+                "file": "Source",
+                "start": 218
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_multi_source/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_multi_source/output.json
new file mode 100644
index 00000000..cb18875e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_multi_source/output.json
@@ -0,0 +1,118 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)
+ --> Source:5:7:
+  |
+5 | \t\t\t\t\t\tassert(y > 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 137,
+                "file": "Source",
+                "start": 124
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)
+  --> Source:10:7:
+   |
+10 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 231,
+                "file": "Source",
+                "start": 218
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+z = 0
+
+Transaction trace:
+C.constructor()
+C.h(0)
+ --> Source2:6:7:
+  |
+6 | \t\t\t\t\t\tassert(z > 100);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+z = 0
+
+Transaction trace:
+C.constructor()
+C.h(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 165,
+                "file": "Source2",
+                "start": 150
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        },
+        "Source2":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_only_one/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_only_one/output.json
new file mode 100644
index 00000000..b4bfd66b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_only_one/output.json
@@ -0,0 +1,80 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)
+ --> Source:5:7:
+  |
+5 | \t\t\t\t\t\tassert(y > 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+y = 0
+
+Transaction trace:
+B.constructor()
+B.g(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 137,
+                "file": "Source",
+                "start": 124
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)
+  --> Source:10:7:
+   |
+10 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+A.constructor()
+A.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 231,
+                "file": "Source",
+                "start": 218
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources/output.json
new file mode 100644
index 00000000..d38ad1b5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "9134",
+            "formattedMessage": "Warning: Requested source \"Sourceee\" does not exist.
+
+",
+            "message": "Requested source \"Sourceee\" does not exist.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "Source":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_2/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_2/output.json
new file mode 100644
index 00000000..98365d1b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_2/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.contracts is not a JSON object.",
+            "message": "settings.modelChecker.contracts is not a JSON object.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_3/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_3/output.json
new file mode 100644
index 00000000..567db80a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_3/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Source contracts must be an array.",
+            "message": "Source contracts must be an array.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_4/output.json b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_4/output.json
new file mode 100644
index 00000000..30d4c2dc
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_contracts_wrong_key_sources_4/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Every contract in settings.modelChecker.contracts must be a string.",
+            "message": "Every contract in settings.modelChecker.contracts must be a string.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_all/output.json
new file mode 100644
index 00000000..b8637143
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_all/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_bmc/output.json
new file mode 100644
index 00000000..a6ce9b3c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_bmc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_chc/output.json
new file mode 100644
index 00000000..b8637143
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_default_chc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_all/output.json
new file mode 100644
index 00000000..f7ecf690
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_all/output.json
@@ -0,0 +1,72 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1218",
+            "formattedMessage": "Warning: CHC: Error trying to invoke SMT solver.
+ --> A:7:15:
+  |
+7 | \t\t\t\t\t\treturn (a / b, a % b);
+  | \t\t\t\t\t\t        ^^^^^
+
+",
+            "message": "CHC: Error trying to invoke SMT solver.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 182,
+                "file": "A",
+                "start": 177
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1218",
+            "formattedMessage": "Warning: CHC: Error trying to invoke SMT solver.
+ --> A:7:22:
+  |
+7 | \t\t\t\t\t\treturn (a / b, a % b);
+  | \t\t\t\t\t\t               ^^^^^
+
+",
+            "message": "CHC: Error trying to invoke SMT solver.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 189,
+                "file": "A",
+                "start": 184
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 2 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 2 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_bmc/output.json
new file mode 100644
index 00000000..a6ce9b3c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_bmc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_chc/output.json
new file mode 100644
index 00000000..fccd1583
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_false_chc/output.json
@@ -0,0 +1,62 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1218",
+            "formattedMessage": "Warning: CHC: Error trying to invoke SMT solver.
+ --> A:7:15:
+  |
+7 | \t\t\t\t\t\treturn (a / b, a % b);
+  | \t\t\t\t\t\t        ^^^^^
+
+",
+            "message": "CHC: Error trying to invoke SMT solver.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 182,
+                "file": "A",
+                "start": 177
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1218",
+            "formattedMessage": "Warning: CHC: Error trying to invoke SMT solver.
+ --> A:7:22:
+  |
+7 | \t\t\t\t\t\treturn (a / b, a % b);
+  | \t\t\t\t\t\t               ^^^^^
+
+",
+            "message": "CHC: Error trying to invoke SMT solver.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 189,
+                "file": "A",
+                "start": 184
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 2 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 2 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_wrong/output.json b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_wrong/output.json
new file mode 100644
index 00000000..457fb1ba
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_divModSlacks_wrong/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.divModNoSlacks must be a Boolean.",
+            "message": "settings.modelChecker.divModNoSlacks must be a Boolean.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_engine_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_engine_all/output.json
new file mode 100644
index 00000000..2a2c394f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_engine_all/output.json
@@ -0,0 +1,46 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)
+ --> A:4:47:
+  |
+4 | contract C { function f(uint x) public pure { assert(x > 0); } }
+  |                                               ^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 119,
+                "file": "A",
+                "start": 106
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_engine_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_engine_bmc/output.json
new file mode 100644
index 00000000..75e679ef
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_engine_bmc/output.json
@@ -0,0 +1,51 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4661",
+            "formattedMessage": "Warning: BMC: Assertion violation happens here.
+ --> A:4:47:
+  |
+4 | contract C { function f(uint x) public pure { assert(x > 0); } }
+  |                                               ^^^^^^^^^^^^^
+Note: Counterexample:
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Assertion violation happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 119,
+                "file": "A",
+                "start": 106
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_engine_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_engine_chc/output.json
new file mode 100644
index 00000000..2a2c394f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_engine_chc/output.json
@@ -0,0 +1,46 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)
+ --> A:4:47:
+  |
+4 | contract C { function f(uint x) public pure { assert(x > 0); } }
+  |                                               ^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 119,
+                "file": "A",
+                "start": 106
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_engine_none/output.json b/compiler/test/cmdlineTests/standard_model_checker_engine_none/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_engine_none/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/input.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/input.json
new file mode 100644
index 00000000..073516dd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/input.json
@@ -0,0 +1,30 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;
+					contract Ext {
+						function f() public view returns (uint) {
+							return 42;
+						}
+					}
+
+					contract test {
+						function g(Ext e) public view {
+							uint x = e.f();
+							assert(x == 42);
+						}
+					}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"extCalls": ""
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/output.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/output.json
new file mode 100644
index 00000000..4e214a37
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_empty_arg/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid model checker extCalls requested.",
+            "message": "Invalid model checker extCalls requested.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/input.json
new file mode 100644
index 00000000..a03b77f2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/input.json
@@ -0,0 +1,30 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;
+					contract Ext {
+						function f() public view returns (uint) {
+							return 42;
+						}
+					}
+
+					contract test {
+						function g(Ext e) public view {
+							uint x = e.f();
+							assert(x == 42);
+						}
+					}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"extCalls": "trusted"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/output.json
new file mode 100644
index 00000000..7f399341
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_trusted_chc/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:4:7:
+  |
+4 | \t\t\t\t\t\tfunction f() public view returns (uint) {
+  | \t\t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 152,
+                "file": "A",
+                "start": 85
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/input.json
new file mode 100644
index 00000000..9fadd08f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/input.json
@@ -0,0 +1,28 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;
+					abstract contract Ext {
+						function f() virtual public view returns (uint);
+					}
+
+					contract test {
+						function g(Ext e) public view {
+							uint x = e.f();
+							assert(x == 0);
+						}
+					}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"extCalls": "untrusted"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/output.json
new file mode 100644
index 00000000..c6b072a8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_untrusted_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+e = 0
+x = 1
+
+Transaction trace:
+test.constructor()
+test.g(0)
+    e.f() -- untrusted external call
+  --> A:10:8:
+   |
+10 | \t\t\t\t\t\t\tassert(x == 0);
+   | \t\t\t\t\t\t\t^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+e = 0
+x = 1
+
+Transaction trace:
+test.constructor()
+test.g(0)
+    e.f() -- untrusted external call",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 254,
+                "file": "A",
+                "start": 240
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/input.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/input.json
new file mode 100644
index 00000000..15113c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/input.json
@@ -0,0 +1,30 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;
+					contract Ext {
+						function f() public view returns (uint) {
+							return 42;
+						}
+					}
+
+					contract test {
+						function g(Ext e) public view {
+							uint x = e.f();
+							assert(x == 42);
+						}
+					}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"extCalls": "what"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/output.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/output.json
new file mode 100644
index 00000000..4e214a37
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_1/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid model checker extCalls requested.",
+            "message": "Invalid model checker extCalls requested.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/input.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/input.json
new file mode 100644
index 00000000..cda245e7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/input.json
@@ -0,0 +1,30 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;
+					contract Ext {
+						function f() public view returns (uint) {
+							return 42;
+						}
+					}
+
+					contract test {
+						function g(Ext e) public view {
+							uint x = e.f();
+							assert(x == 42);
+						}
+					}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"extCalls": 2
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/output.json b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/output.json
new file mode 100644
index 00000000..e869637e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_ext_calls_wrong_arg_2/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.extCalls must be a string.",
+            "message": "settings.modelChecker.extCalls must be a string.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_contract/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_contract/output.json
new file mode 100644
index 00000000..314b66aa
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_contract/output.json
@@ -0,0 +1,36 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "1180",
+            "formattedMessage": "Info: Contract invariant(s) for A:test:
+(!(x >= 1) || true)
+
+
+",
+            "message": "Contract invariant(s) for A:test:
+(!(x >= 1) || true)
+",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_contract_reentrancy/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_contract_reentrancy/output.json
new file mode 100644
index 00000000..5a83ba7a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_contract_reentrancy/output.json
@@ -0,0 +1,70 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "9302",
+            "formattedMessage": "Warning: Return value of low-level calls not used.
+ --> A:7:7:
+  |
+7 | \t\t\t\t\t\t_a.call(\"\");
+  | \t\t\t\t\t\t^^^^^^^^^^^
+
+",
+            "message": "Return value of low-level calls not used.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 143,
+                "file": "A",
+                "start": 132
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+x = 0
+_a = 0x0
+
+Transaction trace:
+test.constructor()
+State: x = 0
+test.f(0x0)
+    _a.call(\"\") -- untrusted external call
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\tassert(x == 10);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+x = 0
+_a = 0x0
+
+Transaction trace:
+test.constructor()
+State: x = 0
+test.f(0x0)
+    _a.call(\"\") -- untrusted external call",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 166,
+                "file": "A",
+                "start": 151
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_reentrancy/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_reentrancy/output.json
new file mode 100644
index 00000000..feb586a3
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_reentrancy/output.json
@@ -0,0 +1,60 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "9302",
+            "formattedMessage": "Warning: Return value of low-level calls not used.
+ --> A:7:7:
+  |
+7 | \t\t\t\t\t\t_a.call(\"\");
+  | \t\t\t\t\t\t^^^^^^^^^^^
+
+",
+            "message": "Return value of low-level calls not used.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 143,
+                "file": "A",
+                "start": 132
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 1 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "1180",
+            "formattedMessage": "Info: Reentrancy property(ies) for A:test:
+(((!(x <= 0) || !(x' >= 1)) && (!(x <= 0) || !(<errorCode> >= 1))) || true)
+<errorCode> = 0 -> no errors
+<errorCode> = 1 -> Assertion failed at assert(x < 10)
+
+
+",
+            "message": "Reentrancy property(ies) for A:test:
+(((!(x <= 0) || !(x' >= 1)) && (!(x <= 0) || !(<errorCode> >= 1))) || true)
+<errorCode> = 0 -> no errors
+<errorCode> = 1 -> Assertion failed at assert(x < 10)
+",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_key/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_key/output.json
new file mode 100644
index 00000000..45fcfbe9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_key/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid model checker invariants requested.",
+            "message": "Invalid model checker invariants requested.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type/output.json
new file mode 100644
index 00000000..d1992e46
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Every invariant type in settings.modelChecker.invariants must be a string.",
+            "message": "Every invariant type in settings.modelChecker.invariants must be a string.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type_2/output.json b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type_2/output.json
new file mode 100644
index 00000000..078edfc1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_invariants_wrong_type_2/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.invariants must be an array.",
+            "message": "settings.modelChecker.invariants must be an array.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_all/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_all/input.json
new file mode 100644
index 00000000..67fc5d8c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_all/input.json
@@ -0,0 +1,27 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+            "printQuery": true,
+			"solvers": ["smtlib2"],
+			"timeout": 1000
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_all/output.json
new file mode 100644
index 00000000..b8e11ced
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_all/output.json
@@ -0,0 +1,540 @@
+{
+    "auxiliaryInputRequested":
+    {
+        "smtlib2queries":
+        {
+            "0x1880095c52d8681601c6821e4a5c29740649509af99947bce54102546dd3376a": "(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+",
+            "0xcbfcc2413b217c6564ee01f322c9ca1f34fd79d19961dc3e62aa9c2e5dcb6efc": "(set-option :produce-models true)
+(set-option :timeout 1000)
+(set-logic ALL)
+(declare-fun |x_5_3| () Int)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_4| () Int)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+"
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2339",
+            "formattedMessage": "Info: CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+
+
+",
+            "message": "CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "3996",
+            "formattedMessage": "Warning: CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.
+
+",
+            "message": "CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6240",
+            "formattedMessage": "Info: BMC: Requested query:
+(set-option :produce-models true)
+(set-option :timeout 1000)
+(set-logic ALL)
+(declare-fun |x_5_3| () Int)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_4| () Int)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+
+
+",
+            "message": "BMC: Requested query:
+(set-option :produce-models true)
+(set-option :timeout 1000)
+(set-logic ALL)
+(declare-fun |x_5_3| () Int)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_4| () Int)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "8084",
+            "formattedMessage": "Warning: BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.
+
+",
+            "message": "BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/input.json
new file mode 100644
index 00000000..7957a58e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/input.json
@@ -0,0 +1,26 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+            "printQuery": true,
+			"solvers": ["smtlib2"]
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/output.json
new file mode 100644
index 00000000..f7b4dc7e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_bmc/output.json
@@ -0,0 +1,129 @@
+{
+    "auxiliaryInputRequested":
+    {
+        "smtlib2queries":
+        {
+            "0x8704a7b848b706ef33cbfc06e4f185636f568a29621126b7244355dd0de956bb": "(set-option :produce-models true)
+(set-logic ALL)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+"
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6240",
+            "formattedMessage": "Info: BMC: Requested query:
+(set-option :produce-models true)
+(set-logic ALL)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+
+
+",
+            "message": "BMC: Requested query:
+(set-option :produce-models true)
+(set-logic ALL)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_5_0| () Int)
+(declare-fun |expr_6_0| () Int)
+(declare-fun |x_5_1| () Int)
+(declare-fun |expr_9_0| () Int)
+(declare-fun |expr_10_0| () Int)
+(declare-fun |expr_11_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> (and true true) true) (and (= expr_10_0 0) (and (=> (and true true) (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_1) (and (ite (and true true) (= x_5_1 expr_6_0) (= x_5_1 x_5_0)) (and (=> (and true true) true) (and (= expr_6_0 0) (and (= x_5_0 0) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true))))))))))) (not expr_11_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_5_1))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "8084",
+            "formattedMessage": "Warning: BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.
+
+",
+            "message": "BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/input.json
new file mode 100644
index 00000000..d5801ef2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/input.json
@@ -0,0 +1,27 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+            "printQuery": true,
+			"solvers": ["smtlib2"],
+			"timeout": 1000
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/output.json
new file mode 100644
index 00000000..9ef925b2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_chc/output.json
@@ -0,0 +1,420 @@
+{
+    "auxiliaryInputRequested":
+    {
+        "smtlib2queries":
+        {
+            "0x1880095c52d8681601c6821e4a5c29740649509af99947bce54102546dd3376a": "(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+"
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2339",
+            "formattedMessage": "Info: CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+
+
+",
+            "message": "CHC: Requested query:
+(set-option :timeout 1000)
+(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_16_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_16_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_4_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (and (and (nondet_interface_1_C_16_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2))) (nondet_interface_1_C_16_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_6_f_14_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int))
+(=> (and (and (block_5_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true)) true) (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1))))
+
+
+(declare-fun |block_7_return_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true)))))))))) (and (and true (not expr_11_1)) (= error_1 1))) (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (block_8_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2) (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_6_f_14_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (= error_1 error_0) (and (= expr_11_1 (= expr_9_0 expr_10_0)) (and (=> true true) (and (= expr_10_0 0) (and (=> true (and (>= expr_9_0 0) (<= expr_9_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_9_0 x_5_2) (and (= x_5_2 expr_6_0) (and (=> true true) (and (= expr_6_0 0) (and (= x_5_1 0) true))))))))))) true) (block_7_return_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_7_return_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) true) true) (summary_3_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |block_9_function_f__15_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (block_9_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1 x_5_1) (and (summary_3_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 state_3) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 638722032)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 38)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 18)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 31)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 240)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true))))))) true) (summary_4_function_f__15_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_3))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_16_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_16_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (summary_constructor_2_C_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_16_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> (and (and (interface_0_C_16_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__15_16_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_10_0 Int) (expr_11_1 Bool) (expr_6_0 Int) (expr_9_0 Int) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_5_0 Int) (x_5_1 Int) (x_5_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "3996",
+            "formattedMessage": "Warning: CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.
+
+",
+            "message": "CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/input.json
new file mode 100644
index 00000000..97822c2b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/input.json
@@ -0,0 +1,25 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+            "printQuery": 17
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/output.json
new file mode 100644
index 00000000..00c389f7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_invalid_arg/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.printQuery must be a Boolean value.",
+            "message": "settings.modelChecker.printQuery must be a Boolean value.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/input.json
new file mode 100644
index 00000000..0159c256
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/input.json
@@ -0,0 +1,25 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+            "printQuery": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/output.json
new file mode 100644
index 00000000..42d4b5b2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_no_smtlib2_solver/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Only SMTLib2 solver can be enabled to print queries",
+            "message": "Only SMTLib2 solver can be enabled to print queries",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/input.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/input.json
new file mode 100644
index 00000000..9ebda001
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/input.json
@@ -0,0 +1,26 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n
+                contract C
+                {
+                    function f() public pure {
+                        uint x = 0;
+                        assert(x == 0);
+                    }
+                }"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+            "printQuery": true,
+            "solvers": ["smtlib2", "z3"]
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/output.json b/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/output.json
new file mode 100644
index 00000000..42d4b5b2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_print_query_superflous_solver/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Only SMTLib2 solver can be enabled to print queries",
+            "message": "Only SMTLib2 solver can be enabled to print queries",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/input.json
new file mode 100644
index 00000000..0d6db096
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/output.json
new file mode 100644
index 00000000..b8118ba1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_all_engines/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/input.json
new file mode 100644
index 00000000..e60b0231
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/output.json
new file mode 100644
index 00000000..eb6ed6e2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_bmc/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/input.json
new file mode 100644
index 00000000..9f3abdf5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/output.json
new file mode 100644
index 00000000..b8118ba1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_default_chc/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/input.json
new file mode 100644
index 00000000..37f4ce65
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showProvedSafe": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/output.json
new file mode 100644
index 00000000..b8118ba1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_all_engines/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/input.json
new file mode 100644
index 00000000..cc48fefd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+			"showProvedSafe": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/output.json
new file mode 100644
index 00000000..eb6ed6e2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_bmc/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/input.json
new file mode 100644
index 00000000..e8a47469
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"showProvedSafe": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/output.json
new file mode 100644
index 00000000..b8118ba1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_false_chc/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 2 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/input.json
new file mode 100644
index 00000000..baf5f619
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showProvedSafe": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/output.json
new file mode 100644
index 00000000..84822985
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_all_engines/output.json
@@ -0,0 +1,72 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "9576",
+            "formattedMessage": "Info: CHC: Assertion violation check is safe!
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassert(x >= 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 130,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "9576",
+            "formattedMessage": "Info: CHC: Assertion violation check is safe!
+ --> A:7:7:
+  |
+7 | \t\t\t\t\t\tassert(x < 1000);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 154,
+                "file": "A",
+                "start": 138
+            },
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/input.json
new file mode 100644
index 00000000..20948ed9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+			"showProvedSafe": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/output.json
new file mode 100644
index 00000000..20ddce1f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_bmc/output.json
@@ -0,0 +1,72 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2961",
+            "formattedMessage": "Info: BMC: Assertion violation check is safe!
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassert(x >= 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^
+
+",
+            "message": "BMC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 130,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "2961",
+            "formattedMessage": "Info: BMC: Assertion violation check is safe!
+ --> A:7:7:
+  |
+7 | \t\t\t\t\t\tassert(x < 1000);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^
+
+",
+            "message": "BMC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 154,
+                "file": "A",
+                "start": 138
+            },
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/input.json
new file mode 100644
index 00000000..5fb18aac
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"showProvedSafe": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/output.json
new file mode 100644
index 00000000..84822985
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_true_chc/output.json
@@ -0,0 +1,72 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2018",
+            "formattedMessage": "Warning: Function state mutability can be restricted to pure
+ --> A:5:6:
+  |
+5 | \t\t\t\t\tfunction f(uint8 x) public {
+  | \t\t\t\t\t^ (Relevant source part starts here and spans across multiple lines).
+
+",
+            "message": "Function state mutability can be restricted to pure",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 162,
+                "file": "A",
+                "start": 81
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "9576",
+            "formattedMessage": "Info: CHC: Assertion violation check is safe!
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassert(x >= 0);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 130,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "9576",
+            "formattedMessage": "Info: CHC: Assertion violation check is safe!
+ --> A:7:7:
+  |
+7 | \t\t\t\t\t\tassert(x < 1000);
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation check is safe!",
+            "severity": "info",
+            "sourceLocation":
+            {
+                "end": 154,
+                "file": "A",
+                "start": 138
+            },
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/input.json
new file mode 100644
index 00000000..eea83e14
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/input.json
@@ -0,0 +1,23 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f(uint8 x) public {
+						assert(x >= 0);
+						assert(x < 1000);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showProvedSafe": "aaa"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/output.json
new file mode 100644
index 00000000..7c8ccff6
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_proved_safe_wrong/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.showProvedSafe must be a Boolean value.",
+            "message": "settings.modelChecker.showProvedSafe must be a Boolean value.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_default_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_default_all_engines/output.json
new file mode 100644
index 00000000..fb599d21
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_default_all_engines/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_all_engines/output.json
new file mode 100644
index 00000000..fb599d21
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_all_engines/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_bmc/output.json
new file mode 100644
index 00000000..4554ec69
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_bmc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_chc/output.json
new file mode 100644
index 00000000..7f0e676c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_false_chc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_all_engines/output.json
new file mode 100644
index 00000000..ecb157f8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_all_engines/output.json
@@ -0,0 +1,59 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation might happen here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\tassert(s.x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation might happen here.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 201,
+                "file": "A",
+                "start": 186
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "7812",
+            "formattedMessage": "Warning: BMC: Assertion violation might happen here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\tassert(s.x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+Note:
+
+",
+            "message": "BMC: Assertion violation might happen here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 201,
+                "file": "A",
+                "start": 186
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_bmc/output.json
new file mode 100644
index 00000000..116af8dc
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_bmc/output.json
@@ -0,0 +1,39 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7812",
+            "formattedMessage": "Warning: BMC: Assertion violation might happen here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\tassert(s.x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+Note:
+
+",
+            "message": "BMC: Assertion violation might happen here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 201,
+                "file": "A",
+                "start": 186
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_chc/output.json
new file mode 100644
index 00000000..58956287
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_true_chc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation might happen here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\tassert(s.x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation might happen here.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 201,
+                "file": "A",
+                "start": 186
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unproved_wrong/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_wrong/output.json
new file mode 100644
index 00000000..a9342cdd
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unproved_wrong/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.showUnproved must be a Boolean value.",
+            "message": "settings.modelChecker.showUnproved must be a Boolean value.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/input.json
new file mode 100644
index 00000000..c307217c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/input.json
@@ -0,0 +1,21 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_all_engines/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/input.json
new file mode 100644
index 00000000..668a60e0
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/input.json
@@ -0,0 +1,21 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_bmc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/input.json
new file mode 100644
index 00000000..360235eb
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/input.json
@@ -0,0 +1,21 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_default_chc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/input.json
new file mode 100644
index 00000000..10092aa6
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showUnsupported": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/input.json
new file mode 100644
index 00000000..e3a42c29
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/input.json
@@ -0,0 +1,27 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					struct S {
+						uint x;
+					}
+					S s;
+					function f(bool b) public {
+						s.x |= b ? 1 : 2;
+						assert(s.x > 0);
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showUnsupported": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/output.json
new file mode 100644
index 00000000..fb599d21
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_all_engines/standard_model_checker_show_unsupported_false_all_enginesstandard_model_checker_show_unsupported_false_bmc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/input.json
new file mode 100644
index 00000000..7d15e6d7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+			"showUnsupported": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_bmc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/input.json
new file mode 100644
index 00000000..4d5a79c6
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"showUnsupported": false
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/output.json
new file mode 100644
index 00000000..23cf80de
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_false_chc/output.json
@@ -0,0 +1,22 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5724",
+            "formattedMessage": "Warning: SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.
+
+",
+            "message": "SMTChecker: 1 unsupported language feature(s). Enable the model checker option \"show unsupported\" to see all of them.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/input.json
new file mode 100644
index 00000000..c1fbeab1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showUnsupported": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/output.json
new file mode 100644
index 00000000..13d327d4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_all_engines/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7737",
+            "formattedMessage": "Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassembly {}
+  | \t\t\t\t\t\t^^^^^^^^^^^
+
+",
+            "message": "Inline assembly may cause SMTChecker to produce spurious warnings (false positives).",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 127,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/input.json
new file mode 100644
index 00000000..38e5cb7a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "bmc",
+			"showUnsupported": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/output.json
new file mode 100644
index 00000000..13d327d4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_bmc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7737",
+            "formattedMessage": "Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassembly {}
+  | \t\t\t\t\t\t^^^^^^^^^^^
+
+",
+            "message": "Inline assembly may cause SMTChecker to produce spurious warnings (false positives).",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 127,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/input.json
new file mode 100644
index 00000000..f84ca461
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "chc",
+			"showUnsupported": true
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/output.json
new file mode 100644
index 00000000..13d327d4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_true_chc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7737",
+            "formattedMessage": "Warning: Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+ --> A:6:7:
+  |
+6 | \t\t\t\t\t\tassembly {}
+  | \t\t\t\t\t\t^^^^^^^^^^^
+
+",
+            "message": "Inline assembly may cause SMTChecker to produce spurious warnings (false positives).",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 127,
+                "file": "A",
+                "start": 116
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/input.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/input.json
new file mode 100644
index 00000000..9fa8f5a5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/input.json
@@ -0,0 +1,22 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {
+					function f() external pure {
+						assembly {}
+					}
+				}"
+		}
+	},
+	"settings":
+	{
+		"modelChecker":
+		{
+			"engine": "all",
+			"showUnsupported": "aaa"
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/output.json b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/output.json
new file mode 100644
index 00000000..997b005e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_show_unsupported_wrong/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.showUnsupported must be a Boolean value.",
+            "message": "settings.modelChecker.showUnsupported must be a Boolean value.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_solvers_none/output.json b/compiler/test/cmdlineTests/standard_model_checker_solvers_none/output.json
new file mode 100644
index 00000000..e5d356ce
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_solvers_none/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7649",
+            "formattedMessage": "Warning: CHC analysis was not possible since no Horn solver was found and enabled. The accepted solvers for CHC are Eldarica and z3.
+
+",
+            "message": "CHC analysis was not possible since no Horn solver was found and enabled. The accepted solvers for CHC are Eldarica and z3.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "7710",
+            "formattedMessage": "Warning: BMC analysis was not possible since no SMT solver was found and enabled. The accepted solvers for BMC are cvc4 and z3.
+
+",
+            "message": "BMC analysis was not possible since no SMT solver was found and enabled. The accepted solvers for BMC are cvc4 and z3.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_solvers_smtlib2/output.json b/compiler/test/cmdlineTests/standard_model_checker_solvers_smtlib2/output.json
new file mode 100644
index 00000000..ebeca53f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_solvers_smtlib2/output.json
@@ -0,0 +1,208 @@
+{
+    "auxiliaryInputRequested":
+    {
+        "smtlib2queries":
+        {
+            "0x75b95497d56c30e254a59358d72ddd4e78f9e90db621cfe677e85d05b2252411": "(set-option :produce-models true)
+(set-logic ALL)
+(declare-fun |x_3_3| () Int)
+(declare-fun |error_0| () Int)
+(declare-fun |this_0| () Int)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-fun |tx_0| () |tx_type|)
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-fun |crypto_0| () |crypto_type|)
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-fun |abi_0| () |abi_type|)
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |state_0| () |state_type|)
+(declare-fun |x_3_4| () Int)
+(declare-fun |x_3_0| () Int)
+(declare-fun |expr_7_0| () Int)
+(declare-fun |expr_8_0| () Int)
+(declare-fun |expr_9_1| () Bool)
+
+(assert (and (and (and true true) (and (= expr_9_1 (> expr_7_0 expr_8_0)) (and (=> (and true true) true) (and (= expr_8_0 0) (and (=> (and true true) (and (>= expr_7_0 0) (<= expr_7_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_7_0 x_3_0) (and (and (>= x_3_0 0) (<= x_3_0 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 3017696395)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 179)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 222)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 100)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 139)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) true)))))))) (not expr_9_1)))
+(declare-const |EVALEXPR_0| Int)
+(assert (= |EVALEXPR_0| x_3_0))
+(check-sat)
+(get-value (|EVALEXPR_0| ))
+",
+            "0xe3dc20257e2b1bd9c6eb77b75913ec3a5752be174e0fd56af16d9fc95afa1b15": "(set-logic HORN)
+(declare-datatypes ((|bytes_tuple| 0)) (((|bytes_tuple| (|bytes_tuple_accessor_array| (Array Int Int)) (|bytes_tuple_accessor_length| Int)))))
+(declare-datatypes ((|tx_type| 0)) (((|tx_type| (|block.basefee| Int) (|block.chainid| Int) (|block.coinbase| Int) (|block.gaslimit| Int) (|block.number| Int) (|block.prevrandao| Int) (|block.timestamp| Int) (|blockhash| (Array Int Int)) (|msg.data| |bytes_tuple|) (|msg.sender| Int) (|msg.sig| Int) (|msg.value| Int) (|tx.gasprice| Int) (|tx.origin| Int)))))
+(declare-datatypes ((|ecrecover_input_type| 0)) (((|ecrecover_input_type| (|hash| Int) (|v| Int) (|r| Int) (|s| Int)))))
+(declare-datatypes ((|crypto_type| 0)) (((|crypto_type| (|ecrecover| (Array |ecrecover_input_type| Int)) (|keccak256| (Array |bytes_tuple| Int)) (|ripemd160| (Array |bytes_tuple| Int)) (|sha256| (Array |bytes_tuple| Int))))))
+(declare-datatypes ((|abi_type| 0)) (((|abi_type|))))
+(declare-datatypes ((|state_type| 0)) (((|state_type| (|balances| (Array Int Int))))))
+(declare-fun |interface_0_C_14_0| (Int |abi_type| |crypto_type| |state_type| ) Bool)
+(declare-fun |nondet_interface_1_C_14_0| (Int Int |abi_type| |crypto_type| |state_type| |state_type| ) Bool)
+(declare-fun |summary_constructor_2_C_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (state_0 |state_type|) (this_0 Int) (tx_0 |tx_type|))
+(=> (= error_0 0) (nondet_interface_1_C_14_0 error_0 this_0 abi_0 crypto_0 state_0 state_0))))
+
+
+(declare-fun |summary_3_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(declare-fun |summary_4_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (and (and (nondet_interface_1_C_14_0 error_0 this_0 abi_0 crypto_0 state_0 state_1) true) (and (= error_0 0) (summary_4_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 x_3_0 state_2 x_3_1))) (nondet_interface_1_C_14_0 error_1 this_0 abi_0 crypto_0 state_0 state_2))))
+
+
+(declare-fun |block_5_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(declare-fun |block_6_f_12_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(block_5_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (and (and (block_5_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) (and true (= x_3_1 x_3_0))) true)) true) (block_6_f_12_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1))))
+
+
+(declare-fun |block_7_return_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(declare-fun |block_8_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (and (and (block_6_f_12_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (and (= expr_9_1 (> expr_7_0 expr_8_0)) (and (=> true true) (and (= expr_8_0 0) (and (=> true (and (>= expr_7_0 0) (<= expr_7_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_7_0 x_3_1) (and (and (>= x_3_1 0) (<= x_3_1 115792089237316195423570985008687907853269984665640564039457584007913129639935)) true))))))) (and (and true (not expr_9_1)) (= error_1 1))) (block_8_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (block_8_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (summary_3_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (and (and (block_6_f_12_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (and (= error_1 error_0) (and (= expr_9_1 (> expr_7_0 expr_8_0)) (and (=> true true) (and (= expr_8_0 0) (and (=> true (and (>= expr_7_0 0) (<= expr_7_0 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (= expr_7_0 x_3_1) (and (and (>= x_3_1 0) (<= x_3_1 115792089237316195423570985008687907853269984665640564039457584007913129639935)) true)))))))) true) (block_7_return_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(=> (and (and (block_7_return_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) true) true) (summary_3_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1))))
+
+
+(declare-fun |block_9_function_f__13_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| Int |state_type| Int ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int))
+(block_9_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1)))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (block_9_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (and (summary_3_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_2 x_3_1 state_3 x_3_2) (and (= state_2 (|state_type| (store (|balances| state_1) this_0 (+ (select (|balances| state_1) this_0) funds_2_0)))) (and (and (>= (+ (select (|balances| state_1) this_0) funds_2_0) 0) (<= (+ (select (|balances| state_1) this_0) funds_2_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935)) (and (>= funds_2_0 (|msg.value| tx_0)) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (and (and (and (and (and (= (|msg.value| tx_0) 0) (= (|msg.sig| tx_0) 3017696395)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 0) 179)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 1) 222)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 2) 100)) (= (select (|bytes_tuple_accessor_array| (|msg.data| tx_0)) 3) 139)) (>= (|bytes_tuple_accessor_length| (|msg.data| tx_0)) 4))) (and (and (and (and (= state_1 state_0) (= error_0 0)) true) (and true (= x_3_1 x_3_0))) true))))))) true) (summary_4_function_f__13_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_3 x_3_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (interface_0_C_14_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (= error_0 0))) (interface_0_C_14_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |contract_initializer_10_C_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(declare-fun |contract_initializer_entry_11_C_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (= state_1 state_0) (= error_0 0)) true) (contract_initializer_entry_11_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |contract_initializer_after_init_12_C_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (contract_initializer_entry_11_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_after_init_12_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (contract_initializer_after_init_12_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) true) (contract_initializer_10_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(declare-fun |implicit_constructor_entry_13_C_14_0| (Int Int |abi_type| |crypto_type| |tx_type| |state_type| |state_type| ) Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (and (and (and (= state_1 state_0) (= error_0 0)) true) true) true) (>= (select (|balances| state_1) this_0) (|msg.value| tx_0))) (implicit_constructor_entry_13_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (contract_initializer_10_C_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true)) (> error_1 0)) (summary_constructor_2_C_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (implicit_constructor_entry_13_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) (and (= error_1 0) (and (contract_initializer_10_C_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_1 state_2) true))) true) (summary_constructor_2_C_14_0 error_1 this_0 abi_0 crypto_0 tx_0 state_0 state_2))))
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (summary_constructor_2_C_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 state_1) true) (and (and (and (and (and (and (and (and (and (and (and (and (and (> (|block.prevrandao| tx_0) 18446744073709551616) (and (>= (|block.basefee| tx_0) 0) (<= (|block.basefee| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.chainid| tx_0) 0) (<= (|block.chainid| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.coinbase| tx_0) 0) (<= (|block.coinbase| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|block.prevrandao| tx_0) 0) (<= (|block.prevrandao| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.gaslimit| tx_0) 0) (<= (|block.gaslimit| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.number| tx_0) 0) (<= (|block.number| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|block.timestamp| tx_0) 0) (<= (|block.timestamp| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|msg.sender| tx_0) 0) (<= (|msg.sender| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|msg.value| tx_0) 0) (<= (|msg.value| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (and (>= (|tx.origin| tx_0) 0) (<= (|tx.origin| tx_0) 1461501637330902918203684832716283019655932542975))) (and (>= (|tx.gasprice| tx_0) 0) (<= (|tx.gasprice| tx_0) 115792089237316195423570985008687907853269984665640564039457584007913129639935))) (= (|msg.value| tx_0) 0)) (= error_0 0))) (interface_0_C_14_0 this_0 abi_0 crypto_0 state_1))))
+
+
+(declare-fun |error_target_3_0| () Bool)
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> (and (and (interface_0_C_14_0 this_0 abi_0 crypto_0 state_0) true) (and (summary_4_function_f__13_14_0 error_0 this_0 abi_0 crypto_0 tx_0 state_0 x_3_0 state_1 x_3_1) (= error_0 1))) error_target_3_0)))
+
+
+
+(assert
+(forall ( (abi_0 |abi_type|) (crypto_0 |crypto_type|) (error_0 Int) (error_1 Int) (expr_7_0 Int) (expr_8_0 Int) (expr_9_1 Bool) (funds_2_0 Int) (state_0 |state_type|) (state_1 |state_type|) (state_2 |state_type|) (state_3 |state_type|) (this_0 Int) (tx_0 |tx_type|) (x_3_0 Int) (x_3_1 Int) (x_3_2 Int))
+(=> error_target_3_0 false)))
+(check-sat)
+"
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "3996",
+            "formattedMessage": "Warning: CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.
+
+",
+            "message": "CHC analysis was not possible. No Horn solver was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "8084",
+            "formattedMessage": "Warning: BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.
+
+",
+            "message": "BMC analysis was not possible. No SMT solver (Z3 or CVC4) was available. None of the installed solvers was enabled.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_solvers_z3/output.json b/compiler/test/cmdlineTests/standard_model_checker_solvers_z3/output.json
new file mode 100644
index 00000000..2a2c394f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_solvers_z3/output.json
@@ -0,0 +1,46 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)
+ --> A:4:47:
+  |
+4 | contract C { function f(uint x) public pure { assert(x > 0); } }
+  |                                               ^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 119,
+                "file": "A",
+                "start": 106
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_solvers_z3_smtlib2/output.json b/compiler/test/cmdlineTests/standard_model_checker_solvers_z3_smtlib2/output.json
new file mode 100644
index 00000000..2a2c394f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_solvers_z3_smtlib2/output.json
@@ -0,0 +1,46 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)
+ --> A:4:47:
+  |
+4 | contract C { function f(uint x) public pure { assert(x > 0); } }
+  |                                               ^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+
+x = 0
+
+Transaction trace:
+C.constructor()
+C.f(0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 119,
+                "file": "A",
+                "start": 106
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_assert_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_assert_bmc/output.json
new file mode 100644
index 00000000..18452ccb
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_assert_bmc/output.json
@@ -0,0 +1,53 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4661",
+            "formattedMessage": "Warning: BMC: Assertion violation happens here.
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Assertion violation happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_assert_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_assert_chc/output.json
new file mode 100644
index 00000000..5c43fe6b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_assert_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_balance_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_balance_bmc/output.json
new file mode 100644
index 00000000..9ee51dab
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_balance_bmc/output.json
@@ -0,0 +1,53 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1236",
+            "formattedMessage": "Warning: BMC: Insufficient funds happens here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\ta.transfer(x);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Insufficient funds happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 237,
+                "file": "A",
+                "start": 224
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_balance_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_balance_chc/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_balance_chc/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_bmc/output.json
new file mode 100644
index 00000000..94ba81c2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_bmc/output.json
@@ -0,0 +1,39 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6838",
+            "formattedMessage": "Warning: BMC: Condition is always true.
+ --> A:7:15:
+  |
+7 | \t\t\t\t\t\trequire(x >= 0);
+  | \t\t\t\t\t\t        ^^^^^^
+Note: Callstack:
+
+",
+            "message": "BMC: Condition is always true.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Callstack:"
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 165,
+                "file": "A",
+                "start": 159
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_chc/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_constantCondition_chc/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_default_all_engines/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_default_all_engines/output.json
new file mode 100644
index 00000000..4c967fa5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_default_all_engines/output.json
@@ -0,0 +1,232 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4281",
+            "formattedMessage": "Warning: CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:10:7:
+   |
+10 | \t\t\t\t\t\t2 / x;
+   | \t\t\t\t\t\t^^^^^
+
+",
+            "message": "CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 216,
+                "file": "A",
+                "start": 211
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2529",
+            "formattedMessage": "Warning: CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:13:7:
+   |
+13 | \t\t\t\t\t\tarr.pop();
+   | \t\t\t\t\t\t^^^^^^^^^
+
+",
+            "message": "CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 275,
+                "file": "A",
+                "start": 266
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6368",
+            "formattedMessage": "Warning: CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:14:7:
+   |
+14 | \t\t\t\t\t\tarr[x];
+   | \t\t\t\t\t\t^^^^^^
+
+",
+            "message": "CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 289,
+                "file": "A",
+                "start": 283
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6838",
+            "formattedMessage": "Warning: BMC: Condition is always true.
+ --> A:7:15:
+  |
+7 | \t\t\t\t\t\trequire(x >= 0);
+  | \t\t\t\t\t\t        ^^^^^^
+Note: Callstack:
+
+",
+            "message": "BMC: Condition is always true.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Callstack:"
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 165,
+                "file": "A",
+                "start": 159
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1236",
+            "formattedMessage": "Warning: BMC: Insufficient funds happens here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\ta.transfer(x);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Insufficient funds happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 237,
+                "file": "A",
+                "start": 224
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_default_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_default_bmc/output.json
new file mode 100644
index 00000000..1be99ca4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_default_bmc/output.json
@@ -0,0 +1,164 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6838",
+            "formattedMessage": "Warning: BMC: Condition is always true.
+ --> A:7:15:
+  |
+7 | \t\t\t\t\t\trequire(x >= 0);
+  | \t\t\t\t\t\t        ^^^^^^
+Note: Callstack:
+
+",
+            "message": "BMC: Condition is always true.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Callstack:"
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 165,
+                "file": "A",
+                "start": 159
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "3046",
+            "formattedMessage": "Warning: BMC: Division by zero happens here.
+  --> A:10:7:
+   |
+10 | \t\t\t\t\t\t2 / x;
+   | \t\t\t\t\t\t^^^^^
+Note: Counterexample:
+  <result> = 0
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Division by zero happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = 0
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 216,
+                "file": "A",
+                "start": 211
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1236",
+            "formattedMessage": "Warning: BMC: Insufficient funds happens here.
+  --> A:11:7:
+   |
+11 | \t\t\t\t\t\ta.transfer(x);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Insufficient funds happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 237,
+                "file": "A",
+                "start": 224
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "4661",
+            "formattedMessage": "Warning: BMC: Assertion violation happens here.
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Assertion violation happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_default_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_default_chc/output.json
new file mode 100644
index 00000000..c3df366c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_default_chc/output.json
@@ -0,0 +1,164 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4281",
+            "formattedMessage": "Warning: CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:10:7:
+   |
+10 | \t\t\t\t\t\t2 / x;
+   | \t\t\t\t\t\t^^^^^
+
+",
+            "message": "CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 216,
+                "file": "A",
+                "start": 211
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2529",
+            "formattedMessage": "Warning: CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:13:7:
+   |
+13 | \t\t\t\t\t\tarr.pop();
+   | \t\t\t\t\t\t^^^^^^^^^
+
+",
+            "message": "CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 275,
+                "file": "A",
+                "start": 266
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6368",
+            "formattedMessage": "Warning: CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:14:7:
+   |
+14 | \t\t\t\t\t\tarr[x];
+   | \t\t\t\t\t\t^^^^^^
+
+",
+            "message": "CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 289,
+                "file": "A",
+                "start": 283
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_bmc/output.json
new file mode 100644
index 00000000..05ce12ca
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_bmc/output.json
@@ -0,0 +1,55 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3046",
+            "formattedMessage": "Warning: BMC: Division by zero happens here.
+  --> A:10:7:
+   |
+10 | \t\t\t\t\t\t2 / x;
+   | \t\t\t\t\t\t^^^^^
+Note: Counterexample:
+  <result> = 0
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Division by zero happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = 0
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 216,
+                "file": "A",
+                "start": 211
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_chc/output.json
new file mode 100644
index 00000000..5c09175e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_div_by_zero_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4281",
+            "formattedMessage": "Warning: CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:10:7:
+   |
+10 | \t\t\t\t\t\t2 / x;
+   | \t\t\t\t\t\t^^^^^
+
+",
+            "message": "CHC: Division by zero happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 216,
+                "file": "A",
+                "start": 211
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_empty_array/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_empty_array/output.json
new file mode 100644
index 00000000..312af974
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_empty_array/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.targets must be a non-empty array.",
+            "message": "settings.modelChecker.targets must be a non-empty array.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_bmc/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_bmc/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_chc/output.json
new file mode 100644
index 00000000..b87480e7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_out_of_bounds_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6368",
+            "formattedMessage": "Warning: CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:14:7:
+   |
+14 | \t\t\t\t\t\tarr[x];
+   | \t\t\t\t\t\t^^^^^^
+
+",
+            "message": "CHC: Out of bounds access happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 289,
+                "file": "A",
+                "start": 283
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_bmc/output.json
new file mode 100644
index 00000000..09c1cdb5
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_bmc/output.json
@@ -0,0 +1,55 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2661",
+            "formattedMessage": "Warning: BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+Note: Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Overflow (resulting value larger than 2**256 - 1) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_chc/output.json
new file mode 100644
index 00000000..b700a938
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_overflow_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4984",
+            "formattedMessage": "Warning: CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_bmc/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_bmc/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_chc/output.json
new file mode 100644
index 00000000..c670bb4f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_pop_empty_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2529",
+            "formattedMessage": "Warning: CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:13:7:
+   |
+13 | \t\t\t\t\t\tarr.pop();
+   | \t\t\t\t\t\t^^^^^^^^^
+
+",
+            "message": "CHC: Empty array \"pop\" happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 275,
+                "file": "A",
+                "start": 266
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_bmc/output.json
new file mode 100644
index 00000000..c656eda2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_bmc/output.json
@@ -0,0 +1,55 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4144",
+            "formattedMessage": "Warning: BMC: Underflow (resulting value less than 0) happens here.
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+Note: Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Underflow (resulting value less than 0) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_chc/output.json
new file mode 100644
index 00000000..600d7fe6
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_chc/output.json
@@ -0,0 +1,50 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3944",
+            "formattedMessage": "Warning: CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+
+",
+            "message": "CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_bmc/output.json
new file mode 100644
index 00000000..004b9812
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_bmc/output.json
@@ -0,0 +1,139 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4144",
+            "formattedMessage": "Warning: BMC: Underflow (resulting value less than 0) happens here.
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+Note: Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Underflow (resulting value less than 0) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2661",
+            "formattedMessage": "Warning: BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+Note: Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Overflow (resulting value larger than 2**256 - 1) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "4661",
+            "formattedMessage": "Warning: BMC: Assertion violation happens here.
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+Note: Counterexample:
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Assertion violation happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_chc/output.json
new file mode 100644
index 00000000..5afeeaa9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_assert_chc/output.json
@@ -0,0 +1,126 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3944",
+            "formattedMessage": "Warning: CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+
+",
+            "message": "CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "4984",
+            "formattedMessage": "Warning: CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6328",
+            "formattedMessage": "Warning: CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)
+  --> A:12:7:
+   |
+12 | \t\t\t\t\t\tassert(x > 0);
+   | \t\t\t\t\t\t^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Assertion violation happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 1)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "A",
+                "start": 245
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_bmc/output.json
new file mode 100644
index 00000000..8a9452a7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_bmc/output.json
@@ -0,0 +1,98 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "4144",
+            "formattedMessage": "Warning: BMC: Underflow (resulting value less than 0) happens here.
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+Note: Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Underflow (resulting value less than 0) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = (- 1)
+  a = 0
+  x = 0
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "2661",
+            "formattedMessage": "Warning: BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+Note: Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+
+Note: Callstack:
+Note:
+
+",
+            "message": "BMC: Overflow (resulting value larger than 2**256 - 1) happens here.",
+            "secondarySourceLocations":
+            [
+                {
+                    "message": "Counterexample:
+  <result> = 2**256
+  a = 0
+  x = 1
+"
+                },
+                {
+                    "message": "Callstack:"
+                },
+                {
+                    "message": ""
+                }
+            ],
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_chc/output.json
new file mode 100644
index 00000000..9a07b669
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_underflow_overflow_chc/output.json
@@ -0,0 +1,88 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3944",
+            "formattedMessage": "Warning: CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)
+ --> A:8:7:
+  |
+8 | \t\t\t\t\t\t--x;
+  | \t\t\t\t\t\t^^^
+
+",
+            "message": "CHC: Underflow (resulting value less than 0) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 0
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 0)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 177,
+                "file": "A",
+                "start": 174
+            },
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "4984",
+            "formattedMessage": "Warning: CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)
+ --> A:9:7:
+  |
+9 | \t\t\t\t\t\tx + type(uint).max;
+  | \t\t\t\t\t\t^^^^^^^^^^^^^^^^^^
+
+",
+            "message": "CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+Counterexample:
+arr = []
+a = 0x0
+x = 1
+
+Transaction trace:
+test.constructor()
+State: arr = []
+test.f(0x0, 2)",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 203,
+                "file": "A",
+                "start": 185
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types/output.json
new file mode 100644
index 00000000..6e2af863
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Every target in settings.modelChecker.targets must be a string.",
+            "message": "Every target in settings.modelChecker.targets must be a string.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types_2/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types_2/output.json
new file mode 100644
index 00000000..c1e7759b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_target_types_2/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.targets must be an array.",
+            "message": "settings.modelChecker.targets must be an array.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_targets/output.json b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_targets/output.json
new file mode 100644
index 00000000..d0bf7f56
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_targets_wrong_targets/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid model checker targets requested.",
+            "message": "Invalid model checker targets requested.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_timeout_all/output.json b/compiler/test/cmdlineTests/standard_model_checker_timeout_all/output.json
new file mode 100644
index 00000000..73b11714
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_timeout_all/output.json
@@ -0,0 +1,42 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        },
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_timeout_bmc/output.json b/compiler/test/cmdlineTests/standard_model_checker_timeout_bmc/output.json
new file mode 100644
index 00000000..a709ec06
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_timeout_bmc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2788",
+            "formattedMessage": "Warning: BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "BMC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "6002",
+            "formattedMessage": "Info: BMC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "BMC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_timeout_chc/output.json b/compiler/test/cmdlineTests/standard_model_checker_timeout_chc/output.json
new file mode 100644
index 00000000..553a1b93
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_timeout_chc/output.json
@@ -0,0 +1,32 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "5840",
+            "formattedMessage": "Warning: CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.
+
+",
+            "message": "CHC: 1 verification condition(s) could not be proved. Enable the model checker option \"show unproved\" to see all of them. Consider choosing a specific contract to be verified in order to reduce the solving problems. Consider increasing the timeout per query.",
+            "severity": "warning",
+            "type": "Warning"
+        },
+        {
+            "component": "general",
+            "errorCode": "1391",
+            "formattedMessage": "Info: CHC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.
+
+",
+            "message": "CHC: 4 verification condition(s) proved safe! Enable the model checker option \"show proved safe\" to see all of them.",
+            "severity": "info",
+            "type": "Info"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_key/output.json b/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_key/output.json
new file mode 100644
index 00000000..137562f4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_key/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"atimeout\"",
+            "message": "Unknown key \"atimeout\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_value/output.json b/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_value/output.json
new file mode 100644
index 00000000..ce630905
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_model_checker_timeout_wrong_value/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "settings.modelChecker.timeout must be an unsigned integer.",
+            "message": "settings.modelChecker.timeout must be an unsigned integer.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_no_append_cbor/input.json b/compiler/test/cmdlineTests/standard_no_append_cbor/input.json
new file mode 100644
index 00000000..49332550
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_append_cbor/input.json
@@ -0,0 +1,28 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {}"
+		}
+	},
+	"settings":
+	{
+		"viaIR": true,
+		"optimizer": {
+			"enabled": true
+		},
+		"metadata":
+		{
+			"appendCBOR": false
+		},
+		"outputSelection":
+		{
+			"A":
+			{
+				"test": ["evm.bytecode"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_no_append_cbor/output.json b/compiler/test/cmdlineTests/standard_no_append_cbor/output.json
new file mode 100644
index 00000000..0fca3f27
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_append_cbor/output.json
@@ -0,0 +1,30 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "test":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/input.json b/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/input.json
new file mode 100644
index 00000000..f12e45bf
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/input.json
@@ -0,0 +1,29 @@
+{
+	"language": "Solidity",
+	"sources":
+	{
+		"A":
+		{
+			"content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;\n\ncontract test {}"
+		}
+	},
+	"settings":
+	{
+		"viaIR": true,
+		"optimizer": {
+			"enabled": true
+		},
+		"metadata":
+		{
+			"appendCBOR": false,
+			"bytecodeHash": "ipfs"
+		},
+		"outputSelection":
+		{
+			"A":
+			{
+				"test": ["evm.bytecode"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/output.json b/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/output.json
new file mode 100644
index 00000000..0c264f89
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_append_cbor_with_metadata_hash/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "When the parameter \"appendCBOR\" is set to false, the parameter \"bytecodeHash\" cannot be set to \"ipfs\". The parameter \"bytecodeHash\" should either be skipped, or set to \"none\".",
+            "message": "When the parameter \"appendCBOR\" is set to false, the parameter \"bytecodeHash\" cannot be set to \"ipfs\". The parameter \"bytecodeHash\" should either be skipped, or set to \"none\".",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_no_import_callback/B.sol b/compiler/test/cmdlineTests/standard_no_import_callback/B.sol
new file mode 100644
index 00000000..4bf9ea14
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_import_callback/B.sol
@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
diff --git a/compiler/test/cmdlineTests/standard_no_import_callback/args b/compiler/test/cmdlineTests/standard_no_import_callback/args
new file mode 100644
index 00000000..b8edaa42
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_import_callback/args
@@ -0,0 +1 @@
+--no-import-callback
diff --git a/compiler/test/cmdlineTests/standard_no_import_callback/input.json b/compiler/test/cmdlineTests/standard_no_import_callback/input.json
new file mode 100644
index 00000000..229b5fb3
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_import_callback/input.json
@@ -0,0 +1,8 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {
+            "content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0; import 'standard_no_import_callback/B.sol';"
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_no_import_callback/output.json b/compiler/test/cmdlineTests/standard_no_import_callback/output.json
new file mode 100644
index 00000000..a4e2d8d3
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_no_import_callback/output.json
@@ -0,0 +1,26 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "6275",
+            "formattedMessage": "ParserError: Source \"standard_no_import_callback/B.sol\" not found: No import callback.
+ --> A:2:24:
+  |
+2 | pragma solidity >=0.0; import 'standard_no_import_callback/B.sol';
+  |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+",
+            "message": "Source \"standard_no_import_callback/B.sol\" not found: No import callback.",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 102,
+                "file": "A",
+                "start": 59
+            },
+            "type": "ParserError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_only_ast_requested/output.json b/compiler/test/cmdlineTests/standard_only_ast_requested/output.json
new file mode 100644
index 00000000..6ecac5ca
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_only_ast_requested/output.json
@@ -0,0 +1,97 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "absolutePath": "A",
+                "exportedSymbols":
+                {
+                    "C":
+                    [
+                        6
+                    ]
+                },
+                "id": 7,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            ">=",
+                            "0.0"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:22:0"
+                    },
+                    {
+                        "abstract": false,
+                        "baseContracts": [],
+                        "canonicalName": "C",
+                        "contractDependencies": [],
+                        "contractKind": "contract",
+                        "fullyImplemented": true,
+                        "id": 6,
+                        "linearizedBaseContracts":
+                        [
+                            6
+                        ],
+                        "name": "C",
+                        "nameLocation": "68:1:0",
+                        "nodeType": "ContractDefinition",
+                        "nodes":
+                        [
+                            {
+                                "body":
+                                {
+                                    "id": 4,
+                                    "nodeType": "Block",
+                                    "src": "97:2:0",
+                                    "statements": []
+                                },
+                                "functionSelector": "26121ff0",
+                                "id": 5,
+                                "implemented": true,
+                                "kind": "function",
+                                "modifiers": [],
+                                "name": "f",
+                                "nameLocation": "81:1:0",
+                                "nodeType": "FunctionDefinition",
+                                "parameters":
+                                {
+                                    "id": 2,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "82:2:0"
+                                },
+                                "returnParameters":
+                                {
+                                    "id": 3,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "97:0:0"
+                                },
+                                "scope": 6,
+                                "src": "72:27:0",
+                                "stateMutability": "pure",
+                                "virtual": false,
+                                "visibility": "public"
+                            }
+                        ],
+                        "scope": 7,
+                        "src": "59:42:0",
+                        "usedErrors": [],
+                        "usedEvents": []
+                    }
+                ],
+                "src": "36:65:0"
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_generatedSources/output.json b/compiler/test/cmdlineTests/standard_optimizer_generatedSources/output.json
new file mode 100644
index 00000000..da2c31cb
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_generatedSources/output.json
@@ -0,0 +1,1747 @@
+{
+    "contracts":
+    {
+        "a.sol":
+        {
+            "A":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "generatedSources": [],
+                        "object": "<BYTECODE REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "generatedSources":
+                        [
+                            {
+                                "ast":
+                                {
+                                    "nativeSrc": "0:1445:1",
+                                    "nodeType": "YulBlock",
+                                    "src": "0:1445:1",
+                                    "statements":
+                                    [
+                                        {
+                                            "nativeSrc": "6:3:1",
+                                            "nodeType": "YulBlock",
+                                            "src": "6:3:1",
+                                            "statements": []
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "46:95:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "46:95:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "63:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "63:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "70:3:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "70:3:1",
+                                                                            "type": "",
+                                                                            "value": "224"
+                                                                        },
+                                                                        {
+                                                                            "kind": "number",
+                                                                            "nativeSrc": "75:10:1",
+                                                                            "nodeType": "YulLiteral",
+                                                                            "src": "75:10:1",
+                                                                            "type": "",
+                                                                            "value": "0x4e487b71"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "shl",
+                                                                        "nativeSrc": "66:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "66:3:1"
+                                                                    },
+                                                                    "nativeSrc": "66:20:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "66:20:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "56:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "56:6:1"
+                                                            },
+                                                            "nativeSrc": "56:31:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "56:31:1"
+                                                        },
+                                                        "nativeSrc": "56:31:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "56:31:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "103:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "103:1:1",
+                                                                    "type": "",
+                                                                    "value": "4"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "106:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "106:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x41"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "96:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "96:6:1"
+                                                            },
+                                                            "nativeSrc": "96:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "96:15:1"
+                                                        },
+                                                        "nativeSrc": "96:15:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "96:15:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "127:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "127:1:1",
+                                                                    "type": "",
+                                                                    "value": "0"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "130:4:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "130:4:1",
+                                                                    "type": "",
+                                                                    "value": "0x24"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "revert",
+                                                                "nativeSrc": "120:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "120:6:1"
+                                                            },
+                                                            "nativeSrc": "120:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "120:15:1"
+                                                        },
+                                                        "nativeSrc": "120:15:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "120:15:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "panic_error_0x41",
+                                            "nativeSrc": "14:127:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "src": "14:127:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "241:1020:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "241:1020:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "251:12:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "251:12:1",
+                                                        "value":
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "261:2:1",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "261:2:1",
+                                                            "type": "",
+                                                            "value": "32"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "_1",
+                                                                "nativeSrc": "255:2:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "255:2:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "308:16:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "308:16:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "317:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "317:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "320:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "320:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert",
+                                                                            "nativeSrc": "310:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "310:6:1"
+                                                                        },
+                                                                        "nativeSrc": "310:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "310:12:1"
+                                                                    },
+                                                                    "nativeSrc": "310:12:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "310:12:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "dataEnd",
+                                                                            "nativeSrc": "283:7:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "283:7:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "headStart",
+                                                                            "nativeSrc": "292:9:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "292:9:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "sub",
+                                                                        "nativeSrc": "279:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "279:3:1"
+                                                                    },
+                                                                    "nativeSrc": "279:23:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "279:23:1"
+                                                                },
+                                                                {
+                                                                    "name": "_1",
+                                                                    "nativeSrc": "304:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "304:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "slt",
+                                                                "nativeSrc": "275:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "275:3:1"
+                                                            },
+                                                            "nativeSrc": "275:32:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "275:32:1"
+                                                        },
+                                                        "nativeSrc": "272:52:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "272:52:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "333:37:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "333:37:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "headStart",
+                                                                    "nativeSrc": "360:9:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "360:9:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "calldataload",
+                                                                "nativeSrc": "347:12:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "347:12:1"
+                                                            },
+                                                            "nativeSrc": "347:23:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "347:23:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "offset",
+                                                                "nativeSrc": "337:6:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "337:6:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "379:28:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "379:28:1",
+                                                        "value":
+                                                        {
+                                                            "kind": "number",
+                                                            "nativeSrc": "389:18:1",
+                                                            "nodeType": "YulLiteral",
+                                                            "src": "389:18:1",
+                                                            "type": "",
+                                                            "value": "0xffffffffffffffff"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "_2",
+                                                                "nativeSrc": "383:2:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "383:2:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "434:16:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "434:16:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "443:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "443:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "446:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "446:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert",
+                                                                            "nativeSrc": "436:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "436:6:1"
+                                                                        },
+                                                                        "nativeSrc": "436:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "436:12:1"
+                                                                    },
+                                                                    "nativeSrc": "436:12:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "436:12:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "offset",
+                                                                    "nativeSrc": "422:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "422:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "_2",
+                                                                    "nativeSrc": "430:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "430:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "gt",
+                                                                "nativeSrc": "419:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "419:2:1"
+                                                            },
+                                                            "nativeSrc": "419:14:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "419:14:1"
+                                                        },
+                                                        "nativeSrc": "416:34:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "416:34:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "459:32:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "459:32:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "headStart",
+                                                                    "nativeSrc": "473:9:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "473:9:1"
+                                                                },
+                                                                {
+                                                                    "name": "offset",
+                                                                    "nativeSrc": "484:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "484:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "469:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "469:3:1"
+                                                            },
+                                                            "nativeSrc": "469:22:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "469:22:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "_3",
+                                                                "nativeSrc": "463:2:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "463:2:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "539:16:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "539:16:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "548:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "548:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "551:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "551:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert",
+                                                                            "nativeSrc": "541:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "541:6:1"
+                                                                        },
+                                                                        "nativeSrc": "541:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "541:12:1"
+                                                                    },
+                                                                    "nativeSrc": "541:12:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "541:12:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "_3",
+                                                                                    "nativeSrc": "518:2:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "518:2:1"
+                                                                                },
+                                                                                {
+                                                                                    "kind": "number",
+                                                                                    "nativeSrc": "522:4:1",
+                                                                                    "nodeType": "YulLiteral",
+                                                                                    "src": "522:4:1",
+                                                                                    "type": "",
+                                                                                    "value": "0x1f"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "add",
+                                                                                "nativeSrc": "514:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "514:3:1"
+                                                                            },
+                                                                            "nativeSrc": "514:13:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "514:13:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "dataEnd",
+                                                                            "nativeSrc": "529:7:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "529:7:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "slt",
+                                                                        "nativeSrc": "510:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "510:3:1"
+                                                                    },
+                                                                    "nativeSrc": "510:27:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "510:27:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "iszero",
+                                                                "nativeSrc": "503:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "503:6:1"
+                                                            },
+                                                            "nativeSrc": "503:35:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "503:35:1"
+                                                        },
+                                                        "nativeSrc": "500:55:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "500:55:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "564:26:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "564:26:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "_3",
+                                                                    "nativeSrc": "587:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "587:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "calldataload",
+                                                                "nativeSrc": "574:12:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "574:12:1"
+                                                            },
+                                                            "nativeSrc": "574:16:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "574:16:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "_4",
+                                                                "nativeSrc": "568:2:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "568:2:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "613:22:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "613:22:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "panic_error_0x41",
+                                                                            "nativeSrc": "615:16:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "615:16:1"
+                                                                        },
+                                                                        "nativeSrc": "615:18:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "615:18:1"
+                                                                    },
+                                                                    "nativeSrc": "615:18:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "615:18:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "_4",
+                                                                    "nativeSrc": "605:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "605:2:1"
+                                                                },
+                                                                {
+                                                                    "name": "_2",
+                                                                    "nativeSrc": "609:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "609:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "gt",
+                                                                "nativeSrc": "602:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "602:2:1"
+                                                            },
+                                                            "nativeSrc": "602:10:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "602:10:1"
+                                                        },
+                                                        "nativeSrc": "599:36:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "599:36:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "644:20:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "644:20:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "658:1:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "658:1:1",
+                                                                    "type": "",
+                                                                    "value": "5"
+                                                                },
+                                                                {
+                                                                    "name": "_4",
+                                                                    "nativeSrc": "661:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "661:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "shl",
+                                                                "nativeSrc": "654:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "654:3:1"
+                                                            },
+                                                            "nativeSrc": "654:10:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "654:10:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "_5",
+                                                                "nativeSrc": "648:2:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "648:2:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "673:23:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "673:23:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "693:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "693:2:1",
+                                                                    "type": "",
+                                                                    "value": "64"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mload",
+                                                                "nativeSrc": "687:5:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "687:5:1"
+                                                            },
+                                                            "nativeSrc": "687:9:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "687:9:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "memPtr",
+                                                                "nativeSrc": "677:6:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "677:6:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "705:56:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "705:56:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "memPtr",
+                                                                    "nativeSrc": "727:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "727:6:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "name": "_5",
+                                                                                    "nativeSrc": "743:2:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "743:2:1"
+                                                                                },
+                                                                                {
+                                                                                    "kind": "number",
+                                                                                    "nativeSrc": "747:2:1",
+                                                                                    "nodeType": "YulLiteral",
+                                                                                    "src": "747:2:1",
+                                                                                    "type": "",
+                                                                                    "value": "63"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "add",
+                                                                                "nativeSrc": "739:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "739:3:1"
+                                                                            },
+                                                                            "nativeSrc": "739:11:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "739:11:1"
+                                                                        },
+                                                                        {
+                                                                            "arguments":
+                                                                            [
+                                                                                {
+                                                                                    "kind": "number",
+                                                                                    "nativeSrc": "756:2:1",
+                                                                                    "nodeType": "YulLiteral",
+                                                                                    "src": "756:2:1",
+                                                                                    "type": "",
+                                                                                    "value": "31"
+                                                                                }
+                                                                            ],
+                                                                            "functionName":
+                                                                            {
+                                                                                "name": "not",
+                                                                                "nativeSrc": "752:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "752:3:1"
+                                                                            },
+                                                                            "nativeSrc": "752:7:1",
+                                                                            "nodeType": "YulFunctionCall",
+                                                                            "src": "752:7:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "and",
+                                                                        "nativeSrc": "735:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "735:3:1"
+                                                                    },
+                                                                    "nativeSrc": "735:25:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "735:25:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "723:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "723:3:1"
+                                                            },
+                                                            "nativeSrc": "723:38:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "723:38:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "newFreePtr",
+                                                                "nativeSrc": "709:10:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "709:10:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "820:22:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "820:22:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments": [],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "panic_error_0x41",
+                                                                            "nativeSrc": "822:16:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "822:16:1"
+                                                                        },
+                                                                        "nativeSrc": "822:18:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "822:18:1"
+                                                                    },
+                                                                    "nativeSrc": "822:18:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "822:18:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "newFreePtr",
+                                                                            "nativeSrc": "779:10:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "779:10:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "_2",
+                                                                            "nativeSrc": "791:2:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "791:2:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "gt",
+                                                                        "nativeSrc": "776:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "776:2:1"
+                                                                    },
+                                                                    "nativeSrc": "776:18:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "776:18:1"
+                                                                },
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "newFreePtr",
+                                                                            "nativeSrc": "799:10:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "799:10:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "memPtr",
+                                                                            "nativeSrc": "811:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "811:6:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "lt",
+                                                                        "nativeSrc": "796:2:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "796:2:1"
+                                                                    },
+                                                                    "nativeSrc": "796:22:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "796:22:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "or",
+                                                                "nativeSrc": "773:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "773:2:1"
+                                                            },
+                                                            "nativeSrc": "773:46:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "773:46:1"
+                                                        },
+                                                        "nativeSrc": "770:72:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "770:72:1"
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "858:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "858:2:1",
+                                                                    "type": "",
+                                                                    "value": "64"
+                                                                },
+                                                                {
+                                                                    "name": "newFreePtr",
+                                                                    "nativeSrc": "862:10:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "862:10:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "851:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "851:6:1"
+                                                            },
+                                                            "nativeSrc": "851:22:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "851:22:1"
+                                                        },
+                                                        "nativeSrc": "851:22:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "851:22:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "882:17:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "882:17:1",
+                                                        "value":
+                                                        {
+                                                            "name": "memPtr",
+                                                            "nativeSrc": "893:6:1",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "893:6:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "dst",
+                                                                "nativeSrc": "886:3:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "886:3:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "memPtr",
+                                                                    "nativeSrc": "915:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "915:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "_4",
+                                                                    "nativeSrc": "923:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "923:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "908:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "908:6:1"
+                                                            },
+                                                            "nativeSrc": "908:18:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "908:18:1"
+                                                        },
+                                                        "nativeSrc": "908:18:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "908:18:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "935:22:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "935:22:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "memPtr",
+                                                                    "nativeSrc": "946:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "946:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "_1",
+                                                                    "nativeSrc": "954:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "954:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "942:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "942:3:1"
+                                                            },
+                                                            "nativeSrc": "942:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "942:15:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "dst",
+                                                                "nativeSrc": "935:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "935:3:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "nativeSrc": "966:34:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "966:34:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "arguments":
+                                                                    [
+                                                                        {
+                                                                            "name": "_3",
+                                                                            "nativeSrc": "988:2:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "988:2:1"
+                                                                        },
+                                                                        {
+                                                                            "name": "_5",
+                                                                            "nativeSrc": "992:2:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "992:2:1"
+                                                                        }
+                                                                    ],
+                                                                    "functionName":
+                                                                    {
+                                                                        "name": "add",
+                                                                        "nativeSrc": "984:3:1",
+                                                                        "nodeType": "YulIdentifier",
+                                                                        "src": "984:3:1"
+                                                                    },
+                                                                    "nativeSrc": "984:11:1",
+                                                                    "nodeType": "YulFunctionCall",
+                                                                    "src": "984:11:1"
+                                                                },
+                                                                {
+                                                                    "name": "_1",
+                                                                    "nativeSrc": "997:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "997:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "980:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "980:3:1"
+                                                            },
+                                                            "nativeSrc": "980:20:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "980:20:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "srcEnd",
+                                                                "nativeSrc": "970:6:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "970:6:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "1032:16:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1032:16:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "1041:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "1041:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            },
+                                                                            {
+                                                                                "kind": "number",
+                                                                                "nativeSrc": "1044:1:1",
+                                                                                "nodeType": "YulLiteral",
+                                                                                "src": "1044:1:1",
+                                                                                "type": "",
+                                                                                "value": "0"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "revert",
+                                                                            "nativeSrc": "1034:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1034:6:1"
+                                                                        },
+                                                                        "nativeSrc": "1034:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1034:12:1"
+                                                                    },
+                                                                    "nativeSrc": "1034:12:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "1034:12:1"
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "srcEnd",
+                                                                    "nativeSrc": "1015:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1015:6:1"
+                                                                },
+                                                                {
+                                                                    "name": "dataEnd",
+                                                                    "nativeSrc": "1023:7:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1023:7:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "gt",
+                                                                "nativeSrc": "1012:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1012:2:1"
+                                                            },
+                                                            "nativeSrc": "1012:19:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1012:19:1"
+                                                        },
+                                                        "nativeSrc": "1009:39:1",
+                                                        "nodeType": "YulIf",
+                                                        "src": "1009:39:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "1057:22:1",
+                                                        "nodeType": "YulVariableDeclaration",
+                                                        "src": "1057:22:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "_3",
+                                                                    "nativeSrc": "1072:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1072:2:1"
+                                                                },
+                                                                {
+                                                                    "name": "_1",
+                                                                    "nativeSrc": "1076:2:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1076:2:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "1068:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1068:3:1"
+                                                            },
+                                                            "nativeSrc": "1068:11:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1068:11:1"
+                                                        },
+                                                        "variables":
+                                                        [
+                                                            {
+                                                                "name": "src",
+                                                                "nativeSrc": "1061:3:1",
+                                                                "nodeType": "YulTypedName",
+                                                                "src": "1061:3:1",
+                                                                "type": ""
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "body":
+                                                        {
+                                                            "nativeSrc": "1144:86:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1144:86:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "expression":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "dst",
+                                                                                "nativeSrc": "1165:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1165:3:1"
+                                                                            },
+                                                                            {
+                                                                                "arguments":
+                                                                                [
+                                                                                    {
+                                                                                        "name": "src",
+                                                                                        "nativeSrc": "1183:3:1",
+                                                                                        "nodeType": "YulIdentifier",
+                                                                                        "src": "1183:3:1"
+                                                                                    }
+                                                                                ],
+                                                                                "functionName":
+                                                                                {
+                                                                                    "name": "calldataload",
+                                                                                    "nativeSrc": "1170:12:1",
+                                                                                    "nodeType": "YulIdentifier",
+                                                                                    "src": "1170:12:1"
+                                                                                },
+                                                                                "nativeSrc": "1170:17:1",
+                                                                                "nodeType": "YulFunctionCall",
+                                                                                "src": "1170:17:1"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "mstore",
+                                                                            "nativeSrc": "1158:6:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1158:6:1"
+                                                                        },
+                                                                        "nativeSrc": "1158:30:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1158:30:1"
+                                                                    },
+                                                                    "nativeSrc": "1158:30:1",
+                                                                    "nodeType": "YulExpressionStatement",
+                                                                    "src": "1158:30:1"
+                                                                },
+                                                                {
+                                                                    "nativeSrc": "1201:19:1",
+                                                                    "nodeType": "YulAssignment",
+                                                                    "src": "1201:19:1",
+                                                                    "value":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "dst",
+                                                                                "nativeSrc": "1212:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1212:3:1"
+                                                                            },
+                                                                            {
+                                                                                "name": "_1",
+                                                                                "nativeSrc": "1217:2:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1217:2:1"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "add",
+                                                                            "nativeSrc": "1208:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1208:3:1"
+                                                                        },
+                                                                        "nativeSrc": "1208:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1208:12:1"
+                                                                    },
+                                                                    "variableNames":
+                                                                    [
+                                                                        {
+                                                                            "name": "dst",
+                                                                            "nativeSrc": "1201:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1201:3:1"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            ]
+                                                        },
+                                                        "condition":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "src",
+                                                                    "nativeSrc": "1099:3:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1099:3:1"
+                                                                },
+                                                                {
+                                                                    "name": "srcEnd",
+                                                                    "nativeSrc": "1104:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1104:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "lt",
+                                                                "nativeSrc": "1096:2:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1096:2:1"
+                                                            },
+                                                            "nativeSrc": "1096:15:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1096:15:1"
+                                                        },
+                                                        "nativeSrc": "1088:142:1",
+                                                        "nodeType": "YulForLoop",
+                                                        "post":
+                                                        {
+                                                            "nativeSrc": "1112:23:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1112:23:1",
+                                                            "statements":
+                                                            [
+                                                                {
+                                                                    "nativeSrc": "1114:19:1",
+                                                                    "nodeType": "YulAssignment",
+                                                                    "src": "1114:19:1",
+                                                                    "value":
+                                                                    {
+                                                                        "arguments":
+                                                                        [
+                                                                            {
+                                                                                "name": "src",
+                                                                                "nativeSrc": "1125:3:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1125:3:1"
+                                                                            },
+                                                                            {
+                                                                                "name": "_1",
+                                                                                "nativeSrc": "1130:2:1",
+                                                                                "nodeType": "YulIdentifier",
+                                                                                "src": "1130:2:1"
+                                                                            }
+                                                                        ],
+                                                                        "functionName":
+                                                                        {
+                                                                            "name": "add",
+                                                                            "nativeSrc": "1121:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1121:3:1"
+                                                                        },
+                                                                        "nativeSrc": "1121:12:1",
+                                                                        "nodeType": "YulFunctionCall",
+                                                                        "src": "1121:12:1"
+                                                                    },
+                                                                    "variableNames":
+                                                                    [
+                                                                        {
+                                                                            "name": "src",
+                                                                            "nativeSrc": "1114:3:1",
+                                                                            "nodeType": "YulIdentifier",
+                                                                            "src": "1114:3:1"
+                                                                        }
+                                                                    ]
+                                                                }
+                                                            ]
+                                                        },
+                                                        "pre":
+                                                        {
+                                                            "nativeSrc": "1092:3:1",
+                                                            "nodeType": "YulBlock",
+                                                            "src": "1092:3:1",
+                                                            "statements": []
+                                                        },
+                                                        "src": "1088:142:1"
+                                                    },
+                                                    {
+                                                        "nativeSrc": "1239:16:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1239:16:1",
+                                                        "value":
+                                                        {
+                                                            "name": "memPtr",
+                                                            "nativeSrc": "1249:6:1",
+                                                            "nodeType": "YulIdentifier",
+                                                            "src": "1249:6:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "value0",
+                                                                "nativeSrc": "1239:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1239:6:1"
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptr",
+                                            "nativeSrc": "146:1115:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "headStart",
+                                                    "nativeSrc": "207:9:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "207:9:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "dataEnd",
+                                                    "nativeSrc": "218:7:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "218:7:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "value0",
+                                                    "nativeSrc": "230:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "230:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "146:1115:1"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "nativeSrc": "1367:76:1",
+                                                "nodeType": "YulBlock",
+                                                "src": "1367:76:1",
+                                                "statements":
+                                                [
+                                                    {
+                                                        "nativeSrc": "1377:26:1",
+                                                        "nodeType": "YulAssignment",
+                                                        "src": "1377:26:1",
+                                                        "value":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "headStart",
+                                                                    "nativeSrc": "1389:9:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1389:9:1"
+                                                                },
+                                                                {
+                                                                    "kind": "number",
+                                                                    "nativeSrc": "1400:2:1",
+                                                                    "nodeType": "YulLiteral",
+                                                                    "src": "1400:2:1",
+                                                                    "type": "",
+                                                                    "value": "32"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "add",
+                                                                "nativeSrc": "1385:3:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1385:3:1"
+                                                            },
+                                                            "nativeSrc": "1385:18:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1385:18:1"
+                                                        },
+                                                        "variableNames":
+                                                        [
+                                                            {
+                                                                "name": "tail",
+                                                                "nativeSrc": "1377:4:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1377:4:1"
+                                                            }
+                                                        ]
+                                                    },
+                                                    {
+                                                        "expression":
+                                                        {
+                                                            "arguments":
+                                                            [
+                                                                {
+                                                                    "name": "headStart",
+                                                                    "nativeSrc": "1419:9:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1419:9:1"
+                                                                },
+                                                                {
+                                                                    "name": "value0",
+                                                                    "nativeSrc": "1430:6:1",
+                                                                    "nodeType": "YulIdentifier",
+                                                                    "src": "1430:6:1"
+                                                                }
+                                                            ],
+                                                            "functionName":
+                                                            {
+                                                                "name": "mstore",
+                                                                "nativeSrc": "1412:6:1",
+                                                                "nodeType": "YulIdentifier",
+                                                                "src": "1412:6:1"
+                                                            },
+                                                            "nativeSrc": "1412:25:1",
+                                                            "nodeType": "YulFunctionCall",
+                                                            "src": "1412:25:1"
+                                                        },
+                                                        "nativeSrc": "1412:25:1",
+                                                        "nodeType": "YulExpressionStatement",
+                                                        "src": "1412:25:1"
+                                                    }
+                                                ]
+                                            },
+                                            "name": "abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed",
+                                            "nativeSrc": "1266:177:1",
+                                            "nodeType": "YulFunctionDefinition",
+                                            "parameters":
+                                            [
+                                                {
+                                                    "name": "headStart",
+                                                    "nativeSrc": "1336:9:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1336:9:1",
+                                                    "type": ""
+                                                },
+                                                {
+                                                    "name": "value0",
+                                                    "nativeSrc": "1347:6:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1347:6:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "returnVariables":
+                                            [
+                                                {
+                                                    "name": "tail",
+                                                    "nativeSrc": "1358:4:1",
+                                                    "nodeType": "YulTypedName",
+                                                    "src": "1358:4:1",
+                                                    "type": ""
+                                                }
+                                            ],
+                                            "src": "1266:177:1"
+                                        }
+                                    ]
+                                },
+                                "contents": "{
+    { }
+    function panic_error_0x41()
+    {
+        mstore(0, shl(224, 0x4e487b71))
+        mstore(4, 0x41)
+        revert(0, 0x24)
+    }
+    function abi_decode_tuple_t_array$_t_uint256_$dyn_memory_ptr(headStart, dataEnd) -> value0
+    {
+        let _1 := 32
+        if slt(sub(dataEnd, headStart), _1) { revert(0, 0) }
+        let offset := calldataload(headStart)
+        let _2 := 0xffffffffffffffff
+        if gt(offset, _2) { revert(0, 0) }
+        let _3 := add(headStart, offset)
+        if iszero(slt(add(_3, 0x1f), dataEnd)) { revert(0, 0) }
+        let _4 := calldataload(_3)
+        if gt(_4, _2) { panic_error_0x41() }
+        let _5 := shl(5, _4)
+        let memPtr := mload(64)
+        let newFreePtr := add(memPtr, and(add(_5, 63), not(31)))
+        if or(gt(newFreePtr, _2), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+        mstore(64, newFreePtr)
+        let dst := memPtr
+        mstore(memPtr, _4)
+        dst := add(memPtr, _1)
+        let srcEnd := add(add(_3, _5), _1)
+        if gt(srcEnd, dataEnd) { revert(0, 0) }
+        let src := add(_3, _1)
+        for { } lt(src, srcEnd) { src := add(src, _1) }
+        {
+            mstore(dst, calldataload(src))
+            dst := add(dst, _1)
+        }
+        value0 := memPtr
+    }
+    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail
+    {
+        tail := add(headStart, 32)
+        mstore(headStart, value0)
+    }
+}",
+                                "id": 1,
+                                "language": "Yul",
+                                "name": "#utility.yul"
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "a.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/input.json
new file mode 100644
index 00000000..5be769f7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": "dhfoDgvulfnTUtnIf\n[    xar:rscLM\n]\njmuljuljul VcTOcul jmul"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/output.json
new file mode 100644
index 00000000..f44ca7e2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_invalid_nested_delimiter/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid optimizer step sequence in \"settings.optimizer.details.optimizerSteps\": Cleanup sequence delimiter cannot be placed inside the brackets",
+            "message": "Invalid optimizer step sequence in \"settings.optimizer.details.optimizerSteps\": Cleanup sequence delimiter cannot be placed inside the brackets",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/input.json
new file mode 100644
index 00000000..0bddd9d9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": "dhfoDgvu:lfnTUtnIf\n[    xarrscLM\n]\njmuljulj:ul VcTOcul jmul"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/output.json
new file mode 100644
index 00000000..16cba14d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_mutliple_delimiters/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Invalid optimizer step sequence in \"settings.optimizer.details.optimizerSteps\": Too many cleanup sequence delimiters",
+            "message": "Invalid optimizer step sequence in \"settings.optimizer.details.optimizerSteps\": Too many cleanup sequence delimiters",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/input.json
new file mode 100644
index 00000000..51186025
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_no_yul/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": false,
+                    "yulDetails": {
+                        "optimizerSteps": "u:fdntOc"
+                    }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/output.json
new file mode 100644
index 00000000..fa3c9d93
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_no_yul/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "If Yul optimizer is disabled, only an empty optimizerSteps sequence is accepted.",
+            "message": "If Yul optimizer is disabled, only an empty optimizerSteps sequence is accepted.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/input.json
new file mode 100644
index 00000000..b557a966
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": "dhfoDgvulfnTUtnIf\n[    xarrscLM\n]\njmuljuljul VcTOcul jmul:fDnTOc"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_cleanup_sequence/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/input.json
new file mode 100644
index 00000000..7d2f529c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": "dhfoDgvulfnTUtnIf\n[    xarrscLM\n]\njmuljuljul VcTOcul jmul:"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_cleanup_sequence/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/input.json
new file mode 100644
index 00000000..9c603d6f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": ":dhfoDgvulfnTUtnIf\n[    xarrscLM\n]\njmuljuljul VcTOcul jmul"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_optimisation_sequence/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/input.json
new file mode 100644
index 00000000..5780bea8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": true,
+                "yulDetails": {
+                    "optimizerSteps": ":"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/input.json
new file mode 100644
index 00000000..9de7beea
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/input.json
@@ -0,0 +1,16 @@
+{
+  	"language": "Solidity",
+  	"sources": {
+		"A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/in.sol"]}
+  	},
+  	"settings": {
+		"optimizer": {
+	  		"details": {
+				"yul": false,
+				"yulDetails": {
+		  			"optimizerSteps": ":"
+				}
+	  		}
+		}
+  	}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_empty_sequence_no_yul/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/in.sol b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/in.sol
new file mode 100644
index 00000000..9e535007
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C {
+    function f() public pure {}
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/input.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/input.json
new file mode 100644
index 00000000..321ac8e9
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/input.json
@@ -0,0 +1,16 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "A": {"urls": ["standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/in.sol"]}
+    },
+    "settings": {
+        "optimizer": {
+            "details": {
+                "yul": false,
+                "yulDetails": {
+                    "optimizerSteps": "\n  : "
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/output.json
new file mode 100644
index 00000000..acf3b74e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_optimiserSteps_with_whitespace_newline_sequence_no_yul/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_optimizer_yulDetails_without_yul/output.json b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_without_yul/output.json
new file mode 100644
index 00000000..2470015e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_optimizer_yulDetails_without_yul/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Only optimizerSteps can be set in yulDetails when Yul optimizer is disabled.",
+            "message": "Only optimizerSteps can be set in yulDetails when Yul optimizer is disabled.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/args b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/in.sol b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/in.sol
new file mode 100644
index 00000000..b31d6403
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/in.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {
+    // This will trigger a fatal error at the analysis stage, of the kind that terminates analysis
+    // immediately without letting the current step finish.
+    constructor(uint[] storage) {}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/input.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/input.json
new file mode 100644
index 00000000..b640f033
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/input.json
@@ -0,0 +1,14 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_outputs_on_analysis_error_fatal/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {
+				"*": ["*"],
+				"": ["*"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/output.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/output.json
new file mode 100644
index 00000000..51d12668
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal/output.json
@@ -0,0 +1,26 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3644",
+            "formattedMessage": "TypeError: This parameter has a type that can only be used internally. You can make the contract abstract to avoid this problem.
+ --> C:7:17:
+  |
+7 |     constructor(uint[] storage) {}
+  |                 ^^^^^^^^^^^^^^
+
+",
+            "message": "This parameter has a type that can only be used internally. You can make the contract abstract to avoid this problem.",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 258,
+                "file": "C",
+                "start": 244
+            },
+            "type": "TypeError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/args b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/in.sol b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/in.sol
new file mode 100644
index 00000000..6c8bb393
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+// This will trigger a fatal error at the analysis stage, of the kind that lets the current
+// analysis steps finish but terminates analysis after immediately after that step.
+function f(uint immutable x) {}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/input.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/input.json
new file mode 100644
index 00000000..0214e00e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/input.json
@@ -0,0 +1,14 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_outputs_on_analysis_error_fatal_after_current_step/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {
+				"*": ["*"],
+				"": ["*"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/output.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/output.json
new file mode 100644
index 00000000..d47ded5d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_fatal_after_current_step/output.json
@@ -0,0 +1,26 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "8297",
+            "formattedMessage": "DeclarationError: The \"immutable\" keyword can only be used for state variables.
+ --> C:6:12:
+  |
+6 | function f(uint immutable x) {}
+  |            ^^^^^^^^^^^^^^^^
+
+",
+            "message": "The \"immutable\" keyword can only be used for state variables.",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 259,
+                "file": "C",
+                "start": 243
+            },
+            "type": "DeclarationError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/args b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/in.sol b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/in.sol
new file mode 100644
index 00000000..050f5ad4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/in.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {
+    // This will trigger a non-fatal error at the analysis stage.
+    // With this kind of error we still run subsequent analysis stages.
+    uint x;
+    string y = x;
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/input.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/input.json
new file mode 100644
index 00000000..904ebc5b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/input.json
@@ -0,0 +1,14 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_outputs_on_analysis_error_non_fatal/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {
+				"*": ["*"],
+				"": ["*"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/output.json b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/output.json
new file mode 100644
index 00000000..2f3aaae4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_analysis_error_non_fatal/output.json
@@ -0,0 +1,26 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7407",
+            "formattedMessage": "TypeError: Type uint256 is not implicitly convertible to expected type string storage ref.
+ --> C:8:16:
+  |
+8 |     string y = x;
+  |                ^
+
+",
+            "message": "Type uint256 is not implicitly convertible to expected type string storage ref.",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 235,
+                "file": "C",
+                "start": 234
+            },
+            "type": "TypeError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/args b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/in.sol b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/in.sol
new file mode 100644
index 00000000..1d5118b8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/in.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {
+    // This will trigger an error at the compilation stage.
+    // CodeGenerationError due to immutable initialization in constructor being optimized out.
+    uint immutable public x;
+
+    constructor() {
+        x = 0;
+        while (true) {}
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/input.json b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/input.json
new file mode 100644
index 00000000..855f0076
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/input.json
@@ -0,0 +1,15 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_outputs_on_compilation_error/in.sol"]}
+	},
+	"settings": {
+		"optimizer": {"enabled": true},
+		"outputSelection": {
+			"*": {
+				"*": ["*"],
+				"": ["*"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/output.json b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/output.json
new file mode 100644
index 00000000..ac01fb1e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_compilation_error/output.json
@@ -0,0 +1,280 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C":
+            {
+                "abi":
+                [
+                    {
+                        "inputs": [],
+                        "stateMutability": "nonpayable",
+                        "type": "constructor"
+                    },
+                    {
+                        "inputs": [],
+                        "name": "x",
+                        "outputs":
+                        [
+                            {
+                                "internalType": "uint256",
+                                "name": "",
+                                "type": "uint256"
+                            }
+                        ],
+                        "stateMutability": "view",
+                        "type": "function"
+                    }
+                ],
+                "devdoc":
+                {
+                    "kind": "dev",
+                    "methods": {},
+                    "version": 1
+                },
+                "evm":
+                {
+                    "methodIdentifiers":
+                    {
+                        "x()": "0c55699c"
+                    }
+                },
+                "metadata": "{\"compiler\":{\"version\":\"<VERSION REMOVED>\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"x\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"C\":\"C\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"C\":{\"keccak256\":\"0x67a13ebd685e4c6f792e71eb747dac57edb99e94d04d841ee6c979ae517934ce\",\"license\":\"GPL-3.0\",\"urls\":[\"bzz-raw://665b000da768823654f680d02686c1e59d682a0b3882e43a77fed9f80ce64ae8\",\"dweb:/ipfs/QmVnKvuidH6KiCdNQpoAQUtDbB8hXkafVLXWMNitUcxnqC\"]}},\"version\":1}",
+                "storageLayout":
+                {
+                    "storage": [],
+                    "types": null
+                },
+                "userdoc":
+                {
+                    "kind": "user",
+                    "methods": {},
+                    "version": 1
+                }
+            }
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "1284",
+            "formattedMessage": "CodeGenerationError: Some immutables were read from but never assigned, possibly because of optimization.
+
+",
+            "message": "Some immutables were read from but never assigned, possibly because of optimization.",
+            "severity": "error",
+            "type": "CodeGenerationError"
+        }
+    ],
+    "sources":
+    {
+        "C":
+        {
+            "ast":
+            {
+                "absolutePath": "C",
+                "exportedSymbols":
+                {
+                    "C":
+                    [
+                        15
+                    ]
+                },
+                "id": 16,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            "*"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:18:0"
+                    },
+                    {
+                        "abstract": false,
+                        "baseContracts": [],
+                        "canonicalName": "C",
+                        "contractDependencies": [],
+                        "contractKind": "contract",
+                        "fullyImplemented": true,
+                        "id": 15,
+                        "linearizedBaseContracts":
+                        [
+                            15
+                        ],
+                        "name": "C",
+                        "nameLocation": "65:1:0",
+                        "nodeType": "ContractDefinition",
+                        "nodes":
+                        [
+                            {
+                                "constant": false,
+                                "functionSelector": "0c55699c",
+                                "id": 3,
+                                "mutability": "immutable",
+                                "name": "x",
+                                "nameLocation": "250:1:0",
+                                "nodeType": "VariableDeclaration",
+                                "scope": 15,
+                                "src": "228:23:0",
+                                "stateVariable": true,
+                                "storageLocation": "default",
+                                "typeDescriptions":
+                                {
+                                    "typeIdentifier": "t_uint256",
+                                    "typeString": "uint256"
+                                },
+                                "typeName":
+                                {
+                                    "id": 2,
+                                    "name": "uint",
+                                    "nodeType": "ElementaryTypeName",
+                                    "src": "228:4:0",
+                                    "typeDescriptions":
+                                    {
+                                        "typeIdentifier": "t_uint256",
+                                        "typeString": "uint256"
+                                    }
+                                },
+                                "visibility": "public"
+                            },
+                            {
+                                "body":
+                                {
+                                    "id": 13,
+                                    "nodeType": "Block",
+                                    "src": "272:46:0",
+                                    "statements":
+                                    [
+                                        {
+                                            "expression":
+                                            {
+                                                "id": 8,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": false,
+                                                "lValueRequested": false,
+                                                "leftHandSide":
+                                                {
+                                                    "id": 6,
+                                                    "name": "x",
+                                                    "nodeType": "Identifier",
+                                                    "overloadedDeclarations": [],
+                                                    "referencedDeclaration": 3,
+                                                    "src": "282:1:0",
+                                                    "typeDescriptions":
+                                                    {
+                                                        "typeIdentifier": "t_uint256",
+                                                        "typeString": "uint256"
+                                                    }
+                                                },
+                                                "nodeType": "Assignment",
+                                                "operator": "=",
+                                                "rightHandSide":
+                                                {
+                                                    "hexValue": "30",
+                                                    "id": 7,
+                                                    "isConstant": false,
+                                                    "isLValue": false,
+                                                    "isPure": true,
+                                                    "kind": "number",
+                                                    "lValueRequested": false,
+                                                    "nodeType": "Literal",
+                                                    "src": "286:1:0",
+                                                    "typeDescriptions":
+                                                    {
+                                                        "typeIdentifier": "t_rational_0_by_1",
+                                                        "typeString": "int_const 0"
+                                                    },
+                                                    "value": "0"
+                                                },
+                                                "src": "282:5:0",
+                                                "typeDescriptions":
+                                                {
+                                                    "typeIdentifier": "t_uint256",
+                                                    "typeString": "uint256"
+                                                }
+                                            },
+                                            "id": 9,
+                                            "nodeType": "ExpressionStatement",
+                                            "src": "282:5:0"
+                                        },
+                                        {
+                                            "body":
+                                            {
+                                                "id": 11,
+                                                "nodeType": "Block",
+                                                "src": "310:2:0",
+                                                "statements": []
+                                            },
+                                            "condition":
+                                            {
+                                                "hexValue": "74727565",
+                                                "id": 10,
+                                                "isConstant": false,
+                                                "isLValue": false,
+                                                "isPure": true,
+                                                "kind": "bool",
+                                                "lValueRequested": false,
+                                                "nodeType": "Literal",
+                                                "src": "304:4:0",
+                                                "typeDescriptions":
+                                                {
+                                                    "typeIdentifier": "t_bool",
+                                                    "typeString": "bool"
+                                                },
+                                                "value": "true"
+                                            },
+                                            "id": 12,
+                                            "nodeType": "WhileStatement",
+                                            "src": "297:15:0"
+                                        }
+                                    ]
+                                },
+                                "id": 14,
+                                "implemented": true,
+                                "kind": "constructor",
+                                "modifiers": [],
+                                "name": "",
+                                "nameLocation": "-1:-1:-1",
+                                "nodeType": "FunctionDefinition",
+                                "parameters":
+                                {
+                                    "id": 4,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "269:2:0"
+                                },
+                                "returnParameters":
+                                {
+                                    "id": 5,
+                                    "nodeType": "ParameterList",
+                                    "parameters": [],
+                                    "src": "272:0:0"
+                                },
+                                "scope": 15,
+                                "src": "258:60:0",
+                                "stateMutability": "nonpayable",
+                                "virtual": false,
+                                "visibility": "public"
+                            }
+                        ],
+                        "scope": 16,
+                        "src": "56:264:0",
+                        "usedErrors": [],
+                        "usedEvents": []
+                    }
+                ],
+                "src": "36:285:0"
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/args b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/in.sol b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/in.sol
new file mode 100644
index 00000000..a4d891c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/in.sol
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+// This will trigger an error at the parsing stage
+contract C {}}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/input.json b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/input.json
new file mode 100644
index 00000000..a0d00c4e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/input.json
@@ -0,0 +1,14 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_outputs_on_parsing_error/in.sol"]}
+	},
+	"settings": {
+		"outputSelection": {
+			"*": {
+				"*": ["*"],
+				"": ["*"]
+			}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/output.json b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/output.json
new file mode 100644
index 00000000..8c1f6c0d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_outputs_on_parsing_error/output.json
@@ -0,0 +1,26 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "7858",
+            "formattedMessage": "ParserError: Expected pragma, import directive or contract/interface/library/struct/enum/constant/function/error definition.
+ --> C:5:14:
+  |
+5 | contract C {}}
+  |              ^
+
+",
+            "message": "Expected pragma, import directive or contract/interface/library/struct/enum/constant/function/error definition.",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 121,
+                "file": "C",
+                "start": 120
+            },
+            "type": "ParserError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_secondary_source_location/output.json b/compiler/test/cmdlineTests/standard_secondary_source_location/output.json
new file mode 100644
index 00000000..6423769a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_secondary_source_location/output.json
@@ -0,0 +1,51 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "3364",
+            "formattedMessage": "DeclarationError: Base constructor arguments given twice.
+ --> A:2:105:
+  |
+2 | pragma solidity >=0.0; contract A { constructor(uint) {} } contract B is A(2) { } contract C is A(3) {} contract D is B, C {}
+  |                                                                                                         ^^^^^^^^^^^^^^^^^^^^^
+Note: First constructor call is here:
+ --> A:2:74:
+  |
+2 | pragma solidity >=0.0; contract A { constructor(uint) {} } contract B is A(2) { } contract C is A(3) {} contract D is B, C {}
+  |                                                                          ^^^^
+Note: Second constructor call is here:
+ --> A:2:97:
+  |
+2 | pragma solidity >=0.0; contract A { constructor(uint) {} } contract B is A(2) { } contract C is A(3) {} contract D is B, C {}
+  |                                                                                                 ^^^^
+
+",
+            "message": "Base constructor arguments given twice.",
+            "secondarySourceLocations":
+            [
+                {
+                    "end": 112,
+                    "file": "A",
+                    "message": "First constructor call is here:",
+                    "start": 108
+                },
+                {
+                    "end": 135,
+                    "file": "A",
+                    "message": "Second constructor call is here:",
+                    "start": 131
+                }
+            ],
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 160,
+                "file": "A",
+                "start": 139
+            },
+            "type": "DeclarationError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/args b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/in.sol b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/in.sol
new file mode 100644
index 00000000..e78a24ff
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+import "A";
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/input.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/input.json
new file mode 100644
index 00000000..34f15749
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/input.json
@@ -0,0 +1,12 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_stop_after_parsing_ast_requested/in.sol"]}
+	},
+	"settings": {
+		"stopAfter": "parsing",
+		"outputSelection": {
+			"*": {"": ["ast"]}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/output.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/output.json
new file mode 100644
index 00000000..6907d478
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_ast_requested/output.json
@@ -0,0 +1,54 @@
+{
+    "sources":
+    {
+        "C":
+        {
+            "ast":
+            {
+                "absolutePath": "C",
+                "id": 4,
+                "license": "GPL-3.0",
+                "nodeType": "SourceUnit",
+                "nodes":
+                [
+                    {
+                        "id": 1,
+                        "literals":
+                        [
+                            "solidity",
+                            "*"
+                        ],
+                        "nodeType": "PragmaDirective",
+                        "src": "36:18:0"
+                    },
+                    {
+                        "absolutePath": "A",
+                        "file": "A",
+                        "id": 2,
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "ImportDirective",
+                        "src": "56:11:0",
+                        "symbolAliases": [],
+                        "unitAlias": ""
+                    },
+                    {
+                        "abstract": false,
+                        "baseContracts": [],
+                        "contractDependencies": [],
+                        "contractKind": "contract",
+                        "id": 3,
+                        "name": "C",
+                        "nameLocation": "78:1:0",
+                        "nodeType": "ContractDefinition",
+                        "nodes": [],
+                        "src": "69:13:0",
+                        "usedErrors": [],
+                        "usedEvents": []
+                    }
+                ],
+                "src": "36:47:0"
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/args b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/in.sol b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/in.sol
new file mode 100644
index 00000000..e78a24ff
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/in.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+import "A";
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/input.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/input.json
new file mode 100644
index 00000000..7ef3d37f
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/input.json
@@ -0,0 +1,12 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_stop_after_parsing_bytecode_requested/in.sol"]}
+	},
+	"settings": {
+		"stopAfter": "parsing",
+		"outputSelection": {
+			"*": {"*": ["evm.bytecode.object"]}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/output.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/output.json
new file mode 100644
index 00000000..37195309
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_bytecode_requested/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Requested output selection conflicts with \"settings.stopAfter\".",
+            "message": "Requested output selection conflicts with \"settings.stopAfter\".",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/args b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/in.sol b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/in.sol
new file mode 100644
index 00000000..978517b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/in.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+import "A";
+
+contract C {
+    function f() public {}
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/input.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/input.json
new file mode 100644
index 00000000..ac4d623c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/input.json
@@ -0,0 +1,19 @@
+{
+	"language": "Solidity",
+	"sources": {
+		"C": {"urls": ["standard_stop_after_parsing_non_binary_output_requested/in.sol"]}
+	},
+	"settings": {
+		"stopAfter": "parsing",
+		"outputSelection": {
+			"*": {"*": [
+				"abi",
+				"devdoc",
+				"userdoc",
+				"metadata",
+				"storageLayout",
+				"evm.methodIdentifiers"
+			]}
+		}
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/output.json b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/output.json
new file mode 100644
index 00000000..5b64763b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_stop_after_parsing_non_binary_output_requested/output.json
@@ -0,0 +1,9 @@
+{
+    "sources":
+    {
+        "C":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_urls_existing_and_missing/contract.sol b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/contract.sol
new file mode 100644
index 00000000..a32f63f7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/contract.sol
@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
diff --git a/compiler/test/cmdlineTests/standard_urls_existing_and_missing/input.json b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/input.json
new file mode 100644
index 00000000..686e8128
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/input.json
@@ -0,0 +1,13 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "url_not_found.sol": {
+            "urls": [
+                "standard_urls_existing_and_missing/non-existent-contract-1.sol",
+                "standard_urls_existing_and_missing/contract.sol",
+                "standard_urls_existing_and_missing/non-existent-contract-2.sol"
+            ]
+        }
+    },
+    "settings": {"outputSelection": {"*": { "*": ["metadata", "evm.bytecode"]}}}
+}
diff --git a/compiler/test/cmdlineTests/standard_urls_existing_and_missing/output.json b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/output.json
new file mode 100644
index 00000000..87db5f4d
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_existing_and_missing/output.json
@@ -0,0 +1,19 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Cannot import url (\"standard_urls_existing_and_missing/non-existent-contract-1.sol\"): File not found. Searched the following locations: \"\".",
+            "message": "Cannot import url (\"standard_urls_existing_and_missing/non-existent-contract-1.sol\"): File not found. Searched the following locations: \"\".",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "url_not_found.sol":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_urls_missing/contract.sol b/compiler/test/cmdlineTests/standard_urls_missing/contract.sol
new file mode 100644
index 00000000..a32f63f7
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_missing/contract.sol
@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
diff --git a/compiler/test/cmdlineTests/standard_urls_missing/input.json b/compiler/test/cmdlineTests/standard_urls_missing/input.json
new file mode 100644
index 00000000..fecc50eb
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_missing/input.json
@@ -0,0 +1,13 @@
+{
+    "language": "Solidity",
+    "sources": {
+        "url_not_found.sol": {
+            "urls": [
+                "standard_urls_missing/non-existent-contract-1.sol",
+                "standard_urls_missing/non-existent-contract.sol",
+                "standard_urls_missing/non-existent-contract-2.sol"
+            ]
+        }
+    },
+    "settings": {"outputSelection": {"*": { "*": ["metadata", "evm.bytecode"]}}}
+}
diff --git a/compiler/test/cmdlineTests/standard_urls_missing/output.json b/compiler/test/cmdlineTests/standard_urls_missing/output.json
new file mode 100644
index 00000000..267618ee
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_urls_missing/output.json
@@ -0,0 +1,27 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Cannot import url (\"standard_urls_missing/non-existent-contract-1.sol\"): File not found. Searched the following locations: \"\".",
+            "message": "Cannot import url (\"standard_urls_missing/non-existent-contract-1.sol\"): File not found. Searched the following locations: \"\".",
+            "severity": "error",
+            "type": "IOError"
+        },
+        {
+            "component": "general",
+            "formattedMessage": "Cannot import url (\"standard_urls_missing/non-existent-contract.sol\"): File not found. Searched the following locations: \"\".",
+            "message": "Cannot import url (\"standard_urls_missing/non-existent-contract.sol\"): File not found. Searched the following locations: \"\".",
+            "severity": "error",
+            "type": "IOError"
+        },
+        {
+            "component": "general",
+            "formattedMessage": "Cannot import url (\"standard_urls_missing/non-existent-contract-2.sol\"): File not found. Searched the following locations: \"\".",
+            "message": "Cannot import url (\"standard_urls_missing/non-existent-contract-2.sol\"): File not found. Searched the following locations: \"\".",
+            "severity": "error",
+            "type": "IOError"
+        }
+    ],
+    "sources": {}
+}
diff --git a/compiler/test/cmdlineTests/standard_viair_requested/output.json b/compiler/test/cmdlineTests/standard_viair_requested/output.json
new file mode 100644
index 00000000..3e459c56
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_viair_requested/output.json
@@ -0,0 +1,332 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "generatedSources": [],
+                        "object": "<BYTECODE REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                },
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_3\" {
+    code {
+        /// @src 0:79:92  \"contract C {}\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_3()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_3_deployed\"), datasize(\"C_3_deployed\"))
+
+        return(_1, datasize(\"C_3_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:79:92  \"contract C {}\"
+        function constructor_C_3() {
+
+            /// @src 0:79:92  \"contract C {}\"
+
+        }
+        /// @src 0:79:92  \"contract C {}\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_3_deployed\" {
+        code {
+            /// @src 0:79:92  \"contract C {}\"
+            mstore(64, memoryguard(128))
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            },
+            "D":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "generatedSources": [],
+                        "object": "<BYTECODE REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "object": "<BYTECODE REMOVED>"
+                    }
+                },
+                "ir": "
+/// @use-src 0:\"A\"
+object \"D_16\" {
+    code {
+        /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_D_16()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"D_16_deployed\"), datasize(\"D_16_deployed\"))
+
+        return(_1, datasize(\"D_16_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+        function constructor_D_16() {
+
+            /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+
+        }
+        /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"D_16_deployed\" {
+        code {
+            /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_15()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function abi_encode_tuple__to__fromStack(headStart ) -> tail {
+                tail := add(headStart, 0)
+
+            }
+
+            function external_fun_f_15() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_15()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos  )
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function revert_forward_1() {
+                let pos := allocate_unbounded()
+                returndatacopy(pos, 0, returndatasize())
+                revert(pos, returndatasize())
+            }
+
+            /// @ast-id 15
+            /// @src 0:106:144  \"function f() public { C c = new C(); }\"
+            function fun_f_15() {
+
+                /// @src 0:134:141  \"new C()\"
+                let _1 := allocate_unbounded()
+                let _2 := add(_1, datasize(\"C_3\"))
+                if or(gt(_2, 0xffffffffffffffff), lt(_2, _1)) { panic_error_0x41() }
+                datacopy(_1, dataoffset(\"C_3\"), datasize(\"C_3\"))
+                _2 := abi_encode_tuple__to__fromStack(_2)
+
+                let expr_12_address := create(0, _1, sub(_2, _1))
+
+                if iszero(expr_12_address) { revert_forward_1() }
+
+                /// @src 0:128:141  \"C c = new C()\"
+                let var_c_8_address := expr_12_address
+
+            }
+            /// @src 0:93:146  \"contract D { function f() public { C c = new C(); } }\"
+
+        }
+
+        /// @use-src 0:\"A\"
+        object \"C_3\" {
+            code {
+                /// @src 0:79:92  \"contract C {}\"
+                mstore(64, memoryguard(128))
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+                constructor_C_3()
+
+                let _1 := allocate_unbounded()
+                codecopy(_1, dataoffset(\"C_3_deployed\"), datasize(\"C_3_deployed\"))
+
+                return(_1, datasize(\"C_3_deployed\"))
+
+                function allocate_unbounded() -> memPtr {
+                    memPtr := mload(64)
+                }
+
+                function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                    revert(0, 0)
+                }
+
+                /// @src 0:79:92  \"contract C {}\"
+                function constructor_C_3() {
+
+                    /// @src 0:79:92  \"contract C {}\"
+
+                }
+                /// @src 0:79:92  \"contract C {}\"
+
+            }
+            /// @use-src 0:\"A\"
+            object \"C_3_deployed\" {
+                code {
+                    /// @src 0:79:92  \"contract C {}\"
+                    mstore(64, memoryguard(128))
+
+                    revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+                    function shift_right_224_unsigned(value) -> newValue {
+                        newValue :=
+
+                        shr(224, value)
+
+                    }
+
+                    function allocate_unbounded() -> memPtr {
+                        memPtr := mload(64)
+                    }
+
+                    function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                        revert(0, 0)
+                    }
+
+                }
+
+                data \".metadata\" hex\"<BYTECODE REMOVED>\"
+            }
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "errors":
+    [
+        {
+            "component": "general",
+            "errorCode": "2072",
+            "formattedMessage": "Warning: Unused local variable.
+ --> A:2:93:
+  |
+2 | pragma solidity >=0.0; pragma abicoder v2; contract C {} contract D { function f() public { C c = new C(); } }
+  |                                                                                             ^^^
+
+",
+            "message": "Unused local variable.",
+            "severity": "warning",
+            "sourceLocation":
+            {
+                "end": 131,
+                "file": "A",
+                "start": 128
+            },
+            "type": "Warning"
+        }
+    ],
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_auxiliary_input/output.json b/compiler/test/cmdlineTests/standard_wrong_key_auxiliary_input/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_auxiliary_input/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_metadata/output.json b/compiler/test/cmdlineTests/standard_wrong_key_metadata/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_metadata/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_optimizer/output.json b/compiler/test/cmdlineTests/standard_wrong_key_optimizer/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_optimizer/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_root/output.json b/compiler/test/cmdlineTests/standard_wrong_key_root/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_root/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_settings/output.json b/compiler/test/cmdlineTests/standard_wrong_key_settings/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_settings/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_key_source/output.json b/compiler/test/cmdlineTests/standard_wrong_key_source/output.json
new file mode 100644
index 00000000..1e846d19
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_key_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Unknown key \"key1\"",
+            "message": "Unknown key \"key1\"",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input/output.json b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input/output.json
new file mode 100644
index 00000000..877ecad4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"auxiliaryInput\" must be an object",
+            "message": "\"auxiliaryInput\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses/output.json b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses/output.json
new file mode 100644
index 00000000..c2823814
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"auxiliaryInput.smtlib2responses\" must be an object.",
+            "message": "\"auxiliaryInput.smtlib2responses\" must be an object.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses_member/output.json b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses_member/output.json
new file mode 100644
index 00000000..6676998c
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_auxiliary_input_smtlib2responses_member/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"smtlib2Responses.abc\" must be a string.",
+            "message": "\"smtlib2Responses.abc\" must be a string.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_metadata/output.json b/compiler/test/cmdlineTests/standard_wrong_type_metadata/output.json
new file mode 100644
index 00000000..df9f8cae
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_metadata/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.metadata\" must be an object",
+            "message": "\"settings.metadata\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_optimizer/output.json b/compiler/test/cmdlineTests/standard_wrong_type_optimizer/output.json
new file mode 100644
index 00000000..d7ce3032
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_optimizer/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.optimizer\" must be an object",
+            "message": "\"settings.optimizer\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_output_selection/output.json b/compiler/test/cmdlineTests/standard_wrong_type_output_selection/output.json
new file mode 100644
index 00000000..d7d8f563
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_output_selection/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.outputSelection\" must be an object",
+            "message": "\"settings.outputSelection\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_output_selection_contract/output.json b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_contract/output.json
new file mode 100644
index 00000000..5a35419e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_contract/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.outputSelection.fileA.A\" must be a string array",
+            "message": "\"settings.outputSelection.fileA.A\" must be a string array",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_output_selection_file/output.json b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_file/output.json
new file mode 100644
index 00000000..888efc75
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_file/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.outputSelection.fileA\" must be an object",
+            "message": "\"settings.outputSelection.fileA\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_output_selection_output/output.json b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_output/output.json
new file mode 100644
index 00000000..5a35419e
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_output_selection_output/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.outputSelection.fileA.A\" must be a string array",
+            "message": "\"settings.outputSelection.fileA.A\" must be a string array",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_remappings/output.json b/compiler/test/cmdlineTests/standard_wrong_type_remappings/output.json
new file mode 100644
index 00000000..b9491907
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_remappings/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.remappings\" must be an array of strings.",
+            "message": "\"settings.remappings\" must be an array of strings.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_remappings_entry/output.json b/compiler/test/cmdlineTests/standard_wrong_type_remappings_entry/output.json
new file mode 100644
index 00000000..d083c85b
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_remappings_entry/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.remappings\" must be an array of strings",
+            "message": "\"settings.remappings\" must be an array of strings",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_root/output.json b/compiler/test/cmdlineTests/standard_wrong_type_root/output.json
new file mode 100644
index 00000000..da8fefdf
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_root/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Input is not a JSON object.",
+            "message": "Input is not a JSON object.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_settings/output.json b/compiler/test/cmdlineTests/standard_wrong_type_settings/output.json
new file mode 100644
index 00000000..a25071c8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_settings/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings\" must be an object",
+            "message": "\"settings\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_source/output.json b/compiler/test/cmdlineTests/standard_wrong_type_source/output.json
new file mode 100644
index 00000000..98496c64
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_source/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"sources.A\" must be an object",
+            "message": "\"sources.A\" must be an object",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_sources/output.json b/compiler/test/cmdlineTests/standard_wrong_type_sources/output.json
new file mode 100644
index 00000000..3f5f51fc
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_sources/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"sources\" is not a JSON object.",
+            "message": "\"sources\" is not a JSON object.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_wrong_type_useLiteralContent/output.json b/compiler/test/cmdlineTests/standard_wrong_type_useLiteralContent/output.json
new file mode 100644
index 00000000..7135c985
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_wrong_type_useLiteralContent/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "\"settings.metadata.useLiteralContent\" must be Boolean",
+            "message": "\"settings.metadata.useLiteralContent\" must be Boolean",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_yul/output.json b/compiler/test/cmdlineTests/standard_yul/output.json
new file mode 100644
index 00000000..c1b22726
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul/output.json
@@ -0,0 +1,175 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "object":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":38:39   */
+  0x00
+    /* \"A\":11:19   */
+  dup1
+  dup1
+  mload
+    /* \"A\":27:36   */
+  add
+    /* \"A\":20:40   */
+  sstore
+    /* \"A\":0:42   */
+  stop
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                },
+                "ir": "object \"object\" {
+    code {
+        let x := mload(0)
+        sstore(add(x, 0), 0)
+    }
+}
+",
+                "irOptimized": "object \"object\" {
+    code {
+        {
+            let x := mload(0)
+            sstore(add(x, 0), 0)
+        }
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "code":
+                {
+                    "block":
+                    {
+                        "nativeSrc": "0:42:0",
+                        "nodeType": "YulBlock",
+                        "src": "0:42:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "2:17:0",
+                                "nodeType": "YulVariableDeclaration",
+                                "src": "2:17:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "17:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "17:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "mload",
+                                        "nativeSrc": "11:5:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "11:5:0"
+                                    },
+                                    "nativeSrc": "11:8:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "11:8:0"
+                                },
+                                "variables":
+                                [
+                                    {
+                                        "name": "x",
+                                        "nativeSrc": "6:1:0",
+                                        "nodeType": "YulTypedName",
+                                        "src": "6:1:0",
+                                        "type": ""
+                                    }
+                                ]
+                            },
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "name": "x",
+                                                    "nativeSrc": "31:1:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "31:1:0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "34:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "34:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "add",
+                                                "nativeSrc": "27:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "27:3:0"
+                                            },
+                                            "nativeSrc": "27:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "27:9:0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "38:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "38:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "sstore",
+                                        "nativeSrc": "20:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "20:6:0"
+                                    },
+                                    "nativeSrc": "20:20:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "20:20:0"
+                                },
+                                "nativeSrc": "20:20:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "20:20:0"
+                            }
+                        ]
+                    },
+                    "nodeType": "YulCode"
+                },
+                "name": "object",
+                "nodeType": "YulObject",
+                "subObjects": []
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/args b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/in.yul b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/in.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/in.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/output.json b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/output.json
new file mode 100644
index 00000000..9d675a06
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_all/output.json
@@ -0,0 +1,26 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C_6_deployed":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"input.sol\":60:101   */
+  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump\t// in
+tag_2:
+  stop
+    /* \"input.sol\":77:99   */
+tag_1:
+  sstore(0x00, 0x2a)
+  jump\t// out
+"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/args b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/in.yul b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/in.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/in.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/output.json b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/output.json
new file mode 100644
index 00000000..8cbbd326
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_location_only/output.json
@@ -0,0 +1,26 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C_6_deployed":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"input.sol\":60:101 */
+  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump\t// in
+tag_2:
+  stop
+    /* \"input.sol\":77:99 */
+tag_1:
+  sstore(0x00, 0x2a)
+  jump\t// out
+"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/args b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/in.yul b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/in.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/in.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/output.json b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/output.json
new file mode 100644
index 00000000..d1e4cff4
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_none/output.json
@@ -0,0 +1,24 @@
+{
+    "contracts":
+    {
+        "C":
+        {
+            "C_6_deployed":
+            {
+                "evm":
+                {
+                    "assembly": "  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump\t// in
+tag_2:
+  stop
+tag_1:
+  sstore(0x00, 0x2a)
+  jump\t// out
+"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/args b/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/in.yul b/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/in.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_debug_info_print_snippet_only/in.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_embedded_object_name/output.json b/compiler/test/cmdlineTests/standard_yul_embedded_object_name/output.json
new file mode 100644
index 00000000..2c63c085
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_embedded_object_name/output.json
@@ -0,0 +1,2 @@
+{
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/input.json b/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/input.json
new file mode 100644
index 00000000..f51ffed8
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Yul",
+	"sources": {
+		"input.yul": {"content": "{}"}
+	},
+	"settings": {
+		"evmVersion": "byzantium"
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/output.json b/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/output.json
new file mode 100644
index 00000000..9fff5627
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_evm_version_byzantium/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "message": "Support for EVM versions older than constantinople is deprecated and will be removed in the future.",
+            "severity": "warning",
+            "type": "Warning"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/input.json b/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/input.json
new file mode 100644
index 00000000..9b0043cf
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/input.json
@@ -0,0 +1,9 @@
+{
+	"language": "Yul",
+	"sources": {
+		"input.yul": {"content": "{}"}
+	},
+	"settings": {
+		"evmVersion": "constantinople"
+	}
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/output.json b/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/output.json
new file mode 100644
index 00000000..2c63c085
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_evm_version_constantinople/output.json
@@ -0,0 +1,2 @@
+{
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_immutable_references/output.json b/compiler/test/cmdlineTests/standard_yul_immutable_references/output.json
new file mode 100644
index 00000000..1f75e8ad
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_immutable_references/output.json
@@ -0,0 +1,42 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "YulTest":
+            {
+                "evm":
+                {
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "immutableReferences":
+                        {
+                            "test":
+                            [
+                                {
+                                    "length": 32,
+                                    "start": 1
+                                }
+                            ]
+                        },
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_invalid_object_name/output.json b/compiler/test/cmdlineTests/standard_yul_invalid_object_name/output.json
new file mode 100644
index 00000000..2c63c085
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_invalid_object_name/output.json
@@ -0,0 +1,2 @@
+{
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_multiple_files/output.json b/compiler/test/cmdlineTests/standard_yul_multiple_files/output.json
new file mode 100644
index 00000000..cdef28c2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_multiple_files/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Yul mode only supports exactly one input file.",
+            "message": "Yul mode only supports exactly one input file.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_multiple_files_selected/output.json b/compiler/test/cmdlineTests/standard_yul_multiple_files_selected/output.json
new file mode 100644
index 00000000..cdef28c2
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_multiple_files_selected/output.json
@@ -0,0 +1,12 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "Yul mode only supports exactly one input file.",
+            "message": "Yul mode only supports exactly one input file.",
+            "severity": "error",
+            "type": "JSONError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_object/output.json b/compiler/test/cmdlineTests/standard_yul_object/output.json
new file mode 100644
index 00000000..1404cd3a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_object/output.json
@@ -0,0 +1,185 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "NamedObject":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":80:81   */
+  0x00
+    /* \"A\":39:61   */
+  dup1
+  data_4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
+    /* \"A\":69:78   */
+  add
+    /* \"A\":62:82   */
+  sstore
+    /* \"A\":28:84   */
+  stop
+stop
+data_4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45 616263
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                },
+                "ir": "object \"NamedObject\" {
+    code {
+        let x := dataoffset(\"DataName\")
+        sstore(add(x, 0), 0)
+    }
+    data \"DataName\" hex\"616263\"
+}
+",
+                "irOptimized": "object \"NamedObject\" {
+    code {
+        {
+            let x := dataoffset(\"DataName\")
+            sstore(add(x, 0), 0)
+        }
+    }
+    data \"DataName\" hex\"616263\"
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "code":
+                {
+                    "block":
+                    {
+                        "nativeSrc": "28:56:0",
+                        "nodeType": "YulBlock",
+                        "src": "28:56:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "30:31:0",
+                                "nodeType": "YulVariableDeclaration",
+                                "src": "30:31:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "hexValue": "446174614e616d65",
+                                            "kind": "string",
+                                            "nativeSrc": "50:10:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "50:10:0",
+                                            "type": "",
+                                            "value": "DataName"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "dataoffset",
+                                        "nativeSrc": "39:10:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "39:10:0"
+                                    },
+                                    "nativeSrc": "39:22:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "39:22:0"
+                                },
+                                "variables":
+                                [
+                                    {
+                                        "name": "x",
+                                        "nativeSrc": "34:1:0",
+                                        "nodeType": "YulTypedName",
+                                        "src": "34:1:0",
+                                        "type": ""
+                                    }
+                                ]
+                            },
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "name": "x",
+                                                    "nativeSrc": "73:1:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "73:1:0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "76:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "76:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "add",
+                                                "nativeSrc": "69:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "69:3:0"
+                                            },
+                                            "nativeSrc": "69:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "69:9:0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "80:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "80:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "sstore",
+                                        "nativeSrc": "62:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "62:6:0"
+                                    },
+                                    "nativeSrc": "62:20:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "62:20:0"
+                                },
+                                "nativeSrc": "62:20:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "62:20:0"
+                            }
+                        ]
+                    },
+                    "nodeType": "YulCode"
+                },
+                "name": "NamedObject",
+                "nodeType": "YulObject",
+                "subObjects":
+                [
+                    {
+                        "nodeType": "YulData",
+                        "value": "616263"
+                    }
+                ]
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_object_invalid_sub/output.json b/compiler/test/cmdlineTests/standard_yul_object_invalid_sub/output.json
new file mode 100644
index 00000000..98522145
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_object_invalid_sub/output.json
@@ -0,0 +1,24 @@
+{
+    "errors":
+    [
+        {
+            "component": "general",
+            "formattedMessage": "TypeError: Unknown data object \"NamedObject.\".
+ --> A:1:51:
+  |
+1 | object \"NamedObject\" { code { let x := dataoffset(\"NamedObject.\") sstore(add(x, 0), 0) } object \"OtherObject\" { code { revert(0, 0) } } }
+  |                                                   ^^^^^^^^^^^^^^
+
+",
+            "message": "Unknown data object \"NamedObject.\".",
+            "severity": "error",
+            "sourceLocation":
+            {
+                "end": 64,
+                "file": "A",
+                "start": 50
+            },
+            "type": "TypeError"
+        }
+    ]
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_object_name/output.json b/compiler/test/cmdlineTests/standard_yul_object_name/output.json
new file mode 100644
index 00000000..6803c322
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_object_name/output.json
@@ -0,0 +1,264 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "NamedObject":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":80:81   */
+  0x00
+    /* \"A\":39:61   */
+  dup1
+  data_4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
+    /* \"A\":69:78   */
+  add
+    /* \"A\":62:82   */
+  sstore
+    /* \"A\":28:84   */
+  stop
+stop
+data_4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45 616263
+
+sub_0: assembly {
+        /* \"A\":147:148   */
+      0x00
+        /* \"A\":137:149   */
+      dup1
+      revert
+}
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    },
+                    "deployedBytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "immutableReferences": {},
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                },
+                "ir": "object \"NamedObject\" {
+    code {
+        let x := dataoffset(\"DataName\")
+        sstore(add(x, 0), 0)
+    }
+    data \"DataName\" hex\"616263\"
+    object \"OtherObject\" {
+        code { revert(0, 0) }
+    }
+}
+",
+                "irOptimized": "object \"NamedObject\" {
+    code {
+        {
+            let x := dataoffset(\"DataName\")
+            sstore(add(x, 0), 0)
+        }
+    }
+    data \"DataName\" hex\"616263\"
+    object \"OtherObject\" {
+        code { { revert(0, 0) } }
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "code":
+                {
+                    "block":
+                    {
+                        "nativeSrc": "28:56:0",
+                        "nodeType": "YulBlock",
+                        "src": "28:56:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "30:31:0",
+                                "nodeType": "YulVariableDeclaration",
+                                "src": "30:31:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "hexValue": "446174614e616d65",
+                                            "kind": "string",
+                                            "nativeSrc": "50:10:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "50:10:0",
+                                            "type": "",
+                                            "value": "DataName"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "dataoffset",
+                                        "nativeSrc": "39:10:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "39:10:0"
+                                    },
+                                    "nativeSrc": "39:22:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "39:22:0"
+                                },
+                                "variables":
+                                [
+                                    {
+                                        "name": "x",
+                                        "nativeSrc": "34:1:0",
+                                        "nodeType": "YulTypedName",
+                                        "src": "34:1:0",
+                                        "type": ""
+                                    }
+                                ]
+                            },
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "name": "x",
+                                                    "nativeSrc": "73:1:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "73:1:0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "76:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "76:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "add",
+                                                "nativeSrc": "69:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "69:3:0"
+                                            },
+                                            "nativeSrc": "69:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "69:9:0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "80:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "80:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "sstore",
+                                        "nativeSrc": "62:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "62:6:0"
+                                    },
+                                    "nativeSrc": "62:20:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "62:20:0"
+                                },
+                                "nativeSrc": "62:20:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "62:20:0"
+                            }
+                        ]
+                    },
+                    "nodeType": "YulCode"
+                },
+                "name": "NamedObject",
+                "nodeType": "YulObject",
+                "subObjects":
+                [
+                    {
+                        "nodeType": "YulData",
+                        "value": "616263"
+                    },
+                    {
+                        "code":
+                        {
+                            "block":
+                            {
+                                "nativeSrc": "135:16:0",
+                                "nodeType": "YulBlock",
+                                "src": "135:16:0",
+                                "statements":
+                                [
+                                    {
+                                        "expression":
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "144:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "144:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "147:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "147:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "revert",
+                                                "nativeSrc": "137:6:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "137:6:0"
+                                            },
+                                            "nativeSrc": "137:12:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "137:12:0"
+                                        },
+                                        "nativeSrc": "137:12:0",
+                                        "nodeType": "YulExpressionStatement",
+                                        "src": "137:12:0"
+                                    }
+                                ]
+                            },
+                            "nodeType": "YulCode"
+                        },
+                        "name": "OtherObject",
+                        "nodeType": "YulObject",
+                        "subObjects": []
+                    }
+                ]
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_optimiserSteps/output.json b/compiler/test/cmdlineTests/standard_yul_optimiserSteps/output.json
new file mode 100644
index 00000000..85a34261
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_optimiserSteps/output.json
@@ -0,0 +1,172 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "object":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":38:39   */
+  0x00
+    /* \"A\":11:19   */
+  dup1
+  mload
+    /* \"A\":20:40   */
+  sstore
+    /* \"A\":0:42   */
+  stop
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                },
+                "ir": "object \"object\" {
+    code {
+        let x := mload(0)
+        sstore(add(x, 0), 0)
+    }
+}
+",
+                "irOptimized": "object \"object\" {
+    code {
+        {
+            let x := mload(0)
+            sstore(add(x, 0), 0)
+        }
+    }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "code":
+                {
+                    "block":
+                    {
+                        "nativeSrc": "0:42:0",
+                        "nodeType": "YulBlock",
+                        "src": "0:42:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "2:17:0",
+                                "nodeType": "YulVariableDeclaration",
+                                "src": "2:17:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "17:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "17:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "mload",
+                                        "nativeSrc": "11:5:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "11:5:0"
+                                    },
+                                    "nativeSrc": "11:8:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "11:8:0"
+                                },
+                                "variables":
+                                [
+                                    {
+                                        "name": "x",
+                                        "nativeSrc": "6:1:0",
+                                        "nodeType": "YulTypedName",
+                                        "src": "6:1:0",
+                                        "type": ""
+                                    }
+                                ]
+                            },
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "name": "x",
+                                                    "nativeSrc": "31:1:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "31:1:0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "34:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "34:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "add",
+                                                "nativeSrc": "27:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "27:3:0"
+                                            },
+                                            "nativeSrc": "27:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "27:9:0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "38:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "38:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "sstore",
+                                        "nativeSrc": "20:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "20:6:0"
+                                    },
+                                    "nativeSrc": "20:20:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "20:20:0"
+                                },
+                                "nativeSrc": "20:20:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "20:20:0"
+                            }
+                        ]
+                    },
+                    "nodeType": "YulCode"
+                },
+                "name": "object",
+                "nodeType": "YulObject",
+                "subObjects": []
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_optimized/output.json b/compiler/test/cmdlineTests/standard_yul_optimized/output.json
new file mode 100644
index 00000000..d580ef6a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_optimized/output.json
@@ -0,0 +1,167 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "object":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":17:18   */
+  0x00
+    /* \"A\":11:19   */
+  dup1
+  mload
+    /* \"A\":20:40   */
+  sstore
+    /* \"A\":0:42   */
+  stop
+",
+                    "bytecode":
+                    {
+                        "functionDebugData": {},
+                        "generatedSources": [],
+                        "linkReferences": {},
+                        "object": "<BYTECODE REMOVED>",
+                        "opcodes":"<OPCODES REMOVED>",
+                        "sourceMap":"<SOURCEMAP REMOVED>"
+                    }
+                },
+                "ir": "object \"object\" {
+    code {
+        let x := mload(0)
+        sstore(add(x, 0), 0)
+    }
+}
+",
+                "irOptimized": "object \"object\" {
+    code { { sstore(mload(0), 0) } }
+}
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "ast":
+            {
+                "code":
+                {
+                    "block":
+                    {
+                        "nativeSrc": "0:42:0",
+                        "nodeType": "YulBlock",
+                        "src": "0:42:0",
+                        "statements":
+                        [
+                            {
+                                "nativeSrc": "2:17:0",
+                                "nodeType": "YulVariableDeclaration",
+                                "src": "2:17:0",
+                                "value":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "17:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "17:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "mload",
+                                        "nativeSrc": "11:5:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "11:5:0"
+                                    },
+                                    "nativeSrc": "11:8:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "11:8:0"
+                                },
+                                "variables":
+                                [
+                                    {
+                                        "name": "x",
+                                        "nativeSrc": "6:1:0",
+                                        "nodeType": "YulTypedName",
+                                        "src": "6:1:0",
+                                        "type": ""
+                                    }
+                                ]
+                            },
+                            {
+                                "expression":
+                                {
+                                    "arguments":
+                                    [
+                                        {
+                                            "arguments":
+                                            [
+                                                {
+                                                    "name": "x",
+                                                    "nativeSrc": "31:1:0",
+                                                    "nodeType": "YulIdentifier",
+                                                    "src": "31:1:0"
+                                                },
+                                                {
+                                                    "kind": "number",
+                                                    "nativeSrc": "34:1:0",
+                                                    "nodeType": "YulLiteral",
+                                                    "src": "34:1:0",
+                                                    "type": "",
+                                                    "value": "0"
+                                                }
+                                            ],
+                                            "functionName":
+                                            {
+                                                "name": "add",
+                                                "nativeSrc": "27:3:0",
+                                                "nodeType": "YulIdentifier",
+                                                "src": "27:3:0"
+                                            },
+                                            "nativeSrc": "27:9:0",
+                                            "nodeType": "YulFunctionCall",
+                                            "src": "27:9:0"
+                                        },
+                                        {
+                                            "kind": "number",
+                                            "nativeSrc": "38:1:0",
+                                            "nodeType": "YulLiteral",
+                                            "src": "38:1:0",
+                                            "type": "",
+                                            "value": "0"
+                                        }
+                                    ],
+                                    "functionName":
+                                    {
+                                        "name": "sstore",
+                                        "nativeSrc": "20:6:0",
+                                        "nodeType": "YulIdentifier",
+                                        "src": "20:6:0"
+                                    },
+                                    "nativeSrc": "20:20:0",
+                                    "nodeType": "YulFunctionCall",
+                                    "src": "20:20:0"
+                                },
+                                "nativeSrc": "20:20:0",
+                                "nodeType": "YulExpressionStatement",
+                                "src": "20:20:0"
+                            }
+                        ]
+                    },
+                    "nodeType": "YulCode"
+                },
+                "name": "object",
+                "nodeType": "YulObject",
+                "subObjects": []
+            },
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_single_file_via_urls/args b/compiler/test/cmdlineTests/standard_yul_single_file_via_urls/args
new file mode 100644
index 00000000..18532c5a
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_single_file_via_urls/args
@@ -0,0 +1 @@
+--allow-paths .
diff --git a/compiler/test/cmdlineTests/standard_yul_stack_opt/output.json b/compiler/test/cmdlineTests/standard_yul_stack_opt/output.json
new file mode 100644
index 00000000..e10ef0c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_stack_opt/output.json
@@ -0,0 +1,29 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "object":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":16:17   */
+  0x01
+    /* \"A\":27:28   */
+  0x00
+    /* \"A\":20:32   */
+  sstore
+    /* \"A\":50:51   */
+  0x02
+    /* \"A\":61:63   */
+  0x20
+    /* \"A\":54:67   */
+  sstore
+    /* \"A\":0:72   */
+  stop
+"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/standard_yul_stack_opt_disabled/output.json b/compiler/test/cmdlineTests/standard_yul_stack_opt_disabled/output.json
new file mode 100644
index 00000000..8d58cf32
--- /dev/null
+++ b/compiler/test/cmdlineTests/standard_yul_stack_opt_disabled/output.json
@@ -0,0 +1,27 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "object":
+            {
+                "evm":
+                {
+                    "assembly": "    /* \"A\":16:17   */
+  0x01
+    /* \"A\":27:28   */
+  0x00
+    /* \"A\":20:32   */
+  sstore
+    /* \"A\":50:51   */
+  0x02
+    /* \"A\":61:63   */
+  0x20
+    /* \"A\":54:67   */
+  sstore
+"
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_abi/args b/compiler/test/cmdlineTests/stop_after_parsing_abi/args
new file mode 100644
index 00000000..9ec9f63e
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_abi/args
@@ -0,0 +1 @@
+--pretty-json --json-indent 4 --stop-after parsing --abi
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_abi/err b/compiler/test/cmdlineTests/stop_after_parsing_abi/err
new file mode 100644
index 00000000..ae3fb5d0
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_abi/err
@@ -0,0 +1 @@
+Error: The following options are mutually exclusive: --stop-after, --abi. Select at most one.
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_abi/exit b/compiler/test/cmdlineTests/stop_after_parsing_abi/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_abi/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_abi/input.sol b/compiler/test/cmdlineTests/stop_after_parsing_abi/input.sol
new file mode 100644
index 00000000..978517b3
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_abi/input.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+import "A";
+
+contract C {
+    function f() public {}
+}
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_ast/args b/compiler/test/cmdlineTests/stop_after_parsing_ast/args
new file mode 100644
index 00000000..72df9974
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_ast/args
@@ -0,0 +1 @@
+--pretty-json --json-indent 4 --stop-after parsing --ast-compact-json
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_ast/input.sol b/compiler/test/cmdlineTests/stop_after_parsing_ast/input.sol
new file mode 100644
index 00000000..e78a24ff
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_ast/input.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+import "A";
+
+contract C {}
diff --git a/compiler/test/cmdlineTests/stop_after_parsing_ast/output b/compiler/test/cmdlineTests/stop_after_parsing_ast/output
new file mode 100644
index 00000000..16394186
--- /dev/null
+++ b/compiler/test/cmdlineTests/stop_after_parsing_ast/output
@@ -0,0 +1,48 @@
+JSON AST (compact format):
+
+
+======= stop_after_parsing_ast/input.sol =======
+{
+    "absolutePath": "stop_after_parsing_ast/input.sol",
+    "id": 4,
+    "license": "GPL-3.0",
+    "nodeType": "SourceUnit",
+    "nodes":
+    [
+        {
+            "id": 1,
+            "literals":
+            [
+                "solidity",
+                "*"
+            ],
+            "nodeType": "PragmaDirective",
+            "src": "36:18:0"
+        },
+        {
+            "absolutePath": "A",
+            "file": "A",
+            "id": 2,
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "ImportDirective",
+            "src": "56:11:0",
+            "symbolAliases": [],
+            "unitAlias": ""
+        },
+        {
+            "abstract": false,
+            "baseContracts": [],
+            "contractDependencies": [],
+            "contractKind": "contract",
+            "id": 3,
+            "name": "C",
+            "nameLocation": "78:1:0",
+            "nodeType": "ContractDefinition",
+            "nodes": [],
+            "src": "69:13:0",
+            "usedErrors": [],
+            "usedEvents": []
+        }
+    ],
+    "src": "36:47:0"
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_bytes/output.json b/compiler/test/cmdlineTests/storage_layout_bytes/output.json
new file mode 100644
index 00000000..c2ca7813
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_bytes/output.json
@@ -0,0 +1,49 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 4,
+                            "contract": "fileA:A",
+                            "label": "s1",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_bytes_storage"
+                        },
+                        {
+                            "astId": 6,
+                            "contract": "fileA:A",
+                            "label": "s2",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_bytes_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_bytes_storage":
+                        {
+                            "encoding": "bytes",
+                            "label": "bytes",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_dyn_array/output.json b/compiler/test/cmdlineTests/storage_layout_dyn_array/output.json
new file mode 100644
index 00000000..fa7ed04b
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_dyn_array/output.json
@@ -0,0 +1,69 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 4,
+                            "contract": "fileA:A",
+                            "label": "array1",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_array(t_uint256)dyn_storage"
+                        },
+                        {
+                            "astId": 7,
+                            "contract": "fileA:A",
+                            "label": "array2",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_array(t_bool)dyn_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_array(t_bool)dyn_storage":
+                        {
+                            "base": "t_bool",
+                            "encoding": "dynamic_array",
+                            "label": "bool[]",
+                            "numberOfBytes": "32"
+                        },
+                        "t_array(t_uint256)dyn_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "dynamic_array",
+                            "label": "uint256[]",
+                            "numberOfBytes": "32"
+                        },
+                        "t_bool":
+                        {
+                            "encoding": "inplace",
+                            "label": "bool",
+                            "numberOfBytes": "1"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_many/output.json b/compiler/test/cmdlineTests/storage_layout_many/output.json
new file mode 100644
index 00000000..68cb0068
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_many/output.json
@@ -0,0 +1,198 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 15,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 17,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 20,
+                            "contract": "fileA:A",
+                            "label": "s",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_struct(S)13_storage"
+                        },
+                        {
+                            "astId": 22,
+                            "contract": "fileA:A",
+                            "label": "addr",
+                            "offset": 0,
+                            "slot": "6",
+                            "type": "t_address"
+                        },
+                        {
+                            "astId": 28,
+                            "contract": "fileA:A",
+                            "label": "map",
+                            "offset": 0,
+                            "slot": "7",
+                            "type": "t_mapping(t_uint256,t_mapping(t_address,t_bool))"
+                        },
+                        {
+                            "astId": 31,
+                            "contract": "fileA:A",
+                            "label": "array",
+                            "offset": 0,
+                            "slot": "8",
+                            "type": "t_array(t_uint256)dyn_storage"
+                        },
+                        {
+                            "astId": 33,
+                            "contract": "fileA:A",
+                            "label": "s1",
+                            "offset": 0,
+                            "slot": "9",
+                            "type": "t_string_storage"
+                        },
+                        {
+                            "astId": 35,
+                            "contract": "fileA:A",
+                            "label": "b1",
+                            "offset": 0,
+                            "slot": "10",
+                            "type": "t_bytes_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_array(t_uint256)2_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "inplace",
+                            "label": "uint256[2]",
+                            "numberOfBytes": "64"
+                        },
+                        "t_array(t_uint256)dyn_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "dynamic_array",
+                            "label": "uint256[]",
+                            "numberOfBytes": "32"
+                        },
+                        "t_bool":
+                        {
+                            "encoding": "inplace",
+                            "label": "bool",
+                            "numberOfBytes": "1"
+                        },
+                        "t_bytes_storage":
+                        {
+                            "encoding": "bytes",
+                            "label": "bytes",
+                            "numberOfBytes": "32"
+                        },
+                        "t_mapping(t_address,t_bool)":
+                        {
+                            "encoding": "mapping",
+                            "key": "t_address",
+                            "label": "mapping(address => bool)",
+                            "numberOfBytes": "32",
+                            "value": "t_bool"
+                        },
+                        "t_mapping(t_uint256,t_mapping(t_address,t_bool))":
+                        {
+                            "encoding": "mapping",
+                            "key": "t_uint256",
+                            "label": "mapping(uint256 => mapping(address => bool))",
+                            "numberOfBytes": "32",
+                            "value": "t_mapping(t_address,t_bool)"
+                        },
+                        "t_string_storage":
+                        {
+                            "encoding": "bytes",
+                            "label": "string",
+                            "numberOfBytes": "32"
+                        },
+                        "t_struct(S)13_storage":
+                        {
+                            "encoding": "inplace",
+                            "label": "struct A.S",
+                            "members":
+                            [
+                                {
+                                    "astId": 3,
+                                    "contract": "fileA:A",
+                                    "label": "a",
+                                    "offset": 0,
+                                    "slot": "0",
+                                    "type": "t_uint128"
+                                },
+                                {
+                                    "astId": 5,
+                                    "contract": "fileA:A",
+                                    "label": "b",
+                                    "offset": 16,
+                                    "slot": "0",
+                                    "type": "t_uint128"
+                                },
+                                {
+                                    "astId": 9,
+                                    "contract": "fileA:A",
+                                    "label": "staticArray",
+                                    "offset": 0,
+                                    "slot": "1",
+                                    "type": "t_array(t_uint256)2_storage"
+                                },
+                                {
+                                    "astId": 12,
+                                    "contract": "fileA:A",
+                                    "label": "dynArray",
+                                    "offset": 0,
+                                    "slot": "3",
+                                    "type": "t_array(t_uint256)dyn_storage"
+                                }
+                            ],
+                            "numberOfBytes": "128"
+                        },
+                        "t_uint128":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint128",
+                            "numberOfBytes": "16"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_mapping/output.json b/compiler/test/cmdlineTests/storage_layout_mapping/output.json
new file mode 100644
index 00000000..8d13fb34
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_mapping/output.json
@@ -0,0 +1,85 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 3,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 5,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 11,
+                            "contract": "fileA:A",
+                            "label": "map",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_mapping(t_uint256,t_mapping(t_address,t_bool))"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_bool":
+                        {
+                            "encoding": "inplace",
+                            "label": "bool",
+                            "numberOfBytes": "1"
+                        },
+                        "t_mapping(t_address,t_bool)":
+                        {
+                            "encoding": "mapping",
+                            "key": "t_address",
+                            "label": "mapping(address => bool)",
+                            "numberOfBytes": "32",
+                            "value": "t_bool"
+                        },
+                        "t_mapping(t_uint256,t_mapping(t_address,t_bool))":
+                        {
+                            "encoding": "mapping",
+                            "key": "t_uint256",
+                            "label": "mapping(uint256 => mapping(address => bool))",
+                            "numberOfBytes": "32",
+                            "value": "t_mapping(t_address,t_bool)"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_smoke/output.json b/compiler/test/cmdlineTests/storage_layout_smoke/output.json
new file mode 100644
index 00000000..9fe46bb6
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_smoke/output.json
@@ -0,0 +1,23 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage": [],
+                    "types": null
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_smoke_two_contracts/output.json b/compiler/test/cmdlineTests/storage_layout_smoke_two_contracts/output.json
new file mode 100644
index 00000000..fc4e422a
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_smoke_two_contracts/output.json
@@ -0,0 +1,27 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage": [],
+                    "types": null
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        },
+        "fileB":
+        {
+            "id": 1
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_string/output.json b/compiler/test/cmdlineTests/storage_layout_string/output.json
new file mode 100644
index 00000000..20c6f64c
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_string/output.json
@@ -0,0 +1,49 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 4,
+                            "contract": "fileA:A",
+                            "label": "s1",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_string_storage"
+                        },
+                        {
+                            "astId": 6,
+                            "contract": "fileA:A",
+                            "label": "s2",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_string_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_string_storage":
+                        {
+                            "encoding": "bytes",
+                            "label": "string",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_struct/output.json b/compiler/test/cmdlineTests/storage_layout_struct/output.json
new file mode 100644
index 00000000..f682d963
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_struct/output.json
@@ -0,0 +1,126 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 15,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 17,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 20,
+                            "contract": "fileA:A",
+                            "label": "s",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_struct(S)13_storage"
+                        },
+                        {
+                            "astId": 22,
+                            "contract": "fileA:A",
+                            "label": "addr",
+                            "offset": 0,
+                            "slot": "7",
+                            "type": "t_address"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_array(t_uint256)2_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "inplace",
+                            "label": "uint256[2]",
+                            "numberOfBytes": "64"
+                        },
+                        "t_array(t_uint256)dyn_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "dynamic_array",
+                            "label": "uint256[]",
+                            "numberOfBytes": "32"
+                        },
+                        "t_struct(S)13_storage":
+                        {
+                            "encoding": "inplace",
+                            "label": "struct A.S",
+                            "members":
+                            [
+                                {
+                                    "astId": 3,
+                                    "contract": "fileA:A",
+                                    "label": "a",
+                                    "offset": 0,
+                                    "slot": "0",
+                                    "type": "t_uint256"
+                                },
+                                {
+                                    "astId": 5,
+                                    "contract": "fileA:A",
+                                    "label": "b",
+                                    "offset": 0,
+                                    "slot": "1",
+                                    "type": "t_uint256"
+                                },
+                                {
+                                    "astId": 9,
+                                    "contract": "fileA:A",
+                                    "label": "staticArray",
+                                    "offset": 0,
+                                    "slot": "2",
+                                    "type": "t_array(t_uint256)2_storage"
+                                },
+                                {
+                                    "astId": 12,
+                                    "contract": "fileA:A",
+                                    "label": "dynArray",
+                                    "offset": 0,
+                                    "slot": "4",
+                                    "type": "t_array(t_uint256)dyn_storage"
+                                }
+                            ],
+                            "numberOfBytes": "160"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_struct_packed/output.json b/compiler/test/cmdlineTests/storage_layout_struct_packed/output.json
new file mode 100644
index 00000000..7731bd22
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_struct_packed/output.json
@@ -0,0 +1,132 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 15,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 17,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 20,
+                            "contract": "fileA:A",
+                            "label": "s",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_struct(S)13_storage"
+                        },
+                        {
+                            "astId": 22,
+                            "contract": "fileA:A",
+                            "label": "addr",
+                            "offset": 0,
+                            "slot": "6",
+                            "type": "t_address"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_array(t_uint256)2_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "inplace",
+                            "label": "uint256[2]",
+                            "numberOfBytes": "64"
+                        },
+                        "t_array(t_uint256)dyn_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "dynamic_array",
+                            "label": "uint256[]",
+                            "numberOfBytes": "32"
+                        },
+                        "t_struct(S)13_storage":
+                        {
+                            "encoding": "inplace",
+                            "label": "struct A.S",
+                            "members":
+                            [
+                                {
+                                    "astId": 3,
+                                    "contract": "fileA:A",
+                                    "label": "a",
+                                    "offset": 0,
+                                    "slot": "0",
+                                    "type": "t_uint128"
+                                },
+                                {
+                                    "astId": 5,
+                                    "contract": "fileA:A",
+                                    "label": "b",
+                                    "offset": 16,
+                                    "slot": "0",
+                                    "type": "t_uint128"
+                                },
+                                {
+                                    "astId": 9,
+                                    "contract": "fileA:A",
+                                    "label": "staticArray",
+                                    "offset": 0,
+                                    "slot": "1",
+                                    "type": "t_array(t_uint256)2_storage"
+                                },
+                                {
+                                    "astId": 12,
+                                    "contract": "fileA:A",
+                                    "label": "dynArray",
+                                    "offset": 0,
+                                    "slot": "3",
+                                    "type": "t_array(t_uint256)dyn_storage"
+                                }
+                            ],
+                            "numberOfBytes": "128"
+                        },
+                        "t_uint128":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint128",
+                            "numberOfBytes": "16"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_value_types/output.json b/compiler/test/cmdlineTests/storage_layout_value_types/output.json
new file mode 100644
index 00000000..10fbd762
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_value_types/output.json
@@ -0,0 +1,78 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 3,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 5,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint256"
+                        },
+                        {
+                            "astId": 7,
+                            "contract": "fileA:A",
+                            "label": "addr",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_address"
+                        },
+                        {
+                            "astId": 11,
+                            "contract": "fileA:A",
+                            "label": "array",
+                            "offset": 0,
+                            "slot": "3",
+                            "type": "t_array(t_uint256)2_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_array(t_uint256)2_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "inplace",
+                            "label": "uint256[2]",
+                            "numberOfBytes": "64"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/storage_layout_value_types_packed/output.json b/compiler/test/cmdlineTests/storage_layout_value_types_packed/output.json
new file mode 100644
index 00000000..eefb69e6
--- /dev/null
+++ b/compiler/test/cmdlineTests/storage_layout_value_types_packed/output.json
@@ -0,0 +1,98 @@
+{
+    "contracts":
+    {
+        "fileA":
+        {
+            "A":
+            {
+                "storageLayout":
+                {
+                    "storage":
+                    [
+                        {
+                            "astId": 3,
+                            "contract": "fileA:A",
+                            "label": "x",
+                            "offset": 0,
+                            "slot": "0",
+                            "type": "t_uint64"
+                        },
+                        {
+                            "astId": 5,
+                            "contract": "fileA:A",
+                            "label": "y",
+                            "offset": 8,
+                            "slot": "0",
+                            "type": "t_uint128"
+                        },
+                        {
+                            "astId": 7,
+                            "contract": "fileA:A",
+                            "label": "z",
+                            "offset": 0,
+                            "slot": "1",
+                            "type": "t_uint128"
+                        },
+                        {
+                            "astId": 9,
+                            "contract": "fileA:A",
+                            "label": "addr",
+                            "offset": 0,
+                            "slot": "2",
+                            "type": "t_address"
+                        },
+                        {
+                            "astId": 13,
+                            "contract": "fileA:A",
+                            "label": "array",
+                            "offset": 0,
+                            "slot": "3",
+                            "type": "t_array(t_uint256)2_storage"
+                        }
+                    ],
+                    "types":
+                    {
+                        "t_address":
+                        {
+                            "encoding": "inplace",
+                            "label": "address",
+                            "numberOfBytes": "20"
+                        },
+                        "t_array(t_uint256)2_storage":
+                        {
+                            "base": "t_uint256",
+                            "encoding": "inplace",
+                            "label": "uint256[2]",
+                            "numberOfBytes": "64"
+                        },
+                        "t_uint128":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint128",
+                            "numberOfBytes": "16"
+                        },
+                        "t_uint256":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint256",
+                            "numberOfBytes": "32"
+                        },
+                        "t_uint64":
+                        {
+                            "encoding": "inplace",
+                            "label": "uint64",
+                            "numberOfBytes": "8"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "sources":
+    {
+        "fileA":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_ast_compact_json/args b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/args
new file mode 100644
index 00000000..091ceb76
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/args
@@ -0,0 +1 @@
+--strict-assembly --ast-compact-json --pretty-json --json-indent 4
diff --git a/compiler/test/cmdlineTests/strict_asm_ast_compact_json/input.yul b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/input.yul
new file mode 100644
index 00000000..6d1ebe21
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/input.yul
@@ -0,0 +1,15 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_ast_compact_json/output b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/output
new file mode 100644
index 00000000..98afddcf
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_ast_compact_json/output
@@ -0,0 +1,67 @@
+
+======= strict_asm_ast_compact_json/input.yul (EVM) =======
+AST:
+
+{
+    "code":
+    {
+        "block":
+        {
+            "nativeSrc": "60:246:0",
+            "nodeType": "YulBlock",
+            "src": "-1:-1:0",
+            "statements":
+            [
+                {
+                    "nativeSrc": "60:246:0",
+                    "nodeType": "YulBlock",
+                    "src": "-1:-1:0",
+                    "statements":
+                    [
+                        {
+                            "expression":
+                            {
+                                "arguments":
+                                [
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "122:2:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:41:0",
+                                        "type": "",
+                                        "value": "64"
+                                    },
+                                    {
+                                        "kind": "number",
+                                        "nativeSrc": "126:3:0",
+                                        "nodeType": "YulLiteral",
+                                        "src": "60:41:0",
+                                        "type": "",
+                                        "value": "128"
+                                    }
+                                ],
+                                "functionName":
+                                {
+                                    "name": "mstore",
+                                    "nativeSrc": "115:6:0",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "60:41:0"
+                                },
+                                "nativeSrc": "115:15:0",
+                                "nodeType": "YulFunctionCall",
+                                "src": "60:41:0"
+                            },
+                            "nativeSrc": "115:15:0",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "60:41:0"
+                        }
+                    ]
+                }
+            ]
+        },
+        "nodeType": "YulCode"
+    },
+    "name": "C_6_deployed",
+    "nodeType": "YulObject",
+    "subObjects": []
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/input.yul b/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/input.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/input.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/output b/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/output
new file mode 100644
index 00000000..0e58baf5
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_all/output
@@ -0,0 +1,34 @@
+
+======= strict_asm_debug_info_print_all/input.yul (EVM) =======
+
+Pretty printed source:
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        {
+            /// @src 0:60:101
+            mstore(64, 128)
+            fun_f()
+        }
+        /// @src 0:77:99
+        function fun_f()
+        { sstore(0, 42) }
+    }
+}
+
+
+Binary representation:
+6080604052600a600c565b005b602a5f5556
+
+Text representation:
+    /* "input.sol":60:101   */
+  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump	// in
+tag_2:
+  stop
+    /* "input.sol":77:99   */
+tag_1:
+  sstore(0x00, 0x2a)
+  jump	// out
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/input.yul b/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/input.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/input.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/output b/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/output
new file mode 100644
index 00000000..17d2f50e
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_location_only/output
@@ -0,0 +1,34 @@
+
+======= strict_asm_debug_info_print_location_only/input.yul (EVM) =======
+
+Pretty printed source:
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        {
+            /// @src 0:60:101
+            mstore(64, 128)
+            fun_f()
+        }
+        /// @src 0:77:99
+        function fun_f()
+        { sstore(0, 42) }
+    }
+}
+
+
+Binary representation:
+6080604052600a600c565b005b602a5f5556
+
+Text representation:
+    /* "input.sol":60:101 */
+  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump	// in
+tag_2:
+  stop
+    /* "input.sol":77:99 */
+tag_1:
+  sstore(0x00, 0x2a)
+  jump	// out
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/input.yul b/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/input.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/input.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/output b/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/output
new file mode 100644
index 00000000..51f77949
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_none/output
@@ -0,0 +1,30 @@
+
+======= strict_asm_debug_info_print_none/input.yul (EVM) =======
+
+Pretty printed source:
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        {
+            mstore(64, 128)
+            fun_f()
+        }
+        function fun_f()
+        { sstore(0, 42) }
+    }
+}
+
+
+Binary representation:
+6080604052600a600c565b005b602a5f5556
+
+Text representation:
+  mstore(0x40, 0x80)
+  tag_2
+  tag_1
+  jump	// in
+tag_2:
+  stop
+tag_1:
+  sstore(0x00, 0x2a)
+  jump	// out
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/err b/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/err
new file mode 100644
index 00000000..e4abc612
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/err
@@ -0,0 +1 @@
+Error: To use 'snippet' with --debug-info you must select also 'location'.
diff --git a/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/input.yul b/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/input.yul
new file mode 100644
index 00000000..aa564d00
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_debug_info_print_snippet_only/input.yul
@@ -0,0 +1,16 @@
+/// @use-src 0:"input.sol"
+object "C_6_deployed" {
+    code {
+        /// @src 0:60:101  "contract C {..."
+        mstore(64, 128)
+
+        // f()
+        fun_f_5()
+
+        /// @src 0:77:99  "function f() public {}"
+        function fun_f_5() {
+            sstore(0, 42)
+        }
+        /// @src 0:60:101  "contract C {..."
+    }
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/args b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/args
new file mode 100644
index 00000000..468f02fa
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/args
@@ -0,0 +1 @@
+--strict-assembly --evm-version byzantium
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/err b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/err
new file mode 100644
index 00000000..603b329d
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/err
@@ -0,0 +1 @@
+Warning: Support for EVM versions older than constantinople is deprecated and will be removed in the future.
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/input.yul b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/input.yul
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/input.yul
@@ -0,0 +1 @@
+{}
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/output b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/output
new file mode 100644
index 00000000..3a23390a
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_byzantium/output
@@ -0,0 +1,15 @@
+
+======= strict_asm_evm_version_byzantium/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code { { } }
+}
+
+
+Binary representation:
+00
+
+Text representation:
+    /* "strict_asm_evm_version_byzantium/input.yul":0:2   */
+  stop
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/args b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/args
new file mode 100644
index 00000000..a59b0eb0
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/args
@@ -0,0 +1 @@
+--strict-assembly --evm-version constantinople
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/input.yul b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/input.yul
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/input.yul
@@ -0,0 +1 @@
+{}
diff --git a/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/output b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/output
new file mode 100644
index 00000000..c8febd6f
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_evm_version_constantinople/output
@@ -0,0 +1,15 @@
+
+======= strict_asm_evm_version_constantinople/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code { { } }
+}
+
+
+Binary representation:
+00
+
+Text representation:
+    /* "strict_asm_evm_version_constantinople/input.yul":0:2   */
+  stop
diff --git a/compiler/test/cmdlineTests/strict_asm_invalid_option_output_dir/err b/compiler/test/cmdlineTests/strict_asm_invalid_option_output_dir/err
new file mode 100644
index 00000000..2aa3fd76
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_invalid_option_output_dir/err
@@ -0,0 +1 @@
+Error: The following options are invalid in assembly mode: --output-dir.
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/args b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/args
new file mode 100644
index 00000000..f1cb6151
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/args
@@ -0,0 +1 @@
+--strict-assembly --debug-info none --optimize
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/input.yul b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/input.yul
new file mode 100644
index 00000000..ccff7a32
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/input.yul
@@ -0,0 +1,13 @@
+{
+    function f() -> x {
+        x := mload(0)
+    }
+
+    // In pure Yul optimization in presence of msize is allowed.
+    // Everything in this file should get optimized out.
+    pop(msize())
+
+    let x := 0
+    let y := x
+    mstore(0, f())
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/output b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/output
new file mode 100644
index 00000000..fbc1e69f
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_with_optimizer/output
@@ -0,0 +1,14 @@
+
+======= strict_asm_msize_with_optimizer/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code { { } }
+}
+
+
+Binary representation:
+00
+
+Text representation:
+  stop
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/args b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/args
new file mode 100644
index 00000000..7e891dd8
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/args
@@ -0,0 +1 @@
+--strict-assembly --debug-info none
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/input.yul b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/input.yul
new file mode 100644
index 00000000..e787c400
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/input.yul
@@ -0,0 +1,13 @@
+{
+    function f() -> x {
+        x := mload(0)
+    }
+
+    // In pure Yul without optimizer presence of msize disables stack optimization.
+    // This file should remain untouched when passed through the optimizer.
+    pop(msize())
+
+    let x := 0
+    let y := x
+    mstore(0, f())
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/output b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/output
new file mode 100644
index 00000000..fabd2e87
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_msize_without_optimizer/output
@@ -0,0 +1,40 @@
+
+======= strict_asm_msize_without_optimizer/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code {
+        function f() -> x
+        { x := mload(0) }
+        pop(msize())
+        let x := 0
+        let y := x
+        mstore(0, f())
+    }
+}
+
+
+Binary representation:
+600b565b5f8051905090565b5f8060136003565b5f525050
+
+Text representation:
+  jump(tag_2)
+tag_1:
+  0x00
+  dup1
+  mload
+  swap1
+  pop
+  swap1
+  jump	// out
+tag_2:
+  0x00
+  dup1
+  tag_4
+  tag_1
+  jump	// in
+tag_4:
+  0x00
+  mstore
+  pop
+  pop
diff --git a/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/args b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/args
new file mode 100644
index 00000000..cbefff3e
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/args
@@ -0,0 +1 @@
+--strict-assembly --optimize-yul --no-optimize-yul
diff --git a/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/err b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/err
new file mode 100644
index 00000000..b8fc3914
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/err
@@ -0,0 +1 @@
+Error: Options --optimize-yul and --no-optimize-yul cannot be used together.
diff --git a/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/exit b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/exit
new file mode 100644
index 00000000..d00491fd
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/exit
@@ -0,0 +1 @@
+1
diff --git a/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/input.yul b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/input.yul
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_optimizer_invalid_yul_optimizer_enabled_and_disabled/input.yul
@@ -0,0 +1 @@
+{}
diff --git a/compiler/test/cmdlineTests/strict_asm_optimizer_steps/output b/compiler/test/cmdlineTests/strict_asm_optimizer_steps/output
new file mode 100644
index 00000000..c10fb02f
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_optimizer_steps/output
@@ -0,0 +1,84 @@
+
+======= strict_asm_optimizer_steps/input.yul (EVM) =======
+
+Pretty printed source:
+object "C_6" {
+    code {
+        {
+            mstore(64, 128)
+            if callvalue() { revert(0, 0) }
+            codecopy(0, dataoffset("C_6_deployed"), datasize("C_6_deployed"))
+            return(0, datasize("C_6_deployed"))
+        }
+    }
+    object "C_6_deployed" {
+        code {
+            {
+                mstore(64, 128)
+                sstore(0, iszero(calldatasize()))
+                revert(0, 0)
+            }
+        }
+    }
+}
+
+
+Binary representation:
+608060405234601357600c60185f39600c5ff35b5f80fdfe608060405236155f555f80fd
+
+Text representation:
+    /* "strict_asm_optimizer_steps/input.yul":45:48   */
+  0x80
+    /* "strict_asm_optimizer_steps/input.yul":41:43   */
+  0x40
+    /* "strict_asm_optimizer_steps/input.yul":34:49   */
+  mstore
+    /* "strict_asm_optimizer_steps/input.yul":61:72   */
+  callvalue
+    /* "strict_asm_optimizer_steps/input.yul":58:89   */
+  tag_1
+  jumpi
+    /* "strict_asm_optimizer_steps/input.yul":138:162   */
+  dataSize(sub_0)
+    /* "strict_asm_optimizer_steps/input.yul":110:136   */
+  dataOffset(sub_0)
+    /* "strict_asm_optimizer_steps/input.yul":107:108   */
+  0x00
+    /* "strict_asm_optimizer_steps/input.yul":98:163   */
+  codecopy
+    /* "strict_asm_optimizer_steps/input.yul":182:206   */
+  dataSize(sub_0)
+    /* "strict_asm_optimizer_steps/input.yul":179:180   */
+  0x00
+    /* "strict_asm_optimizer_steps/input.yul":172:207   */
+  return
+    /* "strict_asm_optimizer_steps/input.yul":73:89   */
+tag_1:
+    /* "strict_asm_optimizer_steps/input.yul":85:86   */
+  0x00
+    /* "strict_asm_optimizer_steps/input.yul":75:87   */
+  dup1
+  revert
+stop
+
+sub_0: assembly {
+        /* "strict_asm_optimizer_steps/input.yul":298:301   */
+      0x80
+        /* "strict_asm_optimizer_steps/input.yul":294:296   */
+      0x40
+        /* "strict_asm_optimizer_steps/input.yul":287:302   */
+      mstore
+        /* "strict_asm_optimizer_steps/input.yul":533:547   */
+      calldatasize
+        /* "strict_asm_optimizer_steps/input.yul":526:548   */
+      iszero
+        /* "strict_asm_optimizer_steps/input.yul":523:524   */
+      0x00
+        /* "strict_asm_optimizer_steps/input.yul":516:549   */
+      sstore
+        /* "strict_asm_optimizer_steps/input.yul":576:577   */
+      0x00
+        /* "strict_asm_optimizer_steps/input.yul":566:578   */
+      dup1
+      revert
+}
diff --git a/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/args b/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/args
new file mode 100644
index 00000000..9efe91f6
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/args
@@ -0,0 +1 @@
+--yul-dialect evm --machine evm
diff --git a/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/err b/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/err
new file mode 100644
index 00000000..dd58c6e8
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_options_in_non_asm_mode/err
@@ -0,0 +1 @@
+Error: --yul-dialect and --machine are only valid in assembly mode.
diff --git a/compiler/test/cmdlineTests/strict_asm_output_selection_bin_only/output b/compiler/test/cmdlineTests/strict_asm_output_selection_bin_only/output
new file mode 100644
index 00000000..86d24957
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_output_selection_bin_only/output
@@ -0,0 +1,5 @@
+
+======= strict_asm_output_selection_bin_only/input.yul (EVM) =======
+
+Binary representation:
+602a5f5500
diff --git a/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/args b/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/args
new file mode 100644
index 00000000..daeb64aa
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/args
@@ -0,0 +1 @@
+--strict-assembly --asm --asm-json --opcodes --bin --bin-runtime --abi --ir --ir-optimized --hashes --userdoc --devdoc --metadata --storage-layout
diff --git a/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/err b/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/err
new file mode 100644
index 00000000..81d6eff8
--- /dev/null
+++ b/compiler/test/cmdlineTests/strict_asm_output_selection_invalid/err
@@ -0,0 +1 @@
+Error: The following outputs are not supported in assembler mode: --abi, --asm-json, --bin-runtime, --devdoc, --hashes, --ir, --metadata, --opcodes, --storage-layout, --userdoc.
diff --git a/compiler/test/cmdlineTests/viair_msize_without_optimizer/args b/compiler/test/cmdlineTests/viair_msize_without_optimizer/args
new file mode 100644
index 00000000..3b9da15f
--- /dev/null
+++ b/compiler/test/cmdlineTests/viair_msize_without_optimizer/args
@@ -0,0 +1 @@
+--via-ir --ir-optimized --asm --debug-info none
diff --git a/compiler/test/cmdlineTests/viair_msize_without_optimizer/input.sol b/compiler/test/cmdlineTests/viair_msize_without_optimizer/input.sol
new file mode 100644
index 00000000..e70ba17f
--- /dev/null
+++ b/compiler/test/cmdlineTests/viair_msize_without_optimizer/input.sol
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity *;
+
+contract C {
+    function f() pure public {
+        assembly ("memory-safe") {
+            function f() -> x {
+                x := mload(0)
+            }
+
+            // Presence of msize disables all Yul optimizations, including the minimal steps or
+            // stack optimization that would normally be performed even with the optimizer nominally disabled.
+            // This block should remain untouched when passed through the optimizer.
+            pop(msize())
+
+            let x := 0
+            let y := x
+            mstore(0, f())
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/viair_msize_without_optimizer/output b/compiler/test/cmdlineTests/viair_msize_without_optimizer/output
new file mode 100644
index 00000000..b54f8a3f
--- /dev/null
+++ b/compiler/test/cmdlineTests/viair_msize_without_optimizer/output
@@ -0,0 +1,261 @@
+
+======= viair_msize_without_optimizer/input.sol:C =======
+EVM assembly:
+  mstore(0x40, 0x80)
+  jumpi(tag_4, iszero(callvalue))
+  tag_5
+  tag_2
+  jump	// in
+tag_5:
+tag_4:
+  tag_6
+  tag_3
+  jump	// in
+tag_6:
+  tag_7
+  tag_1
+  jump	// in
+tag_7:
+  dataSize(sub_0)
+  dataOffset(sub_0)
+  dup3
+  codecopy
+  dataSize(sub_0)
+  dup2
+  return
+tag_1:
+  0x00
+  mload(0x40)
+  swap1
+  pop
+  swap1
+  jump	// out
+tag_2:
+  0x00
+  dup1
+  revert
+tag_3:
+  jump	// out
+stop
+
+sub_0: assembly {
+      mstore(0x40, 0x80)
+      jumpi(tag_10, lt(calldatasize, 0x04))
+      tag_11
+      calldataload(0x00)
+      tag_1
+      jump	// in
+    tag_11:
+      dup1
+      0x26121ff0
+      dup2
+      sub
+      tag_12
+      jumpi
+      tag_14
+      tag_7
+      jump	// in
+    tag_14:
+    tag_12:
+      pop
+      pop
+    tag_10:
+      tag_15
+      tag_8
+      jump	// in
+    tag_15:
+      jump(tag_16)
+    tag_1:
+      0x00
+      dup2
+      0xe0
+      shr
+      swap1
+      pop
+      swap2
+      swap1
+      pop
+      jump	// out
+    tag_2:
+      0x00
+      mload(0x40)
+      swap1
+      pop
+      swap1
+      jump	// out
+    tag_3:
+      0x00
+      dup1
+      revert
+    tag_4:
+      0x00
+      dup1
+      revert
+    tag_5:
+      0x00
+      dup2
+      dup4
+      sub
+      slt
+      iszero
+      tag_22
+      jumpi
+      tag_23
+      tag_4
+      jump	// in
+    tag_23:
+    tag_22:
+      pop
+      pop
+      jump	// out
+    tag_6:
+      0x00
+      dup1
+      dup3
+      add
+      swap1
+      pop
+      swap2
+      swap1
+      pop
+      jump	// out
+    tag_7:
+      jumpi(tag_26, iszero(callvalue))
+      tag_27
+      tag_3
+      jump	// in
+    tag_27:
+    tag_26:
+      tag_28
+      calldatasize
+      0x04
+      tag_5
+      jump	// in
+    tag_28:
+      tag_29
+      tag_9
+      jump	// in
+    tag_29:
+      tag_30
+      tag_2
+      jump	// in
+    tag_30:
+      tag_31
+      dup2
+      tag_6
+      jump	// in
+    tag_31:
+      dup2
+      dup2
+      sub
+      dup3
+      return
+    tag_8:
+      0x00
+      dup1
+      revert
+    tag_9:
+      jump(tag_35)
+    tag_34:
+      0x00
+      dup1
+      mload
+      swap1
+      pop
+      swap1
+      jump	// out
+    tag_35:
+      0x00
+      dup1
+      tag_37
+      tag_34
+      jump	// in
+    tag_37:
+      0x00
+      mstore
+      pop
+      pop
+      jump	// out
+    tag_16:
+
+    auxdata: <AUXDATA REMOVED>
+}
+
+Optimized IR:
+/// @use-src 0:"viair_msize_without_optimizer/input.sol"
+object "C_7" {
+    code {
+        mstore(64, memoryguard(128))
+        if callvalue()
+        {
+            revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+        }
+        constructor_C_7()
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset("C_7_deployed"), datasize("C_7_deployed"))
+        return(_1, datasize("C_7_deployed"))
+        function allocate_unbounded() -> memPtr
+        { memPtr := mload(64) }
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+        { revert(0, 0) }
+        function constructor_C_7()
+        { }
+    }
+    /// @use-src 0:"viair_msize_without_optimizer/input.sol"
+    object "C_7_deployed" {
+        code {
+            mstore(64, memoryguard(128))
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+                case 0x26121ff0 { external_fun_f_6() }
+                default { }
+            }
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            function shift_right_224_unsigned(value) -> newValue
+            { newValue := shr(224, value) }
+            function allocate_unbounded() -> memPtr
+            { memPtr := mload(64) }
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            { revert(0, 0) }
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+            { revert(0, 0) }
+            function abi_decode_tuple_(headStart, dataEnd)
+            {
+                if slt(sub(dataEnd, headStart), 0)
+                {
+                    revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+                }
+            }
+            function abi_encode_tuple__to__fromStack(headStart) -> tail
+            { tail := add(headStart, 0) }
+            function external_fun_f_6()
+            {
+                if callvalue()
+                {
+                    revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+                }
+                abi_decode_tuple_(4, calldatasize())
+                fun_f_6()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple__to__fromStack(memPos)
+                return(memPos, sub(memEnd, memPos))
+            }
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            { revert(0, 0) }
+            function fun_f_6()
+            {
+                {
+                    function usr$f() -> usr$x
+                    { usr$x := mload(0) }
+                    pop(msize())
+                    let usr$x := 0
+                    let usr$y := usr$x
+                    mstore(0, usr$f())
+                }
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/viair_subobject_optimization/output b/compiler/test/cmdlineTests/viair_subobject_optimization/output
new file mode 100644
index 00000000..4804d138
--- /dev/null
+++ b/compiler/test/cmdlineTests/viair_subobject_optimization/output
@@ -0,0 +1,317 @@
+
+======= viair_subobject_optimization/input.sol:C =======
+EVM assembly:
+    /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+  0x80
+  jumpi(tag_7, callvalue)
+  0x1f
+  bytecodeSize
+  codesize
+  dup2
+  swap1
+  sub
+  swap2
+  dup3
+  add
+  not(0x1f)
+  and
+  dup4
+  add
+  swap2
+  sub(shl(0x40, 0x01), 0x01)
+  dup4
+  gt
+  dup5
+  dup5
+  lt
+  or
+  tag_3
+  jumpi
+  dup1
+  dup5
+  swap3
+  0x20
+  swap5
+  0x40
+  mstore
+  dup4
+  codecopy
+  dup2
+  add
+  sub
+  slt
+  tag_7
+  jumpi
+  mload
+  sub(shl(0x48, 0x01), 0xbe)
+    /* "viair_subobject_optimization/input.sol":620:645  x == 0xFFFFFFFFFFFFFFFF42 */
+  eq
+    /* "viair_subobject_optimization/input.sol":616:661  if (x == 0xFFFFFFFFFFFFFFFF42)... */
+  tag_7
+  jumpi
+    /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+  mload(0x40)
+  dataSize(sub_0)
+  swap1
+  dup2
+  dataOffset(sub_0)
+  dup3
+  codecopy
+  return
+    /* "viair_subobject_optimization/input.sol":616:661  if (x == 0xFFFFFFFFFFFFFFFF42)... */
+tag_7:
+  0x00
+    /* "viair_subobject_optimization/input.sol":653:661  revert() */
+  dup1
+  revert
+    /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+tag_3:
+  mstore(0x00, shl(0xe0, 0x4e487b71))
+  mstore(0x04, 0x41)
+  revert(0x00, 0x24)
+stop
+
+sub_0: assembly {
+        /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+      0x00
+      dup1
+      revert
+
+    auxdata: <AUXDATA REMOVED>
+}
+
+
+======= viair_subobject_optimization/input.sol:D =======
+EVM assembly:
+    /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+  0x80
+  dup1
+  0x40
+  mstore
+  jumpi(tag_1, callvalue)
+  dataSize(sub_0)
+  swap1
+  dup2
+  dataOffset(sub_0)
+  dup3
+  codecopy
+  return
+tag_1:
+  0x00
+  dup1
+  revert
+stop
+
+sub_0: assembly {
+        /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+      0x80
+      jumpi(tag_1, iszero(lt(calldatasize, 0x04)))
+      0x00
+      dup1
+      revert
+    tag_1:
+      jumpi(tag_3, eq(0x26121ff0, shr(0xe0, calldataload(0x00))))
+      0x00
+      dup1
+      revert
+    tag_3:
+      jumpi(tag_7, callvalue)
+      jumpi(tag_7, slt(add(not(0x03), calldatasize), 0x00))
+      not(0x1f)
+        /* "viair_subobject_optimization/input.sol":745:765  type(C).creationCode */
+      dataSize(sub_0)
+        /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+      0x3f
+      dup2
+      add
+      dup3
+      and
+      dup4
+      add
+      swap1
+      dup4
+      dup3
+      lt
+      0xffffffffffffffff
+      dup4
+      gt
+      or
+      tag_9
+      jumpi
+      swap3
+      swap1
+      0x40
+      swap1
+      0x40
+      mstore
+        /* "viair_subobject_optimization/input.sol":745:765  type(C).creationCode */
+      dup4
+      dup3
+      mstore
+      0x20
+      swap4
+      dataOffset(sub_0)
+      0x20
+      dup5
+      add
+      codecopy
+        /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+      mload(0x40)
+      swap4
+      dup5
+      swap3
+        /* "viair_subobject_optimization/input.sol":745:765  type(C).creationCode */
+      0x20
+        /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+      dup5
+      mstore
+      dup1
+      mload
+      swap3
+      dup4
+        /* "viair_subobject_optimization/input.sol":745:765  type(C).creationCode */
+      0x20
+        /* "viair_subobject_optimization/input.sol":669:772  contract D {... */
+      dup7
+      add
+      mstore
+      0x00
+    tag_11:
+      dup5
+      dup2
+      lt
+      tag_12
+      jumpi
+      dup6
+      0x40
+      dup2
+      dup10
+      0x1f
+      dup10
+      0x00
+      dup6
+      dup3
+      dup7
+      add
+      add
+      mstore
+      add
+      and
+      dup2
+      add
+      sub
+      add
+      swap1
+      return
+    tag_12:
+      dup3
+      dup2
+      add
+      dup5
+      add
+      mload
+      dup9
+      dup3
+      add
+      dup4
+      add
+      mstore
+      dup8
+      swap6
+      pop
+      dup4
+      add
+      jump(tag_11)
+    tag_9:
+      mstore(0x00, shl(0xe0, 0x4e487b71))
+      mstore(0x04, 0x41)
+      revert(0x00, 0x24)
+    tag_7:
+      0x00
+      dup1
+      revert
+    stop
+
+    sub_0: assembly {
+            /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+          0x80
+          jumpi(tag_7, callvalue)
+          0x1f
+          bytecodeSize
+          codesize
+          dup2
+          swap1
+          sub
+          swap2
+          dup3
+          add
+          not(0x1f)
+          and
+          dup4
+          add
+          swap2
+          sub(shl(0x40, 0x01), 0x01)
+          dup4
+          gt
+          dup5
+          dup5
+          lt
+          or
+          tag_3
+          jumpi
+          dup1
+          dup5
+          swap3
+          0x20
+          swap5
+          0x40
+          mstore
+          dup4
+          codecopy
+          dup2
+          add
+          sub
+          slt
+          tag_7
+          jumpi
+          mload
+          sub(shl(0x48, 0x01), 0xbe)
+            /* "viair_subobject_optimization/input.sol":620:645  x == 0xFFFFFFFFFFFFFFFF42 */
+          eq
+            /* "viair_subobject_optimization/input.sol":616:661  if (x == 0xFFFFFFFFFFFFFFFF42)... */
+          tag_7
+          jumpi
+            /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+          mload(0x40)
+          dataSize(sub_0)
+          swap1
+          dup2
+          dataOffset(sub_0)
+          dup3
+          codecopy
+          return
+            /* "viair_subobject_optimization/input.sol":616:661  if (x == 0xFFFFFFFFFFFFFFFF42)... */
+        tag_7:
+          0x00
+            /* "viair_subobject_optimization/input.sol":653:661  revert() */
+          dup1
+          revert
+            /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+        tag_3:
+          mstore(0x00, shl(0xe0, 0x4e487b71))
+          mstore(0x04, 0x41)
+          revert(0x00, 0x24)
+        stop
+
+        sub_0: assembly {
+                /* "viair_subobject_optimization/input.sol":61:668  contract C {... */
+              0x00
+              dup1
+              revert
+
+            auxdata: <AUXDATA REMOVED>
+        }
+    }
+
+    auxdata: <AUXDATA REMOVED>
+}
diff --git a/compiler/test/cmdlineTests/viair_subobjects/output b/compiler/test/cmdlineTests/viair_subobjects/output
new file mode 100644
index 00000000..7a6bc8e6
--- /dev/null
+++ b/compiler/test/cmdlineTests/viair_subobjects/output
@@ -0,0 +1,117 @@
+
+======= viair_subobjects/input.sol:C =======
+Binary:
+<BYTECODE REMOVED>
+Binary of the runtime part:
+<BYTECODE REMOVED>
+Optimized IR:
+/// @use-src 0:"viair_subobjects/input.sol"
+object "C_3" {
+    code {
+        {
+            /// @src 0:82:95  "contract C {}"
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("C_3_deployed")
+            codecopy(_1, dataoffset("C_3_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"viair_subobjects/input.sol"
+    object "C_3_deployed" {
+        code {
+            {
+                /// @src 0:82:95  "contract C {}"
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
+
+
+======= viair_subobjects/input.sol:D =======
+Binary:
+<BYTECODE REMOVED>
+Binary of the runtime part:
+<BYTECODE REMOVED>
+Optimized IR:
+/// @use-src 0:"viair_subobjects/input.sol"
+object "D_16" {
+    code {
+        {
+            /// @src 0:96:165  "contract D {..."
+            let _1 := memoryguard(0x80)
+            mstore(64, _1)
+            if callvalue() { revert(0, 0) }
+            let _2 := datasize("D_16_deployed")
+            codecopy(_1, dataoffset("D_16_deployed"), _2)
+            return(_1, _2)
+        }
+    }
+    /// @use-src 0:"viair_subobjects/input.sol"
+    object "D_16_deployed" {
+        code {
+            {
+                /// @src 0:96:165  "contract D {..."
+                let _1 := memoryguard(0x80)
+                mstore(64, _1)
+                if iszero(lt(calldatasize(), 4))
+                {
+                    if eq(0x26121ff0, shr(224, calldataload(0)))
+                    {
+                        if callvalue() { revert(0, 0) }
+                        if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+                        /// @src 0:149:156  "new C()"
+                        let _2 := datasize("C_3")
+                        let _3 := add(_1, _2)
+                        if or(gt(_3, 0xffffffffffffffff), lt(_3, _1))
+                        {
+                            /// @src 0:96:165  "contract D {..."
+                            mstore(0, shl(224, 0x4e487b71))
+                            mstore(4, 0x41)
+                            revert(0, 0x24)
+                        }
+                        /// @src 0:149:156  "new C()"
+                        datacopy(_1, dataoffset("C_3"), _2)
+                        if iszero(create(/** @src 0:96:165  "contract D {..." */ 0, /** @src 0:149:156  "new C()" */ _1, sub(_3, _1)))
+                        {
+                            /// @src 0:96:165  "contract D {..."
+                            let pos := mload(64)
+                            returndatacopy(pos, 0, returndatasize())
+                            revert(pos, returndatasize())
+                        }
+                        return(0, 0)
+                    }
+                }
+                revert(0, 0)
+            }
+        }
+        /// @use-src 0:"viair_subobjects/input.sol"
+        object "C_3" {
+            code {
+                {
+                    /// @src 0:82:95  "contract C {}"
+                    let _1 := memoryguard(0x80)
+                    mstore(64, _1)
+                    if callvalue() { revert(0, 0) }
+                    let _2 := datasize("C_3_deployed")
+                    codecopy(_1, dataoffset("C_3_deployed"), _2)
+                    return(_1, _2)
+                }
+            }
+            /// @use-src 0:"viair_subobjects/input.sol"
+            object "C_3_deployed" {
+                code {
+                    {
+                        /// @src 0:82:95  "contract C {}"
+                        revert(0, 0)
+                    }
+                }
+                data ".metadata" hex"<BYTECODE REMOVED>"
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_function_name_clashes/output b/compiler/test/cmdlineTests/yul_function_name_clashes/output
new file mode 100644
index 00000000..2c54b6f5
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_function_name_clashes/output
@@ -0,0 +1,46 @@
+
+======= yul_function_name_clashes/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code {
+        {
+            let a
+            let b
+            a := z()
+            b := z_1()
+            sstore(a, b)
+        }
+        function z() -> y
+        { y := calldataload(0) }
+        function z_1() -> y
+        { y := calldataload(0x20) }
+    }
+}
+
+
+Binary representation:
+6005600f565b600b6014565b9055005b5f3590565b6020359056
+
+Text representation:
+  tag_3
+  tag_1
+  jump	// in
+tag_3:
+  tag_4
+  tag_2
+  jump	// in
+tag_4:
+  swap1
+  sstore
+  stop
+tag_1:
+  0x00
+  calldataload
+  swap1
+  jump	// out
+tag_2:
+  0x20
+  calldataload
+  swap1
+  jump	// out
diff --git a/compiler/test/cmdlineTests/yul_function_name_clashes_different_params/output b/compiler/test/cmdlineTests/yul_function_name_clashes_different_params/output
new file mode 100644
index 00000000..22cee64c
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_function_name_clashes_different_params/output
@@ -0,0 +1,59 @@
+
+======= yul_function_name_clashes_different_params/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code {
+        {
+            let a
+            let b
+            a := z()
+            b := z_1(0x70)
+            sstore(a, b)
+        }
+        function z() -> y
+        { y := calldataload(0) }
+        function z_1(r) -> y
+        { y := calldataload(r) }
+    }
+}
+
+
+Binary representation:
+60056011565b600d60706016565b9055005b5f3590565b359056
+
+Text representation:
+    /* "yul_function_name_clashes_different_params/input.yul":151:154   */
+  tag_3
+  tag_1
+  jump	// in
+tag_3:
+    /* "yul_function_name_clashes_different_params/input.yul":260:267   */
+  tag_4
+    /* "yul_function_name_clashes_different_params/input.yul":262:266   */
+  0x70
+    /* "yul_function_name_clashes_different_params/input.yul":260:267   */
+  tag_2
+  jump	// in
+tag_4:
+    /* "yul_function_name_clashes_different_params/input.yul":286:298   */
+  swap1
+  sstore
+    /* "yul_function_name_clashes_different_params/input.yul":27:304   */
+  stop
+    /* "yul_function_name_clashes_different_params/input.yul":79:133   */
+tag_1:
+    /* "yul_function_name_clashes_different_params/input.yul":129:130   */
+  0x00
+    /* "yul_function_name_clashes_different_params/input.yul":116:131   */
+  calldataload
+    /* "yul_function_name_clashes_different_params/input.yul":79:133   */
+  swap1
+  jump	// out
+    /* "yul_function_name_clashes_different_params/input.yul":187:242   */
+tag_2:
+    /* "yul_function_name_clashes_different_params/input.yul":225:240   */
+  calldataload
+    /* "yul_function_name_clashes_different_params/input.yul":187:242   */
+  swap1
+  jump	// out
diff --git a/compiler/test/cmdlineTests/yul_optimize_runs/output b/compiler/test/cmdlineTests/yul_optimize_runs/output
new file mode 100644
index 00000000..b7fcabaa
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimize_runs/output
@@ -0,0 +1,51 @@
+
+======= yul_optimize_runs/input.yul (EVM) =======
+
+Pretty printed source:
+object "RunsTest1" {
+    code {
+        {
+            let _1 := datasize("Runtime_deployed")
+            datacopy(0, dataoffset("Runtime_deployed"), _1)
+            return(0, _1)
+        }
+    }
+    object "Runtime_deployed" {
+        code {
+            {
+                sstore(0, 0xabc1234500000000000000000000000000000000000000000000000000000000)
+            }
+        }
+    }
+}
+
+
+Binary representation:
+602480600a5f395ff3fe7fabc12345000000000000000000000000000000000000000000000000000000005f5500
+
+Text representation:
+    /* "yul_optimize_runs/input.yul":115:143   */
+  dataSize(sub_0)
+    /* "yul_optimize_runs/input.yul":83:113   */
+  dup1
+  dataOffset(sub_0)
+    /* "yul_optimize_runs/input.yul":80:81   */
+  0x00
+    /* "yul_optimize_runs/input.yul":71:144   */
+  codecopy
+    /* "yul_optimize_runs/input.yul":80:81   */
+  0x00
+    /* "yul_optimize_runs/input.yul":153:192   */
+  return
+stop
+
+sub_0: assembly {
+        /* "yul_optimize_runs/input.yul":273:293   */
+      0xabc1234500000000000000000000000000000000000000000000000000000000
+        /* "yul_optimize_runs/input.yul":313:314   */
+      0x00
+        /* "yul_optimize_runs/input.yul":306:324   */
+      sstore
+        /* "yul_optimize_runs/input.yul":244:334   */
+      stop
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_disabled/err b/compiler/test/cmdlineTests/yul_optimizer_steps_disabled/err
new file mode 100644
index 00000000..1abbab8b
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_disabled/err
@@ -0,0 +1 @@
+Error: --yul-optimizations is invalid with a non-empty sequence if Yul optimizer is disabled.
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_invalid_abbreviation/err b/compiler/test/cmdlineTests/yul_optimizer_steps_invalid_abbreviation/err
new file mode 100644
index 00000000..49669b1f
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_invalid_abbreviation/err
@@ -0,0 +1 @@
+Error: Invalid optimizer step sequence in --yul-optimizations: 'b' is not a valid step abbreviation
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_nested_brackets/output b/compiler/test/cmdlineTests/yul_optimizer_steps_nested_brackets/output
new file mode 100644
index 00000000..9687abf6
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_nested_brackets/output
@@ -0,0 +1,79 @@
+Optimized IR:
+/// @use-src 0:"yul_optimizer_steps_nested_brackets/input.sol"
+object "C_6" {
+    code {
+        {
+            /// @src 0:60:103  "contract C..."
+            mstore(64, memoryguard(0x80))
+            if callvalue()
+            {
+                revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            }
+            let _1 := allocate_unbounded()
+            codecopy(_1, dataoffset("C_6_deployed"), datasize("C_6_deployed"))
+            return(_1, datasize("C_6_deployed"))
+        }
+        function allocate_unbounded() -> memPtr
+        {
+            let memPtr_1 := mload(64)
+            memPtr := memPtr_1
+        }
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+        { revert(0, 0) }
+    }
+    /// @use-src 0:"yul_optimizer_steps_nested_brackets/input.sol"
+    object "C_6_deployed" {
+        code {
+            {
+                /// @src 0:60:103  "contract C..."
+                mstore(64, memoryguard(0x80))
+                if iszero(lt(calldatasize(), 4))
+                {
+                    let selector := shift_right_unsigned(calldataload(0))
+                    if eq(0x26121ff0, selector) { external_fun_f() }
+                }
+                revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            }
+            function shift_right_unsigned(value) -> newValue
+            {
+                let newValue_1 := shr(224, value)
+                newValue := newValue_1
+            }
+            function allocate_unbounded() -> memPtr
+            {
+                let memPtr_1 := mload(64)
+                memPtr := memPtr_1
+            }
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            { revert(0, 0) }
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+            { revert(0, 0) }
+            function abi_decode(headStart, dataEnd)
+            {
+                if slt(sub(dataEnd, headStart), 0)
+                {
+                    revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+                }
+            }
+            function abi_encode_tuple(headStart) -> tail
+            {
+                let tail_1 := add(headStart, 0)
+                tail := tail_1
+            }
+            function external_fun_f()
+            {
+                if callvalue()
+                {
+                    revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+                }
+                abi_decode(4, calldatasize())
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple(memPos)
+                return(memPos, sub(memEnd, memPos))
+            }
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            { revert(0, 0) }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_nesting_too_deep/err b/compiler/test/cmdlineTests/yul_optimizer_steps_nesting_too_deep/err
new file mode 100644
index 00000000..a28e8cff
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_nesting_too_deep/err
@@ -0,0 +1 @@
+Error: Invalid optimizer step sequence in --yul-optimizations: Brackets nested too deep
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/args b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/args
new file mode 100644
index 00000000..ba2f47eb
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/args
@@ -0,0 +1 @@
+--ir-optimized --optimize --yul-optimizations iDu
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/input.sol b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/input.sol
new file mode 100644
index 00000000..2d82716f
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/input.sol
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+pragma abicoder v2;
+
+contract C {
+    constructor() payable {
+        assembly ("memory-safe") {
+            let a := 0
+            revert(0, a)
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/output b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/output
new file mode 100644
index 00000000..dc77ce3c
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_short_sequence/output
@@ -0,0 +1,23 @@
+Optimized IR:
+/// @use-src 0:"yul_optimizer_steps_short_sequence/input.sol"
+object "C_8" {
+    code {
+        {
+            /// @src 0:80:221  "contract C {..."
+            mstore(64, memoryguard(0x80))
+            /// @src 0:129:213  "assembly (\"memory-safe\") {..."
+            revert(0, 0)
+        }
+    }
+    /// @use-src 0:"yul_optimizer_steps_short_sequence/input.sol"
+    object "C_8_deployed" {
+        code {
+            {
+                /// @src 0:80:221  "contract C {..."
+                mstore(64, memoryguard(0x80))
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_closing_bracket/err b/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_closing_bracket/err
new file mode 100644
index 00000000..dda1e8c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_closing_bracket/err
@@ -0,0 +1 @@
+Error: Invalid optimizer step sequence in --yul-optimizations: Unbalanced brackets
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_opening_bracket/err b/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_opening_bracket/err
new file mode 100644
index 00000000..dda1e8c1
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_unbalanced_opening_bracket/err
@@ -0,0 +1 @@
+Error: Invalid optimizer step sequence in --yul-optimizations: Unbalanced brackets
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/args b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/args
new file mode 100644
index 00000000..6673a776
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/args
@@ -0,0 +1 @@
+--ir-optimized --optimize --yul-optimizations iDu:
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/input.sol b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/input.sol
new file mode 100644
index 00000000..fc9ba5ba
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/input.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+pragma abicoder v2;
+
+contract C {
+    constructor() payable {
+        assembly ("memory-safe") {
+            let a := 0
+            // Without the cleanup sequence this will not be simplified to ``revert(a, a)``.
+            revert(0, a)
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/output b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/output
new file mode 100644
index 00000000..01641c53
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_cleanup_sequence/output
@@ -0,0 +1,24 @@
+Optimized IR:
+/// @use-src 0:"yul_optimizer_steps_with_empty_cleanup_sequence/input.sol"
+object "C_8" {
+    code {
+        {
+            /// @src 0:80:314  "contract C {..."
+            mstore(64, memoryguard(0x80))
+            /// @src 0:129:306  "assembly (\"memory-safe\") {..."
+            let usr$a := 0
+            revert(0, usr$a)
+        }
+    }
+    /// @use-src 0:"yul_optimizer_steps_with_empty_cleanup_sequence/input.sol"
+    object "C_8_deployed" {
+        code {
+            {
+                /// @src 0:80:314  "contract C {..."
+                mstore(64, memoryguard(0x80))
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/args b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/args
new file mode 100644
index 00000000..b5d1d3c6
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/args
@@ -0,0 +1 @@
+--ir-optimized --optimize --yul-optimizations :iDu
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/input.sol b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/input.sol
new file mode 100644
index 00000000..fc9ba5ba
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/input.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+pragma abicoder v2;
+
+contract C {
+    constructor() payable {
+        assembly ("memory-safe") {
+            let a := 0
+            // Without the cleanup sequence this will not be simplified to ``revert(a, a)``.
+            revert(0, a)
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/output b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/output
new file mode 100644
index 00000000..b13e6e28
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_with_empty_optimization_sequence/output
@@ -0,0 +1,24 @@
+Optimized IR:
+/// @use-src 0:"yul_optimizer_steps_with_empty_optimization_sequence/input.sol"
+object "C_8" {
+    code {
+        {
+            /// @src 0:80:314  "contract C {..."
+            mstore(64, memoryguard(0x80))
+            /// @src 0:129:306  "assembly (\"memory-safe\") {..."
+            let usr$a := 0
+            revert(0, usr$a)
+        }
+    }
+    /// @use-src 0:"yul_optimizer_steps_with_empty_optimization_sequence/input.sol"
+    object "C_8_deployed" {
+        code {
+            {
+                /// @src 0:80:314  "contract C {..."
+                mstore(64, memoryguard(0x80))
+                revert(0, 0)
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/args b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/args
new file mode 100644
index 00000000..fef6c653
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/args
@@ -0,0 +1 @@
+--ir-optimized --metadata --yul-optimizations :
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/err b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/err
new file mode 100644
index 00000000..95e30df2
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/err
@@ -0,0 +1,11 @@
+Warning: Unused local variable.
+  --> yul_optimizer_steps_without_optimize_empty_sequence/input.sol:13:9:
+   |
+13 |         uint b = a;
+   |         ^^^^^^
+
+Warning: Unused local variable.
+  --> yul_optimizer_steps_without_optimize_empty_sequence/input.sol:14:9:
+   |
+14 |         uint c = a;
+   |         ^^^^^^
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/input.sol b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/input.sol
new file mode 100644
index 00000000..9e1b04ab
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/input.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.0;
+
+contract C
+{
+    constructor() {}
+
+    function foo() public pure returns (bool)
+    {
+        // given the empty optimizer sequence ``:``, ``b`` and ``c`` should not be removed in the
+        // optimized IR as the ``UnusedPruner`` step will not be run.
+        uint a = 100;
+        uint b = a;
+        uint c = a;
+
+        return a == 100;
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/output b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/output
new file mode 100644
index 00000000..9ee68107
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_optimizer_steps_without_optimize_empty_sequence/output
@@ -0,0 +1,133 @@
+
+======= yul_optimizer_steps_without_optimize_empty_sequence/input.sol:C =======
+Optimized IR:
+/// @use-src 0:"yul_optimizer_steps_without_optimize_empty_sequence/input.sol"
+object "C_28" {
+    code {
+        {
+            /// @src 0:60:410  "contract C..."
+            mstore(64, memoryguard(0x80))
+            if callvalue()
+            {
+                revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            }
+            constructor_C()
+            let _1 := allocate_unbounded()
+            codecopy(_1, dataoffset("C_28_deployed"), datasize("C_28_deployed"))
+            return(_1, datasize("C_28_deployed"))
+        }
+        function allocate_unbounded() -> memPtr
+        { memPtr := mload(64) }
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+        { revert(0, 0) }
+        /// @ast-id 5 @src 0:77:93  "constructor() {}"
+        function constructor_C()
+        { }
+    }
+    /// @use-src 0:"yul_optimizer_steps_without_optimize_empty_sequence/input.sol"
+    object "C_28_deployed" {
+        code {
+            {
+                /// @src 0:60:410  "contract C..."
+                mstore(64, memoryguard(0x80))
+                if iszero(lt(calldatasize(), 4))
+                {
+                    let selector := shift_right_unsigned(calldataload(0))
+                    switch selector
+                    case 0xc2985578 { external_fun_foo() }
+                    default { }
+                }
+                revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            }
+            function shift_right_unsigned(value) -> newValue
+            { newValue := shr(224, value) }
+            function allocate_unbounded() -> memPtr
+            { memPtr := mload(64) }
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+            { revert(0, 0) }
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+            { revert(0, 0) }
+            function abi_decode(headStart, dataEnd)
+            {
+                if slt(sub(dataEnd, headStart), 0)
+                {
+                    revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b()
+                }
+            }
+            function cleanup_bool(value) -> cleaned
+            {
+                cleaned := iszero(iszero(value))
+            }
+            function abi_encode_bool_to_bool(value, pos)
+            {
+                mstore(pos, cleanup_bool(value))
+            }
+            function abi_encode_bool(headStart, value0) -> tail
+            {
+                tail := add(headStart, 32)
+                abi_encode_bool_to_bool(value0, add(headStart, 0))
+            }
+            function external_fun_foo()
+            {
+                if callvalue()
+                {
+                    revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb()
+                }
+                abi_decode(4, calldatasize())
+                let ret := fun_foo()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_bool(memPos, ret)
+                return(memPos, sub(memEnd, memPos))
+            }
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+            { revert(0, 0) }
+            function zero_value_for_split_bool() -> ret
+            { ret := 0 }
+            function cleanup_rational_by(value) -> cleaned
+            { cleaned := value }
+            function cleanup_uint256(value) -> cleaned
+            { cleaned := value }
+            function identity(value) -> ret
+            { ret := value }
+            function convert_rational_by_to_uint256(value) -> converted
+            {
+                converted := cleanup_uint256(identity(cleanup_rational_by(value)))
+            }
+            /// @ast-id 27 @src 0:99:408  "function foo() public pure returns (bool)..."
+            function fun_foo() -> var
+            {
+                /// @src 0:135:139  "bool"
+                let zero_bool := zero_value_for_split_bool()
+                var := zero_bool
+                /// @src 0:332:335  "100"
+                let expr := 0x64
+                /// @src 0:323:335  "uint a = 100"
+                let var_a := convert_rational_by_to_uint256(expr)
+                /// @src 0:354:355  "a"
+                let _1 := var_a
+                let expr_1 := _1
+                /// @src 0:345:355  "uint b = a"
+                let var_b := expr_1
+                /// @src 0:374:375  "a"
+                let _2 := var_a
+                let expr_2 := _2
+                /// @src 0:365:375  "uint c = a"
+                let var_c := expr_2
+                /// @src 0:393:394  "a"
+                let _3 := var_a
+                let expr_3 := _3
+                /// @src 0:398:401  "100"
+                let expr_4 := 0x64
+                /// @src 0:393:401  "a == 100"
+                let expr_5 := eq(cleanup_uint256(expr_3), convert_rational_by_to_uint256(expr_4))
+                /// @src 0:386:401  "return a == 100"
+                var := expr_5
+                leave
+            }
+        }
+        data ".metadata" hex"<BYTECODE REMOVED>"
+    }
+}
+
+Metadata:
+{"compiler":{"version": "<VERSION REMOVED>"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"foo","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"yul_optimizer_steps_without_optimize_empty_sequence/input.sol":"C"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"details":{"constantOptimizer":false,"cse":false,"deduplicate":false,"inliner":false,"jumpdestRemover":true,"orderLiterals":false,"peephole":true,"simpleCounterForLoopUncheckedIncrement":true,"yul":false,"yulDetails":{"optimizerSteps":":"}},"runs":200},"remappings":[]},"sources":{"yul_optimizer_steps_without_optimize_empty_sequence/input.sol":{"keccak256":"0x3fc910e345ce1ee62bfa6b0f66931ee632c08265b25b6139cfbbfe4d2f8d5dd8","license":"GPL-3.0","urls":["bzz-raw://e557e9ad2c2e420a669c06ae456b0b790d77d2d6d492cd8540e6b244388a5140","dweb:/ipfs/QmaNiZmC2Mo3YxGiehs1n3dVTjZwD7FguX7EUtpeshMVuR"]}},"version":1}
diff --git a/compiler/test/cmdlineTests/yul_string_format_ascii/output.json b/compiler/test/cmdlineTests/yul_string_format_ascii/output.json
new file mode 100644
index 00000000..aa830d1a
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_string_format_ascii/output.json
@@ -0,0 +1,229 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_11\" {
+    code {
+        /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_11()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_11_deployed\"), datasize(\"C_11_deployed\"))
+
+        return(_1, datasize(\"C_11_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+        function constructor_C_11() {
+
+            /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+
+        }
+        /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_11_deployed\" {
+        code {
+            /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_10()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function array_length_t_string_memory_ptr(value) -> length {
+
+                length := mload(value)
+
+            }
+
+            function array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length) -> updated_pos {
+                mstore(pos, length)
+                updated_pos := add(pos, 0x20)
+            }
+
+            function copy_memory_to_memory_with_cleanup(src, dst, length) {
+                let i := 0
+                for { } lt(i, length) { i := add(i, 32) }
+                {
+                    mstore(add(dst, i), mload(add(src, i)))
+                }
+                mstore(add(dst, length), 0)
+            }
+
+            function round_up_to_mul_of_32(value) -> result {
+                result := and(add(value, 31), not(31))
+            }
+
+            function abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value, pos) -> end {
+                let length := array_length_t_string_memory_ptr(value)
+                pos := array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length)
+                copy_memory_to_memory_with_cleanup(add(value, 0x20), pos, length)
+                end := add(pos, round_up_to_mul_of_32(length))
+            }
+
+            function abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                mstore(add(headStart, 0), sub(tail, headStart))
+                tail := abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value0,  tail)
+
+            }
+
+            function external_fun_f_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_string_memory_ptr() -> ret {
+                ret := 96
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function finalize_allocation(memPtr, size) {
+                let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+                // protect against overflow
+                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+                mstore(64, newFreePtr)
+            }
+
+            function allocate_memory(size) -> memPtr {
+                memPtr := allocate_unbounded()
+                finalize_allocation(memPtr, size)
+            }
+
+            function array_allocation_size_t_string_memory_ptr(length) -> size {
+                // Make sure we can allocate memory without overflow
+                if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
+
+                size := round_up_to_mul_of_32(length)
+
+                // add length slot
+                size := add(size, 0x20)
+
+            }
+
+            function allocate_memory_array_t_string_memory_ptr(length) -> memPtr {
+                let allocSize := array_allocation_size_t_string_memory_ptr(length)
+                memPtr := allocate_memory(allocSize)
+
+                mstore(memPtr, length)
+
+            }
+
+            function store_literal_in_memory_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21(memPtr) {
+
+                mstore(add(memPtr, 0), \"abcabc\")
+
+            }
+
+            function copy_literal_to_memory_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21() -> memPtr {
+                memPtr := allocate_memory_array_t_string_memory_ptr(6)
+                store_literal_in_memory_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21(add(memPtr, 32))
+            }
+
+            function convert_t_stringliteral_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21_to_t_string_memory_ptr() -> converted {
+                converted := copy_literal_to_memory_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21()
+            }
+
+            /// @ast-id 10
+            /// @src 0:91:162  \"function f() external pure returns (string memory) { return \\\"abcabc\\\"; }\"
+            function fun_f_10() -> var__5_mpos {
+                /// @src 0:127:140  \"string memory\"
+                let zero_t_string_memory_ptr_1_mpos := zero_value_for_split_t_string_memory_ptr()
+                var__5_mpos := zero_t_string_memory_ptr_1_mpos
+
+                /// @src 0:144:159  \"return \\\"abcabc\\\"\"
+                var__5_mpos := convert_t_stringliteral_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21_to_t_string_memory_ptr()
+                leave
+
+            }
+            /// @src 0:78:164  \"contract C { function f() external pure returns (string memory) { return \\\"abcabc\\\"; } }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32/output.json b/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32/output.json
new file mode 100644
index 00000000..bfe775ca
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32/output.json
@@ -0,0 +1,157 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_11\" {
+    code {
+        /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_11()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_11_deployed\"), datasize(\"C_11_deployed\"))
+
+        return(_1, datasize(\"C_11_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+        function constructor_C_11() {
+
+            /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+
+        }
+        /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_11_deployed\" {
+        code {
+            /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_10()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function cleanup_t_bytes32(value) -> cleaned {
+                cleaned := value
+            }
+
+            function abi_encode_t_bytes32_to_t_bytes32_fromStack(value, pos) {
+                mstore(pos, cleanup_t_bytes32(value))
+            }
+
+            function abi_encode_tuple_t_bytes32__to_t_bytes32__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                abi_encode_t_bytes32_to_t_bytes32_fromStack(value0,  add(headStart, 0))
+
+            }
+
+            function external_fun_f_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_bytes32__to_t_bytes32__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_bytes32() -> ret {
+                ret := 0
+            }
+
+            function convert_t_stringliteral_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21_to_t_bytes32() -> converted {
+                converted := 0x6162636162630000000000000000000000000000000000000000000000000000
+            }
+
+            /// @ast-id 10
+            /// @src 0:91:156  \"function f() external pure returns (bytes32) { return \\\"abcabc\\\"; }\"
+            function fun_f_10() -> var__5 {
+                /// @src 0:127:134  \"bytes32\"
+                let zero_t_bytes32_1 := zero_value_for_split_t_bytes32()
+                var__5 := zero_t_bytes32_1
+
+                /// @src 0:138:153  \"return \\\"abcabc\\\"\"
+                var__5 := convert_t_stringliteral_9f0adad0a59b05d2e04a1373342b10b9eb16c57c164c8a3bfcbf46dccee39a21_to_t_bytes32()
+                leave
+
+            }
+            /// @src 0:78:158  \"contract C { function f() external pure returns (bytes32) { return \\\"abcabc\\\"; } }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32_from_number/output.json b/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32_from_number/output.json
new file mode 100644
index 00000000..f4b14aad
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_string_format_ascii_bytes32_from_number/output.json
@@ -0,0 +1,170 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_11\" {
+    code {
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_11()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_11_deployed\"), datasize(\"C_11_deployed\"))
+
+        return(_1, datasize(\"C_11_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+        function constructor_C_11() {
+
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+
+        }
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_11_deployed\" {
+        code {
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_10()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function cleanup_t_bytes4(value) -> cleaned {
+                cleaned := and(value, 0xffffffff00000000000000000000000000000000000000000000000000000000)
+            }
+
+            function abi_encode_t_bytes4_to_t_bytes4_fromStack(value, pos) {
+                mstore(pos, cleanup_t_bytes4(value))
+            }
+
+            function abi_encode_tuple_t_bytes4__to_t_bytes4__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                abi_encode_t_bytes4_to_t_bytes4_fromStack(value0,  add(headStart, 0))
+
+            }
+
+            function external_fun_f_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_bytes4__to_t_bytes4__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_bytes4() -> ret {
+                ret := 0
+            }
+
+            function cleanup_t_rational_1633837924_by_1(value) -> cleaned {
+                cleaned := value
+            }
+
+            function shift_left_224(value) -> newValue {
+                newValue :=
+
+                shl(224, value)
+
+            }
+
+            function convert_t_rational_1633837924_by_1_to_t_bytes4(value) -> converted {
+                converted := cleanup_t_bytes4(shift_left_224(cleanup_t_rational_1633837924_by_1(value)))
+            }
+
+            /// @ast-id 10
+            /// @src 0:91:157  \"function f() external pure returns (bytes4) { return 0x61626364; }\"
+            function fun_f_10() -> var__5 {
+                /// @src 0:127:133  \"bytes4\"
+                let zero_t_bytes4_1 := zero_value_for_split_t_bytes4()
+                var__5 := zero_t_bytes4_1
+
+                /// @src 0:144:154  \"0x61626364\"
+                let expr_7 := 0x61626364
+                /// @src 0:137:154  \"return 0x61626364\"
+                var__5 := convert_t_rational_1633837924_by_1_to_t_bytes4(expr_7)
+                leave
+
+            }
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0x61626364; } }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_string_format_ascii_long/output.json b/compiler/test/cmdlineTests/yul_string_format_ascii_long/output.json
new file mode 100644
index 00000000..348e5a0b
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_string_format_ascii_long/output.json
@@ -0,0 +1,233 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_11\" {
+    code {
+        /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_11()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_11_deployed\"), datasize(\"C_11_deployed\"))
+
+        return(_1, datasize(\"C_11_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+        function constructor_C_11() {
+
+            /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+
+        }
+        /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_11_deployed\" {
+        code {
+            /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_10()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function array_length_t_string_memory_ptr(value) -> length {
+
+                length := mload(value)
+
+            }
+
+            function array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length) -> updated_pos {
+                mstore(pos, length)
+                updated_pos := add(pos, 0x20)
+            }
+
+            function copy_memory_to_memory_with_cleanup(src, dst, length) {
+                let i := 0
+                for { } lt(i, length) { i := add(i, 32) }
+                {
+                    mstore(add(dst, i), mload(add(src, i)))
+                }
+                mstore(add(dst, length), 0)
+            }
+
+            function round_up_to_mul_of_32(value) -> result {
+                result := and(add(value, 31), not(31))
+            }
+
+            function abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value, pos) -> end {
+                let length := array_length_t_string_memory_ptr(value)
+                pos := array_storeLengthForEncoding_t_string_memory_ptr_fromStack(pos, length)
+                copy_memory_to_memory_with_cleanup(add(value, 0x20), pos, length)
+                end := add(pos, round_up_to_mul_of_32(length))
+            }
+
+            function abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                mstore(add(headStart, 0), sub(tail, headStart))
+                tail := abi_encode_t_string_memory_ptr_to_t_string_memory_ptr_fromStack(value0,  tail)
+
+            }
+
+            function external_fun_f_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_string_memory_ptr__to_t_string_memory_ptr__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_string_memory_ptr() -> ret {
+                ret := 96
+            }
+
+            function panic_error_0x41() {
+                mstore(0, 35408467139433450592217433187231851964531694900788300625387963629091585785856)
+                mstore(4, 0x41)
+                revert(0, 0x24)
+            }
+
+            function finalize_allocation(memPtr, size) {
+                let newFreePtr := add(memPtr, round_up_to_mul_of_32(size))
+                // protect against overflow
+                if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
+                mstore(64, newFreePtr)
+            }
+
+            function allocate_memory(size) -> memPtr {
+                memPtr := allocate_unbounded()
+                finalize_allocation(memPtr, size)
+            }
+
+            function array_allocation_size_t_string_memory_ptr(length) -> size {
+                // Make sure we can allocate memory without overflow
+                if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
+
+                size := round_up_to_mul_of_32(length)
+
+                // add length slot
+                size := add(size, 0x20)
+
+            }
+
+            function allocate_memory_array_t_string_memory_ptr(length) -> memPtr {
+                let allocSize := array_allocation_size_t_string_memory_ptr(length)
+                memPtr := allocate_memory(allocSize)
+
+                mstore(memPtr, length)
+
+            }
+
+            function store_literal_in_memory_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571(memPtr) {
+
+                mstore(add(memPtr, 0), \"abcdabcdcafecafeabcdabcdcafecafe\")
+
+                mstore(add(memPtr, 32), \"ffffzzzzoooo0123456789,.<,>.?:;'\")
+
+                mstore(add(memPtr, 64), \"[{]}|`~!@#$%^&*()-_=+\")
+
+            }
+
+            function copy_literal_to_memory_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571() -> memPtr {
+                memPtr := allocate_memory_array_t_string_memory_ptr(85)
+                store_literal_in_memory_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571(add(memPtr, 32))
+            }
+
+            function convert_t_stringliteral_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571_to_t_string_memory_ptr() -> converted {
+                converted := copy_literal_to_memory_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571()
+            }
+
+            /// @ast-id 10
+            /// @src 0:91:241  \"function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; }\"
+            function fun_f_10() -> var__5_mpos {
+                /// @src 0:127:140  \"string memory\"
+                let zero_t_string_memory_ptr_1_mpos := zero_value_for_split_t_string_memory_ptr()
+                var__5_mpos := zero_t_string_memory_ptr_1_mpos
+
+                /// @src 0:144:238  \"return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"\"
+                var__5_mpos := convert_t_stringliteral_d6604f85ac07e2b33103a620b3d3d75b0473c7214912beded67b9b624d41c571_to_t_string_memory_ptr()
+                leave
+
+            }
+            /// @src 0:78:243  \"contract C { function f() external pure returns (string memory) { return \\\"abcdabcdcafecafeabcdabcdcafecafeffffzzzzoooo0123456789,.<,>.?:;'[{]}|`~!@#$%^&*()-_=+\\\"; } }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_string_format_hex/output.json b/compiler/test/cmdlineTests/yul_string_format_hex/output.json
new file mode 100644
index 00000000..5568fc7a
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_string_format_hex/output.json
@@ -0,0 +1,170 @@
+{
+    "contracts":
+    {
+        "A":
+        {
+            "C":
+            {
+                "ir": "
+/// @use-src 0:\"A\"
+object \"C_11\" {
+    code {
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+        mstore(64, memoryguard(128))
+        if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+
+        constructor_C_11()
+
+        let _1 := allocate_unbounded()
+        codecopy(_1, dataoffset(\"C_11_deployed\"), datasize(\"C_11_deployed\"))
+
+        return(_1, datasize(\"C_11_deployed\"))
+
+        function allocate_unbounded() -> memPtr {
+            memPtr := mload(64)
+        }
+
+        function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+            revert(0, 0)
+        }
+
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+        function constructor_C_11() {
+
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+
+        }
+        /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+
+    }
+    /// @use-src 0:\"A\"
+    object \"C_11_deployed\" {
+        code {
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+            mstore(64, memoryguard(128))
+
+            if iszero(lt(calldatasize(), 4))
+            {
+                let selector := shift_right_224_unsigned(calldataload(0))
+                switch selector
+
+                case 0x26121ff0
+                {
+                    // f()
+
+                    external_fun_f_10()
+                }
+
+                default {}
+            }
+
+            revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74()
+
+            function shift_right_224_unsigned(value) -> newValue {
+                newValue :=
+
+                shr(224, value)
+
+            }
+
+            function allocate_unbounded() -> memPtr {
+                memPtr := mload(64)
+            }
+
+            function revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() {
+                revert(0, 0)
+            }
+
+            function revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() {
+                revert(0, 0)
+            }
+
+            function abi_decode_tuple_(headStart, dataEnd)   {
+                if slt(sub(dataEnd, headStart), 0) { revert_error_dbdddcbe895c83990c08b3492a0e83918d802a52331272ac6fdb6a7c4aea3b1b() }
+
+            }
+
+            function cleanup_t_bytes4(value) -> cleaned {
+                cleaned := and(value, 0xffffffff00000000000000000000000000000000000000000000000000000000)
+            }
+
+            function abi_encode_t_bytes4_to_t_bytes4_fromStack(value, pos) {
+                mstore(pos, cleanup_t_bytes4(value))
+            }
+
+            function abi_encode_tuple_t_bytes4__to_t_bytes4__fromStack(headStart , value0) -> tail {
+                tail := add(headStart, 32)
+
+                abi_encode_t_bytes4_to_t_bytes4_fromStack(value0,  add(headStart, 0))
+
+            }
+
+            function external_fun_f_10() {
+
+                if callvalue() { revert_error_ca66f745a3ce8ff40e2ccaf1ad45db7774001b90d25810abd9040049be7bf4bb() }
+                abi_decode_tuple_(4, calldatasize())
+                let ret_0 :=  fun_f_10()
+                let memPos := allocate_unbounded()
+                let memEnd := abi_encode_tuple_t_bytes4__to_t_bytes4__fromStack(memPos , ret_0)
+                return(memPos, sub(memEnd, memPos))
+
+            }
+
+            function revert_error_42b3090547df1d2001c96683413b8cf91c1b902ef5e3cb8d9f6f304cf7446f74() {
+                revert(0, 0)
+            }
+
+            function zero_value_for_split_t_bytes4() -> ret {
+                ret := 0
+            }
+
+            function cleanup_t_rational_2864434397_by_1(value) -> cleaned {
+                cleaned := value
+            }
+
+            function shift_left_224(value) -> newValue {
+                newValue :=
+
+                shl(224, value)
+
+            }
+
+            function convert_t_rational_2864434397_by_1_to_t_bytes4(value) -> converted {
+                converted := cleanup_t_bytes4(shift_left_224(cleanup_t_rational_2864434397_by_1(value)))
+            }
+
+            /// @ast-id 10
+            /// @src 0:91:157  \"function f() external pure returns (bytes4) { return 0xaabbccdd; }\"
+            function fun_f_10() -> var__5 {
+                /// @src 0:127:133  \"bytes4\"
+                let zero_t_bytes4_1 := zero_value_for_split_t_bytes4()
+                var__5 := zero_t_bytes4_1
+
+                /// @src 0:144:154  \"0xaabbccdd\"
+                let expr_7 := 0xaabbccdd
+                /// @src 0:137:154  \"return 0xaabbccdd\"
+                var__5 := convert_t_rational_2864434397_by_1_to_t_bytes4(expr_7)
+                leave
+
+            }
+            /// @src 0:78:159  \"contract C { function f() external pure returns (bytes4) { return 0xaabbccdd; } }\"
+
+        }
+
+        data \".metadata\" hex\"<BYTECODE REMOVED>\"
+    }
+
+}
+
+"
+            }
+        }
+    },
+    "sources":
+    {
+        "A":
+        {
+            "id": 0
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/yul_verbatim_msize/output b/compiler/test/cmdlineTests/yul_verbatim_msize/output
new file mode 100644
index 00000000..22259fff
--- /dev/null
+++ b/compiler/test/cmdlineTests/yul_verbatim_msize/output
@@ -0,0 +1,34 @@
+
+======= yul_verbatim_msize/input.yul (EVM) =======
+
+Pretty printed source:
+object "object" {
+    code {
+        {
+            pop(mload(0x2000))
+            verbatim_0i_0o("aa")
+            sstore(0, 2)
+        }
+    }
+}
+
+
+Binary representation:
+6120005150616160025f5500
+
+Text representation:
+    /* "yul_verbatim_msize/input.yul":125:131   */
+  0x2000
+    /* "yul_verbatim_msize/input.yul":119:132   */
+  mload
+  pop
+    /* "yul_verbatim_msize/input.yul":137:157   */
+  verbatimbytecode_6161
+    /* "yul_verbatim_msize/input.yul":172:173   */
+  0x02
+    /* "yul_verbatim_msize/input.yul":169:170   */
+  0x00
+    /* "yul_verbatim_msize/input.yul":162:174   */
+  sstore
+    /* "yul_verbatim_msize/input.yul":0:176   */
+  stop
diff --git a/compiler/test/cmdlineTests/~assembler_modes/test.sh b/compiler/test/cmdlineTests/~assembler_modes/test.sh
new file mode 100755
index 00000000..5ca1bb40
--- /dev/null
+++ b/compiler/test/cmdlineTests/~assembler_modes/test.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+function test_solc_assembly_output
+{
+    local input="${1}"
+    local expected="${2}"
+    IFS=" " read -r -a solc_args <<< "${3}"
+
+    local expected_object="object \"object\" { code ${expected} }"
+
+    output=$(echo "${input}" | msg_on_error --no-stderr "$SOLC" - "${solc_args[@]}")
+    empty=$(echo "$output" | tr '\n' ' ' | tr -s ' ' | sed -ne "/${expected_object}/p")
+    if [ -z "$empty" ]
+    then
+        printError "Incorrect assembly output. Expected: "
+        >&2 echo -e "${expected}"
+        printError "with arguments ${solc_args[*]}, but got:"
+        >&2 echo "${output}"
+        fail
+    fi
+}
+
+echo '{}' | msg_on_error --silent "$SOLC" - --assemble
+echo '{}' | msg_on_error --silent "$SOLC" - --yul
+echo '{}' | msg_on_error --silent "$SOLC" - --strict-assembly
+
+# Test options above in conjunction with --optimize.
+# Using both, --assemble and --optimize should fail.
+echo '{}' | "$SOLC" - --assemble --optimize &>/dev/null && fail "solc --assemble --optimize did not fail as expected."
+echo '{}' | "$SOLC" - --yul --optimize &>/dev/null && fail "solc --yul --optimize did not fail as expected."
+
+# Test yul and strict assembly output
+# Non-empty code results in non-empty binary representation with optimizations turned off,
+# while it results in empty binary representation with optimizations turned on.
+test_solc_assembly_output "{ let x:u256 := 0:u256 mstore(0, x) }" "{ { let x := 0 mstore(0, x) } }" "--yul"
+test_solc_assembly_output "{ let x:u256 := bitnot(7:u256) mstore(0, x) }" "{ { let x := bitnot(7) mstore(0, x) } }" "--yul"
+test_solc_assembly_output "{ let t:bool := not(true) if t { mstore(0, 1) } }" "{ { let t:bool := not(true) if t { mstore(0, 1) } } }" "--yul"
+test_solc_assembly_output "{ let x := 0 mstore(0, x) }" "{ { let x := 0 mstore(0, x) } }" "--strict-assembly"
+test_solc_assembly_output "{ let x := 0 mstore(0, x) }" "{ { } }" "--strict-assembly --optimize"
diff --git a/compiler/test/cmdlineTests/~ast_export_with_stop_after_parsing/test.sh b/compiler/test/cmdlineTests/~ast_export_with_stop_after_parsing/test.sh
new file mode 100755
index 00000000..e6a69d28
--- /dev/null
+++ b/compiler/test/cmdlineTests/~ast_export_with_stop_after_parsing/test.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+"$REPO_ROOT/test/stopAfterParseTests.sh"
diff --git a/compiler/test/cmdlineTests/~ast_import_export/test.sh b/compiler/test/cmdlineTests/~ast_import_export/test.sh
new file mode 100755
index 00000000..ff3ab881
--- /dev/null
+++ b/compiler/test/cmdlineTests/~ast_import_export/test.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-ast-import-export-XXXXXX")
+cd "$SOLTMPDIR"
+if ! "$REPO_ROOT/scripts/ASTImportTest.sh" ast
+then
+    rm -r "$SOLTMPDIR"
+    fail
+fi
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/inputs.sol b/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/inputs.sol
new file mode 100644
index 00000000..43099c7a
--- /dev/null
+++ b/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/inputs.sol
@@ -0,0 +1,29 @@
+==== Source: A.sol ====
+import "@/D.sol";
+import "B.sol";
+
+contract A is B {
+    function a() public pure {
+        e();
+    }
+}
+
+==== Source: B.sol ====
+import "C.sol";
+
+abstract contract B is C {}
+
+==== Source: C.sol ====
+abstract contract C {
+    function c() public pure returns (uint) {
+        return 0;
+    }
+}
+
+==== Source: @/D.sol ====
+import "@/E.sol";
+
+==== Source: @/E.sol ====
+function e() pure returns (bytes memory returndata) {
+    return "";
+}
diff --git a/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/test.py b/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/test.py
new file mode 100755
index 00000000..32be181e
--- /dev/null
+++ b/compiler/test/cmdlineTests/~bytecode_equivalence_independent_of_import_discovery_order/test.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+from pathlib import Path
+from textwrap import dedent
+
+# pylint: disable=wrong-import-position
+PROJECT_ROOT = Path(__file__).parents[3]
+sys.path.insert(0, str(PROJECT_ROOT / 'scripts'))
+
+from common.cmdline_helpers import add_preamble
+from common.cmdline_helpers import inside_temporary_dir
+from common.cmdline_helpers import save_bytecode
+from common.cmdline_helpers import solc_bin_report
+from common.git_helpers import git_diff
+from splitSources import split_sources
+
+
+@inside_temporary_dir(Path(__file__).parent.name)
+def test_bytecode_equivalence():
+    source_file_path = Path(__file__).parent / 'inputs.sol'
+    split_sources(source_file_path, suppress_output=True)
+    add_preamble(Path.cwd())
+
+    solc_binary = os.environ.get('SOLC')
+    if solc_binary is None:
+        raise RuntimeError(dedent("""\
+            `solc` compiler not found.
+            Please ensure you set the SOLC environment variable
+            with the correct path to the compiler's binary.
+        """))
+
+    # Whether a file is passed to the compiler explicitly or only discovered when traversing imports
+    # may affect the order in which files are processed and result in different AST IDs.
+    # This, however, must not result in different bytecode being generated.
+    save_bytecode(Path('A.bin'), solc_bin_report(solc_binary, [Path('A.sol')], via_ir=True))
+    save_bytecode(Path('AB.bin'), solc_bin_report(solc_binary, [Path('A.sol'), Path('B.sol')], via_ir=True))
+    return git_diff(Path('A.bin'), Path('AB.bin'))
+
+
+if __name__ == '__main__':
+    sys.exit(test_bytecode_equivalence())
diff --git a/compiler/test/cmdlineTests/~cli_and_standard_json_equivalence/test.sh b/compiler/test/cmdlineTests/~cli_and_standard_json_equivalence/test.sh
new file mode 100755
index 00000000..4a7fe05b
--- /dev/null
+++ b/compiler/test/cmdlineTests/~cli_and_standard_json_equivalence/test.sh
@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+function test_cli_and_standard_json_equivalence
+{
+    (( $# == 5 )) || assertFail
+    local cli_options="$1"
+    local selected_cli_output="$2"
+    local standard_json_settings="$3"
+    local selected_standard_json_output="$4"
+    local input_file_relative_path="$5"
+
+    # CLI normalizes paths, Standard JSON uses them as is. Using paths that would change under this
+    # normalization will make the comparison fail. To avoid this use already normalized paths.
+    # The sanity check below should reject most of these by disallowing absolute paths, relative
+    # paths with ./ or ../ segments and paths with redundant slashes, but keep in mind it's not foolproof.
+    [[ $input_file_relative_path =~ ^/|^\.$|\./|^\.\.$|\.\./|// ]] && assertfail
+
+    local cli_output standard_json_output
+    cli_output=$(
+        # shellcheck disable=SC2086 # Intentionally unquoted. May contain multiple options.
+        msg_on_error --no-stderr \
+            "$SOLC" $cli_options "$selected_cli_output" "$input_file_relative_path"
+    )
+    standard_json_output=$(
+        singleContractOutputViaStandardJSON \
+            Solidity \
+            "$selected_standard_json_output" \
+            "$standard_json_settings" \
+            "$input_file_relative_path"
+    )
+
+    diff_values \
+        "$(echo "$cli_output" | stripCLIDecorations | stripEmptyLines)" \
+        "$(echo "$standard_json_output" | stripEmptyLines)" \
+        --ignore-space-change \
+        --ignore-blank-lines
+}
+
+cd "$REPO_ROOT"
+
+printTask "    - --optimize vs optimizer.enabled: true (--asm output)"
+test_cli_and_standard_json_equivalence \
+    '--optimize' \
+    '--asm' \
+    '"optimizer": {"enabled": true}' \
+    'evm.assembly' \
+    "test/libsolidity/semanticTests/various/erc20.sol"
+
+printTask "    - --optimize-yul vs optimizer.details.yul: true (--asm output)"
+test_cli_and_standard_json_equivalence \
+    '--optimize-yul' \
+    '--asm' \
+    '"optimizer": {"enabled": false, "details": {"yul": true}}' \
+    'evm.assembly' \
+    "test/libsolidity/semanticTests/various/erc20.sol"
diff --git a/compiler/test/cmdlineTests/~compilation_tests/test.sh b/compiler/test/cmdlineTests/~compilation_tests/test.sh
new file mode 100755
index 00000000..d411c5ce
--- /dev/null
+++ b/compiler/test/cmdlineTests/~compilation_tests/test.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+cd "$REPO_ROOT"/test/compilationTests/
+for dir in */
+do
+    echo "    - $dir"
+    cd "$dir"
+    # shellcheck disable=SC2046 # These file names are not supposed to contain spaces.
+    compileFull --expect-warnings $(find . -name '*.sol')
+    cd ..
+done
diff --git a/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/test.sh b/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/test.sh
new file mode 100755
index 00000000..19b57e8c
--- /dev/null
+++ b/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/test.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# This is a regression test against https://github.com/ethereum/solidity/issues/14640
+# The bug caused the block deduplicator to incorrectly merge two blocks which have
+# verbatim items surrounded by identical opcodes. Due to the bug, the contents of
+# the verbatim were ignored and the blocks merged into a single one.
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+YUL_SOURCE="${SCRIPT_DIR}/verbatim_inside_identical_blocks.yul"
+
+VERBATIM_OCCURRENCES=$(< "$YUL_SOURCE" "$SOLC" --strict-assembly - --optimize --asm | grep -e "verbatim" -c)
+
+[[ $VERBATIM_OCCURRENCES == 2 ]] || assertFail "Incorrect number of verbatim items in assembly."
diff --git a/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/verbatim_inside_identical_blocks.yul b/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/verbatim_inside_identical_blocks.yul
new file mode 100644
index 00000000..1dc9a461
--- /dev/null
+++ b/compiler/test/cmdlineTests/~deduplicator-verbatim-bug/verbatim_inside_identical_blocks.yul
@@ -0,0 +1,21 @@
+{
+  let special := 0xFFFFFFFFFFFF
+  let input := sload(0)
+  let output
+
+  switch input
+  case 0x00 {
+      output := verbatim_1i_1o(hex"506000", special)
+  }
+  case 0x01 {
+      output := 1
+  }
+  case 0x02 {
+      output := verbatim_1i_1o(hex"506002", special)
+  }
+  case 0x03 {
+      output := 3
+  }
+
+  sstore(0, output)
+}
diff --git a/compiler/test/cmdlineTests/~documentation_examples/test.sh b/compiler/test/cmdlineTests/~documentation_examples/test.sh
new file mode 100755
index 00000000..1acf5e8a
--- /dev/null
+++ b/compiler/test/cmdlineTests/~documentation_examples/test.sh
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-docs-examples-XXXXXX")
+cd "$SOLTMPDIR"
+
+"$REPO_ROOT"/scripts/isolate_tests.py "$REPO_ROOT"/docs/
+
+developmentVersion=$("$REPO_ROOT/scripts/get_version.sh")
+
+for f in *.yul *.sol
+do
+    # The contributors guide uses syntax tests, but we cannot
+    # really handle them here.
+    if grep -E 'DeclarationError:|// ----' "$f" >/dev/null
+    then
+        continue
+    fi
+    echo "    - Compiling example $f"
+
+    opts=()
+    # We expect errors if explicitly stated, or if imports
+    # are used (in the style guide)
+    if grep -E "// This will not compile" "$f" >/dev/null ||
+        sed -e 's|//.*||g' "$f" | grep -E "import \"" >/dev/null
+    then
+        opts=(--expect-errors)
+    fi
+    if grep "// This will report a warning" "$f" >/dev/null
+    then
+        opts+=(--expect-warnings)
+    fi
+    if grep "// This may report a warning" "$f" >/dev/null
+    then
+        opts+=(--ignore-warnings)
+    fi
+
+    # Disable the version pragma in code snippets that only work with the current development version.
+    # It's necessary because x.y.z won't match `^x.y.z` or `>=x.y.z` pragmas until it's officially released.
+    sed -i.bak -E -e 's/pragma[[:space:]]+solidity[[:space:]]*(\^|>=)[[:space:]]*'"$developmentVersion"'/pragma solidity >0.0.1/' "$f"
+    compileFull "${opts[@]}" "$SOLTMPDIR/$f"
+done
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~evmasm_import_export/test.sh b/compiler/test/cmdlineTests/~evmasm_import_export/test.sh
new file mode 100755
index 00000000..f1ef07af
--- /dev/null
+++ b/compiler/test/cmdlineTests/~evmasm_import_export/test.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-evmasm-import-export-XXXXXX")
+cd "$SOLTMPDIR"
+if ! "$REPO_ROOT/scripts/ASTImportTest.sh" evm-assembly
+then
+    rm -r "$SOLTMPDIR"
+    fail
+fi
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~library_checksum/test.sh b/compiler/test/cmdlineTests/~library_checksum/test.sh
new file mode 100755
index 00000000..bb5fbf51
--- /dev/null
+++ b/compiler/test/cmdlineTests/~library_checksum/test.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+echo '' | msg_on_error --no-stdout "$SOLC" - --link --libraries a=0x90f20564390eAe531E810af625A22f51385Cd222
+echo '' | "$SOLC" - --link --libraries a=0x80f20564390eAe531E810af625A22f51385Cd222 &>/dev/null && \
+    fail "solc --link did not reject a library address with an invalid checksum."
+
+exit 0
diff --git a/compiler/test/cmdlineTests/~library_long_names/test.sh b/compiler/test/cmdlineTests/~library_long_names/test.sh
new file mode 100755
index 00000000..ad3008cd
--- /dev/null
+++ b/compiler/test/cmdlineTests/~library_long_names/test.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+echo '' | msg_on_error --no-stdout "$SOLC" - --link --libraries aveeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeerylonglibraryname=0x90f20564390eAe531E810af625A22f51385Cd222
diff --git a/compiler/test/cmdlineTests/~linking/test.sh b/compiler/test/cmdlineTests/~linking/test.sh
new file mode 100755
index 00000000..ad7d9e17
--- /dev/null
+++ b/compiler/test/cmdlineTests/~linking/test.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-linking-XXXXXX")
+cd "$SOLTMPDIR"
+
+echo 'library L { function f() public pure {} } contract C { function f() public pure { L.f(); } }' > x.sol
+msg_on_error --no-stderr "$SOLC" --bin -o . x.sol
+
+# Explanation and placeholder should be there
+grep -q '//' C.bin && grep -q '__' C.bin
+
+# But not in library file.
+grep -q -v '[/_]' L.bin
+
+# Now link
+printf "    "
+msg_on_error "$SOLC" --link --libraries x.sol:L=0x90f20564390eAe531E810af625A22f51385Cd222 C.bin
+
+# Now the placeholder and explanation should be gone.
+grep -q -v '[/_]' C.bin
+
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~name_dependent_cse_bug/cse_bug.yul b/compiler/test/cmdlineTests/~name_dependent_cse_bug/cse_bug.yul
new file mode 100644
index 00000000..2ed2f27f
--- /dev/null
+++ b/compiler/test/cmdlineTests/~name_dependent_cse_bug/cse_bug.yul
@@ -0,0 +1,30 @@
+object "C" {
+    code {}
+
+    object "C_deployed" {
+        code {
+            main(0, 0)
+
+            function main(a, b) {
+                for {} 1 {}
+                {
+                    if iszero(a) { break }
+
+                    let mid := avg(a, a)
+                    switch a
+                    case 0 {
+                        a := mid
+                    }
+                    default {
+                        sstore(0, mid)
+                    }
+                }
+            }
+
+            function avg(x, y) -> var {
+                let __placeholder__ := add(x, y)
+                var := add(__placeholder__, __placeholder__)
+            }
+        }
+    }
+}
diff --git a/compiler/test/cmdlineTests/~name_dependent_cse_bug/test.sh b/compiler/test/cmdlineTests/~name_dependent_cse_bug/test.sh
new file mode 100755
index 00000000..96c3ac23
--- /dev/null
+++ b/compiler/test/cmdlineTests/~name_dependent_cse_bug/test.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# This is a regression test against https://github.com/ethereum/solidity/issues/14494
+# Due to the bug, a decision about which variable to use to replace a subexpression in CSE would
+# depend on sorting order of variable names. A variable not being used as a replacement could lead
+# to it being unused in general and removed by Unused Pruner. This would show up as a difference
+# in the bytecode.
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+
+function assemble_with_variable_name {
+    local input_file="$1"
+    local variable_name="$2"
+
+    sed -e "s|__placeholder__|${variable_name}|g" "$input_file" | msg_on_error --no-stderr \
+        "$SOLC" --strict-assembly - --optimize --debug-info none |
+            stripCLIDecorations
+}
+
+diff_values \
+    "$(assemble_with_variable_name "${SCRIPT_DIR}/cse_bug.yul" _1)" \
+    "$(assemble_with_variable_name "${SCRIPT_DIR}/cse_bug.yul" _2)"
diff --git a/compiler/test/cmdlineTests/~overwriting_files/test.sh b/compiler/test/cmdlineTests/~overwriting_files/test.sh
new file mode 100755
index 00000000..acb8a7ac
--- /dev/null
+++ b/compiler/test/cmdlineTests/~overwriting_files/test.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-overwriting-files-XXXXXX")
+
+# First time it works
+echo 'contract C {}' | msg_on_error --no-stderr "$SOLC" - --bin -o "$SOLTMPDIR/non-existing-stuff-to-create"
+
+# Second time it fails
+echo 'contract C {}' | "$SOLC" - --bin -o "$SOLTMPDIR/non-existing-stuff-to-create" 2>/dev/null && \
+    fail "solc did not refuse to overwrite $SOLTMPDIR/non-existing-stuff-to-create."
+
+# Unless we force
+echo 'contract C {}' | msg_on_error --no-stderr "$SOLC" - --overwrite --bin -o "$SOLTMPDIR/non-existing-stuff-to-create"
+
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~soljson_via_fuzzer/test.sh b/compiler/test/cmdlineTests/~soljson_via_fuzzer/test.sh
new file mode 100755
index 00000000..9c1d338c
--- /dev/null
+++ b/compiler/test/cmdlineTests/~soljson_via_fuzzer/test.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-soljson-via-fuzzer-XXXXXX")
+cd "$SOLTMPDIR"
+
+"$REPO_ROOT"/scripts/isolate_tests.py "$REPO_ROOT"/test/
+"$REPO_ROOT"/scripts/isolate_tests.py "$REPO_ROOT"/docs/
+
+gnu_grep -L --include="*.sol" "^pragma experimental solidity;$" ./* | xargs -P 4 -n 50 "${SOLIDITY_BUILD_DIR}/test/tools/solfuzzer" --quiet --input-files
+gnu_grep -L --include="*.sol" "^pragma experimental solidity;$" ./* | xargs -P 4 -n 50 "${SOLIDITY_BUILD_DIR}/test/tools/solfuzzer" --without-optimizer --quiet --input-files
+
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~standard_input/test.sh b/compiler/test/cmdlineTests/~standard_input/test.sh
new file mode 100755
index 00000000..4aab34be
--- /dev/null
+++ b/compiler/test/cmdlineTests/~standard_input/test.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+set +e
+output=$("$SOLC" --bin 2>&1)
+result=$?
+set -e
+
+# This should fail
+if [[ ! ("$output" =~ "No input files given") || ($result == 0) ]]
+then
+    fail "Incorrect response to empty input arg list: $output"
+fi
+
+# The contract should be compiled
+if ! echo 'contract C {}' | msg_on_error --no-stderr "$SOLC" - --bin | grep -q "<stdin>:C"
+then
+    fail "Failed to compile a simple contract from standard input"
+fi
+
+# This should not fail
+echo '' | msg_on_error --silent --msg "Incorrect response to --ast-compact-json option with empty stdin" \
+    "$SOLC" --ast-compact-json -
diff --git a/compiler/test/cmdlineTests/~unknown_options/test.sh b/compiler/test/cmdlineTests/~unknown_options/test.sh
new file mode 100755
index 00000000..373a849d
--- /dev/null
+++ b/compiler/test/cmdlineTests/~unknown_options/test.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+set +e
+output=$("$SOLC" --allow=test 2>&1)
+failed=$?
+set -e
+
+if [[ $output != "Error: unrecognised option '--allow=test'" ]] || (( failed == 0 ))
+then
+    fail "Incorrect response to unknown options: $output"
+fi
diff --git a/compiler/test/cmdlineTests/~update_bugs_by_version/test.sh b/compiler/test/cmdlineTests/~update_bugs_by_version/test.sh
new file mode 100755
index 00000000..6ec1d069
--- /dev/null
+++ b/compiler/test/cmdlineTests/~update_bugs_by_version/test.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+
+SOLTMPDIR=$(mktemp -d -t "cmdline-test-update-bugs-by-version-XXXXXX")
+
+cp "${REPO_ROOT}/docs/bugs_by_version.json" "${SOLTMPDIR}/original_bugs_by_version.json"
+"${REPO_ROOT}/scripts/update_bugs_by_version.py"
+
+diff --unified "${SOLTMPDIR}/original_bugs_by_version.json" "${REPO_ROOT}/docs/bugs_by_version.json" || \
+    fail "The bug list in bugs_by_version.json was out of date and has been updated. Please investigate and submit a bugfix if necessary."
+
+rm -r "$SOLTMPDIR"
diff --git a/compiler/test/cmdlineTests/~via_ir_equivalence/test.sh b/compiler/test/cmdlineTests/~via_ir_equivalence/test.sh
new file mode 100755
index 00000000..d663bef8
--- /dev/null
+++ b/compiler/test/cmdlineTests/~via_ir_equivalence/test.sh
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# shellcheck source=scripts/common.sh
+source "${REPO_ROOT}/scripts/common.sh"
+# shellcheck source=scripts/common_cmdline.sh
+source "${REPO_ROOT}/scripts/common_cmdline.sh"
+
+function test_via_ir_equivalence()
+{
+    (( $# <= 2 )) || fail "This function accepts at most two arguments."
+    local solidity_file="$1"
+    local optimize_flag="$2"
+    [[ $optimize_flag == --optimize || $optimize_flag == "" ]] || assertFail "The second argument must be --optimize if present."
+
+    local output_file_prefix
+    output_file_prefix=$(basename "$solidity_file" .sol)
+
+    SOLTMPDIR=$(mktemp -d -t "cmdline-test-via-ir-equivalence-${output_file_prefix}-XXXXXX")
+    pushd "$SOLTMPDIR" > /dev/null
+
+    local optimizer_flags=()
+    [[ $optimize_flag == "" ]] || optimizer_flags+=("$optimize_flag")
+    [[ $optimize_flag == "" ]] || output_file_prefix+="_optimize"
+
+    msg_on_error --no-stderr \
+        "$SOLC" --ir-optimized --debug-info location "${optimizer_flags[@]}" "$solidity_file" |
+            stripCLIDecorations |
+            split_on_empty_lines_into_numbered_files "$output_file_prefix" ".yul"
+
+    local asm_output_two_stage asm_output_via_ir
+
+    for yul_file in $(find . -name "${output_file_prefix}*.yul" | sort -V); do
+        asm_output_two_stage+=$(
+            msg_on_error --no-stderr \
+                "$SOLC" --strict-assembly --asm "${optimizer_flags[@]}" --no-optimize-yul "$yul_file" |
+                    stripCLIDecorations
+        )
+    done
+
+    asm_output_via_ir=$(
+        msg_on_error --no-stderr \
+            "$SOLC" --via-ir --asm --debug-info location "${optimizer_flags[@]}" "$solidity_file" |
+                stripCLIDecorations
+    )
+
+    diff_values "$asm_output_two_stage" "$asm_output_via_ir" --ignore-space-change --ignore-blank-lines
+
+    local bin_output_two_stage bin_output_via_ir
+
+    for yul_file in $(find . -name "${output_file_prefix}*.yul" | sort -V); do
+        bin_output_two_stage+=$(
+            msg_on_error --no-stderr \
+                "$SOLC" --strict-assembly --bin "${optimizer_flags[@]}" "$yul_file" --no-optimize-yul |
+                    stripCLIDecorations
+        )
+    done
+
+    bin_output_via_ir=$(
+        msg_on_error --no-stderr \
+            "$SOLC" --via-ir --bin "${optimizer_flags[@]}" "$solidity_file" | stripCLIDecorations
+    )
+
+    diff_values "$bin_output_two_stage" "$bin_output_via_ir" --ignore-space-change --ignore-blank-lines
+
+    popd > /dev/null
+    rm -r "$SOLTMPDIR"
+}
+
+externalContracts=(
+    externalTests/solc-js/DAO/TokenCreation.sol
+    libsolidity/semanticTests/externalContracts/_prbmath/PRBMathSD59x18.sol
+    libsolidity/semanticTests/externalContracts/_prbmath/PRBMathUD60x18.sol
+    libsolidity/semanticTests/externalContracts/_stringutils/stringutils.sol
+    libsolidity/semanticTests/externalContracts/deposit_contract.sol
+    libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol
+    libsolidity/semanticTests/externalContracts/snark.sol
+)
+
+requiresOptimizer=(
+    externalTests/solc-js/DAO/TokenCreation.sol
+    libsolidity/semanticTests/externalContracts/deposit_contract.sol
+    libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol
+    libsolidity/semanticTests/externalContracts/snark.sol
+)
+
+for contractFile in "${externalContracts[@]}"
+do
+    if ! [[ "${requiresOptimizer[*]}" =~ $contractFile ]]
+    then
+        printTask "    - ${contractFile}"
+        test_via_ir_equivalence "${REPO_ROOT}/test/${contractFile}"
+    fi
+
+    printTask "    - ${contractFile} (optimized)"
+    test_via_ir_equivalence "${REPO_ROOT}/test/${contractFile}" --optimize
+done
diff --git a/compiler/test/compilationTests/corion/premium.sol b/compiler/test/compilationTests/corion/premium.sol
new file mode 100644
index 00000000..8dbe7621
--- /dev/null
+++ b/compiler/test/compilationTests/corion/premium.sol
@@ -0,0 +1,346 @@
+pragma solidity >=0.0;
+
+import "./safeMath.sol";
+import "./tokenDB.sol";
+import "./module.sol";
+
+contract thirdPartyPContractAbstract {
+    function receiveCorionPremiumToken(address, uint256, bytes calldata) external returns (bool, uint256) {}
+    function approvedCorionPremiumToken(address, uint256, bytes calldata) external returns (bool) {}
+}
+
+contract ptokenDB is tokenDB {}
+
+/**
+ *
+ * @title Corion Platform Premium Token
+ * @author iFA @ Corion Platform
+ *
+ */
+contract premium is module, safeMath {
+    function replaceModule(address payable addr) external override returns (bool success) {
+        require( super.isModuleHandler(payable(msg.sender)) );
+        require( db.replaceOwner(addr) );
+        super._replaceModule(addr);
+        return true;
+    }
+    modifier isReady {
+        (bool _success, bool _active) = super.isActive();
+        require( _success && _active );
+        _;
+    }
+
+    string public name = "Corion Premium";
+    string public symbol = "CORP";
+    uint8 public decimals = 0;
+
+    address public icoAddr;
+    tokenDB public db;
+    bool    public  isICO;
+
+    mapping(address => bool) public genesis;
+
+    constructor(bool forReplace, address payable moduleHandler, address dbAddress, address icoContractAddr, address[] memory genesisAddr, uint256[] memory genesisValue) {
+        /*
+            Setup function.
+            If an ICOaddress is defined then the balance of the genesis addresses will be set as well.
+
+            @forReplace         This address will be replaced with the old one or not.
+            @moduleHandler      Modulhandler’s address
+            @dbAddress          Address of database
+            @icoContractAddr    Address of ico contract.
+            @genesisAddr        Array of the genesis addresses.
+            @genesisValue       Array of the balance of the genesis addresses
+        */
+        super.registerModuleHandler(moduleHandler);
+        require( dbAddress != address(0x00) );
+        db = ptokenDB(dbAddress);
+        if ( ! forReplace ) {
+            require( db.replaceOwner(address(this)) );
+            isICO = true;
+            icoAddr = icoContractAddr;
+            assert( genesisAddr.length == genesisValue.length );
+            for ( uint256 a=0 ; a<genesisAddr.length ; a++ ) {
+                genesis[genesisAddr[a]] = true;
+                require( db.increase(genesisAddr[a], genesisValue[a]) );
+                emit Mint(genesisAddr[a], genesisValue[a]);
+            }
+        }
+    }
+
+    function closeIco() external returns (bool success) {
+        /*
+            Finishing the ICO. Can be invited only by an ICO contract.
+
+            @success    If the function was successful.
+        */
+        require( isICO );
+        isICO = false;
+        return true;
+    }
+
+    /**
+     * @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf.
+     * @param spender The address of the account able to transfer the tokens
+     * @param amount The amount of tokens to be approved for transfer
+     * @param nonce The transaction count of the authorised address
+     * @return success True if the approval was successful
+     */
+    function approve(address spender, uint256 amount, uint256 nonce) isReady external returns (bool success) {
+        /*
+            Authorize another address to use an exact amount of the principal’s balance.
+
+            @spender    Address of authorised party
+            @amount     Token quantity
+            @nonce      Transaction count
+
+            @success    Was the Function successful?
+        */
+        _approve(spender, amount, nonce);
+        return true;
+    }
+
+    /**
+     * @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf and notify the spender from your approve with your `extraData` data.
+     * @param spender The address of the account able to transfer the tokens
+     * @param amount The amount of tokens to be approved for transfer
+     * @param nonce The transaction count of the authorised address
+     * @param extraData Data to give forward to the receiver
+     * @return success True if the approval was successful
+     */
+    function approveAndCall(address spender, uint256 amount, uint256 nonce, bytes calldata extraData) isReady external returns (bool success) {
+        /*
+            Authorize another address to use an exact amount of the principal’s balance.
+            After the transaction the approvedCorionPremiumToken function of the address will be called with the given data.
+
+            @spender        Authorized address
+            @amount         Token quantity
+            @extraData      Extra data to be received by the receiver
+            @nonce          Transaction count
+
+            @success         Was the Function successful?
+        */
+        _approve(spender, amount, nonce);
+        require( thirdPartyPContractAbstract(spender).approvedCorionPremiumToken(msg.sender, amount, extraData) );
+        return true;
+    }
+
+    function _approve(address spender, uint256 amount, uint256 nonce) isReady internal {
+        /*
+            Inner function to authorize another address to use an exact amount of the principal’s balance.
+            If the transaction count not match the authorise fails.
+
+            @spender    Address of authorised party
+            @amount     Token quantity
+            @nonce      Transaction count
+        */
+        require( msg.sender != spender );
+        require( db.balanceOf(msg.sender) >= amount );
+        require( db.setAllowance(msg.sender, spender, amount, nonce) );
+        emit Approval(msg.sender, spender, amount);
+    }
+
+    function allowance(address owner, address spender) public view returns (uint256 remaining, uint256 nonce) {
+        /*
+            Get the quantity of tokens given to be used
+
+            @owner          Authorising address
+            @spender        Authorised address
+
+            @remaining      Tokens to be spent
+            @nonce          Transaction count
+        */
+        (bool _success, uint256 _remaining, uint256 _nonce) = db.getAllowance(owner, spender);
+        require( _success );
+        return (_remaining, _nonce);
+    }
+
+    /**
+     * @notice Send `amount` Corion tokens to `to` from `msg.sender`
+     * @param to The address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @return success Whether the transfer was successful or not
+     */
+    function transfer(address to, uint256 amount) isReady external returns (bool success) {
+        /*
+            Launch a transaction where the token is sent from the sender’s address to the receiver’s address.
+            Transaction fee is going to be added as well.
+            If the receiver is not a natural address but also a person then she/he will be invited as well.
+
+            @to         For who
+            @amount     Amount
+
+            @success    Was the function successful?
+        */
+        bytes memory _data;
+        if ( isContract(to) ) {
+            transferToContract(msg.sender, to, amount, _data);
+        } else {
+            _transfer(msg.sender, to, amount);
+        }
+        emit Transfer(msg.sender, to, amount, _data);
+        return true;
+    }
+
+    /**
+     * @notice Send `amount` tokens to `to` from `from` on the condition it is approved by `from`
+     * @param from The address holding the tokens being transferred
+     * @param to The address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @return success True if the transfer was successful
+     */
+    function transferFrom(address from, address to, uint256 amount) isReady external returns (bool success) {
+        /*
+            Launch a transaction where we transfer from a given address to another one. It can only be called by an address which was allowed before.
+            Transaction fee will be charged too.
+            If the receiver is not a natural address but also a person then she/he will be invited as well
+
+            @from       From who?
+            @to         For who?
+            @amount     Amount
+
+            @success    If the function was successful.
+        */
+        if ( from != msg.sender ) {
+            (bool _success, uint256 _remaining, uint256 _nonce) = db.getAllowance(from, msg.sender);
+            require( _success );
+            _remaining = safeSub(_remaining, amount);
+            _nonce = safeAdd(_nonce, 1);
+            require( db.setAllowance(from, msg.sender, _remaining, _nonce) );
+            emit AllowanceUsed(msg.sender, from, amount);
+        }
+        bytes memory _data;
+        if ( isContract(to) ) {
+            transferToContract(from, to, amount, _data);
+        } else {
+            _transfer( from, to, amount);
+        }
+        emit Transfer(from, to, amount, _data);
+        return true;
+    }
+
+    /**
+     * @notice Send `amount` Corion tokens to `to` from `msg.sender` and notify the receiver from your transaction with your `extraData` data
+     * @param to The contract address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @param extraData Data to give forward to the receiver
+     * @return success Whether the transfer was successful or not
+     */
+    function transfer(address to, uint256 amount, bytes calldata extraData) isReady external returns (bool success) {
+        /*
+            Launch a transaction where we transfer from a given address to another one.
+            After thetransaction the approvedCorionPremiumToken function of the receiver’s address is going to be called with the given data.
+
+            @to         For who?
+            @amount     Amount
+            @extraData  Extra data that will be given to the receiver
+
+            @success    If the function was successful.
+        */
+        if ( isContract(to) ) {
+            transferToContract(msg.sender, to, amount, extraData);
+        } else {
+            _transfer( msg.sender, to, amount);
+        }
+        emit Transfer(msg.sender, to, amount, extraData);
+        return true;
+    }
+
+    function transferToContract(address from, address to, uint256 amount, bytes memory extraData) internal {
+        /*
+            Inner function in order to transact a contract.
+
+            @to             For who?
+            @amount         Amount
+            @extraData      Extra data that will be given to the receiver
+        */
+        _transfer(from, to, amount);
+        (bool _success, uint256 _back) = thirdPartyPContractAbstract(to).receiveCorionPremiumToken(from, amount, extraData);
+        require( _success );
+        require( amount > _back );
+        if ( _back > 0 ) {
+            _transfer(to, from, _back);
+        }
+    }
+
+    function _transfer(address from, address to, uint256 amount) isReady internal {
+        /*
+            Inner function to launch a transaction.
+            During the ICO transactions are only possible from the genesis address.
+            0xa636a97578d26a3b76b060bbc18226d954cf3757 address is blacklisted.
+
+            @from      From how?
+            @to        For who?
+            @amount    Amount
+        */
+        require( from != address(0x00) && to != address(0x00) && to != 0xa636A97578d26A3b76B060Bbc18226d954cf3757 );
+        require( ( ! isICO) || genesis[from] );
+        require( db.decrease(from, amount) );
+        require( db.increase(to, amount) );
+    }
+
+    function mint(address owner, uint256 value) external returns (bool success) {
+        /*
+            Generating tokens. It can be called only by ICO contract.
+
+            @owner      Address
+            @value      Amount.
+
+            @success    Was the Function successful?
+        */
+        require( msg.sender == icoAddr || isICO );
+        _mint(owner, value);
+        return true;
+    }
+
+    function _mint(address owner, uint256 value) isReady internal {
+        /*
+            Inner function to create a token.
+
+            @owner     Address of crediting the token.
+            @value     Amount
+        */
+        require( db.increase(owner, value) );
+        emit Mint(owner, value);
+    }
+
+    function isContract(address addr) internal returns (bool success) {
+        /*
+            Inner function in order to check if the given address is a natural address or a contract.
+
+            @addr       The address which is needed to be checked.
+
+            @success    Is the address crontact or not
+        */
+        uint256 _codeLength;
+        assembly {
+            _codeLength := extcodesize(addr)
+        }
+        return _codeLength > 0;
+    }
+
+    function balanceOf(address owner) public view returns (uint256 value) {
+        /*
+            Token balance query
+
+            @owner      Address
+            @value      Balance of address
+        */
+        return db.balanceOf(owner);
+    }
+
+    function totalSupply() public view returns (uint256 value) {
+        /*
+            Total token quantity query
+
+            @value      Total token quantity
+        */
+        return db.totalSupply();
+    }
+
+    event AllowanceUsed(address indexed spender, address indexed owner, uint256 indexed value);
+    event Mint(address indexed addr, uint256 indexed value);
+    event Burn(address indexed addr, uint256 indexed value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+    event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _extraData);
+}
diff --git a/compiler/test/compilationTests/corion/token.sol b/compiler/test/compilationTests/corion/token.sol
new file mode 100644
index 00000000..51c93f12
--- /dev/null
+++ b/compiler/test/compilationTests/corion/token.sol
@@ -0,0 +1,519 @@
+pragma solidity >=0.0;
+
+import "./announcementTypes.sol";
+import "./safeMath.sol";
+import "./module.sol";
+import "./moduleHandler.sol";
+import "./tokenDB.sol";
+
+contract thirdPartyContractAbstract {
+    function receiveCorionToken(address, uint256, bytes calldata) external returns (bool, uint256) {}
+    function approvedCorionToken(address, uint256, bytes calldata) external returns (bool) {}
+}
+
+/**
+ *
+ * @title Corion Platform Token
+ * @author iFA @ Corion Platform
+ *
+ */
+contract token is safeMath, module, announcementTypes {
+    /*
+        module callbacks
+    */
+    function replaceModule(address payable addr) external override returns (bool success) {
+        require( super.isModuleHandler(payable(msg.sender)) );
+        require( db.replaceOwner(addr) );
+        super._replaceModule(addr);
+        return true;
+    }
+    modifier isReady {
+        (bool _success, bool _active) = super.isActive();
+        require( _success && _active );
+        _;
+    }
+
+    string public name = "Corion";
+    string public symbol = "COR";
+    uint8 public decimals = 6;
+
+    tokenDB public db;
+    address payable public icoAddr;
+    uint256 public transactionFeeRate      = 20;
+    uint256 public transactionFeeRateM     = 1e3;
+    uint256 public transactionFeeMin       =   20000;
+    uint256 public transactionFeeMax       = 5000000;
+    uint256 public transactionFeeBurn      = 80;
+    address payable public exchangeAddress;
+    bool    public isICO                   = true;
+
+    mapping(address => bool) public genesis;
+
+    constructor(bool forReplace, address payable moduleHandler, address dbAddr, address payable icoContractAddr, address payable exchangeContractAddress, address payable[] memory genesisAddr, uint256[] memory genesisValue) payable {
+        /*
+            Installation function
+
+            When _icoAddr is defined, 0.2 ether has to be attached  as many times  as many genesis addresses are given
+
+            @forReplace                 This address will be replaced with the old one or not.
+            @moduleHandler              Modulhandler's address
+            @dbAddr                     Address of database
+            @icoContractAddr            Address of ICO contract
+            @exchangeContractAddress    Address of Market in order to buy gas during ICO
+            @genesisAddr                Array of Genesis addresses
+            @genesisValue               Array of balance of genesis addresses
+        */
+        super.registerModuleHandler(moduleHandler);
+        require( dbAddr != address(0x00) );
+        require( icoContractAddr != address(0x00) );
+        require( exchangeContractAddress != address(0x00) );
+        db = tokenDB(dbAddr);
+        icoAddr = icoContractAddr;
+        exchangeAddress = exchangeContractAddress;
+        isICO = ! forReplace;
+        if ( ! forReplace ) {
+            require( db.replaceOwner(address(this)) );
+            assert( genesisAddr.length == genesisValue.length );
+            require( address(this).balance >= genesisAddr.length * 0.2 ether );
+            for ( uint256 a=0 ; a<genesisAddr.length ; a++ ) {
+                genesis[genesisAddr[a]] = true;
+                require( db.increase(genesisAddr[a], genesisValue[a]) );
+                if ( ! genesisAddr[a].send(0.2 ether) ) {}
+                emit Mint(genesisAddr[a], genesisValue[a]);
+            }
+        }
+    }
+
+    function closeIco() external returns (bool success) {
+        /*
+            ICO finished. It can be called only by ICO contract
+
+            @success    Was the Function successful?
+        */
+        require( msg.sender == icoAddr );
+        isICO = false;
+        return true;
+    }
+
+    /**
+     * @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf.
+     * @param spender The address of the account able to transfer the tokens
+     * @param amount The amount of tokens to be approved for transfer
+     * @param nonce The transaction count of the authorised address
+     * @return success True if the approval was successful
+     */
+    function approve(address spender, uint256 amount, uint256 nonce) isReady external returns (bool success) {
+        /*
+            Authorise another address to use a certain quantity of the authorising owner’s balance
+
+            @spender            Address of authorised party
+            @amount             Token quantity
+            @nonce              Transaction count
+
+            @success            Was the Function successful?
+        */
+        _approve(spender, amount, nonce);
+        return true;
+    }
+
+    /**
+     * @notice `msg.sender` approves `spender` to spend `amount` tokens on its behalf and notify the spender from your approve with your `extraData` data.
+     * @param spender The address of the account able to transfer the tokens
+     * @param amount The amount of tokens to be approved for transfer
+     * @param nonce The transaction count of the authorised address
+     * @param extraData Data to give forward to the receiver
+     * @return success True if the approval was successful
+     */
+    function approveAndCall(address spender, uint256 amount, uint256 nonce, bytes calldata extraData) isReady external returns (bool success) {
+        /*
+            Authorise another address to use a certain quantity of the authorising  owner’s balance
+            Following the transaction the receiver address `approvedCorionToken` function is called by the given data
+
+            @spender            Authorized address
+            @amount             Token quantity
+            @extraData          Extra data to be received by the receiver
+            @nonce              Transaction count
+
+            @success            Was the Function successful?
+        */
+        _approve(spender, amount, nonce);
+        require( thirdPartyContractAbstract(spender).approvedCorionToken(msg.sender, amount, extraData) );
+        return true;
+    }
+
+    function _approve(address spender, uint256 amount, uint256 nonce) internal {
+        /*
+            Internal Function to authorise another address to use a certain quantity of the authorising owner’s balance.
+            If the transaction count not match the authorise fails.
+
+            @spender           Address of authorised party
+            @amount            Token quantity
+            @nonce             Transaction count
+        */
+        require( msg.sender != spender );
+        require( db.balanceOf(msg.sender) >= amount );
+        require( db.setAllowance(msg.sender, spender, amount, nonce) );
+        emit Approval(msg.sender, spender, amount);
+    }
+
+    function allowance(address owner, address spender) public view returns (uint256 remaining, uint256 nonce) {
+        /*
+            Get the quantity of tokens given to be used
+
+            @owner         Authorising address
+            @spender       Authorised address
+
+            @remaining     Tokens to be spent
+            @nonce         Transaction count
+        */
+        (bool _success, uint256 _remaining, uint256 _nonce) = db.getAllowance(owner, spender);
+        require( _success );
+        return (_remaining, _nonce);
+    }
+
+    /**
+     * @notice Send `amount` Corion tokens to `to` from `msg.sender`
+     * @param to The address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @return success Whether the transfer was successful or not
+     */
+    function transfer(address to, uint256 amount) isReady external returns (bool success) {
+        /*
+            Start transaction, token is sent from caller’s address to receiver’s address
+            Transaction fee is to be deducted.
+            If receiver is not a natural address but a person, he will be called
+
+            @to         To who
+            @amount     Quantity
+
+            @success    Was the Function successful?
+        */
+        bytes memory _data;
+        if ( isContract(to) ) {
+            _transferToContract(msg.sender, to, amount, _data);
+        } else {
+            _transfer( msg.sender, to, amount, true);
+        }
+        emit Transfer(msg.sender, to, amount, _data);
+        return true;
+    }
+
+    /**
+     * @notice Send `amount` tokens to `to` from `from` on the condition it is approved by `from`
+     * @param from The address holding the tokens being transferred
+     * @param to The address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @return success True if the transfer was successful
+     */
+    function transferFrom(address from, address to, uint256 amount) isReady external returns (bool success) {
+        /*
+            Start transaction to send a quantity from a given address to another address. (approve / allowance). This can be called only by the address approved in advance
+            Transaction fee is to be deducted
+            If receiver is not a natural address but a person, he will be called
+
+            @from       From who.
+            @to         To who
+            @amount     Quantity
+
+            @success    Was the Function successful?
+        */
+        if ( from != msg.sender ) {
+            (bool _success, uint256 _remaining, uint256 _nonce) = db.getAllowance(from, msg.sender);
+            require( _success );
+            _remaining = safeSub(_remaining, amount);
+            _nonce = safeAdd(_nonce, 1);
+            require( db.setAllowance(from, msg.sender, _remaining, _nonce) );
+            emit AllowanceUsed(msg.sender, from, amount);
+        }
+        bytes memory _data;
+        if ( isContract(to) ) {
+            _transferToContract(from, to, amount, _data);
+        } else {
+            _transfer( from, to, amount, true);
+        }
+        emit Transfer(from, to, amount, _data);
+        return true;
+    }
+
+    /**
+     * @notice Send `amount` tokens to `to` from `from` on the condition it is approved by `from`
+     * @param from The address holding the tokens being transferred
+     * @param to The address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @return success True if the transfer was successful
+     */
+    function transferFromByModule(address from, address to, uint256 amount, bool fee) isReady external returns (bool success) {
+        /*
+            Start transaction to send a quantity from a given address to another address
+            Only ModuleHandler can call it
+
+            @from       From who
+            @to         To who.
+            @amount     Quantity
+            @fee        Deduct transaction fee - yes or no?
+
+            @success    Was the Function successful?
+        */
+        bytes memory _data;
+        require( super.isModuleHandler(payable(msg.sender)) );
+        _transfer( from, to, amount, fee);
+        emit Transfer(from, to, amount, _data);
+        return true;
+    }
+
+    /**
+     * @notice Send `amount` Corion tokens to `to` from `msg.sender` and notify the receiver from your transaction with your `extraData` data
+     * @param to The contract address of the recipient
+     * @param amount The amount of tokens to be transferred
+     * @param extraData Data to give forward to the receiver
+     * @return success Whether the transfer was successful or not
+     */
+    function transfer(address to, uint256 amount, bytes calldata extraData) isReady external returns (bool success) {
+        /*
+            Start transaction to send a quantity from a given address to another address
+            After transaction the function `receiveCorionToken`of the receiver is called  by the given data
+            When sending an amount, it is possible the total amount cannot be processed, the remaining amount is sent back with no fee charged
+
+            @to             To who.
+            @amount         Quantity
+            @extraData      Extra data the receiver will get
+
+            @success        Was the Function successful?
+        */
+        if ( isContract(to) ) {
+            _transferToContract(msg.sender, to, amount, extraData);
+        } else {
+            _transfer( msg.sender, to, amount, true);
+        }
+        emit Transfer(msg.sender, to, amount, extraData);
+        return true;
+    }
+
+    function _transferToContract(address from, address to, uint256 amount, bytes memory extraData) internal {
+        /*
+            Internal function to start transactions to a contract
+
+            @from           From who
+            @to             To who.
+            @amount         Quantity
+            @extraData      Extra data the receiver will get
+        */
+        _transfer(from, to, amount, exchangeAddress == to);
+        (bool _success, uint256 _back) = thirdPartyContractAbstract(to).receiveCorionToken(from, amount, extraData);
+        require( _success );
+        require( amount > _back );
+        if ( _back > 0 ) {
+            _transfer(to, from, _back, false);
+        }
+        _processTransactionFee(from, amount - _back);
+    }
+
+    function _transfer(address from, address to, uint256 amount, bool fee) internal {
+        /*
+            Internal function to start transactions. When Tokens are sent, transaction fee is charged
+            During ICO transactions are allowed only from genesis addresses.
+            After sending the tokens, the ModuleHandler is notified and it will broadcast the fact among members
+
+            The 0xa636a97578d26a3b76b060bbc18226d954cf3757 address are blacklisted.
+
+            @from       From who
+            @to         To who
+            @amount     Quantity
+            @fee        Deduct transaction fee - yes or no?
+        */
+        if( fee ) {
+            (bool success, uint256 _fee) = getTransactionFee(amount);
+            require( success );
+            require( db.balanceOf(from) >= amount + _fee );
+        }
+        require( from != address(0x00) && to != address(0x00) && to != 0xa636A97578d26A3b76B060Bbc18226d954cf3757 );
+        require( ( ! isICO) || genesis[from] );
+        require( db.decrease(from, amount) );
+        require( db.increase(to, amount) );
+        if ( fee ) { _processTransactionFee(from, amount); }
+        if ( isICO ) {
+            require( ico(icoAddr).setInterestDB(from, db.balanceOf(from)) );
+            require( ico(icoAddr).setInterestDB(to, db.balanceOf(to)) );
+        }
+        require( moduleHandler(moduleHandlerAddress).broadcastTransfer(from, to, amount) );
+    }
+
+    /**
+     * @notice Transaction fee will be deduced from `owner` for transacting `value`
+     * @param owner The address where will the transaction fee deduced
+     * @param value The base for calculating the fee
+     * @return success True if the transfer was successful
+     */
+    function processTransactionFee(address owner, uint256 value) isReady external returns (bool success) {
+        /*
+            Charge transaction fee. It can be called only by moduleHandler
+
+            @owner      From who.
+            @value      Quantity to calculate the fee
+
+            @success    Was the Function successful?
+        */
+        require( super.isModuleHandler(payable(msg.sender)) );
+        _processTransactionFee(owner, value);
+        return true;
+    }
+
+    function _processTransactionFee(address owner, uint256 value) internal {
+        /*
+            Internal function to charge the transaction fee. A certain quantity is burnt, the rest is sent to the Schelling game prize pool.
+            No transaction fee during ICO.
+
+            @owner      From who
+            @value      Quantity to calculate the fee
+        */
+        if ( isICO ) { return; }
+        (bool _success, uint256 _fee) = getTransactionFee(value);
+        require( _success );
+        uint256 _forBurn = _fee * transactionFeeBurn / 100;
+        uint256 _forSchelling = _fee - _forBurn;
+        bool _found;
+        address _schellingAddr;
+        (_success, _found, _schellingAddr) = moduleHandler(moduleHandlerAddress).getModuleAddressByName('Schelling');
+        require( _success );
+        if ( _schellingAddr != address(0x00) && _found) {
+            require( db.decrease(owner, _forSchelling) );
+            require( db.increase(_schellingAddr, _forSchelling) );
+            _burn(owner, _forBurn);
+            bytes memory _data;
+            emit Transfer(owner, _schellingAddr, _forSchelling, _data);
+            require( moduleHandler(moduleHandlerAddress).broadcastTransfer(owner, _schellingAddr, _forSchelling) );
+        } else {
+            _burn(owner, _fee);
+        }
+    }
+
+    function getTransactionFee(uint256 value) public view returns (bool success, uint256 fee) {
+        /*
+            Transaction fee query.
+
+            @value      Quantity to calculate the fee
+
+            @success    Was the Function successful?
+            @fee        Amount of Transaction fee
+        */
+        if ( isICO ) { return (true, 0); }
+        fee = value * transactionFeeRate / transactionFeeRateM / 100;
+        if ( fee > transactionFeeMax ) { fee = transactionFeeMax; }
+        else if ( fee < transactionFeeMin ) { fee = transactionFeeMin; }
+        return (true, fee);
+    }
+
+    function mint(address owner, uint256 value) isReady external returns (bool success) {
+        /*
+            Generating tokens. It can be called only by ICO contract or the moduleHandler.
+
+            @owner      Address
+            @value      Amount.
+
+            @success    Was the Function successful?
+        */
+        require( super.isModuleHandler(payable(msg.sender)) || msg.sender == icoAddr );
+        _mint(owner, value);
+        return true;
+    }
+
+    function _mint(address owner, uint256 value) internal {
+        /*
+            Internal function to generate tokens
+
+            @owner     Token is credited to this address
+            @value     Quantity
+        */
+        require( db.increase(owner, value) );
+        require( moduleHandler(moduleHandlerAddress).broadcastTransfer(address(0x00), owner, value) );
+        if ( isICO ) {
+            require( ico(icoAddr).setInterestDB(owner, db.balanceOf(owner)) );
+        }
+        emit Mint(owner, value);
+    }
+
+    function burn(address owner, uint256 value) isReady external returns (bool success) {
+        /*
+            Burning the token. Can call only modulehandler
+
+            @owner     Burn the token from this address
+            @value     Quantity
+
+            @success    Was the Function successful?
+        */
+        require( super.isModuleHandler(payable(msg.sender)) );
+        _burn(owner, value);
+        return true;
+    }
+
+    function _burn(address owner, uint256 value) internal {
+        /*
+            Internal function to burn the token
+
+            @owner     Burn the token from this address
+            @value     Quantity
+        */
+        require( db.decrease(owner, value) );
+        require( moduleHandler(moduleHandlerAddress).broadcastTransfer(owner, address(0x00), value) );
+        emit Burn(owner, value);
+    }
+
+    function isContract(address addr) internal returns (bool success) {
+        /*
+            Internal function to check if the given address is natural, or a contract
+
+            @addr       Address to be checked
+
+            @success    Is the address crontact or not
+        */
+        uint256 _codeLength;
+        assembly {
+            _codeLength := extcodesize(addr)
+        }
+        return _codeLength > 0;
+    }
+
+    function balanceOf(address owner) public view returns (uint256 value) {
+        /*
+            Token balance query
+
+            @owner      Address
+
+            @value      Balance of address
+        */
+        return db.balanceOf(owner);
+    }
+
+    function totalSupply() public view returns (uint256 value) {
+        /*
+            Total token quantity query
+
+            @value      Total token quantity
+        */
+        return db.totalSupply();
+    }
+
+    function configure(announcementType aType, uint256 value) isReady external returns(bool success) {
+        /*
+            Token settings configuration.It  can be call only by moduleHandler
+
+            @aType      Type of setting
+            @value      Value
+
+            @success    Was the Function successful?
+        */
+        require( super.isModuleHandler(payable(msg.sender)) );
+        if      ( aType == announcementType.transactionFeeRate )    { transactionFeeRate = value; }
+        else if ( aType == announcementType.transactionFeeMin )     { transactionFeeMin = value; }
+        else if ( aType == announcementType.transactionFeeMax )     { transactionFeeMax = value; }
+        else if ( aType == announcementType.transactionFeeBurn )    { transactionFeeBurn = value; }
+        else { return false; }
+        return true;
+    }
+
+    event AllowanceUsed(address indexed spender, address indexed owner, uint256 indexed value);
+    event Mint(address indexed addr, uint256 indexed value);
+    event Burn(address indexed addr, uint256 indexed value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _value, bytes _extraData);
+}
diff --git a/compiler/test/contracts/AuctionRegistrar.cpp b/compiler/test/contracts/AuctionRegistrar.cpp
new file mode 100644
index 00000000..8d0b1ccb
--- /dev/null
+++ b/compiler/test/contracts/AuctionRegistrar.cpp
@@ -0,0 +1,459 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Tests for a fixed fee registrar contract.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <test/contracts/ContractInterface.h>
+#include <test/EVMHost.h>
+
+#include <libsolutil/LazyInit.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <optional>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+static char const* registrarCode = R"DELIMITER(
+pragma solidity >=0.7.0 <0.9.0;
+
+abstract contract NameRegister {
+	function addr(string memory _name) public virtual view returns (address o_owner);
+	function name(address _owner) public view virtual returns (string memory o_name);
+}
+
+abstract contract Registrar is NameRegister {
+	event Changed(string indexed name);
+	event PrimaryChanged(string indexed name, address indexed addr);
+
+	function owner(string memory _name) public view virtual returns (address o_owner);
+	function addr(string memory _name) public virtual override view returns (address o_address);
+	function subRegistrar(string memory _name) public virtual view returns (address o_subRegistrar);
+	function content(string memory _name) public virtual view returns (bytes32 o_content);
+
+	function name(address _owner) public virtual override view returns (string memory o_name);
+}
+
+abstract contract AuctionSystem {
+	event AuctionEnded(string indexed _name, address _winner);
+	event NewBid(string indexed _name, address _bidder, uint _value);
+
+	/// Function that is called once an auction ends.
+	function onAuctionEnd(string memory _name) internal virtual;
+
+	function bid(string memory _name, address payable _bidder, uint _value) internal {
+		Auction storage auction = m_auctions[_name];
+		if (auction.endDate > 0 && block.timestamp > auction.endDate)
+		{
+			emit AuctionEnded(_name, auction.highestBidder);
+			onAuctionEnd(_name);
+			delete m_auctions[_name];
+			return;
+		}
+		if (msg.value > auction.highestBid)
+		{
+			// new bid on auction
+			auction.secondHighestBid = auction.highestBid;
+			auction.sumOfBids += _value;
+			auction.highestBid = _value;
+			auction.highestBidder = _bidder;
+			auction.endDate = block.timestamp + c_biddingTime;
+
+			emit NewBid(_name, _bidder, _value);
+		}
+	}
+
+	uint constant c_biddingTime = 7 days;
+
+	struct Auction {
+		address payable highestBidder;
+		uint highestBid;
+		uint secondHighestBid;
+		uint sumOfBids;
+		uint endDate;
+	}
+	mapping(string => Auction) m_auctions;
+}
+
+contract GlobalRegistrar is Registrar, AuctionSystem {
+	struct Record {
+		address payable owner;
+		address primary;
+		address subRegistrar;
+		bytes32 content;
+		uint renewalDate;
+	}
+
+	uint constant c_renewalInterval = 365 days;
+	uint constant c_freeBytes = 12;
+
+	constructor() {
+		// TODO: Populate with hall-of-fame.
+	}
+
+	function onAuctionEnd(string memory _name) internal override {
+		Auction storage auction = m_auctions[_name];
+		Record storage record = m_toRecord[_name];
+		address previousOwner = record.owner;
+		record.renewalDate = block.timestamp + c_renewalInterval;
+		record.owner = auction.highestBidder;
+		emit Changed(_name);
+		if (previousOwner != 0x0000000000000000000000000000000000000000) {
+			if (!record.owner.send(auction.sumOfBids - auction.highestBid / 100))
+				revert();
+		} else {
+			if (!auction.highestBidder.send(auction.highestBid - auction.secondHighestBid))
+				revert();
+		}
+	}
+
+	function reserve(string calldata _name) external payable {
+		if (bytes(_name).length == 0)
+			revert();
+		bool needAuction = requiresAuction(_name);
+		if (needAuction)
+		{
+			if (block.timestamp < m_toRecord[_name].renewalDate)
+				revert();
+			bid(_name, payable(msg.sender), msg.value);
+		} else {
+			Record storage record = m_toRecord[_name];
+			if (record.owner != 0x0000000000000000000000000000000000000000)
+				revert();
+			m_toRecord[_name].owner = payable(msg.sender);
+			emit Changed(_name);
+		}
+	}
+
+	function requiresAuction(string memory _name) internal returns (bool) {
+		return bytes(_name).length < c_freeBytes;
+	}
+
+	modifier onlyrecordowner(string memory _name) { if (m_toRecord[_name].owner == msg.sender) _; }
+
+	function transfer(string memory _name, address payable _newOwner) onlyrecordowner(_name) public {
+		m_toRecord[_name].owner = _newOwner;
+		emit Changed(_name);
+	}
+
+	function disown(string memory _name) onlyrecordowner(_name) public {
+		if (stringsEqual(m_toName[m_toRecord[_name].primary], _name))
+		{
+			emit PrimaryChanged(_name, m_toRecord[_name].primary);
+			m_toName[m_toRecord[_name].primary] = "";
+		}
+		delete m_toRecord[_name];
+		emit Changed(_name);
+	}
+
+	function setAddress(string memory _name, address _a, bool _primary) onlyrecordowner(_name) public {
+		m_toRecord[_name].primary = _a;
+		if (_primary)
+		{
+			emit PrimaryChanged(_name, _a);
+			m_toName[_a] = _name;
+		}
+		emit Changed(_name);
+	}
+	function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) public {
+		m_toRecord[_name].subRegistrar = _registrar;
+		emit Changed(_name);
+	}
+	function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) public {
+		m_toRecord[_name].content = _content;
+		emit Changed(_name);
+	}
+
+	function stringsEqual(string storage _a, string memory _b) internal returns (bool) {
+		bytes storage a = bytes(_a);
+		bytes memory b = bytes(_b);
+		if (a.length != b.length)
+			return false;
+		// @todo unroll this loop
+		for (uint i = 0; i < a.length; i ++)
+			if (a[i] != b[i])
+				return false;
+		return true;
+	}
+
+	function owner(string memory _name) public override view returns (address) { return m_toRecord[_name].owner; }
+	function addr(string memory _name) public override view returns (address) { return m_toRecord[_name].primary; }
+	function subRegistrar(string memory _name) public override view returns (address) { return m_toRecord[_name].subRegistrar; }
+	function content(string memory _name) public override view returns (bytes32) { return m_toRecord[_name].content; }
+	function name(address _addr) public override view returns (string memory o_name) { return m_toName[_addr]; }
+
+	mapping (address => string) m_toName;
+	mapping (string => Record) m_toRecord;
+}
+)DELIMITER";
+
+static LazyInit<bytes> s_compiledRegistrar;
+
+class AuctionRegistrarTestFramework: public SolidityExecutionFramework
+{
+protected:
+	void deployRegistrar()
+	{
+		bytes const& compiled = s_compiledRegistrar.init([&]{
+			return compileContract(registrarCode, "GlobalRegistrar");
+		});
+
+		sendMessage(compiled, true);
+		BOOST_REQUIRE(m_transactionSuccessful);
+		BOOST_REQUIRE(!m_output.empty());
+	}
+
+	class RegistrarInterface: public ContractInterface
+	{
+	public:
+		RegistrarInterface(SolidityExecutionFramework& _framework): ContractInterface(_framework) {}
+		void reserve(std::string const& _name)
+		{
+			callString("reserve", _name);
+		}
+		h160 owner(std::string const& _name)
+		{
+			return callStringReturnsAddress("owner", _name);
+		}
+		void setAddress(std::string const& _name, h160 const& _address, bool _primary)
+		{
+			callStringAddressBool("setAddress", _name, _address, _primary);
+		}
+		h160 addr(std::string const& _name)
+		{
+			return callStringReturnsAddress("addr", _name);
+		}
+		std::string name(h160 const& _addr)
+		{
+			return callAddressReturnsString("name", _addr);
+		}
+		void setSubRegistrar(std::string const& _name, h160 const& _address)
+		{
+			callStringAddress("setSubRegistrar", _name, _address);
+		}
+		h160 subRegistrar(std::string const& _name)
+		{
+			return callStringReturnsAddress("subRegistrar", _name);
+		}
+		void setContent(std::string const& _name, h256 const& _content)
+		{
+			callStringBytes32("setContent", _name, _content);
+		}
+		h256 content(std::string const& _name)
+		{
+			return callStringReturnsBytes32("content", _name);
+		}
+		void transfer(std::string const& _name, h160 const& _target)
+		{
+			return callStringAddress("transfer", _name, _target);
+		}
+		void disown(std::string const& _name)
+		{
+			return callString("disown", _name);
+		}
+	};
+
+	int64_t const m_biddingTime = 7 * 24 * 3600;
+};
+
+}
+
+/// This is a test suite that tests optimised code!
+BOOST_FIXTURE_TEST_SUITE(SolidityAuctionRegistrar, AuctionRegistrarTestFramework)
+
+BOOST_AUTO_TEST_CASE(creation)
+{
+	deployRegistrar();
+}
+
+BOOST_AUTO_TEST_CASE(reserve)
+{
+	// Test that reserving works for long strings
+	deployRegistrar();
+	std::vector<std::string> names{"abcabcabcabcabc", "defdefdefdefdef", "ghighighighighighighighighighighighighighighi"};
+
+	RegistrarInterface registrar(*this);
+
+	// should not work
+	registrar.reserve("");
+	BOOST_CHECK_EQUAL(registrar.owner(""), h160{});
+
+	for (auto const& name: names)
+	{
+		registrar.reserve(name);
+		BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(double_reserve_long)
+{
+	// Test that it is not possible to re-reserve from a different address.
+	deployRegistrar();
+	std::string name = "abcabcabcabcabcabcabcabcabcabca";
+	RegistrarInterface registrar(*this);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
+
+	sendEther(account(1), u256(10) * ether);
+	m_sender = account(1);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), account(0));
+}
+
+BOOST_AUTO_TEST_CASE(properties)
+{
+	// Test setting and retrieving  the various properties works.
+	deployRegistrar();
+	RegistrarInterface registrar(*this);
+	std::string names[] = {"abcaeouoeuaoeuaoeu", "defncboagufra,fui", "ghagpyajfbcuajouhaeoi"};
+	size_t addr = 0x9872543;
+	size_t count = 1;
+	for (std::string const& name: names)
+	{
+		m_sender = account(0);
+		sendEther(account(count), u256(20) * ether);
+		m_sender = account(count);
+		auto sender = m_sender;
+		addr += count;
+		// setting by sender works
+		registrar.reserve(name);
+		BOOST_CHECK_EQUAL(registrar.owner(name), sender);
+		registrar.setAddress(name, h160(addr), true);
+		BOOST_CHECK_EQUAL(registrar.addr(name), h160(addr));
+		registrar.setSubRegistrar(name, h160(addr + 20));
+		BOOST_CHECK_EQUAL(registrar.subRegistrar(name), h160(addr + 20));
+		registrar.setContent(name, h256(u256(addr + 90)));
+		BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
+
+		// but not by someone else
+		m_sender = account(count - 1);
+		BOOST_CHECK_EQUAL(registrar.owner(name), sender);
+		registrar.setAddress(name, h160(addr + 1), true);
+		BOOST_CHECK_EQUAL(registrar.addr(name), h160(addr));
+		registrar.setSubRegistrar(name, h160(addr + 20 + 1));
+		BOOST_CHECK_EQUAL(registrar.subRegistrar(name), h160(addr + 20));
+		registrar.setContent(name, h256(u256(addr + 90 + 1)));
+		BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(addr + 90)));
+		count++;
+	}
+}
+
+BOOST_AUTO_TEST_CASE(transfer)
+{
+	deployRegistrar();
+	std::string name = "abcaoeguaoucaeoduceo";
+	RegistrarInterface registrar(*this);
+	registrar.reserve(name);
+	registrar.setContent(name, h256(u256(123)));
+	registrar.transfer(name, h160(555));
+	BOOST_CHECK_EQUAL(registrar.owner(name), h160(555));
+	BOOST_CHECK_EQUAL(registrar.content(name), h256(u256(123)));
+}
+
+BOOST_AUTO_TEST_CASE(disown)
+{
+	deployRegistrar();
+	std::string name = "abcaoeguaoucaeoduceo";
+
+	RegistrarInterface registrar(*this);
+	registrar.reserve(name);
+	registrar.setContent(name, h256(u256(123)));
+	registrar.setAddress(name, h160(124), true);
+	registrar.setSubRegistrar(name, h160(125));
+	BOOST_CHECK_EQUAL(registrar.name(h160(124)), name);
+
+	// someone else tries disowning
+	sendEther(account(1), u256(10) * ether);
+	m_sender = account(1);
+	registrar.disown(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), account(0));
+
+	m_sender = account(0);
+	registrar.disown(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), h160());
+	BOOST_CHECK_EQUAL(registrar.addr(name), h160());
+	BOOST_CHECK_EQUAL(registrar.subRegistrar(name), h160());
+	BOOST_CHECK_EQUAL(registrar.content(name), h256());
+	BOOST_CHECK_EQUAL(registrar.name(h160(124)), "");
+}
+
+BOOST_AUTO_TEST_CASE(auction_simple)
+{
+	deployRegistrar();
+	std::string name = "x";
+
+	RegistrarInterface registrar(*this);
+	// initiate auction
+	registrar.setNextValue(8);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), h160());
+	// "wait" until auction end
+
+	m_evmcHost->tx_context.block_timestamp += m_biddingTime + 10;
+	// trigger auction again
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), m_sender);
+}
+
+BOOST_AUTO_TEST_CASE(auction_bidding)
+{
+	deployRegistrar();
+	std::string name = "x";
+
+	unsigned startTime = 0x776347e2;
+	m_evmcHost->tx_context.block_timestamp = startTime;
+
+	RegistrarInterface registrar(*this);
+	// initiate auction
+	registrar.setNextValue(8);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), h160());
+	// overbid self
+	m_evmcHost->tx_context.block_timestamp = startTime + m_biddingTime - 10;
+	registrar.setNextValue(12);
+	registrar.reserve(name);
+	// another bid by someone else
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	m_evmcHost->tx_context.block_timestamp = startTime + 2 * m_biddingTime - 50;
+	registrar.setNextValue(13);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), h160());
+	// end auction by first bidder (which is not highest) trying to overbid again (too late)
+	m_sender = account(0);
+	m_evmcHost->tx_context.block_timestamp = startTime + 4 * m_biddingTime;
+	registrar.setNextValue(20);
+	registrar.reserve(name);
+	BOOST_CHECK_EQUAL(registrar.owner(name), account(1));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/contracts/Wallet.cpp b/compiler/test/contracts/Wallet.cpp
new file mode 100644
index 00000000..db9119de
--- /dev/null
+++ b/compiler/test/contracts/Wallet.cpp
@@ -0,0 +1,706 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Tests for a (comparatively) complex multisig wallet contract.
+ */
+
+#include <libsolutil/LazyInit.h>
+
+#include <string>
+#include <tuple>
+#include <optional>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4535) // calling _set_se_translator requires /EHa
+#endif
+#include <boost/test/unit_test.hpp>
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+using namespace solidity::test;
+using namespace solidity::util;
+
+namespace solidity::frontend::test
+{
+static char const* walletCode = R"DELIMITER(
+//sol Wallet
+// Multi-sig, daily-limited account proxy/wallet.
+// @authors:
+// Gav Wood <g@ethdev.com>
+// inheritable "property" contract that enables methods to be protected by requiring the acquiescence of either a
+// single, or, crucially, each of a number of, designated owners.
+// usage:
+// use modifiers onlyowner (just own owned) or onlymanyowners(hash), whereby the same hash must be provided by
+// some number (specified in constructor) of the set of owners (specified in the constructor, modifiable) before the
+// interior is executed.
+
+pragma solidity >=0.4.0 <0.9.0;
+
+contract multiowned {
+
+	// TYPES
+
+	// struct for the status of a pending operation.
+	struct PendingState {
+		uint yetNeeded;
+		uint ownersDone;
+		uint index;
+	}
+
+	// EVENTS
+
+	// this contract only has five types of events: it can accept a confirmation, in which case
+	// we record owner and operation (hash) alongside it.
+	event Confirmation(address owner, bytes32 operation);
+	event Revoke(address owner, bytes32 operation);
+	// some others are in the case of an owner changing.
+	event OwnerChanged(address oldOwner, address newOwner);
+	event OwnerAdded(address newOwner);
+	event OwnerRemoved(address oldOwner);
+	// the last one is emitted if the required signatures change
+	event RequirementChanged(uint newRequirement);
+
+	// MODIFIERS
+
+	// simple single-sig function modifier.
+	modifier onlyowner {
+		if (isOwner(msg.sender))
+			_;
+	}
+	// multi-sig function modifier: the operation must have an intrinsic hash in order
+	// that later attempts can be realised as the same underlying operation and
+	// thus count as confirmations.
+	modifier onlymanyowners(bytes32 _operation) {
+		if (confirmAndCheck(_operation))
+			_;
+	}
+
+	// METHODS
+
+	// constructor is given number of sigs required to do protected "onlymanyowners" transactions
+	// as well as the selection of addresses capable of confirming them.
+	constructor(address[] memory _owners, uint _required) {
+		m_numOwners = _owners.length + 1;
+		m_owners[1] = uint160(msg.sender);
+		m_ownerIndex[uint160(msg.sender)] = 1;
+		for (uint i = 0; i < _owners.length; ++i)
+		{
+			m_owners[2 + i] = uint160(_owners[i]);
+			m_ownerIndex[uint160(_owners[i])] = 2 + i;
+		}
+		m_required = _required;
+	}
+
+	// Revokes a prior confirmation of the given operation
+	function revoke(bytes32 _operation) external {
+		uint ownerIndex = m_ownerIndex[uint160(msg.sender)];
+		// make sure they're an owner
+		if (ownerIndex == 0) return;
+		uint ownerIndexBit = 2**ownerIndex;
+		PendingState storage pending = m_pending[_operation];
+		if (pending.ownersDone & ownerIndexBit > 0) {
+			pending.yetNeeded++;
+			pending.ownersDone -= ownerIndexBit;
+			emit Revoke(msg.sender, _operation);
+		}
+	}
+
+	// Replaces an owner `_from` with another `_to`.
+	function changeOwner(address _from, address _to) onlymanyowners(keccak256(msg.data)) public virtual {
+		if (isOwner(_to)) return;
+		uint ownerIndex = m_ownerIndex[uint160(_from)];
+		if (ownerIndex == 0) return;
+
+		clearPending();
+		m_owners[ownerIndex] = uint160(_to);
+		m_ownerIndex[uint160(_from)] = 0;
+		m_ownerIndex[uint160(_to)] = ownerIndex;
+		emit OwnerChanged(_from, _to);
+	}
+
+	function addOwner(address _owner) onlymanyowners(keccak256(msg.data)) external {
+		if (isOwner(_owner)) return;
+
+		clearPending();
+		if (m_numOwners >= c_maxOwners)
+			reorganizeOwners();
+		if (m_numOwners >= c_maxOwners)
+			return;
+		m_numOwners++;
+		m_owners[m_numOwners] = uint160(_owner);
+		m_ownerIndex[uint160(_owner)] = m_numOwners;
+		emit OwnerAdded(_owner);
+	}
+
+	function removeOwner(address _owner) onlymanyowners(keccak256(msg.data)) external {
+		uint ownerIndex = m_ownerIndex[uint160(_owner)];
+		if (ownerIndex == 0) return;
+		if (m_required > m_numOwners - 1) return;
+
+		m_owners[ownerIndex] = 0;
+		m_ownerIndex[uint160(_owner)] = 0;
+		clearPending();
+		reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot
+		emit OwnerRemoved(_owner);
+	}
+
+	function changeRequirement(uint _newRequired) onlymanyowners(keccak256(msg.data)) external {
+		if (_newRequired > m_numOwners) return;
+		m_required = _newRequired;
+		clearPending();
+		emit RequirementChanged(_newRequired);
+	}
+
+	function isOwner(address _addr) public returns (bool) {
+		return m_ownerIndex[uint160(_addr)] > 0;
+	}
+
+	function hasConfirmed(bytes32 _operation, address _owner) public view returns (bool) {
+		PendingState storage pending = m_pending[_operation];
+		uint ownerIndex = m_ownerIndex[uint160(_owner)];
+
+		// make sure they're an owner
+		if (ownerIndex == 0) return false;
+
+		// determine the bit to set for this owner.
+		uint ownerIndexBit = 2**ownerIndex;
+		if (pending.ownersDone & ownerIndexBit == 0) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	// INTERNAL METHODS
+
+	function confirmAndCheck(bytes32 _operation) internal returns (bool) {
+		// determine what index the present sender is:
+		uint ownerIndex = m_ownerIndex[uint160(msg.sender)];
+		// make sure they're an owner
+		if (ownerIndex == 0) return false;
+
+		PendingState storage pending = m_pending[_operation];
+		// if we're not yet working on this operation, switch over and reset the confirmation status.
+		if (pending.yetNeeded == 0) {
+			// reset count of confirmations needed.
+			pending.yetNeeded = m_required;
+			// reset which owners have confirmed (none) - set our bitmap to 0.
+			pending.ownersDone = 0;
+			m_pendingIndex.push(_operation);
+			pending.index = m_pendingIndex.length - 1;
+		}
+		// determine the bit to set for this owner.
+		uint ownerIndexBit = 2**ownerIndex;
+		// make sure we (the message sender) haven't confirmed this operation previously.
+		if (pending.ownersDone & ownerIndexBit == 0) {
+			emit Confirmation(msg.sender, _operation);
+			// ok - check if count is enough to go ahead.
+			if (pending.yetNeeded <= 1) {
+				// enough confirmations: reset and run interior.
+				delete m_pendingIndex[m_pending[_operation].index];
+				delete m_pending[_operation];
+				return true;
+			}
+			else
+			{
+				// not enough: record that this owner in particular confirmed.
+				pending.yetNeeded--;
+				pending.ownersDone |= ownerIndexBit;
+				return false;
+			}
+		}
+	}
+
+	function reorganizeOwners() private returns (bool) {
+		uint free = 1;
+		while (free < m_numOwners)
+		{
+			while (free < m_numOwners && m_owners[free] != 0) free++;
+			while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
+			if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
+			{
+				m_owners[free] = m_owners[m_numOwners];
+				m_ownerIndex[m_owners[free]] = free;
+				m_owners[m_numOwners] = 0;
+			}
+		}
+	}
+
+	function clearPending() internal virtual {
+		uint length = m_pendingIndex.length;
+		for (uint i = 0; i < length; ++i)
+			if (m_pendingIndex[i] != 0)
+				delete m_pending[m_pendingIndex[i]];
+		delete m_pendingIndex;
+	}
+
+	// FIELDS
+
+	// the number of owners that must confirm the same operation before it is run.
+	uint public m_required;
+	// pointer used to find a free slot in m_owners
+	uint public m_numOwners;
+
+	// list of owners
+	uint[256] m_owners;
+	uint constant c_maxOwners = 250;
+	// index on the list of owners to allow reverse lookup
+	mapping(uint => uint) m_ownerIndex;
+	// the ongoing operations.
+	mapping(bytes32 => PendingState) m_pending;
+	bytes32[] m_pendingIndex;
+}
+
+// inheritable "property" contract that enables methods to be protected by placing a linear limit (specifiable)
+// on a particular resource per calendar day. is multiowned to allow the limit to be altered. resource that method
+// uses is specified in the modifier.
+abstract contract daylimit is multiowned {
+
+	// MODIFIERS
+
+	// simple modifier for daily limit.
+	modifier limitedDaily(uint _value) {
+		if (underLimit(_value))
+			_;
+	}
+
+	// METHODS
+
+	// constructor - stores initial daily limit and records the present day's index.
+	constructor(uint _limit) {
+		m_dailyLimit = _limit;
+		m_lastDay = today();
+	}
+	// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
+	function setDailyLimit(uint _newLimit) onlymanyowners(keccak256(msg.data)) external {
+		m_dailyLimit = _newLimit;
+	}
+	// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
+	function resetSpentToday() onlymanyowners(keccak256(msg.data)) external {
+		m_spentToday = 0;
+	}
+
+	// INTERNAL METHODS
+
+	// checks to see if there is at least `_value` left from the daily limit today. if there is, subtracts it and
+	// returns true. otherwise just returns false.
+	function underLimit(uint _value) internal onlyowner returns (bool) {
+		// reset the spend limit if we're on a different day to last time.
+		if (today() > m_lastDay) {
+			m_spentToday = 0;
+			m_lastDay = today();
+		}
+		// check to see if there's enough left - if so, subtract and return true.
+		if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
+			m_spentToday += _value;
+			return true;
+		}
+		return false;
+	}
+	// determines today's index.
+	function today() private view returns (uint) { return block.timestamp / 1 days; }
+
+	// FIELDS
+
+	uint public m_dailyLimit;
+	uint m_spentToday;
+	uint m_lastDay;
+}
+
+// interface contract for multisig proxy contracts; see below for docs.
+abstract contract multisig {
+
+	// EVENTS
+
+	// logged events:
+	// Funds has arrived into the wallet (record how much).
+	event Deposit(address from, uint value);
+	// Single transaction going out of the wallet (record who signed for it, how much, and to whom it's going).
+	event SingleTransact(address owner, uint value, address to, bytes data);
+	// Multi-sig transaction going out of the wallet (record who signed for it last, the operation hash, how much, and to whom it's going).
+	event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
+	// Confirmation still needed for a transaction.
+	event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
+
+	// FUNCTIONS
+
+	// TODO: document
+	function changeOwner(address _from, address _to) public virtual;
+	function execute(address _to, uint _value, bytes calldata _data) external virtual returns (bytes32);
+	function confirm(bytes32 _h) public virtual returns (bool);
+}
+
+// usage:
+// bytes32 h = Wallet(w).from(oneOwner).transact(to, value, data);
+// Wallet(w).from(anotherOwner).confirm(h);
+contract Wallet is multisig, multiowned, daylimit {
+
+	// TYPES
+
+	// Transaction structure to remember details of transaction lest it need be saved for a later call.
+	struct Transaction {
+		address to;
+		uint value;
+		bytes data;
+	}
+
+	// METHODS
+
+	// constructor - just pass on the owner array to the multiowned and
+	// the limit to daylimit
+	constructor(address[] memory _owners, uint _required, uint _daylimit) payable
+			multiowned(_owners, _required) daylimit(_daylimit) {
+	}
+
+	function changeOwner(address _from, address _to) public override(multiowned, multisig) {
+		multiowned.changeOwner(_from, _to);
+	}
+	// destroys the contract sending everything to `_to`.
+	function shutdown(address payable _to) onlymanyowners(keccak256(msg.data)) external {
+		selfdestruct(_to);
+	}
+
+	// gets called for plain ether transfers
+	receive() external payable {
+		// did we actually receive value?
+		if (msg.value > 0)
+			emit Deposit(msg.sender, msg.value);
+	}
+
+	// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
+	// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
+	// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
+	// and _data arguments). They still get the option of using them if they want, anyways.
+	function execute(address _to, uint _value, bytes calldata _data) external override onlyowner returns (bytes32 _r) {
+		// first, take the opportunity to check that we're under the daily limit.
+		if (underLimit(_value)) {
+			emit SingleTransact(msg.sender, _value, _to, _data);
+			// yes - just execute the call.
+			_to.call{value: _value}(_data);
+			return 0;
+		}
+		// determine our operation hash.
+		_r = keccak256(abi.encodePacked(msg.data, block.number));
+		if (!confirm(_r) && m_txs[_r].to == 0x0000000000000000000000000000000000000000) {
+			m_txs[_r].to = _to;
+			m_txs[_r].value = _value;
+			m_txs[_r].data = _data;
+			emit ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
+		}
+	}
+
+	// confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order
+	// to determine the body of the transaction from the hash provided.
+	function confirm(bytes32 _h) onlymanyowners(_h) public override returns (bool) {
+		if (m_txs[_h].to != 0x0000000000000000000000000000000000000000) {
+			m_txs[_h].to.call{value: m_txs[_h].value}(m_txs[_h].data);
+			emit MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
+			delete m_txs[_h];
+			return true;
+		}
+	}
+
+	// INTERNAL METHODS
+
+	function clearPending() internal override {
+		uint length = m_pendingIndex.length;
+		for (uint i = 0; i < length; ++i)
+			delete m_txs[m_pendingIndex[i]];
+		super.clearPending();
+	}
+
+	// FIELDS
+
+	// pending transactions we have at present.
+	mapping (bytes32 => Transaction) m_txs;
+}
+)DELIMITER";
+
+static LazyInit<bytes> s_compiledWallet;
+
+class WalletTestFramework: public SolidityExecutionFramework
+{
+protected:
+	void deployWallet(
+		u256 const& _value = 0,
+		std::vector<h160> const& _owners = std::vector<h160>{},
+		u256 _required = 1,
+		u256 _dailyLimit = 0
+	)
+	{
+		bytes const& compiled = s_compiledWallet.init([&]{
+			return compileContract(walletCode, "Wallet");
+		});
+
+		bytes args = encodeArgs(u256(0x60), _required, _dailyLimit, u256(_owners.size()), _owners);
+		sendMessage(compiled + args, true, _value);
+		BOOST_REQUIRE(m_transactionSuccessful);
+		BOOST_REQUIRE(!m_output.empty());
+	}
+};
+
+/// This is a test suite that tests optimised code!
+BOOST_FIXTURE_TEST_SUITE(SolidityWallet, WalletTestFramework)
+
+BOOST_AUTO_TEST_CASE(creation)
+{
+	deployWallet(200);
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", m_sender) == encodeArgs(true));
+	bool v2 = !solidity::test::CommonOptions::get().useABIEncoderV1;
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h256(~0)) == (v2 ? encodeArgs() : encodeArgs(false)));
+}
+
+BOOST_AUTO_TEST_CASE(add_owners)
+{
+	deployWallet(200);
+	h160 originalOwner = m_sender;
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(1)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", account(1)) == encodeArgs(true));
+	// now let the new owner add someone
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x13)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x13)) == encodeArgs(true));
+	// and check that a non-owner cannot add a new owner
+	m_sender = account(0);
+	sendEther(account(2), 10 * ether);
+	m_sender = account(2);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x20)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x20)) == encodeArgs(false));
+	// finally check that all the owners are there
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", originalOwner) == encodeArgs(true));
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", account(1)) == encodeArgs(true));
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x13)) == encodeArgs(true));
+}
+
+BOOST_AUTO_TEST_CASE(change_owners)
+{
+	deployWallet(200);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x12)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12)) == encodeArgs(true));
+	BOOST_REQUIRE(callContractFunction("changeOwner(address,address)", h160(0x12), h160(0x13)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12)) == encodeArgs(false));
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x13)) == encodeArgs(true));
+}
+
+BOOST_AUTO_TEST_CASE(remove_owner)
+{
+	deployWallet(200);
+	// add 10 owners
+	for (unsigned i = 0; i < 10; ++i)
+	{
+		BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x12 + i)) == encodeArgs());
+		BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12 + i)) == encodeArgs(true));
+	}
+	// check they are there again
+	for (unsigned i = 0; i < 10; ++i)
+		BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12 + i)) == encodeArgs(true));
+	// remove the odd owners
+	for (unsigned i = 0; i < 10; ++i)
+		if (i % 2 == 1)
+			BOOST_REQUIRE(callContractFunction("removeOwner(address)", h160(0x12 + i)) == encodeArgs());
+	// check the result
+	for (unsigned i = 0; i < 10; ++i)
+		BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12 + i)) == encodeArgs(i % 2 == 0));
+	// add them again
+	for (unsigned i = 0; i < 10; ++i)
+		if (i % 2 == 1)
+			BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x12 + i)) == encodeArgs());
+	// check everyone is there
+	for (unsigned i = 0; i < 10; ++i)
+		BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x12 + i)) == encodeArgs(true));
+}
+
+BOOST_AUTO_TEST_CASE(initial_owners)
+{
+	std::vector<h160> owners{
+		h160("0x42c56279432962a17176998a4747d1b4d6ed4367"),
+		h160("0xd4d4669f5ba9f4c27d38ef02a358c339b5560c47"),
+		h160("0xe6716f9544a56c530d868e4bfbacb172315bdead"),
+		h160("0x775e18be7a50a0abb8a4e82b1bd697d79f31fe04"),
+		h160("0xf4dd5c3794f1fd0cdc0327a83aa472609c806e99"),
+		h160("0x4c9113886af165b2de069d6e99430647e94a9fff"),
+		h160("0x3fb1cd2cd96c6d5c0b5eb3322d807b34482481d4")
+	};
+	deployWallet(0, owners, 4, 2);
+	BOOST_CHECK(callContractFunction("m_numOwners()") == encodeArgs(u256(8)));
+	BOOST_CHECK(callContractFunction("isOwner(address)", m_sender) == encodeArgs(true));
+	for (h160 const& owner: owners)
+	{
+		BOOST_CHECK(callContractFunction("isOwner(address)", owner) == encodeArgs(true));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(multisig_value_transfer)
+{
+	deployWallet(200);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(1)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(2)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(3)) == encodeArgs());
+	// 4 owners, set required to 3
+	BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
+	h160 destination = h160("0x5c6d6026d3fb35cd7175fd0054ae8df50d8f8b41");
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	auto ophash = callContractFunction("execute(address,uint256,bytes)", destination, 100, 0x60, 0x00);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(2), 10 * ether);
+	m_sender = account(2);
+	callContractFunction("confirm(bytes32)", ophash);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(3), 10 * ether);
+	m_sender = account(3);
+	callContractFunction("confirm(bytes32)", ophash);
+	// now it should go through
+	BOOST_CHECK_EQUAL(balanceAt(destination), 100);
+}
+
+BOOST_AUTO_TEST_CASE(revoke_addOwner)
+{
+	deployWallet();
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(1)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(2)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(3)) == encodeArgs());
+	// 4 owners, set required to 3
+	BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
+	// add a new owner
+	h160 deployer = m_sender;
+	h256 opHash = util::keccak256(util::selectorFromSignatureH32("addOwner(address)").asBytes() + h256(0x33).asBytes());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x33)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x33)) == encodeArgs(false));
+	m_sender = account(0);
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x33)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x33)) == encodeArgs(false));
+	// revoke one confirmation
+	m_sender = deployer;
+	BOOST_REQUIRE(callContractFunction("revoke(bytes32)", opHash) == encodeArgs());
+	m_sender = account(0);
+	sendEther(account(2), 10 * ether);
+	m_sender = account(2);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x33)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x33)) == encodeArgs(false));
+	m_sender = account(0);
+	sendEther(account(3), 10 * ether);
+	m_sender = account(3);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", h160(0x33)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("isOwner(address)", h160(0x33)) == encodeArgs(true));
+}
+
+BOOST_AUTO_TEST_CASE(revoke_transaction)
+{
+	deployWallet(200);
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(1)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(2)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(3)) == encodeArgs());
+	// 4 owners, set required to 3
+	BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
+	// create a transaction
+	h160 deployer = m_sender;
+	h160 destination = h160("0x5c6d6026d3fb35cd7175fd0054ae8df50d8f8b41");
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	auto opHash = callContractFunction("execute(address,uint256,bytes)", destination, 100, 0x60, 0x00);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(2), 10 * ether);
+	m_sender = account(2);
+	callContractFunction("confirm(bytes32)", opHash);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	BOOST_REQUIRE(callContractFunction("revoke(bytes32)", opHash) == encodeArgs());
+	m_sender = deployer;
+	callContractFunction("confirm(bytes32)", opHash);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	m_sender = account(0);
+	sendEther(account(3), 10 * ether);
+	m_sender = account(3);
+	callContractFunction("confirm(bytes32)", opHash);
+	// now it should go through
+	BOOST_CHECK_EQUAL(balanceAt(destination), 100);
+}
+
+BOOST_AUTO_TEST_CASE(daylimit)
+{
+	deployWallet(200);
+	BOOST_REQUIRE(callContractFunction("m_dailyLimit()") == encodeArgs(u256(0)));
+	BOOST_REQUIRE(callContractFunction("setDailyLimit(uint256)", u256(100)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("m_dailyLimit()") == encodeArgs(u256(100)));
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(1)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(2)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("addOwner(address)", account(3)) == encodeArgs());
+	// 4 owners, set required to 3
+	BOOST_REQUIRE(callContractFunction("changeRequirement(uint256)", u256(3)) == encodeArgs());
+
+	// try to send tx over daylimit
+	h160 destination = h160("0x5c6d6026d3fb35cd7175fd0054ae8df50d8f8b41");
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	sendEther(account(1), 10 * ether);
+	m_sender = account(1);
+	BOOST_REQUIRE(
+		callContractFunction("execute(address,uint256,bytes)", destination, 150, 0x60, 0x00) !=
+		encodeArgs(u256(0))
+	);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	// try to send tx under daylimit by stranger
+	m_sender = account(0);
+	sendEther(account(4), 10 * ether);
+	m_sender = account(4);
+	BOOST_REQUIRE(
+		callContractFunction("execute(address,uint256,bytes)", destination, 90, 0x60, 0x00) ==
+		encodeArgs(u256(0))
+	);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 0);
+	// now send below limit by owner
+	m_sender = account(0);
+	sendEther(account(1), 10 * ether);
+	BOOST_REQUIRE(
+		callContractFunction("execute(address,uint256,bytes)", destination, 90, 0x60, 0x00) ==
+		encodeArgs(u256(0))
+	);
+	BOOST_CHECK_EQUAL(balanceAt(destination), 90);
+}
+
+BOOST_AUTO_TEST_CASE(daylimit_constructor)
+{
+	deployWallet(200, {}, 1, 20);
+	BOOST_REQUIRE(callContractFunction("m_dailyLimit()") == encodeArgs(u256(20)));
+	BOOST_REQUIRE(callContractFunction("setDailyLimit(uint256)", u256(30)) == encodeArgs());
+	BOOST_REQUIRE(callContractFunction("m_dailyLimit()") == encodeArgs(u256(30)));
+}
+
+//@todo test data calls
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/evmc/README.md b/compiler/test/evmc/README.md
new file mode 100644
index 00000000..9381b4f5
--- /dev/null
+++ b/compiler/test/evmc/README.md
@@ -0,0 +1,10 @@
+# EVMC
+
+This is an import of [EVMC](https://github.com/ethereum/evmc) version [11.0.0](https://github.com/ethereum/evmc/releases/tag/v11.0.0).
+
+Steps when upgrading:
+- Copy all from [include/evmc](https://github.com/ethereum/evmc/tree/master/include/evmc) to [test/evmc](https://github.com/ethereum/solidity/tree/develop/test/evmc)
+    - Note that you should delete (or not copy in the first place) `tooling.hpp` and `instructions.h`.
+- Copy [`loader.c`](https://github.com/ethereum/evmc/blob/master/lib/loader/loader.c) to [test/evmc](https://github.com/ethereum/solidity/tree/develop/test/evmc)
+- `MockedAccount.storage` in `mocked_host.hpp` should be changed to a `map` from `unordered_map` as ordering is important for fuzzing. You'll also need to include `<map>`.
+    See [PR #11094](https://github.com/ethereum/solidity/pull/11094) for more details.
diff --git a/compiler/test/evmc/evmc.h b/compiler/test/evmc/evmc.h
new file mode 100644
index 00000000..48b03e55
--- /dev/null
+++ b/compiler/test/evmc/evmc.h
@@ -0,0 +1,1198 @@
+/**
+ * EVMC: Ethereum Client-VM Connector API
+ *
+ * @copyright
+ * Copyright 2016 The EVMC Authors.
+ * Licensed under the Apache License, Version 2.0.
+ *
+ * @defgroup EVMC EVMC
+ * @{
+ */
+#ifndef EVMC_H
+#define EVMC_H
+
+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 6)
+/**
+ * Portable declaration of "deprecated" attribute.
+ *
+ * Available for clang and GCC 6+ compilers. The older GCC compilers know
+ * this attribute, but it cannot be applied to enum elements.
+ */
+#define EVMC_DEPRECATED __attribute__((deprecated))
+#else
+#define EVMC_DEPRECATED
+#endif
+
+
+#include <stdbool.h> /* Definition of bool, true and false. */
+#include <stddef.h>  /* Definition of size_t. */
+#include <stdint.h>  /* Definition of int64_t, uint64_t. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEGIN Python CFFI declarations */
+
+enum
+{
+    /**
+     * The EVMC ABI version number of the interface declared in this file.
+     *
+     * The EVMC ABI version always equals the major version number of the EVMC project.
+     * The Host SHOULD check if the ABI versions match when dynamically loading VMs.
+     *
+     * @see @ref versioning
+     */
+    EVMC_ABI_VERSION = 11
+};
+
+
+/**
+ * The fixed size array of 32 bytes.
+ *
+ * 32 bytes of data capable of storing e.g. 256-bit hashes.
+ */
+typedef struct evmc_bytes32
+{
+    /** The 32 bytes. */
+    uint8_t bytes[32];
+} evmc_bytes32;
+
+/**
+ * The alias for evmc_bytes32 to represent a big-endian 256-bit integer.
+ */
+typedef struct evmc_bytes32 evmc_uint256be;
+
+/** Big-endian 160-bit hash suitable for keeping an Ethereum address. */
+typedef struct evmc_address
+{
+    /** The 20 bytes of the hash. */
+    uint8_t bytes[20];
+} evmc_address;
+
+/** The kind of call-like instruction. */
+enum evmc_call_kind
+{
+    EVMC_CALL = 0,         /**< Request CALL. */
+    EVMC_DELEGATECALL = 1, /**< Request DELEGATECALL. Valid since Homestead.
+                                The value param ignored. */
+    EVMC_CALLCODE = 2,     /**< Request CALLCODE. */
+    EVMC_CREATE = 3,       /**< Request CREATE. */
+    EVMC_CREATE2 = 4       /**< Request CREATE2. Valid since Constantinople.*/
+};
+
+/** The flags for ::evmc_message. */
+enum evmc_flags
+{
+    EVMC_STATIC = 1 /**< Static call mode. */
+};
+
+/**
+ * The message describing an EVM call, including a zero-depth calls from a transaction origin.
+ *
+ * Most of the fields are modelled by the section 8. Message Call of the Ethereum Yellow Paper.
+ */
+struct evmc_message
+{
+    /** The kind of the call. For zero-depth calls ::EVMC_CALL SHOULD be used. */
+    enum evmc_call_kind kind;
+
+    /**
+     * Additional flags modifying the call execution behavior.
+     * In the current version the only valid values are ::EVMC_STATIC or 0.
+     */
+    uint32_t flags;
+
+    /**
+     * The present depth of the message call stack.
+     *
+     * Defined as `e` in the Yellow Paper.
+     */
+    int32_t depth;
+
+    /**
+     * The amount of gas available to the message execution.
+     *
+     * Defined as `g` in the Yellow Paper.
+     */
+    int64_t gas;
+
+    /**
+     * The recipient of the message.
+     *
+     * This is the address of the account which storage/balance/nonce is going to be modified
+     * by the message execution. In case of ::EVMC_CALL, this is also the account where the
+     * message value evmc_message::value is going to be transferred.
+     * For ::EVMC_CALLCODE or ::EVMC_DELEGATECALL, this may be different from
+     * the evmc_message::code_address.
+     *
+     * Defined as `r` in the Yellow Paper.
+     */
+    evmc_address recipient;
+
+    /**
+     * The sender of the message.
+     *
+     * The address of the sender of a message call defined as `s` in the Yellow Paper.
+     * This must be the message recipient of the message at the previous (lower) depth,
+     * except for the ::EVMC_DELEGATECALL where recipient is the 2 levels above the present depth.
+     * At the depth 0 this must be the transaction origin.
+     */
+    evmc_address sender;
+
+    /**
+     * The message input data.
+     *
+     * The arbitrary length byte array of the input data of the call,
+     * defined as `d` in the Yellow Paper.
+     * This MAY be NULL.
+     */
+    const uint8_t* input_data;
+
+    /**
+     * The size of the message input data.
+     *
+     * If input_data is NULL this MUST be 0.
+     */
+    size_t input_size;
+
+    /**
+     * The amount of Ether transferred with the message.
+     *
+     * This is transferred value for ::EVMC_CALL or apparent value for ::EVMC_DELEGATECALL.
+     * Defined as `v` or `v~` in the Yellow Paper.
+     */
+    evmc_uint256be value;
+
+    /**
+     * The optional value used in new contract address construction.
+     *
+     * Needed only for a Host to calculate created address when kind is ::EVMC_CREATE2.
+     * Ignored in evmc_execute_fn().
+     */
+    evmc_bytes32 create2_salt;
+
+    /**
+     * The address of the code to be executed.
+     *
+     * For ::EVMC_CALLCODE or ::EVMC_DELEGATECALL this may be different from
+     * the evmc_message::recipient.
+     * Not required when invoking evmc_execute_fn(), only when invoking evmc_call_fn().
+     * Ignored if kind is ::EVMC_CREATE or ::EVMC_CREATE2.
+     *
+     * In case of ::EVMC_CAPABILITY_PRECOMPILES implementation, this fields should be inspected
+     * to identify the requested precompile.
+     *
+     * Defined as `c` in the Yellow Paper.
+     */
+    evmc_address code_address;
+};
+
+
+/** The transaction and block data for execution. */
+struct evmc_tx_context
+{
+    evmc_uint256be tx_gas_price;      /**< The transaction gas price. */
+    evmc_address tx_origin;           /**< The transaction origin account. */
+    evmc_address block_coinbase;      /**< The miner of the block. */
+    int64_t block_number;             /**< The block number. */
+    int64_t block_timestamp;          /**< The block timestamp. */
+    int64_t block_gas_limit;          /**< The block gas limit. */
+    evmc_uint256be block_prev_randao; /**< The block previous RANDAO (EIP-4399). */
+    evmc_uint256be chain_id;          /**< The blockchain's ChainID. */
+    evmc_uint256be block_base_fee;    /**< The block base fee per gas (EIP-1559, EIP-3198). */
+    evmc_uint256be blob_base_fee;     /**< The blob base fee (EIP-7516). */
+    const evmc_bytes32* blob_hashes;  /**< The array of blob hashes (EIP-4844). */
+    size_t blob_hashes_count;         /**< The number of blob hashes (EIP-4844). */
+};
+
+/**
+ * @struct evmc_host_context
+ * The opaque data type representing the Host execution context.
+ * @see evmc_execute_fn().
+ */
+struct evmc_host_context;
+
+/**
+ * Get transaction context callback function.
+ *
+ *  This callback function is used by an EVM to retrieve the transaction and
+ *  block context.
+ *
+ *  @param      context  The pointer to the Host execution context.
+ *  @return              The transaction context.
+ */
+typedef struct evmc_tx_context (*evmc_get_tx_context_fn)(struct evmc_host_context* context);
+
+/**
+ * Get block hash callback function.
+ *
+ * This callback function is used by a VM to query the hash of the header of the given block.
+ * If the information about the requested block is not available, then this is signalled by
+ * returning null bytes.
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param number   The block number.
+ * @return         The block hash or null bytes
+ *                 if the information about the block is not available.
+ */
+typedef evmc_bytes32 (*evmc_get_block_hash_fn)(struct evmc_host_context* context, int64_t number);
+
+/**
+ * The execution status code.
+ *
+ * Successful execution is represented by ::EVMC_SUCCESS having value 0.
+ *
+ * Positive values represent failures defined by VM specifications with generic
+ * ::EVMC_FAILURE code of value 1.
+ *
+ * Status codes with negative values represent VM internal errors
+ * not provided by EVM specifications. These errors MUST not be passed back
+ * to the caller. They MAY be handled by the Client in predefined manner
+ * (see e.g. ::EVMC_REJECTED), otherwise internal errors are not recoverable.
+ * The generic representant of errors is ::EVMC_INTERNAL_ERROR but
+ * an EVM implementation MAY return negative status codes that are not defined
+ * in the EVMC documentation.
+ *
+ * @note
+ * In case new status codes are needed, please create an issue or pull request
+ * in the EVMC repository (https://github.com/ethereum/evmc).
+ */
+enum evmc_status_code
+{
+    /** Execution finished with success. */
+    EVMC_SUCCESS = 0,
+
+    /** Generic execution failure. */
+    EVMC_FAILURE = 1,
+
+    /**
+     * Execution terminated with REVERT opcode.
+     *
+     * In this case the amount of gas left MAY be non-zero and additional output
+     * data MAY be provided in ::evmc_result.
+     */
+    EVMC_REVERT = 2,
+
+    /** The execution has run out of gas. */
+    EVMC_OUT_OF_GAS = 3,
+
+    /**
+     * The designated INVALID instruction has been hit during execution.
+     *
+     * The EIP-141 (https://github.com/ethereum/EIPs/blob/master/EIPS/eip-141.md)
+     * defines the instruction 0xfe as INVALID instruction to indicate execution
+     * abortion coming from high-level languages. This status code is reported
+     * in case this INVALID instruction has been encountered.
+     */
+    EVMC_INVALID_INSTRUCTION = 4,
+
+    /** An undefined instruction has been encountered. */
+    EVMC_UNDEFINED_INSTRUCTION = 5,
+
+    /**
+     * The execution has attempted to put more items on the EVM stack
+     * than the specified limit.
+     */
+    EVMC_STACK_OVERFLOW = 6,
+
+    /** Execution of an opcode has required more items on the EVM stack. */
+    EVMC_STACK_UNDERFLOW = 7,
+
+    /** Execution has violated the jump destination restrictions. */
+    EVMC_BAD_JUMP_DESTINATION = 8,
+
+    /**
+     * Tried to read outside memory bounds.
+     *
+     * An example is RETURNDATACOPY reading past the available buffer.
+     */
+    EVMC_INVALID_MEMORY_ACCESS = 9,
+
+    /** Call depth has exceeded the limit (if any) */
+    EVMC_CALL_DEPTH_EXCEEDED = 10,
+
+    /** Tried to execute an operation which is restricted in static mode. */
+    EVMC_STATIC_MODE_VIOLATION = 11,
+
+    /**
+     * A call to a precompiled or system contract has ended with a failure.
+     *
+     * An example: elliptic curve functions handed invalid EC points.
+     */
+    EVMC_PRECOMPILE_FAILURE = 12,
+
+    /**
+     * Contract validation has failed (e.g. due to EVM 1.5 jump validity,
+     * Casper's purity checker or ewasm contract rules).
+     */
+    EVMC_CONTRACT_VALIDATION_FAILURE = 13,
+
+    /**
+     * An argument to a state accessing method has a value outside of the
+     * accepted range of values.
+     */
+    EVMC_ARGUMENT_OUT_OF_RANGE = 14,
+
+    /**
+     * A WebAssembly `unreachable` instruction has been hit during execution.
+     */
+    EVMC_WASM_UNREACHABLE_INSTRUCTION = 15,
+
+    /**
+     * A WebAssembly trap has been hit during execution. This can be for many
+     * reasons, including division by zero, validation errors, etc.
+     */
+    EVMC_WASM_TRAP = 16,
+
+    /** The caller does not have enough funds for value transfer. */
+    EVMC_INSUFFICIENT_BALANCE = 17,
+
+    /** EVM implementation generic internal error. */
+    EVMC_INTERNAL_ERROR = -1,
+
+    /**
+     * The execution of the given code and/or message has been rejected
+     * by the EVM implementation.
+     *
+     * This error SHOULD be used to signal that the EVM is not able to or
+     * willing to execute the given code type or message.
+     * If an EVM returns the ::EVMC_REJECTED status code,
+     * the Client MAY try to execute it in other EVM implementation.
+     * For example, the Client tries running a code in the EVM 1.5. If the
+     * code is not supported there, the execution falls back to the EVM 1.0.
+     */
+    EVMC_REJECTED = -2,
+
+    /** The VM failed to allocate the amount of memory needed for execution. */
+    EVMC_OUT_OF_MEMORY = -3
+};
+
+/* Forward declaration. */
+struct evmc_result;
+
+/**
+ * Releases resources assigned to an execution result.
+ *
+ * This function releases memory (and other resources, if any) assigned to the
+ * specified execution result making the result object invalid.
+ *
+ * @param result  The execution result which resources are to be released. The
+ *                result itself it not modified by this function, but becomes
+ *                invalid and user MUST discard it as well.
+ *                This MUST NOT be NULL.
+ *
+ * @note
+ * The result is passed by pointer to avoid (shallow) copy of the ::evmc_result
+ * struct. Think of this as the best possible C language approximation to
+ * passing objects by reference.
+ */
+typedef void (*evmc_release_result_fn)(const struct evmc_result* result);
+
+/** The EVM code execution result. */
+struct evmc_result
+{
+    /** The execution status code. */
+    enum evmc_status_code status_code;
+
+    /**
+     * The amount of gas left after the execution.
+     *
+     * If evmc_result::status_code is neither ::EVMC_SUCCESS nor ::EVMC_REVERT
+     * the value MUST be 0.
+     */
+    int64_t gas_left;
+
+    /**
+     * The refunded gas accumulated from this execution and its sub-calls.
+     *
+     * The transaction gas refund limit is not applied.
+     * If evmc_result::status_code is other than ::EVMC_SUCCESS the value MUST be 0.
+     */
+    int64_t gas_refund;
+
+    /**
+     * The reference to output data.
+     *
+     * The output contains data coming from RETURN opcode (iff evmc_result::code
+     * field is ::EVMC_SUCCESS) or from REVERT opcode.
+     *
+     * The memory containing the output data is owned by EVM and has to be
+     * freed with evmc_result::release().
+     *
+     * This pointer MAY be NULL.
+     * If evmc_result::output_size is 0 this pointer MUST NOT be dereferenced.
+     */
+    const uint8_t* output_data;
+
+    /**
+     * The size of the output data.
+     *
+     * If evmc_result::output_data is NULL this MUST be 0.
+     */
+    size_t output_size;
+
+    /**
+     * The method releasing all resources associated with the result object.
+     *
+     * This method (function pointer) is optional (MAY be NULL) and MAY be set
+     * by the VM implementation. If set it MUST be called by the user once to
+     * release memory and other resources associated with the result object.
+     * Once the resources are released the result object MUST NOT be used again.
+     *
+     * The suggested code pattern for releasing execution results:
+     * @code
+     * struct evmc_result result = ...;
+     * if (result.release)
+     *     result.release(&result);
+     * @endcode
+     *
+     * @note
+     * It works similarly to C++ virtual destructor. Attaching the release
+     * function to the result itself allows VM composition.
+     */
+    evmc_release_result_fn release;
+
+    /**
+     * The address of the possibly created contract.
+     *
+     * The create address may be provided even though the contract creation has failed
+     * (evmc_result::status_code is not ::EVMC_SUCCESS). This is useful in situations
+     * when the address is observable, e.g. access to it remains warm.
+     * In all other cases the address MUST be null bytes.
+     */
+    evmc_address create_address;
+
+    /**
+     * Reserved data that MAY be used by a evmc_result object creator.
+     *
+     * This reserved 4 bytes together with 20 bytes from create_address form
+     * 24 bytes of memory called "optional data" within evmc_result struct
+     * to be optionally used by the evmc_result object creator.
+     *
+     * @see evmc_result_optional_data, evmc_get_optional_data().
+     *
+     * Also extends the size of the evmc_result to 64 bytes (full cache line).
+     */
+    uint8_t padding[4];
+};
+
+
+/**
+ * Check account existence callback function.
+ *
+ * This callback function is used by the VM to check if
+ * there exists an account at given address.
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account the query is about.
+ * @return         true if exists, false otherwise.
+ */
+typedef bool (*evmc_account_exists_fn)(struct evmc_host_context* context,
+                                       const evmc_address* address);
+
+/**
+ * Get storage callback function.
+ *
+ * This callback function is used by a VM to query the given account storage entry.
+ *
+ * @param context  The Host execution context.
+ * @param address  The address of the account.
+ * @param key      The index of the account's storage entry.
+ * @return         The storage value at the given storage key or null bytes
+ *                 if the account does not exist.
+ */
+typedef evmc_bytes32 (*evmc_get_storage_fn)(struct evmc_host_context* context,
+                                            const evmc_address* address,
+                                            const evmc_bytes32* key);
+
+/**
+ * Get transient storage callback function.
+ *
+ * This callback function is used by a VM to query
+ * the given account transient storage (EIP-1153) entry.
+ *
+ * @param context  The Host execution context.
+ * @param address  The address of the account.
+ * @param key      The index of the account's transient storage entry.
+ * @return         The transient storage value at the given storage key or null bytes
+ *                 if the account does not exist.
+ */
+typedef evmc_bytes32 (*evmc_get_transient_storage_fn)(struct evmc_host_context* context,
+                                                      const evmc_address* address,
+                                                      const evmc_bytes32* key);
+
+
+/**
+ * The effect of an attempt to modify a contract storage item.
+ *
+ * See @ref storagestatus for additional information about design of this enum
+ * and analysis of the specification.
+ *
+ * For the purpose of explaining the meaning of each element, the following
+ * notation is used:
+ * - 0 is zero value,
+ * - X != 0 (X is any value other than 0),
+ * - Y != 0, Y != X,  (Y is any value other than X and 0),
+ * - Z != 0, Z != X, Z != X (Z is any value other than Y and X and 0),
+ * - the "o -> c -> v" triple describes the change status in the context of:
+ *   - o: original value (cold value before a transaction started),
+ *   - c: current storage value,
+ *   - v: new storage value to be set.
+ *
+ * The order of elements follows EIPs introducing net storage gas costs:
+ * - EIP-2200: https://eips.ethereum.org/EIPS/eip-2200,
+ * - EIP-1283: https://eips.ethereum.org/EIPS/eip-1283.
+ */
+enum evmc_storage_status
+{
+    /**
+     * The new/same value is assigned to the storage item without affecting the cost structure.
+     *
+     * The storage value item is either:
+     * - left unchanged (c == v) or
+     * - the dirty value (o != c) is modified again (c != v).
+     * This is the group of cases related to minimal gas cost of only accessing warm storage.
+     * 0|X   -> 0 -> 0 (current value unchanged)
+     * 0|X|Y -> Y -> Y (current value unchanged)
+     * 0|X   -> Y -> Z (modified previously added/modified value)
+     *
+     * This is "catch all remaining" status. I.e. if all other statuses are correctly matched
+     * this status should be assigned to all remaining cases.
+     */
+    EVMC_STORAGE_ASSIGNED = 0,
+
+    /**
+     * A new storage item is added by changing
+     * the current clean zero to a nonzero value.
+     * 0 -> 0 -> Z
+     */
+    EVMC_STORAGE_ADDED = 1,
+
+    /**
+     * A storage item is deleted by changing
+     * the current clean nonzero to the zero value.
+     * X -> X -> 0
+     */
+    EVMC_STORAGE_DELETED = 2,
+
+    /**
+     * A storage item is modified by changing
+     * the current clean nonzero to other nonzero value.
+     * X -> X -> Z
+     */
+    EVMC_STORAGE_MODIFIED = 3,
+
+    /**
+     * A storage item is added by changing
+     * the current dirty zero to a nonzero value other than the original value.
+     * X -> 0 -> Z
+     */
+    EVMC_STORAGE_DELETED_ADDED = 4,
+
+    /**
+     * A storage item is deleted by changing
+     * the current dirty nonzero to the zero value and the original value is not zero.
+     * X -> Y -> 0
+     */
+    EVMC_STORAGE_MODIFIED_DELETED = 5,
+
+    /**
+     * A storage item is added by changing
+     * the current dirty zero to the original value.
+     * X -> 0 -> X
+     */
+    EVMC_STORAGE_DELETED_RESTORED = 6,
+
+    /**
+     * A storage item is deleted by changing
+     * the current dirty nonzero to the original zero value.
+     * 0 -> Y -> 0
+     */
+    EVMC_STORAGE_ADDED_DELETED = 7,
+
+    /**
+     * A storage item is modified by changing
+     * the current dirty nonzero to the original nonzero value other than the current value.
+     * X -> Y -> X
+     */
+    EVMC_STORAGE_MODIFIED_RESTORED = 8
+};
+
+
+/**
+ * Set storage callback function.
+ *
+ * This callback function is used by a VM to update the given account storage entry.
+ * The VM MUST make sure that the account exists. This requirement is only a formality because
+ * VM implementations only modify storage of the account of the current execution context
+ * (i.e. referenced by evmc_message::recipient).
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account.
+ * @param key      The index of the storage entry.
+ * @param value    The value to be stored.
+ * @return         The effect on the storage item.
+ */
+typedef enum evmc_storage_status (*evmc_set_storage_fn)(struct evmc_host_context* context,
+                                                        const evmc_address* address,
+                                                        const evmc_bytes32* key,
+                                                        const evmc_bytes32* value);
+
+/**
+ * Set transient storage callback function.
+ *
+ * This callback function is used by a VM to update
+ * the given account's transient storage (EIP-1153) entry.
+ * The VM MUST make sure that the account exists. This requirement is only a formality because
+ * VM implementations only modify storage of the account of the current execution context
+ * (i.e. referenced by evmc_message::recipient).
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account.
+ * @param key      The index of the transient storage entry.
+ * @param value    The value to be stored.
+ */
+typedef void (*evmc_set_transient_storage_fn)(struct evmc_host_context* context,
+                                              const evmc_address* address,
+                                              const evmc_bytes32* key,
+                                              const evmc_bytes32* value);
+
+/**
+ * Get balance callback function.
+ *
+ * This callback function is used by a VM to query the balance of the given account.
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account.
+ * @return         The balance of the given account or 0 if the account does not exist.
+ */
+typedef evmc_uint256be (*evmc_get_balance_fn)(struct evmc_host_context* context,
+                                              const evmc_address* address);
+
+/**
+ * Get code size callback function.
+ *
+ * This callback function is used by a VM to get the size of the code stored
+ * in the account at the given address.
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account.
+ * @return         The size of the code in the account or 0 if the account does not exist.
+ */
+typedef size_t (*evmc_get_code_size_fn)(struct evmc_host_context* context,
+                                        const evmc_address* address);
+
+/**
+ * Get code hash callback function.
+ *
+ * This callback function is used by a VM to get the keccak256 hash of the code stored
+ * in the account at the given address. For existing accounts not having a code, this
+ * function returns keccak256 hash of empty data.
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param address  The address of the account.
+ * @return         The hash of the code in the account or null bytes if the account does not exist.
+ */
+typedef evmc_bytes32 (*evmc_get_code_hash_fn)(struct evmc_host_context* context,
+                                              const evmc_address* address);
+
+/**
+ * Copy code callback function.
+ *
+ * This callback function is used by an EVM to request a copy of the code
+ * of the given account to the memory buffer provided by the EVM.
+ * The Client MUST copy the requested code, starting with the given offset,
+ * to the provided memory buffer up to the size of the buffer or the size of
+ * the code, whichever is smaller.
+ *
+ * @param context      The pointer to the Host execution context. See ::evmc_host_context.
+ * @param address      The address of the account.
+ * @param code_offset  The offset of the code to copy.
+ * @param buffer_data  The pointer to the memory buffer allocated by the EVM
+ *                     to store a copy of the requested code.
+ * @param buffer_size  The size of the memory buffer.
+ * @return             The number of bytes copied to the buffer by the Client.
+ */
+typedef size_t (*evmc_copy_code_fn)(struct evmc_host_context* context,
+                                    const evmc_address* address,
+                                    size_t code_offset,
+                                    uint8_t* buffer_data,
+                                    size_t buffer_size);
+
+/**
+ * Selfdestruct callback function.
+ *
+ * This callback function is used by an EVM to SELFDESTRUCT given contract.
+ * The execution of the contract will not be stopped, that is up to the EVM.
+ *
+ * @param context      The pointer to the Host execution context. See ::evmc_host_context.
+ * @param address      The address of the contract to be selfdestructed.
+ * @param beneficiary  The address where the remaining ETH is going to be transferred.
+ * @return             The information if the given address has not been registered as
+ *                     selfdestructed yet. True if registered for the first time, false otherwise.
+ */
+typedef bool (*evmc_selfdestruct_fn)(struct evmc_host_context* context,
+                                     const evmc_address* address,
+                                     const evmc_address* beneficiary);
+
+/**
+ * Log callback function.
+ *
+ * This callback function is used by an EVM to inform about a LOG that happened
+ * during an EVM bytecode execution.
+ *
+ * @param context       The pointer to the Host execution context. See ::evmc_host_context.
+ * @param address       The address of the contract that generated the log.
+ * @param data          The pointer to unindexed data attached to the log.
+ * @param data_size     The length of the data.
+ * @param topics        The pointer to the array of topics attached to the log.
+ * @param topics_count  The number of the topics. Valid values are between 0 and 4 inclusively.
+ */
+typedef void (*evmc_emit_log_fn)(struct evmc_host_context* context,
+                                 const evmc_address* address,
+                                 const uint8_t* data,
+                                 size_t data_size,
+                                 const evmc_bytes32 topics[],
+                                 size_t topics_count);
+
+/**
+ * Access status per EIP-2929: Gas cost increases for state access opcodes.
+ */
+enum evmc_access_status
+{
+    /**
+     * The entry hasn't been accessed before – it's the first access.
+     */
+    EVMC_ACCESS_COLD = 0,
+
+    /**
+     * The entry is already in accessed_addresses or accessed_storage_keys.
+     */
+    EVMC_ACCESS_WARM = 1
+};
+
+/**
+ * Access account callback function.
+ *
+ * This callback function is used by a VM to add the given address
+ * to accessed_addresses substate (EIP-2929).
+ *
+ * @param context  The Host execution context.
+ * @param address  The address of the account.
+ * @return         EVMC_ACCESS_WARM if accessed_addresses already contained the address
+ *                 or EVMC_ACCESS_COLD otherwise.
+ */
+typedef enum evmc_access_status (*evmc_access_account_fn)(struct evmc_host_context* context,
+                                                          const evmc_address* address);
+
+/**
+ * Access storage callback function.
+ *
+ * This callback function is used by a VM to add the given account storage entry
+ * to accessed_storage_keys substate (EIP-2929).
+ *
+ * @param context  The Host execution context.
+ * @param address  The address of the account.
+ * @param key      The index of the account's storage entry.
+ * @return         EVMC_ACCESS_WARM if accessed_storage_keys already contained the key
+ *                 or EVMC_ACCESS_COLD otherwise.
+ */
+typedef enum evmc_access_status (*evmc_access_storage_fn)(struct evmc_host_context* context,
+                                                          const evmc_address* address,
+                                                          const evmc_bytes32* key);
+
+/**
+ * Pointer to the callback function supporting EVM calls.
+ *
+ * @param context  The pointer to the Host execution context.
+ * @param msg      The call parameters.
+ * @return         The result of the call.
+ */
+typedef struct evmc_result (*evmc_call_fn)(struct evmc_host_context* context,
+                                           const struct evmc_message* msg);
+
+/**
+ * The Host interface.
+ *
+ * The set of all callback functions expected by VM instances. This is C
+ * realisation of vtable for OOP interface (only virtual methods, no data).
+ * Host implementations SHOULD create constant singletons of this (similarly
+ * to vtables) to lower the maintenance and memory management cost.
+ */
+struct evmc_host_interface
+{
+    /** Check account existence callback function. */
+    evmc_account_exists_fn account_exists;
+
+    /** Get storage callback function. */
+    evmc_get_storage_fn get_storage;
+
+    /** Set storage callback function. */
+    evmc_set_storage_fn set_storage;
+
+    /** Get balance callback function. */
+    evmc_get_balance_fn get_balance;
+
+    /** Get code size callback function. */
+    evmc_get_code_size_fn get_code_size;
+
+    /** Get code hash callback function. */
+    evmc_get_code_hash_fn get_code_hash;
+
+    /** Copy code callback function. */
+    evmc_copy_code_fn copy_code;
+
+    /** Selfdestruct callback function. */
+    evmc_selfdestruct_fn selfdestruct;
+
+    /** Call callback function. */
+    evmc_call_fn call;
+
+    /** Get transaction context callback function. */
+    evmc_get_tx_context_fn get_tx_context;
+
+    /** Get block hash callback function. */
+    evmc_get_block_hash_fn get_block_hash;
+
+    /** Emit log callback function. */
+    evmc_emit_log_fn emit_log;
+
+    /** Access account callback function. */
+    evmc_access_account_fn access_account;
+
+    /** Access storage callback function. */
+    evmc_access_storage_fn access_storage;
+
+    /** Get transient storage callback function. */
+    evmc_get_transient_storage_fn get_transient_storage;
+
+    /** Set transient storage callback function. */
+    evmc_set_transient_storage_fn set_transient_storage;
+};
+
+
+/* Forward declaration. */
+struct evmc_vm;
+
+/**
+ * Destroys the VM instance.
+ *
+ * @param vm  The VM instance to be destroyed.
+ */
+typedef void (*evmc_destroy_fn)(struct evmc_vm* vm);
+
+/**
+ * Possible outcomes of evmc_set_option.
+ */
+enum evmc_set_option_result
+{
+    EVMC_SET_OPTION_SUCCESS = 0,
+    EVMC_SET_OPTION_INVALID_NAME = 1,
+    EVMC_SET_OPTION_INVALID_VALUE = 2
+};
+
+/**
+ * Configures the VM instance.
+ *
+ * Allows modifying options of the VM instance.
+ * Options:
+ * - code cache behavior: on, off, read-only, ...
+ * - optimizations,
+ *
+ * @param vm     The VM instance to be configured.
+ * @param name   The option name. NULL-terminated string. Cannot be NULL.
+ * @param value  The new option value. NULL-terminated string. Cannot be NULL.
+ * @return       The outcome of the operation.
+ */
+typedef enum evmc_set_option_result (*evmc_set_option_fn)(struct evmc_vm* vm,
+                                                          char const* name,
+                                                          char const* value);
+
+
+/**
+ * EVM revision.
+ *
+ * The revision of the EVM specification based on the Ethereum
+ * upgrade / hard fork codenames.
+ */
+enum evmc_revision
+{
+    /**
+     * The Frontier revision.
+     *
+     * The one Ethereum launched with.
+     */
+    EVMC_FRONTIER = 0,
+
+    /**
+     * The Homestead revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-606
+     */
+    EVMC_HOMESTEAD = 1,
+
+    /**
+     * The Tangerine Whistle revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-608
+     */
+    EVMC_TANGERINE_WHISTLE = 2,
+
+    /**
+     * The Spurious Dragon revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-607
+     */
+    EVMC_SPURIOUS_DRAGON = 3,
+
+    /**
+     * The Byzantium revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-609
+     */
+    EVMC_BYZANTIUM = 4,
+
+    /**
+     * The Constantinople revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-1013
+     */
+    EVMC_CONSTANTINOPLE = 5,
+
+    /**
+     * The Petersburg revision.
+     *
+     * Other names: Constantinople2, ConstantinopleFix.
+     *
+     * https://eips.ethereum.org/EIPS/eip-1716
+     */
+    EVMC_PETERSBURG = 6,
+
+    /**
+     * The Istanbul revision.
+     *
+     * https://eips.ethereum.org/EIPS/eip-1679
+     */
+    EVMC_ISTANBUL = 7,
+
+    /**
+     * The Berlin revision.
+     *
+     * https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/berlin.md
+     */
+    EVMC_BERLIN = 8,
+
+    /**
+     * The London revision.
+     *
+     * https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/london.md
+     */
+    EVMC_LONDON = 9,
+
+    /**
+     * The Paris revision (aka The Merge).
+     *
+     * https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md
+     */
+    EVMC_PARIS = 10,
+
+    /**
+     * The Shanghai revision.
+     *
+     * https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md
+     */
+    EVMC_SHANGHAI = 11,
+
+    /**
+     * The Cancun revision.
+     *
+     * The future next revision after Shanghai.
+     * https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md
+     */
+    EVMC_CANCUN = 12,
+
+    /**
+     * The Prague revision.
+     *
+     * The future next revision after Cancun.
+     */
+    EVMC_PRAGUE = 13,
+
+    /** The maximum EVM revision supported. */
+    EVMC_MAX_REVISION = EVMC_PRAGUE,
+
+    /**
+     * The latest known EVM revision with finalized specification.
+     *
+     * This is handy for EVM tools to always use the latest revision available.
+     */
+    EVMC_LATEST_STABLE_REVISION = EVMC_SHANGHAI
+};
+
+
+/**
+ * Executes the given code using the input from the message.
+ *
+ * This function MAY be invoked multiple times for a single VM instance.
+ *
+ * @param vm         The VM instance. This argument MUST NOT be NULL.
+ * @param host       The Host interface. This argument MUST NOT be NULL unless
+ *                   the @p vm has the ::EVMC_CAPABILITY_PRECOMPILES capability.
+ * @param context    The opaque pointer to the Host execution context.
+ *                   This argument MAY be NULL. The VM MUST pass the same
+ *                   pointer to the methods of the @p host interface.
+ *                   The VM MUST NOT dereference the pointer.
+ * @param rev        The requested EVM specification revision.
+ * @param msg        The call parameters. See ::evmc_message. This argument MUST NOT be NULL.
+ * @param code       The reference to the code to be executed. This argument MAY be NULL.
+ * @param code_size  The length of the code. If @p code is NULL this argument MUST be 0.
+ * @return           The execution result.
+ */
+typedef struct evmc_result (*evmc_execute_fn)(struct evmc_vm* vm,
+                                              const struct evmc_host_interface* host,
+                                              struct evmc_host_context* context,
+                                              enum evmc_revision rev,
+                                              const struct evmc_message* msg,
+                                              uint8_t const* code,
+                                              size_t code_size);
+
+/**
+ * Possible capabilities of a VM.
+ */
+enum evmc_capabilities
+{
+    /**
+     * The VM is capable of executing EVM1 bytecode.
+     */
+    EVMC_CAPABILITY_EVM1 = (1u << 0),
+
+    /**
+     * The VM is capable of executing ewasm bytecode.
+     */
+    EVMC_CAPABILITY_EWASM = (1u << 1),
+
+    /**
+     * The VM is capable of executing the precompiled contracts
+     * defined for the range of code addresses.
+     *
+     * The EIP-1352 (https://eips.ethereum.org/EIPS/eip-1352) specifies
+     * the range 0x000...0000 - 0x000...ffff of addresses
+     * reserved for precompiled and system contracts.
+     *
+     * This capability is **experimental** and MAY be removed without notice.
+     */
+    EVMC_CAPABILITY_PRECOMPILES = (1u << 2)
+};
+
+/**
+ * Alias for unsigned integer representing a set of bit flags of EVMC capabilities.
+ *
+ * @see evmc_capabilities
+ */
+typedef uint32_t evmc_capabilities_flagset;
+
+/**
+ * Return the supported capabilities of the VM instance.
+ *
+ * This function MAY be invoked multiple times for a single VM instance,
+ * and its value MAY be influenced by calls to evmc_vm::set_option.
+ *
+ * @param vm  The VM instance.
+ * @return    The supported capabilities of the VM. @see evmc_capabilities.
+ */
+typedef evmc_capabilities_flagset (*evmc_get_capabilities_fn)(struct evmc_vm* vm);
+
+
+/**
+ * The VM instance.
+ *
+ * Defines the base struct of the VM implementation.
+ */
+struct evmc_vm
+{
+    /**
+     * EVMC ABI version implemented by the VM instance.
+     *
+     * Can be used to detect ABI incompatibilities.
+     * The EVMC ABI version represented by this file is in ::EVMC_ABI_VERSION.
+     */
+    const int abi_version;
+
+    /**
+     * The name of the EVMC VM implementation.
+     *
+     * It MUST be a NULL-terminated not empty string.
+     * The content MUST be UTF-8 encoded (this implies ASCII encoding is also allowed).
+     */
+    const char* name;
+
+    /**
+     * The version of the EVMC VM implementation, e.g. "1.2.3b4".
+     *
+     * It MUST be a NULL-terminated not empty string.
+     * The content MUST be UTF-8 encoded (this implies ASCII encoding is also allowed).
+     */
+    const char* version;
+
+    /**
+     * Pointer to function destroying the VM instance.
+     *
+     * This is a mandatory method and MUST NOT be set to NULL.
+     */
+    evmc_destroy_fn destroy;
+
+    /**
+     * Pointer to function executing a code by the VM instance.
+     *
+     * This is a mandatory method and MUST NOT be set to NULL.
+     */
+    evmc_execute_fn execute;
+
+    /**
+     * A method returning capabilities supported by the VM instance.
+     *
+     * The value returned MAY change when different options are set via the set_option() method.
+     *
+     * A Client SHOULD only rely on the value returned if it has queried it after
+     * it has called the set_option().
+     *
+     * This is a mandatory method and MUST NOT be set to NULL.
+     */
+    evmc_get_capabilities_fn get_capabilities;
+
+    /**
+     * Optional pointer to function modifying VM's options.
+     *
+     * If the VM does not support this feature the pointer can be NULL.
+     */
+    evmc_set_option_fn set_option;
+};
+
+/* END Python CFFI declarations */
+
+#ifdef EVMC_DOCUMENTATION
+/**
+ * Example of a function creating an instance of an example EVM implementation.
+ *
+ * Each EVM implementation MUST provide a function returning an EVM instance.
+ * The function SHOULD be named `evmc_create_<vm-name>(void)`. If the VM name contains hyphens
+ * replaces them with underscores in the function names.
+ *
+ * @par Binaries naming convention
+ * For VMs distributed as shared libraries, the name of the library SHOULD match the VM name.
+ * The convetional library filename prefixes and extensions SHOULD be ignored by the Client.
+ * For example, the shared library with the "beta-interpreter" implementation may be named
+ * `libbeta-interpreter.so`.
+ *
+ * @return  The VM instance or NULL indicating instance creation failure.
+ */
+struct evmc_vm* evmc_create_example_vm(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/** @} */
diff --git a/compiler/test/evmc/evmc.hpp b/compiler/test/evmc/evmc.hpp
new file mode 100644
index 00000000..91386c46
--- /dev/null
+++ b/compiler/test/evmc/evmc.hpp
@@ -0,0 +1,961 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2018 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+#pragma once
+
+#include <evmc/evmc.h>
+#include <evmc/helpers.h>
+#include <evmc/hex.hpp>
+
+#include <functional>
+#include <initializer_list>
+#include <ostream>
+#include <string_view>
+#include <utility>
+
+static_assert(EVMC_LATEST_STABLE_REVISION <= EVMC_MAX_REVISION,
+              "latest stable revision ill-defined");
+
+/// EVMC C++ API - wrappers and bindings for C++
+/// @ingroup cpp
+namespace evmc
+{
+/// String view of uint8_t chars.
+using bytes_view = std::basic_string_view<uint8_t>;
+
+/// The big-endian 160-bit hash suitable for keeping an Ethereum address.
+///
+/// This type wraps C ::evmc_address to make sure objects of this type are always initialized.
+struct address : evmc_address
+{
+    /// Default and converting constructor.
+    ///
+    /// Initializes bytes to zeros if not other @p init value provided.
+    constexpr address(evmc_address init = {}) noexcept : evmc_address{init} {}
+
+    /// Converting constructor from unsigned integer value.
+    ///
+    /// This constructor assigns the @p v value to the last 8 bytes [12:19]
+    /// in big-endian order.
+    constexpr explicit address(uint64_t v) noexcept
+      : evmc_address{{0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      static_cast<uint8_t>(v >> 56),
+                      static_cast<uint8_t>(v >> 48),
+                      static_cast<uint8_t>(v >> 40),
+                      static_cast<uint8_t>(v >> 32),
+                      static_cast<uint8_t>(v >> 24),
+                      static_cast<uint8_t>(v >> 16),
+                      static_cast<uint8_t>(v >> 8),
+                      static_cast<uint8_t>(v >> 0)}}
+    {}
+
+    /// Explicit operator converting to bool.
+    inline constexpr explicit operator bool() const noexcept;
+
+    /// Implicit operator converting to bytes_view.
+    inline constexpr operator bytes_view() const noexcept { return {bytes, sizeof(bytes)}; }
+};
+
+/// The fixed size array of 32 bytes for storing 256-bit EVM values.
+///
+/// This type wraps C ::evmc_bytes32 to make sure objects of this type are always initialized.
+struct bytes32 : evmc_bytes32
+{
+    /// Default and converting constructor.
+    ///
+    /// Initializes bytes to zeros if not other @p init value provided.
+    constexpr bytes32(evmc_bytes32 init = {}) noexcept : evmc_bytes32{init} {}
+
+    /// Converting constructor from unsigned integer value.
+    ///
+    /// This constructor assigns the @p v value to the last 8 bytes [24:31]
+    /// in big-endian order.
+    constexpr explicit bytes32(uint64_t v) noexcept
+      : evmc_bytes32{{0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      0,
+                      static_cast<uint8_t>(v >> 56),
+                      static_cast<uint8_t>(v >> 48),
+                      static_cast<uint8_t>(v >> 40),
+                      static_cast<uint8_t>(v >> 32),
+                      static_cast<uint8_t>(v >> 24),
+                      static_cast<uint8_t>(v >> 16),
+                      static_cast<uint8_t>(v >> 8),
+                      static_cast<uint8_t>(v >> 0)}}
+    {}
+
+    /// Explicit operator converting to bool.
+    inline constexpr explicit operator bool() const noexcept;
+
+    /// Implicit operator converting to bytes_view.
+    inline constexpr operator bytes_view() const noexcept { return {bytes, sizeof(bytes)}; }
+};
+
+/// The alias for evmc::bytes32 to represent a big-endian 256-bit integer.
+using uint256be = bytes32;
+
+
+/// Loads 64 bits / 8 bytes of data from the given @p data array in big-endian order.
+inline constexpr uint64_t load64be(const uint8_t* data) noexcept
+{
+    return (uint64_t{data[0]} << 56) | (uint64_t{data[1]} << 48) | (uint64_t{data[2]} << 40) |
+           (uint64_t{data[3]} << 32) | (uint64_t{data[4]} << 24) | (uint64_t{data[5]} << 16) |
+           (uint64_t{data[6]} << 8) | uint64_t{data[7]};
+}
+
+/// Loads 64 bits / 8 bytes of data from the given @p data array in little-endian order.
+inline constexpr uint64_t load64le(const uint8_t* data) noexcept
+{
+    return uint64_t{data[0]} | (uint64_t{data[1]} << 8) | (uint64_t{data[2]} << 16) |
+           (uint64_t{data[3]} << 24) | (uint64_t{data[4]} << 32) | (uint64_t{data[5]} << 40) |
+           (uint64_t{data[6]} << 48) | (uint64_t{data[7]} << 56);
+}
+
+/// Loads 32 bits / 4 bytes of data from the given @p data array in big-endian order.
+inline constexpr uint32_t load32be(const uint8_t* data) noexcept
+{
+    return (uint32_t{data[0]} << 24) | (uint32_t{data[1]} << 16) | (uint32_t{data[2]} << 8) |
+           uint32_t{data[3]};
+}
+
+/// Loads 32 bits / 4 bytes of data from the given @p data array in little-endian order.
+inline constexpr uint32_t load32le(const uint8_t* data) noexcept
+{
+    return uint32_t{data[0]} | (uint32_t{data[1]} << 8) | (uint32_t{data[2]} << 16) |
+           (uint32_t{data[3]} << 24);
+}
+
+namespace fnv
+{
+constexpr auto prime = 0x100000001b3;              ///< The 64-bit FNV prime number.
+constexpr auto offset_basis = 0xcbf29ce484222325;  ///< The 64-bit FNV offset basis.
+
+/// The hashing transformation for 64-bit inputs based on the FNV-1a formula.
+inline constexpr uint64_t fnv1a_by64(uint64_t h, uint64_t x) noexcept
+{
+    return (h ^ x) * prime;
+}
+}  // namespace fnv
+
+
+/// The "equal to" comparison operator for the evmc::address type.
+inline constexpr bool operator==(const address& a, const address& b) noexcept
+{
+    return load64le(&a.bytes[0]) == load64le(&b.bytes[0]) &&
+           load64le(&a.bytes[8]) == load64le(&b.bytes[8]) &&
+           load32le(&a.bytes[16]) == load32le(&b.bytes[16]);
+}
+
+/// The "not equal to" comparison operator for the evmc::address type.
+inline constexpr bool operator!=(const address& a, const address& b) noexcept
+{
+    return !(a == b);
+}
+
+/// The "less than" comparison operator for the evmc::address type.
+inline constexpr bool operator<(const address& a, const address& b) noexcept
+{
+    return load64be(&a.bytes[0]) < load64be(&b.bytes[0]) ||
+           (load64be(&a.bytes[0]) == load64be(&b.bytes[0]) &&
+            (load64be(&a.bytes[8]) < load64be(&b.bytes[8]) ||
+             (load64be(&a.bytes[8]) == load64be(&b.bytes[8]) &&
+              load32be(&a.bytes[16]) < load32be(&b.bytes[16]))));
+}
+
+/// The "greater than" comparison operator for the evmc::address type.
+inline constexpr bool operator>(const address& a, const address& b) noexcept
+{
+    return b < a;
+}
+
+/// The "less than or equal to" comparison operator for the evmc::address type.
+inline constexpr bool operator<=(const address& a, const address& b) noexcept
+{
+    return !(b < a);
+}
+
+/// The "greater than or equal to" comparison operator for the evmc::address type.
+inline constexpr bool operator>=(const address& a, const address& b) noexcept
+{
+    return !(a < b);
+}
+
+/// The "equal to" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator==(const bytes32& a, const bytes32& b) noexcept
+{
+    return load64le(&a.bytes[0]) == load64le(&b.bytes[0]) &&
+           load64le(&a.bytes[8]) == load64le(&b.bytes[8]) &&
+           load64le(&a.bytes[16]) == load64le(&b.bytes[16]) &&
+           load64le(&a.bytes[24]) == load64le(&b.bytes[24]);
+}
+
+/// The "not equal to" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator!=(const bytes32& a, const bytes32& b) noexcept
+{
+    return !(a == b);
+}
+
+/// The "less than" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator<(const bytes32& a, const bytes32& b) noexcept
+{
+    return load64be(&a.bytes[0]) < load64be(&b.bytes[0]) ||
+           (load64be(&a.bytes[0]) == load64be(&b.bytes[0]) &&
+            (load64be(&a.bytes[8]) < load64be(&b.bytes[8]) ||
+             (load64be(&a.bytes[8]) == load64be(&b.bytes[8]) &&
+              (load64be(&a.bytes[16]) < load64be(&b.bytes[16]) ||
+               (load64be(&a.bytes[16]) == load64be(&b.bytes[16]) &&
+                load64be(&a.bytes[24]) < load64be(&b.bytes[24]))))));
+}
+
+/// The "greater than" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator>(const bytes32& a, const bytes32& b) noexcept
+{
+    return b < a;
+}
+
+/// The "less than or equal to" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator<=(const bytes32& a, const bytes32& b) noexcept
+{
+    return !(b < a);
+}
+
+/// The "greater than or equal to" comparison operator for the evmc::bytes32 type.
+inline constexpr bool operator>=(const bytes32& a, const bytes32& b) noexcept
+{
+    return !(a < b);
+}
+
+/// Checks if the given address is the zero address.
+inline constexpr bool is_zero(const address& a) noexcept
+{
+    return a == address{};
+}
+
+inline constexpr address::operator bool() const noexcept
+{
+    return !is_zero(*this);
+}
+
+/// Checks if the given bytes32 object has all zero bytes.
+inline constexpr bool is_zero(const bytes32& a) noexcept
+{
+    return a == bytes32{};
+}
+
+inline constexpr bytes32::operator bool() const noexcept
+{
+    return !is_zero(*this);
+}
+
+namespace literals
+{
+/// Converts a raw literal into value of type T.
+///
+/// This function is expected to be used on literals in constexpr context only.
+/// In case the input is invalid the std::terminate() is called.
+/// TODO(c++20): Use consteval.
+template <typename T>
+constexpr T parse(std::string_view s) noexcept
+{
+    return from_hex<T>(s).value();
+}
+
+/// Literal for evmc::address.
+constexpr address operator""_address(const char* s) noexcept
+{
+    return parse<address>(s);
+}
+
+/// Literal for evmc::bytes32.
+constexpr bytes32 operator""_bytes32(const char* s) noexcept
+{
+    return parse<bytes32>(s);
+}
+}  // namespace literals
+
+using namespace literals;
+
+
+/// @copydoc evmc_status_code_to_string
+inline const char* to_string(evmc_status_code status_code) noexcept
+{
+    return evmc_status_code_to_string(status_code);
+}
+
+/// @copydoc evmc_revision_to_string
+inline const char* to_string(evmc_revision rev) noexcept
+{
+    return evmc_revision_to_string(rev);
+}
+
+
+/// Alias for evmc_make_result().
+constexpr auto make_result = evmc_make_result;
+
+/// @copydoc evmc_result
+///
+/// This is a RAII wrapper for evmc_result and objects of this type
+/// automatically release attached resources.
+class Result : private evmc_result
+{
+public:
+    using evmc_result::create_address;
+    using evmc_result::gas_left;
+    using evmc_result::gas_refund;
+    using evmc_result::output_data;
+    using evmc_result::output_size;
+    using evmc_result::status_code;
+
+    /// Creates the result from the provided arguments.
+    ///
+    /// The provided output is copied to memory allocated with malloc()
+    /// and the evmc_result::release function is set to one invoking free().
+    ///
+    /// @param _status_code  The status code.
+    /// @param _gas_left     The amount of gas left.
+    /// @param _gas_refund   The amount of refunded gas.
+    /// @param _output_data  The pointer to the output.
+    /// @param _output_size  The output size.
+    explicit Result(evmc_status_code _status_code,
+                    int64_t _gas_left,
+                    int64_t _gas_refund,
+                    const uint8_t* _output_data,
+                    size_t _output_size) noexcept
+      : evmc_result{make_result(_status_code, _gas_left, _gas_refund, _output_data, _output_size)}
+    {}
+
+    /// Creates the result without output.
+    ///
+    /// @param _status_code  The status code.
+    /// @param _gas_left     The amount of gas left.
+    /// @param _gas_refund   The amount of refunded gas.
+    explicit Result(evmc_status_code _status_code = EVMC_INTERNAL_ERROR,
+                    int64_t _gas_left = 0,
+                    int64_t _gas_refund = 0) noexcept
+      : evmc_result{make_result(_status_code, _gas_left, _gas_refund, nullptr, 0)}
+    {}
+
+    /// Creates the result of contract creation.
+    ///
+    /// @param _status_code     The status code.
+    /// @param _gas_left        The amount of gas left.
+    /// @param _gas_refund      The amount of refunded gas.
+    /// @param _create_address  The address of the possibly created account.
+    explicit Result(evmc_status_code _status_code,
+                    int64_t _gas_left,
+                    int64_t _gas_refund,
+                    const evmc_address& _create_address) noexcept
+      : evmc_result{make_result(_status_code, _gas_left, _gas_refund, nullptr, 0)}
+    {
+        create_address = _create_address;
+    }
+
+    /// Converting constructor from raw evmc_result.
+    ///
+    /// This object takes ownership of the resources of @p res.
+    explicit Result(const evmc_result& res) noexcept : evmc_result{res} {}
+
+    /// Destructor responsible for automatically releasing attached resources.
+    ~Result() noexcept
+    {
+        if (release != nullptr)
+            release(this);
+    }
+
+    /// Move constructor.
+    Result(Result&& other) noexcept : evmc_result{other}
+    {
+        other.release = nullptr;  // Disable releasing of the rvalue object.
+    }
+
+    /// Move assignment operator.
+    ///
+    /// The self-assignment MUST never happen.
+    ///
+    /// @param other The other result object.
+    /// @return      The reference to the left-hand side object.
+    Result& operator=(Result&& other) noexcept
+    {
+        this->~Result();                           // Release this object.
+        static_cast<evmc_result&>(*this) = other;  // Copy data.
+        other.release = nullptr;                   // Disable releasing of the rvalue object.
+        return *this;
+    }
+
+    /// Access the result object as a referenced to ::evmc_result.
+    evmc_result& raw() noexcept { return *this; }
+
+    /// Access the result object as a const referenced to ::evmc_result.
+    const evmc_result& raw() const noexcept { return *this; }
+
+    /// Releases the ownership and returns the raw copy of evmc_result.
+    ///
+    /// This method drops the ownership of the result
+    /// (result's resources are not going to be released when this object is destructed).
+    /// It is the caller's responsibility having the returned copy of the result to release it.
+    /// This object MUST NOT be used after this method is invoked.
+    ///
+    /// @return  The copy of this object converted to raw evmc_result.
+    evmc_result release_raw() noexcept
+    {
+        const auto out = evmc_result{*this};  // Copy data.
+        this->release = nullptr;              // Disable releasing of this object.
+        return out;
+    }
+};
+
+
+/// The EVMC Host interface
+class HostInterface
+{
+public:
+    virtual ~HostInterface() noexcept = default;
+
+    /// @copydoc evmc_host_interface::account_exists
+    virtual bool account_exists(const address& addr) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_storage
+    virtual bytes32 get_storage(const address& addr, const bytes32& key) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::set_storage
+    virtual evmc_storage_status set_storage(const address& addr,
+                                            const bytes32& key,
+                                            const bytes32& value) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_balance
+    virtual uint256be get_balance(const address& addr) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_code_size
+    virtual size_t get_code_size(const address& addr) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_code_hash
+    virtual bytes32 get_code_hash(const address& addr) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::copy_code
+    virtual size_t copy_code(const address& addr,
+                             size_t code_offset,
+                             uint8_t* buffer_data,
+                             size_t buffer_size) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::selfdestruct
+    virtual bool selfdestruct(const address& addr, const address& beneficiary) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::call
+    virtual Result call(const evmc_message& msg) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_tx_context
+    virtual evmc_tx_context get_tx_context() const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_block_hash
+    virtual bytes32 get_block_hash(int64_t block_number) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::emit_log
+    virtual void emit_log(const address& addr,
+                          const uint8_t* data,
+                          size_t data_size,
+                          const bytes32 topics[],
+                          size_t num_topics) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::access_account
+    virtual evmc_access_status access_account(const address& addr) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::access_storage
+    virtual evmc_access_status access_storage(const address& addr, const bytes32& key) noexcept = 0;
+
+    /// @copydoc evmc_host_interface::get_transient_storage
+    virtual bytes32 get_transient_storage(const address& addr,
+                                          const bytes32& key) const noexcept = 0;
+
+    /// @copydoc evmc_host_interface::set_transient_storage
+    virtual void set_transient_storage(const address& addr,
+                                       const bytes32& key,
+                                       const bytes32& value) noexcept = 0;
+};
+
+
+/// Wrapper around EVMC host context / host interface.
+///
+/// To be used by VM implementations as better alternative to using ::evmc_host_context directly.
+class HostContext : public HostInterface
+{
+    const evmc_host_interface* host = nullptr;
+    evmc_host_context* context = nullptr;
+
+public:
+    /// Default constructor for null Host context.
+    HostContext() = default;
+
+    /// Constructor from the EVMC Host primitives.
+    /// @param interface  The reference to the Host interface.
+    /// @param ctx        The pointer to the Host context object. This parameter MAY be null.
+    HostContext(const evmc_host_interface& interface, evmc_host_context* ctx) noexcept
+      : host{&interface}, context{ctx}
+    {}
+
+    bool account_exists(const address& address) const noexcept final
+    {
+        return host->account_exists(context, &address);
+    }
+
+    bytes32 get_storage(const address& address, const bytes32& key) const noexcept final
+    {
+        return host->get_storage(context, &address, &key);
+    }
+
+    evmc_storage_status set_storage(const address& address,
+                                    const bytes32& key,
+                                    const bytes32& value) noexcept final
+    {
+        return host->set_storage(context, &address, &key, &value);
+    }
+
+    uint256be get_balance(const address& address) const noexcept final
+    {
+        return host->get_balance(context, &address);
+    }
+
+    size_t get_code_size(const address& address) const noexcept final
+    {
+        return host->get_code_size(context, &address);
+    }
+
+    bytes32 get_code_hash(const address& address) const noexcept final
+    {
+        return host->get_code_hash(context, &address);
+    }
+
+    size_t copy_code(const address& address,
+                     size_t code_offset,
+                     uint8_t* buffer_data,
+                     size_t buffer_size) const noexcept final
+    {
+        return host->copy_code(context, &address, code_offset, buffer_data, buffer_size);
+    }
+
+    bool selfdestruct(const address& addr, const address& beneficiary) noexcept final
+    {
+        return host->selfdestruct(context, &addr, &beneficiary);
+    }
+
+    Result call(const evmc_message& message) noexcept final
+    {
+        return Result{host->call(context, &message)};
+    }
+
+    /// @copydoc HostInterface::get_tx_context()
+    evmc_tx_context get_tx_context() const noexcept final { return host->get_tx_context(context); }
+
+    bytes32 get_block_hash(int64_t number) const noexcept final
+    {
+        return host->get_block_hash(context, number);
+    }
+
+    void emit_log(const address& addr,
+                  const uint8_t* data,
+                  size_t data_size,
+                  const bytes32 topics[],
+                  size_t topics_count) noexcept final
+    {
+        host->emit_log(context, &addr, data, data_size, topics, topics_count);
+    }
+
+    evmc_access_status access_account(const address& address) noexcept final
+    {
+        return host->access_account(context, &address);
+    }
+
+    evmc_access_status access_storage(const address& address, const bytes32& key) noexcept final
+    {
+        return host->access_storage(context, &address, &key);
+    }
+
+    bytes32 get_transient_storage(const address& address, const bytes32& key) const noexcept final
+    {
+        return host->get_transient_storage(context, &address, &key);
+    }
+
+    void set_transient_storage(const address& address,
+                               const bytes32& key,
+                               const bytes32& value) noexcept final
+    {
+        host->set_transient_storage(context, &address, &key, &value);
+    }
+};
+
+
+/// Abstract class to be used by Host implementations.
+///
+/// When implementing EVMC Host, you can directly inherit from the evmc::Host class.
+/// This way your implementation will be simpler by avoiding manual handling
+/// of the ::evmc_host_context and the ::evmc_host_interface.
+class Host : public HostInterface
+{
+public:
+    /// Provides access to the global host interface.
+    /// @returns  Reference to the host interface object.
+    static const evmc_host_interface& get_interface() noexcept;
+
+    /// Converts the Host object to the opaque host context pointer.
+    /// @returns  Pointer to evmc_host_context.
+    evmc_host_context* to_context() noexcept { return reinterpret_cast<evmc_host_context*>(this); }
+
+    /// Converts the opaque host context pointer back to the original Host object.
+    /// @tparam DerivedClass  The class derived from the Host class.
+    /// @param context        The opaque host context pointer.
+    /// @returns              The pointer to DerivedClass.
+    template <typename DerivedClass = Host>
+    static DerivedClass* from_context(evmc_host_context* context) noexcept
+    {
+        // Get pointer of the Host base class.
+        auto* h = reinterpret_cast<Host*>(context);
+
+        // Additional downcast, only possible if DerivedClass inherits from Host.
+        return static_cast<DerivedClass*>(h);
+    }
+};
+
+
+/// @copybrief evmc_vm
+///
+/// This is a RAII wrapper for evmc_vm, and object of this type
+/// automatically destroys the VM instance.
+class VM
+{
+public:
+    VM() noexcept = default;
+
+    /// Converting constructor from evmc_vm.
+    explicit VM(evmc_vm* vm) noexcept : m_instance{vm} {}
+
+    /// Destructor responsible for automatically destroying the VM instance.
+    ~VM() noexcept
+    {
+        if (m_instance != nullptr)
+            m_instance->destroy(m_instance);
+    }
+
+    VM(const VM&) = delete;
+    VM& operator=(const VM&) = delete;
+
+    /// Move constructor.
+    VM(VM&& other) noexcept : m_instance{other.m_instance} { other.m_instance = nullptr; }
+
+    /// Move assignment operator.
+    VM& operator=(VM&& other) noexcept
+    {
+        this->~VM();
+        m_instance = other.m_instance;
+        other.m_instance = nullptr;
+        return *this;
+    }
+
+    /// The constructor that captures a VM instance and configures the instance
+    /// with the provided list of options.
+    inline VM(evmc_vm* vm,
+              std::initializer_list<std::pair<const char*, const char*>> options) noexcept;
+
+    /// Checks if contains a valid pointer to the VM instance.
+    explicit operator bool() const noexcept { return m_instance != nullptr; }
+
+    /// Checks whenever the VM instance is ABI compatible with the current EVMC API.
+    bool is_abi_compatible() const noexcept { return m_instance->abi_version == EVMC_ABI_VERSION; }
+
+    /// @copydoc evmc_vm::name
+    char const* name() const noexcept { return m_instance->name; }
+
+    /// @copydoc evmc_vm::version
+    char const* version() const noexcept { return m_instance->version; }
+
+    /// Checks if the VM has the given capability.
+    bool has_capability(evmc_capabilities capability) const noexcept
+    {
+        return (get_capabilities() & static_cast<evmc_capabilities_flagset>(capability)) != 0;
+    }
+
+    /// @copydoc evmc_vm::get_capabilities
+    evmc_capabilities_flagset get_capabilities() const noexcept
+    {
+        return m_instance->get_capabilities(m_instance);
+    }
+
+    /// @copydoc evmc_set_option()
+    evmc_set_option_result set_option(const char name[], const char value[]) noexcept
+    {
+        return evmc_set_option(m_instance, name, value);
+    }
+
+    /// @copydoc evmc_execute()
+    Result execute(const evmc_host_interface& host,
+                   evmc_host_context* ctx,
+                   evmc_revision rev,
+                   const evmc_message& msg,
+                   const uint8_t* code,
+                   size_t code_size) noexcept
+    {
+        return Result{m_instance->execute(m_instance, &host, ctx, rev, &msg, code, code_size)};
+    }
+
+    /// Convenient variant of the VM::execute() that takes reference to evmc::Host class.
+    Result execute(Host& host,
+                   evmc_revision rev,
+                   const evmc_message& msg,
+                   const uint8_t* code,
+                   size_t code_size) noexcept
+    {
+        return execute(Host::get_interface(), host.to_context(), rev, msg, code, code_size);
+    }
+
+    /// Executes code without the Host context.
+    ///
+    /// The same as
+    /// execute(const evmc_host_interface&, evmc_host_context*, evmc_revision,
+    ///         const evmc_message&, const uint8_t*, size_t),
+    /// but without providing the Host context and interface.
+    /// This method is for experimental precompiles support where execution is
+    /// guaranteed not to require any Host access.
+    Result execute(evmc_revision rev,
+                   const evmc_message& msg,
+                   const uint8_t* code,
+                   size_t code_size) noexcept
+    {
+        return Result{
+            m_instance->execute(m_instance, nullptr, nullptr, rev, &msg, code, code_size)};
+    }
+
+    /// Returns the pointer to C EVMC struct representing the VM.
+    ///
+    /// Gives access to the C EVMC VM struct to allow advanced interaction with the VM not supported
+    /// by the C++ interface. Use as the last resort.
+    /// This object still owns the VM after returning the pointer. The returned pointer MAY be null.
+    evmc_vm* get_raw_pointer() const noexcept { return m_instance; }
+
+private:
+    evmc_vm* m_instance = nullptr;
+};
+
+inline VM::VM(evmc_vm* vm,
+              std::initializer_list<std::pair<const char*, const char*>> options) noexcept
+  : m_instance{vm}
+{
+    // This constructor is implemented outside of the class definition to workaround a doxygen bug.
+    for (const auto& option : options)
+        set_option(option.first, option.second);
+}
+
+
+namespace internal
+{
+inline bool account_exists(evmc_host_context* h, const evmc_address* addr) noexcept
+{
+    return Host::from_context(h)->account_exists(*addr);
+}
+
+inline evmc_bytes32 get_storage(evmc_host_context* h,
+                                const evmc_address* addr,
+                                const evmc_bytes32* key) noexcept
+{
+    return Host::from_context(h)->get_storage(*addr, *key);
+}
+
+inline evmc_storage_status set_storage(evmc_host_context* h,
+                                       const evmc_address* addr,
+                                       const evmc_bytes32* key,
+                                       const evmc_bytes32* value) noexcept
+{
+    return Host::from_context(h)->set_storage(*addr, *key, *value);
+}
+
+inline evmc_uint256be get_balance(evmc_host_context* h, const evmc_address* addr) noexcept
+{
+    return Host::from_context(h)->get_balance(*addr);
+}
+
+inline size_t get_code_size(evmc_host_context* h, const evmc_address* addr) noexcept
+{
+    return Host::from_context(h)->get_code_size(*addr);
+}
+
+inline evmc_bytes32 get_code_hash(evmc_host_context* h, const evmc_address* addr) noexcept
+{
+    return Host::from_context(h)->get_code_hash(*addr);
+}
+
+inline size_t copy_code(evmc_host_context* h,
+                        const evmc_address* addr,
+                        size_t code_offset,
+                        uint8_t* buffer_data,
+                        size_t buffer_size) noexcept
+{
+    return Host::from_context(h)->copy_code(*addr, code_offset, buffer_data, buffer_size);
+}
+
+inline bool selfdestruct(evmc_host_context* h,
+                         const evmc_address* addr,
+                         const evmc_address* beneficiary) noexcept
+{
+    return Host::from_context(h)->selfdestruct(*addr, *beneficiary);
+}
+
+inline evmc_result call(evmc_host_context* h, const evmc_message* msg) noexcept
+{
+    return Host::from_context(h)->call(*msg).release_raw();
+}
+
+inline evmc_tx_context get_tx_context(evmc_host_context* h) noexcept
+{
+    return Host::from_context(h)->get_tx_context();
+}
+
+inline evmc_bytes32 get_block_hash(evmc_host_context* h, int64_t block_number) noexcept
+{
+    return Host::from_context(h)->get_block_hash(block_number);
+}
+
+inline void emit_log(evmc_host_context* h,
+                     const evmc_address* addr,
+                     const uint8_t* data,
+                     size_t data_size,
+                     const evmc_bytes32 topics[],
+                     size_t num_topics) noexcept
+{
+    Host::from_context(h)->emit_log(*addr, data, data_size, static_cast<const bytes32*>(topics),
+                                    num_topics);
+}
+
+inline evmc_access_status access_account(evmc_host_context* h, const evmc_address* addr) noexcept
+{
+    return Host::from_context(h)->access_account(*addr);
+}
+
+inline evmc_access_status access_storage(evmc_host_context* h,
+                                         const evmc_address* addr,
+                                         const evmc_bytes32* key) noexcept
+{
+    return Host::from_context(h)->access_storage(*addr, *key);
+}
+
+inline evmc_bytes32 get_transient_storage(evmc_host_context* h,
+                                          const evmc_address* addr,
+                                          const evmc_bytes32* key) noexcept
+{
+    return Host::from_context(h)->get_transient_storage(*addr, *key);
+}
+
+inline void set_transient_storage(evmc_host_context* h,
+                                  const evmc_address* addr,
+                                  const evmc_bytes32* key,
+                                  const evmc_bytes32* value) noexcept
+{
+    Host::from_context(h)->set_transient_storage(*addr, *key, *value);
+}
+}  // namespace internal
+
+inline const evmc_host_interface& Host::get_interface() noexcept
+{
+    static constexpr evmc_host_interface interface = {
+        ::evmc::internal::account_exists,
+        ::evmc::internal::get_storage,
+        ::evmc::internal::set_storage,
+        ::evmc::internal::get_balance,
+        ::evmc::internal::get_code_size,
+        ::evmc::internal::get_code_hash,
+        ::evmc::internal::copy_code,
+        ::evmc::internal::selfdestruct,
+        ::evmc::internal::call,
+        ::evmc::internal::get_tx_context,
+        ::evmc::internal::get_block_hash,
+        ::evmc::internal::emit_log,
+        ::evmc::internal::access_account,
+        ::evmc::internal::access_storage,
+        ::evmc::internal::get_transient_storage,
+        ::evmc::internal::set_transient_storage,
+    };
+    return interface;
+}
+}  // namespace evmc
+
+
+/// "Stream out" operator implementation for ::evmc_status_code.
+///
+/// @note This is defined in global namespace to match ::evmc_status_code definition and allow
+///       convenient operator overloading usage.
+inline std::ostream& operator<<(std::ostream& os, evmc_status_code status_code)
+{
+    return os << evmc::to_string(status_code);
+}
+
+/// "Stream out" operator implementation for ::evmc_revision.
+///
+/// @note This is defined in global namespace to match ::evmc_revision definition and allow
+///       convenient operator overloading usage.
+inline std::ostream& operator<<(std::ostream& os, evmc_revision rev)
+{
+    return os << evmc::to_string(rev);
+}
+
+namespace std
+{
+/// Hash operator template specialization for evmc::address. Needed for unordered containers.
+template <>
+struct hash<evmc::address>
+{
+    /// Hash operator using FNV1a-based folding.
+    constexpr size_t operator()(const evmc::address& s) const noexcept
+    {
+        using namespace evmc;
+        using namespace fnv;
+        return static_cast<size_t>(fnv1a_by64(
+            fnv1a_by64(fnv1a_by64(fnv::offset_basis, load64le(&s.bytes[0])), load64le(&s.bytes[8])),
+            load32le(&s.bytes[16])));
+    }
+};
+
+/// Hash operator template specialization for evmc::bytes32. Needed for unordered containers.
+template <>
+struct hash<evmc::bytes32>
+{
+    /// Hash operator using FNV1a-based folding.
+    constexpr size_t operator()(const evmc::bytes32& s) const noexcept
+    {
+        using namespace evmc;
+        using namespace fnv;
+        return static_cast<size_t>(
+            fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv1a_by64(fnv::offset_basis, load64le(&s.bytes[0])),
+                                             load64le(&s.bytes[8])),
+                                  load64le(&s.bytes[16])),
+                       load64le(&s.bytes[24])));
+    }
+};
+}  // namespace std
diff --git a/compiler/test/evmc/filter_iterator.hpp b/compiler/test/evmc/filter_iterator.hpp
new file mode 100644
index 00000000..0a349fc9
--- /dev/null
+++ b/compiler/test/evmc/filter_iterator.hpp
@@ -0,0 +1,105 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2022 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+#pragma once
+
+#include <iterator>
+
+namespace evmc
+{
+/// The constexpr variant of std::isspace().
+inline constexpr bool isspace(char ch) noexcept
+{
+    // Implementation taken from LLVM's libc.
+    return ch == ' ' || (static_cast<unsigned>(ch) - '\t') < 5;
+}
+
+/// Checks if a character is not a white space.
+inline constexpr bool is_not_space(char ch) noexcept
+{
+    return !isspace(ch);
+}
+
+/// The filter iterator adaptor creates a view of an iterator range in which some elements of the
+/// range are skipped. A predicate function controls which elements are skipped. When the predicate
+/// is applied to an element, if it returns true then the element is retained and if it returns
+/// false then the element is skipped over. When skipping over elements, it is necessary for the
+/// filter adaptor to know when to stop so as to avoid going past the end of the underlying range.
+/// A filter iterator is therefore constructed with pair of iterators indicating the range of
+/// elements in the unfiltered sequence to be traversed.
+///
+/// Similar to boost::filter_iterator.
+template <typename BaseIterator,
+          bool predicate(typename std::iterator_traits<BaseIterator>::value_type) noexcept>
+struct filter_iterator
+{
+    /// The iterator difference type.
+    using difference_type = typename std::iterator_traits<BaseIterator>::difference_type;
+
+    /// The iterator value type.
+    using value_type = typename std::iterator_traits<BaseIterator>::value_type;
+
+    /// The iterator pointer type.
+    using pointer = typename std::iterator_traits<BaseIterator>::pointer;
+
+    /// The iterator reference type.
+    using reference = typename std::iterator_traits<BaseIterator>::reference;
+
+    /// The iterator category.
+    using iterator_category = std::input_iterator_tag;
+
+private:
+    BaseIterator base;
+    BaseIterator base_end;
+    value_type value;
+
+    constexpr void forward_to_next_value() noexcept
+    {
+        for (; base != base_end; ++base)
+        {
+            value = *base;
+            if (predicate(value))
+                break;
+        }
+    }
+
+public:
+    /// The constructor of the base iterator pair.
+    constexpr filter_iterator(BaseIterator it, BaseIterator end) noexcept : base{it}, base_end{end}
+    {
+        forward_to_next_value();
+    }
+
+    /// The dereference operator.
+    constexpr auto operator*() noexcept
+    {
+        // We should not read from an input base iterator twice. So the only read is in
+        // forward_to_next_value() and here we return the cached value.
+        return value;
+    }
+
+    /// The increment operator.
+    constexpr void operator++() noexcept
+    {
+        ++base;
+        forward_to_next_value();
+    }
+
+    /// The equality operator.
+    constexpr bool operator==(const filter_iterator& o) const noexcept { return base == o.base; }
+
+    /// The inequality operator.
+    constexpr bool operator!=(const filter_iterator& o) const noexcept { return base != o.base; }
+};
+
+/// The input filter iterator which skips whitespace characters from the base input iterator.
+template <typename BaseIterator>
+struct skip_space_iterator : filter_iterator<BaseIterator, is_not_space>
+{
+    using filter_iterator<BaseIterator, is_not_space>::filter_iterator;
+};
+
+/// Class template argument deduction guide.
+template <typename BaseIterator>
+skip_space_iterator(BaseIterator, BaseIterator) -> skip_space_iterator<BaseIterator>;
+}  // namespace evmc
diff --git a/compiler/test/evmc/helpers.h b/compiler/test/evmc/helpers.h
new file mode 100644
index 00000000..683567ef
--- /dev/null
+++ b/compiler/test/evmc/helpers.h
@@ -0,0 +1,315 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2018 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+
+/**
+ * EVMC Helpers
+ *
+ * A collection of C helper functions for invoking a VM instance methods.
+ * These are convenient for languages where invoking function pointers
+ * is "ugly" or impossible (such as Go).
+ *
+ * @defgroup helpers EVMC Helpers
+ * @{
+ */
+#pragma once
+
+#include <evmc/evmc.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+#endif
+
+/**
+ * Returns true if the VM has a compatible ABI version.
+ */
+static inline bool evmc_is_abi_compatible(struct evmc_vm* vm)
+{
+    return vm->abi_version == EVMC_ABI_VERSION;
+}
+
+/**
+ * Returns the name of the VM.
+ */
+static inline const char* evmc_vm_name(struct evmc_vm* vm)
+{
+    return vm->name;
+}
+
+/**
+ * Returns the version of the VM.
+ */
+static inline const char* evmc_vm_version(struct evmc_vm* vm)
+{
+    return vm->version;
+}
+
+/**
+ * Checks if the VM has the given capability.
+ *
+ * @see evmc_get_capabilities_fn
+ */
+static inline bool evmc_vm_has_capability(struct evmc_vm* vm, enum evmc_capabilities capability)
+{
+    return (vm->get_capabilities(vm) & (evmc_capabilities_flagset)capability) != 0;
+}
+
+/**
+ * Destroys the VM instance.
+ *
+ * @see evmc_destroy_fn
+ */
+static inline void evmc_destroy(struct evmc_vm* vm)
+{
+    vm->destroy(vm);
+}
+
+/**
+ * Sets the option for the VM, if the feature is supported by the VM.
+ *
+ * @see evmc_set_option_fn
+ */
+static inline enum evmc_set_option_result evmc_set_option(struct evmc_vm* vm,
+                                                          char const* name,
+                                                          char const* value)
+{
+    if (vm->set_option)
+        return vm->set_option(vm, name, value);
+    return EVMC_SET_OPTION_INVALID_NAME;
+}
+
+/**
+ * Executes code in the VM instance.
+ *
+ * @see evmc_execute_fn.
+ */
+static inline struct evmc_result evmc_execute(struct evmc_vm* vm,
+                                              const struct evmc_host_interface* host,
+                                              struct evmc_host_context* context,
+                                              enum evmc_revision rev,
+                                              const struct evmc_message* msg,
+                                              uint8_t const* code,
+                                              size_t code_size)
+{
+    return vm->execute(vm, host, context, rev, msg, code, code_size);
+}
+
+/// The evmc_result release function using free() for releasing the memory.
+///
+/// This function is used in the evmc_make_result(),
+/// but may be also used in other case if convenient.
+///
+/// @param result The result object.
+static void evmc_free_result_memory(const struct evmc_result* result)
+{
+    free((uint8_t*)result->output_data);
+}
+
+/// Creates the result from the provided arguments.
+///
+/// The provided output is copied to memory allocated with malloc()
+/// and the evmc_result::release function is set to one invoking free().
+///
+/// In case of memory allocation failure, the result has all fields zeroed
+/// and only evmc_result::status_code is set to ::EVMC_OUT_OF_MEMORY internal error.
+///
+/// @param status_code  The status code.
+/// @param gas_left     The amount of gas left.
+/// @param gas_refund   The amount of refunded gas.
+/// @param output_data  The pointer to the output.
+/// @param output_size  The output size.
+static inline struct evmc_result evmc_make_result(enum evmc_status_code status_code,
+                                                  int64_t gas_left,
+                                                  int64_t gas_refund,
+                                                  const uint8_t* output_data,
+                                                  size_t output_size)
+{
+    struct evmc_result result;
+    memset(&result, 0, sizeof(result));
+
+    if (output_size != 0)
+    {
+        uint8_t* buffer = (uint8_t*)malloc(output_size);
+
+        if (!buffer)
+        {
+            result.status_code = EVMC_OUT_OF_MEMORY;
+            return result;
+        }
+
+        memcpy(buffer, output_data, output_size);
+        result.output_data = buffer;
+        result.output_size = output_size;
+        result.release = evmc_free_result_memory;
+    }
+
+    result.status_code = status_code;
+    result.gas_left = gas_left;
+    result.gas_refund = gas_refund;
+    return result;
+}
+
+/**
+ * Releases the resources allocated to the execution result.
+ *
+ * @param result  The result object to be released. MUST NOT be NULL.
+ *
+ * @see evmc_result::release() evmc_release_result_fn
+ */
+static inline void evmc_release_result(struct evmc_result* result)
+{
+    if (result->release)
+        result->release(result);
+}
+
+
+/**
+ * Helpers for optional storage of evmc_result.
+ *
+ * In some contexts (i.e. evmc_result::create_address is unused) objects of
+ * type evmc_result contains a memory storage that MAY be used by the object
+ * owner. This group defines helper types and functions for accessing
+ * the optional storage.
+ *
+ * @defgroup result_optional_storage Result Optional Storage
+ * @{
+ */
+
+/**
+ * The union representing evmc_result "optional storage".
+ *
+ * The evmc_result struct contains 24 bytes of optional storage that can be
+ * reused by the object creator if the object does not contain
+ * evmc_result::create_address.
+ *
+ * A VM implementation MAY use this memory to keep additional data
+ * when returning result from evmc_execute_fn().
+ * The host application MAY use this memory to keep additional data
+ * when returning result of performed calls from evmc_call_fn().
+ *
+ * @see evmc_get_optional_storage(), evmc_get_const_optional_storage().
+ */
+union evmc_result_optional_storage
+{
+    uint8_t bytes[24]; /**< 24 bytes of optional storage. */
+    void* pointer;     /**< Optional pointer. */
+};
+
+/** Provides read-write access to evmc_result "optional storage". */
+static inline union evmc_result_optional_storage* evmc_get_optional_storage(
+    struct evmc_result* result)
+{
+    return (union evmc_result_optional_storage*)&result->create_address;
+}
+
+/** Provides read-only access to evmc_result "optional storage". */
+static inline const union evmc_result_optional_storage* evmc_get_const_optional_storage(
+    const struct evmc_result* result)
+{
+    return (const union evmc_result_optional_storage*)&result->create_address;
+}
+
+/** @} */
+
+/** Returns text representation of the ::evmc_status_code. */
+static inline const char* evmc_status_code_to_string(enum evmc_status_code status_code)
+{
+    switch (status_code)
+    {
+    case EVMC_SUCCESS:
+        return "success";
+    case EVMC_FAILURE:
+        return "failure";
+    case EVMC_REVERT:
+        return "revert";
+    case EVMC_OUT_OF_GAS:
+        return "out of gas";
+    case EVMC_INVALID_INSTRUCTION:
+        return "invalid instruction";
+    case EVMC_UNDEFINED_INSTRUCTION:
+        return "undefined instruction";
+    case EVMC_STACK_OVERFLOW:
+        return "stack overflow";
+    case EVMC_STACK_UNDERFLOW:
+        return "stack underflow";
+    case EVMC_BAD_JUMP_DESTINATION:
+        return "bad jump destination";
+    case EVMC_INVALID_MEMORY_ACCESS:
+        return "invalid memory access";
+    case EVMC_CALL_DEPTH_EXCEEDED:
+        return "call depth exceeded";
+    case EVMC_STATIC_MODE_VIOLATION:
+        return "static mode violation";
+    case EVMC_PRECOMPILE_FAILURE:
+        return "precompile failure";
+    case EVMC_CONTRACT_VALIDATION_FAILURE:
+        return "contract validation failure";
+    case EVMC_ARGUMENT_OUT_OF_RANGE:
+        return "argument out of range";
+    case EVMC_WASM_UNREACHABLE_INSTRUCTION:
+        return "wasm unreachable instruction";
+    case EVMC_WASM_TRAP:
+        return "wasm trap";
+    case EVMC_INSUFFICIENT_BALANCE:
+        return "insufficient balance";
+    case EVMC_INTERNAL_ERROR:
+        return "internal error";
+    case EVMC_REJECTED:
+        return "rejected";
+    case EVMC_OUT_OF_MEMORY:
+        return "out of memory";
+    }
+    return "<unknown>";
+}
+
+/** Returns the name of the ::evmc_revision. */
+static inline const char* evmc_revision_to_string(enum evmc_revision rev)
+{
+    switch (rev)
+    {
+    case EVMC_FRONTIER:
+        return "Frontier";
+    case EVMC_HOMESTEAD:
+        return "Homestead";
+    case EVMC_TANGERINE_WHISTLE:
+        return "Tangerine Whistle";
+    case EVMC_SPURIOUS_DRAGON:
+        return "Spurious Dragon";
+    case EVMC_BYZANTIUM:
+        return "Byzantium";
+    case EVMC_CONSTANTINOPLE:
+        return "Constantinople";
+    case EVMC_PETERSBURG:
+        return "Petersburg";
+    case EVMC_ISTANBUL:
+        return "Istanbul";
+    case EVMC_BERLIN:
+        return "Berlin";
+    case EVMC_LONDON:
+        return "London";
+    case EVMC_PARIS:
+        return "Paris";
+    case EVMC_SHANGHAI:
+        return "Shanghai";
+    case EVMC_CANCUN:
+        return "Cancun";
+    case EVMC_PRAGUE:
+        return "Prague";
+    }
+    return "<unknown>";
+}
+
+/** @} */
+
+#ifdef __cplusplus
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+}  // extern "C"
+#endif
diff --git a/compiler/test/evmc/hex.hpp b/compiler/test/evmc/hex.hpp
new file mode 100644
index 00000000..31bbe519
--- /dev/null
+++ b/compiler/test/evmc/hex.hpp
@@ -0,0 +1,158 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2021 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+#pragma once
+
+#include <evmc/filter_iterator.hpp>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace evmc
+{
+/// String of uint8_t chars.
+using bytes = std::basic_string<uint8_t>;
+
+/// String view of uint8_t chars.
+using bytes_view = std::basic_string_view<uint8_t>;
+
+
+/// Encode a byte to a hex string.
+inline std::string hex(uint8_t b) noexcept
+{
+    static constexpr auto hex_digits = "0123456789abcdef";
+    return {hex_digits[b >> 4], hex_digits[b & 0xf]};
+}
+
+/// Encodes bytes as hex string.
+inline std::string hex(bytes_view bs)
+{
+    std::string str;
+    str.reserve(bs.size() * 2);
+    for (const auto b : bs)
+        str += hex(b);
+    return str;
+}
+
+namespace internal
+{
+/// Extracts the nibble value out of a hex digit.
+/// Returns -1 in case of invalid hex digit.
+inline constexpr int from_hex_digit(char h) noexcept
+{
+    if (h >= '0' && h <= '9')
+        return h - '0';
+    else if (h >= 'a' && h <= 'f')
+        return h - 'a' + 10;
+    else if (h >= 'A' && h <= 'F')
+        return h - 'A' + 10;
+    else
+        return -1;
+}
+}  // namespace internal
+
+/// Decodes hex-encoded sequence of characters.
+///
+/// It is guaranteed that the output will not be longer than half of the input length.
+///
+/// @param begin  The input begin iterator. It only must satisfy input iterator concept.
+/// @param end    The input end iterator. It only must satisfy input iterator concept.
+/// @param out    The output iterator. It must satisfy output iterator concept.
+/// @return       True if successful, false if input is invalid hex.
+template <typename InputIt, typename OutputIt>
+inline constexpr bool from_hex(InputIt begin, InputIt end, OutputIt out) noexcept
+{
+    int hi_nibble = -1;  // Init with invalid value, should never be used.
+    size_t i = 0;
+    for (auto it = begin; it != end; ++it, ++i)
+    {
+        const auto h = *it;
+        const int v = evmc::internal::from_hex_digit(h);
+        if (v < 0)
+        {
+            if (i == 1 && hi_nibble == 0 && h == 'x')  // 0x prefix
+                continue;
+            return false;
+        }
+
+        if (i % 2 == 0)
+            hi_nibble = v << 4;
+        else
+            *out++ = static_cast<uint8_t>(hi_nibble | v);
+    }
+
+    return i % 2 == 0;
+}
+
+/// Validates hex encoded string.
+///
+/// @return  True if the input is valid hex.
+inline bool validate_hex(std::string_view hex) noexcept
+{
+    struct noop_output_iterator
+    {
+        uint8_t sink = {};
+        uint8_t& operator*() noexcept { return sink; }
+        noop_output_iterator operator++(int) noexcept { return *this; }  // NOLINT(cert-dcl21-cpp)
+    };
+
+    return from_hex(hex.begin(), hex.end(), noop_output_iterator{});
+}
+
+/// Decodes hex encoded string to bytes.
+///
+/// In case the input is invalid the returned value is std::nullopt.
+/// This can happen if a non-hex digit or odd number of digits is encountered.
+inline std::optional<bytes> from_hex(std::string_view hex)
+{
+    bytes bs;
+    bs.reserve(hex.size() / 2);
+    if (!from_hex(hex.begin(), hex.end(), std::back_inserter(bs)))
+        return {};
+    return bs;
+}
+
+/// Decodes hex-encoded string into custom type T with .bytes array of uint8_t.
+///
+/// When the input is smaller than the result type, the result is padded with zeros on the left
+/// (the result bytes of lowest indices are filled with zeros).
+/// TODO: Support optional left alignment.
+template <typename T>
+constexpr std::optional<T> from_hex(std::string_view s) noexcept
+{
+    // Omit the optional 0x prefix.
+    if (s.size() >= 2 && s[0] == '0' && s[1] == 'x')
+        s.remove_prefix(2);
+
+    T r{};  // The T must have .bytes array. This may be lifted if std::bit_cast is available.
+    constexpr auto num_out_bytes = std::size(r.bytes);
+    const auto num_in_bytes = s.length() / 2;
+    if (num_in_bytes > num_out_bytes)
+        return {};
+    if (!from_hex(s.begin(), s.end(), &r.bytes[num_out_bytes - num_in_bytes]))
+        return {};
+    return r;
+}
+
+/// Decodes hex encoded string to bytes. The whitespace in the input is ignored.
+///
+/// In case the input is invalid the returned value is std::nullopt.
+/// This can happen if a non-hex digit or odd number of digits is encountered.
+/// The whitespace (as defined by std::isspace) in the input is ignored.
+template <typename InputIterator>
+std::optional<bytes> from_spaced_hex(InputIterator begin, InputIterator end) noexcept
+{
+    bytes bs;
+    if (!from_hex(skip_space_iterator{begin, end}, skip_space_iterator{end, end},
+                  std::back_inserter(bs)))
+        return {};
+    return bs;
+}
+
+/// @copydoc from_spaced_hex
+inline std::optional<bytes> from_spaced_hex(std::string_view hex) noexcept
+{
+    return from_spaced_hex(hex.begin(), hex.end());
+}
+}  // namespace evmc
diff --git a/compiler/test/evmc/loader.c b/compiler/test/evmc/loader.c
new file mode 100644
index 00000000..141b1d4f
--- /dev/null
+++ b/compiler/test/evmc/loader.c
@@ -0,0 +1,322 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2018 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+
+#include <evmc/loader.h>
+
+#include <evmc/evmc.h>
+#include <evmc/helpers.h>
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(EVMC_LOADER_MOCK)
+#include "../../test/unittests/loader_mock.h"
+#elif defined(_WIN32)
+#include <Windows.h>
+#define DLL_HANDLE HMODULE
+#define DLL_OPEN(filename) LoadLibrary(filename)
+#define DLL_CLOSE(handle) FreeLibrary(handle)
+#define DLL_GET_CREATE_FN(handle, name) (evmc_create_fn)(uintptr_t) GetProcAddress(handle, name)
+#define DLL_GET_ERROR_MSG() NULL
+#else
+#include <dlfcn.h>
+#define DLL_HANDLE void*
+#define DLL_OPEN(filename) dlopen(filename, RTLD_LAZY)
+#define DLL_CLOSE(handle) dlclose(handle)
+// NOLINTNEXTLINE(performance-no-int-to-ptr)
+#define DLL_GET_CREATE_FN(handle, name) (evmc_create_fn)(uintptr_t) dlsym(handle, name)
+#define DLL_GET_ERROR_MSG() dlerror()
+#endif
+
+#ifdef __has_attribute
+#if __has_attribute(format)
+#define ATTR_FORMAT(archetype, string_index, first_to_check) \
+    __attribute__((format(archetype, string_index, first_to_check)))
+#endif
+#endif
+
+#ifndef ATTR_FORMAT
+#define ATTR_FORMAT(...)
+#endif
+
+/*
+ * Limited variant of strcpy_s().
+ */
+#if !defined(EVMC_LOADER_MOCK)
+static
+#endif
+    int
+    strcpy_sx(char* dest, size_t destsz, const char* src)
+{
+    size_t len = strlen(src);
+    if (len >= destsz)
+    {
+        // The input src will not fit into the dest buffer.
+        // Set the first byte of the dest to null to make it effectively empty string
+        // and return error.
+        dest[0] = 0;
+        return 1;
+    }
+    // NOLINTNEXTLINE(clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+    memcpy(dest, src, len);
+    dest[len] = 0;
+    return 0;
+}
+
+enum
+{
+    PATH_MAX_LENGTH = 4096,
+    LAST_ERROR_MSG_BUFFER_SIZE = 511
+};
+
+static const char* last_error_msg = NULL;
+
+// Buffer for formatted error messages.
+// It has one null byte extra to avoid buffer read overflow during concurrent access.
+static char last_error_msg_buffer[LAST_ERROR_MSG_BUFFER_SIZE + 1];
+
+ATTR_FORMAT(printf, 2, 3)
+static enum evmc_loader_error_code set_error(enum evmc_loader_error_code error_code,
+                                             const char* format,
+                                             ...)
+{
+    va_list args;
+    va_start(args, format);
+    // NOLINTNEXTLINE(clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling)
+    if (vsnprintf(last_error_msg_buffer, LAST_ERROR_MSG_BUFFER_SIZE, format, args) <
+        LAST_ERROR_MSG_BUFFER_SIZE)
+        last_error_msg = last_error_msg_buffer;
+    va_end(args);
+    return error_code;
+}
+
+
+evmc_create_fn evmc_load(const char* filename, enum evmc_loader_error_code* error_code)
+{
+    last_error_msg = NULL;  // Reset last error.
+    enum evmc_loader_error_code ec = EVMC_LOADER_SUCCESS;
+    evmc_create_fn create_fn = NULL;
+
+    if (!filename)
+    {
+        ec = set_error(EVMC_LOADER_INVALID_ARGUMENT, "invalid argument: file name cannot be null");
+        goto exit;
+    }
+
+    const size_t length = strlen(filename);
+    if (length == 0)
+    {
+        ec = set_error(EVMC_LOADER_INVALID_ARGUMENT, "invalid argument: file name cannot be empty");
+        goto exit;
+    }
+    else if (length > PATH_MAX_LENGTH)
+    {
+        ec = set_error(EVMC_LOADER_INVALID_ARGUMENT,
+                       "invalid argument: file name is too long (%d, maximum allowed length is %d)",
+                       (int)length, PATH_MAX_LENGTH);
+        goto exit;
+    }
+
+    DLL_HANDLE handle = DLL_OPEN(filename);
+    if (!handle)
+    {
+        // Get error message if available.
+        last_error_msg = DLL_GET_ERROR_MSG();
+        if (last_error_msg)
+            ec = EVMC_LOADER_CANNOT_OPEN;
+        else
+            ec = set_error(EVMC_LOADER_CANNOT_OPEN, "cannot open %s", filename);
+        goto exit;
+    }
+
+    // Create name buffer with the prefix.
+    const char prefix[] = "evmc_create_";
+    const size_t prefix_length = strlen(prefix);
+    char prefixed_name[sizeof(prefix) + PATH_MAX_LENGTH];
+    strcpy_sx(prefixed_name, sizeof(prefixed_name), prefix);
+
+    // Find filename in the path.
+    const char* sep_pos = strrchr(filename, '/');
+#ifdef _WIN32
+    // On Windows check also Windows classic path separator.
+    const char* sep_pos_windows = strrchr(filename, '\\');
+    sep_pos = sep_pos_windows > sep_pos ? sep_pos_windows : sep_pos;
+#endif
+    const char* name_pos = sep_pos ? sep_pos + 1 : filename;
+
+    // Skip "lib" prefix if present.
+    const char lib_prefix[] = "lib";
+    const size_t lib_prefix_length = strlen(lib_prefix);
+    if (strncmp(name_pos, lib_prefix, lib_prefix_length) == 0)
+        name_pos += lib_prefix_length;
+
+    char* base_name = prefixed_name + prefix_length;
+    strcpy_sx(base_name, PATH_MAX_LENGTH, name_pos);
+
+    // Trim all file extensions.
+    char* ext_pos = strchr(prefixed_name, '.');
+    if (ext_pos)
+        *ext_pos = 0;
+
+    // Replace all "-" with "_".
+    char* dash_pos = base_name;
+    while ((dash_pos = strchr(dash_pos, '-')) != NULL)
+        *dash_pos++ = '_';
+
+    // Search for the built function name.
+    create_fn = DLL_GET_CREATE_FN(handle, prefixed_name);
+
+    if (!create_fn)
+        create_fn = DLL_GET_CREATE_FN(handle, "evmc_create");
+
+    if (!create_fn)
+    {
+        DLL_CLOSE(handle);
+        ec = set_error(EVMC_LOADER_SYMBOL_NOT_FOUND, "EVMC create function not found in %s",
+                       filename);
+    }
+
+exit:
+    if (error_code)
+        *error_code = ec;
+    return create_fn;
+}
+
+const char* evmc_last_error_msg(void)
+{
+    const char* m = last_error_msg;
+    last_error_msg = NULL;
+    return m;
+}
+
+struct evmc_vm* evmc_load_and_create(const char* filename, enum evmc_loader_error_code* error_code)
+{
+    // First load the DLL. This also resets the last_error_msg;
+    evmc_create_fn create_fn = evmc_load(filename, error_code);
+
+    if (!create_fn)
+        return NULL;
+
+    enum evmc_loader_error_code ec = EVMC_LOADER_SUCCESS;
+
+    struct evmc_vm* vm = create_fn();
+    if (!vm)
+    {
+        ec = set_error(EVMC_LOADER_VM_CREATION_FAILURE, "creating EVMC VM of %s has failed",
+                       filename);
+        goto exit;
+    }
+
+    if (!evmc_is_abi_compatible(vm))
+    {
+        ec = set_error(EVMC_LOADER_ABI_VERSION_MISMATCH,
+                       "EVMC ABI version %d of %s mismatches the expected version %d",
+                       vm->abi_version, filename, EVMC_ABI_VERSION);
+        evmc_destroy(vm);
+        vm = NULL;
+        goto exit;
+    }
+
+exit:
+    if (error_code)
+        *error_code = ec;
+
+    return vm;
+}
+
+/// Gets the token delimited by @p delim character of the string pointed by the @p str_ptr.
+/// If the delimiter is not found, the whole string is returned.
+/// The @p str_ptr is also slided after the delimiter or to the string end
+/// if the delimiter is not found (in this case the @p str_ptr points to an empty string).
+static char* get_token(char** str_ptr, char delim)
+{
+    char* str = *str_ptr;
+    char* delim_pos = strchr(str, delim);
+    if (delim_pos)
+    {
+        // If the delimiter is found, null it to get null-terminated prefix
+        // and slide the str_ptr after the delimiter.
+        *delim_pos = '\0';
+        *str_ptr = delim_pos + 1;
+    }
+    else
+    {
+        // Otherwise, slide the str_ptr to the end and return the whole string as the prefix.
+        *str_ptr += strlen(str);
+    }
+    return str;
+}
+
+struct evmc_vm* evmc_load_and_configure(const char* config, enum evmc_loader_error_code* error_code)
+{
+    enum evmc_loader_error_code ec = EVMC_LOADER_SUCCESS;
+    struct evmc_vm* vm = NULL;
+
+    char config_copy_buffer[PATH_MAX_LENGTH];
+    if (strcpy_sx(config_copy_buffer, sizeof(config_copy_buffer), config) != 0)
+    {
+        ec = set_error(EVMC_LOADER_INVALID_ARGUMENT,
+                       "invalid argument: configuration is too long (maximum allowed length is %d)",
+                       (int)sizeof(config_copy_buffer));
+        goto exit;
+    }
+
+    char* options = config_copy_buffer;
+    const char* path = get_token(&options, ',');
+
+    vm = evmc_load_and_create(path, error_code);
+    if (!vm)
+        return NULL;
+
+    while (strlen(options) != 0)
+    {
+        if (vm->set_option == NULL)
+        {
+            ec = set_error(EVMC_LOADER_INVALID_OPTION_NAME, "%s (%s) does not support any options",
+                           vm->name, path);
+            goto exit;
+        }
+
+        char* option = get_token(&options, ',');
+
+        // Slit option into name and value by taking the name token.
+        // The option variable will have the value, can be empty.
+        const char* name = get_token(&option, '=');
+
+        enum evmc_set_option_result r = vm->set_option(vm, name, option);
+        switch (r)
+        {
+        case EVMC_SET_OPTION_SUCCESS:
+            break;
+        case EVMC_SET_OPTION_INVALID_NAME:
+            ec = set_error(EVMC_LOADER_INVALID_OPTION_NAME, "%s (%s): unknown option '%s'",
+                           vm->name, path, name);
+            goto exit;
+        case EVMC_SET_OPTION_INVALID_VALUE:
+            ec = set_error(EVMC_LOADER_INVALID_OPTION_VALUE,
+                           "%s (%s): unsupported value '%s' for option '%s'", vm->name, path,
+                           option, name);
+            goto exit;
+
+        default:
+            ec = set_error(EVMC_LOADER_INVALID_OPTION_VALUE,
+                           "%s (%s): unknown error when setting value '%s' for option '%s'",
+                           vm->name, path, option, name);
+            goto exit;
+        }
+    }
+
+exit:
+    if (error_code)
+        *error_code = ec;
+
+    if (ec == EVMC_LOADER_SUCCESS)
+        return vm;
+
+    if (vm)
+        evmc_destroy(vm);
+    return NULL;
+}
diff --git a/compiler/test/evmc/loader.h b/compiler/test/evmc/loader.h
new file mode 100644
index 00000000..c5ee7e3a
--- /dev/null
+++ b/compiler/test/evmc/loader.h
@@ -0,0 +1,176 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2018 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+
+/**
+ * EVMC Loader Library
+ *
+ * The EVMC Loader Library supports loading VMs implemented as Dynamically Loaded Libraries
+ * (DLLs, shared objects).
+ *
+ * @defgroup loader EVMC Loader
+ * @{
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** The function pointer type for EVMC create functions. */
+typedef struct evmc_vm* (*evmc_create_fn)(void);
+
+/// Error codes for the EVMC loader.
+///
+/// Objects of this type SHOULD be initialized with ::EVMC_LOADER_UNSPECIFIED_ERROR
+/// before passing to the EVMC loader.
+enum evmc_loader_error_code
+{
+    /** The loader succeeded. */
+    EVMC_LOADER_SUCCESS = 0,
+
+    /** The loader cannot open the given file name. */
+    EVMC_LOADER_CANNOT_OPEN = 1,
+
+    /** The VM create function not found. */
+    EVMC_LOADER_SYMBOL_NOT_FOUND = 2,
+
+    /** The invalid argument value provided. */
+    EVMC_LOADER_INVALID_ARGUMENT = 3,
+
+    /** The creation of a VM instance has failed. */
+    EVMC_LOADER_VM_CREATION_FAILURE = 4,
+
+    /** The ABI version of the VM instance has mismatched. */
+    EVMC_LOADER_ABI_VERSION_MISMATCH = 5,
+
+    /** The VM option is invalid. */
+    EVMC_LOADER_INVALID_OPTION_NAME = 6,
+
+    /** The VM option value is invalid. */
+    EVMC_LOADER_INVALID_OPTION_VALUE = 7,
+
+    /// This error value will be never returned by the EVMC loader,
+    /// but can be used by users to init evmc_loader_error_code objects.
+    EVMC_LOADER_UNSPECIFIED_ERROR = -1
+};
+
+/**
+ * Dynamically loads the EVMC module with a VM implementation.
+ *
+ * This function tries to open a dynamically loaded library (DLL) at the given `filename`.
+ * On UNIX-like systems dlopen() function is used. On Windows LoadLibrary() function is used.
+ *
+ * If the file does not exist or is not a valid shared library the ::EVMC_LOADER_CANNOT_OPEN error
+ * code is signaled and NULL is returned.
+ *
+ * After the DLL is successfully loaded the function tries to find the EVM create function in the
+ * library. The `filename` is used to guess the EVM name and the name of the create function.
+ * The create function name is constructed by the following rules. Consider example path:
+ * "/ethereum/libexample-interpreter.so.1.0".
+ * - the filename is taken from the path:
+ *   "libexample-interpreter.so.1.0",
+ * - the "lib" prefix and all file extensions are stripped from the name:
+ *   "example-interpreter"
+ * - all "-" are replaced with "_" to construct _base name_:
+ *   "example_interpreter",
+ * - the function name "evmc_create_" + _base name_ is searched in the library:
+ *   "evmc_create_example_interpreter",
+ * - if the function is not found, the function name "evmc_create" is searched in the library.
+ *
+ * If the create function is found in the library, the pointer to the function is returned.
+ * Otherwise, the ::EVMC_LOADER_SYMBOL_NOT_FOUND error code is signaled and NULL is returned.
+ *
+ * It is safe to call this function with the same filename argument multiple times
+ * (the DLL is not going to be loaded multiple times).
+ *
+ * @param filename    The null terminated path (absolute or relative) to an EVMC module
+ *                    (dynamically loaded library) containing the VM implementation.
+ *                    If the value is NULL, an empty C-string or longer than the path maximum length
+ *                    the ::EVMC_LOADER_INVALID_ARGUMENT is signaled.
+ * @param error_code  The pointer to the error code. If not NULL the value is set to
+ *                    ::EVMC_LOADER_SUCCESS on success or any other error code as described above.
+ * @return            The pointer to the EVM create function or NULL in case of error.
+ */
+evmc_create_fn evmc_load(const char* filename, enum evmc_loader_error_code* error_code);
+
+/**
+ * Dynamically loads the EVMC module and creates the VM instance.
+ *
+ * This is a macro for creating the VM instance with the function returned from evmc_load().
+ * The function signals the same errors as evmc_load() and additionally:
+ * - ::EVMC_LOADER_VM_CREATION_FAILURE when the create function returns NULL,
+ * - ::EVMC_LOADER_ABI_VERSION_MISMATCH when the created VM instance has ABI version different
+ *   from the ABI version of this library (::EVMC_ABI_VERSION).
+ *
+ * It is safe to call this function with the same filename argument multiple times:
+ * the DLL is not going to be loaded multiple times, but the function will return new VM instance
+ * each time.
+ *
+ * @param filename    The null terminated path (absolute or relative) to an EVMC module
+ *                    (dynamically loaded library) containing the VM implementation.
+ *                    If the value is NULL, an empty C-string or longer than the path maximum length
+ *                    the ::EVMC_LOADER_INVALID_ARGUMENT is signaled.
+ * @param error_code  The pointer to the error code. If not NULL the value is set to
+ *                    ::EVMC_LOADER_SUCCESS on success or any other error code as described above.
+ * @return            The pointer to the created VM or NULL in case of error.
+ */
+struct evmc_vm* evmc_load_and_create(const char* filename, enum evmc_loader_error_code* error_code);
+
+/**
+ * Dynamically loads the EVMC module, then creates and configures the VM instance.
+ *
+ * This function performs the following actions atomically:
+ * - loads the EVMC module (as evmc_load()),
+ * - creates the VM instance,
+ * - configures the VM instance with options provided in the @p config parameter.
+ *
+ * The configuration string (@p config) has the following syntax:
+ *
+ *     <path> ("," <option-name> ["=" <option-value>])*
+ *
+ * In this syntax, an option without a value can be specified (`,option,`)
+ * as a shortcut for using empty value (`,option=,`).
+ *
+ * Options are passed to a VM in the order they are specified in the configuration string.
+ * It is up to the VM implementation how to handle duplicated options and other conflicts.
+ *
+ * Example configuration string:
+ *
+ *     ./modules/vm.so,engine=compiler,trace,verbosity=2
+ *
+ * The function signals the same errors as evmc_load_and_create() and additionally:
+ * - ::EVMC_LOADER_INVALID_OPTION_NAME
+ *   when the provided options list contains an option unknown for the VM,
+ * - ::EVMC_LOADER_INVALID_OPTION_VALUE
+ *   when there exists unsupported value for a given VM option.
+
+ *
+ * @param config      The path to the EVMC module with additional configuration options.
+ * @param error_code  The pointer to the error code. If not NULL the value is set to
+ *                    ::EVMC_LOADER_SUCCESS on success or any other error code as described above.
+ * @return            The pointer to the created VM or NULL in case of error.
+ */
+struct evmc_vm* evmc_load_and_configure(const char* config,
+                                        enum evmc_loader_error_code* error_code);
+
+/**
+ * Returns the human-readable message describing the most recent error
+ * that occurred in EVMC loading since the last call to this function.
+ *
+ * In case any loading function returned ::EVMC_LOADER_SUCCESS this function always returns NULL.
+ * In case of error code other than success returned, this function MAY return the error message.
+ * Calling this function "consumes" the error message and the function will return NULL
+ * from subsequent invocations.
+ * This function is not thread-safe.
+ *
+ * @return Error message or NULL if no additional information is available.
+ *         The returned pointer MUST NOT be freed by the caller.
+ */
+const char* evmc_last_error_msg(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
diff --git a/compiler/test/evmc/mocked_host.hpp b/compiler/test/evmc/mocked_host.hpp
new file mode 100644
index 00000000..205a136b
--- /dev/null
+++ b/compiler/test/evmc/mocked_host.hpp
@@ -0,0 +1,515 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2019 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+#pragma once
+
+#include <evmc/evmc.hpp>
+#include <algorithm>
+#include <cassert>
+#include <map>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace evmc
+{
+/// The string of bytes.
+using bytes = std::basic_string<uint8_t>;
+
+/// Extended value (with original value and access flag) for account storage.
+struct StorageValue
+{
+    /// The current storage value.
+    bytes32 current;
+
+    /// The original storage value.
+    bytes32 original;
+
+    /// Is the storage key cold or warm.
+    evmc_access_status access_status = EVMC_ACCESS_COLD;
+
+    /// Default constructor.
+    StorageValue() noexcept = default;
+
+    /// Constructor sets the current and original to the same value. Optional access status.
+    StorageValue(const bytes32& _value,  // NOLINT(hicpp-explicit-conversions)
+                 evmc_access_status _access_status = EVMC_ACCESS_COLD) noexcept
+      : current{_value}, original{_value}, access_status{_access_status}
+    {}
+
+    /// Constructor with original value and optional access status
+    StorageValue(const bytes32& _value,
+                 const bytes32& _original,
+                 evmc_access_status _access_status = EVMC_ACCESS_COLD) noexcept
+      : current{_value}, original{_original}, access_status{_access_status}
+    {}
+};
+
+/// Mocked account.
+struct MockedAccount
+{
+    /// The account nonce.
+    int nonce = 0;
+
+    /// The account code.
+    bytes code;
+
+    /// The code hash. Can be a value not related to the actual code.
+    bytes32 codehash;
+
+    /// The account balance.
+    uint256be balance;
+
+    /// The account storage map.
+    std::map<bytes32, StorageValue> storage;
+
+    /// The account transient storage.
+    std::unordered_map<bytes32, bytes32> transient_storage;
+
+    /// Helper method for setting balance by numeric type.
+    void set_balance(uint64_t x) noexcept
+    {
+        balance = uint256be{};
+        for (std::size_t i = 0; i < sizeof(x); ++i)
+            balance.bytes[sizeof(balance) - 1 - i] = static_cast<uint8_t>(x >> (8 * i));
+    }
+};
+
+/// Mocked EVMC Host implementation.
+class MockedHost : public Host
+{
+public:
+    /// LOG record.
+    struct log_record
+    {
+        /// The address of the account which created the log.
+        address creator;
+
+        /// The data attached to the log.
+        bytes data;
+
+        /// The log topics.
+        std::vector<bytes32> topics;
+
+        /// Equal operator.
+        bool operator==(const log_record& other) const noexcept
+        {
+            return creator == other.creator && data == other.data && topics == other.topics;
+        }
+    };
+
+    /// The set of all accounts in the Host, organized by their addresses.
+    std::unordered_map<address, MockedAccount> accounts;
+
+    /// The EVMC transaction context to be returned by get_tx_context().
+    evmc_tx_context tx_context = {};
+
+    /// The block header hash value to be returned by get_block_hash().
+    bytes32 block_hash = {};
+
+    /// The call result to be returned by the call() method.
+    evmc_result call_result = {};
+
+    /// The record of all block numbers for which get_block_hash() was called.
+    mutable std::vector<int64_t> recorded_blockhashes;
+
+    /// The record of all account accesses.
+    mutable std::vector<address> recorded_account_accesses;
+
+    /// The maximum number of entries in recorded_account_accesses record.
+    /// This is arbitrary value useful in fuzzing when we don't want the record to explode.
+    static constexpr auto max_recorded_account_accesses = 200;
+
+    /// The record of all call messages requested in the call() method.
+    std::vector<evmc_message> recorded_calls;
+
+    /// The maximum number of entries in recorded_calls record.
+    /// This is arbitrary value useful in fuzzing when we don't want the record to explode.
+    static constexpr auto max_recorded_calls = 100;
+
+    /// The record of all LOGs passed to the emit_log() method.
+    std::vector<log_record> recorded_logs;
+
+    /// The record of all SELFDESTRUCTs from the selfdestruct() method
+    /// as a map selfdestructed_address => [beneficiary1, beneficiary2, ...].
+    std::unordered_map<address, std::vector<address>> recorded_selfdestructs;
+
+private:
+    /// The copy of call inputs for the recorded_calls record.
+    std::vector<bytes> m_recorded_calls_inputs;
+
+    /// Record an account access.
+    /// @param addr  The address of the accessed account.
+    void record_account_access(const address& addr) const
+    {
+        if (recorded_account_accesses.empty())
+            recorded_account_accesses.reserve(max_recorded_account_accesses);
+
+        if (recorded_account_accesses.size() < max_recorded_account_accesses)
+            recorded_account_accesses.emplace_back(addr);
+    }
+
+public:
+    /// Returns true if an account exists (EVMC Host method).
+    bool account_exists(const address& addr) const noexcept override
+    {
+        record_account_access(addr);
+        return accounts.count(addr) != 0;
+    }
+
+    /// Get the account's storage value at the given key (EVMC Host method).
+    bytes32 get_storage(const address& addr, const bytes32& key) const noexcept override
+    {
+        record_account_access(addr);
+
+        const auto account_iter = accounts.find(addr);
+        if (account_iter == accounts.end())
+            return {};
+
+        const auto storage_iter = account_iter->second.storage.find(key);
+        if (storage_iter != account_iter->second.storage.end())
+            return storage_iter->second.current;
+        return {};
+    }
+
+    /// Set the account's storage value (EVMC Host method).
+    evmc_storage_status set_storage(const address& addr,
+                                    const bytes32& key,
+                                    const bytes32& value) noexcept override
+    {
+        record_account_access(addr);
+
+        // Get the reference to the storage entry value.
+        // This will create the account in case it was not present.
+        // This is convenient for unit testing and standalone EVM execution to preserve the
+        // storage values after the execution terminates.
+        auto& s = accounts[addr].storage[key];
+
+        // Follow the EIP-2200 specification as closely as possible.
+        // https://eips.ethereum.org/EIPS/eip-2200
+        // Warning: this is not the most efficient implementation. The storage status can be
+        // figured out by combining only 4 checks:
+        // - original != current (dirty)
+        // - original == value (restored)
+        // - current != 0
+        // - value != 0
+        const auto status = [&original = s.original, &current = s.current, &value]() {
+            // Clause 1 is irrelevant:
+            // 1. "If gasleft is less than or equal to gas stipend,
+            //    fail the current call frame with ‘out of gas’ exception"
+
+            // 2. "If current value equals new value (this is a no-op)"
+            if (current == value)
+            {
+                // "SLOAD_GAS is deducted"
+                return EVMC_STORAGE_ASSIGNED;
+            }
+            // 3. "If current value does not equal new value"
+            else
+            {
+                // 3.1. "If original value equals current value
+                //      (this storage slot has not been changed by the current execution context)"
+                if (original == current)
+                {
+                    // 3.1.1 "If original value is 0"
+                    if (is_zero(original))
+                    {
+                        // "SSTORE_SET_GAS is deducted"
+                        return EVMC_STORAGE_ADDED;
+                    }
+                    // 3.1.2 "Otherwise"
+                    else
+                    {
+                        // "SSTORE_RESET_GAS gas is deducted"
+                        auto st = EVMC_STORAGE_MODIFIED;
+
+                        // "If new value is 0"
+                        if (is_zero(value))
+                        {
+                            // "add SSTORE_CLEARS_SCHEDULE gas to refund counter"
+                            st = EVMC_STORAGE_DELETED;
+                        }
+
+                        return st;
+                    }
+                }
+                // 3.2. "If original value does not equal current value
+                //      (this storage slot is dirty),
+                //      SLOAD_GAS gas is deducted.
+                //      Apply both of the following clauses."
+                else
+                {
+                    // Because we need to apply "both following clauses"
+                    // we first collect information which clause is triggered
+                    // then assign status code to combination of these clauses.
+                    enum
+                    {
+                        None = 0,
+                        RemoveClearsSchedule = 1 << 0,
+                        AddClearsSchedule = 1 << 1,
+                        RestoredBySet = 1 << 2,
+                        RestoredByReset = 1 << 3,
+                    };
+                    int triggered_clauses = None;
+
+                    // 3.2.1. "If original value is not 0"
+                    if (!is_zero(original))
+                    {
+                        // 3.2.1.1. "If current value is 0"
+                        if (is_zero(current))
+                        {
+                            // "(also means that new value is not 0)"
+                            assert(!is_zero(value));
+                            // "remove SSTORE_CLEARS_SCHEDULE gas from refund counter"
+                            triggered_clauses |= RemoveClearsSchedule;
+                        }
+                        // 3.2.1.2. "If new value is 0"
+                        if (is_zero(value))
+                        {
+                            // "(also means that current value is not 0)"
+                            assert(!is_zero(current));
+                            // "add SSTORE_CLEARS_SCHEDULE gas to refund counter"
+                            triggered_clauses |= AddClearsSchedule;
+                        }
+                    }
+
+                    // 3.2.2. "If original value equals new value (this storage slot is reset)"
+                    // Except: we use term 'storage slot restored'.
+                    if (original == value)
+                    {
+                        // 3.2.2.1. "If original value is 0"
+                        if (is_zero(original))
+                        {
+                            // "add SSTORE_SET_GAS - SLOAD_GAS to refund counter"
+                            triggered_clauses |= RestoredBySet;
+                        }
+                        // 3.2.2.2. "Otherwise"
+                        else
+                        {
+                            // "add SSTORE_RESET_GAS - SLOAD_GAS gas to refund counter"
+                            triggered_clauses |= RestoredByReset;
+                        }
+                    }
+
+                    switch (triggered_clauses)
+                    {
+                    case RemoveClearsSchedule:
+                        return EVMC_STORAGE_DELETED_ADDED;
+                    case AddClearsSchedule:
+                        return EVMC_STORAGE_MODIFIED_DELETED;
+                    case RemoveClearsSchedule | RestoredByReset:
+                        return EVMC_STORAGE_DELETED_RESTORED;
+                    case RestoredBySet:
+                        return EVMC_STORAGE_ADDED_DELETED;
+                    case RestoredByReset:
+                        return EVMC_STORAGE_MODIFIED_RESTORED;
+                    case None:
+                        return EVMC_STORAGE_ASSIGNED;
+                    default:
+                        assert(false);  // Other combinations are impossible.
+                        return evmc_storage_status{};
+                    }
+                }
+            }
+        }();
+
+        s.current = value;  // Finally update the current storage value.
+        return status;
+    }
+
+    /// Get the account's balance (EVMC Host method).
+    uint256be get_balance(const address& addr) const noexcept override
+    {
+        record_account_access(addr);
+        const auto it = accounts.find(addr);
+        if (it == accounts.end())
+            return {};
+
+        return it->second.balance;
+    }
+
+    /// Get the account's code size (EVMC host method).
+    size_t get_code_size(const address& addr) const noexcept override
+    {
+        record_account_access(addr);
+        const auto it = accounts.find(addr);
+        if (it == accounts.end())
+            return 0;
+        return it->second.code.size();
+    }
+
+    /// Get the account's code hash (EVMC host method).
+    bytes32 get_code_hash(const address& addr) const noexcept override
+    {
+        record_account_access(addr);
+        const auto it = accounts.find(addr);
+        if (it == accounts.end())
+            return {};
+        return it->second.codehash;
+    }
+
+    /// Copy the account's code to the given buffer (EVMC host method).
+    size_t copy_code(const address& addr,
+                     size_t code_offset,
+                     uint8_t* buffer_data,
+                     size_t buffer_size) const noexcept override
+    {
+        record_account_access(addr);
+        const auto it = accounts.find(addr);
+        if (it == accounts.end())
+            return 0;
+
+        const auto& code = it->second.code;
+
+        if (code_offset >= code.size())
+            return 0;
+
+        const auto n = std::min(buffer_size, code.size() - code_offset);
+
+        if (n > 0)
+            std::copy_n(&code[code_offset], n, buffer_data);
+        return n;
+    }
+
+    /// Selfdestruct the account (EVMC host method).
+    bool selfdestruct(const address& addr, const address& beneficiary) noexcept override
+    {
+        record_account_access(addr);
+        auto& beneficiaries = recorded_selfdestructs[addr];
+        beneficiaries.emplace_back(beneficiary);
+        return beneficiaries.size() == 1;
+    }
+
+    /// Call/create other contract (EVMC host method).
+    Result call(const evmc_message& msg) noexcept override
+    {
+        record_account_access(msg.recipient);
+
+        if (recorded_calls.empty())
+        {
+            recorded_calls.reserve(max_recorded_calls);
+            m_recorded_calls_inputs.reserve(max_recorded_calls);  // Iterators will not invalidate.
+        }
+
+        if (recorded_calls.size() < max_recorded_calls)
+        {
+            recorded_calls.emplace_back(msg);
+            auto& call_msg = recorded_calls.back();
+            if (call_msg.input_size > 0)
+            {
+                m_recorded_calls_inputs.emplace_back(call_msg.input_data, call_msg.input_size);
+                const auto& input_copy = m_recorded_calls_inputs.back();
+                call_msg.input_data = input_copy.data();
+            }
+        }
+        return Result{call_result};
+    }
+
+    /// Get transaction context (EVMC host method).
+    evmc_tx_context get_tx_context() const noexcept override { return tx_context; }
+
+    /// Get the block header hash (EVMC host method).
+    bytes32 get_block_hash(int64_t block_number) const noexcept override
+    {
+        recorded_blockhashes.emplace_back(block_number);
+        return block_hash;
+    }
+
+    /// Emit LOG (EVMC host method).
+    void emit_log(const address& addr,
+                  const uint8_t* data,
+                  size_t data_size,
+                  const bytes32 topics[],
+                  size_t topics_count) noexcept override
+    {
+        recorded_logs.push_back({addr, {data, data_size}, {topics, topics + topics_count}});
+    }
+
+    /// Record an account access.
+    ///
+    /// This method is required by EIP-2929 introduced in ::EVMC_BERLIN. It will record the account
+    /// access in MockedHost::recorded_account_accesses and return previous access status.
+    /// This methods returns ::EVMC_ACCESS_WARM for known addresses of precompiles.
+    /// The EIP-2929 specifies that evmc_message::sender and evmc_message::recipient are always
+    /// ::EVMC_ACCESS_WARM. Therefore, you should init the MockedHost with:
+    ///
+    ///     mocked_host.access_account(msg.sender);
+    ///     mocked_host.access_account(msg.recipient);
+    ///
+    /// The same way you can mock transaction access list (EIP-2930) for account addresses.
+    ///
+    /// @param addr  The address of the accessed account.
+    /// @returns     The ::EVMC_ACCESS_WARM if the account has been accessed before,
+    ///              the ::EVMC_ACCESS_COLD otherwise.
+    evmc_access_status access_account(const address& addr) noexcept override
+    {
+        // Check if the address have been already accessed.
+        const auto already_accessed =
+            std::find(recorded_account_accesses.begin(), recorded_account_accesses.end(), addr) !=
+            recorded_account_accesses.end();
+
+        record_account_access(addr);
+
+        // Accessing precompiled contracts is always warm.
+        if (addr >= 0x0000000000000000000000000000000000000001_address &&
+            addr <= 0x0000000000000000000000000000000000000009_address)
+            return EVMC_ACCESS_WARM;
+
+        return already_accessed ? EVMC_ACCESS_WARM : EVMC_ACCESS_COLD;
+    }
+
+    /// Access the account's storage value at the given key.
+    ///
+    /// This method is required by EIP-2929 introduced in ::EVMC_BERLIN. In records
+    /// that the given account's storage key has been access and returns the
+    /// previous access status. To mock storage access list (EIP-2930), you can
+    /// pre-init account's storage values with the ::EVMC_ACCESS_WARM flag:
+    ///
+    ///     mocked_host.accounts[msg.recipient].storage[key] = {value,
+    ///     EVMC_ACCESS_WARM};
+    ///
+    /// @param addr  The account address.
+    /// @param key   The account's storage key.
+    /// @return      The ::EVMC_ACCESS_WARM if the storage key has been accessed before,
+    ///              the ::EVMC_ACCESS_COLD otherwise.
+    evmc_access_status access_storage(const address& addr, const bytes32& key) noexcept override
+    {
+        auto& value = accounts[addr].storage[key];
+        const auto access_status = value.access_status;
+        value.access_status = EVMC_ACCESS_WARM;
+        return access_status;
+    }
+
+    /// Get account's transient storage.
+    ///
+    /// @param addr  The account address.
+    /// @param key   The account's transient storage key.
+    /// @return      The transient storage value. Null value in case the account does not exist.
+    bytes32 get_transient_storage(const address& addr, const bytes32& key) const noexcept override
+    {
+        record_account_access(addr);
+
+        const auto account_iter = accounts.find(addr);
+        if (account_iter == accounts.end())
+            return {};
+
+        const auto storage_iter = account_iter->second.transient_storage.find(key);
+        if (storage_iter != account_iter->second.transient_storage.end())
+            return storage_iter->second;
+        return {};
+    }
+
+    /// Set account's transient storage.
+    ///
+    /// @param addr   The account address.
+    /// @param key    The account's transient storage key.
+    /// @param value  The value to be stored.
+    void set_transient_storage(const address& addr,
+                               const bytes32& key,
+                               const bytes32& value) noexcept override
+    {
+        record_account_access(addr);
+        accounts[addr].transient_storage[key] = value;
+    }
+};
+}  // namespace evmc
diff --git a/compiler/test/evmc/utils.h b/compiler/test/evmc/utils.h
new file mode 100644
index 00000000..8b8f742a
--- /dev/null
+++ b/compiler/test/evmc/utils.h
@@ -0,0 +1,35 @@
+// EVMC: Ethereum Client-VM Connector API.
+// Copyright 2018 The EVMC Authors.
+// Licensed under the Apache License, Version 2.0.
+
+#pragma once
+
+/**
+ * @file
+ * A collection of helper macros to handle some non-portable features of C/C++ compilers.
+ *
+ * @addtogroup helpers
+ * @{
+ */
+
+/**
+ * @def EVMC_EXPORT
+ * Marks a function to be exported from a shared library.
+ */
+#if defined _MSC_VER || defined __MINGW32__
+#define EVMC_EXPORT __declspec(dllexport)
+#else
+#define EVMC_EXPORT __attribute__((visibility("default")))
+#endif
+
+/**
+ * @def EVMC_NOEXCEPT
+ * Safe way of marking a function with `noexcept` C++ specifier.
+ */
+#ifdef __cplusplus
+#define EVMC_NOEXCEPT noexcept
+#else
+#define EVMC_NOEXCEPT
+#endif
+
+/** @} */
diff --git a/compiler/test/externalTests/bleeps.sh b/compiler/test/externalTests/bleeps.sh
new file mode 100755
index 00000000..30f0ec92
--- /dev/null
+++ b/compiler/test/externalTests/bleeps.sh
@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run compile; }
+# NOTE: `npm run test` runs `mocha` which seems to disable the gas reporter.
+function test_fn { HARDHAT_DEPLOY_FIXTURE=true npx --no hardhat --no-compile test; }
+
+function bleeps_test
+{
+    local repo="https://github.com/wighawag/bleeps"
+    local ref_type=branch
+    local ref=main
+    local config_file="hardhat.config.ts"
+    local config_var=config
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        #ir-no-optimize            # Compilation fails with: "YulException: Variable expr_15509_mpos is 4 too deep in the stack". No memoryguard was present.
+        #ir-optimize-evm-only      # Compilation fails with: "YulException: Variable expr_15260_mpos is 4 too deep in the stack". No memoryguard was present.
+        ir-optimize-evm+yul
+        #legacy-no-optimize        # Compilation fails with: "CompilerError: Stack too deep, try removing local variables."
+        #legacy-optimize-evm-only  # Compilation fails with: "CompilerError: Stack too deep, try removing local variables."
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    pushd "common-lib/"
+    neutralize_package_json_hooks
+    npm install
+    npm run build
+    popd
+
+    pushd "contracts/"
+    sed -i 's|"bleeps-common": "workspace:\*",|"bleeps-common": "file:../common-lib/",|g' package.json
+
+    sed -i 's/function() public/fallback() external/g' src/externals/WETH9.sol
+    sed -i 's/this\.balance/address(this).balance/g' src/externals/WETH9.sol
+    sed -i 's/uint(-1)/type(uint).max/g' src/externals/WETH9.sol
+    sed -i 's/msg\.sender\.transfer(/payable(msg.sender).transfer(/g' src/externals/WETH9.sol
+    sed -i 's/^\s*\(Deposit\|Withdrawal\|Approval\|Transfer\)(/emit \1(/g' src/externals/WETH9.sol
+
+    # This test does not currently pass due to an upstream problem.
+    # TODO: Remove this line when https://github.com/wighawag/bleeps/issues/2 is fixed
+    rm test/BleepsDAO.governor.test.ts
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    npm install npm-run-all
+    npm install
+
+    # Causes a test failure with hardhat 2.11.0 (latest at the moment of writing this)
+    # TODO: Remove when https://github.com/wighawag/bleeps/issues/4 is resolved
+    npm install hardhat@2.10.2
+
+    # TODO: Bleeps depends on OpenZeppelin 4.3.2, which is affected by
+    # https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3293.
+    # Forcing OZ >= 4.6.0 fixes this but it also causes a lot of unrelated compilation errors.
+    # Remove this when Bleeps gets updated to support newer OpenZeppelin.
+    perl -i -0pe \
+        "s/(function hashProposal\(\n        address\[\] )calldata( targets,\n        uint256\[\] )calldata( values,\n        bytes\[\] )calldata( calldatas,)/\1memory\2memory\3memory\4/g" \
+        node_modules/@openzeppelin/contracts/governance/IGovernor.sol
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat bleeps "$repo" "$preset"
+    done
+
+    popd
+}
+
+external_test Bleeps bleeps_test
diff --git a/compiler/test/externalTests/brink.sh b/compiler/test/externalTests/brink.sh
new file mode 100755
index 00000000..1c3ad2e1
--- /dev/null
+++ b/compiler/test/externalTests/brink.sh
@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn hardhat-compile; }
+function test_fn { SNAPSHOT_UPDATE=1 npx --no hardhat test; }
+
+function brink_test
+{
+    local repo="https://github.com/brinktrade/brink-core"
+    local ref_type=branch
+    local ref=master
+    local config_file="hardhat.config.js"
+    local config_var=""
+    local extra_settings="metadata: {bytecodeHash: 'none'}"
+    local extra_optimizer_settings="runs: 800"
+
+    local compile_only_presets=(
+        ir-no-optimize             # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+        ir-optimize-evm-only       # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+        ir-optimize-evm+yul        # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+        legacy-optimize-evm+yul    # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+        legacy-no-optimize         # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+        legacy-optimize-evm-only   # Lots of test failures. Tests depend on constants.js, which seems to be calculated specifically for 0.8.10.
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # TODO: Remove this when Brink merges https://github.com/brinktrade/brink-core/pull/52
+    sed -i "s|\(function isValidSignature(bytes \)calldata\( _data, bytes \)calldata\( _signature)\)|\1memory\2memory\3|g" src/Test/MockEIP1271Validator.sol
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var" "$CURRENT_EVM_VERSION" "$extra_settings" "$extra_optimizer_settings"
+    yarn install
+    yarn add hardhat-gas-reporter
+
+    # TODO: Remove when https://github.com/brinktrade/brink-core/issues/48 is fixed.
+    # TODO: Chai is ESM-only since version 5.x (see: https://github.com/chaijs/chai/issues/1561#issuecomment-1871134261),
+    # thus, we should stick to version 4.x until Brink and other dependencies also migrate to ESM.
+    yarn add chai@4.4.0
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var" "$extra_settings" "$extra_optimizer_settings"
+        store_benchmark_report hardhat brink "$repo" "$preset"
+    done
+}
+
+external_test Brink brink_test
diff --git a/compiler/test/externalTests/chainlink.sh b/compiler/test/externalTests/chainlink.sh
new file mode 100755
index 00000000..4d508073
--- /dev/null
+++ b/compiler/test/externalTests/chainlink.sh
@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn compile; }
+function test_fn { yarn test; }
+
+function chainlink_test
+{
+    local repo="https://github.com/solidity-external-tests/chainlink"
+    local ref_type=branch
+    local ref=develop_080
+    local config_file="hardhat.config.ts"
+    local config_var=config
+
+    local compile_only_presets=(
+        legacy-no-optimize        # Tests crash on a machine with 8 GB of RAM in CI "FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory"
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        #ir-no-optimize           # Compilation fails with "YulException: Variable expr_10724_mpos is 2 too deep in the stack". No memoryguard was present.
+        #ir-optimize-evm-only     # Compilation fails with "YulException: Variable expr_1891_mpos is 2 too deep in the stack". No memoryguard was present.
+        ir-optimize-evm+yul
+        legacy-optimize-evm-only  # NOTE: This requires >= 4 GB RAM in CI not to crash
+        legacy-optimize-evm+yul   # NOTE: This requires >= 4 GB RAM in CI not to crash
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    cd "contracts/"
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3365).
+    sed -i "s|\(it\)\(('reverts'\)|\1.skip\2|g" test/v0.6/BasicConsumer.test.ts
+    sed -i "s|\(it\)\(('has a reasonable gas cost \[ @skip-coverage \]'\)|\1.skip\2|g" test/v0.6/BasicConsumer.test.ts
+    sed -i "s|\(describe\)\(('#add[^']*'\)|\1.skip\2|g" test/v0.6/Chainlink.test.ts
+    sed -i "s|\(it\)\(('throws'\)|\1.skip\2|g" test/v0.6/SignedSafeMath.test.ts
+    sed -i "s|\(it\)\(('reverts when not enough LINK in the contract'\)|\1.skip\2|g" test/v0.*/VRFD20.test.ts
+    sed -i "s|\(it\)\(('errors while parsing invalid cron strings'\)|\1.skip\2|g" test/v0.8/Cron.test.ts
+    sed -i "s|\(it\)\(('reverts if the amount passed in data mismatches actual amount sent'\)|\1.skip\2|g" test/v0.8/KeeperRegistrar.test.ts
+    sed -i "s|\(it\)\(('reverts if the sender passed in data mismatches actual sender'\)|\1.skip\2|g" test/v0.8/KeeperRegistrar.test.ts
+    sed -i "s|\(it\)\(('reverts if the admin address is 0x0000...'\)|\1.skip\2|g" test/v0.8/KeeperRegistrar.test.ts
+    sed -i "s|\(it\)\(('reverts if not called with more or less than 32 bytes'\)|\1.skip\2|g" test/v0.8/KeeperRegistry.test.ts
+    sed -i "s|\(context\)\(('when permissions are not set'\)|\1.skip\2|g" test/v0.8/KeeperRegistry.test.ts
+
+    # In some cases Hardhat does not detect revert reasons properly via IR.
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i "s|\(it\)\(('does not allow the specified address to start new rounds'\)|\1.skip\2|g" test/v0.6/FluxAggregator.test.ts
+    sed -i "s|\(describe\)\(('when called by a stranger'\)|\1.skip\2|g" test/v0.6/FluxAggregator.test.ts
+    sed -i "s|\(describe\)\(('if the access control is turned on'\)|\1.skip\2|g" test/v0.*/Flags.test.ts
+    sed -i "s|\(it\)\(('respects the access controls of #getFlag'\)|\1.skip\2|g" test/v0.*/Flags.test.ts
+    sed -i "s|\(describe\)\(('setting 0 authorized senders'\)|\1.skip\2|g" test/v0.7/AuthorizedForwarder.test.ts
+    sed -i "s|\(it\)\(('cannot add an authorized node'\)|\1.skip\2|g" test/v0.7/AuthorizedForwarder.test.ts
+    sed -i "s|\(it\)\(('should disallow reads on AggregatorV2V3Interface functions when consuming contract is not whitelisted'\)|\1.skip\2|g" test/v0.8/dev/ArbitrumSequencerUptimeFeed.test.ts
+    sed -i "s|\(it\)\(('should not be callable by non-owners'\)|\1.skip\2|g" test/v0.8/dev/CrossDomainOwnable.test.ts
+    sed -i "s|\(it\)\(('should not be callable by non pending-owners'\)|\1.skip\2|g" test/v0.8/dev/CrossDomainOwnable.test.ts
+    sed -i "s|\(it\)\(('cannot add a consumer to a nonexistent subscription'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+    sed -i "s|\(it\)\(('cannot remove a consumer from a nonexistent subscription'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+    sed -i "s|\(it\)\(('cannot remove a consumer after it is already removed'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+    sed -i "s|\(it\)\(('fails to fulfill without being a valid consumer'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+    # TODO: check why these two are needed due to this PR.
+    sed -i "s|\(it\)\(('cannot fund a nonexistent subscription'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+    sed -i "s|\(it\)\(('can cancel a subscription'\)|\1.skip\2|g" test/v0.8/dev/VRFCoordinatorV2Mock.test.ts
+
+
+    # Disable tests with hard-coded gas expectations.
+    sed -i "s|\(it\)\(('not use too much gas \[ @skip-coverage \]'\)|\1.skip\2|g" test/v0.6/FluxAggregator.test.ts
+    sed -i "s|\(it\)\(('has a large enough gas overhead to cover upkeeps that use all their gas \[ @skip-coverage \]'\)|\1.skip\2|g" test/v0.*/KeeperRegistry*.test.ts
+    sed -i "s|\(it\)\(('only pays .\+'\)|\1.skip\2|g" test/v0.*/KeeperRegistry*.test.ts
+    sed -i "s|\(it\)\(('uses a specific amount of gas \[ @skip-coverage \]'\)|\1.skip\2|g" test/v0.8/ValidatorProxy.test.ts
+    sed -i "s|\(describe\)\(('Gas costs'\)|\1.skip\2|g" test/v0.8/dev/ArbitrumSequencerUptimeFeed.test.ts
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    name_hardhat_default_export "$config_file" "$config_var"
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+    yarn install
+    yarn add hardhat-gas-reporter
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat chainlink "$repo" "$preset"
+    done
+}
+
+external_test Chainlink chainlink_test
diff --git a/compiler/test/externalTests/colony.sh b/compiler/test/externalTests/colony.sh
new file mode 100755
index 00000000..40286510
--- /dev/null
+++ b/compiler/test/externalTests/colony.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn run provision:token:contracts; }
+function test_fn { yarn run test:contracts; }
+
+function colony_test
+{
+    local repo="https://github.com/solidity-external-tests/colonyNetwork.git"
+    local ref_type=branch
+    local ref="develop_080"
+    local config_file="truffle.js"
+
+    local compile_only_presets=(
+        ir-no-optimize            # Compiles but tests run out of gas
+        ir-optimize-evm-only      # Compiles but tests run out of gas
+        legacy-no-optimize        # Compiles but tests run out of gas
+        legacy-optimize-evm-only  # Compiles but tests run out of gas
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-optimize-evm+yul
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+    [[ $BINARY_TYPE == native ]] && replace_global_solc "$BINARY_PATH"
+
+    neutralize_package_json_hooks
+    force_truffle_compiler_settings "$config_file" "$BINARY_TYPE" "${DIR}/solc/dist" "$(first_word "$SELECTED_PRESETS")"
+    yarn install
+    git submodule update --init
+
+    cd lib
+    rm -Rf dappsys
+    git clone https://github.com/solidity-external-tests/dappsys-monolithic.git -b master_080 dappsys
+    cd ..
+
+    replace_version_pragmas
+    [[ $BINARY_TYPE == solcjs ]] && force_solc_modules "${DIR}/solc/dist"
+
+    for preset in $SELECTED_PRESETS; do
+        truffle_run_test "$config_file" "$BINARY_TYPE" "${DIR}/solc/dist" "$preset" "${compile_only_presets[*]}" compile_fn test_fn
+        store_benchmark_report truffle colony "$repo" "$preset"
+    done
+}
+
+external_test ColonyNetworks colony_test
diff --git a/compiler/test/externalTests/elementfi.sh b/compiler/test/externalTests/elementfi.sh
new file mode 100755
index 00000000..94e622d1
--- /dev/null
+++ b/compiler/test/externalTests/elementfi.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run build; }
+function test_fn { npm run test; }
+
+function elementfi_test
+{
+    local repo="https://github.com/element-fi/elf-contracts"
+    local ref_type=branch
+    local ref=main
+    local config_file="hardhat.config.ts"
+    local config_var=config
+
+    local compile_only_presets=(
+        # ElementFi's test suite is hard-coded for Mainnet forked via alchemy.io.
+        # Locally we can only compile.
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    chmod +x scripts/load-balancer-contracts.sh
+    scripts/load-balancer-contracts.sh
+
+    # Balancer contracts require 0.7.x. Patch them for 0.8.x.
+    pushd contracts/balancer-core-v2
+    sed -i 's|uint256(address(this))|uint256(uint160(address(this)))|g' test/MockPoolFactory.sol
+    sed -i 's|uint256(address(this))|uint256(uint160(address(this)))|g' vault/ProtocolFeesCollector.sol
+    sed -i 's|uint256(address(this))|uint256(uint160(address(this)))|g' vault/VaultAuthorization.sol
+    sed -i 's|msg\.sender\.sendValue(excess)|payable(msg.sender).sendValue(excess)|g' vault/AssetTransfersHandler.sol
+    sed -i 's|msg\.sender\.transfer(wad)|payable(msg.sender).transfer(wad)|g' test/WETH.sol
+    sed -i 's|int256(-amountsOut\[i\])|-int256(amountsOut[i])|g' test/MockVault.sol
+    sed -i 's|int256(-amount)|-int256(amount)|g' vault/AssetManagers.sol
+    sed -i 's|uint256(-1)|type(uint256).max|g' pools/BalancerPoolToken.sol
+    sed -i 's|uint256(-1)|type(uint256).max|g' test/WETH.sol
+    sed -i 's|IERC20(0)|IERC20(address(0))|g' pools/BasePool.sol
+    sed -i 's|IERC20(0)|IERC20(address(0))|g' vault/balances/TwoTokenPoolsBalance.sol
+    sed -i 's|IERC20(0)|IERC20(address(0))|g' vault/FlashLoans.sol
+    sed -i 's|IERC20(0)|IERC20(address(0))|g' vault/PoolTokens.sol
+    sed -i 's|uint256(msg\.sender)|uint256(uint160(msg.sender))|g' pools/BasePool.sol
+    sed -i 's|uint256(msg\.sender)|uint256(uint160(msg.sender))|g' pools/weighted/WeightedPool2Tokens.sol
+    sed -i 's|address(uint256(_data))|address(uint160(uint256(_data)))|g' lib/openzeppelin/Create2.sol
+    sed -i 's|address(uint256(poolId) >> (12 \* 8))|address(uint160(uint256(poolId) >> (12 * 8)))|g' vault/PoolRegistry.sol
+    sed -i 's|bytes32(uint256(pool))|bytes32(uint256(uint160(pool)))|g' vault/PoolRegistry.sol
+    popd
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3365).
+    sed -i 's|it(\("fails to withdraw more shares than in balance"\)|it.skip(\1|g' test/compoundAssetProxyTest.ts
+    sed -i 's|it(\("should prevent withdrawal of Principal Tokens and Interest Tokens before the tranche expires "\)|it.skip(\1|g' test/trancheTest.ts
+    sed -i 's|it(\("should prevent withdrawal of more Principal Tokens and Interest Tokens than the user has"\)|it.skip(\1|g' test/trancheTest.ts
+
+    # This test file is very flaky. There's one particular cases that fails randomly (see
+    # https://github.com/element-fi/elf-contracts/issues/240) but some others also depends on an external
+    # service which makes tests time out when that service is down.
+    # "ProviderError: Too Many Requests error received from eth-mainnet.alchemyapi.io"
+    rm test/mockERC20YearnVaultTest.ts
+
+    # Several tests fail unless we use the exact versions hard-coded in package-lock.json
+    #neutralize_package_lock
+
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+    npm install
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat elementfi "$repo" "$preset"
+    done
+}
+
+external_test ElementFi elementfi_test
diff --git a/compiler/test/externalTests/ens.sh b/compiler/test/externalTests/ens.sh
new file mode 100755
index 00000000..aee291a1
--- /dev/null
+++ b/compiler/test/externalTests/ens.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn build; }
+function test_fn { yarn test; }
+
+function ens_test
+{
+    local repo="https://github.com/ensdomains/ens-contracts.git"
+    local ref_type=commit
+    local ref="083d29a2c50cd0a8307386abf8fadc217b256256"
+    local config_file="hardhat.config.js"
+
+    local compile_only_presets=(
+        ir-no-optimize            # FIXME: Tests fail with "Error: cannot estimate gas; transaction may fail or may require manual gas limit"
+        legacy-no-optimize        # Compiles but tests fail to deploy GovernorCompatibilityBravo (code too large).
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-optimize-evm-only
+        ir-optimize-evm+yul       # Needs memory-safe inline assembly patch
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")"
+    yarn install
+
+    replace_version_pragmas
+    neutralize_packaged_contracts
+
+    # In some cases Hardhat does not detect revert reasons properly via IR.
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i "s|it\(('Does not allow wrapping a name you do not own',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('can set fuses and then burn ability to burn fuses',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('can set fuses and burn canSetResolver and canSetTTL',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if CANNOT_TRANSFER is burned\.',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if CANNOT_SET_RESOLVER is burned\.\?',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if CANNOT_SET_TTL is burned\.\?',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if CREATE_SUBDOMAIN is burned and is a new subdomain',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if REPLACE_SUBDOMAIN is burned and is an existing subdomain',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if CANNOT_CREATE_SUBDOMAIN is burned and is a new subdomain',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+    sed -i "s|it\(('Cannot be called if PARENT_CANNOT_CONTROL is burned and is an existing subdomain',\)|it.skip\1|g" test/wrapper/NameWrapper.js
+
+    find . -name "*.sol" -exec sed -i -e 's/^\(\s*\)\(assembly\)/\1\/\/\/ @solidity memory-safe-assembly\n\1\2/' '{}' \;
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn
+        store_benchmark_report hardhat ens "$repo" "$preset"
+    done
+}
+
+external_test ENS ens_test
diff --git a/compiler/test/externalTests/euler.sh b/compiler/test/externalTests/euler.sh
new file mode 100755
index 00000000..80f18e70
--- /dev/null
+++ b/compiler/test/externalTests/euler.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run compile; }
+function test_fn {
+    # The default timeout of 20000 ms is too short for unoptimized code (https://github.com/ethereum/solidity/pull/12765).
+    TEST_TIMEOUT=100000 npx --no hardhat --no-compile test
+}
+
+function euler_test
+{
+    local repo="https://github.com/euler-xyz/euler-contracts"
+    local ref_type=branch
+    local ref="master"
+    local config_file="hardhat.config.js"
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        #ir-no-optimize           # Compilation fails with "YulException: Variable var_v_mpos is 4 too deep in the stack". No memoryguard was present.
+        #ir-optimize-evm-only     # Compilation fails with "YulException: Variable var_v_mpos is 4 too deep in the stack". No memoryguard was present.
+        ir-optimize-evm+yul
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+        legacy-no-optimize
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i "/expectError: 'JUNK_UPGRADE_TEST_FAILURE'/d" test/moduleUpgrade.js
+    sed -i "/et\.expect(errMsg)\.to\.contain('e\/collateral-violation');/d" test/flashLoanNative.js
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")"
+    force_hardhat_unlimited_contract_size "$config_file"
+    npm install
+    replace_version_pragmas
+    neutralize_packaged_contracts
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn
+        store_benchmark_report hardhat euler "$repo" "$preset"
+    done
+}
+
+external_test Euler euler_test
diff --git a/compiler/test/externalTests/gnosis.sh b/compiler/test/externalTests/gnosis.sh
new file mode 100755
index 00000000..5f7ea487
--- /dev/null
+++ b/compiler/test/externalTests/gnosis.sh
@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run build; }
+function test_fn { npm test; }
+
+function gnosis_safe_test
+{
+    local repo="https://github.com/safe-global/safe-contracts.git"
+    local ref_type=branch
+    local ref=main
+    local config_file="hardhat.config.ts"
+    local config_var=userConfig
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        #ir-no-optimize            # Compilation fails with "YulException: Variable var_txHash is 1 too deep in the stack". No memoryguard was present.
+        #ir-optimize-evm-only      # Compilation fails with "YulException: Variable var_txHash is 1 too deep in the stack". No memoryguard was present.
+        # TODO: Uncomment the preset below when the issue: https://github.com/safe-global/safe-contracts/issues/544 is solved.
+        #ir-optimize-evm+yul       # Compilation fails with "YulException: Cannot swap Variable var_operation with Variable _1: too deep in the stack by 4 slots."
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+    [[ $BINARY_TYPE == native ]] && replace_global_solc "$BINARY_PATH"
+
+    # NOTE: The patterns below intentionally have hard-coded versions.
+    # When the upstream updates them, there's a chance we can just remove the regex.
+    sed -i 's|"@gnosis\.pm/mock-contract": "\^4\.0\.0"|"@gnosis.pm/mock-contract": "github:solidity-external-tests/mock-contract#master_080"|g' package.json
+    sed -i 's|"@openzeppelin/contracts": "\^3\.4\.0"|"@openzeppelin/contracts": "^4.0.0"|g' package.json
+
+    # Disable two tests failing due to Hardhat's heuristics not yet updated to handle solc 0.8.10.
+    # TODO: Remove this when Hardhat implements them (https://github.com/nomiclabs/hardhat/issues/2451).
+    sed -i "s|\(it\)\((\"should revert if called directly\"\)|\1.skip\2|g" test/handlers/CompatibilityFallbackHandler.spec.ts
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3365).
+    sed -i "s|\(it\)\((\"should not allow to call setup on singleton\"\)|\1.skip\2|g" test/core/Safe.Setup.spec.ts
+    sed -i "s|\(it\)\((\"can be used only via DELEGATECALL opcode\"\)|\1.skip\2|g" test/libraries/SignMessageLib.spec.ts
+    sed -i "s|it\((\"can only be called from Safe itself\"\)|it.skip\1|g" test/libraries/Migration.spec.ts
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    npm install
+    npm install hardhat-gas-reporter
+
+    replace_version_pragmas
+    [[ $BINARY_TYPE == solcjs ]] && force_solc_modules "${DIR}/solc/dist"
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat gnosis "$repo" "$preset"
+    done
+}
+
+external_test Gnosis-Safe gnosis_safe_test
diff --git a/compiler/test/externalTests/gp2.sh b/compiler/test/externalTests/gp2.sh
new file mode 100755
index 00000000..bbb44222
--- /dev/null
+++ b/compiler/test/externalTests/gp2.sh
@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn run build; }
+function test_fn { yarn test; }
+
+function gp2_test
+{
+    local repo="https://github.com/cowprotocol/contracts.git"
+    local ref_type=branch
+    local ref=main
+    local config_file="hardhat.config.ts"
+    local config_var="config"
+
+    local compile_only_presets=(
+        ir-no-optimize            # Tests fail with "Error: Transaction reverted: trying to deploy a contract whose code is too large"
+        legacy-no-optimize        # Tests fail with "Error: Transaction reverted: trying to deploy a contract whose code is too large"
+    )
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+    [[ $BINARY_TYPE == native ]] && replace_global_solc "$BINARY_PATH"
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    name_hardhat_default_export "$config_file" "$config_var"
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+    yarn
+
+    # Workaround for error caused by the last release of hardhat-waffle@2.0.6 that bumps ethereum-waffle
+    # to version 4.0.10 and breaks gp2 build with the following error:
+    #
+    #  Cannot find module 'ethereum-waffle/dist/cjs/src/deployContract'
+    #
+    # See: https://github.com/NomicFoundation/hardhat-waffle/commit/83ee9cb36ee59d0bedacbbd00043f030af104ad0
+    yarn add '@nomiclabs/hardhat-waffle@2.0.5'
+
+    # Some dependencies come with pre-built artifacts. We want to build from scratch.
+    rm -r node_modules/@gnosis.pm/safe-contracts/build/
+
+    # FIXME: One of the E2E tests tries to import artifacts from Gnosis Safe. We should rebuild them
+    # but it's not that easy because @gnosis.pm/safe-contracts does not come with Hardhat config.
+    rm test/e2e/contractOrdersWithGnosisSafe.test.ts
+
+    # Patch contracts for 0.8.x compatibility.
+    # NOTE: I'm patching OpenZeppelin as well instead of installing OZ 4.0 because it requires less
+    # work. The project imports files that were moved to different locations in 4.0.
+    sed -i 's|uint256(-1)|type(uint256).max|g' src/contracts/GPv2Settlement.sol
+    sed -i 's|return msg\.sender;|return payable(msg.sender);|g' node_modules/@openzeppelin/contracts/utils/Context.sol
+    perl -i -0pe \
+        "s/uint256 (executedBuyAmount = \(-tokenDeltas\[trade.buyTokenIndex\]\)\n\s+.toUint256\(\);)/uint256 executedBuyAmount; unchecked \{\1\}/g" \
+        src/contracts/GPv2Settlement.sol
+
+    # This test is not supposed to work. The compiler is supposed to enforce zero padding since
+    # at least 0.5.8 (see https://github.com/ethereum/solidity/pull/5815). For some reason the
+    # test worked on 0.7.6 but no longer works on 0.8.x.
+    sed -i 's|it\(("invalid EVM transaction encoding does not change order hash"\)|it.skip\1|g' test/GPv2Signing.test.ts
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3365).
+    sed -i 's|it\(("should revert when encoding invalid flags"\)|it.skip\1|g' test/GPv2Trade.test.ts
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat gp2 "$repo" "$preset"
+    done
+}
+
+external_test Gnosis-Protocol-V2 gp2_test
diff --git a/compiler/test/externalTests/perpetual-pools.sh b/compiler/test/externalTests/perpetual-pools.sh
new file mode 100755
index 00000000..8d8dc34e
--- /dev/null
+++ b/compiler/test/externalTests/perpetual-pools.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn build; }
+function test_fn { yarn test; }
+
+function perpetual_pools_test
+{
+    local repo="https://github.com/solidity-external-tests/perpetual-pools-contracts"
+    local ref_type=branch
+    local ref=pools-v2
+    local config_file="hardhat.config.ts"
+    local config_var="config"
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3365).
+    sed -i 's|\(it\)\(("Should not allow commits that are too large"\)|\1.skip\2|g' test/PoolCommitter/commit.spec.ts
+    sed -i 's|\(it\)\(("Should not allow for too many commitments (that bring amount over a user'\''s balance)"\)|\1.skip\2|g' test/PoolCommitter/commit.spec.ts
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+    yarn install
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat perpetual-pools "$repo" "$preset"
+    done
+}
+
+external_test Tracer-Perpetual-Pools perpetual_pools_test
diff --git a/compiler/test/externalTests/pool-together.sh b/compiler/test/externalTests/pool-together.sh
new file mode 100755
index 00000000..3f7141d9
--- /dev/null
+++ b/compiler/test/externalTests/pool-together.sh
@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn compile; }
+function test_fn { yarn test; }
+
+function pool_together_test
+{
+    local repo="https://github.com/pooltogether/v4-core"
+    local ref_type=branch
+    local ref=master
+    local config_file="hardhat.config.ts"
+    local config_var="config"
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i "s|it\(('should fail to return value if value passed does not fit in [0-9]\+ bits'\)|it.skip\1|g" test/libraries/ExtendedSafeCast.test.ts
+    sed -i "s|it\(('should require an rng to be requested'\)|it.skip\1|g" test/DrawBeacon.test.ts
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    yarn install
+
+    # These come with already compiled artifacts. We want them recompiled with latest compiler.
+    rm -r node_modules/@pooltogether/yield-source-interface/artifacts/
+    rm -r node_modules/@pooltogether/uniform-random-number/artifacts/
+    rm -r node_modules/@pooltogether/owner-manager-contracts/artifacts/
+
+    replace_version_pragmas
+    neutralize_packaged_contracts
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat pool-together "$repo" "$preset"
+    done
+}
+
+external_test Pool-Together-V4 pool_together_test
diff --git a/compiler/test/externalTests/prb-math.py b/compiler/test/externalTests/prb-math.py
new file mode 100755
index 00000000..e57688ec
--- /dev/null
+++ b/compiler/test/externalTests/prb-math.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+# ------------------------------------------------------------------------------
+
+import sys
+import subprocess
+from pathlib import Path
+from shutil import which
+
+# Our scripts/ is not a proper Python package so we need to modify PYTHONPATH to import from it
+# pragma pylint: disable=import-error,wrong-import-position
+PROJECT_ROOT = Path(__file__).parents[2]
+sys.path.insert(0, f"{PROJECT_ROOT}/scripts/externalTests")
+
+from runners.base import run_test
+from runners.base import TestConfig
+from runners.foundry import FoundryRunner
+from test_helpers import SettingsPreset
+
+class PRBMathRunner(FoundryRunner):
+    def configure(self):
+        if which("pnpm") is None:
+            raise RuntimeError("pnpm not found.")
+
+        self.setup_presets_profiles()
+        # Starting from version v4.0.2, the default installation method for PRBMath dependencies
+        # has transitioned from Foundry to Node.js.
+        subprocess.run(
+            ["pnpm", "install"],
+            env=self.env,
+            check=True
+        )
+
+test_config = TestConfig(
+    name="PRBMath",
+    repo_url="https://github.com/PaulRBerg/prb-math.git",
+    ref_type="branch",
+    ref="main",
+    compile_only_presets=[
+        # pylint: disable=line-too-long
+        # SettingsPreset.IR_NO_OPTIMIZE,       # Error: Yul exception:Variable expr_15699_address is 2 slot(s) too deep inside the stack. Stack too deep.
+        # SettingsPreset.IR_OPTIMIZE_EVM_ONLY, # Error: Yul exception:Variable expr_15699_address is 2 slot(s) too deep inside the stack. Stack too deep.
+    ],
+    settings_presets=[
+        SettingsPreset.LEGACY_NO_OPTIMIZE,
+        SettingsPreset.LEGACY_OPTIMIZE_EVM_ONLY,
+        SettingsPreset.LEGACY_OPTIMIZE_EVM_YUL,
+        SettingsPreset.IR_OPTIMIZE_EVM_YUL,
+    ],
+)
+
+sys.exit(run_test(PRBMathRunner(argv=sys.argv[1:], config=test_config)))
diff --git a/compiler/test/externalTests/solc-js/solc-js.sh b/compiler/test/externalTests/solc-js/solc-js.sh
new file mode 100755
index 00000000..af325326
--- /dev/null
+++ b/compiler/test/externalTests/solc-js/solc-js.sh
@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+SOLJSON="$1"
+VERSION="$2"
+SOLCJS_CHECKOUT="$3" # optional
+
+[[ $SOLJSON != "" && -f "$SOLJSON" && $VERSION != "" ]] || fail "Usage: $0 <path to soljson.js> <version> [<path to solc-js>]"
+
+function solcjs_test
+{
+    TEST_DIR=$(pwd)
+    SOLCJS_INPUT_DIR="$TEST_DIR"/test/externalTests/solc-js
+
+    # set up solc-js on the branch specified
+    setup_solc "$DIR" solcjs "$SOLJSON" master solc/ "$SOLCJS_CHECKOUT"
+    cd solc/
+
+    printLog "Updating index.js file..."
+    echo "require('./determinism.js');" >> test/index.js
+
+    printLog "Copying determinism.js..."
+    cp -f "$SOLCJS_INPUT_DIR/determinism.js" test/
+
+    printLog "Copying contracts..."
+    cp -Rf "$SOLCJS_INPUT_DIR/DAO" test/
+
+    printLog "Copying SMTChecker tests..."
+    # We do not copy all tests because that takes too long.
+    cp -Rf "$TEST_DIR"/test/libsolidity/smtCheckerTests/external_calls test/smtCheckerTests/
+    cp -Rf "$TEST_DIR"/test/libsolidity/smtCheckerTests/loops test/smtCheckerTests/
+    cp -Rf "$TEST_DIR"/test/libsolidity/smtCheckerTests/invariants test/smtCheckerTests/
+
+    # Update version (needed for some tests)
+    echo "Updating package.json to version $VERSION"
+    npm version --allow-same-version --no-git-tag-version "$VERSION"
+
+    replace_version_pragmas
+
+    printLog "Running test function..."
+    npm test
+}
+
+external_test solc-js solcjs_test
diff --git a/compiler/test/externalTests/trident.sh b/compiler/test/externalTests/trident.sh
new file mode 100755
index 00000000..d8d94eb3
--- /dev/null
+++ b/compiler/test/externalTests/trident.sh
@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2021 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn build; }
+
+function test_fn {
+    # shellcheck disable=SC2046
+    TS_NODE_TRANSPILE_ONLY=1 npx hardhat test --no-compile $(
+        # TODO: We need to skip Migration.test.ts because it fails and makes other tests fail too.
+        # Replace this with `yarn test` once https://github.com/sushiswap/trident/issues/283 is fixed.
+        find test/ -name "*.test.ts" ! -path "test/Migration.test.ts" | LC_ALL=C sort
+    )
+}
+
+function trident_test
+{
+    local repo="https://github.com/sushiswap/trident"
+    local ref_type=commit
+    # FIXME: Switch back to master branch when https://github.com/sushiswap/trident/issues/303 gets fixed.
+    local ref="0cab5ae884cc9a41223d52791be775c3a053cb26" # master as of 2021-12-16
+    local config_file="hardhat.config.ts"
+    local config_var=config
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul        # Needs memory-safe inline assembly patch
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # TODO: Currently tests work only with the exact versions from yarn.lock.
+    # Re-enable this when https://github.com/sushiswap/trident/issues/284 is fixed.
+    #neutralize_package_lock
+
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    yarn install
+
+    replace_version_pragmas
+    force_solc_modules "${DIR}/solc"
+
+    # BentoBoxV1Flat.sol requires a few small tweaks to compile on 0.8.x.
+    # TODO: Remove once https://github.com/sushiswap/trident/pull/282 gets merged.
+    sed -i 's|uint128(-1)|type(uint128).max|g' contracts/flat/BentoBoxV1Flat.sol
+    sed -i 's|uint64(-1)|type(uint64).max|g' contracts/flat/BentoBoxV1Flat.sol
+    sed -i 's|uint32(-1)|type(uint32).max|g' contracts/flat/BentoBoxV1Flat.sol
+    sed -i 's|IERC20(0)|IERC20(address(0))|g' contracts/flat/BentoBoxV1Flat.sol
+    sed -i 's|IStrategy(0)|IStrategy(address(0))|g' contracts/flat/BentoBoxV1Flat.sol
+    find contracts -name "*.sol" -exec sed -i -e 's/^\(\s*\)\(assembly\)/\1\/\/\/ @solidity memory-safe-assembly\n\1\2/' '{}' \;
+
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i 's|it\(("Reverts on direct deployment via factory"\)|it.skip\1|g' test/MasterDeployer.test.ts
+
+    # @sushiswap/core package contains contracts that get built with 0.6.12 and fail our compiler
+    # version check. It's not used by tests so we can remove it.
+    rm -r node_modules/@sushiswap/core/
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat trident "$repo" "$preset"
+    done
+}
+
+external_test Trident trident_test
diff --git a/compiler/test/externalTests/uniswap.sh b/compiler/test/externalTests/uniswap.sh
new file mode 100755
index 00000000..8d2551b6
--- /dev/null
+++ b/compiler/test/externalTests/uniswap.sh
@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { yarn compile; }
+function test_fn { UPDATE_SNAPSHOT=1 npx hardhat test; }
+
+function uniswap_test
+{
+    local repo="https://github.com/solidity-external-tests/uniswap-v3-core.git"
+    local ref_type=branch
+    local ref=main_080
+    local config_file="hardhat.config.ts"
+    local config_var=config
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove this when https://github.com/NomicFoundation/hardhat/issues/3365 gets fixed.
+    sed -i "s|it\(('underpay zero for one and exact in',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('pay in the wrong token zero for one and exact in',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('underpay zero for one and exact out',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('pay in the wrong token zero for one and exact out',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('underpay one for zero and exact in',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('pay in the wrong token one for zero and exact in',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('underpay one for zero and exact out',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+    sed -i "s|it\(('pay in the wrong token one for zero and exact out',\)|it.skip\1|g" test/UniswapV3Pool.spec.ts
+
+    neutralize_package_json_hooks
+    name_hardhat_default_export "$config_file" "$config_var"
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+
+    # Force latest versions of everything except Hardhat and some of its dependencies.
+    # - Hardhat 2.2.0 pulled in by yarn.lock is too old because it can't decode Panics caused by overflow/underflow.
+    # - Hardhat 2.5.0+ won't work because of error messages hard-coded in test expectations. E.g.
+    #   "revert SPL" is expected but the message is "reverted with reason string 'SPL'" in 2.5.0.
+    # - Newer versions of ethereumjs/tx have an issue with 'gteHardfork()' method.
+    neutralize_package_lock
+
+    yarn install
+    yarn add hardhat-gas-reporter
+
+    # With ethers.js 5.6.2 many tests for revert messages fail.
+    # TODO: Remove when https://github.com/ethers-io/ethers.js/discussions/2849 is resolved.
+    yarn add ethers@5.6.1
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat uniswap "$repo" "$preset"
+    done
+}
+
+external_test Uniswap-V3 uniswap_test
diff --git a/compiler/test/externalTests/yield-liquidator.sh b/compiler/test/externalTests/yield-liquidator.sh
new file mode 100755
index 00000000..7a4353af
--- /dev/null
+++ b/compiler/test/externalTests/yield-liquidator.sh
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2022 solidity contributors.
+#------------------------------------------------------------------------------
+
+set -e
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run build; }
+function test_fn { npm run test; }
+
+function yield_liquidator_test
+{
+    local repo="https://github.com/yieldprotocol/yield-liquidator-v2"
+    local ref_type=branch
+    local ref="master"
+    local config_file="hardhat.config.ts"
+    local config_var="module.exports"
+
+    local compile_only_presets=()
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-no-optimize
+        ir-optimize-evm-only
+        ir-optimize-evm+yul
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+        legacy-no-optimize
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")" "$config_var"
+    force_hardhat_unlimited_contract_size "$config_file" "$config_var"
+    npm install
+
+    # The contract below is not used in any test and it depends on ISwapRouter which does not exists
+    # in the main repository.
+    # See: https://github.com/yieldprotocol/yield-liquidator-v2/blob/9a49d9a0e9398f6a6c07bad531e77d1001a1166f/src/swap_router.rs#L94
+    rm --force contracts/.YvBasicFlashLiquidator.sol
+
+    replace_version_pragmas
+    neutralize_packaged_contracts
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn "$config_var"
+        store_benchmark_report hardhat yield_liquidator "$repo" "$preset"
+    done
+}
+
+external_test Yield-Liquidator-V2 yield_liquidator_test
diff --git a/compiler/test/externalTests/zeppelin.sh b/compiler/test/externalTests/zeppelin.sh
new file mode 100755
index 00000000..54d75334
--- /dev/null
+++ b/compiler/test/externalTests/zeppelin.sh
@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2019 solidity contributors.
+#------------------------------------------------------------------------------
+
+# Disable shellcheck errors on quoted special chars like backticks. Too many false-positives.
+# shellcheck disable=SC2016
+
+set -e
+# Temporary(?) fix to up the heap limit for node in order to prevent 'out of heap errors'
+export NODE_OPTIONS="--max-old-space-size=4096"
+
+source scripts/common.sh
+source scripts/externalTests/common.sh
+
+REPO_ROOT=$(realpath "$(dirname "$0")/../..")
+
+verify_input "$@"
+BINARY_TYPE="$1"
+BINARY_PATH="$(realpath "$2")"
+SELECTED_PRESETS="$3"
+
+function compile_fn { npm run compile; }
+function test_fn { npm test; }
+
+function zeppelin_test
+{
+    local repo="https://github.com/OpenZeppelin/openzeppelin-contracts.git"
+    local ref_type=branch
+    local ref="master"
+    local config_file="hardhat.config.js"
+
+    local compile_only_presets=(
+        #ir-no-optimize           # Compilation fails with "Contract initcode size is 49410 bytes and exceeds 49152 bytes (a limit introduced in Shanghai)."
+        ir-optimize-evm-only      # FIXME: A few tests fail with "Transaction: ... exited with an error (status 0) after consuming all gas."
+)
+    local settings_presets=(
+        "${compile_only_presets[@]}"
+        ir-optimize-evm+yul
+        legacy-no-optimize
+        legacy-optimize-evm-only
+        legacy-optimize-evm+yul
+    )
+
+    [[ $SELECTED_PRESETS != "" ]] || SELECTED_PRESETS=$(circleci_select_steps_multiarg "${settings_presets[@]}")
+    print_presets_or_exit "$SELECTED_PRESETS"
+
+    setup_solc "$DIR" "$BINARY_TYPE" "$BINARY_PATH"
+    download_project "$repo" "$ref_type" "$ref" "$DIR"
+
+    # Disable tests that won't pass on the ir presets due to Hardhat heuristics. Note that this also disables
+    # them for other presets but that's fine - we want same code run for benchmarks to be comparable.
+    # TODO: Remove the lines below when Hardhat adjusts heuristics for IR (https://github.com/nomiclabs/hardhat/issues/3750).
+    sed -i "s|it(\('proxy admin cannot call delegated functions',\)|it.skip(\1|g" test/proxy/transparent/TransparentUpgradeableProxy.behaviour.js
+    sed -i "s|describe(\('when the given implementation is the zero address'\)|describe.skip(\1|g" test/proxy/transparent/TransparentUpgradeableProxy.behaviour.js
+    sed -i "s|describe(\('when the new proposed admin is the zero address'\)|describe.skip(\1|g" test/proxy/transparent/TransparentUpgradeableProxy.behaviour.js
+    # In some cases Hardhat does not detect revert reasons properly via IR.
+    sed -i "s|it(\('prevent unauthorized maintenance'\)|it.skip(\1|g" test/governance/TimelockController.test.js
+    sed -i "s|it(\('cannot cancel invalid operation'\)|it.skip(\1|g" test/governance/TimelockController.test.js
+    sed -i "s|it(\('cannot call onlyInitializable function outside the scope of an initializable function'\)|it.skip(\1|g" test/proxy/utils/Initializable.test.js
+    sed -i "s|it(\('reverts when sending non-zero amounts'\)|it.skip(\1|g" test/utils/Address.test.js
+    sed -i "s|it(\('reverts when sending more than the balance'\)|it.skip(\1|g" test/utils/Address.test.js
+    sed -i "s|it(\('fails deploying a contract if the bytecode length is zero'\)|it.skip(\1|g" test/utils/Create2.test.js
+    sed -i "s|it(\('fails deploying a contract if factory contract does not have sufficient balance'\)|it.skip(\1|g" test/utils/Create2.test.js
+    sed -i "s|it(\('reverts when casting -1'\)|it.skip(\1|g" test/utils/math/SafeCast.test.js
+    sed -i 's|it(\(`reverts when casting [^`]\+`\)|it.skip(\1|g' test/utils/math/SafeCast.test.js
+    sed -i "s|it(\('reverts if index is greater than supply'\)|it.skip(\1|g" test/token/ERC721/ERC721.behavior.js
+    sed -i "s|it(\('burns all tokens'\)|it.skip(\1|g" test/token/ERC721/ERC721.behavior.js
+    sed -i "s|it(\('guards transfer against invalid user'\)|it.skip(\1|g" test/access/Ownable2Step.test.js
+    sed -i "s|it(\('reverting initialization function'\)|it.skip(\1|g" test/proxy/beacon/BeaconProxy.test.js
+    sed -i "s|describe(\('reverting initialization'\)|describe.skip(\1|g" test/proxy/Proxy.behaviour.js
+    sed -i "s|it(\('does not allow remote callback'\)|it.skip(\1|g" test/utils/ReentrancyGuard.test.js
+
+    # TODO: Remove when hardhat properly handle reverts of custom errors with via-ir enabled
+    # and/or open-zeppelin fix https://github.com/OpenZeppelin/openzeppelin-contracts/issues/4349
+    sed -i "s|it(\('cannot nest reinitializers'\)|it.skip(\1|g" test/proxy/utils/Initializable.test.js
+    sed -i "s|it(\('prevents re-initialization'\)|it.skip(\1|g" test/proxy/utils/Initializable.test.js
+    sed -i "s|it(\('can lock contract after initialization'\)|it.skip(\1|g" test/proxy/utils/Initializable.test.js
+    sed -i "s|it(\('calling upgradeTo on the implementation reverts'\)|it.skip(\1|g" test/proxy/utils/UUPSUpgradeable.test.js
+    sed -i "s|it(\('calling upgradeToAndCall on the implementation reverts'\)|it.skip(\1|g" test/proxy/utils/UUPSUpgradeable.test.js
+    sed -i "s|it(\('calling upgradeTo from a contract that is not an ERC1967 proxy\)|it.skip(\1|g" test/proxy/utils/UUPSUpgradeable.test.js
+    sed -i "s|it(\('calling upgradeToAndCall from a contract that is not an ERC1967 proxy\)|it.skip(\1|g" test/proxy/utils/UUPSUpgradeable.test.js
+
+    # Here only the testToInt(248) and testToInt(256) cases fail so change the loop range to skip them
+    sed -i "s|range(8, 256, 8)\(.forEach(bits => testToInt(bits));\)|range(8, 240, 8)\1|" test/utils/math/SafeCast.test.js
+
+    neutralize_package_lock
+    neutralize_package_json_hooks
+    force_hardhat_compiler_binary "$config_file" "$BINARY_TYPE" "$BINARY_PATH"
+    force_hardhat_compiler_settings "$config_file" "$(first_word "$SELECTED_PRESETS")"
+    npm install
+
+    replace_version_pragmas
+
+    for preset in $SELECTED_PRESETS; do
+        hardhat_run_test "$config_file" "$preset" "${compile_only_presets[*]}" compile_fn test_fn
+        store_benchmark_report hardhat zeppelin "$repo" "$preset"
+    done
+}
+
+external_test Zeppelin zeppelin_test
diff --git a/compiler/test/external_tests.py b/compiler/test/external_tests.py
new file mode 100755
index 00000000..a7b8e87e
--- /dev/null
+++ b/compiler/test/external_tests.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+
+# ------------------------------------------------------------------------------
+# This file is part of solidity.
+#
+# solidity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# solidity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with solidity.  If not, see <http://www.gnu.org/licenses/>
+#
+# (c) 2023 solidity contributors.
+# ------------------------------------------------------------------------------
+
+from argparse import ArgumentParser, Namespace
+import os
+from pathlib import Path
+import sys
+import subprocess
+
+EXTERNAL_TESTS_DIR = Path(__file__).parent / "externalTests"
+
+
+class ExternalTestNotFound(Exception):
+    pass
+
+
+def detect_external_tests() -> dict:
+    return {
+        file_path.stem: file_path
+        for file_path in Path(EXTERNAL_TESTS_DIR).iterdir()
+        if file_path.is_file() and file_path.suffix in (".sh", ".py")
+    }
+
+
+def display_available_external_tests(_):
+    print("Available external tests:")
+    print(*detect_external_tests().keys())
+
+
+def run_test_scripts(solc_binary_type: str, solc_binary_path: Path, tests: dict):
+    for test_name, test_script_path in tests.items():
+        print(f"Running {test_name} external test...")
+        subprocess.run(
+            [test_script_path, solc_binary_type, solc_binary_path],
+            check=True
+        )
+
+
+def run_external_tests(args: dict):
+    solc_binary_type = args["solc_binary_type"]
+    solc_binary_path = args["solc_binary_path"]
+
+    all_test_scripts = detect_external_tests()
+    selected_tests = args["selected_tests"]
+    if args["run_all"]:
+        assert len(selected_tests) == 0
+        run_test_scripts(solc_binary_type, solc_binary_path, all_test_scripts)
+        return
+
+    if len(selected_tests) == 0:
+        raise ExternalTestNotFound(
+            "External test was not selected. Please use --run or --run-all option"
+        )
+
+    unrecognized_tests = set(selected_tests) - set(all_test_scripts.keys())
+    if unrecognized_tests != set():
+        raise ExternalTestNotFound(
+            f"External test(s) not found: {', '.join(unrecognized_tests)}"
+        )
+    run_test_scripts(
+        solc_binary_type,
+        solc_binary_path,
+        {k: all_test_scripts[k] for k in selected_tests},
+    )
+
+
+def parse_commandline() -> Namespace:
+    script_description = "Script to run external Solidity tests."
+
+    parser = ArgumentParser(description=script_description)
+    subparser = parser.add_subparsers()
+    list_command = subparser.add_parser(
+        "list",
+        help="List all available external tests.",
+    )
+    list_command.set_defaults(cmd=display_available_external_tests)
+
+    run_command = subparser.add_parser(
+        "test",
+        help="Run external tests.",
+    )
+    run_command.set_defaults(cmd=run_external_tests)
+
+    run_command.add_argument(
+        "--solc-binary-type",
+        dest="solc_binary_type",
+        type=str,
+        required=True,
+        choices=["native", "solcjs"],
+        help="Type of the solidity compiler binary to be used.",
+    )
+    run_command.add_argument(
+        "--solc-binary-path",
+        dest="solc_binary_path",
+        type=Path,
+        required=True,
+        help="Path to the solidity compiler binary.",
+    )
+
+    running_mode = run_command.add_mutually_exclusive_group()
+    running_mode.add_argument(
+        "--run",
+        metavar="TEST_NAME",
+        dest="selected_tests",
+        nargs="+",
+        default=[],
+        help="List of one or more external tests to run (separated by sapce).",
+    )
+    running_mode.add_argument(
+        "--run-all",
+        dest="run_all",
+        default=False,
+        action="store_true",
+        help="Run all available external tests.",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    try:
+        args = parse_commandline()
+        args.cmd(vars(args))
+        return os.EX_OK
+    except ExternalTestNotFound as exception:
+        print(f"Error: {exception}", file=sys.stderr)
+        return os.EX_NOINPUT
+    except RuntimeError as exception:
+        print(f"Error: {exception}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/compiler/test/formal/and_distributed_over_shl.py b/compiler/test/formal/and_distributed_over_shl.py
new file mode 100644
index 00000000..ba1b379c
--- /dev/null
+++ b/compiler/test/formal/and_distributed_over_shl.py
@@ -0,0 +1,25 @@
+from opcodes import AND, SHL
+from rule import Rule
+from z3 import BitVec
+
+"""
+Rule:
+AND(SHL(Z,X), SHL(Z,Y)) -> SHL(Z, AND(X,Y))
+"""
+
+rule = Rule()
+
+n_bits = 128
+
+# Input vars
+X = BitVec('X', n_bits)
+Y = BitVec('Y', n_bits)
+Z = BitVec('Z', n_bits)
+
+# Non optimized result
+nonopt = AND(SHL(Z,X), SHL(Z,Y))
+
+# Optimized result
+opt = SHL(Z, AND(X,Y))
+
+rule.check(nonopt, opt)
diff --git a/compiler/test/libevmasm/Assembler.cpp b/compiler/test/libevmasm/Assembler.cpp
new file mode 100644
index 00000000..2b01ae03
--- /dev/null
+++ b/compiler/test/libevmasm/Assembler.cpp
@@ -0,0 +1,425 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Alex Beregszaszi
+ * @date 2018
+ * Tests for the assembler.
+ */
+#include <test/Common.h>
+
+#include <libevmasm/Assembly.h>
+#include <libsolutil/JSON.h>
+#include <libevmasm/Disassemble.h>
+#include <libyul/Exceptions.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <tuple>
+
+using namespace solidity::langutil;
+using namespace solidity::evmasm;
+using namespace std::string_literals;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+	void checkCompilation(evmasm::Assembly const& _assembly)
+	{
+		LinkerObject output = _assembly.assemble();
+		BOOST_CHECK(output.bytecode.size() > 0);
+		BOOST_CHECK(output.toHex().length() > 0);
+	}
+}
+
+BOOST_AUTO_TEST_SUITE(Assembler)
+
+BOOST_AUTO_TEST_CASE(all_assembly_items)
+{
+	std::map<std::string, unsigned> indices = {
+		{ "root.asm", 0 },
+		{ "sub.asm", 1 },
+		{ "verbatim.asm", 2 }
+	};
+	EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	Assembly _assembly{evmVersion, false, {}};
+	auto root_asm = std::make_shared<std::string>("root.asm");
+	_assembly.setSourceLocation({1, 3, root_asm});
+
+	Assembly _subAsm{evmVersion, false, {}};
+	auto sub_asm = std::make_shared<std::string>("sub.asm");
+	_subAsm.setSourceLocation({6, 8, sub_asm});
+
+	Assembly _verbatimAsm(evmVersion, true, "");
+	auto verbatim_asm = std::make_shared<std::string>("verbatim.asm");
+	_verbatimAsm.setSourceLocation({8, 18, verbatim_asm});
+
+	// PushImmutable
+	_subAsm.appendImmutable("someImmutable");
+	_subAsm.append(AssemblyItem(PushTag, 0));
+	_subAsm.append(Instruction::INVALID);
+	std::shared_ptr<Assembly> _subAsmPtr = std::make_shared<Assembly>(_subAsm);
+
+	_verbatimAsm.appendVerbatim({0xff,0xff}, 0, 0);
+	_verbatimAsm.appendVerbatim({0x74, 0x65, 0x73, 0x74}, 0, 1);
+	_verbatimAsm.append(Instruction::MSTORE);
+	std::shared_ptr<Assembly> _verbatimAsmPtr = std::make_shared<Assembly>(_verbatimAsm);
+
+	// Tag
+	auto tag = _assembly.newTag();
+	_assembly.append(tag);
+	// Operation
+	_assembly.append(u256(1));
+	_assembly.append(u256(2));
+	// Push
+	auto keccak256 = AssemblyItem(Instruction::KECCAK256);
+	_assembly.m_currentModifierDepth = 1;
+	_assembly.append(keccak256);
+	_assembly.m_currentModifierDepth = 0;
+	// PushProgramSize
+	_assembly.appendProgramSize();
+	// PushLibraryAddress
+	_assembly.appendLibraryAddress("someLibrary");
+	// PushTag + Operation
+	_assembly.appendJump(tag);
+	// PushData
+	_assembly.append(bytes{0x1, 0x2, 0x3, 0x4});
+	// PushSubSize
+	auto sub = _assembly.appendSubroutine(_subAsmPtr);
+	// PushSub
+	_assembly.pushSubroutineOffset(static_cast<size_t>(sub.data()));
+	// PushSubSize
+	auto verbatim_sub = _assembly.appendSubroutine(_verbatimAsmPtr);
+	// PushSub
+	_assembly.pushSubroutineOffset(static_cast<size_t>(verbatim_sub.data()));
+	// PushDeployTimeAddress
+	_assembly.append(PushDeployTimeAddress);
+	// AssignImmutable.
+	// Note that since there is no reference to "someOtherImmutable", this will just compile to two POPs in the hex output.
+	_assembly.appendImmutableAssignment("someOtherImmutable");
+	_assembly.append(u256(2));
+	_assembly.appendImmutableAssignment("someImmutable");
+	// Operation
+	_assembly.append(Instruction::STOP);
+	_assembly.appendToAuxiliaryData(bytes{0x42, 0x66});
+	_assembly.appendToAuxiliaryData(bytes{0xee, 0xaa});
+
+	_assembly.m_currentModifierDepth = 2;
+	_assembly.appendJump(tag);
+	_assembly.m_currentModifierDepth = 0;
+
+	checkCompilation(_assembly);
+
+	BOOST_CHECK_EQUAL(
+		_assembly.assemble().toHex(),
+		"5b6001600220607f73__$bf005014d9d0f534b8fcb268bd84c491a2$__"
+		"60005660776024604c600760707300000000000000000000000000000000000000005050"
+		"600260010152"
+		"006000"
+		"56fe"
+		"7f0000000000000000000000000000000000000000000000000000000000000000"
+		"6000feffff7465737452010203044266eeaa"
+	);
+	BOOST_CHECK_EQUAL(
+		_assembly.assemblyString(),
+		"    /* \"root.asm\":1:3   */\n"
+		"tag_1:\n"
+		"  keccak256(0x02, 0x01)\n"
+		"  bytecodeSize\n"
+		"  linkerSymbol(\"bf005014d9d0f534b8fcb268bd84c491a2380f4acd260d1ccfe9cd8201f7e994\")\n"
+		"  jump(tag_1)\n"
+		"  data_a6885b3731702da62e8e4a8f584ac46a7f6822f4e2ba50fba902f67b1588d23b\n"
+		"  dataSize(sub_0)\n"
+		"  dataOffset(sub_0)\n"
+		"  dataSize(sub_1)\n"
+		"  dataOffset(sub_1)\n"
+		"  deployTimeAddress()\n"
+		"  assignImmutable(\"0xc3978657661c4d8e32e3d5f42597c009f0d3859e9f9d0d94325268f9799e2bfb\")\n"
+		"  0x02\n"
+		"  assignImmutable(\"0x26f2c0195e9d408feff3abd77d83f2971f3c9a18d1e8a9437c7835ae4211fc9f\")\n"
+		"  stop\n"
+		"  jump(tag_1)\n"
+		"stop\n"
+		"data_a6885b3731702da62e8e4a8f584ac46a7f6822f4e2ba50fba902f67b1588d23b 01020304\n"
+		"\n"
+		"sub_0: assembly {\n"
+		"        /* \"sub.asm\":6:8   */\n"
+		"      immutable(\"0x26f2c0195e9d408feff3abd77d83f2971f3c9a18d1e8a9437c7835ae4211fc9f\")\n"
+		"      tag_0\n"
+		"      invalid\n"
+		"}\n"
+		"\n"
+		"sub_1: assembly {\n"
+		"        /* \"verbatim.asm\":8:18   */\n"
+		"      verbatimbytecode_ffff\n"
+		"      verbatimbytecode_74657374\n"
+		"      mstore\n"
+		"}\n"
+		"\n"
+		"auxdata: 0x4266eeaa\n"
+	);
+	std::string json{
+		"{\".auxdata\":\"4266eeaa\",\".code\":["
+		"{\"begin\":1,\"end\":3,\"name\":\"tag\",\"source\":0,\"value\":\"1\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"JUMPDEST\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"1\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"2\"},"
+		"{\"begin\":1,\"end\":3,\"modifierDepth\":1,\"name\":\"KECCAK256\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSHSIZE\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSHLIB\",\"source\":0,\"value\":\"someLibrary\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH [tag]\",\"source\":0,\"value\":\"1\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"JUMP\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH data\",\"source\":0,\"value\":\"A6885B3731702DA62E8E4A8F584AC46A7F6822F4E2BA50FBA902F67B1588D23B\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH #[$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH [$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH #[$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000001\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH [$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000001\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSHDEPLOYADDRESS\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"name\":\"ASSIGNIMMUTABLE\",\"source\":0,\"value\":\"someOtherImmutable\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"2\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"ASSIGNIMMUTABLE\",\"source\":0,\"value\":\"someImmutable\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"STOP\",\"source\":0},"
+		"{\"begin\":1,\"end\":3,\"modifierDepth\":2,\"name\":\"PUSH [tag]\",\"source\":0,\"value\":\"1\"},{\"begin\":1,\"end\":3,\"modifierDepth\":2,\"name\":\"JUMP\",\"source\":0}"
+		"],\".data\":{\"0\":{\".code\":["
+		"{\"begin\":6,\"end\":8,\"name\":\"PUSHIMMUTABLE\",\"source\":1,\"value\":\"someImmutable\"},"
+		"{\"begin\":6,\"end\":8,\"name\":\"PUSH [ErrorTag]\",\"source\":1},"
+		"{\"begin\":6,\"end\":8,\"name\":\"INVALID\",\"source\":1}"
+		"]},"
+		"\"1\":{\".code\":["
+		"{\"begin\":8,\"end\":18,\"name\":\"VERBATIM\",\"source\":2,\"value\":\"ffff\"},"
+		"{\"begin\":8,\"end\":18,\"name\":\"VERBATIM\",\"source\":2,\"value\":\"74657374\"},"
+		"{\"begin\":8,\"end\":18,\"name\":\"MSTORE\",\"source\":2}"
+		"]},\"A6885B3731702DA62E8E4A8F584AC46A7F6822F4E2BA50FBA902F67B1588D23B\":\"01020304\"},\"sourceList\":[\"root.asm\",\"sub.asm\",\"verbatim.asm\"]}"
+	};
+	Json::Value jsonValue;
+	BOOST_CHECK(util::jsonParseStrict(json, jsonValue));
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(_assembly.assemblyJSON(indices)), util::jsonCompactPrint(jsonValue));
+}
+
+BOOST_AUTO_TEST_CASE(immutables_and_its_source_maps)
+{
+	EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	// Tests for 1, 2, 3 number of immutables.
+	for (int numImmutables = 1; numImmutables <= 3; ++numImmutables)
+	{
+		BOOST_TEST_MESSAGE("NumImmutables: "s + std::to_string(numImmutables));
+		// Tests for the cases 1, 2, 3 occurrences of an immutable reference.
+		for (int numActualRefs = 1; numActualRefs <= 3; ++numActualRefs)
+		{
+			BOOST_TEST_MESSAGE("NumActualRefs: "s + std::to_string(numActualRefs));
+			auto const NumExpectedMappings =
+				(
+					2 +                        // PUSH <a> PUSH <b>
+					(numActualRefs - 1) * 5 +  // DUP DUP PUSH <n> ADD MSTORE
+					3                          // PUSH <n> ADD MSTORE
+				) * numImmutables;
+
+			auto constexpr NumSubs = 1;
+			auto constexpr NumOpcodesWithoutMappings =
+				NumSubs +                  // PUSH <addr> for every sub assembly
+				1;                         // INVALID
+
+			auto assemblyName = std::make_shared<std::string>("root.asm");
+			auto subName = std::make_shared<std::string>("sub.asm");
+
+			std::map<std::string, unsigned> indices = {
+				{ *assemblyName, 0 },
+				{ *subName, 1 }
+			};
+
+			auto subAsm = std::make_shared<Assembly>(evmVersion, false, std::string{});
+			for (char i = 0; i < numImmutables; ++i)
+			{
+				for (int r = 0; r < numActualRefs; ++r)
+				{
+					subAsm->setSourceLocation(SourceLocation{10*i, 10*i + 6 + r, subName});
+					subAsm->appendImmutable(std::string(1, char('a' + i))); // "a", "b", ...
+				}
+			}
+
+			Assembly assembly{evmVersion, true, {}};
+			for (char i = 1; i <= numImmutables; ++i)
+			{
+				assembly.setSourceLocation({10*i, 10*i + 3+i, assemblyName});
+				assembly.append(u256(0x71));              // immutble value
+				assembly.append(u256(0));                 // target... modules?
+				assembly.appendImmutableAssignment(std::string(1, char('a' + i - 1)));
+			}
+
+			assembly.appendSubroutine(subAsm);
+
+			checkCompilation(assembly);
+
+			std::string const sourceMappings = AssemblyItem::computeSourceMapping(assembly.items(), indices);
+			auto const numberOfMappings = std::count(sourceMappings.begin(), sourceMappings.end(), ';');
+
+			LinkerObject const& obj = assembly.assemble();
+			std::string const disassembly = disassemble(obj.bytecode, evmVersion, "\n");
+			auto const numberOfOpcodes = std::count(disassembly.begin(), disassembly.end(), '\n');
+
+			#if 0 // {{{ debug prints
+			{
+				LinkerObject const& subObj = assembly.sub(0).assemble();
+				std::string const subDisassembly = disassemble(subObj.bytecode, "\n");
+				std::cout << '\n';
+				std::cout << "### immutables: " << numImmutables << ", refs: " << numActualRefs << '\n';
+				std::cout << " - srcmap: \"" << sourceMappings << "\"\n";
+				std::cout << " - src mappings: " << numberOfMappings << '\n';
+				std::cout << " - opcodes: " << numberOfOpcodes << '\n';
+				std::cout << " - subs: " << assembly.numSubs() << '\n';
+				std::cout << " - sub opcodes " << std::count(subDisassembly.begin(), subDisassembly.end(), '\n') << '\n';
+				std::cout << " - sub srcmaps " << AssemblyItem::computeSourceMapping(subAsm->items(), indices) << '\n';
+				std::cout << " - main bytecode:\n\t" << disassemble(obj.bytecode, "\n\t");
+				std::cout << "\r - sub bytecode:\n\t" << disassemble(subObj.bytecode, "\n\t");
+			}
+			#endif // }}}
+
+			BOOST_REQUIRE_EQUAL(NumExpectedMappings, numberOfMappings);
+			BOOST_REQUIRE_EQUAL(NumExpectedMappings, numberOfOpcodes - NumOpcodesWithoutMappings);
+		}
+	}
+}
+
+BOOST_AUTO_TEST_CASE(immutable)
+{
+	std::map<std::string, unsigned> indices = {
+		{ "root.asm", 0 },
+		{ "sub.asm", 1 }
+	};
+	EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	Assembly _assembly{evmVersion, true, {}};
+	auto root_asm = std::make_shared<std::string>("root.asm");
+	_assembly.setSourceLocation({1, 3, root_asm});
+
+	Assembly _subAsm{evmVersion, false, {}};
+	auto sub_asm = std::make_shared<std::string>("sub.asm");
+	_subAsm.setSourceLocation({6, 8, sub_asm});
+	_subAsm.appendImmutable("someImmutable");
+	_subAsm.appendImmutable("someOtherImmutable");
+	_subAsm.appendImmutable("someImmutable");
+	std::shared_ptr<Assembly> _subAsmPtr = std::make_shared<Assembly>(_subAsm);
+
+	_assembly.append(u256(42));
+	_assembly.append(u256(0));
+	_assembly.appendImmutableAssignment("someImmutable");
+	_assembly.append(u256(23));
+	_assembly.append(u256(0));
+	_assembly.appendImmutableAssignment("someOtherImmutable");
+
+	auto sub = _assembly.appendSubroutine(_subAsmPtr);
+	_assembly.pushSubroutineOffset(static_cast<size_t>(sub.data()));
+
+	checkCompilation(_assembly);
+
+	std::string genericPush0 = evmVersion.hasPush0() ? "5f" : "6000";
+	// PUSH1 0x1b v/s PUSH1 0x19
+	std::string dataOffset = evmVersion.hasPush0() ? "6019" : "601b" ;
+
+	BOOST_CHECK_EQUAL(
+		_assembly.assemble().toHex(),
+		// root.asm
+		// assign "someImmutable"
+		"602a" + // PUSH1 42 - value for someImmutable
+		genericPush0 + // PUSH1 0 - offset of code into which to insert the immutable
+		"8181" // DUP2 DUP2
+		"6001" // PUSH1 1 - offset of first someImmutable in sub_0
+		"01" // ADD - add offset of immutable to offset of code
+		"52" // MSTORE
+		"6043" // PUSH1 67 - offset of second someImmutable in sub_0
+		"01" // ADD - add offset of immutable to offset of code
+		"52" // MSTORE
+		// assign "someOtherImmutable"
+		"6017" + // PUSH1 23 - value for someOtherImmutable
+		genericPush0 + // PUSH1 0 - offset of code into which to insert the immutable
+		"6022" // PUSH1 34 - offset of someOtherImmutable in sub_0
+		"01" // ADD - add offset of immutable to offset of code
+		"52" // MSTORE
+		"6063" + // PUSH1 0x63 - dataSize(sub_0)
+		dataOffset +  // PUSH1 0x23 - dataOffset(sub_0)
+		"fe" // INVALID
+		// end of root.asm
+		// sub.asm
+		"7f0000000000000000000000000000000000000000000000000000000000000000" // PUSHIMMUTABLE someImmutable - data at offset 1
+		"7f0000000000000000000000000000000000000000000000000000000000000000" // PUSHIMMUTABLE someOtherImmutable - data at offset 34
+		"7f0000000000000000000000000000000000000000000000000000000000000000" // PUSHIMMUTABLE someImmutable - data at offset 67
+	);
+	BOOST_CHECK_EQUAL(
+		_assembly.assemblyString(),
+		"    /* \"root.asm\":1:3   */\n"
+		"  0x2a\n"
+		"  0x00\n"
+		"  assignImmutable(\"0x26f2c0195e9d408feff3abd77d83f2971f3c9a18d1e8a9437c7835ae4211fc9f\")\n"
+		"  0x17\n"
+		"  0x00\n"
+		"  assignImmutable(\"0xc3978657661c4d8e32e3d5f42597c009f0d3859e9f9d0d94325268f9799e2bfb\")\n"
+		"  dataSize(sub_0)\n"
+		"  dataOffset(sub_0)\n"
+		"stop\n"
+		"\n"
+		"sub_0: assembly {\n"
+		"        /* \"sub.asm\":6:8   */\n"
+		"      immutable(\"0x26f2c0195e9d408feff3abd77d83f2971f3c9a18d1e8a9437c7835ae4211fc9f\")\n"
+		"      immutable(\"0xc3978657661c4d8e32e3d5f42597c009f0d3859e9f9d0d94325268f9799e2bfb\")\n"
+		"      immutable(\"0x26f2c0195e9d408feff3abd77d83f2971f3c9a18d1e8a9437c7835ae4211fc9f\")\n"
+		"}\n"
+	);
+	BOOST_CHECK_EQUAL(
+		util::jsonCompactPrint(_assembly.assemblyJSON(indices)),
+		"{\".code\":["
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"2A\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"0\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"ASSIGNIMMUTABLE\",\"source\":0,\"value\":\"someImmutable\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"17\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH\",\"source\":0,\"value\":\"0\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"ASSIGNIMMUTABLE\",\"source\":0,\"value\":\"someOtherImmutable\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH #[$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"},"
+		"{\"begin\":1,\"end\":3,\"name\":\"PUSH [$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"}"
+		"],\".data\":{\"0\":{\".code\":["
+		"{\"begin\":6,\"end\":8,\"name\":\"PUSHIMMUTABLE\",\"source\":1,\"value\":\"someImmutable\"},"
+		"{\"begin\":6,\"end\":8,\"name\":\"PUSHIMMUTABLE\",\"source\":1,\"value\":\"someOtherImmutable\"},"
+		"{\"begin\":6,\"end\":8,\"name\":\"PUSHIMMUTABLE\",\"source\":1,\"value\":\"someImmutable\"}"
+		"]}},\"sourceList\":[\"root.asm\",\"sub.asm\"]}"
+	);
+}
+
+BOOST_AUTO_TEST_CASE(subobject_encode_decode)
+{
+	EVMVersion evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	Assembly assembly{evmVersion, true, {}};
+
+	std::shared_ptr<Assembly> subAsmPtr = std::make_shared<Assembly>(evmVersion, false, std::string{});
+	std::shared_ptr<Assembly> subSubAsmPtr = std::make_shared<Assembly>(evmVersion, false, std::string{});
+
+	assembly.appendSubroutine(subAsmPtr);
+	subAsmPtr->appendSubroutine(subSubAsmPtr);
+
+	BOOST_CHECK(assembly.encodeSubPath({0}) == 0);
+	BOOST_REQUIRE_THROW(assembly.encodeSubPath({1}), solidity::evmasm::AssemblyException);
+	BOOST_REQUIRE_THROW(assembly.decodeSubPath(1), solidity::evmasm::AssemblyException);
+
+	std::vector<size_t> subPath{0, 0};
+	BOOST_CHECK(assembly.decodeSubPath(assembly.encodeSubPath(subPath)) == subPath);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libevmasm/Optimiser.cpp b/compiler/test/libevmasm/Optimiser.cpp
new file mode 100644
index 00000000..e1795d39
--- /dev/null
+++ b/compiler/test/libevmasm/Optimiser.cpp
@@ -0,0 +1,1920 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Tests for the Solidity optimizer.
+ */
+
+#include <test/Common.h>
+
+#include <libevmasm/CommonSubexpressionEliminator.h>
+#include <libevmasm/PeepholeOptimiser.h>
+#include <libevmasm/Inliner.h>
+#include <libevmasm/JumpdestRemover.h>
+#include <libevmasm/ControlFlowGraph.h>
+#include <libevmasm/BlockDeduplicator.h>
+#include <libevmasm/Assembly.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <range/v3/algorithm/any_of.hpp>
+
+#include <string>
+#include <tuple>
+#include <memory>
+
+using namespace solidity::langutil;
+using namespace solidity::evmasm;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+	AssemblyItems addDummyLocations(AssemblyItems const& _input)
+	{
+		// add dummy locations to each item so that we can check that they are not deleted
+		AssemblyItems input = _input;
+		for (AssemblyItem& item: input)
+			item.setLocation({1, 3, nullptr});
+		return input;
+	}
+
+	evmasm::KnownState createInitialState(AssemblyItems const& _input)
+	{
+		evmasm::KnownState state;
+		for (auto const& item: addDummyLocations(_input))
+			state.feedItem(item, true);
+		return state;
+	}
+
+	AssemblyItems CSE(AssemblyItems const& _input, evmasm::KnownState const& _state = evmasm::KnownState())
+	{
+		AssemblyItems input = addDummyLocations(_input);
+
+		bool usesMsize = ranges::any_of(_input, [](AssemblyItem const& _i) {
+			return _i == AssemblyItem{Instruction::MSIZE} || _i.type() == VerbatimBytecode;
+		});
+		evmasm::CommonSubexpressionEliminator cse(_state);
+		BOOST_REQUIRE(cse.feedItems(input.begin(), input.end(), usesMsize) == input.end());
+		AssemblyItems output = cse.getOptimizedItems();
+
+		for (AssemblyItem const& item: output)
+		{
+			BOOST_CHECK(item == Instruction::POP || item.location().isValid());
+		}
+		return output;
+	}
+
+	void checkCSE(
+		AssemblyItems const& _input,
+		AssemblyItems const& _expectation,
+		KnownState const& _state = evmasm::KnownState()
+	)
+	{
+		AssemblyItems output = CSE(_input, _state);
+		BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
+	}
+
+	/// In contrast to the function `CSE`, this function doesn't finish the CSE optimization on an
+	/// instruction that breaks CSE Analysis block. Copied from Assembly.cpp
+	AssemblyItems fullCSE(AssemblyItems const& _input)
+	{
+		AssemblyItems optimisedItems;
+
+		bool usesMSize = ranges::any_of(_input, [](AssemblyItem const& _i) {
+			return _i == AssemblyItem{Instruction::MSIZE} || _i.type() == VerbatimBytecode;
+		});
+
+		auto iter = _input.begin();
+		while (iter != _input.end())
+		{
+			KnownState emptyState;
+			CommonSubexpressionEliminator eliminator{emptyState};
+			auto orig = iter;
+			iter = eliminator.feedItems(iter, _input.end(), usesMSize);
+			bool shouldReplace = false;
+			AssemblyItems optimisedChunk;
+			optimisedChunk = eliminator.getOptimizedItems();
+			shouldReplace = (optimisedChunk.size() < static_cast<size_t>(iter - orig));
+			if (shouldReplace)
+				optimisedItems += optimisedChunk;
+			else
+				copy(orig, iter, back_inserter(optimisedItems));
+		}
+
+		return optimisedItems;
+	}
+
+	void checkFullCSE(
+		AssemblyItems const& _input,
+		AssemblyItems const& _expectation
+	)
+	{
+		AssemblyItems output = fullCSE(_input);
+		BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
+	}
+
+	AssemblyItems CFG(AssemblyItems const& _input)
+	{
+		AssemblyItems output = _input;
+		// Running it four times should be enough for these tests.
+		for (unsigned i = 0; i < 4; ++i)
+		{
+			ControlFlowGraph cfg(output);
+			AssemblyItems optItems;
+			for (BasicBlock const& block: cfg.optimisedBlocks())
+				copy(output.begin() + static_cast<int>(block.begin), output.begin() + static_cast<int>(block.end),
+					 back_inserter(optItems));
+			output = std::move(optItems);
+		}
+		return output;
+	}
+
+	void checkCFG(AssemblyItems const& _input, AssemblyItems const& _expectation)
+	{
+		AssemblyItems output = CFG(_input);
+		BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
+	}
+}
+
+BOOST_AUTO_TEST_SUITE(Optimiser)
+
+BOOST_AUTO_TEST_CASE(cse_push_immutable_same)
+{
+	AssemblyItem pushImmutable{PushImmutable, 0x1234};
+	checkCSE({pushImmutable, pushImmutable}, {pushImmutable, Instruction::DUP1});
+}
+
+BOOST_AUTO_TEST_CASE(cse_push_immutable_different)
+{
+	AssemblyItems input{{PushImmutable, 0x1234},{PushImmutable, 0xABCD}};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_assign_immutable)
+{
+	{
+		AssemblyItems input{u256(0x42), {AssignImmutable, 0x1234}};
+		checkCSE(input, input);
+	}
+	{
+		AssemblyItems input{{AssignImmutable, 0x1234}};
+		checkCSE(input, input);
+	}
+}
+
+
+BOOST_AUTO_TEST_CASE(cse_assign_immutable_breaks)
+{
+	AssemblyItems input = addDummyLocations(AssemblyItems{
+		u256(0x42),
+		{AssignImmutable, 0x1234},
+		Instruction::ORIGIN
+	});
+
+	evmasm::CommonSubexpressionEliminator cse{evmasm::KnownState()};
+	// Make sure CSE breaks after AssignImmutable.
+	BOOST_REQUIRE(cse.feedItems(input.begin(), input.end(), false) == input.begin() + 2);
+}
+
+BOOST_AUTO_TEST_CASE(cse_intermediate_swap)
+{
+	evmasm::KnownState state;
+	evmasm::CommonSubexpressionEliminator cse(state);
+	AssemblyItems input{
+		Instruction::SWAP1, Instruction::POP, Instruction::ADD, u256(0), Instruction::SWAP1,
+		Instruction::SLOAD, Instruction::SWAP1, u256(100), Instruction::EXP, Instruction::SWAP1,
+		Instruction::DIV, u256(0xff), Instruction::AND
+	};
+	BOOST_REQUIRE(cse.feedItems(input.begin(), input.end(), false) == input.end());
+	AssemblyItems output = cse.getOptimizedItems();
+	BOOST_CHECK(!output.empty());
+}
+
+BOOST_AUTO_TEST_CASE(cse_negative_stack_access)
+{
+	AssemblyItems input{Instruction::DUP2, u256(0)};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_negative_stack_end)
+{
+	AssemblyItems input{Instruction::ADD};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_intermediate_negative_stack)
+{
+	AssemblyItems input{Instruction::ADD, u256(1), Instruction::DUP1};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_pop)
+{
+	checkCSE({Instruction::POP}, {Instruction::POP});
+}
+
+BOOST_AUTO_TEST_CASE(cse_unneeded_items)
+{
+	AssemblyItems input{
+		Instruction::ADD,
+		Instruction::SWAP1,
+		Instruction::POP,
+		u256(7),
+		u256(8),
+	};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_constant_addition)
+{
+	AssemblyItems input{u256(7), u256(8), Instruction::ADD};
+	checkCSE(input, {u256(7 + 8)});
+}
+
+BOOST_AUTO_TEST_CASE(cse_invariants)
+{
+	AssemblyItems input{
+		Instruction::DUP1,
+		Instruction::DUP1,
+		u256(0),
+		Instruction::OR,
+		Instruction::OR
+	};
+	checkCSE(input, {Instruction::DUP1});
+}
+
+BOOST_AUTO_TEST_CASE(cse_subself)
+{
+	checkCSE({Instruction::DUP1, Instruction::SUB}, {Instruction::POP, u256(0)});
+}
+
+BOOST_AUTO_TEST_CASE(cse_subother)
+{
+	checkCSE({Instruction::SUB}, {Instruction::SUB});
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_negation)
+{
+	checkCSE({Instruction::DUP5, Instruction::NOT, Instruction::NOT}, {Instruction::DUP5});
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_iszero)
+{
+	checkCSE({Instruction::GT, Instruction::ISZERO, Instruction::ISZERO}, {Instruction::GT});
+	checkCSE({Instruction::GT, Instruction::ISZERO}, {Instruction::GT, Instruction::ISZERO});
+	checkCSE(
+		{Instruction::ISZERO, Instruction::ISZERO, Instruction::ISZERO},
+		{Instruction::ISZERO}
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cse_associativity)
+{
+	AssemblyItems input{
+		Instruction::DUP1,
+		Instruction::DUP1,
+		u256(0),
+		Instruction::OR,
+		Instruction::OR
+	};
+	checkCSE(input, {Instruction::DUP1});
+}
+
+BOOST_AUTO_TEST_CASE(cse_associativity2)
+{
+	AssemblyItems input{
+		u256(0),
+		Instruction::DUP2,
+		u256(2),
+		u256(1),
+		Instruction::DUP6,
+		Instruction::ADD,
+		u256(2),
+		Instruction::ADD,
+		Instruction::ADD,
+		Instruction::ADD,
+		Instruction::ADD
+	};
+	checkCSE(input, {Instruction::DUP2, Instruction::DUP2, Instruction::ADD, u256(5), Instruction::ADD});
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_shift_right_overflow)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+	{
+		AssemblyItems input{
+			Instruction::CALLVALUE,
+			u256(2),
+			Instruction::SHR,
+			u256(-1),
+			Instruction::SHR
+		};
+		checkCSE(input, {u256(0)});
+	}
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_shift_left_overflow)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+	{
+		AssemblyItems input{
+			Instruction::DUP1,
+			u256(2),
+			Instruction::SHL,
+			u256(-1),
+			Instruction::SHL
+		};
+		checkCSE(input, {u256(0)});
+	}
+}
+
+BOOST_AUTO_TEST_CASE(cse_byte_ordering_bug)
+{
+	AssemblyItems input{
+		u256(31),
+		Instruction::CALLVALUE,
+		Instruction::BYTE
+	};
+	checkCSE(input, {u256(31), Instruction::CALLVALUE, Instruction::BYTE});
+}
+
+BOOST_AUTO_TEST_CASE(cse_byte_ordering_fix)
+{
+	AssemblyItems input{
+		Instruction::CALLVALUE,
+		u256(31),
+		Instruction::BYTE
+	};
+	checkCSE(input, {u256(0xff), Instruction::CALLVALUE, Instruction::AND});
+}
+
+BOOST_AUTO_TEST_CASE(cse_storage)
+{
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+		u256(0),
+		Instruction::SLOAD,
+		Instruction::ADD,
+		u256(0),
+		Instruction::SSTORE
+	};
+	checkCSE(input, {
+		u256(0),
+		Instruction::DUP1,
+		Instruction::SLOAD,
+		Instruction::DUP1,
+		Instruction::ADD,
+		Instruction::SWAP1,
+		Instruction::SSTORE
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_noninterleaved_storage)
+{
+	// two stores to the same location should be replaced by only one store, even if we
+	// read in the meantime
+	AssemblyItems input{
+		u256(7),
+		Instruction::DUP2,
+		Instruction::SSTORE,
+		Instruction::DUP1,
+		Instruction::SLOAD,
+		u256(8),
+		Instruction::DUP3,
+		Instruction::SSTORE
+	};
+	checkCSE(input, {
+		u256(8),
+		Instruction::DUP2,
+		Instruction::SSTORE,
+		u256(7)
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage)
+{
+	// stores and reads to/from two unknown locations, should not optimize away the first store
+	AssemblyItems input{
+		u256(7),
+		Instruction::DUP2,
+		Instruction::SSTORE, // store to "DUP1"
+		Instruction::DUP2,
+		Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
+		u256(0),
+		Instruction::DUP3,
+		Instruction::SSTORE // store different value to "DUP1"
+	};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_same_value)
+{
+	// stores and reads to/from two unknown locations, should not optimize away the first store
+	// but it should optimize away the second, since we already know the value will be the same
+	AssemblyItems input{
+		u256(7),
+		Instruction::DUP2,
+		Instruction::SSTORE, // store to "DUP1"
+		Instruction::DUP2,
+		Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
+		u256(6),
+		u256(1),
+		Instruction::ADD,
+		Instruction::DUP3,
+		Instruction::SSTORE // store same value to "DUP1"
+	};
+	checkCSE(input, {
+		u256(7),
+		Instruction::DUP2,
+		Instruction::SSTORE,
+		Instruction::DUP2,
+		Instruction::SLOAD
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location)
+{
+	// stores and reads to/from two known locations, should optimize away the first store,
+	// because we know that the location is different
+	AssemblyItems input{
+		u256(0x70),
+		u256(1),
+		Instruction::SSTORE, // store to 1
+		u256(2),
+		Instruction::SLOAD, // read from 2, is different from 1
+		u256(0x90),
+		u256(1),
+		Instruction::SSTORE // store different value at 1
+	};
+	checkCSE(input, {
+		u256(2),
+		Instruction::SLOAD,
+		u256(0x90),
+		u256(1),
+		Instruction::SSTORE
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location_offset)
+{
+	// stores and reads to/from two locations which are known to be different,
+	// should optimize away the first store, because we know that the location is different
+	AssemblyItems input{
+		u256(0x70),
+		Instruction::DUP2,
+		u256(1),
+		Instruction::ADD,
+		Instruction::SSTORE, // store to "DUP1"+1
+		Instruction::DUP1,
+		u256(2),
+		Instruction::ADD,
+		Instruction::SLOAD, // read from "DUP1"+2, is different from "DUP1"+1
+		u256(0x90),
+		Instruction::DUP3,
+		u256(1),
+		Instruction::ADD,
+		Instruction::SSTORE // store different value at "DUP1"+1
+	};
+	checkCSE(input, {
+		u256(2),
+		Instruction::DUP2,
+		Instruction::ADD,
+		Instruction::SLOAD,
+		u256(0x90),
+		u256(1),
+		Instruction::DUP4,
+		Instruction::ADD,
+		Instruction::SSTORE
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_deep_stack)
+{
+	AssemblyItems input{
+		Instruction::ADD,
+		Instruction::SWAP1,
+		Instruction::POP,
+		Instruction::SWAP8,
+		Instruction::POP,
+		Instruction::SWAP8,
+		Instruction::POP,
+		Instruction::SWAP8,
+		Instruction::SWAP5,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+	};
+	checkCSE(input, {
+		Instruction::SWAP4,
+		Instruction::SWAP12,
+		Instruction::SWAP3,
+		Instruction::SWAP11,
+		Instruction::POP,
+		Instruction::SWAP1,
+		Instruction::SWAP3,
+		Instruction::ADD,
+		Instruction::SWAP8,
+		Instruction::POP,
+		Instruction::SWAP6,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+		Instruction::POP,
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_jumpi_no_jump)
+{
+	AssemblyItems input{
+		u256(0),
+		u256(1),
+		Instruction::DUP2,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI
+	};
+	checkCSE(input, {
+		u256(0),
+		u256(1)
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_jumpi_jump)
+{
+	AssemblyItems input{
+		u256(1),
+		u256(1),
+		Instruction::DUP2,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI
+	};
+	checkCSE(input, {
+		u256(1),
+		Instruction::DUP1,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_empty_keccak256)
+{
+	AssemblyItems input{
+		u256(0),
+		Instruction::DUP2,
+		Instruction::KECCAK256
+	};
+	checkCSE(input, {
+		u256(util::keccak256(bytesConstRef()))
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_partial_keccak256)
+{
+	AssemblyItems input{
+		u256(0xabcd) << (256 - 16),
+		u256(0),
+		Instruction::MSTORE,
+		u256(2),
+		u256(0),
+		Instruction::KECCAK256
+	};
+	checkCSE(input, {
+		u256(0xabcd) << (256 - 16),
+		u256(0),
+		Instruction::MSTORE,
+		u256(util::keccak256(bytes{0xab, 0xcd}))
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_location)
+{
+	// Keccak-256 twice from same dynamic location
+	AssemblyItems input{
+		Instruction::DUP2,
+		Instruction::DUP1,
+		Instruction::MSTORE,
+		u256(64),
+		Instruction::DUP2,
+		Instruction::KECCAK256,
+		u256(64),
+		Instruction::DUP3,
+		Instruction::KECCAK256
+	};
+	checkCSE(input, {
+		Instruction::DUP2,
+		Instruction::DUP1,
+		Instruction::MSTORE,
+		u256(64),
+		Instruction::DUP2,
+		Instruction::KECCAK256,
+		Instruction::DUP1
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content)
+{
+	// Keccak-256 twice from different dynamic location but with same content
+	AssemblyItems input{
+		Instruction::DUP1,
+		u256(0x80),
+		Instruction::MSTORE, // m[128] = DUP1
+		u256(0x20),
+		u256(0x80),
+		Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+		Instruction::DUP2,
+		u256(12),
+		Instruction::MSTORE, // m[12] = DUP1
+		u256(0x20),
+		u256(12),
+		Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+	};
+	checkCSE(input, {
+		u256(0x80),
+		Instruction::DUP2,
+		Instruction::DUP2,
+		Instruction::MSTORE,
+		u256(0x20),
+		Instruction::SWAP1,
+		Instruction::KECCAK256,
+		u256(12),
+		Instruction::DUP3,
+		Instruction::SWAP1,
+		Instruction::MSTORE,
+		Instruction::DUP1
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_dynamic_store_in_between)
+{
+	// Keccak-256 twice from different dynamic location but with same content,
+	// dynamic mstore in between, which forces us to re-calculate the hash
+	AssemblyItems input{
+		u256(0x80),
+		Instruction::DUP2,
+		Instruction::DUP2,
+		Instruction::MSTORE, // m[128] = DUP1
+		u256(0x20),
+		Instruction::DUP1,
+		Instruction::DUP3,
+		Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+		u256(12),
+		Instruction::DUP5,
+		Instruction::DUP2,
+		Instruction::MSTORE, // m[12] = DUP1
+		Instruction::DUP12,
+		Instruction::DUP14,
+		Instruction::MSTORE, // destroys memory knowledge
+		Instruction::SWAP2,
+		Instruction::SWAP1,
+		Instruction::SWAP2,
+		Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+	};
+	checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_noninterfering_store_in_between)
+{
+	// Keccak-256 twice from different dynamic location but with same content,
+	// dynamic mstore in between, but does not force us to re-calculate the hash
+	AssemblyItems input{
+		u256(0x80),
+		Instruction::DUP2,
+		Instruction::DUP2,
+		Instruction::MSTORE, // m[128] = DUP1
+		u256(0x20),
+		Instruction::DUP1,
+		Instruction::DUP3,
+		Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+		u256(12),
+		Instruction::DUP5,
+		Instruction::DUP2,
+		Instruction::MSTORE, // m[12] = DUP1
+		Instruction::DUP12,
+		u256(12 + 32),
+		Instruction::MSTORE, // does not destroy memory knowledge
+		Instruction::DUP13,
+		u256(128 - 32),
+		Instruction::MSTORE, // does not destroy memory knowledge
+		u256(0x20),
+		u256(12),
+		Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+	};
+	// if this changes too often, only count the number of SHA3 and MSTORE instructions
+	AssemblyItems output = CSE(input);
+	BOOST_CHECK_EQUAL(4, count(output.begin(), output.end(), AssemblyItem(Instruction::MSTORE)));
+	BOOST_CHECK_EQUAL(1, count(output.begin(), output.end(), AssemblyItem(Instruction::KECCAK256)));
+}
+
+BOOST_AUTO_TEST_CASE(cse_with_initially_known_stack)
+{
+	evmasm::KnownState state = createInitialState(AssemblyItems{
+		u256(0x12),
+		u256(0x20),
+		Instruction::ADD
+	});
+	AssemblyItems input{
+		u256(0x12 + 0x20)
+	};
+	checkCSE(input, AssemblyItems{Instruction::DUP1}, state);
+}
+
+BOOST_AUTO_TEST_CASE(cse_equality_on_initially_known_stack)
+{
+	evmasm::KnownState state = createInitialState(AssemblyItems{Instruction::DUP1});
+	AssemblyItems input{
+		Instruction::EQ
+	};
+	AssemblyItems output = CSE(input, state);
+	// check that it directly pushes 1 (true)
+	BOOST_CHECK(find(output.begin(), output.end(), AssemblyItem(u256(1))) != output.end());
+}
+
+BOOST_AUTO_TEST_CASE(cse_access_previous_sequence)
+{
+	// Tests that the code generator detects whether it tries to access SLOAD instructions
+	// from a sequenced expression which is not in its scope.
+	evmasm::KnownState state = createInitialState(AssemblyItems{
+		u256(0),
+		Instruction::SLOAD,
+		u256(1),
+		Instruction::ADD,
+		u256(0),
+		Instruction::SSTORE
+	});
+	// now stored: val_1 + 1 (value at sequence 1)
+	// if in the following instructions, the SLOAD cresolves to "val_1 + 1",
+	// this cannot be generated because we cannot load from sequence 1 anymore.
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+	};
+	BOOST_CHECK_THROW(CSE(input, state), StackTooDeepException);
+	// @todo for now, this throws an exception, but it should recover to the following
+	// (or an even better version) at some point:
+	// 0, SLOAD, 1, ADD, SSTORE, 0 SLOAD
+}
+
+BOOST_AUTO_TEST_CASE(cse_optimise_return)
+{
+	checkCSE(
+		AssemblyItems{u256(0), u256(7), Instruction::RETURN},
+		AssemblyItems{Instruction::STOP}
+	);
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused)
+{
+	// remove parts of the code that are unused
+	AssemblyItems input{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		u256(7),
+		AssemblyItem(Tag, 1),
+	};
+	checkCFG(input, {});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused_loop)
+{
+	AssemblyItems input{
+		AssemblyItem(PushTag, 3),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(7),
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(8),
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 3),
+		u256(11)
+	};
+	checkCFG(input, {u256(11)});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_reconnect_single_jump_source)
+{
+	// move code that has only one unconditional jump source
+	AssemblyItems input{
+		u256(1),
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(2),
+		AssemblyItem(PushTag, 3),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(3),
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 3),
+		u256(4),
+	};
+	checkCFG(input, {u256(1), u256(3), u256(2), u256(4)});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_do_not_remove_returned_to)
+{
+	// do not remove parts that are "returned to"
+	AssemblyItems input{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(2)
+	};
+	checkCFG(input, {u256(2)});
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator)
+{
+	AssemblyItems input{
+		AssemblyItem(PushTag, 2),
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 3),
+		u256(6),
+		Instruction::SWAP3,
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(6),
+		Instruction::SWAP3,
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(6),
+		Instruction::SWAP3,
+		Instruction::JUMP,
+		AssemblyItem(Tag, 3)
+	};
+	BlockDeduplicator deduplicator(input);
+	deduplicator.deduplicate();
+
+	std::set<u256> pushTags;
+	for (AssemblyItem const& item: input)
+		if (item.type() == PushTag)
+			pushTags.insert(item.data());
+	BOOST_CHECK_EQUAL(pushTags.size(), 2);
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator_assign_immutable_same)
+{
+	AssemblyItems blocks{
+		AssemblyItem(Tag, 1),
+		u256(42),
+		AssemblyItem{AssignImmutable, 0x1234},
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(42),
+		AssemblyItem{AssignImmutable, 0x1234},
+		Instruction::JUMP
+	};
+
+	AssemblyItems input = AssemblyItems{
+		AssemblyItem(PushTag, 2),
+		AssemblyItem(PushTag, 1),
+	} + blocks;
+	AssemblyItems output = AssemblyItems{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 1),
+	} + blocks;
+	BlockDeduplicator deduplicator(input);
+	deduplicator.deduplicate();
+	BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end());
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator_assign_immutable_different_value)
+{
+	AssemblyItems input{
+		AssemblyItem(PushTag, 2),
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(Tag, 1),
+		u256(42),
+		AssemblyItem{AssignImmutable, 0x1234},
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(23),
+		AssemblyItem{AssignImmutable, 0x1234},
+		Instruction::JUMP
+	};
+	BlockDeduplicator deduplicator(input);
+	BOOST_CHECK(!deduplicator.deduplicate());
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator_assign_immutable_different_hash)
+{
+	AssemblyItems input{
+		AssemblyItem(PushTag, 2),
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(Tag, 1),
+		u256(42),
+		AssemblyItem{AssignImmutable, 0x1234},
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(42),
+		AssemblyItem{AssignImmutable, 0xABCD},
+		Instruction::JUMP
+	};
+	BlockDeduplicator deduplicator(input);
+	BOOST_CHECK(!deduplicator.deduplicate());
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator_loops)
+{
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMPI,
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(5),
+		u256(6),
+		Instruction::SSTORE,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(5),
+		u256(6),
+		Instruction::SSTORE,
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMP,
+	};
+	BlockDeduplicator deduplicator(input);
+	deduplicator.deduplicate();
+
+	std::set<u256> pushTags;
+	for (AssemblyItem const& item: input)
+		if (item.type() == PushTag)
+			pushTags.insert(item.data());
+	BOOST_CHECK_EQUAL(pushTags.size(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(clear_unreachable_code)
+{
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		u256(0),
+		Instruction::SLOAD,
+		AssemblyItem(Tag, 2),
+		u256(5),
+		u256(6),
+		Instruction::SSTORE,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		u256(5),
+		u256(6)
+	};
+	AssemblyItems expectation{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 2),
+		u256(5),
+		u256(6),
+		Instruction::SSTORE,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP
+	};
+	PeepholeOptimiser peepOpt(items);
+	BOOST_REQUIRE(peepOpt.optimise());
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(peephole_double_push)
+{
+	AssemblyItems items{
+		u256(0),
+		u256(0),
+		u256(5),
+		u256(5),
+		u256(4),
+		u256(5)
+	};
+	AssemblyItems expectation{
+		u256(0),
+		Instruction::DUP1,
+		u256(5),
+		Instruction::DUP1,
+		u256(4),
+		u256(5)
+	};
+	PeepholeOptimiser peepOpt(items);
+	BOOST_REQUIRE(peepOpt.optimise());
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(peephole_pop_calldatasize)
+{
+	AssemblyItems items{
+		u256(4),
+		Instruction::CALLDATASIZE,
+		Instruction::LT,
+		Instruction::POP
+	};
+	PeepholeOptimiser peepOpt(items);
+	for (size_t i = 0; i < 3; i++)
+		BOOST_CHECK(peepOpt.optimise());
+	BOOST_CHECK(items.empty());
+}
+
+BOOST_AUTO_TEST_CASE(peephole_commutative_swap1)
+{
+	std::vector<Instruction> ops{
+		Instruction::ADD,
+		Instruction::MUL,
+		Instruction::EQ,
+		Instruction::AND,
+		Instruction::OR,
+		Instruction::XOR
+	};
+	for (Instruction const op: ops)
+	{
+		AssemblyItems items{
+			u256(1),
+			u256(2),
+			Instruction::SWAP1,
+			op,
+			u256(4),
+			u256(5)
+		};
+		AssemblyItems expectation{
+			u256(1),
+			u256(2),
+			op,
+			u256(4),
+			u256(5)
+		};
+		PeepholeOptimiser peepOpt(items);
+		BOOST_REQUIRE(peepOpt.optimise());
+		BOOST_CHECK_EQUAL_COLLECTIONS(
+			items.begin(), items.end(),
+			expectation.begin(), expectation.end()
+		);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(peephole_noncommutative_swap1)
+{
+	// NOTE: not comprehensive
+	std::vector<Instruction> ops{
+		Instruction::SUB,
+		Instruction::DIV,
+		Instruction::SDIV,
+		Instruction::MOD,
+		Instruction::SMOD,
+		Instruction::EXP
+	};
+	for (Instruction const op: ops)
+	{
+		AssemblyItems items{
+			u256(1),
+			u256(2),
+			Instruction::SWAP1,
+			op,
+			u256(4),
+			u256(5)
+		};
+		AssemblyItems expectation{
+			u256(1),
+			u256(2),
+			Instruction::SWAP1,
+			op,
+			u256(4),
+			u256(5)
+		};
+		PeepholeOptimiser peepOpt(items);
+		BOOST_REQUIRE(!peepOpt.optimise());
+		BOOST_CHECK_EQUAL_COLLECTIONS(
+			items.begin(), items.end(),
+			expectation.begin(), expectation.end()
+		);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(peephole_swap_comparison)
+{
+	std::map<Instruction, Instruction> swappableOps{
+		{ Instruction::LT, Instruction::GT },
+		{ Instruction::GT, Instruction::LT },
+		{ Instruction::SLT, Instruction::SGT },
+		{ Instruction::SGT, Instruction::SLT }
+	};
+
+	for (auto const& op: swappableOps)
+	{
+		AssemblyItems items{
+			u256(1),
+			u256(2),
+			Instruction::SWAP1,
+			op.first,
+			u256(4),
+			u256(5)
+		};
+		AssemblyItems expectation{
+			u256(1),
+			u256(2),
+			op.second,
+			u256(4),
+			u256(5)
+		};
+		PeepholeOptimiser peepOpt(items);
+		BOOST_REQUIRE(peepOpt.optimise());
+		BOOST_CHECK_EQUAL_COLLECTIONS(
+			items.begin(), items.end(),
+			expectation.begin(), expectation.end()
+		);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(peephole_truthy_and)
+{
+	AssemblyItems items{
+		AssemblyItem(Tag, 1),
+		Instruction::BALANCE,
+		u256(0),
+		Instruction::NOT,
+		Instruction::AND,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI
+	};
+	AssemblyItems expectation{
+		AssemblyItem(Tag, 1),
+		Instruction::BALANCE,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI
+	};
+	PeepholeOptimiser peepOpt(items);
+	BOOST_REQUIRE(peepOpt.optimise());
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+
+BOOST_AUTO_TEST_CASE(peephole_iszero_iszero_jumpi)
+{
+	AssemblyItems items{
+		AssemblyItem(Tag, 1),
+		u256(0),
+		Instruction::CALLDATALOAD,
+		Instruction::ISZERO,
+		Instruction::ISZERO,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI,
+		u256(0),
+		u256(0x20),
+		Instruction::RETURN
+	};
+	AssemblyItems expectation{
+		AssemblyItem(Tag, 1),
+		u256(0),
+		Instruction::CALLDATALOAD,
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI,
+		u256(0),
+		u256(0x20),
+		Instruction::RETURN
+	};
+	PeepholeOptimiser peepOpt(items);
+	BOOST_REQUIRE(peepOpt.optimise());
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+	  items.begin(), items.end(),
+	  expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(jumpdest_removal)
+{
+	AssemblyItems items{
+		AssemblyItem(Tag, 2),
+		AssemblyItem(PushTag, 1),
+		u256(5),
+		AssemblyItem(Tag, 10),
+		AssemblyItem(Tag, 3),
+		u256(6),
+		AssemblyItem(Tag, 1),
+		Instruction::JUMP,
+	};
+	AssemblyItems expectation{
+		AssemblyItem(PushTag, 1),
+		u256(5),
+		u256(6),
+		AssemblyItem(Tag, 1),
+		Instruction::JUMP
+	};
+	JumpdestRemover jdr(items);
+	BOOST_REQUIRE(jdr.optimise({}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(jumpdest_removal_subassemblies)
+{
+	// This tests that tags from subassemblies are not removed
+	// if they are referenced by a super-assembly. Furthermore,
+	// tag unifications (due to block deduplication) is also
+	// visible at the super-assembly.
+
+	Assembly::OptimiserSettings settings;
+	settings.runInliner = false;
+	settings.runJumpdestRemover = true;
+	settings.runPeephole = true;
+	settings.runDeduplicate = true;
+	settings.runCSE = true;
+	settings.runConstantOptimiser = true;
+	settings.evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	settings.expectedExecutionsPerDeployment = OptimiserSettings{}.expectedExecutionsPerDeployment;
+
+	Assembly main{settings.evmVersion, false, {}};
+	AssemblyPointer sub = std::make_shared<Assembly>(settings.evmVersion, true, std::string{});
+
+	sub->append(u256(1));
+	auto t1 = sub->newTag();
+	sub->append(t1);
+	sub->append(u256(2));
+	sub->append(Instruction::JUMP);
+	auto t2 = sub->newTag();
+	sub->append(t2); // Identical to T1, will be unified
+	sub->append(u256(2));
+	sub->append(Instruction::JUMP);
+	auto t3 = sub->newTag();
+	sub->append(t3);
+	auto t4 = sub->newTag();
+	sub->append(t4);
+	auto t5 = sub->newTag();
+	sub->append(t5); // This will be removed
+	sub->append(u256(7));
+	sub->append(t4.pushTag());
+	sub->append(Instruction::JUMP);
+
+	size_t subId = static_cast<size_t>(main.appendSubroutine(sub).data());
+	main.append(t1.toSubAssemblyTag(subId));
+	main.append(t1.toSubAssemblyTag(subId));
+	main.append(u256(8));
+
+	main.optimise(settings);
+
+	AssemblyItems expectationMain{
+		AssemblyItem(PushSubSize, 0),
+		t1.toSubAssemblyTag(subId).pushTag(),
+		t1.toSubAssemblyTag(subId).pushTag(),
+		u256(8)
+	};
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		main.items().begin(), main.items().end(),
+		expectationMain.begin(), expectationMain.end()
+	);
+
+	AssemblyItems expectationSub{
+		u256(1), t1.tag(), u256(2), Instruction::JUMP, t4.tag(), u256(7), t4.pushTag(), Instruction::JUMP
+	};
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		sub->items().begin(), sub->items().end(),
+		expectationSub.begin(), expectationSub.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cse_sub_zero)
+{
+	checkCSE({
+		u256(0),
+		Instruction::DUP2,
+		Instruction::SUB
+	}, {
+		Instruction::DUP1
+	});
+
+	checkCSE({
+		Instruction::DUP1,
+		u256(0),
+		Instruction::SUB
+	}, {
+		u256(0),
+		Instruction::DUP2,
+		Instruction::SWAP1,
+		Instruction::SUB
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_simple_verbatim)
+{
+	auto verbatim = AssemblyItem{bytes{1, 2, 3, 4, 5}, 0, 0};
+	AssemblyItems input{verbatim};
+	checkCSE(input, input);
+	checkFullCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_mload_pop)
+{
+	AssemblyItems input{
+		u256(1000),
+		Instruction::MLOAD,
+		Instruction::POP,
+	};
+
+	AssemblyItems output{
+	};
+
+	checkCSE(input, output);
+	checkFullCSE(input, output);
+}
+
+BOOST_AUTO_TEST_CASE(cse_verbatim_mload)
+{
+	auto verbatim = AssemblyItem{bytes{1, 2, 3, 4, 5}, 0, 0};
+	AssemblyItems input{
+		u256(1000),
+		Instruction::MLOAD,	// Should not be removed
+		Instruction::POP,
+		verbatim,
+		u256(1000),
+		Instruction::MLOAD,	// Should not be removed
+		Instruction::POP,
+	};
+
+	checkFullCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_sload_verbatim_dup)
+{
+	auto verbatim = AssemblyItem{bytes{1, 2, 3, 4, 5}, 0, 0};
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+		u256(0),
+		Instruction::SLOAD,
+		verbatim
+	};
+
+	AssemblyItems output{
+		u256(0),
+		Instruction::SLOAD,
+		Instruction::DUP1,
+		verbatim
+	};
+
+	checkCSE(input, output);
+	checkFullCSE(input, output);
+}
+
+BOOST_AUTO_TEST_CASE(cse_verbatim_sload_sideeffect)
+{
+	auto verbatim = AssemblyItem{bytes{1, 2, 3, 4, 5}, 0, 0};
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+		verbatim,
+		u256(0),
+		Instruction::SLOAD,
+	};
+
+	checkFullCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_verbatim_eq)
+{
+	auto verbatim = AssemblyItem{bytes{1, 2, 3, 4, 5}, 0, 0};
+	AssemblyItems input{
+		u256(0),
+		Instruction::SLOAD,
+		verbatim,
+		Instruction::DUP1,
+		Instruction::EQ
+	};
+
+	checkFullCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(verbatim_knownstate)
+{
+	KnownState state = createInitialState(AssemblyItems{
+			Instruction::DUP1,
+			Instruction::DUP2,
+			Instruction::DUP3,
+			Instruction::DUP4
+		});
+	std::map<int, unsigned> const& stackElements = state.stackElements();
+
+	BOOST_CHECK(state.stackHeight() == 4);
+	// One more than stack height because of the initial unknown element.
+	BOOST_CHECK(stackElements.size() == 5);
+	BOOST_CHECK(stackElements.count(0));
+	unsigned initialElement = stackElements.at(0);
+	// Check if all the DUPs were correctly matched to the same class.
+	for (auto const& height: {1, 2, 3, 4})
+		BOOST_CHECK(stackElements.at(height) == initialElement);
+
+	auto verbatim2i5o = AssemblyItem{bytes{1, 2, 3, 4, 5}, 2, 5};
+	state.feedItem(verbatim2i5o);
+
+	BOOST_CHECK(state.stackHeight() == 7);
+	// Stack elements
+	// Before verbatim: {{0, x}, {1, x}, {2, x}, {3, x}, {4, x}}
+	// After verbatim: {{0, x}, {1, x}, {2, x}, {3, a}, {4, b}, {5, c}, {6, d}, {7, e}}
+	BOOST_CHECK(stackElements.size() == 8);
+
+	for (auto const& height: {1, 2})
+		BOOST_CHECK(stackElements.at(height) == initialElement);
+
+	for (auto const& height: {3, 4, 5, 6, 7})
+		BOOST_CHECK(stackElements.at(height) != initialElement);
+
+	for (auto const& height1: {3, 4, 5, 6, 7})
+		for (auto const& height2: {3, 4, 5, 6, 7})
+			if (height1 < height2)
+				BOOST_CHECK(stackElements.at(height1) != stackElements.at(height2));
+}
+
+BOOST_AUTO_TEST_CASE(cse_remove_redundant_shift_masking)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+		return;
+
+	for (unsigned i = 1; i < 256; i++)
+	{
+		checkCSE({
+			u256(boost::multiprecision::pow(u256(2), i) - 1),
+			Instruction::CALLVALUE,
+			u256(256-i),
+			Instruction::SHR,
+			Instruction::AND
+		}, {
+			Instruction::CALLVALUE,
+			u256(256-i),
+			Instruction::SHR,
+		});
+
+		checkCSE({
+			Instruction::CALLVALUE,
+			u256(256-i),
+			Instruction::SHR,
+			u256(boost::multiprecision::pow(u256(2), i)-1),
+			Instruction::AND
+		}, {
+			Instruction::CALLVALUE,
+			u256(256-i),
+			Instruction::SHR,
+		});
+	}
+
+	// Check that opt. does NOT trigger
+	for (unsigned i = 1; i < 255; i++)
+	{
+		checkCSE({
+			u256(boost::multiprecision::pow(u256(2), i) - 1),
+			Instruction::CALLVALUE,
+			u256(255-i),
+			Instruction::SHR,
+			Instruction::AND
+		}, { // Opt. did some reordering
+			Instruction::CALLVALUE,
+			u256(255-i),
+			Instruction::SHR,
+			u256(boost::multiprecision::pow(u256(2), i)-1),
+			Instruction::AND
+		});
+
+		checkCSE({
+			Instruction::CALLVALUE,
+			u256(255-i),
+			Instruction::SHR,
+			u256(boost::multiprecision::pow(u256(2), i)-1),
+			Instruction::AND
+		}, { // Opt. did some reordering
+			u256(boost::multiprecision::pow(u256(2), i)-1),
+			Instruction::CALLVALUE,
+			u256(255-i),
+			Instruction::SHR,
+			Instruction::AND
+		});
+	}
+
+	//(x >> (31*8)) & 0xffffffff
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256(31*8),
+		Instruction::SHR,
+		u256(0xffffffff),
+		Instruction::AND
+	}, {
+		Instruction::CALLVALUE,
+		u256(31*8),
+		Instruction::SHR
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_remove_unwanted_masking_of_address)
+{
+	std::vector<Instruction> ops{
+		Instruction::ADDRESS,
+		Instruction::CALLER,
+		Instruction::ORIGIN,
+		Instruction::COINBASE
+	};
+	for (auto const& op: ops)
+	{
+		checkCSE({
+			u256("0xffffffffffffffffffffffffffffffffffffffff"),
+			op,
+			Instruction::AND
+		}, {
+			op
+		});
+
+		checkCSE({
+			op,
+			u256("0xffffffffffffffffffffffffffffffffffffffff"),
+			Instruction::AND
+		}, {
+			op
+		});
+
+		// do not remove mask for other masking
+		checkCSE({
+			u256(1234),
+			op,
+			Instruction::AND
+		}, {
+			op,
+			u256(1234),
+			Instruction::AND
+		});
+
+		checkCSE({
+			op,
+			u256(1234),
+			Instruction::AND
+		}, {
+			u256(1234),
+			op,
+			Instruction::AND
+		});
+	}
+
+	// leave other opcodes untouched
+	checkCSE({
+		u256("0xffffffffffffffffffffffffffffffffffffffff"),
+		Instruction::CALLVALUE,
+		Instruction::AND
+	}, {
+		Instruction::CALLVALUE,
+		u256("0xffffffffffffffffffffffffffffffffffffffff"),
+		Instruction::AND
+	});
+
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256("0xffffffffffffffffffffffffffffffffffffffff"),
+		Instruction::AND
+	}, {
+		u256("0xffffffffffffffffffffffffffffffffffffffff"),
+		Instruction::CALLVALUE,
+		Instruction::AND
+	});
+}
+
+BOOST_AUTO_TEST_CASE(cse_replace_too_large_shift)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+		return;
+
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256(299),
+		Instruction::SHL
+	}, {
+		u256(0)
+	});
+
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256(299),
+		Instruction::SHR
+	}, {
+		u256(0)
+	});
+
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256(255),
+		Instruction::SHL
+	}, {
+		Instruction::CALLVALUE,
+		u256(255),
+		Instruction::SHL
+	});
+
+	checkCSE({
+		Instruction::CALLVALUE,
+		u256(255),
+		Instruction::SHR
+	}, {
+		Instruction::CALLVALUE,
+		u256(255),
+		Instruction::SHR
+	});
+}
+
+BOOST_AUTO_TEST_CASE(inliner)
+{
+	AssemblyItem jumpInto{Instruction::JUMP};
+	jumpInto.setJumpType(AssemblyItem::JumpType::IntoFunction);
+	AssemblyItem jumpOutOf{Instruction::JUMP};
+	jumpOutOf.setJumpType(AssemblyItem::JumpType::OutOfFunction);
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		jumpInto,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		Instruction::CALLVALUE,
+		Instruction::SWAP1,
+		jumpOutOf,
+	};
+	AssemblyItems expectation{
+		AssemblyItem(PushTag, 1),
+		Instruction::CALLVALUE,
+		Instruction::SWAP1,
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		Instruction::CALLVALUE,
+		Instruction::SWAP1,
+		jumpOutOf,
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+
+BOOST_AUTO_TEST_CASE(inliner_no_inline_type)
+{
+	// Will not inline due to jump types.
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		Instruction::CALLVALUE,
+		Instruction::SWAP1,
+		Instruction::JUMP,
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		items.begin(), items.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_no_inline)
+{
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::CALLVALUE,
+		Instruction::JUMPI,
+		Instruction::JUMP,
+	};
+	AssemblyItems expectation{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::CALLVALUE,
+		Instruction::JUMPI,
+		Instruction::JUMP,
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+
+BOOST_AUTO_TEST_CASE(inliner_single_jump)
+{
+	AssemblyItem jumpInto{Instruction::JUMP};
+	jumpInto.setJumpType(AssemblyItem::JumpType::IntoFunction);
+	AssemblyItem jumpOutOf{Instruction::JUMP};
+	jumpOutOf.setJumpType(AssemblyItem::JumpType::OutOfFunction);
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		jumpInto,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		jumpOutOf,
+	};
+	AssemblyItems expectation{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		jumpOutOf,
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_end_of_bytecode)
+{
+	AssemblyItem jumpInto{Instruction::JUMP};
+	jumpInto.setJumpType(AssemblyItem::JumpType::IntoFunction);
+	// Cannot inline, since the block at Tag_2 does not end in a jump.
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		jumpInto,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		items.begin(), items.end()
+	);
+}
+
+
+BOOST_AUTO_TEST_CASE(inliner_cse_break)
+{
+	AssemblyItem jumpInto{Instruction::JUMP};
+	jumpInto.setJumpType(AssemblyItem::JumpType::IntoFunction);
+	AssemblyItem jumpOutOf{Instruction::JUMP};
+	jumpOutOf.setJumpType(AssemblyItem::JumpType::OutOfFunction);
+	// Could be inlined, but we only consider non-CSE-breaking blocks ending in JUMP so far.
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		AssemblyItem(PushTag, 2),
+		jumpInto,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP,
+		AssemblyItem(Tag, 2),
+		Instruction::STOP, // CSE breaking instruction
+		jumpOutOf
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		items.begin(), items.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_stop)
+{
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP
+	};
+	AssemblyItems expectation{
+		Instruction::STOP,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_stop_jumpi)
+{
+	// Because of `jumpi`, will not be inlined.
+	AssemblyItems items{
+		u256(1),
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMPI,
+		AssemblyItem(Tag, 1),
+		Instruction::STOP
+	};
+	AssemblyItems expectation = items;
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_revert)
+{
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(0),
+		Instruction::DUP1,
+		Instruction::REVERT
+	};
+	AssemblyItems expectation{
+		u256(0),
+		Instruction::DUP1,
+		Instruction::REVERT,
+		AssemblyItem(Tag, 1),
+		u256(0),
+		Instruction::DUP1,
+		Instruction::REVERT
+	};
+
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_revert_increased_datagas)
+{
+	// Inlining this would increase data gas (5 bytes v/s 4 bytes), therefore, skipped.
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		u256(0),
+		u256(0),
+		Instruction::REVERT
+	};
+
+	AssemblyItems expectation = items;
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+BOOST_AUTO_TEST_CASE(inliner_invalid)
+{
+	AssemblyItems items{
+		AssemblyItem(PushTag, 1),
+		Instruction::JUMP,
+		AssemblyItem(Tag, 1),
+		Instruction::INVALID
+	};
+
+	AssemblyItems expectation = {
+		Instruction::INVALID,
+		AssemblyItem(Tag, 1),
+		Instruction::INVALID
+	};
+	Inliner{items, {}, Assembly::OptimiserSettings{}.expectedExecutionsPerDeployment, false, {}}.optimise();
+	BOOST_CHECK_EQUAL_COLLECTIONS(
+		items.begin(), items.end(),
+		expectation.begin(), expectation.end()
+	);
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/liblangutil/CharStream.cpp b/compiler/test/liblangutil/CharStream.cpp
new file mode 100644
index 00000000..07df23ab
--- /dev/null
+++ b/compiler/test/liblangutil/CharStream.cpp
@@ -0,0 +1,135 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Rocky Bernstein <rocky.bernstein@consensys.net>
+ * @date 2019
+ * Unit tests for the CharStream class.
+ */
+
+#include <liblangutil/CharStream.h>
+#include <liblangutil/Exceptions.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::test;
+
+namespace boost::test_tools::tt_detail
+{
+
+template<>
+struct print_log_value<std::optional<int>>
+{
+	void operator()(std::ostream& _out, std::optional<int> const& _value) const
+	{
+		_out << (_value ? to_string(*_value) : "[std::nullopt]");
+	}
+};
+
+template<>
+struct print_log_value<std::nullopt_t>
+{
+	void operator()(std::ostream& _out, std::nullopt_t const&) const
+	{
+		_out << "[std::nullopt]";
+	}
+};
+
+} // namespace boost::test_tools::tt_detail
+
+
+namespace solidity::langutil::test
+{
+
+BOOST_AUTO_TEST_SUITE(CharStreamTest)
+
+BOOST_AUTO_TEST_CASE(test_fail)
+{
+	auto const source = std::make_shared<CharStream>("now is the time for testing", "source");
+
+	BOOST_CHECK('n' == source->get());
+	BOOST_CHECK('n' == source->get());
+	BOOST_CHECK('o' == source->advanceAndGet());
+	BOOST_CHECK('n' == source->rollback(1));
+	BOOST_CHECK('w' == source->setPosition(2));
+	BOOST_REQUIRE_THROW(
+		source->setPosition(200),
+		::solidity::langutil::InternalCompilerError
+	);
+}
+
+namespace
+{
+std::optional<int> toPosition(int _line, int _column, std::string const& _text)
+{
+	return CharStream{_text, "source"}.translateLineColumnToPosition(
+		LineColumn{_line, _column}
+	);
+}
+
+}
+
+BOOST_AUTO_TEST_CASE(translateLineColumnToPosition)
+{
+	BOOST_CHECK_EQUAL(toPosition(-1, 0, "ABC"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(0, -1, "ABC"), std::nullopt);
+
+	BOOST_CHECK_EQUAL(toPosition(0, 0, ""), 0);
+	BOOST_CHECK_EQUAL(toPosition(1, 0, ""), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(0, 1, ""), std::nullopt);
+
+	// With last line containing no LF
+	BOOST_CHECK_EQUAL(toPosition(0, 0, "ABC"), 0);
+	BOOST_CHECK_EQUAL(toPosition(0, 1, "ABC"), 1);
+	BOOST_CHECK_EQUAL(toPosition(0, 2, "ABC"), 2);
+	BOOST_CHECK_EQUAL(toPosition(0, 3, "ABC"), 3);
+	BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC"), std::nullopt);
+
+	BOOST_CHECK_EQUAL(toPosition(0, 3, "ABC\nDEF"), 3);
+	BOOST_CHECK_EQUAL(toPosition(0, 4, "ABC\nDEF"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC\nDEF"), 4);
+	BOOST_CHECK_EQUAL(toPosition(1, 1, "ABC\nDEF"), 5);
+	BOOST_CHECK_EQUAL(toPosition(1, 2, "ABC\nDEF"), 6);
+	BOOST_CHECK_EQUAL(toPosition(1, 3, "ABC\nDEF"), 7);
+	BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF"), std::nullopt);
+
+	// With last line containing LF
+	BOOST_CHECK_EQUAL(toPosition(0, 0, "ABC\nDEF\n"), 0);
+	BOOST_CHECK_EQUAL(toPosition(0, 1, "ABC\nDEF\n"), 1);
+	BOOST_CHECK_EQUAL(toPosition(0, 2, "ABC\nDEF\n"), 2);
+
+	BOOST_CHECK_EQUAL(toPosition(1, 0, "ABC\nDEF\n"), 4);
+	BOOST_CHECK_EQUAL(toPosition(1, 1, "ABC\nDEF\n"), 5);
+	BOOST_CHECK_EQUAL(toPosition(1, 2, "ABC\nDEF\n"), 6);
+	BOOST_CHECK_EQUAL(toPosition(1, 3, "ABC\nDEF\n"), 7);
+	BOOST_CHECK_EQUAL(toPosition(1, 4, "ABC\nDEF\n"), std::nullopt);
+	BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF\n"), 8);
+	BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF\n"), std::nullopt);
+
+	BOOST_CHECK_EQUAL(toPosition(2, 0, "ABC\nDEF\nGHI\n"), 8);
+	BOOST_CHECK_EQUAL(toPosition(2, 1, "ABC\nDEF\nGHI\n"), 9);
+	BOOST_CHECK_EQUAL(toPosition(2, 2, "ABC\nDEF\nGHI\n"), 10);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/liblangutil/Scanner.cpp b/compiler/test/liblangutil/Scanner.cpp
new file mode 100644
index 00000000..8c961a3b
--- /dev/null
+++ b/compiler/test/liblangutil/Scanner.cpp
@@ -0,0 +1,1031 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Unit tests for the solidity scanner.
+ */
+
+#include <liblangutil/Scanner.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+using namespace std::string_literals;
+
+namespace solidity::langutil::test
+{
+
+BOOST_AUTO_TEST_SUITE(ScannerTest)
+
+BOOST_AUTO_TEST_CASE(test_empty)
+{
+	CharStream stream{};
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	CharStream stream("function break;765  \t  \"string1\",'string2'\nidentifier1", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Break);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "765");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "string1");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "string2");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "identifier1");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(assembly_assign)
+{
+	CharStream stream("let a := 1", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Let);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssemblyAssign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "1");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(assembly_multiple_assign)
+{
+	CharStream stream("let a, b, c := 1", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Let);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssemblyAssign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "1");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(string_printable)
+{
+	for (unsigned v = 0x20; v < 0x7e; v++) {
+		std::string lit{static_cast<char>(v)};
+		// Escape \ and " (since we are quoting with ")
+		if (v == '\\' || v == '"')
+			lit = std::string{'\\'} + lit;
+		CharStream stream("  { \"" + lit + "\"", "");
+		Scanner scanner(stream);
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string{static_cast<char>(v)});
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+	// Special case of unescaped " for strings quoted with '
+	CharStream stream("  { '\"'", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "\"");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(string_nonprintable)
+{
+	for (unsigned v = 0; v < 0xff; v++) {
+		// Skip the valid ones
+		if (v >= 0x20 && v <= 0x7e)
+			continue;
+		std::string lit{static_cast<char>(v)};
+		CharStream stream("  { \"" + lit + "\"", "");
+		Scanner scanner(stream);
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		if (v == '\n' || v == '\v' || v == '\f' || v == '\r')
+			BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalStringEndQuote);
+		else
+			BOOST_CHECK_EQUAL(scanner.currentError(),ScannerError::UnicodeCharacterInNonUnicodeString);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(string_escapes)
+{
+	CharStream stream("  { \"a\\x61\"", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "aa");
+}
+
+BOOST_AUTO_TEST_CASE(string_escapes_all)
+{
+	CharStream stream("  { \"a\\x61\\n\\r\\t\"", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "aa\n\r\t");
+}
+
+struct TestScanner
+{
+	std::unique_ptr<CharStream> stream;
+	std::unique_ptr<Scanner> scanner;
+	explicit TestScanner(std::string _text) { reset(std::move(_text)); }
+
+	void reset(std::string _text)
+	{
+		stream = std::make_unique<CharStream>(std::move(_text), "");
+		scanner = std::make_unique<Scanner>(*stream);
+	}
+
+	decltype(auto) currentToken() { return scanner->currentToken(); }
+	decltype(auto) next() { return scanner->next(); }
+	decltype(auto) currentError() { return scanner->currentError(); }
+	decltype(auto) currentLiteral() { return scanner->currentLiteral(); }
+	decltype(auto) currentCommentLiteral() { return scanner->currentCommentLiteral(); }
+	decltype(auto) currentLocation() { return scanner->currentLocation(); }
+};
+
+BOOST_AUTO_TEST_CASE(string_escapes_legal_before_080)
+{
+	TestScanner scanner("  { \"a\\b");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalEscapeSequence);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "");
+	scanner.reset("  { \"a\\f");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalEscapeSequence);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "");
+	scanner.reset("  { \"a\\v");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalEscapeSequence);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(string_escapes_with_zero)
+{
+	TestScanner scanner("  { \"a\\x61\\x00abc\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("aa\0abc", 6));
+}
+
+BOOST_AUTO_TEST_CASE(string_escape_illegal)
+{
+	CharStream stream(" bla \"\\x6rf\" (illegalescape)", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalEscapeSequence);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "");
+	// TODO recovery from illegal tokens should be improved
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(hex_numbers)
+{
+	TestScanner scanner("var x = 0x765432536763762734623472346;");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Var);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Assign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "0x765432536763762734623472346");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("0x1234");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "0x1234");
+	scanner.reset("0X1234");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+}
+
+BOOST_AUTO_TEST_CASE(octal_numbers)
+{
+	TestScanner scanner("07");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	scanner.reset("007");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	scanner.reset("-07");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	scanner.reset("-.07");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	scanner.reset("0");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	scanner.reset("0.1");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+}
+
+BOOST_AUTO_TEST_CASE(scientific_notation)
+{
+	CharStream stream("var x = 2e10;", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Var);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Assign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "2e10");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_dot_in_identifier)
+{
+	TestScanner scanner("function .a(");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("function .a(");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(middle_dot_in_identifier)
+{
+	TestScanner scanner("function a..a(");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("function a...a(");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(trailing_dot_in_identifier)
+{
+	TestScanner scanner("function a.(");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("function a.(");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(trailing_dot_in_numbers)
+{
+	TestScanner scanner("2.5");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("2.5e10");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset(".5");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset(".5e10");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("2.");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_underscore_decimal_is_identifier)
+{
+	// Actual error is caught by SyntaxChecker.
+	CharStream stream("_1.2", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_underscore_decimal_after_dot_illegal)
+{
+	// Actual error is caught by SyntaxChecker.
+	TestScanner scanner("1._2");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+
+	scanner.reset("1._");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_underscore_exp_are_identifier)
+{
+	// Actual error is caught by SyntaxChecker.
+	CharStream stream("_1e2", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_underscore_exp_after_e_illegal)
+{
+	// Actual error is caught by SyntaxChecker.
+	CharStream stream("1e_2", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "1e_2");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(leading_underscore_hex_illegal)
+{
+	CharStream stream("0x_abc", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(fixed_number_invalid_underscore_front)
+{
+	// Actual error is caught by SyntaxChecker.
+	CharStream stream("12._1234_1234", "");
+	Scanner scanner(stream);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(number_literals_with_trailing_underscore_at_eos)
+{
+	// Actual error is caught by SyntaxChecker.
+	TestScanner scanner("0x123_");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+
+	scanner.reset("123_");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+
+	scanner.reset("12.34_");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(negative_numbers)
+{
+	TestScanner scanner("var x = -.2 + -0x78 + -7.3 + 8.9 + 2e-2;");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Var);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Assign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), ".2");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "0x78");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "7.3");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "8.9");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "2e-2");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(locations)
+{
+	TestScanner scanner("function_identifier has ; -0x743/*comment*/\n ident //comment");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().start, 0);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().end, 19);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().start, 20);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().end, 23);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Semicolon);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().start, 24);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().end, 25);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().start, 27);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().end, 32);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().start, 45);
+	BOOST_CHECK_EQUAL(scanner.currentLocation().end, 50);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(ambiguities)
+{
+	// test scanning of some operators which need look-ahead
+	TestScanner scanner("<=" "<" "+ +=a++ =>" "<<" ">>" " >>=" ">>>" ">>>=" " >>>>>=><<=");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LessThanOrEqual);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LessThan);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Add);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssignAdd);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Inc);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::DoubleArrow);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SHL);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SAR);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssignSar);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SHR);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssignShr);
+	// the last "monster" token combination
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SHR);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssignSar);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::GreaterThan);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssignShl);
+}
+
+BOOST_AUTO_TEST_CASE(documentation_comments_parsed_begin)
+{
+	TestScanner scanner("/// Send $(value / 1000) chocolates to the user");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(multiline_documentation_comments_parsed_begin)
+{
+	TestScanner scanner("/** Send $(value / 1000) chocolates to the user*/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(documentation_comments_parsed)
+{
+	TestScanner scanner("some other tokens /// Send $(value / 1000) chocolates to the user");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(multiline_documentation_comments_parsed)
+{
+	TestScanner scanner("some other tokens /**\n"
+						"* Send $(value / 1000) chocolates to the user\n"
+						"*/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), " Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(multiline_documentation_no_stars)
+{
+	TestScanner scanner("some other tokens /**\n"
+						" Send $(value / 1000) chocolates to the user\n"
+						"*/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(multiline_documentation_whitespace_hell)
+{
+	TestScanner scanner("some other tokens /** \t \r \n"
+						"\t \r  * Send $(value / 1000) chocolates to the user\n"
+						"*/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), " Send $(value / 1000) chocolates to the user");
+}
+
+BOOST_AUTO_TEST_CASE(comment_before_eos)
+{
+	TestScanner scanner("//");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(documentation_comment_before_eos)
+{
+	TestScanner scanner("///");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(empty_multiline_comment)
+{
+	TestScanner scanner("/**/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(empty_multiline_documentation_comment_before_eos)
+{
+	TestScanner scanner("/***/");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::EOS);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+}
+
+BOOST_AUTO_TEST_CASE(comments_mixed_in_sequence)
+{
+	TestScanner scanner("hello_world ///documentation comment \n"
+						"//simple comment \n"
+						"<<");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SHL);
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "documentation comment ");
+}
+
+BOOST_AUTO_TEST_CASE(ether_subdenominations)
+{
+	TestScanner scanner("wei gwei ether");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::SubWei);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubGwei);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubEther);
+}
+
+BOOST_AUTO_TEST_CASE(time_subdenominations)
+{
+	TestScanner scanner("seconds minutes hours days weeks years");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::SubSecond);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubMinute);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubHour);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubDay);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubWeek);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::SubYear);
+}
+
+BOOST_AUTO_TEST_CASE(empty_comment)
+{
+	TestScanner scanner("//\ncontract{}");
+	BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Contract);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RBrace);
+
+}
+
+// Unicode string escapes
+
+BOOST_AUTO_TEST_CASE(valid_unicode_string_escape)
+{
+	TestScanner scanner("{ \"\\u00DAnicode\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("\xC3\x9Anicode", 8));
+}
+
+BOOST_AUTO_TEST_CASE(valid_unicode_string_escape_7f)
+{
+	TestScanner scanner("{ \"\\u007Fnicode\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("\x7Fnicode", 7));
+}
+
+BOOST_AUTO_TEST_CASE(valid_unicode_string_escape_7ff)
+{
+	TestScanner scanner("{ \"\\u07FFnicode\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("\xDF\xBFnicode", 8));
+}
+
+BOOST_AUTO_TEST_CASE(valid_unicode_string_escape_ffff)
+{
+	TestScanner scanner("{ \"\\uFFFFnicode\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::StringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("\xEF\xBF\xBFnicode", 9));
+}
+
+BOOST_AUTO_TEST_CASE(invalid_short_unicode_string_escape)
+{
+	TestScanner scanner("{ \"\\uFFnicode\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+}
+
+// Unicode string literal
+
+BOOST_AUTO_TEST_CASE(unicode_prefix_only)
+{
+	TestScanner scanner("{ unicode");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+	scanner.reset("{ unicode");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "unicode");
+}
+
+BOOST_AUTO_TEST_CASE(unicode_invalid_space)
+{
+	TestScanner scanner("{ unicode ");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+}
+
+BOOST_AUTO_TEST_CASE(unicode_invalid_token)
+{
+	TestScanner scanner("{ unicode test");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+	scanner.reset("{ unicode test");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "unicode");
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), "test");
+}
+
+BOOST_AUTO_TEST_CASE(valid_unicode_literal)
+{
+	TestScanner scanner("{ unicode\"Hello 😃\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::UnicodeStringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("Hello \xf0\x9f\x98\x83", 10));
+}
+
+BOOST_AUTO_TEST_CASE(valid_nonprintable_in_unicode_literal)
+{
+	// Non-printable characters are allowed in unicode strings...
+	TestScanner scanner("{ unicode\"Hello \007😃\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::UnicodeStringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("Hello \x07\xf0\x9f\x98\x83", 11));
+}
+
+// Hex string literal
+
+BOOST_AUTO_TEST_CASE(hex_prefix_only)
+{
+	TestScanner scanner("{ hex");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+	scanner.reset("{ hex");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+}
+
+BOOST_AUTO_TEST_CASE(hex_invalid_space)
+{
+	TestScanner scanner("{ hex ");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+}
+
+BOOST_AUTO_TEST_CASE(hex_invalid_token)
+{
+	TestScanner scanner("{ hex test");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+	scanner.reset("{ hex test");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalToken);
+}
+
+BOOST_AUTO_TEST_CASE(valid_hex_literal)
+{
+	TestScanner scanner("{ hex\"00112233FF\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::HexStringLiteral);
+	BOOST_CHECK_EQUAL(scanner.currentLiteral(), std::string("\x00\x11\x22\x33\xFF", 5));
+}
+
+BOOST_AUTO_TEST_CASE(invalid_short_hex_literal)
+{
+	TestScanner scanner("{ hex\"00112233F\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalHexString);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_hex_literal_with_space)
+{
+	TestScanner scanner("{ hex\"00112233FF \"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalHexString);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_hex_literal_with_wrong_quotes)
+{
+	TestScanner scanner("{ hex\"00112233FF'");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalHexString);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_hex_literal_nonhex_string)
+{
+	TestScanner scanner("{ hex\"hello\"");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::LBrace);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.currentError(), ScannerError::IllegalHexString);
+}
+
+// Comments
+
+BOOST_AUTO_TEST_CASE(invalid_multiline_comment_close)
+{
+	// This used to parse as "comment", "identifier"
+	TestScanner scanner("/** / x");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(multiline_doc_comment_at_eos)
+{
+	// This used to parse as "whitespace"
+	TestScanner scanner("/**");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(multiline_comment_at_eos)
+{
+	TestScanner scanner("/*");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(regular_line_break_in_single_line_comment)
+{
+	for (auto const& nl: {"\r", "\n", "\r\n"})
+	{
+		TestScanner scanner("// abc " + std::string(nl) + " def ");
+		BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_single_line_comment)
+{
+	for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
+	{
+		TestScanner scanner("// abc " + std::string(nl) + " def ");
+		BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+		for (size_t i = 0; i < std::string(nl).size() - 1; i++)
+			BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(regular_line_breaks_in_single_line_doc_comment)
+{
+	for (auto const& nl: {"\r", "\n", "\r\n"})
+	{
+		TestScanner scanner("/// abc " + std::string(nl) + " def ");
+		BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "abc ");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(regular_line_breaks_in_multiline_doc_comment)
+{
+	// Test CR, LF, CRLF as line valid terminators for code comments.
+	// Any accepted non-LF is being canonicalized to LF.
+	for (auto const& nl : {"\r"s, "\n"s, "\r\n"s})
+	{
+		TestScanner scanner{"/// Hello" + nl + "/// World" + nl + "ident"};
+		auto const& lit = scanner.currentCommentLiteral();
+		BOOST_CHECK_EQUAL(lit, "Hello\n World");
+		BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "Hello\n World");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "ident");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_single_line_doc_comment)
+{
+	for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
+	{
+		TestScanner scanner("/// abc " + std::string(nl) + " def ");
+		BOOST_CHECK_EQUAL(scanner.currentCommentLiteral(), "abc ");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+		for (size_t i = 0; i < std::string(nl).size() - 1; i++)
+			BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(regular_line_breaks_in_strings)
+{
+	for (auto const& nl: {"\r"s, "\n"s, "\r\n"s})
+	{
+		TestScanner scanner("\"abc " + nl + " def\"");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(irregular_line_breaks_in_strings)
+{
+	for (auto const& nl: {"\v", "\f", "\xE2\x80\xA8", "\xE2\x80\xA9"})
+	{
+		TestScanner scanner("\"abc " + std::string(nl) + " def\"");
+		BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Illegal);
+		for (size_t i = 0; i < std::string(nl).size(); i++)
+			BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+		BOOST_CHECK_EQUAL(scanner.currentLiteral(), "def");
+		BOOST_CHECK_EQUAL(scanner.next(), Token::Illegal);
+		BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(solidity_keywords)
+{
+	// These are tokens which have a different meaning in Yul.
+	std::string keywords = "return byte bool address var in true false leave switch case default";
+	TestScanner scanner(keywords);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Return);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Byte);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Bool);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Address);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Var);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::In);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::TrueLiteral);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::FalseLiteral);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Switch);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Case);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Default);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset(keywords);
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::TrueLiteral);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::FalseLiteral);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Leave);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Switch);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Case);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Default);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(yul_keyword_like)
+{
+	TestScanner scanner("leave.function");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("leave.function");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(yul_identifier_with_dots)
+{
+	TestScanner scanner("mystorage.slot := 1");
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Period);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssemblyAssign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset("mystorage.slot := 1");
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::AssemblyAssign);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Number);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(yul_function)
+{
+	std::string sig = "function f(a, b) -> x, y";
+	TestScanner scanner(sig);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RightArrow);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset(sig);
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RightArrow);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_CASE(yul_function_with_whitespace)
+{
+	std::string sig = "function f (a, b) - > x, y";
+	TestScanner scanner(sig);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::GreaterThan);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+	scanner.reset(sig);
+	scanner.scanner->setScannerMode(ScannerKind::Yul);
+	BOOST_CHECK_EQUAL(scanner.currentToken(), Token::Function);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::LParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::RParen);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Sub);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::GreaterThan);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Comma);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::Identifier);
+	BOOST_CHECK_EQUAL(scanner.next(), Token::EOS);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/ABIDecoderTests.cpp b/compiler/test/libsolidity/ABIDecoderTests.cpp
new file mode 100644
index 00000000..e8ffcad2
--- /dev/null
+++ b/compiler/test/libsolidity/ABIDecoderTests.cpp
@@ -0,0 +1,431 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for Solidity's ABI decoder.
+ */
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <boost/test/unit_test.hpp>
+#include <liblangutil/Exceptions.h>
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+#include <test/libsolidity/ABITestsCommon.h>
+
+using namespace std::placeholders;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+BOOST_FIXTURE_TEST_SUITE(ABIDecoderTest, SolidityExecutionFramework)
+
+BOOST_AUTO_TEST_CASE(value_types)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function f(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool e, C g) public returns (uint) {
+				if (a != 1) return 1;
+				if (b != 2) return 2;
+				if (c != 3) return 3;
+				if (d != 4) return 4;
+				if (x != "abc") return 5;
+				if (e != true) return 6;
+				if (g != this) return 7;
+				return 20;
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction(
+			"f(uint256,uint16,uint24,int24,bytes3,bool,address)",
+			1, 2, 3, 4, std::string("abc"), true, m_contractAddress
+		), encodeArgs(u256(20)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(decode_from_memory_simple)
+{
+	std::string sourceCode = R"(
+		contract C {
+			uint public _a;
+			uint[] public _b;
+			constructor(uint a, uint[] memory b) {
+				_a = a;
+				_b = b;
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode, 0, "C", encodeArgs(
+			7, 0x40,
+			// b
+			3, 0x21, 0x22, 0x23
+		));
+		ABI_CHECK(callContractFunction("_a()"), encodeArgs(7));
+		ABI_CHECK(callContractFunction("_b(uint256)", 0), encodeArgs(0x21));
+		ABI_CHECK(callContractFunction("_b(uint256)", 1), encodeArgs(0x22));
+		ABI_CHECK(callContractFunction("_b(uint256)", 2), encodeArgs(0x23));
+		ABI_CHECK(callContractFunction("_b(uint256)", 3), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(decode_function_type)
+{
+	std::string sourceCode = R"(
+		contract D {
+			function () external returns (uint) public _a;
+			constructor(function () external returns (uint) a) {
+				_a = a;
+			}
+		}
+		contract C {
+			function f() public returns (uint) {
+				return 3;
+			}
+			function g(function () external returns (uint) _f) public returns (uint) {
+				return _f();
+			}
+			// uses "decode from memory"
+			function test1() public returns (uint) {
+				D d = new D(this.f);
+				return d._a()();
+			}
+			// uses "decode from calldata"
+			function test2() public returns (uint) {
+				return this.g(this.f);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("test1()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("test2()"), encodeArgs(3));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(decode_function_type_array)
+{
+	std::string sourceCode = R"(
+		contract D {
+			function () external returns (uint)[] public _a;
+			constructor(function () external returns (uint)[] memory a) {
+				_a = a;
+			}
+		}
+		contract E {
+			function () external returns (uint)[3] public _a;
+			constructor(function () external returns (uint)[3] memory a) {
+				_a = a;
+			}
+		}
+		contract C {
+			function f1() public returns (uint) {
+				return 1;
+			}
+			function f2() public returns (uint) {
+				return 2;
+			}
+			function f3() public returns (uint) {
+				return 3;
+			}
+			function g(function () external returns (uint)[] memory _f, uint i) public returns (uint) {
+				return _f[i]();
+			}
+			function h(function () external returns (uint)[3] memory _f, uint i) public returns (uint) {
+				return _f[i]();
+			}
+			// uses "decode from memory"
+			function test1_dynamic() public returns (uint) {
+				function () external returns (uint)[] memory x = new function() external returns (uint)[](4);
+				x[0] = this.f1;
+				x[1] = this.f2;
+				x[2] = this.f3;
+				D d = new D(x);
+				return d._a(2)();
+			}
+			function test1_static() public returns (uint) {
+				E e = new E([this.f1, this.f2, this.f3]);
+				return e._a(2)();
+			}
+			// uses "decode from calldata"
+			function test2_dynamic() public returns (uint) {
+				function () external returns (uint)[] memory x = new function() external returns (uint)[](3);
+				x[0] = this.f1;
+				x[1] = this.f2;
+				x[2] = this.f3;
+				return this.g(x, 0);
+			}
+			function test2_static() public returns (uint) {
+				return this.h([this.f1, this.f2, this.f3], 0);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("test1_static()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("test1_dynamic()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("test2_static()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("test2_dynamic()"), encodeArgs(1));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(decode_from_memory_complex)
+{
+	std::string sourceCode = R"(
+		contract C {
+			uint public _a;
+			uint[] public _b;
+			bytes[2] public _c;
+			constructor(uint a, uint[] memory b, bytes[2] memory c) {
+				_a = a;
+				_b = b;
+				_c = c;
+			}
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C", encodeArgs(
+			7, 0x60, 7 * 0x20,
+			// b
+			3, 0x21, 0x22, 0x23,
+			// c
+			0x40, 0x80,
+			8, std::string("abcdefgh"),
+			52, std::string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")
+		));
+		ABI_CHECK(callContractFunction("_a()"), encodeArgs(7));
+		ABI_CHECK(callContractFunction("_b(uint256)", 0), encodeArgs(0x21));
+		ABI_CHECK(callContractFunction("_b(uint256)", 1), encodeArgs(0x22));
+		ABI_CHECK(callContractFunction("_b(uint256)", 2), encodeArgs(0x23));
+		ABI_CHECK(callContractFunction("_b(uint256)", 3), encodeArgs());
+		ABI_CHECK(callContractFunction("_c(uint256)", 0), encodeArgs(0x20, 8, std::string("abcdefgh")));
+		ABI_CHECK(callContractFunction("_c(uint256)", 1), encodeArgs(0x20, 52, std::string("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ")));
+		ABI_CHECK(callContractFunction("_c(uint256)", 2), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(short_input_value_type)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function f(uint a, uint b) public pure returns (uint) { return a; }
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("f(uint256,uint256)", 1, 2), encodeArgs(1));
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256,uint256)", bytes(64, 0)), encodeArgs(0));
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256,uint256)", bytes(63, 0)), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(short_input_array)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function f(uint[] memory a) public pure returns (uint) { return 7; }
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 0)), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1) + bytes(31, 0)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 1) + bytes(32, 0)), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("f(uint256[])", encodeArgs(0x20, 2, 5, 6)), encodeArgs(7));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(short_dynamic_input_array)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function f(bytes[1] memory a) public pure returns (uint) { return 7; }
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunctionNoEncoding("f(bytes[1])", encodeArgs(0x20)), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(short_input_bytes)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function e(bytes memory a) public pure returns (uint) { return 7; }
+			function f(bytes[] memory a) public pure returns (uint) { return 7; }
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(5, 0)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(6, 0)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(7, 0)), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("e(bytes)", encodeArgs(0x20, 7) + bytes(8, 0)), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(5, 0)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(6, 0)), encodeArgs());
+		ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(7, 0)), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("f(bytes[])", encodeArgs(0x20, 1, 0x20, 7) + bytes(8, 0)), encodeArgs(7));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(validation_int_inside_arrays)
+{
+	std::string sourceCode = R"(
+		contract C {
+			enum E { A, B }
+			function f(uint16[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+			function g(int16[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+			function h(E[] memory a) public pure returns (uint r) { assembly { r := mload(add(a, 0x20)) } }
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, 7), encodeArgs(7));
+		ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, 7), encodeArgs(7));
+		ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, u256("0xffff")), encodeArgs(u256("0xffff")));
+		ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, u256("0xffff")), encodeArgs());
+		ABI_CHECK(callContractFunction("f(uint16[])", 0x20, 1, u256("0x1ffff")), encodeArgs());
+		ABI_CHECK(callContractFunction("g(int16[])", 0x20, 1, u256("0x10fff")), encodeArgs());
+		ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 0), encodeArgs(u256(0)));
+		ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 1), encodeArgs(u256(1)));
+		ABI_CHECK(callContractFunction("h(uint8[])", 0x20, 1, 2), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(validation_function_type)
+{
+	std::string sourceCode = R"(
+		contract C {
+			function f(function () external) public pure returns (uint r) { r = 1; }
+			function g(function () external[] memory) public pure returns (uint r) { r = 2; }
+			function h(function () external[] calldata) external pure returns (uint r) { r = 3; }
+			function i(function () external[] calldata a) external pure returns (uint r) { a[0]; r = 4; }
+		}
+	)";
+	bool newDecoder = false;
+	std::string validFun{"01234567890123456789abcd"};
+	std::string invalidFun{"01234567890123456789abcdX"};
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("f(function)", validFun), encodeArgs(1));
+		ABI_CHECK(callContractFunction("f(function)", invalidFun), newDecoder ? bytes{} : encodeArgs(1));
+		ABI_CHECK(callContractFunction("g(function[])", 0x20, 1, validFun), encodeArgs(2));
+		ABI_CHECK(callContractFunction("g(function[])", 0x20, 1, invalidFun), newDecoder ? bytes{} : encodeArgs(2));
+		ABI_CHECK(callContractFunction("h(function[])", 0x20, 1, validFun), encodeArgs(3));
+		// No failure because the data is not accessed.
+		ABI_CHECK(callContractFunction("h(function[])", 0x20, 1, invalidFun), encodeArgs(3));
+		ABI_CHECK(callContractFunction("i(function[])", 0x20, 1, validFun), encodeArgs(4));
+		ABI_CHECK(callContractFunction("i(function[])", 0x20, 1, invalidFun), newDecoder ? bytes{} : encodeArgs(4));
+		newDecoder = true;
+	)
+}
+
+BOOST_AUTO_TEST_CASE(struct_short)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S { int a; uint b; bytes16 c; }
+			function f(S memory s) public pure returns (S memory q) {
+				q = s;
+			}
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(
+			callContractFunction("f((int256,uint256,bytes16))", 0xff010, 0xff0002, "abcd"),
+			encodeArgs(0xff010, 0xff0002, "abcd")
+		);
+		ABI_CHECK(
+			callContractFunctionNoEncoding("f((int256,uint256,bytes16))", encodeArgs(0xff010, 0xff0002) + bytes(32, 0)),
+			encodeArgs(0xff010, 0xff0002, 0)
+		);
+		ABI_CHECK(
+			callContractFunctionNoEncoding("f((int256,uint256,bytes16))", encodeArgs(0xff010, 0xff0002) + bytes(31, 0)),
+			encodeArgs()
+		);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(complex_struct)
+{
+	std::string sourceCode = R"(
+		contract C {
+			enum E {A, B, C}
+			struct T { uint x; E e; uint8 y; }
+			struct S { C c; T[] t;}
+			function f(uint a, S[2] memory s1, S[] memory s2, uint b) public returns
+					(uint r1, C r2, uint r3, uint r4, C r5, uint r6, E r7, uint8 r8) {
+				r1 = a;
+				r2 = s1[0].c;
+				r3 = b;
+				r4 = s2.length;
+				r5 = s2[1].c;
+				r6 = s2[1].t.length;
+				r7 = s2[1].t[1].e;
+				r8 = s2[1].t[1].y;
+			}
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C");
+		std::string sig = "f(uint256,(address,(uint256,uint8,uint8)[])[2],(address,(uint256,uint8,uint8)[])[],uint256)";
+		bytes args = encodeArgs(
+			7, 0x80, 0x1e0, 8,
+			// S[2] s1
+			0x40,
+			0x100,
+			// S s1[0]
+			m_contractAddress,
+			0x40,
+			// T s1[0].t
+			1, // length
+			// s1[0].t[0]
+			0x11, 1, 0x12,
+			// S s1[1]
+			0, 0x40,
+			// T s1[1].t
+			0,
+			// S[] s2 (0x1e0)
+			2, // length
+			0x40, 0xa0,
+			// S s2[0]
+			0, 0x40, 0,
+			// S s2[1]
+			0x1234, 0x40,
+			// s2[1].t
+			3, // length
+			0, 0, 0,
+			0x21, 2, 0x22,
+			0, 0, 0
+		);
+		ABI_CHECK(callContractFunction(sig, args), encodeArgs(7, m_contractAddress, 8, 2, 0x1234, 3, 2, 0x22));
+		// invalid enum value
+		args.data()[0x20 * 28] = 3;
+		ABI_CHECK(callContractFunction(sig, args), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/ABIEncoderTests.cpp b/compiler/test/libsolidity/ABIEncoderTests.cpp
new file mode 100644
index 00000000..a56d9e5c
--- /dev/null
+++ b/compiler/test/libsolidity/ABIEncoderTests.cpp
@@ -0,0 +1,788 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for Solidity's ABI encoder.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+#include <test/libsolidity/ABITestsCommon.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <functional>
+#include <string>
+#include <tuple>
+
+using namespace std::placeholders;
+using namespace solidity::util;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+#define REQUIRE_LOG_DATA(DATA) do { \
+	BOOST_REQUIRE_EQUAL(numLogs(), 1); \
+	BOOST_CHECK_EQUAL(logAddress(0), m_contractAddress); \
+	ABI_CHECK(logData(0), DATA); \
+} while (false)
+
+BOOST_FIXTURE_TEST_SUITE(ABIEncoderTest, SolidityExecutionFramework)
+
+BOOST_AUTO_TEST_CASE(value_types)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(uint a, uint16 b, uint24 c, int24 d, bytes3 x, bool, C);
+			function f() public {
+				bytes6 x = hex"1bababababa2";
+				bool b;
+				assembly { b := 7 }
+				C c;
+				assembly { c := sub(0, 5) }
+				emit E(10, uint16(type(uint).max - 1), uint24(uint(0x12121212)), int24(int256(-1)), bytes3(x), b, c);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			10, u256(65534), u256(0x121212), u256(-1), std::string("\x1b\xab\xab"), true, h160("fffffffffffffffffffffffffffffffffffffffb")
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(string_literal)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(string, bytes20, string);
+			function f() public {
+				emit E("abcdef", "abcde", "abcdefabcdefgehabcabcasdfjklabcdefabcedefghabcabcasdfjklabcdefabcdefghabcabcasdfjklabcdeefabcdefghabcabcasdefjklabcdefabcdefghabcabcasdfjkl");
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			0x60, std::string("abcde"), 0xa0,
+			6, std::string("abcdef"),
+			0x8b, std::string("abcdefabcdefgehabcabcasdfjklabcdefabcedefghabcabcasdfjklabcdefabcdefghabcabcasdfjklabcdeefabcdefghabcabcasdefjklabcdefabcdefghabcabcasdfjkl")
+		));
+	)
+}
+
+
+BOOST_AUTO_TEST_CASE(enum_type_cleanup)
+{
+	std::string sourceCode = R"(
+		contract C {
+			enum E { A, B }
+			function f(uint x) public returns (E en) {
+				assembly { en := x }
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		BOOST_CHECK(callContractFunction("f(uint256)", 0) == encodeArgs(0));
+		BOOST_CHECK(callContractFunction("f(uint256)", 1) == encodeArgs(1));
+		BOOST_CHECK(callContractFunction("f(uint256)", 2) == panicData(PanicCode::EnumConversionError));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(conversion)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(bytes4, bytes4, uint16, uint8, int16, int8);
+			function f() public {
+				bytes2 x; assembly { x := 0xf1f2f3f400000000000000000000000000000000000000000000000000000000 }
+				uint8 a;
+				uint16 b = 0x1ff;
+				int8 c;
+				int16 d;
+				assembly { a := sub(0, 1) c := 0x0101ff d := 0xff01 }
+				emit E(bytes4(uint32(10)), x, a, uint8(b), c, int8(d));
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			std::string(3, 0) + std::string("\x0a"), std::string("\xf1\xf2"),
+			0xff, 0xff, u256(-1), u256(1)
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(memory_array_one_dim)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(uint a, int16[] b, uint c);
+			function f() public {
+				int16[] memory x = new int16[](3);
+				assembly {
+					for { let i := 0 } lt(i, 3) { i := add(i, 1) } {
+						mstore(add(x, mul(add(i, 1), 0x20)), add(0xfffffffe, i))
+					}
+				}
+				emit E(10, x, 11);
+			}
+		}
+	)";
+
+	if (solidity::test::CommonOptions::get().useABIEncoderV1)
+	{
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		// The old encoder does not clean array elements.
+		REQUIRE_LOG_DATA(encodeArgs(10, 0x60, 11, 3, u256("0xfffffffe"), u256("0xffffffff"), u256("0x100000000")));
+	}
+
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(10, 0x60, 11, 3, u256(-2), u256(-1), u256(0)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(memory_array_two_dim)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(uint a, int16[][2] b, uint c);
+			function f() public {
+				int16[][2] memory x;
+				x[0] = new int16[](3);
+				x[1] = new int16[](2);
+				x[0][0] = 7;
+				x[0][1] = int16(int(0x010203040506));
+				x[0][2] = -1;
+				x[1][0] = 4;
+				x[1][1] = 5;
+				emit E(10, x, 11);
+			}
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(10, 0x60, 11, 0x40, 0xc0, 3, 7, 0x0506, u256(-1), 2, 4, 5));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(memory_byte_array)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(uint a, bytes[] b, uint c);
+			function f() public {
+				bytes[] memory x = new bytes[](2);
+				x[0] = "abcabcdefghjklmnopqrsuvwabcdefgijklmnopqrstuwabcdefgijklmnoprstuvw";
+				x[1] = "abcdefghijklmnopqrtuvwabcfghijklmnopqstuvwabcdeghijklmopqrstuvw";
+				emit E(10, x, 11);
+			}
+		}
+	)";
+	NEW_ENCODER(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			10, 0x60, 11,
+			2, 0x40, 0xc0,
+			66, std::string("abcabcdefghjklmnopqrsuvwabcdefgijklmnopqrstuwabcdefgijklmnoprstuvw"),
+			63, std::string("abcdefghijklmnopqrtuvwabcfghijklmnopqstuvwabcdeghijklmopqrstuvw")
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(storage_byte_array)
+{
+	std::string sourceCode = R"(
+		contract C {
+			bytes short;
+			bytes long;
+			event E(bytes s, bytes l);
+			function f() public {
+				short = "123456789012345678901234567890a";
+				long = "ffff123456789012345678901234567890afffffffff123456789012345678901234567890a";
+				emit E(short, long);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			0x40, 0x80,
+			31, std::string("123456789012345678901234567890a"),
+			75, std::string("ffff123456789012345678901234567890afffffffff123456789012345678901234567890a")
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(storage_array)
+{
+	std::string sourceCode = R"(
+		contract C {
+			address[3] addr;
+			event E(address[3] a);
+			function f() public {
+				assembly {
+					sstore(0, sub(0, 1))
+					sstore(1, sub(0, 2))
+					sstore(2, sub(0, 3))
+				}
+				emit E(addr);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			h160("ffffffffffffffffffffffffffffffffffffffff"),
+			h160("fffffffffffffffffffffffffffffffffffffffe"),
+			h160("fffffffffffffffffffffffffffffffffffffffd")
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(storage_array_dyn)
+{
+	std::string sourceCode = R"(
+		contract C {
+			address[] addr;
+			event E(address[] a);
+			function f() public {
+				addr.push(0x0000000000000000000000000000000000000001);
+				addr.push(0x0000000000000000000000000000000000000002);
+				addr.push(0x0000000000000000000000000000000000000003);
+				emit E(addr);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			0x20,
+			3,
+			h160("0000000000000000000000000000000000000001"),
+			h160("0000000000000000000000000000000000000002"),
+			h160("0000000000000000000000000000000000000003")
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(storage_array_compact)
+{
+	std::string sourceCode = R"(
+		contract C {
+			int72[] x;
+			event E(int72[]);
+			function f() public {
+				x.push(-1);
+				x.push(2);
+				x.push(-3);
+				x.push(4);
+				x.push(-5);
+				x.push(6);
+				x.push(-7);
+				x.push(8);
+				emit E(x);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f()");
+		REQUIRE_LOG_DATA(encodeArgs(
+			0x20, 8, u256(-1), 2, u256(-3), 4, u256(-5), 6, u256(-7), 8
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(external_function)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(function(uint) external returns (uint), function(uint) external returns (uint));
+			function(uint) external returns (uint) g;
+			function f(uint) public returns (uint) {
+				g = this.f;
+				emit E(this.f, g);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f(uint256)", u256(0));
+		std::string functionIdF = asString(m_contractAddress.ref()) + asString(util::selectorFromSignatureH32("f(uint256)").ref());
+		REQUIRE_LOG_DATA(encodeArgs(functionIdF, functionIdF));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(external_function_cleanup)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(function(uint) external returns (uint), function(uint) external returns (uint));
+			// This test relies on the fact that g is stored in slot zero.
+			function(uint) external returns (uint) g;
+			function f(uint) public returns (uint) {
+				function(uint) external returns (uint)[1] memory h;
+				assembly { sstore(0, sub(0, 1)) mstore(h, sub(0, 1)) }
+				emit E(h[0], g);
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f(uint256)", u256(0));
+		REQUIRE_LOG_DATA(encodeArgs(std::string(24, char(-1)), std::string(24, char(-1))));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(calldata)
+{
+	std::string sourceCode = R"(
+		contract C {
+			event E(bytes);
+			function f(bytes calldata a) external {
+				emit E(a);
+			}
+		}
+	)";
+	std::string s("abcdef");
+	std::string t("abcdefgggggggggggggggggggggggggggggggggggggggghhheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeggg");
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		callContractFunction("f(bytes)", 0x20, s.size(), s);
+		REQUIRE_LOG_DATA(encodeArgs(0x20, s.size(), s));
+		callContractFunction("f(bytes)", 0x20, t.size(), t);
+		REQUIRE_LOG_DATA(encodeArgs(0x20, t.size(), t));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(function_name_collision)
+{
+	// This tests a collision between a function name used by inline assembly
+	// and by the ABI encoder
+	std::string sourceCode = R"(
+		contract C {
+			function f(uint x) public returns (uint) {
+				assembly {
+					function abi_encode_t_uint256_to_t_uint256() {
+						mstore(0, 7)
+						return(0, 0x20)
+					}
+					switch x
+					case 0 { abi_encode_t_uint256_to_t_uint256() }
+				}
+				return 1;
+			}
+		}
+	)";
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode);
+		BOOST_CHECK(callContractFunction("f(uint256)", encodeArgs(0)) == encodeArgs(7));
+		BOOST_CHECK(callContractFunction("f(uint256)", encodeArgs(1)) == encodeArgs(1));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(structs)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S { uint16 a; uint16 b; T[] sub; uint16 c; }
+			struct T { uint64[2] x; }
+			S s;
+			event e(uint16, S);
+			function f() public returns (uint, S memory) {
+				uint16 x = 7;
+				s.a = 8;
+				s.b = 9;
+				s.c = 10;
+				s.sub.push();
+				s.sub.push();
+				s.sub.push();
+				s.sub[0].x[0] = 11;
+				s.sub[1].x[0] = 12;
+				s.sub[2].x[1] = 13;
+				emit e(x, s);
+				return (x, s);
+			}
+		}
+	)";
+
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C");
+		bytes encoded = encodeArgs(
+			u256(7), 0x40,
+			8, 9, 0x80, 10,
+			3,
+			11, 0,
+			12, 0,
+			0, 13
+		);
+		BOOST_CHECK(callContractFunction("f()") == encoded);
+		REQUIRE_LOG_DATA(encoded);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), keccak256(std::string("e(uint16,(uint16,uint16,(uint64[2])[],uint16))")));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(structs2)
+{
+	std::string sourceCode = R"(
+		contract C {
+			enum E {A, B, C}
+			struct T { uint x; E e; uint8 y; }
+			struct S { C c; T[] t;}
+			function f() public returns (uint a, S[2] memory s1, S[] memory s2, uint b) {
+				a = 7;
+				b = 8;
+				s1[0].c = this;
+				s1[0].t = new T[](1);
+				s1[0].t[0].x = 0x11;
+				s1[0].t[0].e = E.B;
+				s1[0].t[0].y = 0x12;
+				s2 = new S[](2);
+				s2[1].c = C(address(0x1234));
+				s2[1].t = new T[](3);
+				s2[1].t[1].x = 0x21;
+				s2[1].t[1].e = E.C;
+				s2[1].t[1].y = 0x22;
+			}
+		}
+	)";
+
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(
+			7, 0x80, 0x1e0, 8,
+			// S[2] s1
+			0x40,
+			0x100,
+			// S s1[0]
+			m_contractAddress,
+			0x40,
+			// T s1[0].t
+			1, // length
+			// s1[0].t[0]
+			0x11, 1, 0x12,
+			// S s1[1]
+			0, 0x40,
+			// T s1[1].t
+			0,
+			// S[] s2 (0x1e0)
+			2, // length
+			0x40, 0xa0,
+			// S s2[0]
+			0, 0x40, 0,
+			// S s2[1]
+			0x1234, 0x40,
+			// s2[1].t
+			3, // length
+			0, 0, 0,
+			0x21, 2, 0x22,
+			0, 0, 0
+		));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bool_arrays)
+{
+	std::string sourceCode = R"(
+		contract C {
+			bool[] x;
+			bool[4] y;
+			event E(bool[], bool[4]);
+			function f() public returns (bool[] memory, bool[4] memory) {
+				x.push(true);
+				x.push(false);
+				x.push(true);
+				x.push(false);
+				y[0] = true;
+				y[1] = false;
+				y[2] = true;
+				y[3] = false;
+				emit E(x, y);
+				return (x, y); // this copies to memory first
+			}
+		}
+	)";
+
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode, 0, "C");
+		bytes encoded = encodeArgs(
+			0xa0, 1, 0, 1, 0,
+			4, 1, 0, 1, 0
+		);
+		ABI_CHECK(callContractFunction("f()"), encoded);
+		REQUIRE_LOG_DATA(encoded);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bool_arrays_split)
+{
+	std::string sourceCode = R"(
+		contract C {
+			bool[] x;
+			bool[4] y;
+			event E(bool[], bool[4]);
+			function store() public {
+				x.push(true);
+				x.push(false);
+				x.push(true);
+				x.push(false);
+				y[0] = true;
+				y[1] = false;
+				y[2] = true;
+				y[3] = false;
+			}
+			function f() public returns (bool[] memory, bool[4] memory) {
+				emit E(x, y);
+				return (x, y); // this copies to memory first
+			}
+		}
+	)";
+
+	BOTH_ENCODERS(
+		compileAndRun(sourceCode, 0, "C");
+		bytes encoded = encodeArgs(
+			0xa0, 1, 0, 1, 0,
+			4, 1, 0, 1, 0
+		);
+		ABI_CHECK(callContractFunction("store()"), bytes{});
+		ABI_CHECK(callContractFunction("f()"), encoded);
+		REQUIRE_LOG_DATA(encoded);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bytesNN_arrays)
+{
+	// This tests that encoding packed arrays from storage work correctly.
+	std::string sourceCode = R"(
+		contract C {
+			bytes8[] x;
+			bytesWIDTH[SIZE] y;
+			event E(bytes8[], bytesWIDTH[SIZE]);
+			function store() public {
+				x.push("abc");
+				x.push("def");
+				for (uint i = 0; i < y.length; i ++)
+					y[i] = bytesWIDTH(uintUINTWIDTH(i + 1));
+			}
+			function f() public returns (bytes8[] memory, bytesWIDTH[SIZE] memory) {
+				emit E(x, y);
+				return (x, y); // this copies to memory first
+			}
+		}
+	)";
+
+	BOTH_ENCODERS(
+		for (size_t size = 1; size < 15; size++)
+		{
+			for (size_t width: {1u, 2u, 4u, 5u, 7u, 15u, 16u, 17u, 31u, 32u})
+			{
+				std::string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", std::to_string(size));
+				source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", std::to_string(width * 8));
+				source = boost::algorithm::replace_all_copy(source, "WIDTH", std::to_string(width));
+				compileAndRun(source, 0, "C");
+				ABI_CHECK(callContractFunction("store()"), bytes{});
+				std::vector<u256> arr;
+				for (size_t i = 0; i < size; i ++)
+					arr.emplace_back(u256(i + 1) << (8 * (32 - width)));
+				bytes encoded = encodeArgs(
+					0x20 * (1 + size), arr,
+					2, "abc", "def"
+				);
+				ABI_CHECK(callContractFunction("f()"), encoded);
+				REQUIRE_LOG_DATA(encoded);
+			}
+		}
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bytesNN_arrays_dyn)
+{
+	// This tests that encoding packed arrays from storage work correctly.
+	std::string sourceCode = R"(
+		contract C {
+			bytes8[] x;
+			bytesWIDTH[] y;
+			event E(bytesWIDTH[], bytes8[]);
+			function store() public {
+				x.push("abc");
+				x.push("def");
+				for (uint i = 0; i < SIZE; i ++)
+					y.push(bytesWIDTH(uintUINTWIDTH(i + 1)));
+			}
+			function f() public returns (bytesWIDTH[] memory, bytes8[] memory) {
+				emit E(y, x);
+				return (y, x); // this copies to memory first
+			}
+		}
+	)";
+
+	BOTH_ENCODERS(
+		for (size_t size = 0; size < 15; size++)
+		{
+			for (size_t width: {1u, 2u, 4u, 5u, 7u, 15u, 16u, 17u, 31u, 32u})
+			{
+				std::string source = boost::algorithm::replace_all_copy(sourceCode, "SIZE", std::to_string(size));
+				source = boost::algorithm::replace_all_copy(source, "UINTWIDTH", std::to_string(width * 8));
+				source = boost::algorithm::replace_all_copy(source, "WIDTH", std::to_string(width));
+				compileAndRun(source, 0, "C");
+				ABI_CHECK(callContractFunction("store()"), bytes{});
+				std::vector<u256> arr;
+				for (size_t i = 0; i < size; i ++)
+					arr.emplace_back(u256(i + 1) << (8 * (32 - width)));
+				bytes encoded = encodeArgs(
+					0x20 * 2, 0x20 * (3 + size),
+					size, arr,
+					2, "abc", "def"
+				);
+				ABI_CHECK(callContractFunction("f()"), encoded);
+				REQUIRE_LOG_DATA(encoded);
+			}
+		}
+	)
+}
+
+BOOST_AUTO_TEST_CASE(packed_structs)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S { bool a; int8 b; function() external g; bytes3 d; int8 e; }
+			S s;
+			event E(S);
+			function store() public {
+				s.a = false;
+				s.b = -5;
+				s.g = this.g;
+				s.d = 0x010203;
+				s.e = -3;
+			}
+			function f() public returns (S memory) {
+				emit E(s);
+				return s; // this copies to memory first
+			}
+			function g() public pure {}
+		}
+	)";
+
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("store()"), bytes{});
+		bytes fun = m_contractAddress.asBytes() + fromHex("0xe2179b8e");
+		bytes encoded = encodeArgs(
+			0, u256(-5), asString(fun), "\x01\x02\x03", u256(-3)
+		);
+		ABI_CHECK(callContractFunction("f()"), encoded);
+		REQUIRE_LOG_DATA(encoded);
+	)
+}
+
+
+BOOST_AUTO_TEST_CASE(struct_in_constructor)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S {
+				string a;
+				uint8 b;
+				string c;
+			}
+			S public x;
+			constructor(S memory s) { x = s; }
+		}
+	)";
+
+	NEW_ENCODER(
+		compileAndRun(sourceCode, 0, "C", encodeArgs(0x20, 0x60, 0x03, 0x80, 0x00, 0x00));
+		ABI_CHECK(callContractFunction("x()"), encodeArgs(0x60, 0x03, 0x80, 0x00, 0x00));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(struct_in_constructor_indirect)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S {
+				string a;
+				uint8 b;
+				string c;
+			}
+			S public x;
+			constructor(S memory s) { x = s; }
+		}
+
+		contract D {
+			function f() public returns (string memory, uint8, string memory) {
+				C.S memory s;
+				s.a = "abc";
+				s.b = 7;
+				s.c = "def";
+				C c = new C(s);
+				return c.x();
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		NEW_ENCODER(
+			compileAndRun(sourceCode, 0, "D");
+			ABI_CHECK(callContractFunction("f()"), encodeArgs(0x60, 7, 0xa0, 3, "abc", 3, "def"));
+		)
+	}
+}
+
+BOOST_AUTO_TEST_CASE(struct_in_constructor_data_short)
+{
+	std::string sourceCode = R"(
+		contract C {
+			struct S {
+				string a;
+				uint8 b;
+				string c;
+			}
+			S public x;
+			constructor(S memory s) { x = s; }
+		}
+	)";
+
+	NEW_ENCODER(
+		BOOST_CHECK(
+			compileAndRunWithoutCheck({{"", sourceCode}}, 0, "C", encodeArgs(0x20, 0x60, 0x03, 0x80, 0x00)).empty()
+		);
+	)
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/ABIJson/event_emited_in_base_contract.sol b/compiler/test/libsolidity/ABIJson/event_emited_in_base_contract.sol
new file mode 100644
index 00000000..f9c3d201
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/event_emited_in_base_contract.sol
@@ -0,0 +1,71 @@
+library   L { event E(uint8); }
+
+contract B {
+    constructor() {
+        emit L.E(0);
+    }
+}
+
+contract C is B {}
+
+// ----
+//     :B
+// [
+//   {
+//     "inputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "constructor"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint8",
+//         "name": "",
+//         "type": "uint8"
+//       }
+//     ],
+//     "name": "E",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :C
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint8",
+//         "name": "",
+//         "type": "uint8"
+//       }
+//     ],
+//     "name": "E",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :L
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint8",
+//         "name": "",
+//         "type": "uint8"
+//       }
+//     ],
+//     "name": "E",
+//     "type": "event"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/event_emitted_from_foreign_contract.sol b/compiler/test/libsolidity/ABIJson/event_emitted_from_foreign_contract.sol
new file mode 100644
index 00000000..30c11566
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/event_emitted_from_foreign_contract.sol
@@ -0,0 +1,112 @@
+interface I {
+    event Event(uint256 value);
+}
+contract C {
+    event Event(address indexed sender);
+}
+contract D {
+    event Event(address indexed sender);
+    function test(address sender) public {
+        emit I.Event(1);
+        emit C.Event(msg.sender);
+        emit Event(msg.sender);
+    }
+}
+// ----
+//     :C
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": true,
+//         "internalType": "address",
+//         "name": "sender",
+//         "type": "address"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :D
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "value",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": true,
+//         "internalType": "address",
+//         "name": "sender",
+//         "type": "address"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": true,
+//         "internalType": "address",
+//         "name": "sender",
+//         "type": "address"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "inputs":
+//     [
+//       {
+//         "internalType": "address",
+//         "name": "sender",
+//         "type": "address"
+//       }
+//     ],
+//     "name": "test",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
+//
+//
+//     :I
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "value",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/event_file_level.sol b/compiler/test/libsolidity/ABIJson/event_file_level.sol
new file mode 100644
index 00000000..5b5c39a8
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/event_file_level.sol
@@ -0,0 +1,107 @@
+event Event();
+event Event(uint);
+
+event UnusedEvent();
+
+function f() {
+    emit Event();
+}
+
+contract C {
+    function c_main() public {
+        emit Event(42);
+        f();
+    }
+}
+
+contract D is C {
+    event Event(string);
+
+    function d_main() public {
+        emit Event("abc");
+    }
+}
+// ----
+//     :C
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "c_main",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
+//
+//
+//     :D
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "string",
+//         "name": "",
+//         "type": "string"
+//       }
+//     ],
+//     "name": "Event",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "c_main",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "d_main",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/event_from_aggregated_contract_not_emmited.sol b/compiler/test/libsolidity/ABIJson/event_from_aggregated_contract_not_emmited.sol
new file mode 100644
index 00000000..6a930589
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/event_from_aggregated_contract_not_emmited.sol
@@ -0,0 +1,42 @@
+contract C {
+    event e();
+    function f() public {
+        emit e();
+    }
+}
+
+contract D {
+    C c;
+    constructor() {
+        c = new C();
+        c.f();
+    }
+}
+
+// ----
+//     :C
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "f",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
+//
+//
+//     :D
+// [
+//   {
+//     "inputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "constructor"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/event_inheritance.sol b/compiler/test/libsolidity/ABIJson/event_inheritance.sol
new file mode 100644
index 00000000..e4a8aeea
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/event_inheritance.sol
@@ -0,0 +1,62 @@
+interface B {
+    event EB();
+}
+
+contract C is B {
+    event EC();
+}
+
+contract D is C {
+    event ED();
+}
+
+// ----
+//     :B
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "EB",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :C
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "EB",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "EC",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :D
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "EB",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "EC",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "ED",
+//     "type": "event"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/events_indirect.sol b/compiler/test/libsolidity/ABIJson/events_indirect.sol
new file mode 100644
index 00000000..86368028
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/events_indirect.sol
@@ -0,0 +1,88 @@
+library L {
+    event e1(uint b);
+    event e2();
+    event e2(uint a);
+    event e3() anonymous;
+}
+contract test {
+    function f() public {
+        emit L.e1(1);
+        emit L.e3();
+    }
+}
+// ----
+//     :L
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "b",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "e1",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e2",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "a",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "e2",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": true,
+//     "inputs": [],
+//     "name": "e3",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :test
+// [
+//   {
+//     "anonymous": false,
+//     "inputs":
+//     [
+//       {
+//         "indexed": false,
+//         "internalType": "uint256",
+//         "name": "b",
+//         "type": "uint256"
+//       }
+//     ],
+//     "name": "e1",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": true,
+//     "inputs": [],
+//     "name": "e3",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "f",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/events_repetitions.sol b/compiler/test/libsolidity/ABIJson/events_repetitions.sol
new file mode 100644
index 00000000..8dd980a6
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/events_repetitions.sol
@@ -0,0 +1,45 @@
+library L {
+	event e();
+}
+contract C {
+	constructor() {
+		emit L.e();
+	}
+	function f() public {
+		emit L.e();
+	}
+}
+
+// ----
+//     :C
+// [
+//   {
+//     "inputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "constructor"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "f",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
+//
+//
+//     :L
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/mapping.sol b/compiler/test/libsolidity/ABIJson/mapping.sol
new file mode 100644
index 00000000..e84b716f
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/mapping.sol
@@ -0,0 +1,77 @@
+contract test {
+    mapping(address owner => mapping(address spender => uint value)) public allowance;
+    mapping(bytes32 => address sender) public commits;
+    mapping(bytes32 => bytes32) public something;
+}
+// ----
+//     :test
+// [
+//   {
+//     "inputs":
+//     [
+//       {
+//         "internalType": "address",
+//         "name": "owner",
+//         "type": "address"
+//       },
+//       {
+//         "internalType": "address",
+//         "name": "spender",
+//         "type": "address"
+//       }
+//     ],
+//     "name": "allowance",
+//     "outputs":
+//     [
+//       {
+//         "internalType": "uint256",
+//         "name": "value",
+//         "type": "uint256"
+//       }
+//     ],
+//     "stateMutability": "view",
+//     "type": "function"
+//   },
+//   {
+//     "inputs":
+//     [
+//       {
+//         "internalType": "bytes32",
+//         "name": "",
+//         "type": "bytes32"
+//       }
+//     ],
+//     "name": "commits",
+//     "outputs":
+//     [
+//       {
+//         "internalType": "address",
+//         "name": "sender",
+//         "type": "address"
+//       }
+//     ],
+//     "stateMutability": "view",
+//     "type": "function"
+//   },
+//   {
+//     "inputs":
+//     [
+//       {
+//         "internalType": "bytes32",
+//         "name": "",
+//         "type": "bytes32"
+//       }
+//     ],
+//     "name": "something",
+//     "outputs":
+//     [
+//       {
+//         "internalType": "bytes32",
+//         "name": "",
+//         "type": "bytes32"
+//       }
+//     ],
+//     "stateMutability": "view",
+//     "type": "function"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/same_event_defined_twice.sol b/compiler/test/libsolidity/ABIJson/same_event_defined_twice.sol
new file mode 100644
index 00000000..9a65e61d
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/same_event_defined_twice.sol
@@ -0,0 +1,61 @@
+library L1 { event e(); }
+library L2 { event e(); }
+contract C {
+	constructor() {
+		emit L1.e();
+	}
+	function f() public {
+		emit L2.e();
+	}
+}
+
+// ----
+//     :C
+// [
+//   {
+//     "inputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "constructor"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   },
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   },
+//   {
+//     "inputs": [],
+//     "name": "f",
+//     "outputs": [],
+//     "stateMutability": "nonpayable",
+//     "type": "function"
+//   }
+// ]
+//
+//
+//     :L1
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   }
+// ]
+//
+//
+//     :L2
+// [
+//   {
+//     "anonymous": false,
+//     "inputs": [],
+//     "name": "e",
+//     "type": "event"
+//   }
+// ]
diff --git a/compiler/test/libsolidity/ABIJson/test/lol.json/basic_test.sol_json.ast b/compiler/test/libsolidity/ABIJson/test/lol.json/basic_test.sol_json.ast
new file mode 100644
index 00000000..21d4ed37
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJson/test/lol.json/basic_test.sol_json.ast
@@ -0,0 +1 @@
+{"absolutePath":"basic_test.sol","exportedSymbols":{"test":[13]},"id":14,"nodeType":"SourceUnit","nodes":[{"abstract":false,"baseContracts":[],"canonicalName":"test","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"id":13,"linearizedBaseContracts":[13],"name":"test","nameLocation":"9:4:0","nodeType":"ContractDefinition","nodes":[{"body":{"id":11,"nodeType":"Block","src":"60:17:0","statements":[{"expression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":9,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":7,"name":"a","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":2,"src":"69:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"37","id":8,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"73:1:0","typeDescriptions":{"typeIdentifier":"t_rational_7_by_1","typeString":"int_const 7"},"value":"7"},"src":"69:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"functionReturnParameters":6,"id":10,"nodeType":"Return","src":"62:12:0"}]},"functionSelector":"b3de648b","id":12,"implemented":true,"kind":"function","modifiers":[],"name":"f","nameLocation":"26:1:0","nodeType":"FunctionDefinition","parameters":{"id":3,"nodeType":"ParameterList","parameters":[{"constant":false,"id":2,"mutability":"mutable","name":"a","nameLocation":"33:1:0","nodeType":"VariableDeclaration","scope":12,"src":"28:6:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":1,"name":"uint","nodeType":"ElementaryTypeName","src":"28:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"27:8:0"},"returnParameters":{"id":6,"nodeType":"ParameterList","parameters":[{"constant":false,"id":5,"mutability":"mutable","name":"d","nameLocation":"57:1:0","nodeType":"VariableDeclaration","scope":12,"src":"52:6:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":4,"name":"uint","nodeType":"ElementaryTypeName","src":"52:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"51:8:0"},"scope":13,"src":"17:60:0","stateMutability":"nonpayable","virtual":false,"visibility":"public"}],"scope":14,"src":"0:79:0","usedErrors":[]}],"src":"0:510:0"}
\ No newline at end of file
diff --git a/compiler/test/libsolidity/ABIJsonTest.cpp b/compiler/test/libsolidity/ABIJsonTest.cpp
new file mode 100644
index 00000000..803445b9
--- /dev/null
+++ b/compiler/test/libsolidity/ABIJsonTest.cpp
@@ -0,0 +1,68 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * Unit tests for the solidity compiler ABI JSON Interface output.
+ */
+
+#include <test/libsolidity/ABIJsonTest.h>
+
+#include <test/Common.h>
+
+#include <libsolidity/interface/CompilerStack.h>
+#include <libsolutil/JSON.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <fstream>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+ABIJsonTest::ABIJsonTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult ABIJsonTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	CompilerStack compiler;
+
+	compiler.setSources({{
+		"",
+		"pragma solidity >=0.0;\n// SPDX-License-Identifier: GPL-3.0\n" + m_source
+	}});
+	compiler.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+	if (!compiler.parseAndAnalyze())
+		BOOST_THROW_EXCEPTION(std::runtime_error("Parsing contract failed"));
+
+	m_obtainedResult.clear();
+	bool first = true;
+	for (std::string const& contractName: compiler.contractNames())
+	{
+		if (!first)
+			m_obtainedResult += "\n\n";
+		m_obtainedResult += "    " + contractName + "\n";
+		m_obtainedResult += jsonPrettyPrint(compiler.contractABI(contractName)) + "\n";
+		first = false;
+	}
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libsolidity/ABITestsCommon.h b/compiler/test/libsolidity/ABITestsCommon.h
new file mode 100644
index 00000000..67c34498
--- /dev/null
+++ b/compiler/test/libsolidity/ABITestsCommon.h
@@ -0,0 +1,46 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <string>
+
+namespace solidity::frontend::test
+{
+
+#define NEW_ENCODER(CODE) \
+{ \
+	std::string sourceCodeTmp = sourceCode; \
+	sourceCode = "pragma abicoder v2;\n" + sourceCode; \
+	{ CODE } \
+	sourceCode = sourceCodeTmp; \
+}
+
+#define OLD_ENCODER(CODE) \
+{ \
+	std::string sourceCodeTmp = sourceCode; \
+	sourceCode = "pragma abicoder v1;\n" + sourceCode; \
+	{ CODE } \
+	sourceCode = sourceCodeTmp; \
+}
+
+#define BOTH_ENCODERS(CODE) \
+{ \
+	OLD_ENCODER(CODE) \
+	NEW_ENCODER(CODE) \
+}
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/ASTJSON/abstract_contract.json b/compiler/test/libsolidity/ASTJSON/abstract_contract.json
new file mode 100644
index 00000000..48c20b43
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/abstract_contract.json
@@ -0,0 +1,74 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": true,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "18:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "37:4:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "34:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "scope": 5,
+          "src": "23:18:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "scope": 6,
+      "src": "0:43:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:44:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/abstract_contract.sol b/compiler/test/libsolidity/ASTJSON/abstract_contract.sol
new file mode 100644
index 00000000..3ef96612
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/abstract_contract.sol
@@ -0,0 +1,5 @@
+abstract contract C {
+	constructor() {
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/abstract_contract_parseOnly.json b/compiler/test/libsolidity/ASTJSON/abstract_contract_parseOnly.json
new file mode 100644
index 00000000..d9ba04e6
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/abstract_contract_parseOnly.json
@@ -0,0 +1,58 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": true,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "18:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "37:4:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "34:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "src": "23:18:1",
+          "stateMutability": "nonpayable",
+          "virtual": false
+        }
+      ],
+      "src": "0:43:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:44:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/address_payable.json b/compiler/test/libsolidity/ASTJSON/address_payable.json
new file mode 100644
index 00000000..adf79823
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/address_payable.json
@@ -0,0 +1,579 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      39
+    ]
+  },
+  "id": 40,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 39,
+      "linearizedBaseContracts":
+      [
+        39
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "functionSelector": "97682884",
+          "id": 4,
+          "mutability": "mutable",
+          "name": "m",
+          "nameLocation": "60:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 39,
+          "src": "17:44:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_address_$_t_address_payable_$",
+            "typeString": "mapping(address => address payable)"
+          },
+          "typeName":
+          {
+            "id": 3,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 1,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "25:7:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_address",
+                "typeString": "address"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "17:35:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_address_$_t_address_payable_$",
+              "typeString": "mapping(address => address payable)"
+            },
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 2,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "36:15:1",
+              "stateMutability": "payable",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_address_payable",
+                "typeString": "address payable"
+              }
+            }
+          },
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 37,
+            "nodeType": "Block",
+            "src": "134:122:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  12
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 12,
+                    "mutability": "mutable",
+                    "name": "a",
+                    "nameLocation": "160:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 37,
+                    "src": "144:17:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    },
+                    "typeName":
+                    {
+                      "id": 11,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "144:15:1",
+                      "stateMutability": "payable",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_address_payable",
+                        "typeString": "address payable"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 16,
+                "initialValue":
+                {
+                  "baseExpression":
+                  {
+                    "id": 13,
+                    "name": "m",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 4,
+                    "src": "164:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_mapping$_t_address_$_t_address_payable_$",
+                      "typeString": "mapping(address => address payable)"
+                    }
+                  },
+                  "id": 15,
+                  "indexExpression":
+                  {
+                    "id": 14,
+                    "name": "arg",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 6,
+                    "src": "166:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    }
+                  },
+                  "isConstant": false,
+                  "isLValue": true,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "nodeType": "IndexAccess",
+                  "src": "164:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address_payable",
+                    "typeString": "address payable"
+                  }
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "144:26:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 19,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftHandSide":
+                  {
+                    "id": 17,
+                    "name": "r",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 9,
+                    "src": "180:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    }
+                  },
+                  "nodeType": "Assignment",
+                  "operator": "=",
+                  "rightHandSide":
+                  {
+                    "id": 18,
+                    "name": "arg",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 6,
+                    "src": "184:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    }
+                  },
+                  "src": "180:7:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address_payable",
+                    "typeString": "address payable"
+                  }
+                },
+                "id": 20,
+                "nodeType": "ExpressionStatement",
+                "src": "180:7:1"
+              },
+              {
+                "assignments":
+                [
+                  22
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 22,
+                    "mutability": "mutable",
+                    "name": "c",
+                    "nameLocation": "205:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 37,
+                    "src": "197:9:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address",
+                      "typeString": "address"
+                    },
+                    "typeName":
+                    {
+                      "id": 21,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "197:7:1",
+                      "stateMutability": "nonpayable",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_address",
+                        "typeString": "address"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 27,
+                "initialValue":
+                {
+                  "arguments":
+                  [
+                    {
+                      "id": 25,
+                      "name": "this",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": -28,
+                      "src": "217:4:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_contract$_C_$39",
+                        "typeString": "contract C"
+                      }
+                    }
+                  ],
+                  "expression":
+                  {
+                    "argumentTypes":
+                    [
+                      {
+                        "typeIdentifier": "t_contract$_C_$39",
+                        "typeString": "contract C"
+                      }
+                    ],
+                    "id": 24,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "lValueRequested": false,
+                    "nodeType": "ElementaryTypeNameExpression",
+                    "src": "209:7:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_type$_t_address_$",
+                      "typeString": "type(address)"
+                    },
+                    "typeName":
+                    {
+                      "id": 23,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "209:7:1",
+                      "typeDescriptions": {}
+                    }
+                  },
+                  "id": 26,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "typeConversion",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "209:13:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address",
+                    "typeString": "address"
+                  }
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "197:25:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 35,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftHandSide":
+                  {
+                    "baseExpression":
+                    {
+                      "id": 28,
+                      "name": "m",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 4,
+                      "src": "232:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_mapping$_t_address_$_t_address_payable_$",
+                        "typeString": "mapping(address => address payable)"
+                      }
+                    },
+                    "id": 30,
+                    "indexExpression":
+                    {
+                      "id": 29,
+                      "name": "c",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 22,
+                      "src": "234:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_address",
+                        "typeString": "address"
+                      }
+                    },
+                    "isConstant": false,
+                    "isLValue": true,
+                    "isPure": false,
+                    "lValueRequested": true,
+                    "nodeType": "IndexAccess",
+                    "src": "232:4:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    }
+                  },
+                  "nodeType": "Assignment",
+                  "operator": "=",
+                  "rightHandSide":
+                  {
+                    "arguments":
+                    [
+                      {
+                        "hexValue": "30",
+                        "id": 33,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": true,
+                        "kind": "number",
+                        "lValueRequested": false,
+                        "nodeType": "Literal",
+                        "src": "247:1:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_rational_0_by_1",
+                          "typeString": "int_const 0"
+                        },
+                        "value": "0"
+                      }
+                    ],
+                    "expression":
+                    {
+                      "argumentTypes":
+                      [
+                        {
+                          "typeIdentifier": "t_rational_0_by_1",
+                          "typeString": "int_const 0"
+                        }
+                      ],
+                      "id": 32,
+                      "isConstant": false,
+                      "isLValue": false,
+                      "isPure": true,
+                      "lValueRequested": false,
+                      "nodeType": "ElementaryTypeNameExpression",
+                      "src": "239:8:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_type$_t_address_payable_$",
+                        "typeString": "type(address payable)"
+                      },
+                      "typeName":
+                      {
+                        "id": 31,
+                        "name": "address",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "239:8:1",
+                        "stateMutability": "payable",
+                        "typeDescriptions": {}
+                      }
+                    },
+                    "id": 34,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "typeConversion",
+                    "lValueRequested": false,
+                    "nameLocations": [],
+                    "names": [],
+                    "nodeType": "FunctionCall",
+                    "src": "239:10:1",
+                    "tryCall": false,
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_address_payable",
+                      "typeString": "address payable"
+                    }
+                  },
+                  "src": "232:17:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address_payable",
+                    "typeString": "address payable"
+                  }
+                },
+                "id": 36,
+                "nodeType": "ExpressionStatement",
+                "src": "232:17:1"
+              }
+            ]
+          },
+          "functionSelector": "fc68521a",
+          "id": 38,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "arg",
+                "nameLocation": "94:3:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 38,
+                "src": "78:19:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_address_payable",
+                  "typeString": "address payable"
+                },
+                "typeName":
+                {
+                  "id": 5,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "78:15:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address_payable",
+                    "typeString": "address payable"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "77:21:1"
+          },
+          "returnParameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 9,
+                "mutability": "mutable",
+                "name": "r",
+                "nameLocation": "131:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 38,
+                "src": "115:17:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_address_payable",
+                  "typeString": "address payable"
+                },
+                "typeName":
+                {
+                  "id": 8,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "115:15:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address_payable",
+                    "typeString": "address payable"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "114:19:1"
+          },
+          "scope": 39,
+          "src": "67:189:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 40,
+      "src": "0:258:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:259:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/address_payable.sol b/compiler/test/libsolidity/ASTJSON/address_payable.sol
new file mode 100644
index 00000000..f9ebb124
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/address_payable.sol
@@ -0,0 +1,10 @@
+contract C {
+    mapping(address => address payable) public m;
+    function f(address payable arg) public returns (address payable r) {
+        address payable a = m[arg];
+        r = arg;
+        address c = address(this);
+        m[c] = payable(0);
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/address_payable_parseOnly.json b/compiler/test/libsolidity/ASTJSON/address_payable_parseOnly.json
new file mode 100644
index 00000000..02b809cc
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/address_payable_parseOnly.json
@@ -0,0 +1,386 @@
+{
+  "absolutePath": "a",
+  "id": 40,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 39,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 4,
+          "mutability": "mutable",
+          "name": "m",
+          "nameLocation": "60:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "17:44:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 3,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 1,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "25:7:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "17:35:1",
+            "typeDescriptions": {},
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 2,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "36:15:1",
+              "stateMutability": "payable",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 37,
+            "nodeType": "Block",
+            "src": "134:122:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  12
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 12,
+                    "mutability": "mutable",
+                    "name": "a",
+                    "nameLocation": "160:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "144:17:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 11,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "144:15:1",
+                      "stateMutability": "payable",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 16,
+                "initialValue":
+                {
+                  "baseExpression":
+                  {
+                    "id": 13,
+                    "name": "m",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "164:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 15,
+                  "indexExpression":
+                  {
+                    "id": 14,
+                    "name": "arg",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "166:3:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "IndexAccess",
+                  "src": "164:6:1",
+                  "typeDescriptions": {}
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "144:26:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 19,
+                  "leftHandSide":
+                  {
+                    "id": 17,
+                    "name": "r",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "180:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "Assignment",
+                  "operator": "=",
+                  "rightHandSide":
+                  {
+                    "id": 18,
+                    "name": "arg",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "184:3:1",
+                    "typeDescriptions": {}
+                  },
+                  "src": "180:7:1",
+                  "typeDescriptions": {}
+                },
+                "id": 20,
+                "nodeType": "ExpressionStatement",
+                "src": "180:7:1"
+              },
+              {
+                "assignments":
+                [
+                  22
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 22,
+                    "mutability": "mutable",
+                    "name": "c",
+                    "nameLocation": "205:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "197:9:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 21,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "197:7:1",
+                      "stateMutability": "nonpayable",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 27,
+                "initialValue":
+                {
+                  "arguments":
+                  [
+                    {
+                      "id": 25,
+                      "name": "this",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "217:4:1",
+                      "typeDescriptions": {}
+                    }
+                  ],
+                  "expression":
+                  {
+                    "id": 24,
+                    "nodeType": "ElementaryTypeNameExpression",
+                    "src": "209:7:1",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 23,
+                      "name": "address",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "209:7:1",
+                      "typeDescriptions": {}
+                    }
+                  },
+                  "id": 26,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "209:13:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "197:25:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 35,
+                  "leftHandSide":
+                  {
+                    "baseExpression":
+                    {
+                      "id": 28,
+                      "name": "m",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "232:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "id": 30,
+                    "indexExpression":
+                    {
+                      "id": 29,
+                      "name": "c",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "234:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "nodeType": "IndexAccess",
+                    "src": "232:4:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "Assignment",
+                  "operator": "=",
+                  "rightHandSide":
+                  {
+                    "arguments":
+                    [
+                      {
+                        "hexValue": "30",
+                        "id": 33,
+                        "kind": "number",
+                        "nodeType": "Literal",
+                        "src": "247:1:1",
+                        "typeDescriptions": {},
+                        "value": "0"
+                      }
+                    ],
+                    "expression":
+                    {
+                      "id": 32,
+                      "nodeType": "ElementaryTypeNameExpression",
+                      "src": "239:8:1",
+                      "typeDescriptions": {},
+                      "typeName":
+                      {
+                        "id": 31,
+                        "name": "address",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "239:8:1",
+                        "stateMutability": "payable",
+                        "typeDescriptions": {}
+                      }
+                    },
+                    "id": 34,
+                    "nameLocations": [],
+                    "names": [],
+                    "nodeType": "FunctionCall",
+                    "src": "239:10:1",
+                    "tryCall": false,
+                    "typeDescriptions": {}
+                  },
+                  "src": "232:17:1",
+                  "typeDescriptions": {}
+                },
+                "id": 36,
+                "nodeType": "ExpressionStatement",
+                "src": "232:17:1"
+              }
+            ]
+          },
+          "id": 38,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "arg",
+                "nameLocation": "94:3:1",
+                "nodeType": "VariableDeclaration",
+                "src": "78:19:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 5,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "78:15:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "77:21:1"
+          },
+          "returnParameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 9,
+                "mutability": "mutable",
+                "name": "r",
+                "nameLocation": "131:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "115:17:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 8,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "115:15:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "114:19:1"
+          },
+          "src": "67:189:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:258:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:259:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/array_type_name.json b/compiler/test/libsolidity/ASTJSON/array_type_name.json
new file mode 100644
index 00000000..1cd97e17
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/array_type_name.json
@@ -0,0 +1,80 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      4
+    ]
+  },
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 4,
+      "linearizedBaseContracts":
+      [
+        4
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "i",
+          "nameLocation": "20:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 4,
+          "src": "13:8:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_array$_t_uint256_$dyn_storage",
+            "typeString": "uint256[]"
+          },
+          "typeName":
+          {
+            "baseType":
+            {
+              "id": 1,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "13:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_uint256",
+                "typeString": "uint256"
+              }
+            },
+            "id": 2,
+            "nodeType": "ArrayTypeName",
+            "src": "13:6:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+              "typeString": "uint256[]"
+            }
+          },
+          "visibility": "internal"
+        }
+      ],
+      "scope": 5,
+      "src": "0:24:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:25:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/array_type_name_parseOnly.json b/compiler/test/libsolidity/ASTJSON/array_type_name_parseOnly.json
new file mode 100644
index 00000000..1e0b72ca
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/array_type_name_parseOnly.json
@@ -0,0 +1,53 @@
+{
+  "absolutePath": "a",
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 4,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "i",
+          "nameLocation": "20:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "13:8:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "baseType":
+            {
+              "id": 1,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "13:4:1",
+              "typeDescriptions": {}
+            },
+            "id": 2,
+            "nodeType": "ArrayTypeName",
+            "src": "13:6:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        }
+      ],
+      "src": "0:24:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:25:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/call.json b/compiler/test/libsolidity/ASTJSON/assembly/call.json
new file mode 100644
index 00000000..d92cf05f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/call.json
@@ -0,0 +1,185 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:59:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:34:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:34:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "arguments":
+                            [
+                              {
+                                "kind": "number",
+                                "nativeSrc": "67:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "67:1:1",
+                                "type": "",
+                                "value": "0"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "70:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "70:1:1",
+                                "type": "",
+                                "value": "1"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "73:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "73:1:1",
+                                "type": "",
+                                "value": "2"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "76:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "76:1:1",
+                                "type": "",
+                                "value": "3"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "79:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "79:1:1",
+                                "type": "",
+                                "value": "4"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "82:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "82:1:1",
+                                "type": "",
+                                "value": "5"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "85:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "85:1:1",
+                                "type": "",
+                                "value": "6"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "call",
+                              "nativeSrc": "62:4:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "62:4:1"
+                            },
+                            "nativeSrc": "62:25:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "62:25:1"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "pop",
+                          "nativeSrc": "58:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "58:3:1"
+                        },
+                        "nativeSrc": "58:30:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "58:30:1"
+                      },
+                      "nativeSrc": "58:30:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "58:30:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:43:1"
+              }
+            ]
+          },
+          "functionSelector": "b582ec5f",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "j",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "scope": 6,
+          "src": "17:79:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:98:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:99:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/call.sol b/compiler/test/libsolidity/ASTJSON/assembly/call.sol
new file mode 100644
index 00000000..1735fd7f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/call.sol
@@ -0,0 +1,6 @@
+contract C {
+    function j() public {
+        assembly { pop(call(0, 1, 2, 3, 4, 5, 6)) }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/call_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/call_parseOnly.json
new file mode 100644
index 00000000..803a1e4f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/call_parseOnly.json
@@ -0,0 +1,169 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:59:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:34:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:34:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "arguments":
+                            [
+                              {
+                                "kind": "number",
+                                "nativeSrc": "67:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "67:1:1",
+                                "type": "",
+                                "value": "0"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "70:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "70:1:1",
+                                "type": "",
+                                "value": "1"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "73:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "73:1:1",
+                                "type": "",
+                                "value": "2"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "76:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "76:1:1",
+                                "type": "",
+                                "value": "3"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "79:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "79:1:1",
+                                "type": "",
+                                "value": "4"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "82:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "82:1:1",
+                                "type": "",
+                                "value": "5"
+                              },
+                              {
+                                "kind": "number",
+                                "nativeSrc": "85:1:1",
+                                "nodeType": "YulLiteral",
+                                "src": "85:1:1",
+                                "type": "",
+                                "value": "6"
+                              }
+                            ],
+                            "functionName":
+                            {
+                              "name": "call",
+                              "nativeSrc": "62:4:1",
+                              "nodeType": "YulIdentifier",
+                              "src": "62:4:1"
+                            },
+                            "nativeSrc": "62:25:1",
+                            "nodeType": "YulFunctionCall",
+                            "src": "62:25:1"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "pop",
+                          "nativeSrc": "58:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "58:3:1"
+                        },
+                        "nativeSrc": "58:30:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "58:30:1"
+                      },
+                      "nativeSrc": "58:30:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "58:30:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:43:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "j",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "src": "17:79:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:98:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:99:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_block.json b/compiler/test/libsolidity/ASTJSON/assembly/empty_block.json
new file mode 100644
index 00000000..3ec3c2ee
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_block.json
@@ -0,0 +1,99 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:31:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:6:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:6:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "63:2:1",
+                      "nodeType": "YulBlock",
+                      "src": "63:2:1",
+                      "statements": []
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:15:1"
+              }
+            ]
+          },
+          "functionSelector": "e2179b8e",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 6,
+          "src": "17:56:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:75:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:76:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_block.sol b/compiler/test/libsolidity/ASTJSON/assembly/empty_block.sol
new file mode 100644
index 00000000..33bb796e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_block.sol
@@ -0,0 +1,6 @@
+contract C {
+    function g() view public {
+        assembly { {} }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_block_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/empty_block_parseOnly.json
new file mode 100644
index 00000000..ee8e7b73
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_block_parseOnly.json
@@ -0,0 +1,83 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:31:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:6:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:6:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "63:2:1",
+                      "nodeType": "YulBlock",
+                      "src": "63:2:1",
+                      "statements": []
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:15:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:56:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:75:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:76:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.json b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.json
new file mode 100644
index 00000000..9d64279d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.json
@@ -0,0 +1,108 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "39:30:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "52:14:1",
+                  "nodeType": "YulBlock",
+                  "src": "52:14:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "57:5:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "57:5:1",
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "61:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "61:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "43:23:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "23:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "24:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "39:0:1"
+          },
+          "scope": 6,
+          "src": "14:55:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:71:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:72:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.sol b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.sol
new file mode 100644
index 00000000..5b396dd4
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration.sol
@@ -0,0 +1,8 @@
+contract C {
+	function f() public pure {
+		assembly {
+			let x
+		}
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration_parseOnly.json
new file mode 100644
index 00000000..5f12f280
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/empty_let_variable_declaration_parseOnly.json
@@ -0,0 +1,92 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "39:30:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "52:14:1",
+                  "nodeType": "YulBlock",
+                  "src": "52:14:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "57:5:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "57:5:1",
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "61:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "61:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "43:23:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "23:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "24:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "39:0:1"
+          },
+          "src": "14:55:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:71:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:72:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/function.json b/compiler/test/libsolidity/ASTJSON/assembly/function.json
new file mode 100644
index 00000000..a3b908ac
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/function.json
@@ -0,0 +1,171 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:68:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:43:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:43:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "76:22:1",
+                        "nodeType": "YulBlock",
+                        "src": "76:22:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments":
+                              [
+                                {
+                                  "arguments":
+                                  [
+                                    {
+                                      "kind": "number",
+                                      "nativeSrc": "92:2:1",
+                                      "nodeType": "YulLiteral",
+                                      "src": "92:2:1",
+                                      "type": "",
+                                      "value": "20"
+                                    }
+                                  ],
+                                  "functionName":
+                                  {
+                                    "name": "blockhash",
+                                    "nativeSrc": "82:9:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "82:9:1"
+                                  },
+                                  "nativeSrc": "82:13:1",
+                                  "nodeType": "YulFunctionCall",
+                                  "src": "82:13:1"
+                                }
+                              ],
+                              "functionName":
+                              {
+                                "name": "pop",
+                                "nativeSrc": "78:3:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "78:3:1"
+                              },
+                              "nativeSrc": "78:18:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "78:18:1"
+                            },
+                            "nativeSrc": "78:18:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "78:18:1"
+                          }
+                        ]
+                      },
+                      "name": "g",
+                      "nativeSrc": "63:35:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "63:35:1"
+                    },
+                    {
+                      "expression":
+                      {
+                        "arguments": [],
+                        "functionName":
+                        {
+                          "name": "g",
+                          "nativeSrc": "99:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "99:1:1"
+                        },
+                        "nativeSrc": "99:3:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "99:3:1"
+                      },
+                      "nativeSrc": "99:3:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "99:3:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:52:1"
+              }
+            ]
+          },
+          "functionSelector": "b8c9d365",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "h",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 6,
+          "src": "17:93:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:112:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:113:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/function.sol b/compiler/test/libsolidity/ASTJSON/assembly/function.sol
new file mode 100644
index 00000000..1edf2f2d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/function.sol
@@ -0,0 +1,6 @@
+contract C {
+    function h() view public {
+        assembly { function g() { pop(blockhash(20)) } g() }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/function_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/function_parseOnly.json
new file mode 100644
index 00000000..04f5c272
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/function_parseOnly.json
@@ -0,0 +1,155 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:68:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:43:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:43:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "76:22:1",
+                        "nodeType": "YulBlock",
+                        "src": "76:22:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments":
+                              [
+                                {
+                                  "arguments":
+                                  [
+                                    {
+                                      "kind": "number",
+                                      "nativeSrc": "92:2:1",
+                                      "nodeType": "YulLiteral",
+                                      "src": "92:2:1",
+                                      "type": "",
+                                      "value": "20"
+                                    }
+                                  ],
+                                  "functionName":
+                                  {
+                                    "name": "blockhash",
+                                    "nativeSrc": "82:9:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "82:9:1"
+                                  },
+                                  "nativeSrc": "82:13:1",
+                                  "nodeType": "YulFunctionCall",
+                                  "src": "82:13:1"
+                                }
+                              ],
+                              "functionName":
+                              {
+                                "name": "pop",
+                                "nativeSrc": "78:3:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "78:3:1"
+                              },
+                              "nativeSrc": "78:18:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "78:18:1"
+                            },
+                            "nativeSrc": "78:18:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "78:18:1"
+                          }
+                        ]
+                      },
+                      "name": "g",
+                      "nativeSrc": "63:35:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "63:35:1"
+                    },
+                    {
+                      "expression":
+                      {
+                        "arguments": [],
+                        "functionName":
+                        {
+                          "name": "g",
+                          "nativeSrc": "99:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "99:1:1"
+                        },
+                        "nativeSrc": "99:3:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "99:3:1"
+                      },
+                      "nativeSrc": "99:3:1",
+                      "nodeType": "YulExpressionStatement",
+                      "src": "99:3:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:52:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "h",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:93:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:112:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:113:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/leave.json b/compiler/test/libsolidity/ASTJSON/assembly/leave.json
new file mode 100644
index 00000000..51c94f54
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/leave.json
@@ -0,0 +1,113 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:51:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:26:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:26:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "71:9:1",
+                        "nodeType": "YulBlock",
+                        "src": "71:9:1",
+                        "statements":
+                        [
+                          {
+                            "nativeSrc": "73:5:1",
+                            "nodeType": "YulLeave",
+                            "src": "73:5:1"
+                          }
+                        ]
+                      },
+                      "name": "f",
+                      "nativeSrc": "58:22:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "58:22:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:35:1"
+              }
+            ]
+          },
+          "functionSelector": "ece866b9",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "l",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "scope": 6,
+          "src": "17:71:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:90:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:91:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/leave.sol b/compiler/test/libsolidity/ASTJSON/assembly/leave.sol
new file mode 100644
index 00000000..39f1cafe
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/leave.sol
@@ -0,0 +1,6 @@
+contract C {
+    function l() public {
+        assembly { function f() { leave } }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/leave_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/leave_parseOnly.json
new file mode 100644
index 00000000..ee34743e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/leave_parseOnly.json
@@ -0,0 +1,97 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:51:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:26:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:26:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "71:9:1",
+                        "nodeType": "YulBlock",
+                        "src": "71:9:1",
+                        "statements":
+                        [
+                          {
+                            "nativeSrc": "73:5:1",
+                            "nodeType": "YulLeave",
+                            "src": "73:5:1"
+                          }
+                        ]
+                      },
+                      "name": "f",
+                      "nativeSrc": "58:22:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "58:22:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:35:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "l",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "src": "17:71:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:90:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:91:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/loop.json b/compiler/test/libsolidity/ASTJSON/assembly/loop.json
new file mode 100644
index 00000000..d3d20992
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/loop.json
@@ -0,0 +1,186 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:74:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:49:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:49:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "90:18:1",
+                        "nodeType": "YulBlock",
+                        "src": "90:18:1",
+                        "statements":
+                        [
+                          {
+                            "nativeSrc": "92:5:1",
+                            "nodeType": "YulBreak",
+                            "src": "92:5:1"
+                          },
+                          {
+                            "nativeSrc": "98:8:1",
+                            "nodeType": "YulContinue",
+                            "src": "98:8:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "70:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "70:1:1",
+                        "type": "",
+                        "value": "1"
+                      },
+                      "nativeSrc": "63:45:1",
+                      "nodeType": "YulForLoop",
+                      "post":
+                      {
+                        "nativeSrc": "72:17:1",
+                        "nodeType": "YulBlock",
+                        "src": "72:17:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments":
+                              [
+                                {
+                                  "arguments":
+                                  [
+                                    {
+                                      "kind": "number",
+                                      "nativeSrc": "84:1:1",
+                                      "nodeType": "YulLiteral",
+                                      "src": "84:1:1",
+                                      "type": "",
+                                      "value": "0"
+                                    }
+                                  ],
+                                  "functionName":
+                                  {
+                                    "name": "sload",
+                                    "nativeSrc": "78:5:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "78:5:1"
+                                  },
+                                  "nativeSrc": "78:8:1",
+                                  "nodeType": "YulFunctionCall",
+                                  "src": "78:8:1"
+                                }
+                              ],
+                              "functionName":
+                              {
+                                "name": "pop",
+                                "nativeSrc": "74:3:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "74:3:1"
+                              },
+                              "nativeSrc": "74:13:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "74:13:1"
+                            },
+                            "nativeSrc": "74:13:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "74:13:1"
+                          }
+                        ]
+                      },
+                      "pre":
+                      {
+                        "nativeSrc": "67:2:1",
+                        "nodeType": "YulBlock",
+                        "src": "67:2:1",
+                        "statements": []
+                      },
+                      "src": "63:45:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:58:1"
+              }
+            ]
+          },
+          "functionSelector": "e2179b8e",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 6,
+          "src": "17:99:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:118:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:119:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/loop.sol b/compiler/test/libsolidity/ASTJSON/assembly/loop.sol
new file mode 100644
index 00000000..baa45e62
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/loop.sol
@@ -0,0 +1,6 @@
+contract C {
+    function g() view public {
+        assembly { for {} 1 { pop(sload(0)) } { break continue } }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/loop_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/loop_parseOnly.json
new file mode 100644
index 00000000..24dbbdc4
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/loop_parseOnly.json
@@ -0,0 +1,170 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:74:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:49:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:49:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "90:18:1",
+                        "nodeType": "YulBlock",
+                        "src": "90:18:1",
+                        "statements":
+                        [
+                          {
+                            "nativeSrc": "92:5:1",
+                            "nodeType": "YulBreak",
+                            "src": "92:5:1"
+                          },
+                          {
+                            "nativeSrc": "98:8:1",
+                            "nodeType": "YulContinue",
+                            "src": "98:8:1"
+                          }
+                        ]
+                      },
+                      "condition":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "70:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "70:1:1",
+                        "type": "",
+                        "value": "1"
+                      },
+                      "nativeSrc": "63:45:1",
+                      "nodeType": "YulForLoop",
+                      "post":
+                      {
+                        "nativeSrc": "72:17:1",
+                        "nodeType": "YulBlock",
+                        "src": "72:17:1",
+                        "statements":
+                        [
+                          {
+                            "expression":
+                            {
+                              "arguments":
+                              [
+                                {
+                                  "arguments":
+                                  [
+                                    {
+                                      "kind": "number",
+                                      "nativeSrc": "84:1:1",
+                                      "nodeType": "YulLiteral",
+                                      "src": "84:1:1",
+                                      "type": "",
+                                      "value": "0"
+                                    }
+                                  ],
+                                  "functionName":
+                                  {
+                                    "name": "sload",
+                                    "nativeSrc": "78:5:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "78:5:1"
+                                  },
+                                  "nativeSrc": "78:8:1",
+                                  "nodeType": "YulFunctionCall",
+                                  "src": "78:8:1"
+                                }
+                              ],
+                              "functionName":
+                              {
+                                "name": "pop",
+                                "nativeSrc": "74:3:1",
+                                "nodeType": "YulIdentifier",
+                                "src": "74:3:1"
+                              },
+                              "nativeSrc": "74:13:1",
+                              "nodeType": "YulFunctionCall",
+                              "src": "74:13:1"
+                            },
+                            "nativeSrc": "74:13:1",
+                            "nodeType": "YulExpressionStatement",
+                            "src": "74:13:1"
+                          }
+                        ]
+                      },
+                      "pre":
+                      {
+                        "nativeSrc": "67:2:1",
+                        "nodeType": "YulBlock",
+                        "src": "67:2:1",
+                        "statements": []
+                      },
+                      "src": "63:45:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:58:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:99:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:118:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:119:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.json b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.json
new file mode 100644
index 00000000..3c9fd53e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.json
@@ -0,0 +1,185 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      8
+    ]
+  },
+  "id": 9,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 8,
+      "linearizedBaseContracts":
+      [
+        8
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 6,
+            "nodeType": "Block",
+            "src": "57:95:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "72:76:1",
+                  "nodeType": "YulBlock",
+                  "src": "72:76:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "94:35:1",
+                        "nodeType": "YulBlock",
+                        "src": "94:35:1",
+                        "statements":
+                        [
+                          {
+                            "body":
+                            {
+                              "nativeSrc": "118:3:1",
+                              "nodeType": "YulBlock",
+                              "src": "118:3:1",
+                              "statements": []
+                            },
+                            "name": "f2",
+                            "nativeSrc": "104:17:1",
+                            "nodeType": "YulFunctionDefinition",
+                            "src": "104:17:1"
+                          }
+                        ]
+                      },
+                      "name": "f1",
+                      "nativeSrc": "80:49:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "80:49:1"
+                    },
+                    {
+                      "nativeSrc": "136:6:1",
+                      "nodeType": "YulAssignment",
+                      "src": "136:6:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "141:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "141:1:1",
+                        "type": "",
+                        "value": "2"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "136:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "136:1:1"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences":
+                [
+                  {
+                    "declaration": 3,
+                    "isOffset": false,
+                    "isSlot": false,
+                    "src": "136:1:1",
+                    "valueSize": 1
+                  }
+                ],
+                "id": 5,
+                "nodeType": "InlineAssembly",
+                "src": "63:85:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 7,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "24:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "25:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 3,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "54:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 7,
+                "src": "49:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 2,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "49:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "48:8:1"
+          },
+          "scope": 8,
+          "src": "15:137:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 9,
+      "src": "0:154:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:155:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.sol b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.sol
new file mode 100644
index 00000000..42479fa9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions.sol
@@ -0,0 +1,11 @@
+contract C {
+  function f() public pure returns (uint x) {
+    assembly {
+      function f1() {
+        function f2() { }
+      }
+      x := 2
+    }
+  }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/nested_functions_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions_parseOnly.json
new file mode 100644
index 00000000..b924b42c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/nested_functions_parseOnly.json
@@ -0,0 +1,151 @@
+{
+  "absolutePath": "a",
+  "id": 9,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 8,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 6,
+            "nodeType": "Block",
+            "src": "57:95:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "72:76:1",
+                  "nodeType": "YulBlock",
+                  "src": "72:76:1",
+                  "statements":
+                  [
+                    {
+                      "body":
+                      {
+                        "nativeSrc": "94:35:1",
+                        "nodeType": "YulBlock",
+                        "src": "94:35:1",
+                        "statements":
+                        [
+                          {
+                            "body":
+                            {
+                              "nativeSrc": "118:3:1",
+                              "nodeType": "YulBlock",
+                              "src": "118:3:1",
+                              "statements": []
+                            },
+                            "name": "f2",
+                            "nativeSrc": "104:17:1",
+                            "nodeType": "YulFunctionDefinition",
+                            "src": "104:17:1"
+                          }
+                        ]
+                      },
+                      "name": "f1",
+                      "nativeSrc": "80:49:1",
+                      "nodeType": "YulFunctionDefinition",
+                      "src": "80:49:1"
+                    },
+                    {
+                      "nativeSrc": "136:6:1",
+                      "nodeType": "YulAssignment",
+                      "src": "136:6:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "141:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "141:1:1",
+                        "type": "",
+                        "value": "2"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "136:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "136:1:1"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 5,
+                "nodeType": "InlineAssembly",
+                "src": "63:85:1"
+              }
+            ]
+          },
+          "id": 7,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "24:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "25:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 3,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "54:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "49:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 2,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "49:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "48:8:1"
+          },
+          "src": "15:137:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:154:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:155:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.json b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.json
new file mode 100644
index 00000000..799239b3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.json
@@ -0,0 +1,263 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      12
+    ]
+  },
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 12,
+      "linearizedBaseContracts":
+      [
+        12
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "canonicalName": "C.S",
+          "id": 3,
+          "members":
+          [
+            {
+              "constant": false,
+              "id": 2,
+              "mutability": "mutable",
+              "name": "x",
+              "nameLocation": "33:1:1",
+              "nodeType": "VariableDeclaration",
+              "scope": 3,
+              "src": "28:6:1",
+              "stateVariable": false,
+              "storageLocation": "default",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_uint256",
+                "typeString": "uint256"
+              },
+              "typeName":
+              {
+                "id": 1,
+                "name": "uint",
+                "nodeType": "ElementaryTypeName",
+                "src": "28:4:1",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                }
+              },
+              "visibility": "internal"
+            }
+          ],
+          "name": "S",
+          "nameLocation": "24:1:1",
+          "nodeType": "StructDefinition",
+          "scope": 12,
+          "src": "17:20:1",
+          "visibility": "public"
+        },
+        {
+          "constant": false,
+          "id": 6,
+          "mutability": "mutable",
+          "name": "s",
+          "nameLocation": "44:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 12,
+          "src": "42:3:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_struct$_S_$3_storage",
+            "typeString": "struct C.S"
+          },
+          "typeName":
+          {
+            "id": 5,
+            "nodeType": "UserDefinedTypeName",
+            "pathNode":
+            {
+              "id": 4,
+              "name": "S",
+              "nameLocations":
+              [
+                "42:1:1"
+              ],
+              "nodeType": "IdentifierPath",
+              "referencedDeclaration": 3,
+              "src": "42:1:1"
+            },
+            "referencedDeclaration": 3,
+            "src": "42:1:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_struct$_S_$3_storage_ptr",
+              "typeString": "struct C.S"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "76:70:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "95:45:1",
+                  "nodeType": "YulBlock",
+                  "src": "95:45:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "97:17:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "97:17:1",
+                      "value":
+                      {
+                        "name": "s.offset",
+                        "nativeSrc": "106:8:1",
+                        "nodeType": "YulIdentifier",
+                        "src": "106:8:1"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "101:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "101:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "115:23:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "115:23:1",
+                      "value":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "name": "s.slot",
+                            "nativeSrc": "128:6:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "128:6:1"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "136:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "136:1:1",
+                            "type": "",
+                            "value": "2"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "mul",
+                          "nativeSrc": "124:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "124:3:1"
+                        },
+                        "nativeSrc": "124:14:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "124:14:1"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "y",
+                          "nativeSrc": "119:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "119:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences":
+                [
+                  {
+                    "declaration": 6,
+                    "isOffset": true,
+                    "isSlot": false,
+                    "src": "106:8:1",
+                    "suffix": "offset",
+                    "valueSize": 1
+                  },
+                  {
+                    "declaration": 6,
+                    "isOffset": false,
+                    "isSlot": true,
+                    "src": "128:6:1",
+                    "suffix": "slot",
+                    "valueSize": 1
+                  }
+                ],
+                "id": 9,
+                "nodeType": "InlineAssembly",
+                "src": "86:54:1"
+              }
+            ]
+          },
+          "functionSelector": "ffae15ba",
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "e",
+          "nameLocation": "60:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "61:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "76:0:1"
+          },
+          "scope": 12,
+          "src": "51:95:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 13,
+      "src": "0:148:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:149:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.sol b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.sol
new file mode 100644
index 00000000..0cc2b07c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset.sol
@@ -0,0 +1,8 @@
+contract C {
+    struct S { uint x; }
+    S s;
+    function e() pure public {
+        assembly { let x := s.offset let y := mul(s.slot, 2) }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/slot_offset_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset_parseOnly.json
new file mode 100644
index 00000000..ef8dc8b0
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/slot_offset_parseOnly.json
@@ -0,0 +1,207 @@
+{
+  "absolutePath": "a",
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 12,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 3,
+          "members":
+          [
+            {
+              "constant": false,
+              "id": 2,
+              "mutability": "mutable",
+              "name": "x",
+              "nameLocation": "33:1:1",
+              "nodeType": "VariableDeclaration",
+              "src": "28:6:1",
+              "stateVariable": false,
+              "storageLocation": "default",
+              "typeDescriptions": {},
+              "typeName":
+              {
+                "id": 1,
+                "name": "uint",
+                "nodeType": "ElementaryTypeName",
+                "src": "28:4:1",
+                "typeDescriptions": {}
+              },
+              "visibility": "internal"
+            }
+          ],
+          "name": "S",
+          "nameLocation": "24:1:1",
+          "nodeType": "StructDefinition",
+          "src": "17:20:1",
+          "visibility": "public"
+        },
+        {
+          "constant": false,
+          "id": 6,
+          "mutability": "mutable",
+          "name": "s",
+          "nameLocation": "44:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "42:3:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 5,
+            "nodeType": "UserDefinedTypeName",
+            "pathNode":
+            {
+              "id": 4,
+              "name": "S",
+              "nameLocations":
+              [
+                "42:1:1"
+              ],
+              "nodeType": "IdentifierPath",
+              "src": "42:1:1"
+            },
+            "src": "42:1:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "76:70:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "95:45:1",
+                  "nodeType": "YulBlock",
+                  "src": "95:45:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "97:17:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "97:17:1",
+                      "value":
+                      {
+                        "name": "s.offset",
+                        "nativeSrc": "106:8:1",
+                        "nodeType": "YulIdentifier",
+                        "src": "106:8:1"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "101:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "101:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "115:23:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "115:23:1",
+                      "value":
+                      {
+                        "arguments":
+                        [
+                          {
+                            "name": "s.slot",
+                            "nativeSrc": "128:6:1",
+                            "nodeType": "YulIdentifier",
+                            "src": "128:6:1"
+                          },
+                          {
+                            "kind": "number",
+                            "nativeSrc": "136:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "136:1:1",
+                            "type": "",
+                            "value": "2"
+                          }
+                        ],
+                        "functionName":
+                        {
+                          "name": "mul",
+                          "nativeSrc": "124:3:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "124:3:1"
+                        },
+                        "nativeSrc": "124:14:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "124:14:1"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "y",
+                          "nativeSrc": "119:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "119:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 9,
+                "nodeType": "InlineAssembly",
+                "src": "86:54:1"
+              }
+            ]
+          },
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "e",
+          "nameLocation": "60:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "61:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "76:0:1"
+          },
+          "src": "51:95:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:148:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:149:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/stringlit.json b/compiler/test/libsolidity/ASTJSON/assembly/stringlit.json
new file mode 100644
index 00000000..ab27a3d1
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/stringlit.json
@@ -0,0 +1,118 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:43:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:18:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:18:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "58:14:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "58:14:1",
+                      "value":
+                      {
+                        "hexValue": "616263",
+                        "kind": "string",
+                        "nativeSrc": "67:5:1",
+                        "nodeType": "YulLiteral",
+                        "src": "67:5:1",
+                        "type": "",
+                        "value": "abc"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "62:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "62:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:27:1"
+              }
+            ]
+          },
+          "functionSelector": "5a2ee019",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "m",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "scope": 6,
+          "src": "17:63:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:82:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:83:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/stringlit.sol b/compiler/test/libsolidity/ASTJSON/assembly/stringlit.sol
new file mode 100644
index 00000000..6f5278ac
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/stringlit.sol
@@ -0,0 +1,6 @@
+contract C {
+    function m() public {
+        assembly { let x := "abc" }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/stringlit_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/stringlit_parseOnly.json
new file mode 100644
index 00000000..3cb2a907
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/stringlit_parseOnly.json
@@ -0,0 +1,102 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "37:43:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "56:18:1",
+                  "nodeType": "YulBlock",
+                  "src": "56:18:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "58:14:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "58:14:1",
+                      "value":
+                      {
+                        "hexValue": "616263",
+                        "kind": "string",
+                        "nativeSrc": "67:5:1",
+                        "nodeType": "YulLiteral",
+                        "src": "67:5:1",
+                        "type": "",
+                        "value": "abc"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "62:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "62:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "47:27:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "m",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "37:0:1"
+          },
+          "src": "17:63:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:82:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:83:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch.json b/compiler/test/libsolidity/ASTJSON/assembly/switch.json
new file mode 100644
index 00000000..99c69e04
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch.json
@@ -0,0 +1,223 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:154:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:129:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:129:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "75:10:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "75:10:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "84:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "84:1:1",
+                        "type": "",
+                        "value": "0"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "v",
+                          "nativeSrc": "79:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "79:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "cases":
+                      [
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "139:10:1",
+                            "nodeType": "YulBlock",
+                            "src": "139:10:1",
+                            "statements":
+                            [
+                              {
+                                "nativeSrc": "141:6:1",
+                                "nodeType": "YulAssignment",
+                                "src": "141:6:1",
+                                "value":
+                                {
+                                  "kind": "number",
+                                  "nativeSrc": "146:1:1",
+                                  "nodeType": "YulLiteral",
+                                  "src": "146:1:1",
+                                  "type": "",
+                                  "value": "1"
+                                },
+                                "variableNames":
+                                [
+                                  {
+                                    "name": "v",
+                                    "nativeSrc": "141:1:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "141:1:1"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          "nativeSrc": "132:17:1",
+                          "nodeType": "YulCase",
+                          "src": "132:17:1",
+                          "value":
+                          {
+                            "kind": "number",
+                            "nativeSrc": "137:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "137:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        },
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "170:10:1",
+                            "nodeType": "YulBlock",
+                            "src": "170:10:1",
+                            "statements":
+                            [
+                              {
+                                "nativeSrc": "172:6:1",
+                                "nodeType": "YulAssignment",
+                                "src": "172:6:1",
+                                "value":
+                                {
+                                  "kind": "number",
+                                  "nativeSrc": "177:1:1",
+                                  "nodeType": "YulLiteral",
+                                  "src": "177:1:1",
+                                  "type": "",
+                                  "value": "2"
+                                },
+                                "variableNames":
+                                [
+                                  {
+                                    "name": "v",
+                                    "nativeSrc": "172:1:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "172:1:1"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          "nativeSrc": "162:18:1",
+                          "nodeType": "YulCase",
+                          "src": "162:18:1",
+                          "value": "default"
+                        }
+                      ],
+                      "expression":
+                      {
+                        "arguments": [],
+                        "functionName":
+                        {
+                          "name": "calldatasize",
+                          "nativeSrc": "105:12:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "105:12:1"
+                        },
+                        "nativeSrc": "105:14:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "105:14:1"
+                      },
+                      "nativeSrc": "98:82:1",
+                      "nodeType": "YulSwitch",
+                      "src": "98:82:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:138:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 6,
+          "src": "17:179:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:198:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:199:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch.sol b/compiler/test/libsolidity/ASTJSON/assembly/switch.sol
new file mode 100644
index 00000000..a7a23d26
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() pure public {
+        assembly {
+            let v := 0
+            switch calldatasize()
+            case 0 { v := 1 }
+            default { v := 2 }
+        }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch_default.json b/compiler/test/libsolidity/ASTJSON/assembly/switch_default.json
new file mode 100644
index 00000000..07f804f3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch_default.json
@@ -0,0 +1,144 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:58:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:33:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:33:1",
+                  "statements":
+                  [
+                    {
+                      "cases":
+                      [
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "79:2:1",
+                            "nodeType": "YulBlock",
+                            "src": "79:2:1",
+                            "statements": []
+                          },
+                          "nativeSrc": "72:9:1",
+                          "nodeType": "YulCase",
+                          "src": "72:9:1",
+                          "value":
+                          {
+                            "kind": "number",
+                            "nativeSrc": "77:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "77:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        },
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "90:2:1",
+                            "nodeType": "YulBlock",
+                            "src": "90:2:1",
+                            "statements": []
+                          },
+                          "nativeSrc": "82:10:1",
+                          "nodeType": "YulCase",
+                          "src": "82:10:1",
+                          "value": "default"
+                        }
+                      ],
+                      "expression":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "70:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "70:1:1",
+                        "type": "",
+                        "value": "0"
+                      },
+                      "nativeSrc": "63:29:1",
+                      "nodeType": "YulSwitch",
+                      "src": "63:29:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:42:1"
+              }
+            ]
+          },
+          "functionSelector": "e2179b8e",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 6,
+          "src": "17:83:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:102:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:103:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch_default.sol b/compiler/test/libsolidity/ASTJSON/assembly/switch_default.sol
new file mode 100644
index 00000000..0760bb7d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch_default.sol
@@ -0,0 +1,6 @@
+contract C {
+    function g() view public {
+        assembly { switch 0 case 0 {} default {} }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch_default_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/switch_default_parseOnly.json
new file mode 100644
index 00000000..2ec30277
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch_default_parseOnly.json
@@ -0,0 +1,128 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:58:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:33:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:33:1",
+                  "statements":
+                  [
+                    {
+                      "cases":
+                      [
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "79:2:1",
+                            "nodeType": "YulBlock",
+                            "src": "79:2:1",
+                            "statements": []
+                          },
+                          "nativeSrc": "72:9:1",
+                          "nodeType": "YulCase",
+                          "src": "72:9:1",
+                          "value":
+                          {
+                            "kind": "number",
+                            "nativeSrc": "77:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "77:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        },
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "90:2:1",
+                            "nodeType": "YulBlock",
+                            "src": "90:2:1",
+                            "statements": []
+                          },
+                          "nativeSrc": "82:10:1",
+                          "nodeType": "YulCase",
+                          "src": "82:10:1",
+                          "value": "default"
+                        }
+                      ],
+                      "expression":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "70:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "70:1:1",
+                        "type": "",
+                        "value": "0"
+                      },
+                      "nativeSrc": "63:29:1",
+                      "nodeType": "YulSwitch",
+                      "src": "63:29:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:42:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:83:1",
+          "stateMutability": "view",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:102:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:103:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/switch_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/switch_parseOnly.json
new file mode 100644
index 00000000..2412ea48
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/switch_parseOnly.json
@@ -0,0 +1,207 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "42:154:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "61:129:1",
+                  "nodeType": "YulBlock",
+                  "src": "61:129:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "75:10:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "75:10:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "84:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "84:1:1",
+                        "type": "",
+                        "value": "0"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "v",
+                          "nativeSrc": "79:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "79:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "cases":
+                      [
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "139:10:1",
+                            "nodeType": "YulBlock",
+                            "src": "139:10:1",
+                            "statements":
+                            [
+                              {
+                                "nativeSrc": "141:6:1",
+                                "nodeType": "YulAssignment",
+                                "src": "141:6:1",
+                                "value":
+                                {
+                                  "kind": "number",
+                                  "nativeSrc": "146:1:1",
+                                  "nodeType": "YulLiteral",
+                                  "src": "146:1:1",
+                                  "type": "",
+                                  "value": "1"
+                                },
+                                "variableNames":
+                                [
+                                  {
+                                    "name": "v",
+                                    "nativeSrc": "141:1:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "141:1:1"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          "nativeSrc": "132:17:1",
+                          "nodeType": "YulCase",
+                          "src": "132:17:1",
+                          "value":
+                          {
+                            "kind": "number",
+                            "nativeSrc": "137:1:1",
+                            "nodeType": "YulLiteral",
+                            "src": "137:1:1",
+                            "type": "",
+                            "value": "0"
+                          }
+                        },
+                        {
+                          "body":
+                          {
+                            "nativeSrc": "170:10:1",
+                            "nodeType": "YulBlock",
+                            "src": "170:10:1",
+                            "statements":
+                            [
+                              {
+                                "nativeSrc": "172:6:1",
+                                "nodeType": "YulAssignment",
+                                "src": "172:6:1",
+                                "value":
+                                {
+                                  "kind": "number",
+                                  "nativeSrc": "177:1:1",
+                                  "nodeType": "YulLiteral",
+                                  "src": "177:1:1",
+                                  "type": "",
+                                  "value": "2"
+                                },
+                                "variableNames":
+                                [
+                                  {
+                                    "name": "v",
+                                    "nativeSrc": "172:1:1",
+                                    "nodeType": "YulIdentifier",
+                                    "src": "172:1:1"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          "nativeSrc": "162:18:1",
+                          "nodeType": "YulCase",
+                          "src": "162:18:1",
+                          "value": "default"
+                        }
+                      ],
+                      "expression":
+                      {
+                        "arguments": [],
+                        "functionName":
+                        {
+                          "name": "calldatasize",
+                          "nativeSrc": "105:12:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "105:12:1"
+                        },
+                        "nativeSrc": "105:14:1",
+                        "nodeType": "YulFunctionCall",
+                        "src": "105:14:1"
+                      },
+                      "nativeSrc": "98:82:1",
+                      "nodeType": "YulSwitch",
+                      "src": "98:82:1"
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "52:138:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:179:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:198:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:199:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/var_access.json b/compiler/test/libsolidity/ASTJSON/assembly/var_access.json
new file mode 100644
index 00000000..ae784581
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/var_access.json
@@ -0,0 +1,167 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      9
+    ]
+  },
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 9,
+      "linearizedBaseContracts":
+      [
+        9
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "42:51:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "57:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 7,
+                    "src": "52:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "52:4:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 5,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "52:6:1"
+              },
+              {
+                "AST":
+                {
+                  "nativeSrc": "77:10:1",
+                  "nodeType": "YulBlock",
+                  "src": "77:10:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "79:6:1",
+                      "nodeType": "YulAssignment",
+                      "src": "79:6:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "84:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "84:1:1",
+                        "type": "",
+                        "value": "7"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "79:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "79:1:1"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences":
+                [
+                  {
+                    "declaration": 4,
+                    "isOffset": false,
+                    "isSlot": false,
+                    "src": "79:1:1",
+                    "valueSize": 1
+                  }
+                ],
+                "id": 6,
+                "nodeType": "InlineAssembly",
+                "src": "68:19:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 9,
+          "src": "17:76:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 10,
+      "src": "0:95:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:96:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/var_access.sol b/compiler/test/libsolidity/ASTJSON/assembly/var_access.sol
new file mode 100644
index 00000000..e4b7423f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/var_access.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() pure public {
+        uint x;
+        assembly { x := 7 }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/assembly/var_access_parseOnly.json b/compiler/test/libsolidity/ASTJSON/assembly/var_access_parseOnly.json
new file mode 100644
index 00000000..ca3fcf92
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/assembly/var_access_parseOnly.json
@@ -0,0 +1,133 @@
+{
+  "absolutePath": "a",
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 9,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "42:51:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "57:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "52:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "52:4:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 5,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "52:6:1"
+              },
+              {
+                "AST":
+                {
+                  "nativeSrc": "77:10:1",
+                  "nodeType": "YulBlock",
+                  "src": "77:10:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "79:6:1",
+                      "nodeType": "YulAssignment",
+                      "src": "79:6:1",
+                      "value":
+                      {
+                        "kind": "number",
+                        "nativeSrc": "84:1:1",
+                        "nodeType": "YulLiteral",
+                        "src": "84:1:1",
+                        "type": "",
+                        "value": "7"
+                      },
+                      "variableNames":
+                      [
+                        {
+                          "name": "x",
+                          "nativeSrc": "79:1:1",
+                          "nodeType": "YulIdentifier",
+                          "src": "79:1:1"
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 6,
+                "nodeType": "InlineAssembly",
+                "src": "68:19:1"
+              }
+            ]
+          },
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:76:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:95:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:96:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.json b/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.json
new file mode 100644
index 00000000..07886a16
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.json
@@ -0,0 +1,1027 @@
+[
+{
+  "absolutePath": "L",
+  "exportedSymbols":
+  {
+    "L":
+    [
+      78
+    ],
+    "free1":
+    [
+      65
+    ],
+    "free2":
+    [
+      69
+    ]
+  },
+  "id": 79,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "body":
+      {
+        "id": 64,
+        "nodeType": "Block",
+        "src": "17:2:1",
+        "statements": []
+      },
+      "id": 65,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "free1",
+      "nameLocation": "9:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 62,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "14:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 63,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "17:0:1"
+      },
+      "scope": 79,
+      "src": "0:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "body":
+      {
+        "id": 68,
+        "nodeType": "Block",
+        "src": "37:2:1",
+        "statements": []
+      },
+      "id": 69,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "free2",
+      "nameLocation": "29:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 66,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "34:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 67,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "37:0:1"
+      },
+      "scope": 79,
+      "src": "20:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "L",
+      "contractDependencies": [],
+      "contractKind": "library",
+      "fullyImplemented": true,
+      "id": 78,
+      "linearizedBaseContracts":
+      [
+        78
+      ],
+      "name": "L",
+      "nameLocation": "48:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 72,
+            "nodeType": "Block",
+            "src": "78:2:1",
+            "statements": []
+          },
+          "id": 73,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "65:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 70,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "66:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 71,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "78:0:1"
+          },
+          "scope": 78,
+          "src": "56:24:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 76,
+            "nodeType": "Block",
+            "src": "107:2:1",
+            "statements": []
+          },
+          "id": 77,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "h",
+          "nameLocation": "94:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 74,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "95:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 75,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "107:0:1"
+          },
+          "scope": 78,
+          "src": "85:24:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "scope": 79,
+      "src": "40:71:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:112:1"
+},
+{
+  "absolutePath": "A",
+  "exportedSymbols":
+  {
+    "A":
+    [
+      22
+    ],
+    "B":
+    [
+      37
+    ],
+    "L":
+    [
+      78
+    ],
+    "free1":
+    [
+      65
+    ],
+    "free2":
+    [
+      69
+    ]
+  },
+  "id": 38,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "absolutePath": "L",
+      "file": "L",
+      "id": 1,
+      "nameLocation": "-1:-1:-1",
+      "nodeType": "ImportDirective",
+      "scope": 38,
+      "sourceUnit": 79,
+      "src": "0:11:2",
+      "symbolAliases": [],
+      "unitAlias": ""
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "A",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 22,
+      "internalFunctionIDs":
+      {
+        "69": 1,
+        "73": 2,
+        "77": 3
+      },
+      "linearizedBaseContracts":
+      [
+        22
+      ],
+      "name": "A",
+      "nameLocation": "21:1:2",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 20,
+            "nodeType": "Block",
+            "src": "49:60:2",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 4,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 78,
+                          "src": "60:1:2",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$78_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 6,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "62:1:2",
+                        "memberName": "g",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 73,
+                        "src": "60:3:2",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 7,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "59:5:2",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 8,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "59:7:2",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 9,
+                "nodeType": "ExpressionStatement",
+                "src": "59:7:2"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 10,
+                        "name": "free2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 69,
+                        "src": "77:5:2",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 11,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "76:7:2",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 12,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "76:9:2",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 13,
+                "nodeType": "ExpressionStatement",
+                "src": "76:9:2"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 14,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 78,
+                          "src": "96:1:2",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$78_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 16,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "98:1:2",
+                        "memberName": "h",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 77,
+                        "src": "96:3:2",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 17,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "95:5:2",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 18,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "95:7:2",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 19,
+                "nodeType": "ExpressionStatement",
+                "src": "95:7:2"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 21,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "38:1:2",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "39:2:2"
+          },
+          "returnParameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:0:2"
+          },
+          "scope": 22,
+          "src": "29:80:2",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 38,
+      "src": "12:99:2",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 37,
+      "internalFunctionIDs":
+      {
+        "69": 1,
+        "77": 2
+      },
+      "linearizedBaseContracts":
+      [
+        37
+      ],
+      "name": "B",
+      "nameLocation": "121:1:2",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 35,
+            "nodeType": "Block",
+            "src": "149:43:2",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 25,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 78,
+                          "src": "160:1:2",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$78_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 27,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "162:1:2",
+                        "memberName": "h",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 77,
+                        "src": "160:3:2",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 28,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "159:5:2",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 29,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "159:7:2",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 30,
+                "nodeType": "ExpressionStatement",
+                "src": "159:7:2"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 31,
+                        "name": "free2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 69,
+                        "src": "177:5:2",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 32,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "176:7:2",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 33,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "176:9:2",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 34,
+                "nodeType": "ExpressionStatement",
+                "src": "176:9:2"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 36,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "138:1:2",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 23,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "139:2:2"
+          },
+          "returnParameters":
+          {
+            "id": 24,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "149:0:2"
+          },
+          "scope": 37,
+          "src": "129:63:2",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 38,
+      "src": "112:82:2",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:195:2"
+},
+{
+  "absolutePath": "C",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      60
+    ],
+    "L":
+    [
+      78
+    ],
+    "free1":
+    [
+      65
+    ],
+    "free2":
+    [
+      69
+    ]
+  },
+  "id": 61,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "absolutePath": "L",
+      "file": "L",
+      "id": 39,
+      "nameLocation": "-1:-1:-1",
+      "nodeType": "ImportDirective",
+      "scope": 61,
+      "sourceUnit": 79,
+      "src": "0:11:3",
+      "symbolAliases": [],
+      "unitAlias": ""
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 60,
+      "internalFunctionIDs":
+      {
+        "69": 1,
+        "73": 2,
+        "77": 3
+      },
+      "linearizedBaseContracts":
+      [
+        60
+      ],
+      "name": "C",
+      "nameLocation": "21:1:3",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 58,
+            "nodeType": "Block",
+            "src": "49:60:3",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 42,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 78,
+                          "src": "60:1:3",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$78_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 44,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "62:1:3",
+                        "memberName": "g",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 73,
+                        "src": "60:3:3",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 45,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "59:5:3",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 46,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "59:7:3",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 47,
+                "nodeType": "ExpressionStatement",
+                "src": "59:7:3"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 48,
+                        "name": "free2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 69,
+                        "src": "77:5:3",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 49,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "76:7:3",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 50,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "76:9:3",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 51,
+                "nodeType": "ExpressionStatement",
+                "src": "76:9:3"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 52,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 78,
+                          "src": "96:1:3",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$78_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 54,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "98:1:3",
+                        "memberName": "h",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 77,
+                        "src": "96:3:3",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 55,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "95:5:3",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 56,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "95:7:3",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 57,
+                "nodeType": "ExpressionStatement",
+                "src": "95:7:3"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 59,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "38:1:3",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 40,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "39:2:3"
+          },
+          "returnParameters":
+          {
+            "id": 41,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:0:3"
+          },
+          "scope": 60,
+          "src": "29:80:3",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 61,
+      "src": "12:99:3",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:112:3"
+}
+]
diff --git a/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.sol b/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.sol
new file mode 100644
index 00000000..6e0b28c8
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/ast_internal_function_different_ids_export.sol
@@ -0,0 +1,38 @@
+==== Source: L ====
+
+function free1() {}
+function free2() {}
+library L {
+    function g() internal {}
+    function h() internal {}
+}
+
+==== Source: A ====
+
+import "L";
+contract A {
+    function f() public {
+        (L.g)();
+        (free2)();
+        (L.h)();
+    }
+}
+contract B {
+    function f() public {
+        (L.h)();
+        (free2)();
+    }
+}
+
+==== Source: C ====
+
+import "L";
+contract C {
+    function f() public {
+        (L.g)();
+        (free2)();
+        (L.h)();
+    }
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.json b/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.json
new file mode 100644
index 00000000..d452f2d9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.json
@@ -0,0 +1,1562 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      128
+    ],
+    "D":
+    [
+      141
+    ],
+    "L":
+    [
+      53
+    ],
+    "free1":
+    [
+      4
+    ],
+    "free2":
+    [
+      8
+    ],
+    "free3":
+    [
+      12
+    ]
+  },
+  "id": 142,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "body":
+      {
+        "id": 3,
+        "nodeType": "Block",
+        "src": "17:2:1",
+        "statements": []
+      },
+      "id": 4,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "free1",
+      "nameLocation": "9:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 1,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "14:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 2,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "17:0:1"
+      },
+      "scope": 142,
+      "src": "0:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "body":
+      {
+        "id": 7,
+        "nodeType": "Block",
+        "src": "37:2:1",
+        "statements": []
+      },
+      "id": 8,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "free2",
+      "nameLocation": "29:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 5,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "34:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 6,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "37:0:1"
+      },
+      "scope": 142,
+      "src": "20:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "body":
+      {
+        "id": 11,
+        "nodeType": "Block",
+        "src": "57:2:1",
+        "statements": []
+      },
+      "id": 12,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "free3",
+      "nameLocation": "49:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 9,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "54:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 10,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "57:0:1"
+      },
+      "scope": 142,
+      "src": "40:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "L",
+      "contractDependencies": [],
+      "contractKind": "library",
+      "fullyImplemented": true,
+      "id": 53,
+      "internalFunctionIDs":
+      {
+        "20": 3,
+        "24": 4,
+        "4": 1,
+        "8": 2
+      },
+      "linearizedBaseContracts":
+      [
+        53
+      ],
+      "name": "L",
+      "nameLocation": "68:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 15,
+            "nodeType": "Block",
+            "src": "100:2:1",
+            "statements": []
+          },
+          "functionSelector": "cf9f23b5",
+          "id": 16,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "ext",
+          "nameLocation": "85:3:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "88:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "100:0:1"
+          },
+          "scope": 53,
+          "src": "76:26:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 19,
+            "nodeType": "Block",
+            "src": "132:2:1",
+            "statements": []
+          },
+          "id": 20,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr1",
+          "nameLocation": "116:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 17,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "120:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 18,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "132:0:1"
+          },
+          "scope": 53,
+          "src": "107:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 23,
+            "nodeType": "Block",
+            "src": "164:2:1",
+            "statements": []
+          },
+          "id": 24,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr2",
+          "nameLocation": "148:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 21,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "152:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 22,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "164:0:1"
+          },
+          "scope": 53,
+          "src": "139:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 27,
+            "nodeType": "Block",
+            "src": "196:2:1",
+            "statements": []
+          },
+          "id": 28,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr3",
+          "nameLocation": "180:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 25,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "184:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 26,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "196:0:1"
+          },
+          "scope": 53,
+          "src": "171:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 39,
+            "nodeType": "Block",
+            "src": "228:51:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "id": 31,
+                  "name": "free1",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 4,
+                  "src": "238:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 32,
+                "nodeType": "ExpressionStatement",
+                "src": "238:5:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 33,
+                  "name": "inr1",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 20,
+                  "src": "253:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 34,
+                "nodeType": "ExpressionStatement",
+                "src": "253:4:1"
+              },
+              {
+                "expression":
+                {
+                  "expression":
+                  {
+                    "id": 35,
+                    "name": "L",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 53,
+                    "src": "267:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_type$_t_contract$_L_$53_$",
+                      "typeString": "type(library L)"
+                    }
+                  },
+                  "id": 37,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "memberLocation": "269:3:1",
+                  "memberName": "ext",
+                  "nodeType": "MemberAccess",
+                  "referencedDeclaration": 16,
+                  "src": "267:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_delegatecall_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 38,
+                "nodeType": "ExpressionStatement",
+                "src": "267:5:1"
+              }
+            ]
+          },
+          "functionSelector": "71907f17",
+          "id": 40,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "access",
+          "nameLocation": "212:6:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 29,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "218:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 30,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "228:0:1"
+          },
+          "scope": 53,
+          "src": "203:76:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 51,
+            "nodeType": "Block",
+            "src": "313:44:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 43,
+                        "name": "free2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 8,
+                        "src": "324:5:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 44,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "323:7:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 45,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "323:9:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 46,
+                "nodeType": "ExpressionStatement",
+                "src": "323:9:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 47,
+                        "name": "inr2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 24,
+                        "src": "343:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 48,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "342:6:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 49,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "342:8:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 50,
+                "nodeType": "ExpressionStatement",
+                "src": "342:8:1"
+              }
+            ]
+          },
+          "functionSelector": "4228dae0",
+          "id": 52,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "expression",
+          "nameLocation": "293:10:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 41,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "303:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 42,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "313:0:1"
+          },
+          "scope": 53,
+          "src": "284:73:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 142,
+      "src": "60:299:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 128,
+      "internalFunctionIDs":
+      {
+        "20": 3,
+        "24": 4,
+        "4": 1,
+        "69": 5,
+        "73": 6,
+        "8": 2
+      },
+      "linearizedBaseContracts":
+      [
+        128
+      ],
+      "name": "C",
+      "nameLocation": "369:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 56,
+            "nodeType": "Block",
+            "src": "402:2:1",
+            "statements": []
+          },
+          "functionSelector": "05b07a6b",
+          "id": 57,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "ext1",
+          "nameLocation": "386:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 54,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "390:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 55,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "402:0:1"
+          },
+          "scope": 128,
+          "src": "377:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 60,
+            "nodeType": "Block",
+            "src": "434:2:1",
+            "statements": []
+          },
+          "functionSelector": "5aa6e183",
+          "id": 61,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "ext2",
+          "nameLocation": "418:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 58,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "422:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 59,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "434:0:1"
+          },
+          "scope": 128,
+          "src": "409:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 64,
+            "nodeType": "Block",
+            "src": "466:2:1",
+            "statements": []
+          },
+          "functionSelector": "0a77b8ef",
+          "id": 65,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "ext3",
+          "nameLocation": "450:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 62,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "454:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 63,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "466:0:1"
+          },
+          "scope": 128,
+          "src": "441:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 68,
+            "nodeType": "Block",
+            "src": "498:2:1",
+            "statements": []
+          },
+          "id": 69,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr1",
+          "nameLocation": "482:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 66,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "486:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 67,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "498:0:1"
+          },
+          "scope": 128,
+          "src": "473:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 72,
+            "nodeType": "Block",
+            "src": "530:2:1",
+            "statements": []
+          },
+          "id": 73,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr2",
+          "nameLocation": "514:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 70,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "518:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 71,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "530:0:1"
+          },
+          "scope": 128,
+          "src": "505:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 76,
+            "nodeType": "Block",
+            "src": "562:2:1",
+            "statements": []
+          },
+          "id": 77,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "inr3",
+          "nameLocation": "546:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 74,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "550:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 75,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "562:0:1"
+          },
+          "scope": 128,
+          "src": "537:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 96,
+            "nodeType": "Block",
+            "src": "594:86:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "expression":
+                  {
+                    "id": 80,
+                    "name": "this",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": -28,
+                    "src": "604:4:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_contract$_C_$128",
+                      "typeString": "contract C"
+                    }
+                  },
+                  "id": 82,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "memberLocation": "609:4:1",
+                  "memberName": "ext1",
+                  "nodeType": "MemberAccess",
+                  "referencedDeclaration": 57,
+                  "src": "604:9:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                    "typeString": "function () external"
+                  }
+                },
+                "id": 83,
+                "nodeType": "ExpressionStatement",
+                "src": "604:9:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 84,
+                  "name": "inr1",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 69,
+                  "src": "623:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 85,
+                "nodeType": "ExpressionStatement",
+                "src": "623:4:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 86,
+                  "name": "free1",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 4,
+                  "src": "637:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 87,
+                "nodeType": "ExpressionStatement",
+                "src": "637:5:1"
+              },
+              {
+                "expression":
+                {
+                  "expression":
+                  {
+                    "id": 88,
+                    "name": "L",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 53,
+                    "src": "652:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_type$_t_contract$_L_$53_$",
+                      "typeString": "type(library L)"
+                    }
+                  },
+                  "id": 90,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "memberLocation": "654:4:1",
+                  "memberName": "inr1",
+                  "nodeType": "MemberAccess",
+                  "referencedDeclaration": 20,
+                  "src": "652:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 91,
+                "nodeType": "ExpressionStatement",
+                "src": "652:6:1"
+              },
+              {
+                "expression":
+                {
+                  "expression":
+                  {
+                    "id": 92,
+                    "name": "L",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 53,
+                    "src": "668:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_type$_t_contract$_L_$53_$",
+                      "typeString": "type(library L)"
+                    }
+                  },
+                  "id": 94,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "memberLocation": "670:3:1",
+                  "memberName": "ext",
+                  "nodeType": "MemberAccess",
+                  "referencedDeclaration": 16,
+                  "src": "668:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_delegatecall_nonpayable$__$returns$__$",
+                    "typeString": "function ()"
+                  }
+                },
+                "id": 95,
+                "nodeType": "ExpressionStatement",
+                "src": "668:5:1"
+              }
+            ]
+          },
+          "functionSelector": "71907f17",
+          "id": 97,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "access",
+          "nameLocation": "578:6:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 78,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "584:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 79,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "594:0:1"
+          },
+          "scope": 128,
+          "src": "569:111:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 126,
+            "nodeType": "Block",
+            "src": "714:106:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 100,
+                          "name": "this",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": -28,
+                          "src": "725:4:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_contract$_C_$128",
+                            "typeString": "contract C"
+                          }
+                        },
+                        "id": 102,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "730:4:1",
+                        "memberName": "ext2",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 61,
+                        "src": "725:9:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                          "typeString": "function () external"
+                        }
+                      }
+                    ],
+                    "id": 103,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "724:11:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                      "typeString": "function () external"
+                    }
+                  },
+                  "id": 104,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "724:13:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 105,
+                "nodeType": "ExpressionStatement",
+                "src": "724:13:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 106,
+                        "name": "inr2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 73,
+                        "src": "748:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 107,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "747:6:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 108,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "747:8:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 109,
+                "nodeType": "ExpressionStatement",
+                "src": "747:8:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "id": 110,
+                        "name": "free2",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": 8,
+                        "src": "766:5:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 111,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "765:7:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 112,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "765:9:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 113,
+                "nodeType": "ExpressionStatement",
+                "src": "765:9:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 114,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 53,
+                          "src": "785:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$53_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 116,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "787:4:1",
+                        "memberName": "inr2",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 24,
+                        "src": "785:6:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 117,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "784:8:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 118,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "784:10:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 119,
+                "nodeType": "ExpressionStatement",
+                "src": "784:10:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "components":
+                    [
+                      {
+                        "expression":
+                        {
+                          "id": 120,
+                          "name": "L",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 53,
+                          "src": "805:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_type$_t_contract$_L_$53_$",
+                            "typeString": "type(library L)"
+                          }
+                        },
+                        "id": 122,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "memberLocation": "807:3:1",
+                        "memberName": "ext",
+                        "nodeType": "MemberAccess",
+                        "referencedDeclaration": 16,
+                        "src": "805:5:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_function_delegatecall_nonpayable$__$returns$__$",
+                          "typeString": "function ()"
+                        }
+                      }
+                    ],
+                    "id": 123,
+                    "isConstant": false,
+                    "isInlineArray": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "TupleExpression",
+                    "src": "804:7:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_delegatecall_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 124,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "804:9:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 125,
+                "nodeType": "ExpressionStatement",
+                "src": "804:9:1"
+              }
+            ]
+          },
+          "functionSelector": "4228dae0",
+          "id": 127,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "expression",
+          "nameLocation": "694:10:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 98,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "704:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 99,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "714:0:1"
+          },
+          "scope": 128,
+          "src": "685:135:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 142,
+      "src": "360:462:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 129,
+            "name": "C",
+            "nameLocations":
+            [
+              "837:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 128,
+            "src": "837:1:1"
+          },
+          "id": 130,
+          "nodeType": "InheritanceSpecifier",
+          "src": "837:1:1"
+        }
+      ],
+      "canonicalName": "D",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 141,
+      "internalFunctionIDs":
+      {
+        "20": 3,
+        "24": 4,
+        "4": 1,
+        "69": 5,
+        "73": 6,
+        "8": 2
+      },
+      "linearizedBaseContracts":
+      [
+        141,
+        128
+      ],
+      "name": "D",
+      "nameLocation": "832:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 139,
+            "nodeType": "Block",
+            "src": "859:47:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 133,
+                    "name": "access",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 97,
+                    "src": "869:6:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 134,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "869:8:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 135,
+                "nodeType": "ExpressionStatement",
+                "src": "869:8:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 136,
+                    "name": "expression",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 127,
+                    "src": "887:10:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 137,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "887:12:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 138,
+                "nodeType": "ExpressionStatement",
+                "src": "887:12:1"
+              }
+            ]
+          },
+          "id": 140,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 131,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "856:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 132,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "859:0:1"
+          },
+          "scope": 141,
+          "src": "845:61:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 142,
+      "src": "823:85:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:909:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.sol b/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.sol
new file mode 100644
index 00000000..100897b7
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/ast_internal_function_id_export.sol
@@ -0,0 +1,48 @@
+function free1() {}
+function free2() {}
+function free3() {}
+library L {
+    function ext() external {}
+    function inr1() internal {}
+    function inr2() internal {}
+    function inr3() internal {}
+    function access() public {
+        free1;
+        inr1;
+        L.ext;
+    }
+    function expression() public {
+        (free2)();
+        (inr2)();
+    }
+}
+contract C {
+    function ext1() external {}
+    function ext2() external {}
+    function ext3() external {}
+    function inr1() internal {}
+    function inr2() internal {}
+    function inr3() internal {}
+    function access() public {
+        this.ext1;
+        inr1;
+        free1;
+        L.inr1;
+        L.ext;
+    }
+    function expression() public {
+        (this.ext2)();
+        (inr2)();
+        (free2)();
+        (L.inr2)();
+        (L.ext)();
+    }
+}
+contract D is C {
+    constructor() {
+        access();
+        expression();
+    }
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/base_constructor_call.json b/compiler/test/libsolidity/ASTJSON/base_constructor_call.json
new file mode 100644
index 00000000..2c3c68c4
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/base_constructor_call.json
@@ -0,0 +1,228 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "A":
+    [
+      7
+    ],
+    "C":
+    [
+      17
+    ]
+  },
+  "id": 18,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "A",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 7,
+      "linearizedBaseContracts":
+      [
+        7
+      ],
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "31:2:1",
+            "statements": []
+          },
+          "id": 6,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "scope": 6,
+                "src": "25:4:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "25:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "24:6:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "31:0:1"
+          },
+          "scope": 7,
+          "src": "13:20:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 18,
+      "src": "0:35:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 8,
+            "name": "A",
+            "nameLocations":
+            [
+              "50:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 7,
+            "src": "50:1:1"
+          },
+          "id": 9,
+          "nodeType": "InheritanceSpecifier",
+          "src": "50:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 17,
+      "linearizedBaseContracts":
+      [
+        17,
+        7
+      ],
+      "name": "C",
+      "nameLocation": "45:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 15,
+            "nodeType": "Block",
+            "src": "73:2:1",
+            "statements": []
+          },
+          "id": 16,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "32",
+                  "id": 12,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "number",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "70:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_2_by_1",
+                    "typeString": "int_const 2"
+                  },
+                  "value": "2"
+                }
+              ],
+              "id": 13,
+              "kind": "baseConstructorSpecifier",
+              "modifierName":
+              {
+                "id": 11,
+                "name": "A",
+                "nameLocations":
+                [
+                  "68:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 7,
+                "src": "68:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "68:4:1"
+            }
+          ],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "65:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "73:0:1"
+          },
+          "scope": 17,
+          "src": "54:21:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 18,
+      "src": "36:41:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:78:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/base_constructor_call_parseOnly.json b/compiler/test/libsolidity/ASTJSON/base_constructor_call_parseOnly.json
new file mode 100644
index 00000000..730a0517
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/base_constructor_call_parseOnly.json
@@ -0,0 +1,178 @@
+{
+  "absolutePath": "a",
+  "id": 18,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 7,
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "31:2:1",
+            "statements": []
+          },
+          "id": 6,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "src": "25:4:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "25:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "24:6:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "31:0:1"
+          },
+          "src": "13:20:1",
+          "stateMutability": "nonpayable",
+          "virtual": false
+        }
+      ],
+      "src": "0:35:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 8,
+            "name": "A",
+            "nameLocations":
+            [
+              "50:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "50:1:1"
+          },
+          "id": 9,
+          "nodeType": "InheritanceSpecifier",
+          "src": "50:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 17,
+      "name": "C",
+      "nameLocation": "45:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 15,
+            "nodeType": "Block",
+            "src": "73:2:1",
+            "statements": []
+          },
+          "id": 16,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "32",
+                  "id": 12,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "70:1:1",
+                  "typeDescriptions": {},
+                  "value": "2"
+                }
+              ],
+              "id": 13,
+              "modifierName":
+              {
+                "id": 11,
+                "name": "A",
+                "nameLocations":
+                [
+                  "68:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "68:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "68:4:1"
+            }
+          ],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "65:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "73:0:1"
+          },
+          "src": "54:21:1",
+          "stateMutability": "nonpayable",
+          "virtual": false
+        }
+      ],
+      "src": "36:41:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:78:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/constructor.json b/compiler/test/libsolidity/ASTJSON/constructor.json
new file mode 100644
index 00000000..53e622b5
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/constructor.json
@@ -0,0 +1,74 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "28:4:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "25:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "28:0:1"
+          },
+          "scope": 5,
+          "src": "14:18:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 6,
+      "src": "0:34:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:35:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/constructor.sol b/compiler/test/libsolidity/ASTJSON/constructor.sol
new file mode 100644
index 00000000..b48aa1be
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/constructor.sol
@@ -0,0 +1,5 @@
+contract C {
+	constructor() {
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/constructor_parseOnly.json b/compiler/test/libsolidity/ASTJSON/constructor_parseOnly.json
new file mode 100644
index 00000000..9b1d4cfc
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/constructor_parseOnly.json
@@ -0,0 +1,58 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "28:4:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "25:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "28:0:1"
+          },
+          "src": "14:18:1",
+          "stateMutability": "nonpayable",
+          "virtual": false
+        }
+      ],
+      "src": "0:34:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:35:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/contract_dep_order.json b/compiler/test/libsolidity/ASTJSON/contract_dep_order.json
new file mode 100644
index 00000000..67eff600
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/contract_dep_order.json
@@ -0,0 +1,223 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "A":
+    [
+      1
+    ],
+    "B":
+    [
+      4
+    ],
+    "C":
+    [
+      7
+    ],
+    "D":
+    [
+      10
+    ],
+    "E":
+    [
+      13
+    ]
+  },
+  "id": 14,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "A",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 1,
+      "linearizedBaseContracts":
+      [
+        1
+      ],
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "0:14:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 2,
+            "name": "A",
+            "nameLocations":
+            [
+              "29:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 1,
+            "src": "29:1:1"
+          },
+          "id": 3,
+          "nodeType": "InheritanceSpecifier",
+          "src": "29:1:1"
+        }
+      ],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 4,
+      "linearizedBaseContracts":
+      [
+        4,
+        1
+      ],
+      "name": "B",
+      "nameLocation": "24:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "15:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 5,
+            "name": "B",
+            "nameLocations":
+            [
+              "49:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 4,
+            "src": "49:1:1"
+          },
+          "id": 6,
+          "nodeType": "InheritanceSpecifier",
+          "src": "49:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 7,
+      "linearizedBaseContracts":
+      [
+        7,
+        4,
+        1
+      ],
+      "name": "C",
+      "nameLocation": "44:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "35:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 8,
+            "name": "C",
+            "nameLocations":
+            [
+              "69:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 7,
+            "src": "69:1:1"
+          },
+          "id": 9,
+          "nodeType": "InheritanceSpecifier",
+          "src": "69:1:1"
+        }
+      ],
+      "canonicalName": "D",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 10,
+      "linearizedBaseContracts":
+      [
+        10,
+        7,
+        4,
+        1
+      ],
+      "name": "D",
+      "nameLocation": "64:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "55:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 11,
+            "name": "D",
+            "nameLocations":
+            [
+              "89:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 10,
+            "src": "89:1:1"
+          },
+          "id": 12,
+          "nodeType": "InheritanceSpecifier",
+          "src": "89:1:1"
+        }
+      ],
+      "canonicalName": "E",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 13,
+      "linearizedBaseContracts":
+      [
+        13,
+        10,
+        7,
+        4,
+        1
+      ],
+      "name": "E",
+      "nameLocation": "84:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "75:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:95:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/contract_dep_order_parseOnly.json b/compiler/test/libsolidity/ASTJSON/contract_dep_order_parseOnly.json
new file mode 100644
index 00000000..ba8c377c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/contract_dep_order_parseOnly.json
@@ -0,0 +1,151 @@
+{
+  "absolutePath": "a",
+  "id": 14,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 1,
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "0:14:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 2,
+            "name": "A",
+            "nameLocations":
+            [
+              "29:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "29:1:1"
+          },
+          "id": 3,
+          "nodeType": "InheritanceSpecifier",
+          "src": "29:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 4,
+      "name": "B",
+      "nameLocation": "24:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "15:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 5,
+            "name": "B",
+            "nameLocations":
+            [
+              "49:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "49:1:1"
+          },
+          "id": 6,
+          "nodeType": "InheritanceSpecifier",
+          "src": "49:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 7,
+      "name": "C",
+      "nameLocation": "44:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "35:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 8,
+            "name": "C",
+            "nameLocations":
+            [
+              "69:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "69:1:1"
+          },
+          "id": 9,
+          "nodeType": "InheritanceSpecifier",
+          "src": "69:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 10,
+      "name": "D",
+      "nameLocation": "64:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "55:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 11,
+            "name": "D",
+            "nameLocations":
+            [
+              "89:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "89:1:1"
+          },
+          "id": 12,
+          "nodeType": "InheritanceSpecifier",
+          "src": "89:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 13,
+      "name": "E",
+      "nameLocation": "84:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "75:19:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:95:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation.json b/compiler/test/libsolidity/ASTJSON/documentation.json
new file mode 100644
index 00000000..43224bc6
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation.json
@@ -0,0 +1,273 @@
+[
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      2
+    ]
+  },
+  "id": 3,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:27:1",
+        "text": "This contract is empty"
+      },
+      "fullyImplemented": true,
+      "id": 2,
+      "linearizedBaseContracts":
+      [
+        2
+      ],
+      "name": "C",
+      "nameLocation": "37:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 3,
+      "src": "28:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "28:14:1"
+},
+{
+  "absolutePath": "b",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "documentation":
+      {
+        "id": 4,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:61:2",
+        "text": "This contract is empty\nand has a line-breaking comment."
+      },
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "71:1:2",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 6,
+      "src": "62:13:2",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "62:14:2"
+},
+{
+  "absolutePath": "c",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      23
+    ]
+  },
+  "id": 24,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 23,
+      "linearizedBaseContracts":
+      [
+        23
+      ],
+      "name": "C",
+      "nameLocation": "9:1:3",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "documentation":
+          {
+            "id": 7,
+            "nodeType": "StructuredDocumentation",
+            "src": "15:32:3",
+            "text": "Some comment on state var."
+          },
+          "functionSelector": "c19d93fb",
+          "id": 9,
+          "mutability": "mutable",
+          "name": "state",
+          "nameLocation": "60:5:3",
+          "nodeType": "VariableDeclaration",
+          "scope": 23,
+          "src": "48:17:3",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 8,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "48:4:3",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "visibility": "public"
+        },
+        {
+          "anonymous": false,
+          "documentation":
+          {
+            "id": 10,
+            "nodeType": "StructuredDocumentation",
+            "src": "69:26:3",
+            "text": "Some comment on Evt."
+          },
+          "eventSelector": "a69007916fc1145953e5a7032d7c3eab4b8e2f33ec59b0f71e732904eeede3a4",
+          "id": 12,
+          "name": "Evt",
+          "nameLocation": "102:3:3",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "105:2:3"
+          },
+          "src": "96:12:3"
+        },
+        {
+          "body":
+          {
+            "id": 16,
+            "nodeType": "Block",
+            "src": "153:6:3",
+            "statements":
+            [
+              {
+                "id": 15,
+                "nodeType": "PlaceholderStatement",
+                "src": "155:1:3"
+              }
+            ]
+          },
+          "documentation":
+          {
+            "id": 13,
+            "nodeType": "StructuredDocumentation",
+            "src": "111:26:3",
+            "text": "Some comment on mod."
+          },
+          "id": 17,
+          "name": "mod",
+          "nameLocation": "147:3:3",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "150:2:3"
+          },
+          "src": "138:21:3",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 21,
+            "nodeType": "Block",
+            "src": "209:2:3",
+            "statements": []
+          },
+          "documentation":
+          {
+            "id": 18,
+            "nodeType": "StructuredDocumentation",
+            "src": "162:25:3",
+            "text": "Some comment on fn."
+          },
+          "functionSelector": "a4a2c40b",
+          "id": 22,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "fn",
+          "nameLocation": "197:2:3",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "199:2:3"
+          },
+          "returnParameters":
+          {
+            "id": 20,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "209:0:3"
+          },
+          "scope": 23,
+          "src": "188:23:3",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 24,
+      "src": "0:213:3",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        12
+      ]
+    }
+  ],
+  "src": "0:214:3"
+}
+]
diff --git a/compiler/test/libsolidity/ASTJSON/documentation.sol b/compiler/test/libsolidity/ASTJSON/documentation.sol
new file mode 100644
index 00000000..6bbf4042
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation.sol
@@ -0,0 +1,19 @@
+==== Source: a ====
+
+/**This contract is empty*/ contract C {}
+
+==== Source: b ====
+
+/**This contract is empty
+ and has a line-breaking comment.*/
+contract C {}
+
+==== Source: c ====
+
+contract C {
+  /** Some comment on state var.*/ uint public state;
+  /** Some comment on Evt.*/ event Evt();
+  /** Some comment on mod.*/ modifier mod() { _; }
+  /** Some comment on fn.*/ function fn() public {}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_local_variable.json b/compiler/test/libsolidity/ASTJSON/documentation_local_variable.json
new file mode 100644
index 00000000..62d76e78
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_local_variable.json
@@ -0,0 +1,493 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      41
+    ]
+  },
+  "id": 42,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 41,
+      "linearizedBaseContracts":
+      [
+        41
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 26,
+            "nodeType": "Block",
+            "src": "42:330:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  5
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 5,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "114:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 26,
+                    "src": "109:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    },
+                    "typeName":
+                    {
+                      "id": 4,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "109:4:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "documentation": "Documentation for x; will appear in ast json",
+                "id": 7,
+                "initialValue":
+                {
+                  "hexValue": "31",
+                  "id": 6,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "number",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "118:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_1_by_1",
+                    "typeString": "int_const 1"
+                  },
+                  "value": "1"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "109:10:1"
+              },
+              {
+                "body":
+                {
+                  "id": 24,
+                  "nodeType": "Block",
+                  "src": "270:96:1",
+                  "statements":
+                  [
+                    {
+                      "assignments":
+                      [
+                        21
+                      ],
+                      "declarations":
+                      [
+                        {
+                          "constant": false,
+                          "id": 21,
+                          "mutability": "mutable",
+                          "name": "j",
+                          "nameLocation": "350:1:1",
+                          "nodeType": "VariableDeclaration",
+                          "scope": 24,
+                          "src": "345:6:1",
+                          "stateVariable": false,
+                          "storageLocation": "default",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          },
+                          "typeName":
+                          {
+                            "id": 20,
+                            "name": "uint",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "345:4:1",
+                            "typeDescriptions":
+                            {
+                              "typeIdentifier": "t_uint256",
+                              "typeString": "uint256"
+                            }
+                          },
+                          "visibility": "internal"
+                        }
+                      ],
+                      "documentation": "documentation for j; will appear in ast json",
+                      "id": 23,
+                      "initialValue":
+                      {
+                        "hexValue": "30",
+                        "id": 22,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": true,
+                        "kind": "number",
+                        "lValueRequested": false,
+                        "nodeType": "Literal",
+                        "src": "354:1:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_rational_0_by_1",
+                          "typeString": "int_const 0"
+                        },
+                        "value": "0"
+                      },
+                      "nodeType": "VariableDeclarationStatement",
+                      "src": "345:10:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  },
+                  "id": 15,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftExpression":
+                  {
+                    "id": 13,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 10,
+                    "src": "236:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3130",
+                    "id": 14,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "240:2:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_10_by_1",
+                      "typeString": "int_const 10"
+                    },
+                    "value": "10"
+                  },
+                  "src": "236:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_bool",
+                    "typeString": "bool"
+                  }
+                },
+                "id": 25,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    10
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 10,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "217:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "scope": 25,
+                      "src": "212:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      },
+                      "typeName":
+                      {
+                        "id": 9,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "212:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 12,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 11,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "221:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_0_by_1",
+                      "typeString": "int_const 0"
+                    },
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "212:10:1"
+                },
+                "isSimpleCounterLoop": true,
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 17,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": true,
+                    "src": "256:3:1",
+                    "subExpression":
+                    {
+                      "id": 16,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 10,
+                      "src": "258:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "id": 18,
+                  "nodeType": "ExpressionStatement",
+                  "src": "256:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "129:237:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 27,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 41,
+          "src": "17:355:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 39,
+            "nodeType": "Block",
+            "src": "662:2:1",
+            "statements": []
+          },
+          "functionSelector": "191157d1",
+          "id": 40,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "386:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 37,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 30,
+                "mutability": "mutable",
+                "name": "param1",
+                "nameLocation": "468:6:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 40,
+                "src": "463:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 29,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "463:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              },
+              {
+                "constant": false,
+                "id": 33,
+                "mutability": "mutable",
+                "name": "param2",
+                "nameLocation": "555:6:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 40,
+                "src": "550:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 32,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "550:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              },
+              {
+                "constant": false,
+                "id": 36,
+                "mutability": "mutable",
+                "name": "param3",
+                "nameLocation": "642:6:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 40,
+                "src": "637:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 35,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "637:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "387:267:1"
+          },
+          "returnParameters":
+          {
+            "id": 38,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "662:0:1"
+          },
+          "scope": 41,
+          "src": "377:287:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 42,
+      "src": "0:666:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:667:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_local_variable_parseOnly.json b/compiler/test/libsolidity/ASTJSON/documentation_local_variable_parseOnly.json
new file mode 100644
index 00000000..87258383
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_local_variable_parseOnly.json
@@ -0,0 +1,358 @@
+{
+  "absolutePath": "a",
+  "id": 42,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 41,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 26,
+            "nodeType": "Block",
+            "src": "42:330:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  5
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 5,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "114:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "109:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 4,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "109:4:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "documentation": "Documentation for x; will appear in ast json",
+                "id": 7,
+                "initialValue":
+                {
+                  "hexValue": "31",
+                  "id": 6,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "118:1:1",
+                  "typeDescriptions": {},
+                  "value": "1"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "109:10:1"
+              },
+              {
+                "body":
+                {
+                  "id": 24,
+                  "nodeType": "Block",
+                  "src": "270:96:1",
+                  "statements":
+                  [
+                    {
+                      "assignments":
+                      [
+                        21
+                      ],
+                      "declarations":
+                      [
+                        {
+                          "constant": false,
+                          "id": 21,
+                          "mutability": "mutable",
+                          "name": "j",
+                          "nameLocation": "350:1:1",
+                          "nodeType": "VariableDeclaration",
+                          "src": "345:6:1",
+                          "stateVariable": false,
+                          "storageLocation": "default",
+                          "typeDescriptions": {},
+                          "typeName":
+                          {
+                            "id": 20,
+                            "name": "uint",
+                            "nodeType": "ElementaryTypeName",
+                            "src": "345:4:1",
+                            "typeDescriptions": {}
+                          },
+                          "visibility": "internal"
+                        }
+                      ],
+                      "documentation": "documentation for j; will appear in ast json",
+                      "id": 23,
+                      "initialValue":
+                      {
+                        "hexValue": "30",
+                        "id": 22,
+                        "kind": "number",
+                        "nodeType": "Literal",
+                        "src": "354:1:1",
+                        "typeDescriptions": {},
+                        "value": "0"
+                      },
+                      "nodeType": "VariableDeclarationStatement",
+                      "src": "345:10:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType": {},
+                  "id": 15,
+                  "leftExpression":
+                  {
+                    "id": 13,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "236:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3130",
+                    "id": 14,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "240:2:1",
+                    "typeDescriptions": {},
+                    "value": "10"
+                  },
+                  "src": "236:6:1",
+                  "typeDescriptions": {}
+                },
+                "id": 25,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    10
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 10,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "217:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "src": "212:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions": {},
+                      "typeName":
+                      {
+                        "id": 9,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "212:4:1",
+                        "typeDescriptions": {}
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 12,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 11,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "221:1:1",
+                    "typeDescriptions": {},
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "212:10:1"
+                },
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 17,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": true,
+                    "src": "256:3:1",
+                    "subExpression":
+                    {
+                      "id": 16,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "258:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "typeDescriptions": {}
+                  },
+                  "id": 18,
+                  "nodeType": "ExpressionStatement",
+                  "src": "256:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "129:237:1"
+              }
+            ]
+          },
+          "id": 27,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "17:355:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 39,
+            "nodeType": "Block",
+            "src": "662:2:1",
+            "statements": []
+          },
+          "id": 40,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "386:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 37,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 30,
+                "mutability": "mutable",
+                "name": "param1",
+                "nameLocation": "468:6:1",
+                "nodeType": "VariableDeclaration",
+                "src": "463:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 29,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "463:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              },
+              {
+                "constant": false,
+                "id": 33,
+                "mutability": "mutable",
+                "name": "param2",
+                "nameLocation": "555:6:1",
+                "nodeType": "VariableDeclaration",
+                "src": "550:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 32,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "550:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              },
+              {
+                "constant": false,
+                "id": 36,
+                "mutability": "mutable",
+                "name": "param3",
+                "nameLocation": "642:6:1",
+                "nodeType": "VariableDeclaration",
+                "src": "637:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 35,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "637:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "387:267:1"
+          },
+          "returnParameters":
+          {
+            "id": 38,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "662:0:1"
+          },
+          "src": "377:287:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:666:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:667:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_on_statements.json b/compiler/test/libsolidity/ASTJSON/documentation_on_statements.json
new file mode 100644
index 00000000..cc4a1ef3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_on_statements.json
@@ -0,0 +1,378 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      27
+    ]
+  },
+  "id": 28,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 27,
+      "linearizedBaseContracts":
+      [
+        27
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 2,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "50:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 27,
+          "src": "45:6:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 1,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "45:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 25,
+            "nodeType": "Block",
+            "src": "99:229:1",
+            "statements":
+            [
+              {
+                "body":
+                {
+                  "id": 21,
+                  "nodeType": "Block",
+                  "src": "156:66:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "id": 19,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "leftHandSide":
+                        {
+                          "id": 17,
+                          "name": "x",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 5,
+                          "src": "205:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          }
+                        },
+                        "nodeType": "Assignment",
+                        "operator": "*=",
+                        "rightHandSide":
+                        {
+                          "hexValue": "32",
+                          "id": 18,
+                          "isConstant": false,
+                          "isLValue": false,
+                          "isPure": true,
+                          "kind": "number",
+                          "lValueRequested": false,
+                          "nodeType": "Literal",
+                          "src": "210:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_rational_2_by_1",
+                            "typeString": "int_const 2"
+                          },
+                          "value": "2"
+                        },
+                        "src": "205:6:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "id": 20,
+                      "nodeType": "ExpressionStatement",
+                      "src": "205:6:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  },
+                  "id": 13,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftExpression":
+                  {
+                    "id": 11,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 8,
+                    "src": "143:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3230",
+                    "id": 12,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "147:2:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_20_by_1",
+                      "typeString": "int_const 20"
+                    },
+                    "value": "20"
+                  },
+                  "src": "143:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_bool",
+                    "typeString": "bool"
+                  }
+                },
+                "id": 22,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    8
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 8,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "136:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "scope": 22,
+                      "src": "131:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      },
+                      "typeName":
+                      {
+                        "id": 7,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "131:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 10,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 9,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "140:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_0_by_1",
+                      "typeString": "int_const 0"
+                    },
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "131:10:1"
+                },
+                "isSimpleCounterLoop": true,
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 15,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": false,
+                    "src": "151:3:1",
+                    "subExpression":
+                    {
+                      "id": 14,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 8,
+                      "src": "151:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "id": 16,
+                  "nodeType": "ExpressionStatement",
+                  "src": "151:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "126:96:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 23,
+                  "name": "x",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 5,
+                  "src": "320:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "functionReturnParameters": 6,
+                "id": 24,
+                "nodeType": "Return",
+                "src": "313:8:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 26,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "66:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "67:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 5,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "96:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 26,
+                "src": "91:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 4,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "91:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "90:8:1"
+          },
+          "scope": 27,
+          "src": "57:271:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 28,
+      "src": "0:330:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:331:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_on_statements_parseOnly.json b/compiler/test/libsolidity/ASTJSON/documentation_on_statements_parseOnly.json
new file mode 100644
index 00000000..3872027c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_on_statements_parseOnly.json
@@ -0,0 +1,261 @@
+{
+  "absolutePath": "a",
+  "id": 28,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 27,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 2,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "50:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "45:6:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 1,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "45:4:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 25,
+            "nodeType": "Block",
+            "src": "99:229:1",
+            "statements":
+            [
+              {
+                "body":
+                {
+                  "id": 21,
+                  "nodeType": "Block",
+                  "src": "156:66:1",
+                  "statements":
+                  [
+                    {
+                      "expression":
+                      {
+                        "id": 19,
+                        "leftHandSide":
+                        {
+                          "id": 17,
+                          "name": "x",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "src": "205:1:1",
+                          "typeDescriptions": {}
+                        },
+                        "nodeType": "Assignment",
+                        "operator": "*=",
+                        "rightHandSide":
+                        {
+                          "hexValue": "32",
+                          "id": 18,
+                          "kind": "number",
+                          "nodeType": "Literal",
+                          "src": "210:1:1",
+                          "typeDescriptions": {},
+                          "value": "2"
+                        },
+                        "src": "205:6:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 20,
+                      "nodeType": "ExpressionStatement",
+                      "src": "205:6:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType": {},
+                  "id": 13,
+                  "leftExpression":
+                  {
+                    "id": 11,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "143:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3230",
+                    "id": 12,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "147:2:1",
+                    "typeDescriptions": {},
+                    "value": "20"
+                  },
+                  "src": "143:6:1",
+                  "typeDescriptions": {}
+                },
+                "id": 22,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    8
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 8,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "136:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "src": "131:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions": {},
+                      "typeName":
+                      {
+                        "id": 7,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "131:4:1",
+                        "typeDescriptions": {}
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 10,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 9,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "140:1:1",
+                    "typeDescriptions": {},
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "131:10:1"
+                },
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 15,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": false,
+                    "src": "151:3:1",
+                    "subExpression":
+                    {
+                      "id": 14,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "151:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "typeDescriptions": {}
+                  },
+                  "id": 16,
+                  "nodeType": "ExpressionStatement",
+                  "src": "151:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "126:96:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 23,
+                  "name": "x",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "src": "320:1:1",
+                  "typeDescriptions": {}
+                },
+                "id": 24,
+                "nodeType": "Return",
+                "src": "313:8:1"
+              }
+            ]
+          },
+          "id": 26,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "66:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "67:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 5,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "96:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "91:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 4,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "91:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "90:8:1"
+          },
+          "src": "57:271:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:330:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:331:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_parseOnly.json b/compiler/test/libsolidity/ASTJSON/documentation_parseOnly.json
new file mode 100644
index 00000000..7f446279
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_parseOnly.json
@@ -0,0 +1,208 @@
+[
+{
+  "absolutePath": "a",
+  "id": 3,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:27:1",
+        "text": "This contract is empty"
+      },
+      "id": 2,
+      "name": "C",
+      "nameLocation": "37:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "28:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "28:14:1"
+},
+{
+  "absolutePath": "b",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "documentation":
+      {
+        "id": 4,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:61:2",
+        "text": "This contract is empty\nand has a line-breaking comment."
+      },
+      "id": 5,
+      "name": "C",
+      "nameLocation": "71:1:2",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "62:13:2",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "62:14:2"
+},
+{
+  "absolutePath": "c",
+  "id": 24,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 23,
+      "name": "C",
+      "nameLocation": "9:1:3",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 9,
+          "mutability": "mutable",
+          "name": "state",
+          "nameLocation": "60:5:3",
+          "nodeType": "VariableDeclaration",
+          "src": "48:17:3",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 8,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "48:4:3",
+            "typeDescriptions": {}
+          },
+          "visibility": "public"
+        },
+        {
+          "anonymous": false,
+          "documentation":
+          {
+            "id": 10,
+            "nodeType": "StructuredDocumentation",
+            "src": "69:26:3",
+            "text": "Some comment on Evt."
+          },
+          "id": 12,
+          "name": "Evt",
+          "nameLocation": "102:3:3",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "105:2:3"
+          },
+          "src": "96:12:3"
+        },
+        {
+          "body":
+          {
+            "id": 16,
+            "nodeType": "Block",
+            "src": "153:6:3",
+            "statements":
+            [
+              {
+                "id": 15,
+                "nodeType": "PlaceholderStatement",
+                "src": "155:1:3"
+              }
+            ]
+          },
+          "documentation":
+          {
+            "id": 13,
+            "nodeType": "StructuredDocumentation",
+            "src": "111:26:3",
+            "text": "Some comment on mod."
+          },
+          "id": 17,
+          "name": "mod",
+          "nameLocation": "147:3:3",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "150:2:3"
+          },
+          "src": "138:21:3",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 21,
+            "nodeType": "Block",
+            "src": "209:2:3",
+            "statements": []
+          },
+          "documentation":
+          {
+            "id": 18,
+            "nodeType": "StructuredDocumentation",
+            "src": "162:25:3",
+            "text": "Some comment on fn."
+          },
+          "id": 22,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "fn",
+          "nameLocation": "197:2:3",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "199:2:3"
+          },
+          "returnParameters":
+          {
+            "id": 20,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "209:0:3"
+          },
+          "src": "188:23:3",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:213:3",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:214:3"
+}
+]
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_triple.json b/compiler/test/libsolidity/ASTJSON/documentation_triple.json
new file mode 100644
index 00000000..cd44bd4e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_triple.json
@@ -0,0 +1,388 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      28
+    ]
+  },
+  "id": 29,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 28,
+      "linearizedBaseContracts":
+      [
+        28
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "documentation":
+          {
+            "id": 1,
+            "nodeType": "StructuredDocumentation",
+            "src": "17:8:1",
+            "text": "test"
+          },
+          "id": 3,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "35:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 28,
+          "src": "30:6:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 2,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "30:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 26,
+            "nodeType": "Block",
+            "src": "84:181:1",
+            "statements":
+            [
+              {
+                "body":
+                {
+                  "id": 22,
+                  "nodeType": "Block",
+                  "src": "142:75:1",
+                  "statements":
+                  [
+                    {
+                      "documentation": "tee\n s \"t\" 3",
+                      "expression":
+                      {
+                        "id": 20,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": false,
+                        "lValueRequested": false,
+                        "leftHandSide":
+                        {
+                          "id": 18,
+                          "name": "x",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "referencedDeclaration": 6,
+                          "src": "200:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          }
+                        },
+                        "nodeType": "Assignment",
+                        "operator": "*=",
+                        "rightHandSide":
+                        {
+                          "hexValue": "32",
+                          "id": 19,
+                          "isConstant": false,
+                          "isLValue": false,
+                          "isPure": true,
+                          "kind": "number",
+                          "lValueRequested": false,
+                          "nodeType": "Literal",
+                          "src": "205:1:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_rational_2_by_1",
+                            "typeString": "int_const 2"
+                          },
+                          "value": "2"
+                        },
+                        "src": "200:6:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "id": 21,
+                      "nodeType": "ExpressionStatement",
+                      "src": "200:6:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  },
+                  "id": 14,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftExpression":
+                  {
+                    "id": 12,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 9,
+                    "src": "129:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3230",
+                    "id": 13,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "133:2:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_20_by_1",
+                      "typeString": "int_const 20"
+                    },
+                    "value": "20"
+                  },
+                  "src": "129:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_bool",
+                    "typeString": "bool"
+                  }
+                },
+                "documentation": "test2",
+                "id": 23,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    9
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 9,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "122:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "scope": 23,
+                      "src": "117:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      },
+                      "typeName":
+                      {
+                        "id": 8,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "117:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 11,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 10,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "126:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_0_by_1",
+                      "typeString": "int_const 0"
+                    },
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "117:10:1"
+                },
+                "isSimpleCounterLoop": true,
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 16,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": false,
+                    "src": "137:3:1",
+                    "subExpression":
+                    {
+                      "id": 15,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 9,
+                      "src": "137:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "id": 17,
+                  "nodeType": "ExpressionStatement",
+                  "src": "137:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "112:105:1"
+              },
+              {
+                "documentation": "tes \"t4\" ",
+                "expression":
+                {
+                  "id": 24,
+                  "name": "x",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 6,
+                  "src": "257:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "functionReturnParameters": 7,
+                "id": 25,
+                "nodeType": "Return",
+                "src": "250:8:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 27,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "51:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "52:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "81:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 27,
+                "src": "76:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 5,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "76:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "75:8:1"
+          },
+          "scope": 28,
+          "src": "42:223:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 29,
+      "src": "0:267:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:268:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/documentation_triple_parseOnly.json b/compiler/test/libsolidity/ASTJSON/documentation_triple_parseOnly.json
new file mode 100644
index 00000000..5ccc2631
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/documentation_triple_parseOnly.json
@@ -0,0 +1,264 @@
+{
+  "absolutePath": "a",
+  "id": 29,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 28,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "35:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "30:6:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 2,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "30:4:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 26,
+            "nodeType": "Block",
+            "src": "84:181:1",
+            "statements":
+            [
+              {
+                "body":
+                {
+                  "id": 22,
+                  "nodeType": "Block",
+                  "src": "142:75:1",
+                  "statements":
+                  [
+                    {
+                      "documentation": "tee\n s \"t\" 3",
+                      "expression":
+                      {
+                        "id": 20,
+                        "leftHandSide":
+                        {
+                          "id": 18,
+                          "name": "x",
+                          "nodeType": "Identifier",
+                          "overloadedDeclarations": [],
+                          "src": "200:1:1",
+                          "typeDescriptions": {}
+                        },
+                        "nodeType": "Assignment",
+                        "operator": "*=",
+                        "rightHandSide":
+                        {
+                          "hexValue": "32",
+                          "id": 19,
+                          "kind": "number",
+                          "nodeType": "Literal",
+                          "src": "205:1:1",
+                          "typeDescriptions": {},
+                          "value": "2"
+                        },
+                        "src": "200:6:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 21,
+                      "nodeType": "ExpressionStatement",
+                      "src": "200:6:1"
+                    }
+                  ]
+                },
+                "condition":
+                {
+                  "commonType": {},
+                  "id": 14,
+                  "leftExpression":
+                  {
+                    "id": 12,
+                    "name": "i",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "129:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "<",
+                  "rightExpression":
+                  {
+                    "hexValue": "3230",
+                    "id": 13,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "133:2:1",
+                    "typeDescriptions": {},
+                    "value": "20"
+                  },
+                  "src": "129:6:1",
+                  "typeDescriptions": {}
+                },
+                "documentation": "test2",
+                "id": 23,
+                "initializationExpression":
+                {
+                  "assignments":
+                  [
+                    9
+                  ],
+                  "declarations":
+                  [
+                    {
+                      "constant": false,
+                      "id": 9,
+                      "mutability": "mutable",
+                      "name": "i",
+                      "nameLocation": "122:1:1",
+                      "nodeType": "VariableDeclaration",
+                      "src": "117:6:1",
+                      "stateVariable": false,
+                      "storageLocation": "default",
+                      "typeDescriptions": {},
+                      "typeName":
+                      {
+                        "id": 8,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "117:4:1",
+                        "typeDescriptions": {}
+                      },
+                      "visibility": "internal"
+                    }
+                  ],
+                  "id": 11,
+                  "initialValue":
+                  {
+                    "hexValue": "30",
+                    "id": 10,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "126:1:1",
+                    "typeDescriptions": {},
+                    "value": "0"
+                  },
+                  "nodeType": "VariableDeclarationStatement",
+                  "src": "117:10:1"
+                },
+                "loopExpression":
+                {
+                  "expression":
+                  {
+                    "id": 16,
+                    "nodeType": "UnaryOperation",
+                    "operator": "++",
+                    "prefix": false,
+                    "src": "137:3:1",
+                    "subExpression":
+                    {
+                      "id": 15,
+                      "name": "i",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "137:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "typeDescriptions": {}
+                  },
+                  "id": 17,
+                  "nodeType": "ExpressionStatement",
+                  "src": "137:3:1"
+                },
+                "nodeType": "ForStatement",
+                "src": "112:105:1"
+              },
+              {
+                "documentation": "tes \"t4\" ",
+                "expression":
+                {
+                  "id": 24,
+                  "name": "x",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "src": "257:1:1",
+                  "typeDescriptions": {}
+                },
+                "id": 25,
+                "nodeType": "Return",
+                "src": "250:8:1"
+              }
+            ]
+          },
+          "id": 27,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "51:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "52:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "81:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "76:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 5,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "76:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "75:8:1"
+          },
+          "src": "42:223:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:267:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:268:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/enum_natspec.json b/compiler/test/libsolidity/ASTJSON/enum_natspec.json
new file mode 100644
index 00000000..f3cc7b8d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/enum_natspec.json
@@ -0,0 +1,48 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "Color":
+    [
+      4
+    ]
+  },
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "canonicalName": "Color",
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:112:1",
+        "text": "@title example of title\n @author example of author\n @notice example of notice\n @dev example of dev"
+      },
+      "id": 4,
+      "members":
+      [
+        {
+          "id": 2,
+          "name": "Red",
+          "nameLocation": "129:3:1",
+          "nodeType": "EnumValue",
+          "src": "129:3:1"
+        },
+        {
+          "id": 3,
+          "name": "Green",
+          "nameLocation": "138:5:1",
+          "nodeType": "EnumValue",
+          "src": "138:5:1"
+        }
+      ],
+      "name": "Color",
+      "nameLocation": "117:5:1",
+      "nodeType": "EnumDefinition",
+      "src": "112:33:1"
+    }
+  ],
+  "src": "112:34:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/enum_natspec.sol b/compiler/test/libsolidity/ASTJSON/enum_natspec.sol
new file mode 100644
index 00000000..b9663fa9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/enum_natspec.sol
@@ -0,0 +1,10 @@
+/// @title example of title
+/// @author example of author
+/// @notice example of notice
+/// @dev example of dev
+enum Color {
+    Red,
+    Green
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/enum_natspec_parseOnly.json b/compiler/test/libsolidity/ASTJSON/enum_natspec_parseOnly.json
new file mode 100644
index 00000000..b5a38af6
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/enum_natspec_parseOnly.json
@@ -0,0 +1,40 @@
+{
+  "absolutePath": "a",
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:112:1",
+        "text": "@title example of title\n @author example of author\n @notice example of notice\n @dev example of dev"
+      },
+      "id": 4,
+      "members":
+      [
+        {
+          "id": 2,
+          "name": "Red",
+          "nameLocation": "129:3:1",
+          "nodeType": "EnumValue",
+          "src": "129:3:1"
+        },
+        {
+          "id": 3,
+          "name": "Green",
+          "nameLocation": "138:5:1",
+          "nodeType": "EnumValue",
+          "src": "138:5:1"
+        }
+      ],
+      "name": "Color",
+      "nameLocation": "117:5:1",
+      "nodeType": "EnumDefinition",
+      "src": "112:33:1"
+    }
+  ],
+  "src": "112:34:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/enum_value.json b/compiler/test/libsolidity/ASTJSON/enum_value.json
new file mode 100644
index 00000000..31615f65
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/enum_value.json
@@ -0,0 +1,64 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      4
+    ]
+  },
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 4,
+      "linearizedBaseContracts":
+      [
+        4
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "canonicalName": "C.E",
+          "id": 3,
+          "members":
+          [
+            {
+              "id": 1,
+              "name": "A",
+              "nameLocation": "22:1:1",
+              "nodeType": "EnumValue",
+              "src": "22:1:1"
+            },
+            {
+              "id": 2,
+              "name": "B",
+              "nameLocation": "25:1:1",
+              "nodeType": "EnumValue",
+              "src": "25:1:1"
+            }
+          ],
+          "name": "E",
+          "nameLocation": "18:1:1",
+          "nodeType": "EnumDefinition",
+          "src": "13:15:1"
+        }
+      ],
+      "scope": 5,
+      "src": "0:30:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:31:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/enum_value_parseOnly.json b/compiler/test/libsolidity/ASTJSON/enum_value_parseOnly.json
new file mode 100644
index 00000000..006e2db3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/enum_value_parseOnly.json
@@ -0,0 +1,49 @@
+{
+  "absolutePath": "a",
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 4,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 3,
+          "members":
+          [
+            {
+              "id": 1,
+              "name": "A",
+              "nameLocation": "22:1:1",
+              "nodeType": "EnumValue",
+              "src": "22:1:1"
+            },
+            {
+              "id": 2,
+              "name": "B",
+              "nameLocation": "25:1:1",
+              "nodeType": "EnumValue",
+              "src": "25:1:1"
+            }
+          ],
+          "name": "E",
+          "nameLocation": "18:1:1",
+          "nodeType": "EnumDefinition",
+          "src": "13:15:1"
+        }
+      ],
+      "src": "0:30:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:31:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.json b/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.json
new file mode 100644
index 00000000..e312320c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.json
@@ -0,0 +1,398 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      10
+    ],
+    "D":
+    [
+      30
+    ]
+  },
+  "id": 31,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 10,
+      "linearizedBaseContracts":
+      [
+        10
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "ffae15ba29768297c9b951e2e14bc33dc84599d1572acc234266fc70392babc8",
+          "id": 2,
+          "name": "e",
+          "nameLocation": "23:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "24:2:1"
+          },
+          "src": "17:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 8,
+            "nodeType": "Block",
+            "src": "52:25:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 5,
+                    "name": "e",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 2,
+                    "src": "67:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 6,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "67:3:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 7,
+                "nodeType": "EmitStatement",
+                "src": "62:8:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 9,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "41:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "52:0:1"
+          },
+          "scope": 10,
+          "src": "32:45:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 31,
+      "src": "0:79:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "D",
+      "contractDependencies":
+      [
+        10
+      ],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 30,
+      "linearizedBaseContracts":
+      [
+        30
+      ],
+      "name": "D",
+      "nameLocation": "89:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 13,
+          "mutability": "mutable",
+          "name": "c",
+          "nameLocation": "99:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 30,
+          "src": "97:3:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_contract$_C_$10",
+            "typeString": "contract C"
+          },
+          "typeName":
+          {
+            "id": 12,
+            "nodeType": "UserDefinedTypeName",
+            "pathNode":
+            {
+              "id": 11,
+              "name": "C",
+              "nameLocations":
+              [
+                "97:1:1"
+              ],
+              "nodeType": "IdentifierPath",
+              "referencedDeclaration": 10,
+              "src": "97:1:1"
+            },
+            "referencedDeclaration": 10,
+            "src": "97:1:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_contract$_C_$10",
+              "typeString": "contract C"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 28,
+            "nodeType": "Block",
+            "src": "120:43:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "id": 21,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftHandSide":
+                  {
+                    "id": 16,
+                    "name": "c",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 13,
+                    "src": "130:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_contract$_C_$10",
+                      "typeString": "contract C"
+                    }
+                  },
+                  "nodeType": "Assignment",
+                  "operator": "=",
+                  "rightHandSide":
+                  {
+                    "arguments": [],
+                    "expression":
+                    {
+                      "argumentTypes": [],
+                      "id": 19,
+                      "isConstant": false,
+                      "isLValue": false,
+                      "isPure": false,
+                      "lValueRequested": false,
+                      "nodeType": "NewExpression",
+                      "src": "134:5:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_function_creation_nonpayable$__$returns$_t_contract$_C_$10_$",
+                        "typeString": "function () returns (contract C)"
+                      },
+                      "typeName":
+                      {
+                        "id": 18,
+                        "nodeType": "UserDefinedTypeName",
+                        "pathNode":
+                        {
+                          "id": 17,
+                          "name": "C",
+                          "nameLocations":
+                          [
+                            "138:1:1"
+                          ],
+                          "nodeType": "IdentifierPath",
+                          "referencedDeclaration": 10,
+                          "src": "138:1:1"
+                        },
+                        "referencedDeclaration": 10,
+                        "src": "138:1:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_contract$_C_$10",
+                          "typeString": "contract C"
+                        }
+                      }
+                    },
+                    "id": 20,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "kind": "functionCall",
+                    "lValueRequested": false,
+                    "nameLocations": [],
+                    "names": [],
+                    "nodeType": "FunctionCall",
+                    "src": "134:7:1",
+                    "tryCall": false,
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_contract$_C_$10",
+                      "typeString": "contract C"
+                    }
+                  },
+                  "src": "130:11:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_contract$_C_$10",
+                    "typeString": "contract C"
+                  }
+                },
+                "id": 22,
+                "nodeType": "ExpressionStatement",
+                "src": "130:11:1"
+              },
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "expression":
+                    {
+                      "id": 23,
+                      "name": "c",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 13,
+                      "src": "151:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_contract$_C_$10",
+                        "typeString": "contract C"
+                      }
+                    },
+                    "id": 25,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "memberLocation": "153:1:1",
+                    "memberName": "f",
+                    "nodeType": "MemberAccess",
+                    "referencedDeclaration": 9,
+                    "src": "151:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_external_nonpayable$__$returns$__$",
+                      "typeString": "function () external"
+                    }
+                  },
+                  "id": 26,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "151:5:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 27,
+                "nodeType": "ExpressionStatement",
+                "src": "151:5:1"
+              }
+            ]
+          },
+          "id": 29,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "117:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 15,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "120:0:1"
+          },
+          "scope": 30,
+          "src": "106:57:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 31,
+      "src": "80:85:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:166:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.sol b/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.sol
new file mode 100644
index 00000000..b8fe2b27
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_aggregated_contract.sol
@@ -0,0 +1,15 @@
+contract C {
+    event e();
+    function f() public {
+        emit e();
+    }
+}
+contract D {
+    C c;
+    constructor() {
+        c = new C();
+        c.f();
+    }
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/event_definition.json b/compiler/test/libsolidity/ASTJSON/event_definition.json
new file mode 100644
index 00000000..b59164fc
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_definition.json
@@ -0,0 +1,58 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      3
+    ]
+  },
+  "id": 4,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 3,
+      "linearizedBaseContracts":
+      [
+        3
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028",
+          "id": 2,
+          "name": "E",
+          "nameLocation": "19:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "20:2:1"
+          },
+          "src": "13:10:1"
+        }
+      ],
+      "scope": 4,
+      "src": "0:25:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2
+      ]
+    }
+  ],
+  "src": "0:26:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_definition_parseOnly.json b/compiler/test/libsolidity/ASTJSON/event_definition_parseOnly.json
new file mode 100644
index 00000000..9116b3d2
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_definition_parseOnly.json
@@ -0,0 +1,40 @@
+{
+  "absolutePath": "a",
+  "id": 4,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 3,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "id": 2,
+          "name": "E",
+          "nameLocation": "19:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "20:2:1"
+          },
+          "src": "13:10:1"
+        }
+      ],
+      "src": "0:25:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:26:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.json b/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.json
new file mode 100644
index 00000000..6b183b49
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.json
@@ -0,0 +1,289 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "B":
+    [
+      16
+    ],
+    "C":
+    [
+      19
+    ],
+    "L":
+    [
+      5
+    ]
+  },
+  "id": 20,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "L",
+      "contractDependencies": [],
+      "contractKind": "library",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "L",
+      "nameLocation": "10:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "870e3024466c178150e2490c7cfb455e33c0db877113af040f89189d07946664",
+          "id": 4,
+          "name": "E",
+          "nameLocation": "20:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "indexed": false,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "scope": 4,
+                "src": "22:5:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint8",
+                  "typeString": "uint8"
+                },
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint8",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "22:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint8",
+                    "typeString": "uint8"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "21:7:1"
+          },
+          "src": "14:15:1"
+        }
+      ],
+      "scope": 20,
+      "src": "0:31:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        4
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 16,
+      "linearizedBaseContracts":
+      [
+        16
+      ],
+      "name": "B",
+      "nameLocation": "41:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 14,
+            "nodeType": "Block",
+            "src": "63:28:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments":
+                  [
+                    {
+                      "hexValue": "30",
+                      "id": 11,
+                      "isConstant": false,
+                      "isLValue": false,
+                      "isPure": true,
+                      "kind": "number",
+                      "lValueRequested": false,
+                      "nodeType": "Literal",
+                      "src": "82:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_rational_0_by_1",
+                        "typeString": "int_const 0"
+                      },
+                      "value": "0"
+                    }
+                  ],
+                  "expression":
+                  {
+                    "argumentTypes":
+                    [
+                      {
+                        "typeIdentifier": "t_rational_0_by_1",
+                        "typeString": "int_const 0"
+                      }
+                    ],
+                    "expression":
+                    {
+                      "id": 8,
+                      "name": "L",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 5,
+                      "src": "78:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_type$_t_contract$_L_$5_$",
+                        "typeString": "type(library L)"
+                      }
+                    },
+                    "id": 10,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "memberLocation": "80:1:1",
+                    "memberName": "E",
+                    "nodeType": "MemberAccess",
+                    "referencedDeclaration": 4,
+                    "src": "78:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_event_nonpayable$_t_uint8_$returns$__$",
+                      "typeString": "function (uint8)"
+                    }
+                  },
+                  "id": 12,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "78:6:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 13,
+                "nodeType": "EmitStatement",
+                "src": "73:11:1"
+              }
+            ]
+          },
+          "id": 15,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "60:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "63:0:1"
+          },
+          "scope": 16,
+          "src": "49:42:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 20,
+      "src": "32:61:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        4
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 17,
+            "name": "B",
+            "nameLocations":
+            [
+              "108:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 16,
+            "src": "108:1:1"
+          },
+          "id": 18,
+          "nodeType": "InheritanceSpecifier",
+          "src": "108:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 19,
+      "linearizedBaseContracts":
+      [
+        19,
+        16
+      ],
+      "name": "C",
+      "nameLocation": "103:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 20,
+      "src": "94:18:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        4
+      ]
+    }
+  ],
+  "src": "0:113:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.sol b/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.sol
new file mode 100644
index 00000000..30380323
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_emited_in_base_contract.sol
@@ -0,0 +1,9 @@
+library   L { event E(uint8); }
+contract B {
+    constructor() {
+        emit L.E(0);
+    }
+}
+contract C is B {}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.json b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.json
new file mode 100644
index 00000000..2d70e2f9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.json
@@ -0,0 +1,289 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ],
+    "D":
+    [
+      19
+    ]
+  },
+  "id": 20,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "bd1155618a34fd53d1a2de9f705f42f3582842cba0b985b25c59888d86e0c929",
+          "id": 4,
+          "name": "E",
+          "nameLocation": "23:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "indexed": true,
+                "mutability": "mutable",
+                "name": "sender",
+                "nameLocation": "41:6:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 4,
+                "src": "25:22:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_address",
+                  "typeString": "address"
+                },
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "25:7:1",
+                  "stateMutability": "nonpayable",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address",
+                    "typeString": "address"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "24:24:1"
+          },
+          "src": "17:32:1"
+        }
+      ],
+      "scope": 20,
+      "src": "0:51:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        4
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "D",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 19,
+      "linearizedBaseContracts":
+      [
+        19
+      ],
+      "name": "D",
+      "nameLocation": "61:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 17,
+            "nodeType": "Block",
+            "src": "106:37:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments":
+                  [
+                    {
+                      "expression":
+                      {
+                        "id": 13,
+                        "name": "msg",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "referencedDeclaration": -15,
+                        "src": "125:3:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_magic_message",
+                          "typeString": "msg"
+                        }
+                      },
+                      "id": 14,
+                      "isConstant": false,
+                      "isLValue": false,
+                      "isPure": false,
+                      "lValueRequested": false,
+                      "memberLocation": "129:6:1",
+                      "memberName": "sender",
+                      "nodeType": "MemberAccess",
+                      "src": "125:10:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_address",
+                        "typeString": "address"
+                      }
+                    }
+                  ],
+                  "expression":
+                  {
+                    "argumentTypes":
+                    [
+                      {
+                        "typeIdentifier": "t_address",
+                        "typeString": "address"
+                      }
+                    ],
+                    "expression":
+                    {
+                      "id": 10,
+                      "name": "C",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 5,
+                      "src": "121:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_type$_t_contract$_C_$5_$",
+                        "typeString": "type(contract C)"
+                      }
+                    },
+                    "id": 12,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "memberLocation": "123:1:1",
+                    "memberName": "E",
+                    "nodeType": "MemberAccess",
+                    "referencedDeclaration": 4,
+                    "src": "121:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_event_nonpayable$_t_address_$returns$__$",
+                      "typeString": "function (address)"
+                    }
+                  },
+                  "id": 15,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "121:15:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 16,
+                "nodeType": "EmitStatement",
+                "src": "116:20:1"
+              }
+            ]
+          },
+          "functionSelector": "bb29998e",
+          "id": 18,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "test",
+          "nameLocation": "78:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 7,
+                "mutability": "mutable",
+                "name": "sender",
+                "nameLocation": "91:6:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 18,
+                "src": "83:14:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_address",
+                  "typeString": "address"
+                },
+                "typeName":
+                {
+                  "id": 6,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "83:7:1",
+                  "stateMutability": "nonpayable",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_address",
+                    "typeString": "address"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "82:16:1"
+          },
+          "returnParameters":
+          {
+            "id": 9,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "106:0:1"
+          },
+          "scope": 19,
+          "src": "69:74:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 20,
+      "src": "52:93:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        4
+      ]
+    }
+  ],
+  "src": "0:146:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.sol b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.sol
new file mode 100644
index 00000000..6cad968f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract.sol
@@ -0,0 +1,10 @@
+contract C {
+    event E(address indexed sender);
+}
+contract D {
+    function test(address sender) public {
+        emit C.E(msg.sender);
+    }
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract_parseOnly.json b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract_parseOnly.json
new file mode 100644
index 00000000..b6c0ca5e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_emitted_from_foreign_contract_parseOnly.json
@@ -0,0 +1,194 @@
+{
+  "absolutePath": "a",
+  "id": 20,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "id": 4,
+          "name": "E",
+          "nameLocation": "23:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "indexed": true,
+                "mutability": "mutable",
+                "name": "sender",
+                "nameLocation": "41:6:1",
+                "nodeType": "VariableDeclaration",
+                "src": "25:22:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "25:7:1",
+                  "stateMutability": "nonpayable",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "24:24:1"
+          },
+          "src": "17:32:1"
+        }
+      ],
+      "src": "0:51:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 19,
+      "name": "D",
+      "nameLocation": "61:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 17,
+            "nodeType": "Block",
+            "src": "106:37:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments":
+                  [
+                    {
+                      "expression":
+                      {
+                        "id": 13,
+                        "name": "msg",
+                        "nodeType": "Identifier",
+                        "overloadedDeclarations": [],
+                        "src": "125:3:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 14,
+                      "memberLocation": "129:6:1",
+                      "memberName": "sender",
+                      "nodeType": "MemberAccess",
+                      "src": "125:10:1",
+                      "typeDescriptions": {}
+                    }
+                  ],
+                  "expression":
+                  {
+                    "expression":
+                    {
+                      "id": 10,
+                      "name": "C",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "121:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "id": 12,
+                    "memberLocation": "123:1:1",
+                    "memberName": "E",
+                    "nodeType": "MemberAccess",
+                    "src": "121:3:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 15,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "121:15:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 16,
+                "nodeType": "EmitStatement",
+                "src": "116:20:1"
+              }
+            ]
+          },
+          "id": 18,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "test",
+          "nameLocation": "78:4:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 7,
+                "mutability": "mutable",
+                "name": "sender",
+                "nameLocation": "91:6:1",
+                "nodeType": "VariableDeclaration",
+                "src": "83:14:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 6,
+                  "name": "address",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "83:7:1",
+                  "stateMutability": "nonpayable",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "82:16:1"
+          },
+          "returnParameters":
+          {
+            "id": 9,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "106:0:1"
+          },
+          "src": "69:74:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "52:93:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:146:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_inheritance.json b/compiler/test/libsolidity/ASTJSON/event_inheritance.json
new file mode 100644
index 00000000..afa79e91
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_inheritance.json
@@ -0,0 +1,194 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "B":
+    [
+      3
+    ],
+    "C":
+    [
+      8
+    ],
+    "D":
+    [
+      13
+    ]
+  },
+  "id": 14,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "interface",
+      "fullyImplemented": true,
+      "id": 3,
+      "linearizedBaseContracts":
+      [
+        3
+      ],
+      "name": "B",
+      "nameLocation": "10:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "dbec0351ad6bb0c1f07ea56e236e3e692fde2259f0165fd422f241da339b7e4f",
+          "id": 2,
+          "name": "EB",
+          "nameLocation": "24:2:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "26:2:1"
+          },
+          "src": "18:11:1"
+        }
+      ],
+      "scope": 14,
+      "src": "0:31:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 4,
+            "name": "B",
+            "nameLocations":
+            [
+              "46:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 3,
+            "src": "46:1:1"
+          },
+          "id": 5,
+          "nodeType": "InheritanceSpecifier",
+          "src": "46:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 8,
+      "linearizedBaseContracts":
+      [
+        8,
+        3
+      ],
+      "name": "C",
+      "nameLocation": "41:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "a08b3367d3fa83ea27f8951ffb5d9d160cbfadbd80816b47f677e7699d76f5a0",
+          "id": 7,
+          "name": "EC",
+          "nameLocation": "60:2:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "62:2:1"
+          },
+          "src": "54:11:1"
+        }
+      ],
+      "scope": 14,
+      "src": "32:35:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2,
+        7
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 9,
+            "name": "C",
+            "nameLocations":
+            [
+              "82:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 8,
+            "src": "82:1:1"
+          },
+          "id": 10,
+          "nodeType": "InheritanceSpecifier",
+          "src": "82:1:1"
+        }
+      ],
+      "canonicalName": "D",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 13,
+      "linearizedBaseContracts":
+      [
+        13,
+        8,
+        3
+      ],
+      "name": "D",
+      "nameLocation": "77:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "caa54b91a2314ab89b39714b1cd283762e53a2f59cfb997d6770e2824c39db0d",
+          "id": 12,
+          "name": "ED",
+          "nameLocation": "96:2:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "98:2:1"
+          },
+          "src": "90:11:1"
+        }
+      ],
+      "scope": 14,
+      "src": "68:35:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2,
+        7,
+        12
+      ]
+    }
+  ],
+  "src": "0:104:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/event_inheritance.sol b/compiler/test/libsolidity/ASTJSON/event_inheritance.sol
new file mode 100644
index 00000000..72687375
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_inheritance.sol
@@ -0,0 +1,11 @@
+interface B {
+    event EB();
+}
+contract C is B {
+    event EC();
+}
+contract D is C {
+    event ED();
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types.sol b/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types.sol
new file mode 100644
index 00000000..6fe58c39
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types.sol
@@ -0,0 +1,4 @@
+contract C {
+    event E(function() internal);
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types_parseOnly.json b/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types_parseOnly.json
new file mode 100644
index 00000000..3ff426cb
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/event_with_variables_of_internal_types_parseOnly.json
@@ -0,0 +1,79 @@
+{
+  "absolutePath": "a",
+  "id": 8,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 7,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "id": 6,
+          "name": "E",
+          "nameLocation": "23:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 5,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 4,
+                "indexed": false,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "src": "25:20:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 3,
+                  "nodeType": "FunctionTypeName",
+                  "parameterTypes":
+                  {
+                    "id": 1,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "33:2:1"
+                  },
+                  "returnParameterTypes":
+                  {
+                    "id": 2,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "44:0:1"
+                  },
+                  "src": "25:20:1",
+                  "stateMutability": "nonpayable",
+                  "typeDescriptions": {},
+                  "visibility": "internal"
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "24:21:1"
+          },
+          "src": "17:29:1"
+        }
+      ],
+      "src": "0:48:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:49:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fail_after_parsing.sol b/compiler/test/libsolidity/ASTJSON/fail_after_parsing.sol
new file mode 100644
index 00000000..882b4c95
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fail_after_parsing.sol
@@ -0,0 +1,15 @@
+function g() public;
+
+interface I {
+    struct S { S s; }
+
+    function f(E storage e) {
+        error E;
+        emit E();
+
+        ++c;
+        uint calldata c = 123.4;
+    }
+}
+// ----
+// failAfter: Parsed
diff --git a/compiler/test/libsolidity/ASTJSON/fail_after_parsing_parseOnly.json b/compiler/test/libsolidity/ASTJSON/fail_after_parsing_parseOnly.json
new file mode 100644
index 00000000..f1d95861
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fail_after_parsing_parseOnly.json
@@ -0,0 +1,297 @@
+{
+  "absolutePath": "a",
+  "id": 30,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 3,
+      "implemented": false,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "g",
+      "nameLocation": "9:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 1,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "10:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 2,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "19:0:1"
+      },
+      "src": "0:20:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "public"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "interface",
+      "id": 29,
+      "name": "I",
+      "nameLocation": "31:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 7,
+          "members":
+          [
+            {
+              "constant": false,
+              "id": 6,
+              "mutability": "mutable",
+              "name": "s",
+              "nameLocation": "52:1:1",
+              "nodeType": "VariableDeclaration",
+              "src": "50:3:1",
+              "stateVariable": false,
+              "storageLocation": "default",
+              "typeDescriptions": {},
+              "typeName":
+              {
+                "id": 5,
+                "nodeType": "UserDefinedTypeName",
+                "pathNode":
+                {
+                  "id": 4,
+                  "name": "S",
+                  "nameLocations":
+                  [
+                    "50:1:1"
+                  ],
+                  "nodeType": "IdentifierPath",
+                  "src": "50:1:1"
+                },
+                "src": "50:1:1",
+                "typeDescriptions": {}
+              },
+              "visibility": "internal"
+            }
+          ],
+          "name": "S",
+          "nameLocation": "46:1:1",
+          "nodeType": "StructDefinition",
+          "src": "39:17:1",
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 27,
+            "nodeType": "Block",
+            "src": "85:88:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  15
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 15,
+                    "mutability": "mutable",
+                    "name": "E",
+                    "nameLocation": "101:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "95:7:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 14,
+                      "nodeType": "UserDefinedTypeName",
+                      "pathNode":
+                      {
+                        "id": 13,
+                        "name": "error",
+                        "nameLocations":
+                        [
+                          "95:5:1"
+                        ],
+                        "nodeType": "IdentifierPath",
+                        "src": "95:5:1"
+                      },
+                      "src": "95:5:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 16,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "95:7:1"
+              },
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "id": 17,
+                    "name": "E",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "117:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 18,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "117:3:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 19,
+                "nodeType": "EmitStatement",
+                "src": "112:8:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 21,
+                  "nodeType": "UnaryOperation",
+                  "operator": "++",
+                  "prefix": true,
+                  "src": "130:3:1",
+                  "subExpression":
+                  {
+                    "id": 20,
+                    "name": "c",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "132:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "typeDescriptions": {}
+                },
+                "id": 22,
+                "nodeType": "ExpressionStatement",
+                "src": "130:3:1"
+              },
+              {
+                "assignments":
+                [
+                  24
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 24,
+                    "mutability": "mutable",
+                    "name": "c",
+                    "nameLocation": "157:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "143:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "calldata",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 23,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "143:4:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 26,
+                "initialValue":
+                {
+                  "hexValue": "3132332e34",
+                  "id": 25,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "161:5:1",
+                  "typeDescriptions": {},
+                  "value": "123.4"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "143:23:1"
+              }
+            ]
+          },
+          "id": 28,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "70:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 10,
+                "mutability": "mutable",
+                "name": "e",
+                "nameLocation": "82:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "72:11:1",
+                "stateVariable": false,
+                "storageLocation": "storage",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 9,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 8,
+                    "name": "E",
+                    "nameLocations":
+                    [
+                      "72:1:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "src": "72:1:1"
+                  },
+                  "src": "72:1:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "71:13:1"
+          },
+          "returnParameters":
+          {
+            "id": 12,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "85:0:1"
+          },
+          "src": "61:112:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "21:154:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:176:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback.json b/compiler/test/libsolidity/ASTJSON/fallback.json
new file mode 100644
index 00000000..f68c72ce
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback.json
@@ -0,0 +1,74 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "43:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "43:0:1"
+          },
+          "scope": 5,
+          "src": "15:33:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "scope": 6,
+      "src": "0:50:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:51:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback.sol b/compiler/test/libsolidity/ASTJSON/fallback.sol
new file mode 100644
index 00000000..170e7795
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback.sol
@@ -0,0 +1,5 @@
+contract C {
+  fallback() external payable {
+  }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.json b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.json
new file mode 100644
index 00000000..f41559d2
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.json
@@ -0,0 +1,109 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      9
+    ]
+  },
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 9,
+      "linearizedBaseContracts":
+      [
+        9
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "42:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "receive",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 9,
+          "src": "15:32:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "78:5:1",
+            "statements": []
+          },
+          "id": 8,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 5,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "58:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "78:0:1"
+          },
+          "scope": 9,
+          "src": "50:33:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "scope": 10,
+      "src": "0:85:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:86:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.sol b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.sol
new file mode 100644
index 00000000..7eb71258
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether.sol
@@ -0,0 +1,7 @@
+contract C {
+  receive() external payable {
+  }
+  fallback() external payable {
+  }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether_parseOnly.json b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether_parseOnly.json
new file mode 100644
index 00000000..215bf3a8
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_and_receive_ether_parseOnly.json
@@ -0,0 +1,93 @@
+{
+  "absolutePath": "a",
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 9,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "42:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "receive",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "15:32:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        },
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "78:5:1",
+            "statements": []
+          },
+          "id": 8,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 5,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "58:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "78:0:1"
+          },
+          "src": "50:33:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "src": "0:85:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:86:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_parseOnly.json b/compiler/test/libsolidity/ASTJSON/fallback_parseOnly.json
new file mode 100644
index 00000000..eb81fafb
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_parseOnly.json
@@ -0,0 +1,59 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "43:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "43:0:1"
+          },
+          "src": "15:33:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "src": "0:50:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:51:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_payable.json b/compiler/test/libsolidity/ASTJSON/fallback_payable.json
new file mode 100644
index 00000000..79035176
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_payable.json
@@ -0,0 +1,74 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "34:2:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "34:0:1"
+          },
+          "scope": 5,
+          "src": "14:22:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "scope": 6,
+      "src": "0:38:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:39:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_payable.sol b/compiler/test/libsolidity/ASTJSON/fallback_payable.sol
new file mode 100644
index 00000000..7eff747a
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_payable.sol
@@ -0,0 +1,4 @@
+contract C {
+	fallback() external {}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/fallback_payable_parseOnly.json b/compiler/test/libsolidity/ASTJSON/fallback_payable_parseOnly.json
new file mode 100644
index 00000000..e1810828
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/fallback_payable_parseOnly.json
@@ -0,0 +1,59 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "34:2:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "fallback",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "34:0:1"
+          },
+          "src": "14:22:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "src": "0:38:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:39:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/function_type.json b/compiler/test/libsolidity/ASTJSON/function_type.json
new file mode 100644
index 00000000..e1a5156c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/function_type.json
@@ -0,0 +1,233 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      17
+    ]
+  },
+  "id": 18,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 17,
+      "linearizedBaseContracts":
+      [
+        17
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 15,
+            "nodeType": "Block",
+            "src": "127:2:1",
+            "statements": []
+          },
+          "functionSelector": "d6cd4974",
+          "id": 16,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "67:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 16,
+                "src": "24:44:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_function_external_payable$__$returns$_t_uint256_$",
+                  "typeString": "function () payable external returns (uint256)"
+                },
+                "typeName":
+                {
+                  "id": 5,
+                  "nodeType": "FunctionTypeName",
+                  "parameterTypes":
+                  {
+                    "id": 1,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "32:2:1"
+                  },
+                  "returnParameterTypes":
+                  {
+                    "id": 4,
+                    "nodeType": "ParameterList",
+                    "parameters":
+                    [
+                      {
+                        "constant": false,
+                        "id": 3,
+                        "mutability": "mutable",
+                        "name": "",
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 5,
+                        "src": "61:4:1",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        },
+                        "typeName":
+                        {
+                          "id": 2,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "61:4:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          }
+                        },
+                        "visibility": "internal"
+                      }
+                    ],
+                    "src": "60:6:1"
+                  },
+                  "src": "24:44:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_external_payable$__$returns$_t_uint256_$",
+                    "typeString": "function () payable external returns (uint256)"
+                  },
+                  "visibility": "external"
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:46:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 13,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "scope": 16,
+                "src": "86:40:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                  "typeString": "function () view external returns (uint256)"
+                },
+                "typeName":
+                {
+                  "id": 12,
+                  "nodeType": "FunctionTypeName",
+                  "parameterTypes":
+                  {
+                    "id": 8,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "94:2:1"
+                  },
+                  "returnParameterTypes":
+                  {
+                    "id": 11,
+                    "nodeType": "ParameterList",
+                    "parameters":
+                    [
+                      {
+                        "constant": false,
+                        "id": 10,
+                        "mutability": "mutable",
+                        "name": "",
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "VariableDeclaration",
+                        "scope": 12,
+                        "src": "120:4:1",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        },
+                        "typeName":
+                        {
+                          "id": 9,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "120:4:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          }
+                        },
+                        "visibility": "internal"
+                      }
+                    ],
+                    "src": "119:6:1"
+                  },
+                  "src": "86:40:1",
+                  "stateMutability": "view",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$",
+                    "typeString": "function () view external returns (uint256)"
+                  },
+                  "visibility": "external"
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "85:41:1"
+          },
+          "scope": 17,
+          "src": "13:116:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 18,
+      "src": "0:131:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:132:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/function_type_parseOnly.json b/compiler/test/libsolidity/ASTJSON/function_type_parseOnly.json
new file mode 100644
index 00000000..64b09d5d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/function_type_parseOnly.json
@@ -0,0 +1,181 @@
+{
+  "absolutePath": "a",
+  "id": 18,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 17,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 15,
+            "nodeType": "Block",
+            "src": "127:2:1",
+            "statements": []
+          },
+          "id": 16,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 6,
+                "mutability": "mutable",
+                "name": "x",
+                "nameLocation": "67:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "24:44:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 5,
+                  "nodeType": "FunctionTypeName",
+                  "parameterTypes":
+                  {
+                    "id": 1,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "32:2:1"
+                  },
+                  "returnParameterTypes":
+                  {
+                    "id": 4,
+                    "nodeType": "ParameterList",
+                    "parameters":
+                    [
+                      {
+                        "constant": false,
+                        "id": 3,
+                        "mutability": "mutable",
+                        "name": "",
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "VariableDeclaration",
+                        "src": "61:4:1",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {},
+                        "typeName":
+                        {
+                          "id": 2,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "61:4:1",
+                          "typeDescriptions": {}
+                        },
+                        "visibility": "internal"
+                      }
+                    ],
+                    "src": "60:6:1"
+                  },
+                  "src": "24:44:1",
+                  "stateMutability": "payable",
+                  "typeDescriptions": {},
+                  "visibility": "external"
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:46:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 13,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "src": "86:40:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 12,
+                  "nodeType": "FunctionTypeName",
+                  "parameterTypes":
+                  {
+                    "id": 8,
+                    "nodeType": "ParameterList",
+                    "parameters": [],
+                    "src": "94:2:1"
+                  },
+                  "returnParameterTypes":
+                  {
+                    "id": 11,
+                    "nodeType": "ParameterList",
+                    "parameters":
+                    [
+                      {
+                        "constant": false,
+                        "id": 10,
+                        "mutability": "mutable",
+                        "name": "",
+                        "nameLocation": "-1:-1:-1",
+                        "nodeType": "VariableDeclaration",
+                        "src": "120:4:1",
+                        "stateVariable": false,
+                        "storageLocation": "default",
+                        "typeDescriptions": {},
+                        "typeName":
+                        {
+                          "id": 9,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "120:4:1",
+                          "typeDescriptions": {}
+                        },
+                        "visibility": "internal"
+                      }
+                    ],
+                    "src": "119:6:1"
+                  },
+                  "src": "86:40:1",
+                  "stateMutability": "view",
+                  "typeDescriptions": {},
+                  "visibility": "external"
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "85:41:1"
+          },
+          "src": "13:116:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:131:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:132:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/indirect_event.json b/compiler/test/libsolidity/ASTJSON/indirect_event.json
new file mode 100644
index 00000000..fcbe8175
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/indirect_event.json
@@ -0,0 +1,319 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      25
+    ],
+    "L":
+    [
+      10
+    ]
+  },
+  "id": 26,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "L",
+      "contractDependencies": [],
+      "contractKind": "library",
+      "fullyImplemented": true,
+      "id": 10,
+      "linearizedBaseContracts":
+      [
+        10
+      ],
+      "name": "L",
+      "nameLocation": "44:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028",
+          "id": 2,
+          "name": "E",
+          "nameLocation": "58:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "59:2:1"
+          },
+          "src": "52:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 8,
+            "nodeType": "Block",
+            "src": "89:13:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 5,
+                    "name": "E",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 2,
+                    "src": "96:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 6,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "96:3:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 7,
+                "nodeType": "EmitStatement",
+                "src": "91:8:1"
+              }
+            ]
+          },
+          "id": 9,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "77:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "89:0:1"
+          },
+          "scope": 10,
+          "src": "67:35:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "scope": 26,
+      "src": "36:68:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2
+      ]
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 25,
+      "linearizedBaseContracts":
+      [
+        25
+      ],
+      "name": "C",
+      "nameLocation": "114:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "eventSelector": "70a5d861ef9816388422765f41d618eb3abdf490acb37354b539729e37b09f0e",
+          "id": 12,
+          "name": "H",
+          "nameLocation": "128:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "129:2:1"
+          },
+          "src": "122:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 23,
+            "nodeType": "Block",
+            "src": "157:20:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "expression":
+                    {
+                      "id": 15,
+                      "name": "L",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 10,
+                      "src": "159:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_type$_t_contract$_L_$10_$",
+                        "typeString": "type(library L)"
+                      }
+                    },
+                    "id": 17,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "memberLocation": "161:1:1",
+                    "memberName": "f",
+                    "nodeType": "MemberAccess",
+                    "referencedDeclaration": 9,
+                    "src": "159:3:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 18,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "159:5:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 19,
+                "nodeType": "ExpressionStatement",
+                "src": "159:5:1"
+              },
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 20,
+                    "name": "H",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 12,
+                    "src": "171:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
+                      "typeString": "function ()"
+                    }
+                  },
+                  "id": 21,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "171:3:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 22,
+                "nodeType": "EmitStatement",
+                "src": "166:8:1"
+              }
+            ]
+          },
+          "functionSelector": "e2179b8e",
+          "id": 24,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "146:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "147:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "157:0:1"
+          },
+          "scope": 25,
+          "src": "137:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 26,
+      "src": "105:74:1",
+      "usedErrors": [],
+      "usedEvents":
+      [
+        2,
+        12
+      ]
+    }
+  ],
+  "src": "36:144:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/indirect_event.sol b/compiler/test/libsolidity/ASTJSON/indirect_event.sol
new file mode 100644
index 00000000..c4bba01c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/indirect_event.sol
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0
+library L {
+    event E();
+    function f() internal { emit E(); }
+}
+contract C {
+    event H();
+    function g() public { L.f(); emit H(); }
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/indirect_event_parseOnly.json b/compiler/test/libsolidity/ASTJSON/indirect_event_parseOnly.json
new file mode 100644
index 00000000..17ca036d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/indirect_event_parseOnly.json
@@ -0,0 +1,228 @@
+{
+  "absolutePath": "a",
+  "id": 26,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "library",
+      "id": 10,
+      "name": "L",
+      "nameLocation": "44:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "id": 2,
+          "name": "E",
+          "nameLocation": "58:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "59:2:1"
+          },
+          "src": "52:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 8,
+            "nodeType": "Block",
+            "src": "89:13:1",
+            "statements":
+            [
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "id": 5,
+                    "name": "E",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "96:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 6,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "96:3:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 7,
+                "nodeType": "EmitStatement",
+                "src": "91:8:1"
+              }
+            ]
+          },
+          "id": 9,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "77:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "89:0:1"
+          },
+          "src": "67:35:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "src": "36:68:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 25,
+      "name": "C",
+      "nameLocation": "114:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "anonymous": false,
+          "id": 12,
+          "name": "H",
+          "nameLocation": "128:1:1",
+          "nodeType": "EventDefinition",
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "129:2:1"
+          },
+          "src": "122:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 23,
+            "nodeType": "Block",
+            "src": "157:20:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "expression":
+                    {
+                      "id": 15,
+                      "name": "L",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "src": "159:1:1",
+                      "typeDescriptions": {}
+                    },
+                    "id": 17,
+                    "memberLocation": "161:1:1",
+                    "memberName": "f",
+                    "nodeType": "MemberAccess",
+                    "src": "159:3:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 18,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "159:5:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 19,
+                "nodeType": "ExpressionStatement",
+                "src": "159:5:1"
+              },
+              {
+                "eventCall":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "id": 20,
+                    "name": "H",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "171:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 21,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "171:3:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 22,
+                "nodeType": "EmitStatement",
+                "src": "166:8:1"
+              }
+            ]
+          },
+          "id": 24,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "g",
+          "nameLocation": "146:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "147:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 14,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "157:0:1"
+          },
+          "src": "137:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "105:74:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "36:144:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/inheritance_specifier.json b/compiler/test/libsolidity/ASTJSON/inheritance_specifier.json
new file mode 100644
index 00000000..ae210c94
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/inheritance_specifier.json
@@ -0,0 +1,82 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C1":
+    [
+      1
+    ],
+    "C2":
+    [
+      4
+    ]
+  },
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C1",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 1,
+      "linearizedBaseContracts":
+      [
+        1
+      ],
+      "name": "C1",
+      "nameLocation": "9:2:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 5,
+      "src": "0:14:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 2,
+            "name": "C1",
+            "nameLocations":
+            [
+              "30:2:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 1,
+            "src": "30:2:1"
+          },
+          "id": 3,
+          "nodeType": "InheritanceSpecifier",
+          "src": "30:2:1"
+        }
+      ],
+      "canonicalName": "C2",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 4,
+      "linearizedBaseContracts":
+      [
+        4,
+        1
+      ],
+      "name": "C2",
+      "nameLocation": "24:2:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 5,
+      "src": "15:20:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:36:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/inheritance_specifier_parseOnly.json b/compiler/test/libsolidity/ASTJSON/inheritance_specifier_parseOnly.json
new file mode 100644
index 00000000..171391b3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/inheritance_specifier_parseOnly.json
@@ -0,0 +1,55 @@
+{
+  "absolutePath": "a",
+  "id": 5,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 1,
+      "name": "C1",
+      "nameLocation": "9:2:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "0:14:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 2,
+            "name": "C1",
+            "nameLocations":
+            [
+              "30:2:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "30:2:1"
+          },
+          "id": 3,
+          "nodeType": "InheritanceSpecifier",
+          "src": "30:2:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 4,
+      "name": "C2",
+      "nameLocation": "24:2:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "15:20:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:36:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/license.json b/compiler/test/libsolidity/ASTJSON/license.json
new file mode 100644
index 00000000..4c088263
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/license.json
@@ -0,0 +1,38 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      1
+    ]
+  },
+  "id": 2,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 1,
+      "linearizedBaseContracts":
+      [
+        1
+      ],
+      "name": "C",
+      "nameLocation": "45:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 2,
+      "src": "36:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "36:14:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/license_parseOnly.json b/compiler/test/libsolidity/ASTJSON/license_parseOnly.json
new file mode 100644
index 00000000..f2958f15
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/license_parseOnly.json
@@ -0,0 +1,24 @@
+{
+  "absolutePath": "a",
+  "id": 2,
+  "license": "GPL-3.0",
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 1,
+      "name": "C",
+      "nameLocation": "45:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "36:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "36:14:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation.json b/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation.json
new file mode 100644
index 00000000..9bcd5e8f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation.json
@@ -0,0 +1,176 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "c":
+    [
+      11
+    ]
+  },
+  "id": 12,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "c",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 11,
+      "linearizedBaseContracts":
+      [
+        11
+      ],
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 9,
+            "nodeType": "Block",
+            "src": "33:19:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "a",
+                    "nameLocation": "40:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 9,
+                    "src": "35:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:4:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 8,
+                "initialValue":
+                {
+                  "commonType":
+                  {
+                    "typeIdentifier": "t_rational_5_by_1",
+                    "typeString": "int_const 5"
+                  },
+                  "id": 7,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "lValueRequested": false,
+                  "leftExpression":
+                  {
+                    "hexValue": "32",
+                    "id": 5,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "44:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_2_by_1",
+                      "typeString": "int_const 2"
+                    },
+                    "value": "2"
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "+",
+                  "rightExpression":
+                  {
+                    "hexValue": "33",
+                    "id": 6,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "kind": "number",
+                    "lValueRequested": false,
+                    "nodeType": "Literal",
+                    "src": "48:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_rational_3_by_1",
+                      "typeString": "int_const 3"
+                    },
+                    "value": "3"
+                  },
+                  "src": "44:5:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_5_by_1",
+                    "typeString": "int_const 5"
+                  }
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:14:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 10,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 11,
+          "src": "13:39:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 12,
+      "src": "0:54:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:55:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation_parseOnly.json b/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation_parseOnly.json
new file mode 100644
index 00000000..2cb372dd
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/long_type_name_binary_operation_parseOnly.json
@@ -0,0 +1,123 @@
+{
+  "absolutePath": "a",
+  "id": 12,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 11,
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 9,
+            "nodeType": "Block",
+            "src": "33:19:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "a",
+                    "nameLocation": "40:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:4:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 8,
+                "initialValue":
+                {
+                  "commonType": {},
+                  "id": 7,
+                  "leftExpression":
+                  {
+                    "hexValue": "32",
+                    "id": 5,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "44:1:1",
+                    "typeDescriptions": {},
+                    "value": "2"
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "+",
+                  "rightExpression":
+                  {
+                    "hexValue": "33",
+                    "id": 6,
+                    "kind": "number",
+                    "nodeType": "Literal",
+                    "src": "48:1:1",
+                    "typeDescriptions": {},
+                    "value": "3"
+                  },
+                  "src": "44:5:1",
+                  "typeDescriptions": {}
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:14:1"
+              }
+            ]
+          },
+          "id": 10,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:39:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:54:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:55:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/long_type_name_identifier.json b/compiler/test/libsolidity/ASTJSON/long_type_name_identifier.json
new file mode 100644
index 00000000..c22aeb40
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/long_type_name_identifier.json
@@ -0,0 +1,185 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "c":
+    [
+      15
+    ]
+  },
+  "id": 16,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "c",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 15,
+      "linearizedBaseContracts":
+      [
+        15
+      ],
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "20:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 15,
+          "src": "13:8:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_array$_t_uint256_$dyn_storage",
+            "typeString": "uint256[]"
+          },
+          "typeName":
+          {
+            "baseType":
+            {
+              "id": 1,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "13:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_uint256",
+                "typeString": "uint256"
+              }
+            },
+            "id": 2,
+            "nodeType": "ArrayTypeName",
+            "src": "13:6:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+              "typeString": "uint256[]"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 13,
+            "nodeType": "Block",
+            "src": "43:25:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  10
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 10,
+                    "mutability": "mutable",
+                    "name": "b",
+                    "nameLocation": "60:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 13,
+                    "src": "45:16:1",
+                    "stateVariable": false,
+                    "storageLocation": "storage",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+                      "typeString": "uint256[]"
+                    },
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "id": 8,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "45:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "id": 9,
+                      "nodeType": "ArrayTypeName",
+                      "src": "45:6:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+                        "typeString": "uint256[]"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 12,
+                "initialValue":
+                {
+                  "id": 11,
+                  "name": "a",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "referencedDeclaration": 3,
+                  "src": "64:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_array$_t_uint256_$dyn_storage",
+                    "typeString": "uint256[] storage ref"
+                  }
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "45:20:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 14,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "32:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 5,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "43:0:1"
+          },
+          "scope": 15,
+          "src": "23:45:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 16,
+      "src": "0:70:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:71:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/long_type_name_identifier_parseOnly.json b/compiler/test/libsolidity/ASTJSON/long_type_name_identifier_parseOnly.json
new file mode 100644
index 00000000..1bf50bed
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/long_type_name_identifier_parseOnly.json
@@ -0,0 +1,138 @@
+{
+  "absolutePath": "a",
+  "id": 16,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 15,
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "20:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "13:8:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "baseType":
+            {
+              "id": 1,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "13:4:1",
+              "typeDescriptions": {}
+            },
+            "id": 2,
+            "nodeType": "ArrayTypeName",
+            "src": "13:6:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 13,
+            "nodeType": "Block",
+            "src": "43:25:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  10
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 10,
+                    "mutability": "mutable",
+                    "name": "b",
+                    "nameLocation": "60:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "45:16:1",
+                    "stateVariable": false,
+                    "storageLocation": "storage",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "id": 8,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "45:4:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 9,
+                      "nodeType": "ArrayTypeName",
+                      "src": "45:6:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 12,
+                "initialValue":
+                {
+                  "id": 11,
+                  "name": "a",
+                  "nodeType": "Identifier",
+                  "overloadedDeclarations": [],
+                  "src": "64:1:1",
+                  "typeDescriptions": {}
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "45:20:1"
+              }
+            ]
+          },
+          "id": 14,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "32:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 4,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 5,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "43:0:1"
+          },
+          "src": "23:45:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:70:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:71:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/mappings.json b/compiler/test/libsolidity/ASTJSON/mappings.json
new file mode 100644
index 00000000..81bf19db
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mappings.json
@@ -0,0 +1,323 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      23
+    ]
+  },
+  "id": 24,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 23,
+      "linearizedBaseContracts":
+      [
+        23
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "canonicalName": "C.E",
+          "id": 4,
+          "members":
+          [
+            {
+              "id": 1,
+              "name": "A",
+              "nameLocation": "26:1:1",
+              "nodeType": "EnumValue",
+              "src": "26:1:1"
+            },
+            {
+              "id": 2,
+              "name": "B",
+              "nameLocation": "29:1:1",
+              "nodeType": "EnumValue",
+              "src": "29:1:1"
+            },
+            {
+              "id": 3,
+              "name": "C",
+              "nameLocation": "32:1:1",
+              "nodeType": "EnumValue",
+              "src": "32:1:1"
+            }
+          ],
+          "name": "E",
+          "nameLocation": "22:1:1",
+          "nodeType": "EnumDefinition",
+          "src": "17:18:1"
+        },
+        {
+          "constant": false,
+          "id": 9,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "59:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 23,
+          "src": "40:20:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_contract$_C_$23_$_t_bool_$",
+            "typeString": "mapping(contract C => bool)"
+          },
+          "typeName":
+          {
+            "id": 8,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 6,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 5,
+                "name": "C",
+                "nameLocations":
+                [
+                  "48:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 23,
+                "src": "48:1:1"
+              },
+              "referencedDeclaration": 23,
+              "src": "48:1:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_contract$_C_$23",
+                "typeString": "contract C"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "40:18:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_contract$_C_$23_$_t_bool_$",
+              "typeString": "mapping(contract C => bool)"
+            },
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 7,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "53:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_bool",
+                "typeString": "bool"
+              }
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 13,
+          "mutability": "mutable",
+          "name": "b",
+          "nameLocation": "91:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 23,
+          "src": "66:26:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+            "typeString": "mapping(address => bool)"
+          },
+          "typeName":
+          {
+            "id": 12,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 10,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "74:7:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_address",
+                "typeString": "address"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "66:24:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_address_$_t_bool_$",
+              "typeString": "mapping(address => bool)"
+            },
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 11,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "85:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_bool",
+                "typeString": "bool"
+              }
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 18,
+          "mutability": "mutable",
+          "name": "c",
+          "nameLocation": "117:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 23,
+          "src": "98:20:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_enum$_E_$4_$_t_bool_$",
+            "typeString": "mapping(enum C.E => bool)"
+          },
+          "typeName":
+          {
+            "id": 17,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 15,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 14,
+                "name": "E",
+                "nameLocations":
+                [
+                  "106:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 4,
+                "src": "106:1:1"
+              },
+              "referencedDeclaration": 4,
+              "src": "106:1:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_enum$_E_$4",
+                "typeString": "enum C.E"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "98:18:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_enum$_E_$4_$_t_bool_$",
+              "typeString": "mapping(enum C.E => bool)"
+            },
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 16,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "111:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_bool",
+                "typeString": "bool"
+              }
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 22,
+          "mutability": "mutable",
+          "name": "d",
+          "nameLocation": "169:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 23,
+          "src": "124:46:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_address_$_t_uint256_$",
+            "typeString": "mapping(address => uint256)"
+          },
+          "typeName":
+          {
+            "id": 21,
+            "keyName": "keyAddress",
+            "keyNameLocation": "140:10:1",
+            "keyType":
+            {
+              "id": 19,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "132:7:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_address",
+                "typeString": "address"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "124:44:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_address_$_t_uint256_$",
+              "typeString": "mapping(address => uint256)"
+            },
+            "valueName": "value",
+            "valueNameLocation": "162:5:1",
+            "valueType":
+            {
+              "id": 20,
+              "name": "uint256",
+              "nodeType": "ElementaryTypeName",
+              "src": "154:7:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_uint256",
+                "typeString": "uint256"
+              }
+            }
+          },
+          "visibility": "internal"
+        }
+      ],
+      "scope": 24,
+      "src": "0:173:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:174:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/mappings.sol b/compiler/test/libsolidity/ASTJSON/mappings.sol
new file mode 100644
index 00000000..5412ca60
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mappings.sol
@@ -0,0 +1,8 @@
+contract C {
+    enum E { A, B, C }
+    mapping(C => bool) a;
+    mapping(address => bool) b;
+    mapping(E => bool) c;
+    mapping(address keyAddress => uint256 value) d;
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/mappings_parseOnly.json b/compiler/test/libsolidity/ASTJSON/mappings_parseOnly.json
new file mode 100644
index 00000000..84cfb400
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mappings_parseOnly.json
@@ -0,0 +1,236 @@
+{
+  "absolutePath": "a",
+  "id": 24,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 23,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 4,
+          "members":
+          [
+            {
+              "id": 1,
+              "name": "A",
+              "nameLocation": "26:1:1",
+              "nodeType": "EnumValue",
+              "src": "26:1:1"
+            },
+            {
+              "id": 2,
+              "name": "B",
+              "nameLocation": "29:1:1",
+              "nodeType": "EnumValue",
+              "src": "29:1:1"
+            },
+            {
+              "id": 3,
+              "name": "C",
+              "nameLocation": "32:1:1",
+              "nodeType": "EnumValue",
+              "src": "32:1:1"
+            }
+          ],
+          "name": "E",
+          "nameLocation": "22:1:1",
+          "nodeType": "EnumDefinition",
+          "src": "17:18:1"
+        },
+        {
+          "constant": false,
+          "id": 9,
+          "mutability": "mutable",
+          "name": "a",
+          "nameLocation": "59:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "40:20:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 8,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 6,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 5,
+                "name": "C",
+                "nameLocations":
+                [
+                  "48:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "48:1:1"
+              },
+              "src": "48:1:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "40:18:1",
+            "typeDescriptions": {},
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 7,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "53:4:1",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 13,
+          "mutability": "mutable",
+          "name": "b",
+          "nameLocation": "91:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "66:26:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 12,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 10,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "74:7:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "66:24:1",
+            "typeDescriptions": {},
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 11,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "85:4:1",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 18,
+          "mutability": "mutable",
+          "name": "c",
+          "nameLocation": "117:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "98:20:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 17,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 15,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 14,
+                "name": "E",
+                "nameLocations":
+                [
+                  "106:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "106:1:1"
+              },
+              "src": "106:1:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "98:18:1",
+            "typeDescriptions": {},
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 16,
+              "name": "bool",
+              "nodeType": "ElementaryTypeName",
+              "src": "111:4:1",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 22,
+          "mutability": "mutable",
+          "name": "d",
+          "nameLocation": "169:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "124:46:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 21,
+            "keyName": "keyAddress",
+            "keyNameLocation": "140:10:1",
+            "keyType":
+            {
+              "id": 19,
+              "name": "address",
+              "nodeType": "ElementaryTypeName",
+              "src": "132:7:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "124:44:1",
+            "typeDescriptions": {},
+            "valueName": "value",
+            "valueNameLocation": "162:5:1",
+            "valueType":
+            {
+              "id": 20,
+              "name": "uint256",
+              "nodeType": "ElementaryTypeName",
+              "src": "154:7:1",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "internal"
+        }
+      ],
+      "src": "0:173:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:174:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/modifier_definition.json b/compiler/test/libsolidity/ASTJSON/modifier_definition.json
new file mode 100644
index 00000000..30ebcb7c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/modifier_definition.json
@@ -0,0 +1,177 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      14
+    ]
+  },
+  "id": 15,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 14,
+      "linearizedBaseContracts":
+      [
+        14
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "32:6:1",
+            "statements":
+            [
+              {
+                "id": 4,
+                "nodeType": "PlaceholderStatement",
+                "src": "34:1:1"
+              }
+            ]
+          },
+          "id": 6,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "i",
+                "nameLocation": "29:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 6,
+                "src": "24:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "24:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:8:1"
+          },
+          "src": "13:25:1",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 12,
+            "nodeType": "Block",
+            "src": "64:2:1",
+            "statements": []
+          },
+          "functionSelector": "28811f59",
+          "id": 13,
+          "implemented": true,
+          "kind": "function",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "31",
+                  "id": 9,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "number",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "54:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_1_by_1",
+                    "typeString": "int_const 1"
+                  },
+                  "value": "1"
+                }
+              ],
+              "id": 10,
+              "kind": "modifierInvocation",
+              "modifierName":
+              {
+                "id": 8,
+                "name": "M",
+                "nameLocations":
+                [
+                  "52:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 6,
+                "src": "52:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "52:4:1"
+            }
+          ],
+          "name": "F",
+          "nameLocation": "48:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "64:0:1"
+          },
+          "scope": 14,
+          "src": "39:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 15,
+      "src": "0:68:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:69:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/modifier_definition_parseOnly.json b/compiler/test/libsolidity/ASTJSON/modifier_definition_parseOnly.json
new file mode 100644
index 00000000..f8067952
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/modifier_definition_parseOnly.json
@@ -0,0 +1,142 @@
+{
+  "absolutePath": "a",
+  "id": 15,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 14,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "32:6:1",
+            "statements":
+            [
+              {
+                "id": 4,
+                "nodeType": "PlaceholderStatement",
+                "src": "34:1:1"
+              }
+            ]
+          },
+          "id": 6,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "i",
+                "nameLocation": "29:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "24:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "24:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:8:1"
+          },
+          "src": "13:25:1",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 12,
+            "nodeType": "Block",
+            "src": "64:2:1",
+            "statements": []
+          },
+          "id": 13,
+          "implemented": true,
+          "kind": "function",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "31",
+                  "id": 9,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "54:1:1",
+                  "typeDescriptions": {},
+                  "value": "1"
+                }
+              ],
+              "id": 10,
+              "modifierName":
+              {
+                "id": 8,
+                "name": "M",
+                "nameLocations":
+                [
+                  "52:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "52:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "52:4:1"
+            }
+          ],
+          "name": "F",
+          "nameLocation": "48:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "64:0:1"
+          },
+          "src": "39:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:68:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:69:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/modifier_invocation.json b/compiler/test/libsolidity/ASTJSON/modifier_invocation.json
new file mode 100644
index 00000000..30ebcb7c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/modifier_invocation.json
@@ -0,0 +1,177 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      14
+    ]
+  },
+  "id": 15,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 14,
+      "linearizedBaseContracts":
+      [
+        14
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "32:6:1",
+            "statements":
+            [
+              {
+                "id": 4,
+                "nodeType": "PlaceholderStatement",
+                "src": "34:1:1"
+              }
+            ]
+          },
+          "id": 6,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "i",
+                "nameLocation": "29:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 6,
+                "src": "24:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_uint256",
+                  "typeString": "uint256"
+                },
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "24:4:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:8:1"
+          },
+          "src": "13:25:1",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 12,
+            "nodeType": "Block",
+            "src": "64:2:1",
+            "statements": []
+          },
+          "functionSelector": "28811f59",
+          "id": 13,
+          "implemented": true,
+          "kind": "function",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "31",
+                  "id": 9,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "number",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "54:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_1_by_1",
+                    "typeString": "int_const 1"
+                  },
+                  "value": "1"
+                }
+              ],
+              "id": 10,
+              "kind": "modifierInvocation",
+              "modifierName":
+              {
+                "id": 8,
+                "name": "M",
+                "nameLocations":
+                [
+                  "52:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 6,
+                "src": "52:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "52:4:1"
+            }
+          ],
+          "name": "F",
+          "nameLocation": "48:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "64:0:1"
+          },
+          "scope": 14,
+          "src": "39:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 15,
+      "src": "0:68:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:69:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/modifier_invocation_parseOnly.json b/compiler/test/libsolidity/ASTJSON/modifier_invocation_parseOnly.json
new file mode 100644
index 00000000..f8067952
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/modifier_invocation_parseOnly.json
@@ -0,0 +1,142 @@
+{
+  "absolutePath": "a",
+  "id": 15,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 14,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 5,
+            "nodeType": "Block",
+            "src": "32:6:1",
+            "statements":
+            [
+              {
+                "id": 4,
+                "nodeType": "PlaceholderStatement",
+                "src": "34:1:1"
+              }
+            ]
+          },
+          "id": 6,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 3,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 2,
+                "mutability": "mutable",
+                "name": "i",
+                "nameLocation": "29:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "24:6:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 1,
+                  "name": "uint",
+                  "nodeType": "ElementaryTypeName",
+                  "src": "24:4:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "23:8:1"
+          },
+          "src": "13:25:1",
+          "virtual": false,
+          "visibility": "internal"
+        },
+        {
+          "body":
+          {
+            "id": 12,
+            "nodeType": "Block",
+            "src": "64:2:1",
+            "statements": []
+          },
+          "id": 13,
+          "implemented": true,
+          "kind": "function",
+          "modifiers":
+          [
+            {
+              "arguments":
+              [
+                {
+                  "hexValue": "31",
+                  "id": 9,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "54:1:1",
+                  "typeDescriptions": {},
+                  "value": "1"
+                }
+              ],
+              "id": 10,
+              "modifierName":
+              {
+                "id": 8,
+                "name": "M",
+                "nameLocations":
+                [
+                  "52:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "52:1:1"
+              },
+              "nodeType": "ModifierInvocation",
+              "src": "52:4:1"
+            }
+          ],
+          "name": "F",
+          "nameLocation": "48:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "49:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "64:0:1"
+          },
+          "src": "39:27:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:68:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:69:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/mutability.json b/compiler/test/libsolidity/ASTJSON/mutability.json
new file mode 100644
index 00000000..b6318d84
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mutability.json
@@ -0,0 +1,186 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      10
+    ]
+  },
+  "id": 11,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 10,
+      "linearizedBaseContracts":
+      [
+        10
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "functionSelector": "0dbe671f",
+          "id": 3,
+          "mutability": "immutable",
+          "name": "a",
+          "nameLocation": "39:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 10,
+          "src": "17:27:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 1,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "17:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "value":
+          {
+            "hexValue": "34",
+            "id": 2,
+            "isConstant": false,
+            "isLValue": false,
+            "isPure": true,
+            "kind": "number",
+            "lValueRequested": false,
+            "nodeType": "Literal",
+            "src": "43:1:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_rational_4_by_1",
+              "typeString": "int_const 4"
+            },
+            "value": "4"
+          },
+          "visibility": "public"
+        },
+        {
+          "constant": true,
+          "functionSelector": "4df7e3d0",
+          "id": 6,
+          "mutability": "constant",
+          "name": "b",
+          "nameLocation": "71:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 10,
+          "src": "50:26:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 4,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "50:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "value":
+          {
+            "hexValue": "32",
+            "id": 5,
+            "isConstant": false,
+            "isLValue": false,
+            "isPure": true,
+            "kind": "number",
+            "lValueRequested": false,
+            "nodeType": "Literal",
+            "src": "75:1:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_rational_2_by_1",
+              "typeString": "int_const 2"
+            },
+            "value": "2"
+          },
+          "visibility": "public"
+        },
+        {
+          "constant": false,
+          "functionSelector": "c3da42b8",
+          "id": 9,
+          "mutability": "mutable",
+          "name": "c",
+          "nameLocation": "94:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 10,
+          "src": "82:17:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 7,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "82:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "value":
+          {
+            "hexValue": "33",
+            "id": 8,
+            "isConstant": false,
+            "isLValue": false,
+            "isPure": true,
+            "kind": "number",
+            "lValueRequested": false,
+            "nodeType": "Literal",
+            "src": "98:1:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_rational_3_by_1",
+              "typeString": "int_const 3"
+            },
+            "value": "3"
+          },
+          "visibility": "public"
+        }
+      ],
+      "scope": 11,
+      "src": "0:102:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:103:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/mutability.sol b/compiler/test/libsolidity/ASTJSON/mutability.sol
new file mode 100644
index 00000000..3f67c29e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mutability.sol
@@ -0,0 +1,7 @@
+contract C
+{
+    uint public immutable a = 4;
+    uint public constant b = 2;
+    uint public c = 3;
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/mutability_parseOnly.json b/compiler/test/libsolidity/ASTJSON/mutability_parseOnly.json
new file mode 100644
index 00000000..637f8e11
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/mutability_parseOnly.json
@@ -0,0 +1,118 @@
+{
+  "absolutePath": "a",
+  "id": 11,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 10,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "immutable",
+          "name": "a",
+          "nameLocation": "39:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "17:27:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 1,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "17:4:1",
+            "typeDescriptions": {}
+          },
+          "value":
+          {
+            "hexValue": "34",
+            "id": 2,
+            "kind": "number",
+            "nodeType": "Literal",
+            "src": "43:1:1",
+            "typeDescriptions": {},
+            "value": "4"
+          },
+          "visibility": "public"
+        },
+        {
+          "constant": true,
+          "id": 6,
+          "mutability": "constant",
+          "name": "b",
+          "nameLocation": "71:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "50:26:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 4,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "50:4:1",
+            "typeDescriptions": {}
+          },
+          "value":
+          {
+            "hexValue": "32",
+            "id": 5,
+            "kind": "number",
+            "nodeType": "Literal",
+            "src": "75:1:1",
+            "typeDescriptions": {},
+            "value": "2"
+          },
+          "visibility": "public"
+        },
+        {
+          "constant": false,
+          "id": 9,
+          "mutability": "mutable",
+          "name": "c",
+          "nameLocation": "94:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "82:17:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 7,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "82:4:1",
+            "typeDescriptions": {}
+          },
+          "value":
+          {
+            "hexValue": "33",
+            "id": 8,
+            "kind": "number",
+            "nodeType": "Literal",
+            "src": "98:1:1",
+            "typeDescriptions": {},
+            "value": "3"
+          },
+          "visibility": "public"
+        }
+      ],
+      "src": "0:102:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:103:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/non_utf8.json b/compiler/test/libsolidity/ASTJSON/non_utf8.json
new file mode 100644
index 00000000..0058e56e
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/non_utf8.json
@@ -0,0 +1,238 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      15
+    ]
+  },
+  "id": 16,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 15,
+      "linearizedBaseContracts":
+      [
+        15
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 13,
+            "nodeType": "Block",
+            "src": "33:45:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 13,
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_string_memory_ptr",
+                      "typeString": "string"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_string_storage_ptr",
+                        "typeString": "string"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 12,
+                "initialValue":
+                {
+                  "arguments":
+                  [
+                    {
+                      "arguments":
+                      [
+                        {
+                          "hexValue": "ff",
+                          "id": 9,
+                          "isConstant": false,
+                          "isLValue": false,
+                          "isPure": true,
+                          "kind": "hexString",
+                          "lValueRequested": false,
+                          "nodeType": "Literal",
+                          "src": "66:7:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_stringliteral_8b1a944cf13a9a1c08facb2c9e98623ef3254d2ddb48113885c3e8e97fec8db9",
+                            "typeString": "literal_string hex\"ff\""
+                          }
+                        }
+                      ],
+                      "expression":
+                      {
+                        "argumentTypes":
+                        [
+                          {
+                            "typeIdentifier": "t_stringliteral_8b1a944cf13a9a1c08facb2c9e98623ef3254d2ddb48113885c3e8e97fec8db9",
+                            "typeString": "literal_string hex\"ff\""
+                          }
+                        ],
+                        "id": 8,
+                        "isConstant": false,
+                        "isLValue": false,
+                        "isPure": true,
+                        "lValueRequested": false,
+                        "nodeType": "ElementaryTypeNameExpression",
+                        "src": "60:5:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_type$_t_bytes_storage_ptr_$",
+                          "typeString": "type(bytes storage pointer)"
+                        },
+                        "typeName":
+                        {
+                          "id": 7,
+                          "name": "bytes",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "60:5:1",
+                          "typeDescriptions": {}
+                        }
+                      },
+                      "id": 10,
+                      "isConstant": false,
+                      "isLValue": false,
+                      "isPure": true,
+                      "kind": "typeConversion",
+                      "lValueRequested": false,
+                      "nameLocations": [],
+                      "names": [],
+                      "nodeType": "FunctionCall",
+                      "src": "60:14:1",
+                      "tryCall": false,
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_bytes_memory_ptr",
+                        "typeString": "bytes memory"
+                      }
+                    }
+                  ],
+                  "expression":
+                  {
+                    "argumentTypes":
+                    [
+                      {
+                        "typeIdentifier": "t_bytes_memory_ptr",
+                        "typeString": "bytes memory"
+                      }
+                    ],
+                    "id": 6,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": true,
+                    "lValueRequested": false,
+                    "nodeType": "ElementaryTypeNameExpression",
+                    "src": "53:6:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_type$_t_string_storage_ptr_$",
+                      "typeString": "type(string storage pointer)"
+                    },
+                    "typeName":
+                    {
+                      "id": 5,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "53:6:1",
+                      "typeDescriptions": {}
+                    }
+                  },
+                  "id": 11,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "typeConversion",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "53:22:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_string_memory_ptr",
+                    "typeString": "string memory"
+                  }
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:40:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 14,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 15,
+          "src": "13:65:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 16,
+      "src": "0:80:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:81:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/non_utf8_parseOnly.json b/compiler/test/libsolidity/ASTJSON/non_utf8_parseOnly.json
new file mode 100644
index 00000000..bbc350f9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/non_utf8_parseOnly.json
@@ -0,0 +1,157 @@
+{
+  "absolutePath": "a",
+  "id": 16,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 15,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 13,
+            "nodeType": "Block",
+            "src": "33:45:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 12,
+                "initialValue":
+                {
+                  "arguments":
+                  [
+                    {
+                      "arguments":
+                      [
+                        {
+                          "hexValue": "ff",
+                          "id": 9,
+                          "kind": "hexString",
+                          "nodeType": "Literal",
+                          "src": "66:7:1",
+                          "typeDescriptions": {}
+                        }
+                      ],
+                      "expression":
+                      {
+                        "id": 8,
+                        "nodeType": "ElementaryTypeNameExpression",
+                        "src": "60:5:1",
+                        "typeDescriptions": {},
+                        "typeName":
+                        {
+                          "id": 7,
+                          "name": "bytes",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "60:5:1",
+                          "typeDescriptions": {}
+                        }
+                      },
+                      "id": 10,
+                      "nameLocations": [],
+                      "names": [],
+                      "nodeType": "FunctionCall",
+                      "src": "60:14:1",
+                      "tryCall": false,
+                      "typeDescriptions": {}
+                    }
+                  ],
+                  "expression":
+                  {
+                    "id": 6,
+                    "nodeType": "ElementaryTypeNameExpression",
+                    "src": "53:6:1",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 5,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "53:6:1",
+                      "typeDescriptions": {}
+                    }
+                  },
+                  "id": 11,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "53:22:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:40:1"
+              }
+            ]
+          },
+          "id": 14,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:65:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:80:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:81:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/not_existing_import.sol b/compiler/test/libsolidity/ASTJSON/not_existing_import.sol
new file mode 100644
index 00000000..ad3c100c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/not_existing_import.sol
@@ -0,0 +1,8 @@
+import "notexisting.sol" as NotExisting;
+contract C is NotExisting.X
+{
+	NotExisting.SomeStruct public myStruct;
+	constructor() {}
+}
+// ----
+// failAfter: Parsed
diff --git a/compiler/test/libsolidity/ASTJSON/not_existing_import_parseOnly.json b/compiler/test/libsolidity/ASTJSON/not_existing_import_parseOnly.json
new file mode 100644
index 00000000..ea08150f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/not_existing_import_parseOnly.json
@@ -0,0 +1,119 @@
+{
+  "absolutePath": "a",
+  "id": 12,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "absolutePath": "notexisting.sol",
+      "file": "notexisting.sol",
+      "id": 1,
+      "nameLocation": "28:11:1",
+      "nodeType": "ImportDirective",
+      "src": "0:40:1",
+      "symbolAliases": [],
+      "unitAlias": "NotExisting"
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 2,
+            "name": "NotExisting.X",
+            "nameLocations":
+            [
+              "55:11:1",
+              "67:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "55:13:1"
+          },
+          "id": 3,
+          "nodeType": "InheritanceSpecifier",
+          "src": "55:13:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 11,
+      "name": "C",
+      "nameLocation": "50:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "constant": false,
+          "id": 6,
+          "mutability": "mutable",
+          "name": "myStruct",
+          "nameLocation": "102:8:1",
+          "nodeType": "VariableDeclaration",
+          "src": "72:38:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 5,
+            "nodeType": "UserDefinedTypeName",
+            "pathNode":
+            {
+              "id": 4,
+              "name": "NotExisting.SomeStruct",
+              "nameLocations":
+              [
+                "72:11:1",
+                "84:10:1"
+              ],
+              "nodeType": "IdentifierPath",
+              "src": "72:22:1"
+            },
+            "src": "72:22:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 9,
+            "nodeType": "Block",
+            "src": "127:2:1",
+            "statements": []
+          },
+          "id": 10,
+          "implemented": true,
+          "kind": "constructor",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "124:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "127:0:1"
+          },
+          "src": "113:16:1",
+          "stateMutability": "nonpayable",
+          "virtual": false
+        }
+      ],
+      "src": "41:90:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:132:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/override.json b/compiler/test/libsolidity/ASTJSON/override.json
new file mode 100644
index 00000000..35d36eac
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/override.json
@@ -0,0 +1,340 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "A":
+    [
+      5
+    ],
+    "B":
+    [
+      16
+    ],
+    "C":
+    [
+      29
+    ]
+  },
+  "id": 30,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "A",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "44:2:1",
+            "statements": []
+          },
+          "functionSelector": "a399b6a2",
+          "id": 4,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "23:3:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "26:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "44:0:1"
+          },
+          "scope": 5,
+          "src": "14:32:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "scope": 30,
+      "src": "0:48:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": true,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 6,
+            "name": "A",
+            "nameLocations":
+            [
+              "72:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 5,
+            "src": "72:1:1"
+          },
+          "id": 7,
+          "nodeType": "InheritanceSpecifier",
+          "src": "72:1:1"
+        }
+      ],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": false,
+      "id": 16,
+      "linearizedBaseContracts":
+      [
+        16,
+        5
+      ],
+      "name": "B",
+      "nameLocation": "67:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "functionSelector": "c2985578",
+          "id": 10,
+          "implemented": false,
+          "kind": "function",
+          "modifiers": [],
+          "name": "foo",
+          "nameLocation": "86:3:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "89:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 9,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "106:0:1"
+          },
+          "scope": 16,
+          "src": "77:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        },
+        {
+          "baseFunctions":
+          [
+            4
+          ],
+          "body":
+          {
+            "id": 14,
+            "nodeType": "Block",
+            "src": "148:2:1",
+            "statements": []
+          },
+          "functionSelector": "a399b6a2",
+          "id": 15,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "118:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 12,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "139:8:1"
+          },
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "121:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "148:0:1"
+          },
+          "scope": 16,
+          "src": "109:41:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "scope": 30,
+      "src": "49:103:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 17,
+            "name": "B",
+            "nameLocations":
+            [
+              "167:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 16,
+            "src": "167:1:1"
+          },
+          "id": 18,
+          "nodeType": "InheritanceSpecifier",
+          "src": "167:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 29,
+      "linearizedBaseContracts":
+      [
+        29,
+        16,
+        5
+      ],
+      "name": "C",
+      "nameLocation": "162:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "baseFunctions":
+          [
+            10
+          ],
+          "body":
+          {
+            "id": 22,
+            "nodeType": "Block",
+            "src": "203:3:1",
+            "statements": []
+          },
+          "functionSelector": "c2985578",
+          "id": 23,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "foo",
+          "nameLocation": "181:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 20,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "194:8:1"
+          },
+          "parameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "184:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 21,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "203:0:1"
+          },
+          "scope": 29,
+          "src": "172:34:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "baseFunctions":
+          [
+            15
+          ],
+          "body":
+          {
+            "id": 27,
+            "nodeType": "Block",
+            "src": "239:3:1",
+            "statements": []
+          },
+          "functionSelector": "a399b6a2",
+          "id": 28,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "217:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 25,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "230:8:1"
+          },
+          "parameters":
+          {
+            "id": 24,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "220:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 26,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "239:0:1"
+          },
+          "scope": 29,
+          "src": "208:34:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 30,
+      "src": "153:91:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:245:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/override.sol b/compiler/test/libsolidity/ASTJSON/override.sol
new file mode 100644
index 00000000..a0324498
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/override.sol
@@ -0,0 +1,12 @@
+contract A {
+	function faa() public virtual {}
+}
+abstract contract B is A {
+	function foo() public virtual;
+	function faa() public virtual override {}
+}
+contract C is B {
+	function foo() public override { }
+	function faa() public override { }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/override_parseOnly.json b/compiler/test/libsolidity/ASTJSON/override_parseOnly.json
new file mode 100644
index 00000000..3a927f5f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/override_parseOnly.json
@@ -0,0 +1,277 @@
+{
+  "absolutePath": "a",
+  "id": 30,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "44:2:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "23:3:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "26:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "44:0:1"
+          },
+          "src": "14:32:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:48:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": true,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 6,
+            "name": "A",
+            "nameLocations":
+            [
+              "72:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "72:1:1"
+          },
+          "id": 7,
+          "nodeType": "InheritanceSpecifier",
+          "src": "72:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 16,
+      "name": "B",
+      "nameLocation": "67:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 10,
+          "implemented": false,
+          "kind": "function",
+          "modifiers": [],
+          "name": "foo",
+          "nameLocation": "86:3:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 8,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "89:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 9,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "106:0:1"
+          },
+          "src": "77:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 14,
+            "nodeType": "Block",
+            "src": "148:2:1",
+            "statements": []
+          },
+          "id": 15,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "118:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 12,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "139:8:1"
+          },
+          "parameters":
+          {
+            "id": 11,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "121:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "148:0:1"
+          },
+          "src": "109:41:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "src": "49:103:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 17,
+            "name": "B",
+            "nameLocations":
+            [
+              "167:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "167:1:1"
+          },
+          "id": 18,
+          "nodeType": "InheritanceSpecifier",
+          "src": "167:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 29,
+      "name": "C",
+      "nameLocation": "162:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 22,
+            "nodeType": "Block",
+            "src": "203:3:1",
+            "statements": []
+          },
+          "id": 23,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "foo",
+          "nameLocation": "181:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 20,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "194:8:1"
+          },
+          "parameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "184:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 21,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "203:0:1"
+          },
+          "src": "172:34:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        },
+        {
+          "body":
+          {
+            "id": 27,
+            "nodeType": "Block",
+            "src": "239:3:1",
+            "statements": []
+          },
+          "id": 28,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "faa",
+          "nameLocation": "217:3:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 25,
+            "nodeType": "OverrideSpecifier",
+            "overrides": [],
+            "src": "230:8:1"
+          },
+          "parameters":
+          {
+            "id": 24,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "220:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 26,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "239:0:1"
+          },
+          "src": "208:34:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "153:91:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:245:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/placeholder_statement.json b/compiler/test/libsolidity/ASTJSON/placeholder_statement.json
new file mode 100644
index 00000000..96a46c14
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/placeholder_statement.json
@@ -0,0 +1,69 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "24:6:1",
+            "statements":
+            [
+              {
+                "id": 2,
+                "nodeType": "PlaceholderStatement",
+                "src": "26:1:1"
+              }
+            ]
+          },
+          "id": 4,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "24:0:1"
+          },
+          "src": "13:17:1",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "scope": 6,
+      "src": "0:32:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:33:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/placeholder_statement_parseOnly.json b/compiler/test/libsolidity/ASTJSON/placeholder_statement_parseOnly.json
new file mode 100644
index 00000000..8af17040
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/placeholder_statement_parseOnly.json
@@ -0,0 +1,55 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "24:6:1",
+            "statements":
+            [
+              {
+                "id": 2,
+                "nodeType": "PlaceholderStatement",
+                "src": "26:1:1"
+              }
+            ]
+          },
+          "id": 4,
+          "name": "M",
+          "nameLocation": "22:1:1",
+          "nodeType": "ModifierDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "24:0:1"
+          },
+          "src": "13:17:1",
+          "virtual": false,
+          "visibility": "internal"
+        }
+      ],
+      "src": "0:32:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:33:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity.sol b/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity.sol
new file mode 100644
index 00000000..bb5b771a
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity.sol
@@ -0,0 +1,5 @@
+pragma experimental solidity;
+// ====
+// EVMVersion: >=constantinople
+// ----
+// failAfter: Parsed
diff --git a/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity_parseOnly.json b/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity_parseOnly.json
new file mode 100644
index 00000000..b1ac937a
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/pragma_experimental_solidity_parseOnly.json
@@ -0,0 +1,20 @@
+{
+  "absolutePath": "a",
+  "experimentalSolidity": true,
+  "id": 2,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 1,
+      "literals":
+      [
+        "experimental",
+        "solidity"
+      ],
+      "nodeType": "PragmaDirective",
+      "src": "0:29:1"
+    }
+  ],
+  "src": "0:70:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/receive_ether.json b/compiler/test/libsolidity/ASTJSON/receive_ether.json
new file mode 100644
index 00000000..27904939
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/receive_ether.json
@@ -0,0 +1,74 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      5
+    ]
+  },
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "42:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "receive",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "scope": 5,
+          "src": "15:32:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "scope": 6,
+      "src": "0:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:50:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/receive_ether.sol b/compiler/test/libsolidity/ASTJSON/receive_ether.sol
new file mode 100644
index 00000000..1e59dc13
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/receive_ether.sol
@@ -0,0 +1,5 @@
+contract C {
+  receive() external payable {
+  }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/receive_ether_parseOnly.json b/compiler/test/libsolidity/ASTJSON/receive_ether_parseOnly.json
new file mode 100644
index 00000000..f9aede15
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/receive_ether_parseOnly.json
@@ -0,0 +1,59 @@
+{
+  "absolutePath": "a",
+  "id": 6,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "42:5:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "receive",
+          "modifiers": [],
+          "name": "",
+          "nameLocation": "-1:-1:-1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "22:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "42:0:1"
+          },
+          "src": "15:32:1",
+          "stateMutability": "payable",
+          "virtual": false,
+          "visibility": "external"
+        }
+      ],
+      "src": "0:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:50:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/short_type_name.json b/compiler/test/libsolidity/ASTJSON/short_type_name.json
new file mode 100644
index 00000000..1c1138cb
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/short_type_name.json
@@ -0,0 +1,130 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "c":
+    [
+      11
+    ]
+  },
+  "id": 12,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "c",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 11,
+      "linearizedBaseContracts":
+      [
+        11
+      ],
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 9,
+            "nodeType": "Block",
+            "src": "33:20:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  7
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 7,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 9,
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_array$_t_uint256_$dyn_memory_ptr",
+                      "typeString": "uint256[]"
+                    },
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "id": 5,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "35:4:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_uint256",
+                          "typeString": "uint256"
+                        }
+                      },
+                      "id": 6,
+                      "nodeType": "ArrayTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+                        "typeString": "uint256[]"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 8,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:15:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 10,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 11,
+          "src": "13:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 12,
+      "src": "0:55:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:56:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/short_type_name_parseOnly.json b/compiler/test/libsolidity/ASTJSON/short_type_name_parseOnly.json
new file mode 100644
index 00000000..3c4acfa7
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/short_type_name_parseOnly.json
@@ -0,0 +1,101 @@
+{
+  "absolutePath": "a",
+  "id": 12,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 11,
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 9,
+            "nodeType": "Block",
+            "src": "33:20:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  7
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 7,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "id": 5,
+                        "name": "uint",
+                        "nodeType": "ElementaryTypeName",
+                        "src": "35:4:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 6,
+                      "nodeType": "ArrayTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 8,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:15:1"
+              }
+            ]
+          },
+          "id": 10,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:55:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:56:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/short_type_name_ref.json b/compiler/test/libsolidity/ASTJSON/short_type_name_ref.json
new file mode 100644
index 00000000..447b1e5b
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/short_type_name_ref.json
@@ -0,0 +1,141 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "c":
+    [
+      12
+    ]
+  },
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "c",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 12,
+      "linearizedBaseContracts":
+      [
+        12
+      ],
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "33:25:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  8
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 8,
+                    "mutability": "mutable",
+                    "name": "rows",
+                    "nameLocation": "51:4:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 10,
+                    "src": "35:20:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_array$_t_array$_t_uint256_$dyn_memory_ptr_$dyn_memory_ptr",
+                      "typeString": "uint256[][]"
+                    },
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "baseType":
+                        {
+                          "id": 5,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "35:4:1",
+                          "typeDescriptions":
+                          {
+                            "typeIdentifier": "t_uint256",
+                            "typeString": "uint256"
+                          }
+                        },
+                        "id": 6,
+                        "nodeType": "ArrayTypeName",
+                        "src": "35:6:1",
+                        "typeDescriptions":
+                        {
+                          "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr",
+                          "typeString": "uint256[]"
+                        }
+                      },
+                      "id": 7,
+                      "nodeType": "ArrayTypeName",
+                      "src": "35:8:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_array$_t_array$_t_uint256_$dyn_storage_$dyn_storage_ptr",
+                        "typeString": "uint256[][]"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 9,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:20:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 12,
+          "src": "13:45:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 13,
+      "src": "0:60:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:61:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/short_type_name_ref_parseOnly.json b/compiler/test/libsolidity/ASTJSON/short_type_name_ref_parseOnly.json
new file mode 100644
index 00000000..07c782d4
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/short_type_name_ref_parseOnly.json
@@ -0,0 +1,108 @@
+{
+  "absolutePath": "a",
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 12,
+      "name": "c",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "33:25:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  8
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 8,
+                    "mutability": "mutable",
+                    "name": "rows",
+                    "nameLocation": "51:4:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:20:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "baseType":
+                      {
+                        "baseType":
+                        {
+                          "id": 5,
+                          "name": "uint",
+                          "nodeType": "ElementaryTypeName",
+                          "src": "35:4:1",
+                          "typeDescriptions": {}
+                        },
+                        "id": 6,
+                        "nodeType": "ArrayTypeName",
+                        "src": "35:6:1",
+                        "typeDescriptions": {}
+                      },
+                      "id": 7,
+                      "nodeType": "ArrayTypeName",
+                      "src": "35:8:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 9,
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:20:1"
+              }
+            ]
+          },
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:45:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:60:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:61:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/smoke.json b/compiler/test/libsolidity/ASTJSON/smoke.json
new file mode 100644
index 00000000..d3b114bb
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/smoke.json
@@ -0,0 +1,37 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      1
+    ]
+  },
+  "id": 2,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 1,
+      "linearizedBaseContracts":
+      [
+        1
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 2,
+      "src": "0:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:14:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/smoke_parseOnly.json b/compiler/test/libsolidity/ASTJSON/smoke_parseOnly.json
new file mode 100644
index 00000000..1160fea9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/smoke_parseOnly.json
@@ -0,0 +1,23 @@
+{
+  "absolutePath": "a",
+  "id": 2,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 1,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "0:13:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:14:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/source_location.json b/compiler/test/libsolidity/ASTJSON/source_location.json
new file mode 100644
index 00000000..caeaf027
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/source_location.json
@@ -0,0 +1,173 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      12
+    ]
+  },
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 12,
+      "linearizedBaseContracts":
+      [
+        12
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "33:20:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "40:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 10,
+                    "src": "35:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:4:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_uint256",
+                        "typeString": "uint256"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "32",
+                  "id": 5,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "number",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "44:1:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_rational_2_by_1",
+                    "typeString": "int_const 2"
+                  },
+                  "value": "2"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:10:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 8,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "nodeType": "UnaryOperation",
+                  "operator": "++",
+                  "prefix": false,
+                  "src": "47:3:1",
+                  "subExpression":
+                  {
+                    "id": 7,
+                    "name": "x",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 4,
+                    "src": "47:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_uint256",
+                      "typeString": "uint256"
+                    }
+                  },
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_uint256",
+                    "typeString": "uint256"
+                  }
+                },
+                "id": 9,
+                "nodeType": "ExpressionStatement",
+                "src": "47:3:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 12,
+          "src": "13:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 13,
+      "src": "0:55:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:56:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/source_location_parseOnly.json b/compiler/test/libsolidity/ASTJSON/source_location_parseOnly.json
new file mode 100644
index 00000000..ec25111b
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/source_location_parseOnly.json
@@ -0,0 +1,127 @@
+{
+  "absolutePath": "a",
+  "id": 13,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 12,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 10,
+            "nodeType": "Block",
+            "src": "33:20:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "40:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:6:1",
+                    "stateVariable": false,
+                    "storageLocation": "default",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "uint",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:4:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "32",
+                  "id": 5,
+                  "kind": "number",
+                  "nodeType": "Literal",
+                  "src": "44:1:1",
+                  "typeDescriptions": {},
+                  "value": "2"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:10:1"
+              },
+              {
+                "expression":
+                {
+                  "id": 8,
+                  "nodeType": "UnaryOperation",
+                  "operator": "++",
+                  "prefix": false,
+                  "src": "47:3:1",
+                  "subExpression":
+                  {
+                    "id": 7,
+                    "name": "x",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "47:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "typeDescriptions": {}
+                },
+                "id": 9,
+                "nodeType": "ExpressionStatement",
+                "src": "47:3:1"
+              }
+            ]
+          },
+          "id": 11,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:40:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:55:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:56:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/string.json b/compiler/test/libsolidity/ASTJSON/string.json
new file mode 100644
index 00000000..c7706e3b
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/string.json
@@ -0,0 +1,137 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      9
+    ]
+  },
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 9,
+      "linearizedBaseContracts":
+      [
+        9
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "33:36:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 7,
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_string_memory_ptr",
+                      "typeString": "string"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_string_storage_ptr",
+                        "typeString": "string"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "48656c6c6f20576f726c64",
+                  "id": 5,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "string",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "53:13:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_stringliteral_592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba",
+                    "typeString": "literal_string \"Hello World\""
+                  },
+                  "value": "Hello World"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:31:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 9,
+          "src": "13:56:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 10,
+      "src": "0:71:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:72:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/string_parseOnly.json b/compiler/test/libsolidity/ASTJSON/string_parseOnly.json
new file mode 100644
index 00000000..5f97eb1f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/string_parseOnly.json
@@ -0,0 +1,104 @@
+{
+  "absolutePath": "a",
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 9,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "33:36:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "48656c6c6f20576f726c64",
+                  "id": 5,
+                  "kind": "string",
+                  "nodeType": "Literal",
+                  "src": "53:13:1",
+                  "typeDescriptions": {},
+                  "value": "Hello World"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:31:1"
+              }
+            ]
+          },
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:56:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:71:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:72:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/struct_natspec.json b/compiler/test/libsolidity/ASTJSON/struct_natspec.json
new file mode 100644
index 00000000..d8b38a80
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/struct_natspec.json
@@ -0,0 +1,126 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "Example":
+    [
+      8
+    ]
+  },
+  "id": 9,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "canonicalName": "Example",
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:112:1",
+        "text": "@title example of title\n @author example of author\n @notice example of notice\n @dev example of dev"
+      },
+      "id": 8,
+      "members":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "text",
+          "nameLocation": "140:4:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 8,
+          "src": "133:11:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_string_storage_ptr",
+            "typeString": "string"
+          },
+          "typeName":
+          {
+            "id": 2,
+            "name": "string",
+            "nodeType": "ElementaryTypeName",
+            "src": "133:6:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_string_storage_ptr",
+              "typeString": "string"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 5,
+          "mutability": "mutable",
+          "name": "valid",
+          "nameLocation": "155:5:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 8,
+          "src": "150:10:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_bool",
+            "typeString": "bool"
+          },
+          "typeName":
+          {
+            "id": 4,
+            "name": "bool",
+            "nodeType": "ElementaryTypeName",
+            "src": "150:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_bool",
+              "typeString": "bool"
+            }
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 7,
+          "mutability": "mutable",
+          "name": "value",
+          "nameLocation": "174:5:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 8,
+          "src": "166:13:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_uint256",
+            "typeString": "uint256"
+          },
+          "typeName":
+          {
+            "id": 6,
+            "name": "uint256",
+            "nodeType": "ElementaryTypeName",
+            "src": "166:7:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          },
+          "visibility": "internal"
+        }
+      ],
+      "name": "Example",
+      "nameLocation": "119:7:1",
+      "nodeType": "StructDefinition",
+      "scope": 9,
+      "src": "112:70:1",
+      "visibility": "public"
+    }
+  ],
+  "src": "112:71:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/struct_natspec.sol b/compiler/test/libsolidity/ASTJSON/struct_natspec.sol
new file mode 100644
index 00000000..c9e279f6
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/struct_natspec.sol
@@ -0,0 +1,11 @@
+/// @title example of title
+/// @author example of author
+/// @notice example of notice
+/// @dev example of dev
+struct Example {
+    string text;
+    bool valid;
+    uint256 value;
+}
+
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/struct_natspec_parseOnly.json b/compiler/test/libsolidity/ASTJSON/struct_natspec_parseOnly.json
new file mode 100644
index 00000000..b80aaf37
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/struct_natspec_parseOnly.json
@@ -0,0 +1,90 @@
+{
+  "absolutePath": "a",
+  "id": 9,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "documentation":
+      {
+        "id": 1,
+        "nodeType": "StructuredDocumentation",
+        "src": "0:112:1",
+        "text": "@title example of title\n @author example of author\n @notice example of notice\n @dev example of dev"
+      },
+      "id": 8,
+      "members":
+      [
+        {
+          "constant": false,
+          "id": 3,
+          "mutability": "mutable",
+          "name": "text",
+          "nameLocation": "140:4:1",
+          "nodeType": "VariableDeclaration",
+          "src": "133:11:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 2,
+            "name": "string",
+            "nodeType": "ElementaryTypeName",
+            "src": "133:6:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 5,
+          "mutability": "mutable",
+          "name": "valid",
+          "nameLocation": "155:5:1",
+          "nodeType": "VariableDeclaration",
+          "src": "150:10:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 4,
+            "name": "bool",
+            "nodeType": "ElementaryTypeName",
+            "src": "150:4:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        },
+        {
+          "constant": false,
+          "id": 7,
+          "mutability": "mutable",
+          "name": "value",
+          "nameLocation": "174:5:1",
+          "nodeType": "VariableDeclaration",
+          "src": "166:13:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 6,
+            "name": "uint256",
+            "nodeType": "ElementaryTypeName",
+            "src": "166:7:1",
+            "typeDescriptions": {}
+          },
+          "visibility": "internal"
+        }
+      ],
+      "name": "Example",
+      "nameLocation": "119:7:1",
+      "nodeType": "StructDefinition",
+      "src": "112:70:1",
+      "visibility": "public"
+    }
+  ],
+  "src": "112:71:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/two_base_functions.json b/compiler/test/libsolidity/ASTJSON/two_base_functions.json
new file mode 100644
index 00000000..0ed997a3
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/two_base_functions.json
@@ -0,0 +1,275 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "A":
+    [
+      5
+    ],
+    "B":
+    [
+      10
+    ],
+    "C":
+    [
+      22
+    ]
+  },
+  "id": 23,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "A",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 5,
+      "linearizedBaseContracts":
+      [
+        5
+      ],
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "45:2:1",
+            "statements": []
+          },
+          "functionSelector": "26121ff0",
+          "id": 4,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "45:0:1"
+          },
+          "scope": 5,
+          "src": "17:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "scope": 23,
+      "src": "0:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "B",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 10,
+      "linearizedBaseContracts":
+      [
+        10
+      ],
+      "name": "B",
+      "nameLocation": "59:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 8,
+            "nodeType": "Block",
+            "src": "95:2:1",
+            "statements": []
+          },
+          "functionSelector": "26121ff0",
+          "id": 9,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "77:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "95:0:1"
+          },
+          "scope": 10,
+          "src": "67:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "scope": 23,
+      "src": "50:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 11,
+            "name": "A",
+            "nameLocations":
+            [
+              "114:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 5,
+            "src": "114:1:1"
+          },
+          "id": 12,
+          "nodeType": "InheritanceSpecifier",
+          "src": "114:1:1"
+        },
+        {
+          "baseName":
+          {
+            "id": 13,
+            "name": "B",
+            "nameLocations":
+            [
+              "117:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 10,
+            "src": "117:1:1"
+          },
+          "id": 14,
+          "nodeType": "InheritanceSpecifier",
+          "src": "117:1:1"
+        }
+      ],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 22,
+      "linearizedBaseContracts":
+      [
+        22,
+        10,
+        5
+      ],
+      "name": "C",
+      "nameLocation": "109:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "baseFunctions":
+          [
+            4,
+            9
+          ],
+          "body":
+          {
+            "id": 20,
+            "nodeType": "Block",
+            "src": "160:2:1",
+            "statements": []
+          },
+          "functionSelector": "26121ff0",
+          "id": 21,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "134:1:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 18,
+            "nodeType": "OverrideSpecifier",
+            "overrides":
+            [
+              {
+                "id": 16,
+                "name": "A",
+                "nameLocations":
+                [
+                  "154:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 5,
+                "src": "154:1:1"
+              },
+              {
+                "id": 17,
+                "name": "B",
+                "nameLocations":
+                [
+                  "157:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 10,
+                "src": "157:1:1"
+              }
+            ],
+            "src": "145:14:1"
+          },
+          "parameters":
+          {
+            "id": 15,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "135:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "160:0:1"
+          },
+          "scope": 22,
+          "src": "125:37:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 23,
+      "src": "100:64:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:165:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/two_base_functions.sol b/compiler/test/libsolidity/ASTJSON/two_base_functions.sol
new file mode 100644
index 00000000..0a00bcc1
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/two_base_functions.sol
@@ -0,0 +1,10 @@
+contract A {
+    function f() public virtual {}
+}
+contract B {
+    function f() public virtual {}
+}
+contract C is A, B {
+    function f() public override(A, B) {}
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/two_base_functions_parseOnly.json b/compiler/test/libsolidity/ASTJSON/two_base_functions_parseOnly.json
new file mode 100644
index 00000000..e448be83
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/two_base_functions_parseOnly.json
@@ -0,0 +1,222 @@
+{
+  "absolutePath": "a",
+  "id": 23,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 5,
+      "name": "A",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 3,
+            "nodeType": "Block",
+            "src": "45:2:1",
+            "statements": []
+          },
+          "id": 4,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "26:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "27:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "45:0:1"
+          },
+          "src": "17:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 10,
+      "name": "B",
+      "nameLocation": "59:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 8,
+            "nodeType": "Block",
+            "src": "95:2:1",
+            "statements": []
+          },
+          "id": 9,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "76:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 6,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "77:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 7,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "95:0:1"
+          },
+          "src": "67:30:1",
+          "stateMutability": "nonpayable",
+          "virtual": true,
+          "visibility": "public"
+        }
+      ],
+      "src": "50:49:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "abstract": false,
+      "baseContracts":
+      [
+        {
+          "baseName":
+          {
+            "id": 11,
+            "name": "A",
+            "nameLocations":
+            [
+              "114:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "114:1:1"
+          },
+          "id": 12,
+          "nodeType": "InheritanceSpecifier",
+          "src": "114:1:1"
+        },
+        {
+          "baseName":
+          {
+            "id": 13,
+            "name": "B",
+            "nameLocations":
+            [
+              "117:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "117:1:1"
+          },
+          "id": 14,
+          "nodeType": "InheritanceSpecifier",
+          "src": "117:1:1"
+        }
+      ],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 22,
+      "name": "C",
+      "nameLocation": "109:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 20,
+            "nodeType": "Block",
+            "src": "160:2:1",
+            "statements": []
+          },
+          "id": 21,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "134:1:1",
+          "nodeType": "FunctionDefinition",
+          "overrides":
+          {
+            "id": 18,
+            "nodeType": "OverrideSpecifier",
+            "overrides":
+            [
+              {
+                "id": 16,
+                "name": "A",
+                "nameLocations":
+                [
+                  "154:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "154:1:1"
+              },
+              {
+                "id": 17,
+                "name": "B",
+                "nameLocations":
+                [
+                  "157:1:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "157:1:1"
+              }
+            ],
+            "src": "145:14:1"
+          },
+          "parameters":
+          {
+            "id": 15,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "135:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 19,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "160:0:1"
+          },
+          "src": "125:37:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "100:64:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:165:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/unicode.json b/compiler/test/libsolidity/ASTJSON/unicode.json
new file mode 100644
index 00000000..0ff1426f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/unicode.json
@@ -0,0 +1,137 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      9
+    ]
+  },
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 9,
+      "linearizedBaseContracts":
+      [
+        9
+      ],
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "33:42:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "scope": 7,
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_string_memory_ptr",
+                      "typeString": "string"
+                    },
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_string_storage_ptr",
+                        "typeString": "string"
+                      }
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "48656c6c6f20f09f9883",
+                  "id": 5,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": true,
+                  "kind": "unicodeString",
+                  "lValueRequested": false,
+                  "nodeType": "Literal",
+                  "src": "53:19:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_stringliteral_cd7a99177cebb3d14b8cc54e313dbf76867c71cd6fbb9a33ce3870dc80e9992b",
+                    "typeString": "literal_string hex\"48656c6c6f20f09f9883\""
+                  },
+                  "value": "Hello \ud83d\ude03"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:37:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "scope": 9,
+          "src": "13:62:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 10,
+      "src": "0:77:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:78:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/unicode_parseOnly.json b/compiler/test/libsolidity/ASTJSON/unicode_parseOnly.json
new file mode 100644
index 00000000..c8fb780c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/unicode_parseOnly.json
@@ -0,0 +1,104 @@
+{
+  "absolutePath": "a",
+  "id": 10,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 9,
+      "name": "C",
+      "nameLocation": "9:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 7,
+            "nodeType": "Block",
+            "src": "33:42:1",
+            "statements":
+            [
+              {
+                "assignments":
+                [
+                  4
+                ],
+                "declarations":
+                [
+                  {
+                    "constant": false,
+                    "id": 4,
+                    "mutability": "mutable",
+                    "name": "x",
+                    "nameLocation": "49:1:1",
+                    "nodeType": "VariableDeclaration",
+                    "src": "35:15:1",
+                    "stateVariable": false,
+                    "storageLocation": "memory",
+                    "typeDescriptions": {},
+                    "typeName":
+                    {
+                      "id": 3,
+                      "name": "string",
+                      "nodeType": "ElementaryTypeName",
+                      "src": "35:6:1",
+                      "typeDescriptions": {}
+                    },
+                    "visibility": "internal"
+                  }
+                ],
+                "id": 6,
+                "initialValue":
+                {
+                  "hexValue": "48656c6c6f20f09f9883",
+                  "id": 5,
+                  "kind": "unicodeString",
+                  "nodeType": "Literal",
+                  "src": "53:19:1",
+                  "typeDescriptions": {},
+                  "value": "Hello \ud83d\ude03"
+                },
+                "nodeType": "VariableDeclarationStatement",
+                "src": "35:37:1"
+              }
+            ]
+          },
+          "id": 8,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "22:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "23:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "33:0:1"
+          },
+          "src": "13:62:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:77:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:78:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/used_errors.json b/compiler/test/libsolidity/ASTJSON/used_errors.json
new file mode 100644
index 00000000..12a59f9c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/used_errors.json
@@ -0,0 +1,236 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      19
+    ],
+    "X":
+    [
+      2
+    ],
+    "f":
+    [
+      9
+    ]
+  },
+  "id": 20,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "errorSelector": "c1599bd9",
+      "id": 2,
+      "name": "X",
+      "nameLocation": "6:1:1",
+      "nodeType": "ErrorDefinition",
+      "parameters":
+      {
+        "id": 1,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "7:2:1"
+      },
+      "src": "0:10:1"
+    },
+    {
+      "body":
+      {
+        "id": 8,
+        "nodeType": "Block",
+        "src": "29:15:1",
+        "statements":
+        [
+          {
+            "errorCall":
+            {
+              "arguments": [],
+              "expression":
+              {
+                "argumentTypes": [],
+                "id": 5,
+                "name": "X",
+                "nodeType": "Identifier",
+                "overloadedDeclarations": [],
+                "referencedDeclaration": 2,
+                "src": "38:1:1",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_function_error_pure$__$returns$__$",
+                  "typeString": "function () pure"
+                }
+              },
+              "id": 6,
+              "isConstant": false,
+              "isLValue": false,
+              "isPure": false,
+              "kind": "functionCall",
+              "lValueRequested": false,
+              "nameLocations": [],
+              "names": [],
+              "nodeType": "FunctionCall",
+              "src": "38:3:1",
+              "tryCall": false,
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_tuple$__$",
+                "typeString": "tuple()"
+              }
+            },
+            "id": 7,
+            "nodeType": "RevertStatement",
+            "src": "31:10:1"
+          }
+        ]
+      },
+      "id": 9,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "20:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 3,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "21:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 4,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "29:0:1"
+      },
+      "scope": 20,
+      "src": "11:33:1",
+      "stateMutability": "pure",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 19,
+      "linearizedBaseContracts":
+      [
+        19
+      ],
+      "name": "C",
+      "nameLocation": "54:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "errorSelector": "2bc80f3a",
+          "id": 11,
+          "name": "T",
+          "nameLocation": "68:1:1",
+          "nodeType": "ErrorDefinition",
+          "parameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "69:2:1"
+          },
+          "src": "62:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 17,
+            "nodeType": "Block",
+            "src": "97:8:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "argumentTypes": [],
+                    "id": 14,
+                    "name": "f",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 9,
+                    "src": "99:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_function_internal_pure$__$returns$__$",
+                      "typeString": "function () pure"
+                    }
+                  },
+                  "id": 15,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "kind": "functionCall",
+                  "lValueRequested": false,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "99:3:1",
+                  "tryCall": false,
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_tuple$__$",
+                    "typeString": "tuple()"
+                  }
+                },
+                "id": 16,
+                "nodeType": "ExpressionStatement",
+                "src": "99:3:1"
+              }
+            ]
+          },
+          "functionSelector": "b8c9d365",
+          "id": 18,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "h",
+          "nameLocation": "86:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 12,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "87:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "97:0:1"
+          },
+          "scope": 19,
+          "src": "77:28:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 20,
+      "src": "45:62:1",
+      "usedErrors":
+      [
+        2,
+        11
+      ],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:108:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/used_errors.sol b/compiler/test/libsolidity/ASTJSON/used_errors.sol
new file mode 100644
index 00000000..97f7a27f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/used_errors.sol
@@ -0,0 +1,7 @@
+error X();
+function f() pure { revert X(); }
+contract C {
+    error T();
+    function h() public { f(); }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/used_errors_parseOnly.json b/compiler/test/libsolidity/ASTJSON/used_errors_parseOnly.json
new file mode 100644
index 00000000..115ea2ae
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/used_errors_parseOnly.json
@@ -0,0 +1,175 @@
+{
+  "absolutePath": "a",
+  "id": 20,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 2,
+      "name": "X",
+      "nameLocation": "6:1:1",
+      "nodeType": "ErrorDefinition",
+      "parameters":
+      {
+        "id": 1,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "7:2:1"
+      },
+      "src": "0:10:1"
+    },
+    {
+      "body":
+      {
+        "id": 8,
+        "nodeType": "Block",
+        "src": "29:15:1",
+        "statements":
+        [
+          {
+            "errorCall":
+            {
+              "arguments": [],
+              "expression":
+              {
+                "id": 5,
+                "name": "X",
+                "nodeType": "Identifier",
+                "overloadedDeclarations": [],
+                "src": "38:1:1",
+                "typeDescriptions": {}
+              },
+              "id": 6,
+              "nameLocations": [],
+              "names": [],
+              "nodeType": "FunctionCall",
+              "src": "38:3:1",
+              "tryCall": false,
+              "typeDescriptions": {}
+            },
+            "id": 7,
+            "nodeType": "RevertStatement",
+            "src": "31:10:1"
+          }
+        ]
+      },
+      "id": 9,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "20:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 3,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "21:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 4,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "29:0:1"
+      },
+      "src": "11:33:1",
+      "stateMutability": "pure",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 19,
+      "name": "C",
+      "nameLocation": "54:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 11,
+          "name": "T",
+          "nameLocation": "68:1:1",
+          "nodeType": "ErrorDefinition",
+          "parameters":
+          {
+            "id": 10,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "69:2:1"
+          },
+          "src": "62:10:1"
+        },
+        {
+          "body":
+          {
+            "id": 17,
+            "nodeType": "Block",
+            "src": "97:8:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "arguments": [],
+                  "expression":
+                  {
+                    "id": 14,
+                    "name": "f",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "src": "99:1:1",
+                    "typeDescriptions": {}
+                  },
+                  "id": 15,
+                  "nameLocations": [],
+                  "names": [],
+                  "nodeType": "FunctionCall",
+                  "src": "99:3:1",
+                  "tryCall": false,
+                  "typeDescriptions": {}
+                },
+                "id": 16,
+                "nodeType": "ExpressionStatement",
+                "src": "99:3:1"
+              }
+            ]
+          },
+          "id": 18,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "h",
+          "nameLocation": "86:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 12,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "87:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 13,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "97:0:1"
+          },
+          "src": "77:28:1",
+          "stateMutability": "nonpayable",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "45:62:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:108:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/userDefinedValueType.json b/compiler/test/libsolidity/ASTJSON/userDefinedValueType.json
new file mode 100644
index 00000000..adf1172f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/userDefinedValueType.json
@@ -0,0 +1,360 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      27
+    ],
+    "MyAddress":
+    [
+      2
+    ],
+    "MyUInt":
+    [
+      4
+    ],
+    "f":
+    [
+      16
+    ]
+  },
+  "id": 28,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "canonicalName": "MyAddress",
+      "id": 2,
+      "name": "MyAddress",
+      "nameLocation": "5:9:1",
+      "nodeType": "UserDefinedValueTypeDefinition",
+      "src": "0:26:1",
+      "underlyingType":
+      {
+        "id": 1,
+        "name": "address",
+        "nodeType": "ElementaryTypeName",
+        "src": "18:7:1",
+        "stateMutability": "nonpayable",
+        "typeDescriptions":
+        {
+          "typeIdentifier": "t_address",
+          "typeString": "address"
+        }
+      }
+    },
+    {
+      "canonicalName": "MyUInt",
+      "id": 4,
+      "name": "MyUInt",
+      "nameLocation": "32:6:1",
+      "nodeType": "UserDefinedValueTypeDefinition",
+      "src": "27:20:1",
+      "underlyingType":
+      {
+        "id": 3,
+        "name": "uint",
+        "nodeType": "ElementaryTypeName",
+        "src": "42:4:1",
+        "typeDescriptions":
+        {
+          "typeIdentifier": "t_uint256",
+          "typeString": "uint256"
+        }
+      }
+    },
+    {
+      "body":
+      {
+        "id": 15,
+        "nodeType": "Block",
+        "src": "61:34:1",
+        "statements":
+        [
+          {
+            "assignments":
+            [
+              9
+            ],
+            "declarations":
+            [
+              {
+                "constant": false,
+                "id": 9,
+                "mutability": "mutable",
+                "name": "a",
+                "nameLocation": "77:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 15,
+                "src": "67:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_userDefinedValueType$_MyAddress_$2",
+                  "typeString": "MyAddress"
+                },
+                "typeName":
+                {
+                  "id": 8,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 7,
+                    "name": "MyAddress",
+                    "nameLocations":
+                    [
+                      "67:9:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "referencedDeclaration": 2,
+                    "src": "67:9:1"
+                  },
+                  "referencedDeclaration": 2,
+                  "src": "67:9:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_MyAddress_$2",
+                    "typeString": "MyAddress"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "id": 10,
+            "nodeType": "VariableDeclarationStatement",
+            "src": "67:11:1"
+          },
+          {
+            "assignments":
+            [
+              13
+            ],
+            "declarations":
+            [
+              {
+                "constant": false,
+                "id": 13,
+                "mutability": "mutable",
+                "name": "b",
+                "nameLocation": "91:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 15,
+                "src": "84:8:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_userDefinedValueType$_MyUInt_$4",
+                  "typeString": "MyUInt"
+                },
+                "typeName":
+                {
+                  "id": 12,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 11,
+                    "name": "MyUInt",
+                    "nameLocations":
+                    [
+                      "84:6:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "referencedDeclaration": 4,
+                    "src": "84:6:1"
+                  },
+                  "referencedDeclaration": 4,
+                  "src": "84:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_MyUInt_$4",
+                    "typeString": "MyUInt"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "id": 14,
+            "nodeType": "VariableDeclarationStatement",
+            "src": "84:8:1"
+          }
+        ]
+      },
+      "id": 16,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "57:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 5,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "58:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 6,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "61:0:1"
+      },
+      "scope": 28,
+      "src": "48:47:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 27,
+      "linearizedBaseContracts":
+      [
+        27
+      ],
+      "name": "C",
+      "nameLocation": "105:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "canonicalName": "C.MyAddress",
+          "id": 18,
+          "name": "MyAddress",
+          "nameLocation": "118:9:1",
+          "nodeType": "UserDefinedValueTypeDefinition",
+          "src": "113:26:1",
+          "underlyingType":
+          {
+            "id": 17,
+            "name": "address",
+            "nodeType": "ElementaryTypeName",
+            "src": "131:7:1",
+            "stateMutability": "nonpayable",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_address",
+              "typeString": "address"
+            }
+          }
+        },
+        {
+          "canonicalName": "C.MyUInt",
+          "id": 20,
+          "name": "MyUInt",
+          "nameLocation": "149:6:1",
+          "nodeType": "UserDefinedValueTypeDefinition",
+          "src": "144:20:1",
+          "underlyingType":
+          {
+            "id": 19,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "159:4:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            }
+          }
+        },
+        {
+          "constant": false,
+          "functionSelector": "97682884",
+          "id": 26,
+          "mutability": "mutable",
+          "name": "m",
+          "nameLocation": "205:1:1",
+          "nodeType": "VariableDeclaration",
+          "scope": 27,
+          "src": "169:37:1",
+          "stateVariable": true,
+          "storageLocation": "default",
+          "typeDescriptions":
+          {
+            "typeIdentifier": "t_mapping$_t_userDefinedValueType$_MyAddress_$18_$_t_userDefinedValueType$_MyUInt_$20_$",
+            "typeString": "mapping(C.MyAddress => C.MyUInt)"
+          },
+          "typeName":
+          {
+            "id": 25,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 22,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 21,
+                "name": "MyAddress",
+                "nameLocations":
+                [
+                  "177:9:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 18,
+                "src": "177:9:1"
+              },
+              "referencedDeclaration": 18,
+              "src": "177:9:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_MyAddress_$18",
+                "typeString": "C.MyAddress"
+              }
+            },
+            "nodeType": "Mapping",
+            "src": "169:28:1",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_mapping$_t_userDefinedValueType$_MyAddress_$18_$_t_userDefinedValueType$_MyUInt_$20_$",
+              "typeString": "mapping(C.MyAddress => C.MyUInt)"
+            },
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 24,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 23,
+                "name": "MyUInt",
+                "nameLocations":
+                [
+                  "190:6:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 20,
+                "src": "190:6:1"
+              },
+              "referencedDeclaration": 20,
+              "src": "190:6:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_MyUInt_$20",
+                "typeString": "C.MyUInt"
+              }
+            }
+          },
+          "visibility": "public"
+        }
+      ],
+      "scope": 28,
+      "src": "96:113:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:210:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/userDefinedValueType.sol b/compiler/test/libsolidity/ASTJSON/userDefinedValueType.sol
new file mode 100644
index 00000000..d5ef2e00
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/userDefinedValueType.sol
@@ -0,0 +1,12 @@
+type MyAddress is address;
+type MyUInt is uint;
+function f() {
+    MyAddress a;
+    MyUInt b;
+}
+contract C {
+    type MyAddress is address;
+    type MyUInt is uint;
+    mapping(MyAddress => MyUInt) public m;
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/userDefinedValueType_parseOnly.json b/compiler/test/libsolidity/ASTJSON/userDefinedValueType_parseOnly.json
new file mode 100644
index 00000000..90e48a98
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/userDefinedValueType_parseOnly.json
@@ -0,0 +1,269 @@
+{
+  "absolutePath": "a",
+  "id": 28,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "id": 2,
+      "name": "MyAddress",
+      "nameLocation": "5:9:1",
+      "nodeType": "UserDefinedValueTypeDefinition",
+      "src": "0:26:1",
+      "underlyingType":
+      {
+        "id": 1,
+        "name": "address",
+        "nodeType": "ElementaryTypeName",
+        "src": "18:7:1",
+        "stateMutability": "nonpayable",
+        "typeDescriptions": {}
+      }
+    },
+    {
+      "id": 4,
+      "name": "MyUInt",
+      "nameLocation": "32:6:1",
+      "nodeType": "UserDefinedValueTypeDefinition",
+      "src": "27:20:1",
+      "underlyingType":
+      {
+        "id": 3,
+        "name": "uint",
+        "nodeType": "ElementaryTypeName",
+        "src": "42:4:1",
+        "typeDescriptions": {}
+      }
+    },
+    {
+      "body":
+      {
+        "id": 15,
+        "nodeType": "Block",
+        "src": "61:34:1",
+        "statements":
+        [
+          {
+            "assignments":
+            [
+              9
+            ],
+            "declarations":
+            [
+              {
+                "constant": false,
+                "id": 9,
+                "mutability": "mutable",
+                "name": "a",
+                "nameLocation": "77:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "67:11:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 8,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 7,
+                    "name": "MyAddress",
+                    "nameLocations":
+                    [
+                      "67:9:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "src": "67:9:1"
+                  },
+                  "src": "67:9:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "id": 10,
+            "nodeType": "VariableDeclarationStatement",
+            "src": "67:11:1"
+          },
+          {
+            "assignments":
+            [
+              13
+            ],
+            "declarations":
+            [
+              {
+                "constant": false,
+                "id": 13,
+                "mutability": "mutable",
+                "name": "b",
+                "nameLocation": "91:1:1",
+                "nodeType": "VariableDeclaration",
+                "src": "84:8:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions": {},
+                "typeName":
+                {
+                  "id": 12,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 11,
+                    "name": "MyUInt",
+                    "nameLocations":
+                    [
+                      "84:6:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "src": "84:6:1"
+                  },
+                  "src": "84:6:1",
+                  "typeDescriptions": {}
+                },
+                "visibility": "internal"
+              }
+            ],
+            "id": 14,
+            "nodeType": "VariableDeclarationStatement",
+            "src": "84:8:1"
+          }
+        ]
+      },
+      "id": 16,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "57:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 5,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "58:2:1"
+      },
+      "returnParameters":
+      {
+        "id": 6,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "61:0:1"
+      },
+      "src": "48:47:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 27,
+      "name": "C",
+      "nameLocation": "105:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "id": 18,
+          "name": "MyAddress",
+          "nameLocation": "118:9:1",
+          "nodeType": "UserDefinedValueTypeDefinition",
+          "src": "113:26:1",
+          "underlyingType":
+          {
+            "id": 17,
+            "name": "address",
+            "nodeType": "ElementaryTypeName",
+            "src": "131:7:1",
+            "stateMutability": "nonpayable",
+            "typeDescriptions": {}
+          }
+        },
+        {
+          "id": 20,
+          "name": "MyUInt",
+          "nameLocation": "149:6:1",
+          "nodeType": "UserDefinedValueTypeDefinition",
+          "src": "144:20:1",
+          "underlyingType":
+          {
+            "id": 19,
+            "name": "uint",
+            "nodeType": "ElementaryTypeName",
+            "src": "159:4:1",
+            "typeDescriptions": {}
+          }
+        },
+        {
+          "constant": false,
+          "id": 26,
+          "mutability": "mutable",
+          "name": "m",
+          "nameLocation": "205:1:1",
+          "nodeType": "VariableDeclaration",
+          "src": "169:37:1",
+          "stateVariable": false,
+          "storageLocation": "default",
+          "typeDescriptions": {},
+          "typeName":
+          {
+            "id": 25,
+            "keyName": "",
+            "keyNameLocation": "-1:-1:-1",
+            "keyType":
+            {
+              "id": 22,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 21,
+                "name": "MyAddress",
+                "nameLocations":
+                [
+                  "177:9:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "177:9:1"
+              },
+              "src": "177:9:1",
+              "typeDescriptions": {}
+            },
+            "nodeType": "Mapping",
+            "src": "169:28:1",
+            "typeDescriptions": {},
+            "valueName": "",
+            "valueNameLocation": "-1:-1:-1",
+            "valueType":
+            {
+              "id": 24,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 23,
+                "name": "MyUInt",
+                "nameLocations":
+                [
+                  "190:6:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "src": "190:6:1"
+              },
+              "src": "190:6:1",
+              "typeDescriptions": {}
+            }
+          },
+          "visibility": "public"
+        }
+      ],
+      "src": "96:113:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:210:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/user_defined_operator.json b/compiler/test/libsolidity/ASTJSON/user_defined_operator.json
new file mode 100644
index 00000000..ed72de49
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/user_defined_operator.json
@@ -0,0 +1,664 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      49
+    ],
+    "I8":
+    [
+      2
+    ],
+    "sub":
+    [
+      20
+    ],
+    "unsub":
+    [
+      30
+    ]
+  },
+  "id": 50,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "canonicalName": "I8",
+      "id": 2,
+      "name": "I8",
+      "nameLocation": "5:2:1",
+      "nodeType": "UserDefinedValueTypeDefinition",
+      "src": "0:16:1",
+      "underlyingType":
+      {
+        "id": 1,
+        "name": "int8",
+        "nodeType": "ElementaryTypeName",
+        "src": "11:4:1",
+        "typeDescriptions":
+        {
+          "typeIdentifier": "t_int8",
+          "typeString": "int8"
+        }
+      }
+    },
+    {
+      "functionList":
+      [
+        {
+          "definition":
+          {
+            "id": 3,
+            "name": "sub",
+            "nameLocations":
+            [
+              "24:3:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 20,
+            "src": "24:3:1"
+          },
+          "operator": "-"
+        },
+        {
+          "definition":
+          {
+            "id": 4,
+            "name": "unsub",
+            "nameLocations":
+            [
+              "34:5:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 30,
+            "src": "34:5:1"
+          },
+          "operator": "-"
+        }
+      ],
+      "global": true,
+      "id": 7,
+      "nodeType": "UsingForDirective",
+      "src": "17:43:1",
+      "typeName":
+      {
+        "id": 6,
+        "nodeType": "UserDefinedTypeName",
+        "pathNode":
+        {
+          "id": 5,
+          "name": "I8",
+          "nameLocations":
+          [
+            "50:2:1"
+          ],
+          "nodeType": "IdentifierPath",
+          "referencedDeclaration": 2,
+          "src": "50:2:1"
+        },
+        "referencedDeclaration": 2,
+        "src": "50:2:1",
+        "typeDescriptions":
+        {
+          "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+          "typeString": "I8"
+        }
+      }
+    },
+    {
+      "body":
+      {
+        "id": 19,
+        "nodeType": "Block",
+        "src": "100:2:1",
+        "statements": []
+      },
+      "id": 20,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "sub",
+      "nameLocation": "70:3:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 14,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 10,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 20,
+            "src": "74:2:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+              "typeString": "I8"
+            },
+            "typeName":
+            {
+              "id": 9,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 8,
+                "name": "I8",
+                "nameLocations":
+                [
+                  "74:2:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 2,
+                "src": "74:2:1"
+              },
+              "referencedDeclaration": 2,
+              "src": "74:2:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                "typeString": "I8"
+              }
+            },
+            "visibility": "internal"
+          },
+          {
+            "constant": false,
+            "id": 13,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 20,
+            "src": "78:2:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+              "typeString": "I8"
+            },
+            "typeName":
+            {
+              "id": 12,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 11,
+                "name": "I8",
+                "nameLocations":
+                [
+                  "78:2:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 2,
+                "src": "78:2:1"
+              },
+              "referencedDeclaration": 2,
+              "src": "78:2:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                "typeString": "I8"
+              }
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "73:8:1"
+      },
+      "returnParameters":
+      {
+        "id": 18,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 17,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 20,
+            "src": "96:2:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+              "typeString": "I8"
+            },
+            "typeName":
+            {
+              "id": 16,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 15,
+                "name": "I8",
+                "nameLocations":
+                [
+                  "96:2:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 2,
+                "src": "96:2:1"
+              },
+              "referencedDeclaration": 2,
+              "src": "96:2:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                "typeString": "I8"
+              }
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "95:4:1"
+      },
+      "scope": 50,
+      "src": "61:41:1",
+      "stateMutability": "pure",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "body":
+      {
+        "id": 29,
+        "nodeType": "Block",
+        "src": "140:2:1",
+        "statements": []
+      },
+      "id": 30,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "unsub",
+      "nameLocation": "112:5:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 24,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 23,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 30,
+            "src": "118:2:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+              "typeString": "I8"
+            },
+            "typeName":
+            {
+              "id": 22,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 21,
+                "name": "I8",
+                "nameLocations":
+                [
+                  "118:2:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 2,
+                "src": "118:2:1"
+              },
+              "referencedDeclaration": 2,
+              "src": "118:2:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                "typeString": "I8"
+              }
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "117:4:1"
+      },
+      "returnParameters":
+      {
+        "id": 28,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 27,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 30,
+            "src": "136:2:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+              "typeString": "I8"
+            },
+            "typeName":
+            {
+              "id": 26,
+              "nodeType": "UserDefinedTypeName",
+              "pathNode":
+              {
+                "id": 25,
+                "name": "I8",
+                "nameLocations":
+                [
+                  "136:2:1"
+                ],
+                "nodeType": "IdentifierPath",
+                "referencedDeclaration": 2,
+                "src": "136:2:1"
+              },
+              "referencedDeclaration": 2,
+              "src": "136:2:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                "typeString": "I8"
+              }
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "135:4:1"
+      },
+      "scope": 50,
+      "src": "103:39:1",
+      "stateMutability": "pure",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 49,
+      "linearizedBaseContracts":
+      [
+        49
+      ],
+      "name": "C",
+      "nameLocation": "152:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 47,
+            "nodeType": "Block",
+            "src": "208:30:1",
+            "statements":
+            [
+              {
+                "expression":
+                {
+                  "commonType":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                    "typeString": "I8"
+                  },
+                  "function": 20,
+                  "id": 45,
+                  "isConstant": false,
+                  "isLValue": false,
+                  "isPure": false,
+                  "lValueRequested": false,
+                  "leftExpression":
+                  {
+                    "function": 30,
+                    "id": 43,
+                    "isConstant": false,
+                    "isLValue": false,
+                    "isPure": false,
+                    "lValueRequested": false,
+                    "nodeType": "UnaryOperation",
+                    "operator": "-",
+                    "prefix": true,
+                    "src": "225:2:1",
+                    "subExpression":
+                    {
+                      "id": 42,
+                      "name": "a",
+                      "nodeType": "Identifier",
+                      "overloadedDeclarations": [],
+                      "referencedDeclaration": 33,
+                      "src": "226:1:1",
+                      "typeDescriptions":
+                      {
+                        "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                        "typeString": "I8"
+                      }
+                    },
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                      "typeString": "I8"
+                    }
+                  },
+                  "nodeType": "BinaryOperation",
+                  "operator": "-",
+                  "rightExpression":
+                  {
+                    "id": 44,
+                    "name": "b",
+                    "nodeType": "Identifier",
+                    "overloadedDeclarations": [],
+                    "referencedDeclaration": 36,
+                    "src": "230:1:1",
+                    "typeDescriptions":
+                    {
+                      "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                      "typeString": "I8"
+                    }
+                  },
+                  "src": "225:6:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                    "typeString": "I8"
+                  }
+                },
+                "functionReturnParameters": 41,
+                "id": 46,
+                "nodeType": "Return",
+                "src": "218:13:1"
+              }
+            ]
+          },
+          "functionSelector": "ac9fe858",
+          "id": 48,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "169:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 37,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 33,
+                "mutability": "mutable",
+                "name": "a",
+                "nameLocation": "174:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 48,
+                "src": "171:4:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                  "typeString": "I8"
+                },
+                "typeName":
+                {
+                  "id": 32,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 31,
+                    "name": "I8",
+                    "nameLocations":
+                    [
+                      "171:2:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "referencedDeclaration": 2,
+                    "src": "171:2:1"
+                  },
+                  "referencedDeclaration": 2,
+                  "src": "171:2:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                    "typeString": "I8"
+                  }
+                },
+                "visibility": "internal"
+              },
+              {
+                "constant": false,
+                "id": 36,
+                "mutability": "mutable",
+                "name": "b",
+                "nameLocation": "180:1:1",
+                "nodeType": "VariableDeclaration",
+                "scope": 48,
+                "src": "177:4:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                  "typeString": "I8"
+                },
+                "typeName":
+                {
+                  "id": 35,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 34,
+                    "name": "I8",
+                    "nameLocations":
+                    [
+                      "177:2:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "referencedDeclaration": 2,
+                    "src": "177:2:1"
+                  },
+                  "referencedDeclaration": 2,
+                  "src": "177:2:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                    "typeString": "I8"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "170:12:1"
+          },
+          "returnParameters":
+          {
+            "id": 41,
+            "nodeType": "ParameterList",
+            "parameters":
+            [
+              {
+                "constant": false,
+                "id": 40,
+                "mutability": "mutable",
+                "name": "",
+                "nameLocation": "-1:-1:-1",
+                "nodeType": "VariableDeclaration",
+                "scope": 48,
+                "src": "204:2:1",
+                "stateVariable": false,
+                "storageLocation": "default",
+                "typeDescriptions":
+                {
+                  "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                  "typeString": "I8"
+                },
+                "typeName":
+                {
+                  "id": 39,
+                  "nodeType": "UserDefinedTypeName",
+                  "pathNode":
+                  {
+                    "id": 38,
+                    "name": "I8",
+                    "nameLocations":
+                    [
+                      "204:2:1"
+                    ],
+                    "nodeType": "IdentifierPath",
+                    "referencedDeclaration": 2,
+                    "src": "204:2:1"
+                  },
+                  "referencedDeclaration": 2,
+                  "src": "204:2:1",
+                  "typeDescriptions":
+                  {
+                    "typeIdentifier": "t_userDefinedValueType$_I8_$2",
+                    "typeString": "I8"
+                  }
+                },
+                "visibility": "internal"
+              }
+            ],
+            "src": "203:4:1"
+          },
+          "scope": 49,
+          "src": "160:78:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 50,
+      "src": "143:97:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:241:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/user_defined_operator.sol b/compiler/test/libsolidity/ASTJSON/user_defined_operator.sol
new file mode 100644
index 00000000..bfbdf7b9
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/user_defined_operator.sol
@@ -0,0 +1,10 @@
+type I8 is int8;
+using {sub as -, unsub as -} for I8 global;
+function sub(I8, I8) pure returns (I8) {}
+function unsub(I8) pure returns (I8) {}
+contract C {
+    function f(I8 a, I8 b) public pure returns (I8) {
+        return -a - b;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/using_for_directive.json b/compiler/test/libsolidity/ASTJSON/using_for_directive.json
new file mode 100644
index 00000000..f3094980
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/using_for_directive.json
@@ -0,0 +1,188 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "C":
+    [
+      13
+    ],
+    "L":
+    [
+      4
+    ],
+    "f":
+    [
+      10
+    ]
+  },
+  "id": 14,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "functionList":
+      [
+        {
+          "function":
+          {
+            "id": 1,
+            "name": "f",
+            "nameLocations":
+            [
+              "7:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 10,
+            "src": "7:1:1"
+          }
+        }
+      ],
+      "global": false,
+      "id": 3,
+      "nodeType": "UsingForDirective",
+      "src": "0:19:1",
+      "typeName":
+      {
+        "id": 2,
+        "name": "uint",
+        "nodeType": "ElementaryTypeName",
+        "src": "14:4:1",
+        "typeDescriptions":
+        {
+          "typeIdentifier": "t_uint256",
+          "typeString": "uint256"
+        }
+      }
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "L",
+      "contractDependencies": [],
+      "contractKind": "library",
+      "fullyImplemented": true,
+      "id": 4,
+      "linearizedBaseContracts":
+      [
+        4
+      ],
+      "name": "L",
+      "nameLocation": "28:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "scope": 14,
+      "src": "20:12:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "body":
+      {
+        "id": 9,
+        "nodeType": "Block",
+        "src": "50:2:1",
+        "statements": []
+      },
+      "id": 10,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "42:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 7,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 6,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "scope": 10,
+            "src": "44:4:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions":
+            {
+              "typeIdentifier": "t_uint256",
+              "typeString": "uint256"
+            },
+            "typeName":
+            {
+              "id": 5,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "44:4:1",
+              "typeDescriptions":
+              {
+                "typeIdentifier": "t_uint256",
+                "typeString": "uint256"
+              }
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "43:6:1"
+      },
+      "returnParameters":
+      {
+        "id": 8,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "50:0:1"
+      },
+      "scope": 14,
+      "src": "33:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "C",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 13,
+      "linearizedBaseContracts":
+      [
+        13
+      ],
+      "name": "C",
+      "nameLocation": "62:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "global": false,
+          "id": 12,
+          "libraryName":
+          {
+            "id": 11,
+            "name": "L",
+            "nameLocations":
+            [
+              "72:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "referencedDeclaration": 4,
+            "src": "72:1:1"
+          },
+          "nodeType": "UsingForDirective",
+          "src": "66:14:1"
+        }
+      ],
+      "scope": 14,
+      "src": "53:29:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:83:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/using_for_directive_parseOnly.json b/compiler/test/libsolidity/ASTJSON/using_for_directive_parseOnly.json
new file mode 100644
index 00000000..9360227d
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/using_for_directive_parseOnly.json
@@ -0,0 +1,143 @@
+{
+  "absolutePath": "a",
+  "id": 14,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "functionList":
+      [
+        {
+          "function":
+          {
+            "id": 1,
+            "name": "f",
+            "nameLocations":
+            [
+              "7:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "7:1:1"
+          }
+        }
+      ],
+      "global": false,
+      "id": 3,
+      "nodeType": "UsingForDirective",
+      "src": "0:19:1",
+      "typeName":
+      {
+        "id": 2,
+        "name": "uint",
+        "nodeType": "ElementaryTypeName",
+        "src": "14:4:1",
+        "typeDescriptions": {}
+      }
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "library",
+      "id": 4,
+      "name": "L",
+      "nameLocation": "28:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes": [],
+      "src": "20:12:1",
+      "usedErrors": [],
+      "usedEvents": []
+    },
+    {
+      "body":
+      {
+        "id": 9,
+        "nodeType": "Block",
+        "src": "50:2:1",
+        "statements": []
+      },
+      "id": 10,
+      "implemented": true,
+      "kind": "freeFunction",
+      "modifiers": [],
+      "name": "f",
+      "nameLocation": "42:1:1",
+      "nodeType": "FunctionDefinition",
+      "parameters":
+      {
+        "id": 7,
+        "nodeType": "ParameterList",
+        "parameters":
+        [
+          {
+            "constant": false,
+            "id": 6,
+            "mutability": "mutable",
+            "name": "",
+            "nameLocation": "-1:-1:-1",
+            "nodeType": "VariableDeclaration",
+            "src": "44:4:1",
+            "stateVariable": false,
+            "storageLocation": "default",
+            "typeDescriptions": {},
+            "typeName":
+            {
+              "id": 5,
+              "name": "uint",
+              "nodeType": "ElementaryTypeName",
+              "src": "44:4:1",
+              "typeDescriptions": {}
+            },
+            "visibility": "internal"
+          }
+        ],
+        "src": "43:6:1"
+      },
+      "returnParameters":
+      {
+        "id": 8,
+        "nodeType": "ParameterList",
+        "parameters": [],
+        "src": "50:0:1"
+      },
+      "src": "33:19:1",
+      "stateMutability": "nonpayable",
+      "virtual": false,
+      "visibility": "internal"
+    },
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 13,
+      "name": "C",
+      "nameLocation": "62:1:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "global": false,
+          "id": 12,
+          "libraryName":
+          {
+            "id": 11,
+            "name": "L",
+            "nameLocations":
+            [
+              "72:1:1"
+            ],
+            "nodeType": "IdentifierPath",
+            "src": "72:1:1"
+          },
+          "nodeType": "UsingForDirective",
+          "src": "66:14:1"
+        }
+      ],
+      "src": "53:29:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:83:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/yul_hex_literal.json b/compiler/test/libsolidity/ASTJSON/yul_hex_literal.json
new file mode 100644
index 00000000..0498289c
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/yul_hex_literal.json
@@ -0,0 +1,166 @@
+{
+  "absolutePath": "a",
+  "exportedSymbols":
+  {
+    "Sample":
+    [
+      6
+    ]
+  },
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "canonicalName": "Sample",
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "fullyImplemented": true,
+      "id": 6,
+      "linearizedBaseContracts":
+      [
+        6
+      ],
+      "name": "Sample",
+      "nameLocation": "9:6:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "47:167:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "66:142:1",
+                  "nodeType": "YulBlock",
+                  "src": "66:142:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "80:15:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "80:15:1",
+                      "value":
+                      {
+                        "hexValue": "74657374",
+                        "kind": "string",
+                        "nativeSrc": "89:6:1",
+                        "nodeType": "YulLiteral",
+                        "src": "89:6:1",
+                        "type": "",
+                        "value": "test"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "a",
+                          "nativeSrc": "84:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "84:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "108:54:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "108:54:1",
+                      "value":
+                      {
+                        "hexValue": "112233445566778899aabbccddeeff6677889900",
+                        "kind": "string",
+                        "nativeSrc": "117:45:1",
+                        "nodeType": "YulLiteral",
+                        "src": "117:45:1",
+                        "type": ""
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "b",
+                          "nativeSrc": "112:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "112:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "175:23:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "175:23:1",
+                      "value":
+                      {
+                        "hexValue": "1234abcd",
+                        "kind": "string",
+                        "nativeSrc": "184:14:1",
+                        "nodeType": "YulLiteral",
+                        "src": "184:14:1",
+                        "type": ""
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "c",
+                          "nativeSrc": "179:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "179:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "57:151:1"
+              }
+            ]
+          },
+          "functionSelector": "26121ff0",
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "31:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "32:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "47:0:1"
+          },
+          "scope": 6,
+          "src": "22:192:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "scope": 7,
+      "src": "0:216:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:217:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSON/yul_hex_literal.sol b/compiler/test/libsolidity/ASTJSON/yul_hex_literal.sol
new file mode 100644
index 00000000..c3b57a8f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/yul_hex_literal.sol
@@ -0,0 +1,10 @@
+contract Sample {
+    function f() public pure {
+        assembly {
+            let a := "test"
+            let b := hex"112233445566778899aabbccddeeff6677889900"
+            let c := hex"1234_abcd"
+        }
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/ASTJSON/yul_hex_literal_parseOnly.json b/compiler/test/libsolidity/ASTJSON/yul_hex_literal_parseOnly.json
new file mode 100644
index 00000000..023c13cc
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSON/yul_hex_literal_parseOnly.json
@@ -0,0 +1,150 @@
+{
+  "absolutePath": "a",
+  "id": 7,
+  "nodeType": "SourceUnit",
+  "nodes":
+  [
+    {
+      "abstract": false,
+      "baseContracts": [],
+      "contractDependencies": [],
+      "contractKind": "contract",
+      "id": 6,
+      "name": "Sample",
+      "nameLocation": "9:6:1",
+      "nodeType": "ContractDefinition",
+      "nodes":
+      [
+        {
+          "body":
+          {
+            "id": 4,
+            "nodeType": "Block",
+            "src": "47:167:1",
+            "statements":
+            [
+              {
+                "AST":
+                {
+                  "nativeSrc": "66:142:1",
+                  "nodeType": "YulBlock",
+                  "src": "66:142:1",
+                  "statements":
+                  [
+                    {
+                      "nativeSrc": "80:15:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "80:15:1",
+                      "value":
+                      {
+                        "hexValue": "74657374",
+                        "kind": "string",
+                        "nativeSrc": "89:6:1",
+                        "nodeType": "YulLiteral",
+                        "src": "89:6:1",
+                        "type": "",
+                        "value": "test"
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "a",
+                          "nativeSrc": "84:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "84:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "108:54:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "108:54:1",
+                      "value":
+                      {
+                        "hexValue": "112233445566778899aabbccddeeff6677889900",
+                        "kind": "string",
+                        "nativeSrc": "117:45:1",
+                        "nodeType": "YulLiteral",
+                        "src": "117:45:1",
+                        "type": ""
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "b",
+                          "nativeSrc": "112:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "112:1:1",
+                          "type": ""
+                        }
+                      ]
+                    },
+                    {
+                      "nativeSrc": "175:23:1",
+                      "nodeType": "YulVariableDeclaration",
+                      "src": "175:23:1",
+                      "value":
+                      {
+                        "hexValue": "1234abcd",
+                        "kind": "string",
+                        "nativeSrc": "184:14:1",
+                        "nodeType": "YulLiteral",
+                        "src": "184:14:1",
+                        "type": ""
+                      },
+                      "variables":
+                      [
+                        {
+                          "name": "c",
+                          "nativeSrc": "179:1:1",
+                          "nodeType": "YulTypedName",
+                          "src": "179:1:1",
+                          "type": ""
+                        }
+                      ]
+                    }
+                  ]
+                },
+                "evmVersion": %EVMVERSION%,
+                "externalReferences": [],
+                "id": 3,
+                "nodeType": "InlineAssembly",
+                "src": "57:151:1"
+              }
+            ]
+          },
+          "id": 5,
+          "implemented": true,
+          "kind": "function",
+          "modifiers": [],
+          "name": "f",
+          "nameLocation": "31:1:1",
+          "nodeType": "FunctionDefinition",
+          "parameters":
+          {
+            "id": 1,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "32:2:1"
+          },
+          "returnParameters":
+          {
+            "id": 2,
+            "nodeType": "ParameterList",
+            "parameters": [],
+            "src": "47:0:1"
+          },
+          "src": "22:192:1",
+          "stateMutability": "pure",
+          "virtual": false,
+          "visibility": "public"
+        }
+      ],
+      "src": "0:216:1",
+      "usedErrors": [],
+      "usedEvents": []
+    }
+  ],
+  "src": "0:217:1"
+}
diff --git a/compiler/test/libsolidity/ASTJSONTest.cpp b/compiler/test/libsolidity/ASTJSONTest.cpp
new file mode 100644
index 00000000..daf4a9ea
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSONTest.cpp
@@ -0,0 +1,322 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <liblangutil/SourceReferenceFormatter.h>
+#include <libsolidity/ast/ASTJsonExporter.h>
+#include <libsolutil/AnsiColorized.h>
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/JSON.h>
+
+#include <test/Common.h>
+#include <test/libsolidity/ASTJSONTest.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <fstream>
+#include <memory>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::util::formatting;
+using namespace solidity::util;
+namespace fs = boost::filesystem;
+using namespace boost::unit_test;
+using namespace std::string_literals;
+
+namespace
+{
+
+std::string const sourceDelimiter("==== Source: ");
+
+std::string compilerStateToString(CompilerStack::State _state)
+{
+	switch (_state)
+	{
+		case CompilerStack::State::Empty: return "Empty";
+		case CompilerStack::State::SourcesSet: return "SourcesSet";
+		case CompilerStack::State::Parsed: return "Parsed";
+		case CompilerStack::State::ParsedAndImported: return "ParsedAndImported";
+		case CompilerStack::State::AnalysisSuccessful: return "AnalysisSuccessful";
+		case CompilerStack::State::CompilationSuccessful: return "CompilationSuccessful";
+	}
+	soltestAssert(false, "Unexpected value of state parameter");
+}
+
+CompilerStack::State stringToCompilerState(const std::string& _state)
+{
+	for (unsigned int i = CompilerStack::State::Empty; i <= CompilerStack::State::CompilationSuccessful; ++i)
+	{
+		if (_state == compilerStateToString(CompilerStack::State(i)))
+			return CompilerStack::State(i);
+	}
+	BOOST_THROW_EXCEPTION(std::runtime_error("Unsupported compiler state (" + _state + ") in test contract file"));
+}
+
+void replaceVersionWithTag(std::string& _input)
+{
+	boost::algorithm::replace_all(
+		_input,
+		"\"" + solidity::test::CommonOptions::get().evmVersion().name() + "\"",
+		"%EVMVERSION%"
+	);
+}
+
+void replaceTagWithVersion(std::string& _input)
+{
+	boost::algorithm::replace_all(
+		_input,
+		"%EVMVERSION%",
+		"\"" + solidity::test::CommonOptions::get().evmVersion().name() + "\""
+	);
+}
+
+}
+
+void ASTJSONTest::generateTestVariants(std::string const& _filename)
+{
+	std::string_view baseName = _filename;
+	baseName.remove_suffix(4);
+
+	const std::vector<CompilerStack::State> variantCompileStates = {
+		CompilerStack::State::Parsed,
+		CompilerStack::State::AnalysisSuccessful,
+	};
+
+	for (const auto state: variantCompileStates)
+	{
+		auto variant = TestVariant(baseName, state);
+		if (boost::filesystem::exists(variant.astFilename()))
+		{
+			variant.expectation = readFileAsString(variant.astFilename());
+			boost::replace_all(variant.expectation, "\r\n", "\n");
+			m_variants.push_back(variant);
+		}
+	}
+}
+
+void ASTJSONTest::fillSources(std::string const& _filename)
+{
+	std::ifstream file(_filename);
+	if (!file)
+		BOOST_THROW_EXCEPTION(std::runtime_error("Cannot open test contract: \"" + _filename + "\"."));
+	file.exceptions(std::ios::badbit);
+
+	std::string sourceName;
+	std::string source;
+	std::string line;
+	std::string const delimiter("// ----");
+	std::string const failMarker("// failAfter:");
+	while (getline(file, line))
+	{
+		if (boost::algorithm::starts_with(line, sourceDelimiter))
+		{
+			if (!sourceName.empty())
+				m_sources.emplace_back(sourceName, source);
+
+			sourceName = line.substr(
+				sourceDelimiter.size(),
+				line.size() - " ===="s.size() - sourceDelimiter.size()
+			);
+			source = std::string();
+		}
+		else if (boost::algorithm::starts_with(line, failMarker))
+		{
+			std::string state = line.substr(failMarker.size());
+			boost::algorithm::trim(state);
+			if (m_expectedFailAfter.has_value())
+				BOOST_THROW_EXCEPTION(std::runtime_error("Duplicated \"failAfter\" directive"));
+			m_expectedFailAfter = stringToCompilerState(state);
+
+		}
+		else if (!line.empty() && !boost::algorithm::starts_with(line, delimiter))
+			source += line + "\n";
+	}
+	m_sources.emplace_back(sourceName.empty() ? "a" : sourceName, source);
+	file.close();
+}
+
+void ASTJSONTest::validateTestConfiguration() const
+{
+	if (m_variants.empty())
+		BOOST_THROW_EXCEPTION(std::runtime_error("No file with expected result found."));
+
+	if (m_expectedFailAfter.has_value())
+	{
+		auto unexpectedTestVariant = std::find_if(
+			m_variants.begin(), m_variants.end(),
+			[failAfter = m_expectedFailAfter](TestVariant v) { return v.stopAfter > failAfter; }
+		);
+
+		if (unexpectedTestVariant != m_variants.end())
+			BOOST_THROW_EXCEPTION(
+				std::runtime_error(
+					std::string("Unexpected JSON file: ") + unexpectedTestVariant->astFilename() +
+					" in \"failAfter: " +
+					compilerStateToString(m_expectedFailAfter.value()) + "\" scenario."
+				)
+			);
+	}
+}
+
+ASTJSONTest::ASTJSONTest(std::string const& _filename):
+	EVMVersionRestrictedTestCase(_filename)
+{
+	if (!boost::algorithm::ends_with(_filename, ".sol"))
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid test contract file name: \"" + _filename + "\"."));
+
+	generateTestVariants(_filename);
+	fillSources(_filename);
+	validateTestConfiguration();
+}
+
+TestCase::TestResult ASTJSONTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	CompilerStack c;
+
+	StringMap sources;
+	std::map<std::string, unsigned> sourceIndices;
+	for (size_t i = 0; i < m_sources.size(); i++)
+	{
+		sources[m_sources[i].first] = m_sources[i].second;
+		sourceIndices[m_sources[i].first] = static_cast<unsigned>(i + 1);
+	}
+
+	bool resultsMatch = true;
+
+	for (TestVariant& variant: m_variants)
+	{
+		c.reset();
+		c.setSources(sources);
+		c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+
+		if (!c.parseAndAnalyze(variant.stopAfter))
+		{
+			if (!m_expectedFailAfter.has_value() || m_expectedFailAfter.value() + 1 != c.state())
+			{
+				SourceReferenceFormatter formatter(_stream, c, _formatted, false);
+				formatter.printErrorInformation(c.errors());
+				return TestResult::FatalError;
+			}
+		}
+
+		resultsMatch = resultsMatch && runTest(
+			variant,
+			sourceIndices,
+			c,
+			_stream,
+			_linePrefix,
+			_formatted
+		);
+	}
+
+	return resultsMatch ? TestResult::Success : TestResult::Failure;
+}
+
+bool ASTJSONTest::runTest(
+	TestVariant& _variant,
+	std::map<std::string, unsigned> const& _sourceIndices,
+	CompilerStack& _compiler,
+	std::ostream& _stream,
+	std::string const& _linePrefix,
+	bool const _formatted
+)
+{
+	if (m_sources.size() > 1)
+		_variant.result += "[\n";
+
+	for (size_t i = 0; i < m_sources.size(); i++)
+	{
+		std::ostringstream result;
+		ASTJsonExporter(_compiler.state(), _sourceIndices).print(result, _compiler.ast(m_sources[i].first), JsonFormat{ JsonFormat::Pretty });
+		_variant.result += result.str();
+		if (i != m_sources.size() - 1)
+			_variant.result += ",";
+		_variant.result += "\n";
+	}
+
+	if (m_sources.size() > 1)
+		_variant.result += "]\n";
+
+	replaceTagWithVersion(_variant.expectation);
+
+	if (_variant.expectation != _variant.result)
+	{
+		std::string nextIndentLevel = _linePrefix + "  ";
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) <<
+			_linePrefix <<
+			"Expected result" <<
+			(!_variant.name().empty() ? " (" + _variant.name() + "):" : ":") <<
+			std::endl;
+		printPrefixed(_stream, _variant.expectation, nextIndentLevel);
+		_stream << std::endl;
+
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) <<
+			_linePrefix <<
+			"Obtained result" <<
+			(!_variant.name().empty() ? " (" + _variant.name() + "):" : ":") <<
+			std::endl;
+		printPrefixed(_stream, _variant.result, nextIndentLevel);
+		_stream << std::endl;
+		return false;
+	}
+
+	return true;
+}
+
+void ASTJSONTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool const) const
+{
+	for (auto const& source: m_sources)
+	{
+		if (m_sources.size() > 1 || source.first != "a")
+			printPrefixed(_stream, sourceDelimiter + source.first + " ====\n", _linePrefix);
+		printPrefixed(_stream, source.second, _linePrefix);
+		_stream << std::endl;
+	}
+}
+
+void ASTJSONTest::printUpdatedExpectations(std::ostream&, std::string const&) const
+{
+	for (TestVariant const& variant: m_variants)
+		updateExpectation(
+			variant.astFilename(),
+			variant.result,
+			variant.name().empty() ? "" : variant.name() + " "
+		);
+}
+
+void ASTJSONTest::updateExpectation(std::string const& _filename, std::string const& _expectation, std::string const& _variant) const
+{
+	std::ofstream file(_filename.c_str());
+	if (!file) BOOST_THROW_EXCEPTION(std::runtime_error("Cannot write " + _variant + "AST expectation to \"" + _filename + "\"."));
+	file.exceptions(std::ios::badbit);
+
+	std::string replacedResult = _expectation;
+	replaceVersionWithTag(replacedResult);
+
+	file << replacedResult;
+	file.flush();
+	file.close();
+}
diff --git a/compiler/test/libsolidity/ASTJSONTest.h b/compiler/test/libsolidity/ASTJSONTest.h
new file mode 100644
index 00000000..1e74b62f
--- /dev/null
+++ b/compiler/test/libsolidity/ASTJSONTest.h
@@ -0,0 +1,102 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <libsolutil/AnsiColorized.h>
+#include <libsolidity/interface/CompilerStack.h>
+#include <test/TestCase.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend
+{
+class CompilerStack;
+}
+
+namespace solidity::frontend::test
+{
+
+class ASTJSONTest: public EVMVersionRestrictedTestCase
+{
+public:
+	struct TestVariant
+	{
+		TestVariant(std::string_view _baseName, CompilerStack::State _stopAfter):
+			baseName(_baseName),
+			stopAfter(_stopAfter)
+		{}
+
+		std::string name() const
+		{
+			return stopAfter == CompilerStack::State::Parsed ? "parseOnly" : "";
+		}
+
+		std::string astFilename() const
+		{
+			return std::string(baseName) +
+				(name().empty() ? "" : "_") +
+				name() +
+				".json";
+		}
+
+		std::string baseName;
+		CompilerStack::State stopAfter;
+		std::string result;
+		std::string expectation;
+	};
+
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<ASTJSONTest>(_config.filename);
+	}
+	ASTJSONTest(std::string const& _filename);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+
+	void printSource(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) const override;
+	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const override;
+private:
+	bool runTest(
+		TestVariant& _testVariant,
+		std::map<std::string, unsigned> const& _sourceIndices,
+		CompilerStack& _compiler,
+		std::ostream& _stream,
+		std::string const& _linePrefix = "",
+		bool const _formatted = false
+	);
+	void updateExpectation(
+		std::string const& _filename,
+		std::string const& _expectation,
+		std::string const& _variant
+	) const;
+
+	void generateTestVariants(std::string const& _filename);
+	void fillSources(std::string const& _filename);
+	void validateTestConfiguration() const;
+
+	std::vector<TestVariant> m_variants;
+	std::optional<CompilerStack::State> m_expectedFailAfter;
+
+	std::vector<std::pair<std::string, std::string>> m_sources;
+};
+
+}
diff --git a/compiler/test/libsolidity/ASTPropertyTest.cpp b/compiler/test/libsolidity/ASTPropertyTest.cpp
new file mode 100644
index 00000000..8dc2c293
--- /dev/null
+++ b/compiler/test/libsolidity/ASTPropertyTest.cpp
@@ -0,0 +1,204 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/ASTPropertyTest.h>
+#include <test/Common.h>
+
+#include <libsolidity/ast/ASTJsonExporter.h>
+#include <libsolidity/interface/CompilerStack.h>
+
+#include <liblangutil/Common.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+#include <libsolutil/JSON.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <range/v3/algorithm/find_if.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/split.hpp>
+
+#include <queue>
+
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity;
+using namespace std::string_literals;
+
+ASTPropertyTest::ASTPropertyTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	if (!boost::algorithm::ends_with(_filename, ".sol"))
+		BOOST_THROW_EXCEPTION(std::runtime_error("Not a Solidity file: \"" + _filename + "\"."));
+
+	m_source = m_reader.source();
+	readExpectations();
+	soltestAssert(m_tests.size() > 0, "No tests specified in " + _filename);
+}
+
+std::string ASTPropertyTest::formatExpectations(bool _obtainedResult)
+{
+	std::string expectations;
+	for (std::string const& testId: m_testOrder)
+	{
+		soltestAssert(m_tests.count(testId) > 0);
+		expectations +=
+			testId +
+			": " +
+			(_obtainedResult ? m_tests[testId].obtainedValue : m_tests[testId].expectedValue)
+			+ "\n";
+	}
+	return expectations;
+}
+
+std::vector<StringPair> ASTPropertyTest::readKeyValuePairs(std::string const& _input)
+{
+	std::vector<StringPair> result;
+	for (std::string line: _input | ranges::views::split('\n') | ranges::to<std::vector<std::string>>)
+	{
+		boost::trim(line);
+		if (line.empty())
+			continue;
+
+		soltestAssert(
+			ranges::all_of(line, [](char c) { return isprint(c); }),
+			"Non-printable character(s) found in property test: " + line
+		);
+
+		auto colonPosition = line.find_first_of(':');
+		soltestAssert(colonPosition != std::string::npos, "Property test is missing a colon: " + line);
+
+		StringPair pair{
+			boost::trim_copy(line.substr(0, colonPosition)),
+			boost::trim_copy(line.substr(colonPosition + 1))
+		};
+		soltestAssert(!std::get<0>(pair).empty() != false, "Empty key in property test: " + line);
+		soltestAssert(!std::get<1>(pair).empty() != false, "Empty value in property test: " + line);
+
+		result.push_back(pair);
+	}
+	return result;
+}
+
+void ASTPropertyTest::readExpectations()
+{
+	for (auto const& [testId, testExpectation]: readKeyValuePairs(m_reader.simpleExpectations()))
+	{
+		soltestAssert(m_tests.count(testId) == 0, "More than one expectation for test \"" + testId + "\"");
+		m_tests.emplace(testId, Test{"", testExpectation, ""});
+		m_testOrder.push_back(testId);
+	}
+	m_expectation = formatExpectations(false /* _obtainedResult */);
+}
+
+void ASTPropertyTest::extractTestsFromAST(Json::Value const& _astJson)
+{
+	std::queue<Json::Value> nodesToVisit;
+	nodesToVisit.push(_astJson);
+
+	while (!nodesToVisit.empty())
+	{
+		Json::Value& node = nodesToVisit.front();
+
+		if (node.isArray())
+			for (auto&& member: node)
+				nodesToVisit.push(member);
+		else if (node.isObject())
+			for (std::string const& memberName: node.getMemberNames())
+			{
+				if (memberName != "documentation")
+				{
+					nodesToVisit.push(node[memberName]);
+					continue;
+				}
+
+				std::string nodeDocstring = node["documentation"].isObject() ?
+					node["documentation"]["text"].asString() :
+					node["documentation"].asString();
+				soltestAssert(!nodeDocstring.empty());
+
+				std::vector<StringPair> pairs = readKeyValuePairs(nodeDocstring);
+				if (pairs.empty())
+					continue;
+
+				for (auto const& [testId, testedProperty]: pairs)
+				{
+					soltestAssert(
+						m_tests.count(testId) > 0,
+						"Test \"" + testId + "\" does not have a corresponding expected value."
+					);
+					soltestAssert(
+						m_tests[testId].property.empty(),
+						"Test \"" + testId + "\" was already defined before."
+					);
+					m_tests[testId].property = testedProperty;
+
+					soltestAssert(node.isMember("nodeType"));
+					std::optional<Json::Value> propertyNode = jsonValueByPath(node, testedProperty);
+					soltestAssert(
+						propertyNode.has_value(),
+						node["nodeType"].asString() + " node does not have a property named \""s + testedProperty + "\""
+					);
+					soltestAssert(
+						!propertyNode->isObject() && !propertyNode->isArray(),
+						"Property \"" + testedProperty + "\" is an object or an array."
+					);
+					m_tests[testId].obtainedValue = propertyNode->asString();
+				}
+			}
+
+		nodesToVisit.pop();
+	}
+
+	auto firstTestWithoutProperty = ranges::find_if(
+		m_tests,
+		[&](auto const& _testCase) { return _testCase.second.property.empty(); }
+	);
+	soltestAssert(
+		firstTestWithoutProperty == ranges::end(m_tests),
+		"AST property not defined for test \"" + firstTestWithoutProperty->first + "\""
+	);
+
+	m_obtainedResult = formatExpectations(true /* _obtainedResult */);
+}
+
+TestCase::TestResult ASTPropertyTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	CompilerStack compiler;
+
+	compiler.setSources({{
+		"A",
+		"pragma solidity >=0.0;\n// SPDX-License-Identifier: GPL-3.0\n" + m_source
+	}});
+	compiler.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+	if (!compiler.parseAndAnalyze())
+		BOOST_THROW_EXCEPTION(std::runtime_error(
+			"Parsing contract failed" +
+			SourceReferenceFormatter::formatErrorInformation(compiler.errors(), compiler, _formatted)
+		));
+
+	Json::Value astJson = ASTJsonExporter(compiler.state()).toJson(compiler.ast("A"));
+	soltestAssert(astJson);
+
+	extractTestsFromAST(astJson);
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libsolidity/ASTPropertyTest.h b/compiler/test/libsolidity/ASTPropertyTest.h
new file mode 100644
index 00000000..e4cec052
--- /dev/null
+++ b/compiler/test/libsolidity/ASTPropertyTest.h
@@ -0,0 +1,66 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+
+#include <libsolutil/JSON.h>
+
+#include <string>
+#include <vector>
+
+namespace solidity::frontend
+{
+class CompilerStack;
+}
+
+namespace solidity::frontend::test
+{
+
+using StringPair = std::pair<std::string, std::string>;
+
+class ASTPropertyTest: public TestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<ASTPropertyTest>(_config.filename);
+	}
+	ASTPropertyTest(std::string const& _filename);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+
+private:
+	struct Test
+	{
+		std::string property;
+		std::string expectedValue;
+		std::string obtainedValue;
+	};
+
+	void readExpectations();
+	std::vector<StringPair> readKeyValuePairs(std::string const& _input);
+	void extractTestsFromAST(Json::Value const& _astJson);
+	std::string formatExpectations(bool _obtainedResult = true);
+
+	std::vector<std::string> m_testOrder;
+	std::map<std::string, Test> m_tests;
+};
+
+}
diff --git a/compiler/test/libsolidity/AnalysisFramework.cpp b/compiler/test/libsolidity/AnalysisFramework.cpp
new file mode 100644
index 00000000..dc52ffc1
--- /dev/null
+++ b/compiler/test/libsolidity/AnalysisFramework.cpp
@@ -0,0 +1,232 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Framework for testing features from the analysis phase of compiler.
+ */
+
+#include <test/libsolidity/AnalysisFramework.h>
+
+#include <test/libsolidity/util/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <test/Common.h>
+
+#include <libsolidity/interface/CompilerStack.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolidity/ast/AST.h>
+
+#include <liblangutil/Scanner.h>
+
+#include <libsolutil/FunctionSelector.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+std::pair<SourceUnit const*, ErrorList> AnalysisFramework::runAnalysisAndExpectNoParsingErrors(
+	std::string const& _source,
+	bool _includeWarningsAndInfos,
+	bool _addPreamble,
+	bool _allowMultiple
+)
+{
+	runFramework(_addPreamble ? withPreamble(_source) : _source, PipelineStage::Analysis);
+
+	if (!stageSuccessful(PipelineStage::Parsing))
+		BOOST_FAIL("Parsing contract failed in analysis test suite:" + formatErrors(m_compiler->errors()));
+
+	ErrorList errors = filteredErrors(_includeWarningsAndInfos);
+	if (errors.size() > 1 && !_allowMultiple)
+		BOOST_FAIL("Multiple errors found: " + formatErrors(errors));
+
+	return make_pair(&compiler().ast(""), std::move(errors));
+}
+
+bool AnalysisFramework::runFramework(StringMap _sources, PipelineStage _targetStage)
+{
+	resetFramework();
+	m_targetStage = _targetStage;
+	soltestAssert(m_compiler);
+
+	m_compiler->setSources(std::move(_sources));
+	setupCompiler(*m_compiler);
+	executeCompilationPipeline();
+	return pipelineSuccessful();
+}
+
+void AnalysisFramework::resetFramework()
+{
+	compiler().reset();
+	m_targetStage = PipelineStage::Compilation;
+}
+
+std::unique_ptr<CompilerStack> AnalysisFramework::createStack() const
+{
+	return std::make_unique<CompilerStack>();
+}
+
+void AnalysisFramework::setupCompiler(CompilerStack& _compiler)
+{
+	// These are just defaults based on the (global) CLI options.
+	// Technically, every TestCase should override these with values passed to it in TestCase::Config.
+	// In practice TestCase::Config always matches global config so most test cases don't care.
+	_compiler.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	_compiler.setEOFVersion(solidity::test::CommonOptions::get().eofVersion());
+	_compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+}
+
+void AnalysisFramework::executeCompilationPipeline()
+{
+	soltestAssert(m_compiler);
+
+	// If you add a new stage, remember to handle it below.
+	soltestAssert(
+		m_targetStage == PipelineStage::Parsing ||
+		m_targetStage == PipelineStage::Analysis ||
+		m_targetStage == PipelineStage::Compilation
+	);
+
+	bool parsingSuccessful = m_compiler->parse();
+	soltestAssert(parsingSuccessful || !filteredErrors(false /* _includeWarningsAndInfos */).empty());
+	if (!parsingSuccessful || stageSuccessful(m_targetStage))
+		return;
+
+	bool analysisSuccessful = m_compiler->analyze();
+	soltestAssert(analysisSuccessful || !filteredErrors(false /* _includeWarningsAndInfos */).empty());
+	if (!analysisSuccessful || stageSuccessful(m_targetStage))
+		return;
+
+	bool compilationSuccessful = m_compiler->compile();
+	soltestAssert(compilationSuccessful || !filteredErrors(false /* _includeWarningsAndInfos */).empty());
+	soltestAssert(stageSuccessful(m_targetStage) == compilationSuccessful);
+}
+
+ErrorList AnalysisFramework::filterErrors(ErrorList const& _errorList, bool _includeWarningsAndInfos) const
+{
+	ErrorList errors;
+	for (auto const& currentError: _errorList)
+	{
+		solAssert(currentError->comment(), "");
+		if (!Error::isError(currentError->type()))
+		{
+			if (!_includeWarningsAndInfos)
+				continue;
+			bool ignoreWarningsAndInfos = false;
+			for (auto const& filter: m_warningsToFilter)
+				if (currentError->comment()->find(filter) == 0)
+				{
+					ignoreWarningsAndInfos = true;
+					break;
+				}
+			if (ignoreWarningsAndInfos)
+				continue;
+		}
+
+		std::shared_ptr<Error const> newError = currentError;
+		for (auto const& messagePrefix: m_messagesToCut)
+			if (currentError->comment()->find(messagePrefix) == 0)
+			{
+				SourceLocation const* location = currentError->sourceLocation();
+				// sufficient for now, but in future we might clone the error completely, including the secondary location
+				newError = std::make_shared<Error>(
+					currentError->errorId(),
+					currentError->type(),
+					messagePrefix + " ....",
+					location ? *location : SourceLocation()
+				);
+				break;
+			}
+
+		errors.emplace_back(newError);
+	}
+
+	return errors;
+}
+
+bool AnalysisFramework::stageSuccessful(PipelineStage _stage) const
+{
+	switch (_stage) {
+		case PipelineStage::Parsing: return compiler().state() >= CompilerStack::Parsed;
+		case PipelineStage::Analysis: return compiler().state() >= CompilerStack::AnalysisSuccessful;
+		case PipelineStage::Compilation: return compiler().state() >= CompilerStack::CompilationSuccessful;
+	}
+	unreachable();
+}
+
+ErrorList AnalysisFramework::runAnalysisAndExpectError(
+	std::string const& _source,
+	bool _includeWarningsAndInfos,
+	bool _allowMultiple
+)
+{
+	auto [ast, errors] = runAnalysisAndExpectNoParsingErrors(_source, _includeWarningsAndInfos, true, _allowMultiple);
+	BOOST_REQUIRE(!errors.empty());
+	BOOST_REQUIRE_MESSAGE(ast, "Expected error, but no error happened.");
+	return errors;
+}
+
+std::string AnalysisFramework::formatErrors(
+	langutil::ErrorList const& _errors,
+	bool _colored,
+	bool _withErrorIds
+) const
+{
+	return SourceReferenceFormatter::formatErrorInformation(
+		_errors,
+		*m_compiler,
+		_colored,
+		_withErrorIds
+	);
+}
+
+std::string AnalysisFramework::formatError(
+	Error const& _error,
+	bool _colored,
+	bool _withErrorIds
+) const
+{
+	return SourceReferenceFormatter::formatErrorInformation(
+		_error,
+		*m_compiler,
+		_colored,
+		_withErrorIds
+	);
+}
+
+ContractDefinition const* AnalysisFramework::retrieveContractByName(SourceUnit const& _source, std::string const& _name)
+{
+	ContractDefinition* contract = nullptr;
+
+	for (std::shared_ptr<ASTNode> const& node: _source.nodes())
+		if ((contract = dynamic_cast<ContractDefinition*>(node.get())) && contract->name() == _name)
+			return contract;
+
+	return nullptr;
+}
+
+FunctionTypePointer AnalysisFramework::retrieveFunctionBySignature(
+	ContractDefinition const& _contract,
+	std::string const& _signature
+)
+{
+	return _contract.interfaceFunctions()[util::selectorFromSignatureH32(_signature)];
+}
diff --git a/compiler/test/libsolidity/AnalysisFramework.h b/compiler/test/libsolidity/AnalysisFramework.h
new file mode 100644
index 00000000..e7b2c03e
--- /dev/null
+++ b/compiler/test/libsolidity/AnalysisFramework.h
@@ -0,0 +1,227 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Framework for testing features from the analysis phase of compiler.
+ */
+
+#pragma once
+
+#include <test/libsolidity/ErrorCheck.h>
+
+#include <libsolidity/interface/CompilerStack.h>
+
+#include <functional>
+#include <string>
+#include <memory>
+
+namespace solidity::frontend
+{
+class Type;
+class FunctionType;
+using FunctionTypePointer = FunctionType const*;
+}
+
+namespace solidity::frontend::test
+{
+
+enum class PipelineStage {
+	Parsing,
+	Analysis,
+	Compilation,
+};
+
+class AnalysisFramework
+{
+
+protected:
+	virtual ~AnalysisFramework() = default;
+
+	/// Runs analysis via runFramework() and returns either an AST or a filtered list of errors.
+	/// Uses Boost test macros to fail if errors do not occur specifically at the analysis stage.
+	///
+	/// @deprecated This is a legacy helper. Use runFramework() directly in new tests.
+	///
+	/// @param _includeWarningsAndInfos Do not remove warning and info messages from the error list.
+	/// @param _addPreamble Apply withPreamble() to @p _source.
+	/// @param _allowMultiple When false, use Boost test macros to fail when there's more
+	///        than one item on the error list.
+	std::pair<SourceUnit const*, langutil::ErrorList> runAnalysisAndExpectNoParsingErrors(
+		std::string const& _source,
+		bool _includeWarningsAndInfos = false,
+		bool _addPreamble = true,
+		bool _allowMultiple = false
+	);
+
+	/// Runs analysis via runAnalysisAndExpectNoParsingErrors() and returns the list of errors.
+	/// Uses Boost test macros to fail if there are no errors.
+	///
+	/// @deprecated This is a legacy helper. Use runFramework() directly in new tests.
+	///
+	/// @param _includeWarningsAndInfos Do not remove warning and info messages from the error list.
+	/// @param _allowMultiple When false, use Boost test macros to fail when there's more
+	///        than one item on the error list.
+	langutil::ErrorList runAnalysisAndExpectError(
+		std::string const& _source,
+		bool _includeWarningsAndInfos = false,
+		bool _allowMultiple = false
+	);
+
+public:
+	/// Runs the full compiler pipeline on specified sources. This is the main function of the
+	/// framework. Resets the stack, configures it and runs either until the first failed stage or
+	/// until the @p _targetStage is reached.
+	/// Afterwards the caller can inspect the stack via @p compiler(). The framework provides a few
+	/// convenience helpers to check the state and error list, in general the caller can freely
+	/// access the stack, including generating outputs if the compilation succeeded.
+	bool runFramework(StringMap _sources, PipelineStage _targetStage = PipelineStage::Compilation);
+	bool runFramework(std::string _source, PipelineStage _targetStage = PipelineStage::Compilation)
+	{
+		return runFramework({{"", std::move(_source)}}, _targetStage);
+	}
+
+	void resetFramework();
+
+	PipelineStage targetStage() const { return m_targetStage; }
+	bool pipelineSuccessful() const { return stageSuccessful(m_targetStage); }
+	bool stageSuccessful(PipelineStage _stage) const;
+
+	std::string formatErrors(
+		langutil::ErrorList const& _errors,
+		bool _colored = false,
+		bool _withErrorIds = false
+	) const;
+	std::string formatError(
+		langutil::Error const& _error,
+		bool _colored = false,
+		bool _withErrorIds = false
+	) const;
+
+	static ContractDefinition const* retrieveContractByName(SourceUnit const& _source, std::string const& _name);
+	static FunctionTypePointer retrieveFunctionBySignature(
+		ContractDefinition const& _contract,
+		std::string const& _signature
+	);
+
+	/// filter out the warnings in m_warningsToFilter or all warnings and infos if _includeWarningsAndInfos is false
+	langutil::ErrorList filterErrors(langutil::ErrorList const& _errorList, bool _includeWarningsAndInfos = true) const;
+	langutil::ErrorList filteredErrors(bool _includeWarningsAndInfos = true) const
+	{
+		return filterErrors(compiler().errors(), _includeWarningsAndInfos);
+	}
+
+	/// @returns reference to lazy-instantiated CompilerStack.
+	solidity::frontend::CompilerStack& compiler()
+	{
+		if (!m_compiler)
+			m_compiler = createStack();
+		return *m_compiler;
+	}
+
+	/// @returns reference to lazy-instantiated CompilerStack.
+	solidity::frontend::CompilerStack const& compiler() const
+	{
+		if (!m_compiler)
+			m_compiler = createStack();
+		return *m_compiler;
+	}
+
+protected:
+	/// Creates a new instance of @p CompilerStack. Override if your test case needs to pass in
+	/// custom constructor arguments.
+	virtual std::unique_ptr<CompilerStack> createStack() const;
+
+	/// Configures @p CompilerStack. The default implementation sets basic parameters based on
+	/// CLI options. Override if your test case needs extra configuration.
+	virtual void setupCompiler(CompilerStack& _compiler);
+
+	/// Executes the requested pipeline stages until @p m_targetStage is reached.
+	/// Stops at the first failed stage.
+	void executeCompilationPipeline();
+
+	std::vector<std::string> m_warningsToFilter = {"This is a pre-release compiler version"};
+	std::vector<std::string> m_messagesToCut = {"Source file requires different compiler version (current compiler is"};
+
+private:
+	mutable std::unique_ptr<solidity::frontend::CompilerStack> m_compiler;
+	PipelineStage m_targetStage = PipelineStage::Compilation;
+};
+
+// Asserts that the compilation down to typechecking
+// emits multiple errors of different types and messages, provided in the second argument.
+#define CHECK_ALLOW_MULTI(text, expectations) \
+do \
+{ \
+	ErrorList errors = runAnalysisAndExpectError((text), true, true); \
+	auto message = searchErrors(errors, (expectations)); \
+	BOOST_CHECK_MESSAGE(message.empty(), message); \
+} while(0)
+
+#define CHECK_ERROR_OR_WARNING(text, typ, substrings, includeWarningsAndInfos, allowMulti) \
+do \
+{ \
+	ErrorList errors = runAnalysisAndExpectError((text), (includeWarningsAndInfos), (allowMulti)); \
+	std::vector<std::pair<Error::Type, std::string>> expectations; \
+	for (auto const& str: substrings) \
+		expectations.emplace_back((Error::Type::typ), str); \
+	auto message = searchErrors(errors, expectations); \
+	BOOST_CHECK_MESSAGE(message.empty(), message); \
+} while(0)
+
+// [checkError(text, type, substring)] asserts that the compilation down to typechecking
+// emits an error of type [type] and with a message containing [substring].
+#define CHECK_ERROR(text, type, substring) \
+CHECK_ERROR_OR_WARNING(text, type, std::vector<std::string>{(substring)}, false, false)
+
+// [checkError(text, type, substring)] asserts that the compilation down to typechecking
+// emits multiple errors of the same type [type] and with a messages containing [substrings].
+// Because of the limitations of the preprocessor, you cannot use {{T1, "abc"}, {T2, "def"}} as arguments,
+// but have to replace them by (std::vector<std::pair<Error::Type, std::string>>{"abc", "def"})
+// (note the parentheses)
+#define CHECK_ERROR_ALLOW_MULTI(text, type, substrings) \
+CHECK_ERROR_OR_WARNING(text, type, substrings, false, true)
+
+// [checkWarning(text, substring)] asserts that the compilation down to typechecking
+// emits a warning and with a message containing [substring].
+#define CHECK_WARNING(text, substring) \
+CHECK_ERROR_OR_WARNING(text, Warning, std::vector<std::string>{(substring)}, true, false)
+
+// [checkWarningAllowMulti(text, substring)] aserts that the compilation down to typechecking
+// emits a warning and with a message containing [substring].
+// Because of the limitations of the preprocessor, you cannot use {"abc", "def"} as arguments,
+// but have to replace them by (std::vector<std::string>{"abc", "def"}) (note the parentheses)
+#define CHECK_WARNING_ALLOW_MULTI(text, substrings) \
+CHECK_ERROR_OR_WARNING(text, Warning, substrings, true, true)
+
+// [checkSuccess(text)] asserts that the compilation down to typechecking succeeds.
+#define CHECK_SUCCESS(text) do { \
+	auto [ast, errors] = runAnalysisAndExpectNoParsingErrors((text)); \
+	BOOST_CHECK(errors.empty()); \
+} while(0)
+
+#define CHECK_SUCCESS_NO_WARNINGS(text) \
+do \
+{ \
+	auto [ast, errors] = runAnalysisAndExpectNoParsingErrors((text), true); \
+	std::string message; \
+	if (!errors.empty()) \
+		message = formatErrors(errors);\
+	BOOST_CHECK_MESSAGE(errors.empty(), message); \
+} \
+while(0)
+
+}
diff --git a/compiler/test/libsolidity/Assembly.cpp b/compiler/test/libsolidity/Assembly.cpp
new file mode 100644
index 00000000..7def76e6
--- /dev/null
+++ b/compiler/test/libsolidity/Assembly.cpp
@@ -0,0 +1,222 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Lefteris Karapetsas <lefteris@ethdev.com>
+ * @date 2015
+ * Unit tests for Assembly Items from evmasm/Assembly.h
+ */
+
+#include <test/Common.h>
+
+#include <liblangutil/SourceLocation.h>
+#include <libevmasm/Assembly.h>
+
+#include <liblangutil/CharStream.h>
+
+#include <libsolidity/parsing/Parser.h>
+#include <libsolidity/analysis/DeclarationTypeChecker.h>
+#include <libsolidity/analysis/NameAndTypeResolver.h>
+#include <libsolidity/analysis/Scoper.h>
+#include <libsolidity/codegen/Compiler.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/analysis/TypeChecker.h>
+#include <libsolidity/analysis/SyntaxChecker.h>
+#include <liblangutil/ErrorReporter.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+
+using namespace solidity::langutil;
+using namespace solidity::evmasm;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+evmasm::AssemblyItems compileContract(std::shared_ptr<CharStream> _sourceCode)
+{
+	ErrorList errors;
+	ErrorReporter errorReporter(errors);
+	Parser parser(errorReporter, solidity::test::CommonOptions::get().evmVersion());
+	ASTPointer<SourceUnit> sourceUnit;
+	BOOST_REQUIRE_NO_THROW(sourceUnit = parser.parse(*_sourceCode));
+	BOOST_CHECK(!!sourceUnit);
+
+	Scoper::assignScopes(*sourceUnit);
+	BOOST_REQUIRE(SyntaxChecker(errorReporter, false).checkSyntax(*sourceUnit));
+	GlobalContext globalContext(solidity::test::CommonOptions::get().evmVersion());
+	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), errorReporter, false);
+	DeclarationTypeChecker declarationTypeChecker(errorReporter, solidity::test::CommonOptions::get().evmVersion());
+	solAssert(!Error::containsErrors(errorReporter.errors()), "");
+	resolver.registerDeclarations(*sourceUnit);
+	BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*sourceUnit));
+	if (Error::containsErrors(errorReporter.errors()))
+		return AssemblyItems();
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+	{
+		BOOST_REQUIRE_NO_THROW(declarationTypeChecker.check(*node));
+		if (Error::containsErrors(errorReporter.errors()))
+			return AssemblyItems();
+	}
+	TypeChecker checker(solidity::test::CommonOptions::get().evmVersion(), errorReporter);
+	BOOST_REQUIRE_NO_THROW(checker.checkTypeRequirements(*sourceUnit));
+	if (Error::containsErrors(errorReporter.errors()))
+		return AssemblyItems();
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			Compiler compiler(
+				solidity::test::CommonOptions::get().evmVersion(),
+				RevertStrings::Default,
+				solidity::test::CommonOptions::get().optimize ? OptimiserSettings::standard() : OptimiserSettings::minimal()
+			);
+			compiler.compileContract(*contract, std::map<ContractDefinition const*, std::shared_ptr<Compiler const>>{}, bytes());
+
+			return compiler.runtimeAssembly().items();
+		}
+	BOOST_FAIL("No contract found in source.");
+	return AssemblyItems();
+}
+
+void printAssemblyLocations(AssemblyItems const& _items)
+{
+	auto printRepeated = [](SourceLocation const& _loc, size_t _repetitions)
+	{
+		std::cout <<
+			"\t\tvector<SourceLocation>(" <<
+			_repetitions <<
+			", SourceLocation{" <<
+			_loc.start <<
+			", " <<
+			_loc.end <<
+			", make_shared<string>(\"" <<
+			*_loc.sourceName <<
+			"\")}) +" << std::endl;
+	};
+
+	std::vector<SourceLocation> locations;
+	for (auto const& item: _items)
+		locations.push_back(item.location());
+	size_t repetitions = 0;
+	SourceLocation const* previousLoc = nullptr;
+	for (size_t i = 0; i < locations.size(); ++i)
+	{
+		SourceLocation& loc = locations[i];
+		if (previousLoc && *previousLoc == loc)
+			repetitions++;
+		else
+		{
+			if (previousLoc)
+				printRepeated(*previousLoc, repetitions);
+			previousLoc = &loc;
+			repetitions = 1;
+		}
+	}
+	if (previousLoc)
+		printRepeated(*previousLoc, repetitions);
+}
+
+void checkAssemblyLocations(AssemblyItems const& _items, std::vector<SourceLocation> const& _locations)
+{
+	BOOST_CHECK_EQUAL(_items.size(), _locations.size());
+	for (size_t i = 0; i < std::min(_items.size(), _locations.size()); ++i)
+	{
+		if (_items[i].location().start != _locations[i].start ||
+			_items[i].location().end != _locations[i].end)
+		{
+			BOOST_CHECK_MESSAGE(false, "Location mismatch for item " + std::to_string(i) + ". Found the following locations:");
+			printAssemblyLocations(_items);
+			return;
+		}
+	}
+}
+
+
+} // end anonymous namespace
+
+BOOST_AUTO_TEST_SUITE(Assembly)
+
+BOOST_AUTO_TEST_CASE(location_test)
+{
+	std::string sourceCode = R"(
+	pragma abicoder v1;
+	contract test {
+		function f() public returns (uint256 a) {
+			return 16;
+		}
+	}
+	)";
+	AssemblyItems items = compileContract(std::make_shared<CharStream>(sourceCode, ""));
+	std::shared_ptr<std::string> sourceName = std::make_shared<std::string>();
+	bool hasShifts = solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting();
+
+	auto codegenCharStream = std::make_shared<CharStream>("", "--CODEGEN--");
+
+	std::vector<SourceLocation> locations;
+	if (solidity::test::CommonOptions::get().optimize)
+		locations =
+			std::vector<SourceLocation>(31, SourceLocation{23, 103, sourceName}) +
+			std::vector<SourceLocation>(1, SourceLocation{41, 100, sourceName}) +
+			std::vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
+			std::vector<SourceLocation>(15, SourceLocation{41, 100, sourceName});
+	else
+		locations =
+			std::vector<SourceLocation>(hasShifts ? 31 : 32, SourceLocation{23, 103, sourceName}) +
+			std::vector<SourceLocation>(24, SourceLocation{41, 100, sourceName}) +
+			std::vector<SourceLocation>(1, SourceLocation{70, 79, sourceName}) +
+			std::vector<SourceLocation>(1, SourceLocation{93, 95, sourceName}) +
+			std::vector<SourceLocation>(2, SourceLocation{86, 95, sourceName}) +
+			std::vector<SourceLocation>(2, SourceLocation{41, 100, sourceName});
+	checkAssemblyLocations(items, locations);
+}
+
+
+BOOST_AUTO_TEST_CASE(jump_type)
+{
+	auto sourceCode = std::make_shared<CharStream>(R"(
+	pragma abicoder v1;
+	contract C {
+		function f(uint a) public pure returns (uint t) {
+			assembly {
+				function g(x) -> y { if x { leave } y := 8 }
+				t := g(a)
+			}
+		}
+	}
+	)", "");
+	AssemblyItems items = compileContract(sourceCode);
+
+	std::string jumpTypes;
+	for (AssemblyItem const& item: items)
+		if (item.getJumpType() != AssemblyItem::JumpType::Ordinary)
+			jumpTypes += item.getJumpTypeAsString() + "\n";
+
+	if (solidity::test::CommonOptions::get().optimize)
+		BOOST_CHECK_EQUAL(jumpTypes, "[in]\n[out]\n[out]\n[in]\n[out]\n");
+	else
+		BOOST_CHECK_EQUAL(jumpTypes, "[in]\n[out]\n[in]\n[out]\n");
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/ErrorCheck.cpp b/compiler/test/libsolidity/ErrorCheck.cpp
new file mode 100644
index 00000000..8f1f0543
--- /dev/null
+++ b/compiler/test/libsolidity/ErrorCheck.cpp
@@ -0,0 +1,84 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/** @file ErrorCheck.cpp
+ * @author Yoichi Hirai <i@yoichihirai.com>
+ * @date 2016
+ */
+
+#include <test/libsolidity/ErrorCheck.h>
+#include <libsolutil/Exceptions.h>
+
+#include <string>
+#include <set>
+#include <iostream>
+
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+
+namespace
+{
+std::string errorMessage(Error const& _e)
+{
+	return _e.comment() ? *_e.comment() : "NONE";
+}
+}
+
+bool solidity::frontend::test::searchErrorMessage(Error const& _err, std::string const& _substr)
+{
+	if (std::string const* errorMessage = _err.comment())
+	{
+		if (errorMessage->find(_substr) == std::string::npos)
+		{
+			std::cout << "Expected message \"" << _substr << "\" but found \"" << *errorMessage << "\".\n";
+			return false;
+		}
+		return true;
+	}
+	else
+		std::cout << "Expected error message but found none." << std::endl;
+	return _substr.empty();
+}
+
+std::string solidity::frontend::test::searchErrors(ErrorList const& _errors, std::vector<std::pair<Error::Type, std::string>> const& _expectations)
+{
+	auto expectations = _expectations;
+	for (auto const& error: _errors)
+	{
+		std::string msg = errorMessage(*error);
+		bool found = false;
+		for (auto it = expectations.begin(); it != expectations.end(); ++it)
+			if (msg.find(it->second) != std::string::npos && error->type() == it->first)
+			{
+				found = true;
+				expectations.erase(it);
+				break;
+			}
+		if (!found)
+			return "Unexpected error: " + Error::formatErrorType(error->type()) + ": " + msg;
+	}
+	if (!expectations.empty())
+	{
+		std::string msg = "Expected error(s) not present:\n";
+		for (auto const& expectation: expectations)
+			msg += expectation.second + "\n";
+		return msg;
+	}
+
+	return "";
+}
diff --git a/compiler/test/libsolidity/FunctionDependencyGraphTest.cpp b/compiler/test/libsolidity/FunctionDependencyGraphTest.cpp
new file mode 100644
index 00000000..c7992d2a
--- /dev/null
+++ b/compiler/test/libsolidity/FunctionDependencyGraphTest.cpp
@@ -0,0 +1,62 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/FunctionDependencyGraphTest.h>
+
+#include <libsolidity/experimental/analysis/Analysis.h>
+#include <libsolidity/experimental/analysis/FunctionDependencyAnalysis.h>
+
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/optimiser/FunctionCallFinder.h>
+
+#include <libsolutil/StringUtils.h>
+
+#include <fstream>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::util::formatting;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+TestCase::TestResult FunctionDependencyGraphTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	compiler().reset();
+	compiler().setSources(StringMap{{"", m_source}});
+	compiler().setViaIR(true);
+	compiler().setOptimiserSettings(OptimiserSettings::none());
+	if (!compiler().compile(CompilerStack::AnalysisSuccessful))
+	{
+		printPrefixed(_stream, formatErrors(filteredErrors(), _formatted), _linePrefix);
+		return TestResult::FatalError;
+	}
+
+	m_obtainedResult.clear();
+	for (auto [top, subs]: compiler().experimentalAnalysis().annotation<experimental::FunctionDependencyAnalysis>().functionCallGraph.edges)
+	{
+		std::string topName = top->name().empty() ? "fallback" : top->name();
+		m_obtainedResult += "(" + topName + ") --> {";
+		for (auto sub: subs)
+			m_obtainedResult += sub->name() + ",";
+		m_obtainedResult += "}\n";
+	}
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libsolidity/FunctionDependencyGraphTest.h b/compiler/test/libsolidity/FunctionDependencyGraphTest.h
new file mode 100644
index 00000000..83f3eb0a
--- /dev/null
+++ b/compiler/test/libsolidity/FunctionDependencyGraphTest.h
@@ -0,0 +1,50 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <test/CommonSyntaxTest.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend::test
+{
+	using solidity::test::SyntaxTestError;
+
+	class FunctionDependencyGraphTest: public AnalysisFramework, public TestCase
+	{
+	public:
+		static std::unique_ptr<TestCase> create(Config const& _config)
+		{
+			return std::make_unique<FunctionDependencyGraphTest>(_config.filename);
+		}
+
+		FunctionDependencyGraphTest(std::string const& _filename): TestCase(_filename)
+		{
+			m_source = m_reader.source();
+			m_expectation = m_reader.simpleExpectations();
+		}
+
+		TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false) override;
+	};
+}
diff --git a/compiler/test/libsolidity/GasCosts.cpp b/compiler/test/libsolidity/GasCosts.cpp
new file mode 100644
index 00000000..52073281
--- /dev/null
+++ b/compiler/test/libsolidity/GasCosts.cpp
@@ -0,0 +1,217 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Tests that check that the cost of certain operations stay within range.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <liblangutil/EVMVersion.h>
+#include <libsolutil/IpfsHash.h>
+#include <libevmasm/GasMeter.h>
+
+#include <cmath>
+
+using namespace solidity::langutil;
+using namespace solidity::langutil;
+using namespace solidity::evmasm;
+using namespace solidity::frontend;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+#define CHECK_DEPLOY_GAS(_gasNoOpt, _gasOpt, _evmVersion) \
+	do \
+	{ \
+		u256 metaCost = GasMeter::dataGas(m_compiler.cborMetadata(m_compiler.lastContractName()), true, _evmVersion); \
+		u256 gasOpt{_gasOpt}; \
+		u256 gasNoOpt{_gasNoOpt}; \
+		u256 gas = m_optimiserSettings == OptimiserSettings::minimal() ? gasNoOpt : gasOpt; \
+		BOOST_CHECK_MESSAGE( \
+			m_gasUsed >= metaCost, \
+			"Gas used: " + \
+			m_gasUsed.str() + \
+			" is less than the data cost for the cbor metadata: " + \
+			u256(metaCost).str() \
+		); \
+		u256 gasUsed = m_gasUsed - metaCost; \
+		BOOST_CHECK_MESSAGE( \
+			gas == gasUsed, \
+			"Gas used: " + \
+			gasUsed.str() + \
+			" - expected: " + \
+			gas.str() \
+		); \
+	} while(0)
+
+#define CHECK_GAS(_gasNoOpt, _gasOpt, _tolerance) \
+	do \
+	{ \
+		u256 gasOpt{_gasOpt}; \
+		u256 gasNoOpt{_gasNoOpt}; \
+		u256 tolerance{_tolerance}; \
+		u256 gas = m_optimiserSettings == OptimiserSettings::minimal() ? gasNoOpt : gasOpt; \
+		u256 diff = gas < m_gasUsed ? m_gasUsed - gas : gas - m_gasUsed; \
+		BOOST_CHECK_MESSAGE( \
+			diff <= tolerance, \
+			"Gas used: " + \
+			m_gasUsed.str() + \
+			" - expected: " + \
+			gas.str() + \
+			" (tolerance: " + \
+			tolerance.str() + \
+			")" \
+		); \
+	} while(0)
+
+BOOST_FIXTURE_TEST_SUITE(GasCostTests, SolidityExecutionFramework)
+
+BOOST_AUTO_TEST_CASE(string_storage)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f() pure public {
+				require(false, "Not Authorized. This function can only be called by the custodian or owner of this contract");
+			}
+		}
+	)";
+	m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+	m_appendCBORMetadata = false;
+	compileAndRun(sourceCode);
+
+	auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
+
+	if (evmVersion <= EVMVersion::byzantium())
+	{
+		if (CommonOptions::get().useABIEncoderV1)
+			CHECK_DEPLOY_GAS(133045, 129731, evmVersion);
+		else
+			CHECK_DEPLOY_GAS(144999, 121229, evmVersion);
+	}
+	// This is only correct on >=Constantinople.
+	else if (!CommonOptions::get().useABIEncoderV1)
+	{
+		if (CommonOptions::get().optimize)
+		{
+			// Costs with 0 are cases which cannot be triggered in tests.
+			if (evmVersion < EVMVersion::istanbul())
+				CHECK_DEPLOY_GAS(0, 109241, evmVersion);
+			else if (evmVersion < EVMVersion::shanghai())
+				CHECK_DEPLOY_GAS(0, 97697, evmVersion);
+			// Shanghai is cheaper due to `push0`
+			else
+				CHECK_DEPLOY_GAS(0, 97071, evmVersion);
+		}
+		else
+		{
+			if (evmVersion < EVMVersion::istanbul())
+				CHECK_DEPLOY_GAS(139013, 123969, evmVersion);
+			else if (evmVersion < EVMVersion::shanghai())
+				CHECK_DEPLOY_GAS(123361, 110969, evmVersion);
+			// Shanghai is cheaper due to `push0`
+			else
+				CHECK_DEPLOY_GAS(121493, 110969, evmVersion);
+		}
+	}
+	else if (evmVersion < EVMVersion::istanbul())
+		CHECK_DEPLOY_GAS(125829, 118559, evmVersion);
+	else if (evmVersion < EVMVersion::shanghai())
+		CHECK_DEPLOY_GAS(114077, 96461, evmVersion);
+	else
+		CHECK_DEPLOY_GAS(114077, 95835, evmVersion);
+
+	if (evmVersion >= EVMVersion::byzantium())
+	{
+		callContractFunction("f()");
+		if (evmVersion == EVMVersion::byzantium())
+			CHECK_GAS(21741, 21522, 20);
+		// This is only correct on >=Constantinople.
+		else if (!CommonOptions::get().useABIEncoderV1)
+		{
+			if (CommonOptions::get().optimize)
+			{
+				if (evmVersion < EVMVersion::istanbul())
+					CHECK_GAS(0, 21526, 20);
+				else
+					CHECK_GAS(0, 21318, 20);
+			}
+			else
+			{
+				if (evmVersion < EVMVersion::istanbul())
+					CHECK_GAS(21736, 21559, 20);
+				else
+					CHECK_GAS(21528, 21351, 20);
+			}
+		}
+		else if (evmVersion < EVMVersion::istanbul())
+			CHECK_GAS(21546, 21526, 20);
+		else
+			CHECK_GAS(21332, 21322, 20);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(single_callvaluecheck)
+{
+	std::string sourceCode = R"(
+		// All functions nonpayable, we can check callvalue at the beginning
+		contract Nonpayable {
+			address a;
+			function f(address b) public {
+				a = b;
+			}
+			function f1(address b) public pure returns (uint c) {
+				return uint160(b) + 2;
+			}
+			function f2(address b) public pure returns (uint) {
+				return uint160(b) + 8;
+			}
+			function f3(address, uint c) pure public returns (uint) {
+				return c - 5;
+			}
+		}
+		// At least on payable function, we cannot do the optimization.
+		contract Payable {
+			address a;
+			function f(address b) public {
+				a = b;
+			}
+			function f1(address b) public pure returns (uint c) {
+				return uint160(b) + 2;
+			}
+			function f2(address b) public pure returns (uint) {
+				return uint160(b) + 8;
+			}
+			function f3(address, uint c) payable public returns (uint) {
+				return c - 5;
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	size_t bytecodeSizeNonpayable = m_compiler.object("Nonpayable").bytecode.size();
+	size_t bytecodeSizePayable = m_compiler.object("Payable").bytecode.size();
+
+	auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	if (evmVersion < EVMVersion::shanghai())
+		BOOST_CHECK_EQUAL(bytecodeSizePayable - bytecodeSizeNonpayable, 26);
+	else
+		BOOST_CHECK_EQUAL(bytecodeSizePayable - bytecodeSizeNonpayable, 24);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/GasMeter.cpp b/compiler/test/libsolidity/GasMeter.cpp
new file mode 100644
index 00000000..1afebac5
--- /dev/null
+++ b/compiler/test/libsolidity/GasMeter.cpp
@@ -0,0 +1,452 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Unit tests for the gas estimator.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <libevmasm/GasMeter.h>
+#include <libevmasm/KnownState.h>
+#include <libevmasm/PathGasMeter.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/GasEstimator.h>
+
+using namespace solidity::langutil;
+using namespace solidity::evmasm;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+class GasMeterTestFramework: public SolidityExecutionFramework
+{
+public:
+	void compile(std::string const& _sourceCode)
+	{
+		m_compiler.reset();
+		m_compiler.setSources({{"", "pragma solidity >=0.0;\n"
+				"// SPDX-License-Identifier: GPL-3.0\n" + _sourceCode}});
+		m_compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+		m_compiler.setEVMVersion(m_evmVersion);
+		BOOST_REQUIRE_MESSAGE(m_compiler.compile(), "Compiling contract failed");
+	}
+
+	void testCreationTimeGas(std::string const& _sourceCode, u256 const& _tolerance = u256(0))
+	{
+		compileAndRun(_sourceCode);
+		auto state = std::make_shared<KnownState>();
+		PathGasMeter meter(*m_compiler.assemblyItems(m_compiler.lastContractName()), solidity::test::CommonOptions::get().evmVersion());
+		GasMeter::GasConsumption gas = meter.estimateMax(0, state);
+		u256 bytecodeSize(m_compiler.runtimeObject(m_compiler.lastContractName()).bytecode.size());
+		// costs for deployment
+		gas += bytecodeSize * GasCosts::createDataGas;
+		// costs for transaction
+		gas += gasForTransaction(m_compiler.object(m_compiler.lastContractName()).bytecode, true);
+
+		BOOST_REQUIRE(!gas.isInfinite);
+		BOOST_CHECK_LE(m_gasUsed, gas.value);
+		BOOST_CHECK_LE(gas.value - _tolerance, m_gasUsed);
+	}
+
+	/// Compares the gas computed by PathGasMeter for the given signature (but unknown arguments)
+	/// against the actual gas usage computed by the VM on the given set of argument variants.
+	void testRunTimeGas(std::string const& _sig, std::vector<bytes> _argumentVariants, u256 const& _tolerance = u256(0))
+	{
+		u256 gasUsed = 0;
+		GasMeter::GasConsumption gas;
+		util::FixedHash<4> hash = util::selectorFromSignatureH32(_sig);
+		for (bytes const& arguments: _argumentVariants)
+		{
+			sendMessage(hash.asBytes() + arguments, false, 0);
+			BOOST_CHECK(m_transactionSuccessful);
+			gasUsed = std::max(gasUsed, m_gasUsed);
+			gas = std::max(gas, gasForTransaction(hash.asBytes() + arguments, false));
+		}
+
+		gas += GasEstimator(solidity::test::CommonOptions::get().evmVersion()).functionalEstimation(
+			*m_compiler.runtimeAssemblyItems(m_compiler.lastContractName()),
+			_sig
+		);
+		BOOST_REQUIRE(!gas.isInfinite);
+		BOOST_CHECK_LE(m_gasUsed, gas.value);
+		BOOST_CHECK_LE(gas.value - _tolerance, m_gasUsed);
+	}
+
+	static GasMeter::GasConsumption gasForTransaction(bytes const& _data, bool _isCreation)
+	{
+		auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
+		GasMeter::GasConsumption gas = _isCreation ? GasCosts::txCreateGas : GasCosts::txGas;
+		for (auto i: _data)
+			gas += i != 0 ? GasCosts::txDataNonZeroGas(evmVersion) : GasCosts::txDataZeroGas;
+		return gas;
+	}
+};
+
+BOOST_FIXTURE_TEST_SUITE(GasMeterTests, GasMeterTestFramework)
+
+BOOST_AUTO_TEST_CASE(simple_contract)
+{
+	// Tests a simple "deploy contract" code without constructor. The actual contract is not relevant.
+	char const* sourceCode = R"(
+		contract test {
+			bytes32 public shaValue;
+			function f(uint a) public {
+				shaValue = keccak256(abi.encodePacked(a));
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+}
+
+BOOST_AUTO_TEST_CASE(store_keccak256)
+{
+	char const* sourceCode = R"(
+		// TODO: We should enable v2 again once the yul optimizer is activated.
+		pragma abicoder v1;
+
+		contract test {
+			bytes32 public shaValue;
+			constructor() {
+				shaValue = keccak256(abi.encodePacked(this));
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+}
+
+BOOST_AUTO_TEST_CASE(updating_store)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint data;
+			uint data2;
+			constructor() {
+				data = 1;
+				data = 2;
+				data2 = 0;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode, m_evmVersion < langutil::EVMVersion::constantinople() ? u256(0) : u256(9600));
+}
+
+BOOST_AUTO_TEST_CASE(branches)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint data;
+			uint data2;
+			function f(uint x) public {
+				if (x > 7)
+					data2 = 1;
+				else
+					data = 1;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode, 1);
+	testRunTimeGas("f(uint256)", std::vector<bytes>{encodeArgs(2), encodeArgs(8)}, 1);
+}
+
+BOOST_AUTO_TEST_CASE(function_calls)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint data;
+			uint data2;
+			function f(uint x) public {
+				if (x > 7)
+					{ unchecked { data2 = g(x**8) + 1; } }
+				else
+					data = 1;
+			}
+			function g(uint x) internal returns (uint) {
+				return data2;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	// In f, data2 is accessed twice, so there is a reduction of 2200 to 100 in actual costs.
+	// However, GasMeter always assumes cold costs.
+	testRunTimeGas(
+		"f(uint256)",
+		std::vector<bytes>{encodeArgs(2), encodeArgs(8)},
+		m_evmVersion < EVMVersion::berlin() ?
+		u256(0) :
+		u256(2100)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(multiple_external_functions)
+{
+	char const* sourceCode = R"(
+		// TODO: We should enable v2 again once the yul optimizer is activated.
+		pragma abicoder v1;
+
+		contract test {
+			uint data;
+			uint data2;
+			function f(uint x) public {
+				if (x > 7)
+					{ unchecked { data2 = g(x**8) + 1; } }
+				else
+					data = 1;
+			}
+			function g(uint x) public returns (uint) {
+				return data2;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	// In f, data2 is accessed twice, so there is a reduction of 2200 to 100 in actual costs.
+	// However, GasMeter always assumes cold costs.
+	testRunTimeGas(
+		"f(uint256)",
+		std::vector<bytes>{encodeArgs(2), encodeArgs(8)},
+		m_evmVersion < EVMVersion::berlin() ?
+		u256(0) :
+		u256(2100)
+	);
+
+	testRunTimeGas("g(uint256)", std::vector<bytes>{encodeArgs(2)});
+}
+
+BOOST_AUTO_TEST_CASE(exponent_size)
+{
+	char const* sourceCode = R"(
+		// TODO: We should enable v2 again once the yul optimizer is activated.
+		pragma abicoder v1;
+
+		contract A {
+			function f(uint x) public returns (uint) {
+				unchecked { return x ** 0; }
+			}
+			function g(uint x) public returns (uint) {
+				unchecked { return x ** 0x100; }
+			}
+			function h(uint x) public returns (uint) {
+				unchecked { return x ** 0x10000; }
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("f(uint256)", std::vector<bytes>{encodeArgs(2)});
+	testRunTimeGas("g(uint256)", std::vector<bytes>{encodeArgs(2)});
+	testRunTimeGas("h(uint256)", std::vector<bytes>{encodeArgs(2)});
+}
+
+BOOST_AUTO_TEST_CASE(balance_gas)
+{
+	char const* sourceCode = R"(
+		contract A {
+			function lookup_balance(address a) public returns (uint) {
+				return a.balance;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("lookup_balance(address)", std::vector<bytes>{encodeArgs(2), encodeArgs(100)});
+}
+
+BOOST_AUTO_TEST_CASE(extcodesize_gas)
+{
+	char const* sourceCode = R"(
+		contract A {
+			function f() public returns (uint _s) {
+				assembly {
+					_s := extcodesize(0x30)
+				}
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("f()", std::vector<bytes>{encodeArgs()});
+}
+
+BOOST_AUTO_TEST_CASE(regular_functions_exclude_fallback)
+{
+	// A bug in the estimator caused the costs for a specific function
+	// to always include the costs for the fallback.
+	char const* sourceCode = R"(
+		contract A {
+			uint public x;
+			fallback() external { x = 2; }
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("x()", std::vector<bytes>{encodeArgs()});
+}
+
+BOOST_AUTO_TEST_CASE(complex_control_flow)
+{
+	// This crashed the gas estimator previously (or took a very long time).
+	// Now we do not follow branches if they start out with lower gas costs than the ones
+	// we previously considered. This of course reduces accuracy.
+	char const* sourceCode = R"(
+		// TODO: We should enable v2 again once the yul optimizer is activated.
+		pragma abicoder v1;
+
+		contract log {
+			function ln(int128 x) public pure returns (int128 result) {
+				unchecked {
+					int128 t = x / 256;
+					int128 y = 5545177;
+					x = t;
+					t = x * 16; if (t <= 1000000) { x = t; y = y - 2772588; }
+					t = x * 4; if (t <= 1000000) { x = t; y = y - 1386294; }
+					t = x * 2; if (t <= 1000000) { x = t; y = y - 693147; }
+					t = x + x / 2; if (t <= 1000000) { x = t; y = y - 405465; }
+					t = x + x / 4; if (t <= 1000000) { x = t; y = y - 223144; }
+					t = x + x / 8; if (t <= 1000000) { x = t; y = y - 117783; }
+					t = x + x / 16; if (t <= 1000000) { x = t; y = y - 60624; }
+					t = x + x / 32; if (t <= 1000000) { x = t; y = y - 30771; }
+					t = x + x / 64; if (t <= 1000000) { x = t; y = y - 15504; }
+					t = x + x / 128; if (t <= 1000000) { x = t; y = y - 7782; }
+					t = x + x / 256; if (t <= 1000000) { x = t; y = y - 3898; }
+					t = x + x / 512; if (t <= 1000000) { x = t; y = y - 1951; }
+					t = x + x / 1024; if (t <= 1000000) { x = t; y = y - 976; }
+					t = x + x / 2048; if (t <= 1000000) { x = t; y = y - 488; }
+					t = x + x / 4096; if (t <= 1000000) { x = t; y = y - 244; }
+					t = x + x / 8192; if (t <= 1000000) { x = t; y = y - 122; }
+					t = x + x / 16384; if (t <= 1000000) { x = t; y = y - 61; }
+					t = x + x / 32768; if (t <= 1000000) { x = t; y = y - 31; }
+					t = x + x / 65536; if (t <= 1000000) { y = y - 15; }
+					return y;
+				}
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	// max gas is used for small x
+	testRunTimeGas("ln(int128)", std::vector<bytes>{encodeArgs(0), encodeArgs(10), encodeArgs(105), encodeArgs(30000)});
+}
+
+BOOST_AUTO_TEST_CASE(
+	mcopy_memory_expansion_gas,
+	*boost::unit_test::precondition(minEVMVersionCheck(EVMVersion::cancun()))
+)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function no_expansion() public {
+				assembly {
+					mstore(0xffe0, 1) // expand memory before using mcopy
+					mcopy(0, 0xffff, 1)
+					return(0, 1)
+				}
+			}
+
+			function expansion_on_write() public {
+				assembly {
+					mcopy(0xffff, 0, 1)
+					return(0xffff, 1)
+				}
+			}
+
+			function expansion_on_read() public {
+				assembly {
+					mcopy(0, 0xffff, 1)
+					return(0, 1)
+				}
+			}
+
+			function expansion_on_read_write() public {
+				assembly {
+					mcopy(0xffff, 0xffff, 1)
+					return(0, 1)
+				}
+			}
+
+			function expansion_on_zero_size() public {
+				assembly {
+					mcopy(0xffff, 0xffff, 0)
+					return(0, 1)
+				}
+			}
+
+			function expansion_on_0_0_0() public {
+				assembly {
+					mcopy(0, 0, 0)
+					return(0, 1)
+				}
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("no_expansion()", {encodeArgs()});
+	testRunTimeGas("expansion_on_write()", {encodeArgs()});
+	testRunTimeGas("expansion_on_read()", {encodeArgs()});
+	testRunTimeGas("expansion_on_read_write()", {encodeArgs()});
+	testRunTimeGas("expansion_on_zero_size()", {encodeArgs()});
+	testRunTimeGas("expansion_on_0_0_0()", {encodeArgs()});
+}
+
+BOOST_AUTO_TEST_CASE(
+	mcopy_word_gas,
+	*boost::unit_test::precondition(minEVMVersionCheck(EVMVersion::cancun()))
+)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function no_overlap() public {
+				assembly {
+					mstore(0xffe0, 1) // expand memory before using mcopy
+					mcopy(0x4000, 0x2000, 0x2000)
+					return(0, 0x10000)
+				}
+			}
+
+			function overlap_right() public {
+				assembly {
+					mstore(0xffe0, 1) // expand memory before using mcopy
+					mcopy(0x3000, 0x2000, 0x2000)
+					return(0, 0x10000)
+				}
+			}
+
+			function overlap_left() public {
+				assembly {
+					mstore(0xffe0, 1) // expand memory before using mcopy
+					mcopy(0x1000, 0x2000, 0x2000)
+					return(0, 0x10000)
+				}
+			}
+
+			function overlap_full() public {
+				assembly {
+					mstore(0xffe0, 1) // expand memory before using mcopy
+					mcopy(0x2000, 0x2000, 0x2000)
+					return(0, 0x10000)
+				}
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("no_overlap()", {encodeArgs()});
+	testRunTimeGas("overlap_right()", {encodeArgs()});
+	testRunTimeGas("overlap_left()", {encodeArgs()});
+	testRunTimeGas("overlap_full()", {encodeArgs()});
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/GasTest.cpp b/compiler/test/libsolidity/GasTest.cpp
new file mode 100644
index 00000000..4786a2a8
--- /dev/null
+++ b/compiler/test/libsolidity/GasTest.cpp
@@ -0,0 +1,161 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/GasTest.h>
+#include <test/libsolidity/util/Common.h>
+#include <test/Common.h>
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/JSON.h>
+#include <libsolutil/StringUtils.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/throw_exception.hpp>
+#include <fstream>
+#include <stdexcept>
+
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity;
+using namespace boost::unit_test;
+
+GasTest::GasTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_optimise = m_reader.boolSetting("optimize", false);
+	m_optimiseYul = m_reader.boolSetting("optimize-yul", false);
+	m_optimiseRuns = m_reader.sizetSetting("optimize-runs", OptimiserSettings{}.expectedExecutionsPerDeployment);
+	parseExpectations(m_reader.stream());
+}
+
+void GasTest::parseExpectations(std::istream& _stream)
+{
+	std::map<std::string, std::string>* currentKind = nullptr;
+	std::string line;
+
+	while (getline(_stream, line))
+		if (!boost::starts_with(line, "// "))
+			BOOST_THROW_EXCEPTION(std::runtime_error("Invalid expectation: expected \"// \"."));
+		else if (boost::ends_with(line, ":"))
+		{
+			std::string kind = line.substr(3, line.length() - 4);
+			boost::trim(kind);
+			currentKind = &m_expectations[std::move(kind)];
+		}
+		else if (!currentKind)
+			BOOST_THROW_EXCEPTION(std::runtime_error("No function kind specified. Expected \"creation:\", \"external:\" or \"internal:\"."));
+		else
+		{
+			auto it = line.begin() + 3;
+			skipWhitespace(it, line.end());
+			auto functionNameBegin = it;
+			while (it != line.end() && *it != ':')
+				++it;
+			std::string functionName(functionNameBegin, it);
+			if (functionName == "fallback")
+				functionName.clear();
+			expect(it, line.end(), ':');
+			skipWhitespace(it, line.end());
+			if (it == line.end())
+				BOOST_THROW_EXCEPTION(std::runtime_error("Invalid expectation: expected gas cost."));
+			(*currentKind)[functionName] = std::string(it, line.end());
+		}
+}
+
+void GasTest::printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const
+{
+	Json::Value estimates = compiler().gasEstimates(compiler().lastContractName());
+	for (auto groupIt = estimates.begin(); groupIt != estimates.end(); ++groupIt)
+	{
+		_stream << _linePrefix << groupIt.key().asString() << ":" << std::endl;
+		for (auto it = groupIt->begin(); it != groupIt->end(); ++it)
+		{
+			_stream << _linePrefix << "  ";
+			if (it.key().asString().empty())
+				_stream << "fallback";
+			else
+				_stream << it.key().asString();
+			_stream << ": " << it->asString() << std::endl;
+		}
+	}
+}
+
+void GasTest::setupCompiler(CompilerStack& _compiler)
+{
+	AnalysisFramework::setupCompiler(_compiler);
+
+	// Prerelease CBOR metadata varies in size due to changing version numbers and build dates.
+	// This leads to volatile creation cost estimates. Therefore we force the compiler to
+	// release mode for testing gas estimates.
+	_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+	OptimiserSettings settings = m_optimise ? OptimiserSettings::standard() : OptimiserSettings::minimal();
+	if (m_optimiseYul)
+	{
+		settings.runYulOptimiser = m_optimise;
+		settings.optimizeStackAllocation = m_optimise;
+	}
+	settings.expectedExecutionsPerDeployment = m_optimiseRuns;
+	_compiler.setOptimiserSettings(settings);
+
+	// Intentionally ignoring EVM version specified on the command line.
+	// Gas expectations are only valid for the default version.
+	_compiler.setEVMVersion(EVMVersion{});
+}
+
+TestCase::TestResult GasTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	if (!runFramework(withPreamble(m_source), PipelineStage::Compilation))
+	{
+		util::printPrefixed(_stream, formatErrors(filteredErrors(), _formatted), _linePrefix);
+		return TestResult::FatalError;
+	}
+
+	Json::Value estimateGroups = compiler().gasEstimates(compiler().lastContractName());
+	if (
+		m_expectations.size() == estimateGroups.size() &&
+		boost::all(m_expectations, [&](auto const& expectations) {
+		auto const& estimates = estimateGroups[expectations.first];
+		return estimates.size() == expectations.second.size() &&
+			boost::all(expectations.second, [&](auto const& entry) {
+				return entry.second == estimates[entry.first].asString();
+			});
+		})
+	)
+		return TestResult::Success;
+	else
+	{
+		_stream << _linePrefix << "Expected:" << std::endl;
+		for (auto const& expectations: m_expectations)
+		{
+			_stream << _linePrefix << "  " << expectations.first << ":" << std::endl;
+			for (auto const& entry: expectations.second)
+				_stream << _linePrefix
+					<< "    "
+					<< (entry.first.empty() ? "fallback" : entry.first)
+					<< ": "
+					<< entry.second
+					<< std::endl;
+		}
+		_stream << _linePrefix << "Obtained:" << std::endl;
+		printUpdatedExpectations(_stream, _linePrefix + "  ");
+		return TestResult::Failure;
+	}
+}
diff --git a/compiler/test/libsolidity/GasTest.h b/compiler/test/libsolidity/GasTest.h
new file mode 100644
index 00000000..1337ae3f
--- /dev/null
+++ b/compiler/test/libsolidity/GasTest.h
@@ -0,0 +1,58 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <liblangutil/Exceptions.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend::test
+{
+
+class GasTest: AnalysisFramework, public TestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{ return std::make_unique<GasTest>(_config.filename); }
+	GasTest(std::string const& _filename);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false) override;
+
+	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const override;
+
+protected:
+	void setupCompiler(CompilerStack& _compiler) override;
+
+private:
+	void parseExpectations(std::istream& _stream);
+
+	bool m_optimise = false;
+	bool m_optimiseYul = false;
+	size_t m_optimiseRuns = OptimiserSettings{}.expectedExecutionsPerDeployment;
+	std::map<std::string, std::map<std::string, std::string>> m_expectations;
+};
+
+}
diff --git a/compiler/test/libsolidity/Imports.cpp b/compiler/test/libsolidity/Imports.cpp
new file mode 100644
index 00000000..5f094d15
--- /dev/null
+++ b/compiler/test/libsolidity/Imports.cpp
@@ -0,0 +1,117 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Tests for high level features like import.
+ */
+
+#include <test/libsolidity/ErrorCheck.h>
+#include <test/Common.h>
+
+#include <liblangutil/Exceptions.h>
+#include <libsolidity/interface/CompilerStack.h>
+#include <libsolidity/interface/ImportRemapper.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(SolidityImports)
+
+BOOST_AUTO_TEST_CASE(remappings)
+{
+	CompilerStack c;
+	c.setRemappings(std::vector<ImportRemapper::Remapping>{{"", "s", "s_1.4.6"},{"", "t", "Tee"}});
+	c.setSources({
+		{"a", "import \"s/s.sol\"; contract A is S {} pragma solidity >=0.0;"},
+		{"b", "import \"t/tee.sol\"; contract A is Tee {} pragma solidity >=0.0;"},
+		{"s_1.4.6/s.sol", "contract S {} pragma solidity >=0.0;"},
+		{"Tee/tee.sol", "contract Tee {} pragma solidity >=0.0;"}
+	});
+	c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	BOOST_CHECK(c.compile());
+}
+
+BOOST_AUTO_TEST_CASE(context_dependent_remappings)
+{
+	CompilerStack c;
+	c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a", "s", "s_1.4.6"}, {"b", "s", "s_1.4.7"}});
+	c.setSources({
+		{"a/a.sol", "import \"s/s.sol\"; contract A is SSix {} pragma solidity >=0.0;"},
+		{"b/b.sol", "import \"s/s.sol\"; contract B is SSeven {} pragma solidity >=0.0;"},
+		{"s_1.4.6/s.sol", "contract SSix {} pragma solidity >=0.0;"},
+		{"s_1.4.7/s.sol", "contract SSeven {} pragma solidity >=0.0;"}
+	});
+	c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	BOOST_CHECK(c.compile());
+}
+
+BOOST_AUTO_TEST_CASE(context_dependent_remappings_ensure_default_and_module_preserved)
+{
+	CompilerStack c;
+	c.setRemappings(std::vector<ImportRemapper::Remapping>{
+		{"", "foo", "vendor/foo_2.0.0"},
+		{"vendor/bar", "foo", "vendor/foo_1.0.0"},
+		{"", "bar", "vendor/bar"}
+	});
+	c.setSources({
+		{"main.sol", "import \"foo/foo.sol\"; import {Bar} from \"bar/bar.sol\"; contract Main is Foo2, Bar {} pragma solidity >=0.0;"},
+		{"vendor/bar/bar.sol", "import \"foo/foo.sol\"; contract Bar {Foo1 foo;} pragma solidity >=0.0;"},
+		{"vendor/foo_1.0.0/foo.sol", "contract Foo1 {} pragma solidity >=0.0;"},
+		{"vendor/foo_2.0.0/foo.sol", "contract Foo2 {} pragma solidity >=0.0;"}
+	});
+	c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	BOOST_CHECK(c.compile());
+}
+
+BOOST_AUTO_TEST_CASE(context_dependent_remappings_order_independent_1)
+{
+	CompilerStack c;
+	c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a", "x/y/z", "d"}, {"a/b", "x", "e"}});
+	c.setSources({
+		{"a/main.sol", "import \"x/y/z/z.sol\"; contract Main is D {} pragma solidity >=0.0;"},
+		{"a/b/main.sol", "import \"x/y/z/z.sol\"; contract Main is E {} pragma solidity >=0.0;"},
+		{"d/z.sol", "contract D {} pragma solidity >=0.0;"},
+		{"e/y/z/z.sol", "contract E {} pragma solidity >=0.0;"}
+	});
+	c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	BOOST_CHECK(c.compile());
+}
+
+BOOST_AUTO_TEST_CASE(context_dependent_remappings_order_independent_2)
+{
+	CompilerStack c;
+	c.setRemappings(std::vector<ImportRemapper::Remapping>{{"a/b", "x", "e"}, {"a", "x/y/z", "d"}});
+	c.setSources({
+		{"a/main.sol", "import \"x/y/z/z.sol\"; contract Main is D {} pragma solidity >=0.0;"},
+		{"a/b/main.sol", "import \"x/y/z/z.sol\"; contract Main is E {} pragma solidity >=0.0;"},
+		{"d/z.sol", "contract D {} pragma solidity >=0.0;"},
+		{"e/y/z/z.sol", "contract E {} pragma solidity >=0.0;"}
+	});
+	c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	BOOST_CHECK(c.compile());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/InlineAssembly.cpp b/compiler/test/libsolidity/InlineAssembly.cpp
new file mode 100644
index 00000000..1c848d60
--- /dev/null
+++ b/compiler/test/libsolidity/InlineAssembly.cpp
@@ -0,0 +1,381 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2016
+ * Unit tests for inline assembly.
+ */
+
+#include <test/Common.h>
+
+#include <test/libsolidity/ErrorCheck.h>
+
+#include <libsolidity/ast/AST.h>
+
+#include <libyul/YulStack.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/Scanner.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libevmasm/Assembly.h>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+using namespace solidity::langutil;
+using namespace solidity::yul;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+std::optional<Error> parseAndReturnFirstError(
+	std::string const& _source,
+	bool _assemble = false,
+	bool _allowWarnings = true,
+	YulStack::Language _language = YulStack::Language::Assembly,
+	YulStack::Machine _machine = YulStack::Machine::EVM
+)
+{
+	YulStack stack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		_language,
+		solidity::frontend::OptimiserSettings::none(),
+		DebugInfoSelection::None()
+	);
+	bool success = false;
+	try
+	{
+		success = stack.parseAndAnalyze("", _source);
+		if (success && _assemble)
+			stack.assemble(_machine);
+	}
+	catch (FatalError const&)
+	{
+		BOOST_FAIL("Fatal error leaked.");
+		success = false;
+	}
+	std::shared_ptr<Error const> error;
+	for (auto const& e: stack.errors())
+	{
+		if (_allowWarnings && e->type() == Error::Type::Warning)
+			continue;
+		if (error)
+			BOOST_FAIL(
+				"Found more than one error:\n" +
+				SourceReferenceFormatter::formatErrorInformation(stack.errors(), stack)
+			);
+		error = e;
+	}
+	if (!success)
+		BOOST_REQUIRE(error);
+	if (error)
+		return *error;
+	return {};
+}
+
+bool successParse(
+	std::string const& _source,
+	bool _assemble = false,
+	bool _allowWarnings = true,
+	YulStack::Language _language = YulStack::Language::Assembly,
+	YulStack::Machine _machine = YulStack::Machine::EVM
+)
+{
+	return !parseAndReturnFirstError(_source, _assemble, _allowWarnings, _language, _machine);
+}
+
+bool successAssemble(std::string const& _source, bool _allowWarnings = true, YulStack::Language _language = YulStack::Language::Assembly)
+{
+	return
+		successParse(_source, true, _allowWarnings, _language, YulStack::Machine::EVM);
+}
+
+Error expectError(
+	std::string const& _source,
+	bool _assemble,
+	bool _allowWarnings = false,
+	YulStack::Language _language = YulStack::Language::Assembly
+)
+{
+
+	auto error = parseAndReturnFirstError(_source, _assemble, _allowWarnings, _language);
+	BOOST_REQUIRE(error);
+	return *error;
+}
+
+void parsePrintCompare(std::string const& _source, bool _canWarn = false)
+{
+	YulStack stack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		YulStack::Language::Assembly,
+		OptimiserSettings::none(),
+		DebugInfoSelection::None()
+	);
+	BOOST_REQUIRE(stack.parseAndAnalyze("", _source));
+	if (_canWarn)
+		BOOST_REQUIRE(!Error::containsErrors(stack.errors()));
+	else
+		BOOST_REQUIRE(stack.errors().empty());
+	std::string expectation = "object \"object\" {\n    code " + boost::replace_all_copy(_source, "\n", "\n    ") + "\n}\n";
+	BOOST_CHECK_EQUAL(stack.print(), expectation);
+}
+
+}
+
+#define CHECK_ERROR_LANG(text, assemble, typ, substring, warnings, language) \
+do \
+{ \
+	Error err = expectError((text), (assemble), warnings, (language)); \
+	BOOST_CHECK(err.type() == (Error::Type::typ)); \
+	BOOST_CHECK(searchErrorMessage(err, (substring))); \
+} while(0)
+
+#define CHECK_ERROR(text, assemble, typ, substring, warnings) \
+CHECK_ERROR_LANG(text, assemble, typ, substring, warnings, YulStack::Language::Assembly)
+
+#define CHECK_PARSE_ERROR(text, type, substring) \
+CHECK_ERROR(text, false, type, substring, false)
+
+#define CHECK_PARSE_WARNING(text, type, substring) \
+CHECK_ERROR(text, false, type, substring, false)
+
+#define CHECK_ASSEMBLE_ERROR(text, type, substring) \
+CHECK_ERROR(text, true, type, substring, false)
+
+#define CHECK_STRICT_ERROR(text, type, substring) \
+CHECK_ERROR_LANG(text, false, type, substring, false, YulStack::Language::StrictAssembly)
+
+#define CHECK_STRICT_WARNING(text, type, substring) \
+CHECK_ERROR(text, false, type, substring, false, YulStack::Language::StrictAssembly)
+
+#define SUCCESS_STRICT(text) \
+do { successParse((text), false, false, YulStack::Language::StrictAssembly); } while (false)
+
+
+BOOST_AUTO_TEST_SUITE(SolidityInlineAssembly)
+
+BOOST_AUTO_TEST_SUITE(Printing) // {{{
+
+BOOST_AUTO_TEST_CASE(print_smoke)
+{
+	parsePrintCompare("{ }");
+}
+
+BOOST_AUTO_TEST_CASE(print_instructions)
+{
+	parsePrintCompare("{ pop(7) }");
+}
+
+BOOST_AUTO_TEST_CASE(print_subblock)
+{
+	parsePrintCompare("{ { pop(7) } }");
+}
+
+BOOST_AUTO_TEST_CASE(print_functional)
+{
+	parsePrintCompare("{ let x := mul(sload(0x12), 7) }");
+}
+
+BOOST_AUTO_TEST_CASE(print_assignments)
+{
+	parsePrintCompare("{\n    let x := mul(2, 3)\n    pop(7)\n    x := add(1, 2)\n}");
+}
+
+BOOST_AUTO_TEST_CASE(print_multi_assignments)
+{
+	parsePrintCompare("{\n    function f() -> x, y\n    { }\n    let x, y := f()\n}");
+}
+
+BOOST_AUTO_TEST_CASE(print_string_literals)
+{
+	parsePrintCompare("{ let x := \"\\n'\\xab\\x95\\\"\" }");
+}
+
+BOOST_AUTO_TEST_CASE(print_string_literal_unicode)
+{
+	std::string source = "{ let x := \"\\u1bac\" }";
+	std::string parsed = "object \"object\" {\n    code { let x := \"\\xe1\\xae\\xac\" }\n}\n";
+	YulStack stack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		YulStack::Language::Assembly,
+		OptimiserSettings::none(),
+		DebugInfoSelection::None()
+	);
+	BOOST_REQUIRE(stack.parseAndAnalyze("", source));
+	BOOST_REQUIRE(stack.errors().empty());
+	BOOST_CHECK_EQUAL(stack.print(), parsed);
+
+	std::string parsedInner = "{ let x := \"\\xe1\\xae\\xac\" }";
+	parsePrintCompare(parsedInner);
+}
+
+BOOST_AUTO_TEST_CASE(print_if)
+{
+	parsePrintCompare("{ if 2 { pop(mload(0)) } }");
+}
+
+BOOST_AUTO_TEST_CASE(print_switch)
+{
+	parsePrintCompare("{\n    switch 42\n    case 1 { }\n    case 2 { }\n    default { }\n}");
+}
+
+BOOST_AUTO_TEST_CASE(print_for)
+{
+	parsePrintCompare("{\n    let ret := 5\n    for { let i := 1 } lt(i, 15) { i := add(i, 1) }\n    { ret := mul(ret, i) }\n}");
+}
+
+BOOST_AUTO_TEST_CASE(function_definitions_multiple_args)
+{
+	parsePrintCompare("{\n    function f(a, d)\n    { mstore(a, d) }\n    function g(a, d) -> x, y\n    { }\n}");
+}
+
+BOOST_AUTO_TEST_CASE(function_calls)
+{
+	std::string source = R"({
+	function y()
+	{ }
+	function f(a) -> b
+	{ }
+	function g(a, b, c)
+	{ }
+	g(1, mul(2, address()), f(mul(2, caller())))
+	y()
+})";
+	boost::replace_all(source, "\t", "    ");
+	parsePrintCompare(source);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+// }}}
+
+BOOST_AUTO_TEST_SUITE(Analysis) // {{{
+
+BOOST_AUTO_TEST_CASE(string_literals)
+{
+	BOOST_CHECK(successAssemble("{ let x := \"12345678901234567890123456789012\" }"));
+}
+
+BOOST_AUTO_TEST_CASE(oversize_string_literals)
+{
+	CHECK_ASSEMBLE_ERROR("{ let x := \"123456789012345678901234567890123\" }", TypeError, "String literal too long");
+}
+
+BOOST_AUTO_TEST_CASE(magic_variables)
+{
+	CHECK_ASSEMBLE_ERROR("{ pop(this) }", DeclarationError, "Identifier \"this\" not found");
+	CHECK_ASSEMBLE_ERROR("{ pop(ecrecover) }", DeclarationError, "Identifier \"ecrecover\" not found");
+	BOOST_CHECK(successAssemble("{ let ecrecover := 1 pop(ecrecover) }"));
+}
+
+BOOST_AUTO_TEST_CASE(stack_variables)
+{
+	BOOST_CHECK(successAssemble("{ let y := 3 { let z := 2 { let x := y } } }"));
+}
+
+BOOST_AUTO_TEST_CASE(designated_invalid_instruction)
+{
+	BOOST_CHECK(successAssemble("{ invalid() }"));
+}
+
+BOOST_AUTO_TEST_CASE(inline_assembly_shadowed_instruction_declaration)
+{
+	CHECK_ASSEMBLE_ERROR("{ let gas := 1 }", ParserError, "Cannot use builtin");
+}
+
+BOOST_AUTO_TEST_CASE(revert)
+{
+	BOOST_CHECK(successAssemble("{ revert(0, 0) }"));
+}
+
+BOOST_AUTO_TEST_CASE(large_constant)
+{
+	auto source = R"({
+		switch mul(1, 2)
+		case 0x0000000000000000000000000000000000000000000000000000000026121ff0 {
+		}
+	})";
+	BOOST_CHECK(successAssemble(source));
+}
+
+BOOST_AUTO_TEST_CASE(keccak256)
+{
+	BOOST_CHECK(successAssemble("{ pop(keccak256(0, 0)) }"));
+}
+
+BOOST_AUTO_TEST_CASE(returndatasize)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+		return;
+	BOOST_CHECK(successAssemble("{ let r := returndatasize() }"));
+}
+
+BOOST_AUTO_TEST_CASE(returndatacopy)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+		return;
+	BOOST_CHECK(successAssemble("{ returndatacopy(0, 32, 64) }"));
+}
+
+BOOST_AUTO_TEST_CASE(staticcall)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+		return;
+	BOOST_CHECK(successAssemble("{ pop(staticcall(10000, 0x123, 64, 0x10, 128, 0x10)) }"));
+}
+
+BOOST_AUTO_TEST_CASE(create2)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().hasCreate2())
+		return;
+	BOOST_CHECK(successAssemble("{ pop(create2(10, 0x123, 32, 64)) }"));
+}
+
+BOOST_AUTO_TEST_CASE(shift)
+{
+	if (!solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+		return;
+	BOOST_CHECK(successAssemble("{ pop(shl(10, 32)) }"));
+	BOOST_CHECK(successAssemble("{ pop(shr(10, 32)) }"));
+	BOOST_CHECK(successAssemble("{ pop(sar(10, 32)) }"));
+}
+
+BOOST_AUTO_TEST_CASE(shift_constantinople_warning)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasBitwiseShifting())
+		return;
+	CHECK_PARSE_WARNING("{ shl(10, 32) }", TypeError, "The \"shl\" instruction is only available for Constantinople-compatible VMs");
+	CHECK_PARSE_WARNING("{ shr(10, 32) }", TypeError, "The \"shr\" instruction is only available for Constantinople-compatible VMs");
+	CHECK_PARSE_WARNING("{ sar(10, 32) }", TypeError, "The \"sar\" instruction is only available for Constantinople-compatible VMs");
+}
+
+BOOST_AUTO_TEST_SUITE_END() // }}}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/LibSolc.cpp b/compiler/test/libsolidity/LibSolc.cpp
new file mode 100644
index 00000000..1a7a6ba6
--- /dev/null
+++ b/compiler/test/libsolidity/LibSolc.cpp
@@ -0,0 +1,183 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @date 2017
+ * Unit tests for libsolc/libsolc.cpp.
+ */
+
+#include <string>
+#include <boost/test/unit_test.hpp>
+#include <libsolutil/JSON.h>
+#include <libsolidity/interface/ReadFile.h>
+#include <libsolidity/interface/Version.h>
+#include <libsolc/libsolc.h>
+
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+/// TODO: share this between StandardCompiler.cpp
+/// Helper to match a specific error type and message
+bool containsError(Json::Value const& _compilerResult, std::string const& _type, std::string const& _message)
+{
+	if (!_compilerResult.isMember("errors"))
+		return false;
+
+	for (auto const& error: _compilerResult["errors"])
+	{
+		BOOST_REQUIRE(error.isObject());
+		BOOST_REQUIRE(error["type"].isString());
+		BOOST_REQUIRE(error["message"].isString());
+		if ((error["type"].asString() == _type) && (error["message"].asString() == _message))
+			return true;
+	}
+
+	return false;
+}
+
+Json::Value compile(std::string const& _input, CStyleReadFileCallback _callback = nullptr)
+{
+	char* output_ptr = solidity_compile(_input.c_str(), _callback, nullptr);
+	std::string output(output_ptr);
+	solidity_free(output_ptr);
+	solidity_reset();
+	Json::Value ret;
+	BOOST_REQUIRE(util::jsonParseStrict(output, ret));
+	return ret;
+}
+
+char* stringToSolidity(std::string const& _input)
+{
+	char* ptr = solidity_alloc(_input.length());
+	BOOST_REQUIRE(ptr != nullptr);
+	std::memcpy(ptr, _input.c_str(), _input.length());
+	return ptr;
+}
+
+} // end anonymous namespace
+
+BOOST_AUTO_TEST_SUITE(LibSolc)
+
+BOOST_AUTO_TEST_CASE(read_version)
+{
+	std::string output(solidity_version());
+	BOOST_CHECK(output.find(VersionString) == 0);
+}
+
+BOOST_AUTO_TEST_CASE(read_license)
+{
+	std::string output(solidity_license());
+	BOOST_CHECK(output.find("GNU GENERAL PUBLIC LICENSE") != std::string::npos);
+}
+
+BOOST_AUTO_TEST_CASE(standard_compilation)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_REQUIRE(result.isObject());
+
+	// Only tests some assumptions. The StandardCompiler is tested properly in another suite.
+	BOOST_CHECK(result.isMember("sources"));
+	// This used to test that it is a member, but we did not actually request any output,
+	// so there should not be a contract member.
+	BOOST_CHECK(!result.isMember("contracts"));
+}
+
+BOOST_AUTO_TEST_CASE(missing_callback)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"fileA": {
+				"content": "import \"missing.sol\"; contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_REQUIRE(result.isObject());
+
+	BOOST_CHECK(containsError(result, "ParserError", "Source \"missing.sol\" not found: File not supplied initially."));
+}
+
+BOOST_AUTO_TEST_CASE(with_callback)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"fileA": {
+				"content": "import \"found.sol\"; import \"notfound.sol\"; contract A { }"
+			}
+		}
+	}
+	)";
+
+	CStyleReadFileCallback callback{
+		[](void* _context, char const* _kind, char const* _path, char** o_contents, char** o_error)
+		{
+			// Passed in a nullptr in the compile() helper above.
+			BOOST_REQUIRE(_context == nullptr);
+			// Caller frees the pointers.
+			BOOST_REQUIRE(std::string(_kind) == ReadCallback::kindString(ReadCallback::Kind::ReadFile));
+			if (std::string(_path) == "found.sol")
+			{
+				static std::string content{"import \"missing.sol\"; contract B {}"};
+				*o_contents = stringToSolidity(content);
+				*o_error = nullptr;
+			}
+			else if (std::string(_path) == "missing.sol")
+			{
+				static std::string errorMsg{"Missing file."};
+				*o_error = stringToSolidity(errorMsg);
+				*o_contents = nullptr;
+			}
+			else
+			{
+				*o_error = nullptr;
+				*o_contents = nullptr;
+			}
+		}
+	};
+
+	Json::Value result = compile(input, callback);
+	BOOST_REQUIRE(result.isObject());
+
+	// This ensures that "found.sol" was properly loaded which triggered the second import statement.
+	BOOST_CHECK(containsError(result, "ParserError", "Source \"missing.sol\" not found: Missing file."));
+
+	// This should be placed due to the missing "notfound.sol" which sets both pointers to null.
+	BOOST_CHECK(containsError(result, "ParserError", "Source \"notfound.sol\" not found: Callback not supported."));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/MemoryGuardTest.cpp b/compiler/test/libsolidity/MemoryGuardTest.cpp
new file mode 100644
index 00000000..7f0914cc
--- /dev/null
+++ b/compiler/test/libsolidity/MemoryGuardTest.cpp
@@ -0,0 +1,88 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/MemoryGuardTest.h>
+
+#include <test/Common.h>
+#include <test/libyul/Common.h>
+#include <libsolidity/codegen/ir/Common.h>
+#include <libsolutil/Algorithms.h>
+#include <libsolutil/StringUtils.h>
+#include <libyul/Object.h>
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/optimiser/FunctionCallFinder.h>
+#include <fstream>
+#include <memory>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::util::formatting;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::test;
+using namespace yul;
+
+void MemoryGuardTest::setupCompiler(CompilerStack& _compiler)
+{
+	AnalysisFramework::setupCompiler(_compiler);
+
+	_compiler.setViaIR(true);
+	_compiler.setOptimiserSettings(OptimiserSettings::none());
+}
+
+TestCase::TestResult MemoryGuardTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	if (!runFramework(m_source, PipelineStage::Compilation))
+	{
+		printPrefixed(_stream, formatErrors(filteredErrors(), _formatted), _linePrefix);
+		return TestResult::FatalError;
+	}
+
+	m_obtainedResult.clear();
+	for (std::string contractName: compiler().contractNames())
+	{
+		ErrorList errors;
+		auto [object, analysisInfo] = yul::test::parse(
+			compiler().yulIR(contractName),
+			EVMDialect::strictAssemblyForEVMObjects(CommonOptions::get().evmVersion()),
+			errors
+		);
+
+		if (!object || !analysisInfo || Error::containsErrors(errors))
+		{
+			AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing IR:" << std::endl;
+			printPrefixed(_stream, formatErrors(filterErrors(errors), _formatted), _linePrefix);
+			return TestResult::FatalError;
+		}
+
+		auto handleObject = [&](std::string const& _kind, Object const& _object) {
+			m_obtainedResult += contractName + "(" + _kind + ") " + (FunctionCallFinder::run(
+				*_object.code,
+				"memoryguard"_yulstring
+			).empty() ? "false" : "true") + "\n";
+		};
+		handleObject("creation", *object);
+		size_t deployedIndex = object->subIndexByName.at(
+			YulString(IRNames::deployedObject(compiler().contractDefinition(contractName)))
+		);
+		handleObject("runtime", dynamic_cast<Object const&>(*object->subObjects[deployedIndex]));
+	}
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libsolidity/MemoryGuardTest.h b/compiler/test/libsolidity/MemoryGuardTest.h
new file mode 100644
index 00000000..e8e5f0ea
--- /dev/null
+++ b/compiler/test/libsolidity/MemoryGuardTest.h
@@ -0,0 +1,56 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <test/CommonSyntaxTest.h>
+#include <liblangutil/Exceptions.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend::test
+{
+
+using solidity::test::SyntaxTestError;
+
+class MemoryGuardTest: public AnalysisFramework, public EVMVersionRestrictedTestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<MemoryGuardTest>(_config.filename);
+	}
+	MemoryGuardTest(std::string const& _filename): EVMVersionRestrictedTestCase(_filename)
+	{
+		m_source = m_reader.source();
+		m_expectation = m_reader.simpleExpectations();
+	}
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false) override;
+
+protected:
+	void setupCompiler(CompilerStack& _compiler) override;
+};
+
+}
diff --git a/compiler/test/libsolidity/Metadata.cpp b/compiler/test/libsolidity/Metadata.cpp
new file mode 100644
index 00000000..029419af
--- /dev/null
+++ b/compiler/test/libsolidity/Metadata.cpp
@@ -0,0 +1,659 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @date 2017
+ * Unit tests for the metadata output.
+ */
+
+#include <test/Metadata.h>
+#include <test/Common.h>
+#include <libsolidity/interface/CompilerStack.h>
+#include <libsolidity/interface/Version.h>
+#include <libsolutil/SwarmHash.h>
+#include <libsolutil/IpfsHash.h>
+#include <libsolutil/JSON.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+std::map<std::string, std::string> requireParsedCBORMetadata(bytes const& _bytecode, CompilerStack::MetadataFormat _metadataFormat)
+{
+	bytes cborMetadata = solidity::test::onlyMetadata(_bytecode);
+	if (_metadataFormat != CompilerStack::MetadataFormat::NoMetadata)
+	{
+		BOOST_REQUIRE(!cborMetadata.empty());
+		std::optional<std::map<std::string, std::string>> tmp = solidity::test::parseCBORMetadata(cborMetadata);
+		BOOST_REQUIRE(tmp);
+		return *tmp;
+	}
+	BOOST_REQUIRE(cborMetadata.empty());
+	return {};
+}
+
+std::optional<std::string> compileAndCheckLicenseMetadata(std::string const& _contractName, char const* _sourceCode)
+{
+	CompilerStack compilerStack;
+	compilerStack.setSources({{"A.sol", _sourceCode}});
+	BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+	std::string const& serialisedMetadata = compilerStack.metadata(_contractName);
+	Json::Value metadata;
+	BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
+	BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+	BOOST_CHECK_EQUAL(metadata["sources"].size(), 1);
+	BOOST_REQUIRE(metadata["sources"].isMember("A.sol"));
+
+	if (metadata["sources"]["A.sol"].isMember("license"))
+	{
+		BOOST_REQUIRE(metadata["sources"]["A.sol"]["license"].isString());
+		return metadata["sources"]["A.sol"]["license"].asString();
+	}
+	else
+		return std::nullopt;
+}
+
+}
+
+BOOST_AUTO_TEST_SUITE(Metadata)
+
+BOOST_AUTO_TEST_CASE(metadata_stamp)
+{
+	// Check that the metadata stamp is at the end of the runtime bytecode.
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		pragma experimental __testOnlyAnalysis;
+		contract test {
+			function g(function(uint) external returns (uint) x) public {}
+		}
+	)";
+	for (auto metadataFormat: std::set<CompilerStack::MetadataFormat>{
+		CompilerStack::MetadataFormat::NoMetadata,
+		CompilerStack::MetadataFormat::WithReleaseVersionTag,
+		CompilerStack::MetadataFormat::WithPrereleaseVersionTag
+	})
+		for (auto metadataHash: std::set<CompilerStack::MetadataHash>{
+			CompilerStack::MetadataHash::IPFS,
+			CompilerStack::MetadataHash::Bzzr1,
+			CompilerStack::MetadataHash::None
+		})
+		{
+			CompilerStack compilerStack;
+			compilerStack.setMetadataFormat(metadataFormat);
+			compilerStack.setSources({{"", sourceCode}});
+			compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+			compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+			compilerStack.setMetadataHash(metadataHash);
+			BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+			bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
+			std::string const& metadata = compilerStack.metadata("test");
+			BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+			auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
+			if (metadataHash == CompilerStack::MetadataHash::None)
+				BOOST_CHECK(cborMetadata.size() == (metadataFormat == CompilerStack::MetadataFormat::NoMetadata ? 0 : 1));
+			else
+			{
+				bytes hash;
+				std::string hashMethod;
+				if (metadataHash == CompilerStack::MetadataHash::IPFS)
+				{
+					hash = util::ipfsHash(metadata);
+					BOOST_REQUIRE(hash.size() == 34);
+					hashMethod = "ipfs";
+				}
+				else
+				{
+					hash = util::bzzr1Hash(metadata).asBytes();
+					BOOST_REQUIRE(hash.size() == 32);
+					hashMethod = "bzzr1";
+				}
+
+				if (metadataFormat != CompilerStack::MetadataFormat::NoMetadata)
+				{
+					BOOST_CHECK(cborMetadata.size() == 2);
+					BOOST_CHECK(cborMetadata.count(hashMethod) == 1);
+					BOOST_CHECK(cborMetadata.at(hashMethod) == util::toHex(hash));
+				}
+			}
+
+			if (metadataFormat == CompilerStack::MetadataFormat::NoMetadata)
+				BOOST_CHECK(cborMetadata.count("solc") == 0);
+			else
+			{
+				BOOST_CHECK(cborMetadata.count("solc") == 1);
+				if (metadataFormat == CompilerStack::MetadataFormat::WithReleaseVersionTag)
+					BOOST_CHECK(cborMetadata.at("solc") == util::toHex(VersionCompactBytes));
+				else
+					BOOST_CHECK(cborMetadata.at("solc") == VersionStringStrict);
+			}
+		}
+}
+
+BOOST_AUTO_TEST_CASE(metadata_stamp_experimental)
+{
+	// Check that the metadata stamp is at the end of the runtime bytecode.
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		pragma experimental __test;
+		contract test {
+			function g(function(uint) external returns (uint) x) public {}
+		}
+	)";
+	for (auto metadataFormat: std::set<CompilerStack::MetadataFormat>{
+			CompilerStack::MetadataFormat::NoMetadata,
+			CompilerStack::MetadataFormat::WithReleaseVersionTag,
+			CompilerStack::MetadataFormat::WithPrereleaseVersionTag
+	})
+		for (auto metadataHash: std::set<CompilerStack::MetadataHash>{
+			CompilerStack::MetadataHash::IPFS,
+			CompilerStack::MetadataHash::Bzzr1,
+			CompilerStack::MetadataHash::None
+		})
+		{
+			CompilerStack compilerStack;
+			compilerStack.setMetadataFormat(metadataFormat);
+			compilerStack.setSources({{"", sourceCode}});
+			compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+			compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+			compilerStack.setMetadataHash(metadataHash);
+			BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+			bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
+			std::string const& metadata = compilerStack.metadata("test");
+			BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+			auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
+			if (metadataHash == CompilerStack::MetadataHash::None)
+				BOOST_CHECK(cborMetadata.size() == (metadataFormat == CompilerStack::MetadataFormat::NoMetadata ? 0 : 2));
+			else
+			{
+				bytes hash;
+				std::string hashMethod;
+				if (metadataHash == CompilerStack::MetadataHash::IPFS)
+				{
+					hash = util::ipfsHash(metadata);
+					BOOST_REQUIRE(hash.size() == 34);
+					hashMethod = "ipfs";
+				}
+				else
+				{
+					hash = util::bzzr1Hash(metadata).asBytes();
+					BOOST_REQUIRE(hash.size() == 32);
+					hashMethod = "bzzr1";
+				}
+
+				if (metadataFormat != CompilerStack::MetadataFormat::NoMetadata)
+				{
+					BOOST_CHECK(cborMetadata.size() == 3);
+					BOOST_CHECK(cborMetadata.count(hashMethod) == 1);
+					BOOST_CHECK(cborMetadata.at(hashMethod) == util::toHex(hash));
+				}
+			}
+
+			if (metadataFormat == CompilerStack::MetadataFormat::NoMetadata)
+				BOOST_CHECK(cborMetadata.count("solc") == 0);
+			else
+			{
+				BOOST_CHECK(cborMetadata.count("solc") == 1);
+				if (metadataFormat == CompilerStack::MetadataFormat::WithReleaseVersionTag)
+					BOOST_CHECK(cborMetadata.at("solc") == util::toHex(VersionCompactBytes));
+				else
+					BOOST_CHECK(cborMetadata.at("solc") == VersionStringStrict);
+				BOOST_CHECK(cborMetadata.count("experimental") == 1);
+				BOOST_CHECK(cborMetadata.at("experimental") == "true");
+			}
+		}
+}
+
+BOOST_AUTO_TEST_CASE(metadata_eof_experimental)
+{
+	// Check that setting an EOF version results in the experimental flag being set.
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		contract test {
+			function g(function(uint) external returns (uint) x) public {}
+		}
+	)";
+	for (auto metadataFormat: std::set<CompilerStack::MetadataFormat>{
+		CompilerStack::MetadataFormat::NoMetadata,
+		CompilerStack::MetadataFormat::WithReleaseVersionTag,
+		CompilerStack::MetadataFormat::WithPrereleaseVersionTag
+	})
+	{
+		CompilerStack compilerStack;
+		compilerStack.setMetadataFormat(metadataFormat);
+		compilerStack.setSources({{"", sourceCode}});
+		compilerStack.setEVMVersion({});
+		compilerStack.setViaIR(true);
+		compilerStack.setEOFVersion(1);
+		compilerStack.setOptimiserSettings(true);
+		BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+		bytes const& bytecode = compilerStack.runtimeObject("test").bytecode;
+		std::string const& metadata = compilerStack.metadata("test");
+		BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+		auto const cborMetadata = requireParsedCBORMetadata(bytecode, metadataFormat);
+
+		if (metadataFormat == CompilerStack::MetadataFormat::NoMetadata)
+			BOOST_CHECK(cborMetadata.count("experimental") == 0);
+		else
+		{
+			BOOST_CHECK(cborMetadata.count("experimental") == 1);
+			BOOST_CHECK(cborMetadata.at("experimental") == "true");
+		}
+	}
+}
+
+BOOST_AUTO_TEST_CASE(metadata_relevant_sources)
+{
+	CompilerStack compilerStack;
+	char const* sourceCodeA = R"(
+		pragma solidity >=0.0;
+		contract A {
+			function g(function(uint) external returns (uint) x) public {}
+		}
+	)";
+	char const* sourceCodeB = R"(
+		pragma solidity >=0.0;
+		contract B {
+			function g(function(uint) external returns (uint) x) public {}
+		}
+	)";
+	compilerStack.setSources({
+		{"A", sourceCodeA},
+		{"B", sourceCodeB},
+	});
+	compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+	BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+	std::string const& serialisedMetadata = compilerStack.metadata("A");
+	Json::Value metadata;
+	BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
+	BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+	BOOST_CHECK_EQUAL(metadata["sources"].size(), 1);
+	BOOST_CHECK(metadata["sources"].isMember("A"));
+}
+
+BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
+{
+	CompilerStack compilerStack;
+	char const* sourceCodeA = R"(
+		pragma solidity >=0.0;
+		contract A {
+			function g(function(uint) external returns (uint) x) public virtual {}
+		}
+	)";
+	char const* sourceCodeB = R"(
+		pragma solidity >=0.0;
+		import "./A";
+		contract B is A {
+			function g(function(uint) external returns (uint) x) public virtual override {}
+		}
+	)";
+	char const* sourceCodeC = R"(
+		pragma solidity >=0.0;
+		import "./B";
+		contract C is B {
+			function g(function(uint) external returns (uint) x) public override {}
+		}
+	)";
+	compilerStack.setSources({
+		{"A", sourceCodeA},
+		{"B", sourceCodeB},
+		{"C", sourceCodeC}
+	});
+	compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+	compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+	BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+	std::string const& serialisedMetadata = compilerStack.metadata("C");
+	Json::Value metadata;
+	BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
+	BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+	BOOST_CHECK_EQUAL(metadata["sources"].size(), 3);
+	BOOST_CHECK(metadata["sources"].isMember("A"));
+	BOOST_CHECK(metadata["sources"].isMember("B"));
+	BOOST_CHECK(metadata["sources"].isMember("C"));
+}
+
+BOOST_AUTO_TEST_CASE(metadata_useLiteralContent)
+{
+	// Check that the metadata contains "useLiteralContent"
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		contract test {
+		}
+	)";
+
+	auto check = [](char const* _src, bool _literal)
+	{
+		CompilerStack compilerStack;
+		compilerStack.setSources({{"", _src}});
+		compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+		compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+		compilerStack.useMetadataLiteralSources(_literal);
+		BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+		std::string metadata_str = compilerStack.metadata("test");
+		Json::Value metadata;
+		BOOST_REQUIRE(util::jsonParseStrict(metadata_str, metadata));
+		BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+		BOOST_CHECK(metadata.isMember("settings"));
+		BOOST_CHECK(metadata["settings"].isMember("metadata"));
+		BOOST_CHECK(metadata["settings"]["metadata"].isMember("bytecodeHash"));
+		if (_literal)
+		{
+			BOOST_CHECK(metadata["settings"]["metadata"].isMember("useLiteralContent"));
+			BOOST_CHECK(metadata["settings"]["metadata"]["useLiteralContent"].asBool());
+		}
+	};
+
+	check(sourceCode, true);
+	check(sourceCode, false);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_viair)
+{
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		contract test {
+		}
+	)";
+
+	auto check = [](char const* _src, bool _viaIR)
+	{
+		CompilerStack compilerStack;
+		compilerStack.setSources({{"", _src}});
+		compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+		compilerStack.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
+		compilerStack.setViaIR(_viaIR);
+		BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+		Json::Value metadata;
+		BOOST_REQUIRE(util::jsonParseStrict(compilerStack.metadata("test"), metadata));
+		BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+		BOOST_CHECK(metadata.isMember("settings"));
+		if (_viaIR)
+		{
+			BOOST_CHECK(metadata["settings"].isMember("viaIR"));
+			BOOST_CHECK(metadata["settings"]["viaIR"].asBool());
+		}
+		else
+			BOOST_CHECK(!metadata["settings"].isMember("viaIR"));
+
+		BOOST_CHECK(compilerStack.cborMetadata("test") == compilerStack.cborMetadata("test", _viaIR));
+		BOOST_CHECK(compilerStack.cborMetadata("test") != compilerStack.cborMetadata("test", !_viaIR));
+
+		std::map<std::string, std::string> const parsedCBORMetadata = requireParsedCBORMetadata(
+			compilerStack.runtimeObject("test").bytecode,
+			CompilerStack::MetadataFormat::WithReleaseVersionTag
+		);
+
+		BOOST_CHECK(parsedCBORMetadata.count("experimental") == 0);
+	};
+
+	check(sourceCode, true);
+	check(sourceCode, false);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_revert_strings)
+{
+	CompilerStack compilerStack;
+	char const* sourceCodeA = R"(
+		pragma solidity >=0.0;
+		contract A {
+		}
+	)";
+	compilerStack.setSources({{"A", sourceCodeA}});
+	compilerStack.setRevertStringBehaviour(RevertStrings::Strip);
+	BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+	std::string const& serialisedMetadata = compilerStack.metadata("A");
+	Json::Value metadata;
+	BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
+	BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+
+	BOOST_CHECK_EQUAL(metadata["settings"]["debug"]["revertStrings"], "strip");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_optimiser_sequence)
+{
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		contract C {
+		}
+	)";
+
+	std::vector<std::tuple<std::string, std::string>> sequences =
+	{
+		// {"<optimizer sequence>", "<optimizer cleanup sequence>"}
+		{"", ""},
+		{"", "fDn"},
+		{"dhfoDgvulfnTUtnIf", "" },
+		{"dhfoDgvulfnTUtnIf", "fDn"}
+	};
+
+	auto check = [sourceCode](std::string const& _optimizerSequence, std::string const& _optimizerCleanupSequence)
+	{
+		OptimiserSettings optimizerSettings = OptimiserSettings::minimal();
+		optimizerSettings.runYulOptimiser = true;
+		optimizerSettings.yulOptimiserSteps = _optimizerSequence;
+		optimizerSettings.yulOptimiserCleanupSteps = _optimizerCleanupSequence;
+		CompilerStack compilerStack;
+		compilerStack.setSources({{"", sourceCode}});
+		compilerStack.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
+		compilerStack.setOptimiserSettings(optimizerSettings);
+
+		BOOST_REQUIRE_MESSAGE(compilerStack.compile(), "Compiling contract failed");
+
+		std::string const& serialisedMetadata = compilerStack.metadata("C");
+		Json::Value metadata;
+		BOOST_REQUIRE(util::jsonParseStrict(serialisedMetadata, metadata));
+		BOOST_CHECK(solidity::test::isValidMetadata(metadata));
+		BOOST_CHECK(metadata["settings"]["optimizer"].isMember("details"));
+		BOOST_CHECK(metadata["settings"]["optimizer"]["details"].isMember("yulDetails"));
+		BOOST_CHECK(metadata["settings"]["optimizer"]["details"]["yulDetails"].isMember("optimizerSteps"));
+
+		std::string const metadataOptimizerSteps = metadata["settings"]["optimizer"]["details"]["yulDetails"]["optimizerSteps"].asString();
+		std::string const expectedMetadataOptimiserSteps = _optimizerSequence + ":" + _optimizerCleanupSequence;
+		BOOST_CHECK_EQUAL(metadataOptimizerSteps, expectedMetadataOptimiserSteps);
+	};
+
+	for (auto const& [sequence, cleanupSequence] : sequences)
+		check(sequence, cleanupSequence);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_missing)
+{
+	char const* sourceCode = R"(
+		pragma solidity >=0.0;
+		contract C {
+		}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_gpl3)
+{
+	// Can't use a raw string here due to the stylechecker.
+	char const* sourceCode =
+		"// NOTE: we also add trailing whitespace after the license, to see it is trimmed.\n"
+		"// SPDX-License-Identifier: GPL-3.0    \n"
+		"pragma solidity >=0.0;\n"
+		"contract C {\n"
+		"}\n";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_whitespace_before_spdx)
+{
+	char const* sourceCode = R"(
+		//     SPDX-License-Identifier: GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_whitespace_after_colon)
+{
+	char const* sourceCode = R"(
+		// SPDX-License-Identifier:    GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_gpl3_or_apache2)
+{
+	char const* sourceCode = R"(
+		// SPDX-License-Identifier: GPL-3.0 OR Apache-2.0
+		pragma solidity >=0.0;
+		contract C {
+		}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0 OR Apache-2.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_bidi_marks)
+{
+	char const* sourceCode =
+		"// \xE2\x80\xAE""0.3-LPG :reifitnedI-esneciL-XDPS\xE2\x80\xAC\n"
+		"// NOTE: The text above is reversed using Unicode directional marks. In raw form it would look like this:\n"
+		"// <LRO>0.3-LPG :reifitnedI-esneciL-XDPS<PDF>\n"
+		"contract C {}\n";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_bottom)
+{
+	char const* sourceCode = R"(
+		contract C {}
+		// SPDX-License-Identifier: GPL-3.0
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_cr_endings)
+{
+	char const* sourceCode =
+		"// SPDX-License-Identifier: GPL-3.0\r"
+		"contract C {}\r";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_crlf_endings)
+{
+	char const* sourceCode =
+		"// SPDX-License-Identifier: GPL-3.0\r\n"
+		"contract C {}\r\n";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_in_string)
+{
+	char const* sourceCode = R"(
+		contract C {
+			bytes license = "// SPDX-License-Identifier: GPL-3.0";
+		}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_in_contract)
+{
+	char const* sourceCode = R"(
+		contract C {
+		// SPDX-License-Identifier: GPL-3.0
+		}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_missing_colon)
+{
+	char const* sourceCode = R"(
+		// SPDX-License-Identifier GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_multiline)
+{
+	char const* sourceCode = R"(
+		/* SPDX-License-Identifier: GPL-3.0 */
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_natspec)
+{
+	char const* sourceCode = R"(
+		/// SPDX-License-Identifier: GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_natspec_multiline)
+{
+	char const* sourceCode = R"(
+		/** SPDX-License-Identifier: GPL-3.0 */
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_no_whitespace_multiline)
+{
+	char const* sourceCode = R"(
+		/*SPDX-License-Identifier:GPL-3.0*/
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_nonempty_line)
+{
+	char const* sourceCode = R"(
+		pragma solidity >= 0.0; // SPDX-License-Identifier: GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_CASE(metadata_license_no_whitespace)
+{
+	char const* sourceCode = R"(
+		//SPDX-License-Identifier:GPL-3.0
+		contract C {}
+	)";
+	BOOST_CHECK(compileAndCheckLicenseMetadata("C", sourceCode) == "GPL-3.0");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/NatspecJSONTest.cpp b/compiler/test/libsolidity/NatspecJSONTest.cpp
new file mode 100644
index 00000000..9f1ba1d7
--- /dev/null
+++ b/compiler/test/libsolidity/NatspecJSONTest.cpp
@@ -0,0 +1,211 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * Unit tests for the solidity compiler ABI JSON Interface output.
+ */
+
+#include <test/libsolidity/NatspecJSONTest.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <fmt/format.h>
+
+#include <vector>
+
+using namespace solidity::frontend::test;
+using namespace solidity::util;
+using namespace std::string_literals;
+
+std::ostream& solidity::frontend::test::operator<<(std::ostream& _output, NatspecJSONKind _kind)
+{
+	switch (_kind) {
+	case NatspecJSONKind::Devdoc: _output << "devdoc"; break;
+	case NatspecJSONKind::Userdoc: _output << "userdoc"; break;
+	}
+	return _output;
+}
+
+std::unique_ptr<TestCase> NatspecJSONTest::create(Config const& _config)
+{
+	return std::make_unique<NatspecJSONTest>(_config.filename, _config.evmVersion);
+}
+
+void NatspecJSONTest::parseCustomExpectations(std::istream& _stream)
+{
+	soltestAssert(m_expectedNatspecJSON.empty());
+
+	// We expect a series of expectations in the following format:
+	//
+	//     // <qualified contract name> <devdoc|userdoc>
+	//     // <json>
+
+	std::string line;
+	while (getline(_stream, line))
+	{
+		std::string_view strippedLine = expectLinePrefix(line);
+		if (strippedLine.empty())
+			continue;
+
+		auto [contractName, kind] = parseExpectationHeader(strippedLine);
+
+		std::string rawJSON = extractExpectationJSON(_stream);
+		std::string jsonErrors;
+		Json::Value parsedJSON;
+		bool jsonParsingSuccessful = jsonParseStrict(rawJSON, parsedJSON, &jsonErrors);
+		if (!jsonParsingSuccessful)
+			BOOST_THROW_EXCEPTION(std::runtime_error(fmt::format(
+				"Malformed JSON in {} expectation for contract {}.\n"
+				"Note that JSON expectations must be pretty-printed to be split correctly. "
+				"The object is assumed to and at the first unindented closing brace.\n"
+				"{}",
+				toString(kind),
+				contractName,
+				rawJSON
+			)));
+
+		m_expectedNatspecJSON[std::string(contractName)][kind] = parsedJSON;
+	}
+}
+
+bool NatspecJSONTest::expectationsMatch()
+{
+	// NOTE: Comparing pretty printed Json::Values to avoid using its operator==, which fails to
+	// compare equal numbers as equal. For example, for 'version' field the value is sometimes int,
+	// sometimes uint and they compare as different even when both are 1.
+	return
+		SyntaxTest::expectationsMatch() &&
+		prettyPrinted(obtainedNatspec()) == prettyPrinted(m_expectedNatspecJSON);
+}
+
+void NatspecJSONTest::printExpectedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const
+{
+	SyntaxTest::printExpectedResult(_stream, _linePrefix, _formatted);
+	if (!m_expectedNatspecJSON.empty())
+	{
+		_stream << _linePrefix << "----" << std::endl;
+		printPrefixed(_stream, formatNatspecExpectations(m_expectedNatspecJSON), _linePrefix);
+	}
+
+}
+
+void NatspecJSONTest::printObtainedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const
+{
+	SyntaxTest::printObtainedResult(_stream, _linePrefix, _formatted);
+
+	NatspecMap natspecJSON = obtainedNatspec();
+	if (!natspecJSON.empty())
+	{
+		_stream << _linePrefix << "----" << std::endl;
+		// TODO: Diff both versions and highlight differences.
+		// We should have a helper for doing that in newly defined test cases without much effort.
+		printPrefixed(_stream, formatNatspecExpectations(natspecJSON), _linePrefix);
+	}
+}
+
+std::tuple<std::string_view, NatspecJSONKind> NatspecJSONTest::parseExpectationHeader(std::string_view _line)
+{
+	for (NatspecJSONKind kind: {NatspecJSONKind::Devdoc, NatspecJSONKind::Userdoc})
+	{
+		std::string kindSuffix = " " + toString(kind);
+		if (boost::algorithm::ends_with(_line, kindSuffix))
+			return {_line.substr(0, _line.size() - kindSuffix.size()), kind};
+	}
+
+	BOOST_THROW_EXCEPTION(std::runtime_error(
+		"Natspec kind (devdoc/userdoc) not present in the expectation: "s.append(_line)
+	));
+}
+
+std::string NatspecJSONTest::extractExpectationJSON(std::istream& _stream)
+{
+	std::string rawJSON;
+	std::string line;
+	while (getline(_stream, line))
+	{
+		std::string_view strippedLine = expectLinePrefix(line);
+		rawJSON += strippedLine;
+		rawJSON += "\n";
+
+		if (boost::algorithm::starts_with(strippedLine, "}"))
+			break;
+	}
+
+	return rawJSON;
+}
+
+std::string_view NatspecJSONTest::expectLinePrefix(std::string_view _line)
+{
+	size_t startPosition = 0;
+	if (!boost::algorithm::starts_with(_line, "//"))
+		BOOST_THROW_EXCEPTION(std::runtime_error(
+			"Expectation line is not a comment: "s.append(_line)
+		));
+
+	startPosition += 2;
+	if (startPosition < _line.size() && _line[startPosition] == ' ')
+		++startPosition;
+
+	return _line.substr(startPosition, _line.size() - startPosition);
+}
+
+std::string NatspecJSONTest::formatNatspecExpectations(NatspecMap const& _expectations) const
+{
+	std::string output;
+	bool first = true;
+	// NOTE: Not sorting explicitly because CompilerStack seems to put contracts roughly in the
+	// order in which they appear in the source, which is much better than alphabetical order.
+	for (auto const& [contractName, expectationsForAllKinds]: _expectations)
+		for (auto const& [jsonKind, natspecJSON]: expectationsForAllKinds)
+		{
+			if (!first)
+				output += "\n\n";
+			first = false;
+
+			output += contractName + " " + toString(jsonKind) + "\n";
+			output += jsonPrint(natspecJSON, {JsonFormat::Pretty, 4});
+		}
+
+	return output;
+}
+
+NatspecMap NatspecJSONTest::obtainedNatspec() const
+{
+	if (compiler().state() < CompilerStack::AnalysisSuccessful)
+		return {};
+
+	NatspecMap result;
+	for (std::string contractName: compiler().contractNames())
+	{
+		result[contractName][NatspecJSONKind::Devdoc]  = compiler().natspecDev(contractName);
+		result[contractName][NatspecJSONKind::Userdoc] = compiler().natspecUser(contractName);
+	}
+
+	return result;
+}
+
+SerializedNatspecMap NatspecJSONTest::prettyPrinted(NatspecMap const& _expectations) const
+{
+	SerializedNatspecMap result;
+	for (auto const& [contractName, expectationsForAllKinds]: _expectations)
+		for (auto const& [jsonKind, natspecJSON]: expectationsForAllKinds)
+			result[contractName][jsonKind] = jsonPrint(natspecJSON, {JsonFormat::Pretty, 4});
+
+	return result;
+}
diff --git a/compiler/test/libsolidity/NatspecJSONTest.h b/compiler/test/libsolidity/NatspecJSONTest.h
new file mode 100644
index 00000000..762b88d1
--- /dev/null
+++ b/compiler/test/libsolidity/NatspecJSONTest.h
@@ -0,0 +1,82 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the Natspec userdoc and devdoc JSON output.
+ */
+
+#pragma once
+
+#include <test/libsolidity/SyntaxTest.h>
+
+#include <libsolutil/JSON.h>
+
+#include <istream>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <tuple>
+
+namespace solidity::frontend::test
+{
+
+enum class NatspecJSONKind
+{
+	Devdoc,
+	Userdoc,
+};
+
+std::ostream& operator<<(std::ostream& _output, NatspecJSONKind _kind);
+
+using NatspecMap = std::map<std::string, std::map<NatspecJSONKind, Json::Value>>;
+using SerializedNatspecMap = std::map<std::string, std::map<NatspecJSONKind, std::string>>;
+
+class NatspecJSONTest: public SyntaxTest
+{
+public:
+
+	static std::unique_ptr<TestCase> create(Config const& _config);
+
+	NatspecJSONTest(std::string const& _filename, langutil::EVMVersion _evmVersion):
+		SyntaxTest(
+			_filename,
+			_evmVersion,
+			langutil::Error::Severity::Error // _minSeverity
+		)
+	{}
+
+protected:
+	void parseCustomExpectations(std::istream& _stream) override;
+	bool expectationsMatch() override;
+	void printExpectedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const override;
+	void printObtainedResult(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const override;
+
+	NatspecMap m_expectedNatspecJSON;
+
+private:
+	static std::tuple<std::string_view, NatspecJSONKind> parseExpectationHeader(std::string_view _line);
+	static std::string extractExpectationJSON(std::istream& _stream);
+	static std::string_view expectLinePrefix(std::string_view _line);
+
+	std::string formatNatspecExpectations(NatspecMap const& _expectations) const;
+	SerializedNatspecMap prettyPrinted(NatspecMap const& _expectations) const;
+	NatspecMap obtainedNatspec() const;
+};
+
+}
diff --git a/compiler/test/libsolidity/SMTCheckerTest.cpp b/compiler/test/libsolidity/SMTCheckerTest.cpp
new file mode 100644
index 00000000..893ccb0f
--- /dev/null
+++ b/compiler/test/libsolidity/SMTCheckerTest.cpp
@@ -0,0 +1,162 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/SMTCheckerTest.h>
+#include <test/Common.h>
+
+#include <range/v3/action/remove_if.hpp>
+
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+SMTCheckerTest::SMTCheckerTest(std::string const& _filename): SyntaxTest(_filename, EVMVersion{})
+{
+	auto contract = m_reader.stringSetting("SMTContract", "");
+	if (!contract.empty())
+		m_modelCheckerSettings.contracts.contracts[""] = {contract};
+
+	auto extCallsMode = ModelCheckerExtCalls::fromString(m_reader.stringSetting("SMTExtCalls", "untrusted"));
+	if (extCallsMode)
+		m_modelCheckerSettings.externalCalls = *extCallsMode;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT external calls mode."));
+
+	auto const& showUnproved = m_reader.stringSetting("SMTShowUnproved", "yes");
+	if (showUnproved == "no")
+		m_modelCheckerSettings.showUnproved = false;
+	else if (showUnproved == "yes")
+		m_modelCheckerSettings.showUnproved = true;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT \"show unproved\" choice."));
+
+	auto const& showUnsupported = m_reader.stringSetting("SMTShowUnsupported", "yes");
+	if (showUnsupported == "no")
+		m_modelCheckerSettings.showUnsupported = false;
+	else if (showUnsupported == "yes")
+		m_modelCheckerSettings.showUnsupported = true;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT \"show unsupported\" choice."));
+
+	m_modelCheckerSettings.solvers = smtutil::SMTSolverChoice::None();
+	auto const& choice = m_reader.stringSetting("SMTSolvers", "z3");
+	if (choice == "none")
+		m_modelCheckerSettings.solvers = smtutil::SMTSolverChoice::None();
+	else if (!m_modelCheckerSettings.solvers.setSolver(choice))
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT solver choice."));
+
+	m_modelCheckerSettings.solvers &= ModelChecker::availableSolvers();
+
+	/// Underflow and Overflow are not enabled by default for Solidity >=0.8.7,
+	/// so we explicitly enable all targets for the tests,
+	/// if the targets were not explicitly set by the test.
+	auto targets = ModelCheckerTargets::fromString(m_reader.stringSetting("SMTTargets", "all"));
+	if (targets)
+		m_modelCheckerSettings.targets = *targets;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT targets."));
+
+	auto engine = ModelCheckerEngine::fromString(m_reader.stringSetting("SMTEngine", "all"));
+	if (engine)
+		m_modelCheckerSettings.engine = *engine;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT engine choice."));
+
+	if (m_modelCheckerSettings.solvers.none() || m_modelCheckerSettings.engine.none())
+		m_shouldRun = false;
+
+	auto const& ignoreCex = m_reader.stringSetting("SMTIgnoreCex", "yes");
+	if (ignoreCex == "no")
+		m_ignoreCex = false;
+	else if (ignoreCex == "yes")
+		m_ignoreCex = true;
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT counterexample choice."));
+
+	static auto removeInv = [](std::vector<SyntaxTestError>&& errors) {
+		std::vector<SyntaxTestError> filtered;
+		for (auto&& e: errors)
+			if (e.errorId != 1180_error)
+				filtered.emplace_back(e);
+		return filtered;
+	};
+	if (m_modelCheckerSettings.invariants.invariants.empty())
+		m_expectations = removeInv(std::move(m_expectations));
+
+	auto const& ignoreInv = m_reader.stringSetting("SMTIgnoreInv", "yes");
+	if (ignoreInv == "no")
+		m_modelCheckerSettings.invariants = ModelCheckerInvariants::All();
+	else if (ignoreInv == "yes")
+		m_modelCheckerSettings.invariants = ModelCheckerInvariants::None();
+	else
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid SMT invariant choice."));
+
+	auto const& ignoreOSSetting = m_reader.stringSetting("SMTIgnoreOS", "none");
+	for (std::string const& os: ignoreOSSetting | ranges::views::split(',') | ranges::to<std::vector<std::string>>())
+	{
+#ifdef __APPLE__
+		if (os == "macos")
+			m_shouldRun = false;
+#elif _WIN32
+		if (os == "windows")
+			m_shouldRun = false;
+#elif __linux__
+		if (os == "linux")
+			m_shouldRun = false;
+#endif
+	}
+
+	auto const& bmcLoopIterations = m_reader.sizetSetting("BMCLoopIterations", 1);
+	m_modelCheckerSettings.bmcLoopIterations = std::optional<unsigned>{bmcLoopIterations};
+}
+
+void SMTCheckerTest::setupCompiler(CompilerStack& _compiler)
+{
+	SyntaxTest::setupCompiler(_compiler);
+
+	_compiler.setModelCheckerSettings(m_modelCheckerSettings);
+}
+
+void SMTCheckerTest::filterObtainedErrors()
+{
+	SyntaxTest::filterObtainedErrors();
+	m_unfilteredErrorList = m_errorList;
+
+	static auto removeCex = [](std::vector<SyntaxTestError>& errors) {
+		for (auto& e: errors)
+			if (
+				auto cexPos = e.message.find("\\nCounterexample");
+				cexPos != std::string::npos
+			)
+				e.message = e.message.substr(0, cexPos);
+	};
+
+	if (m_ignoreCex)
+	{
+		removeCex(m_expectations);
+		removeCex(m_errorList);
+	}
+}
+
+void SMTCheckerTest::printUpdatedExpectations(std::ostream &_stream, const std::string &_linePrefix) const {
+	if (!m_unfilteredErrorList.empty())
+		printErrorList(_stream, m_unfilteredErrorList, _linePrefix, false);
+	else
+		CommonSyntaxTest::printUpdatedExpectations(_stream, _linePrefix);
+}
diff --git a/compiler/test/libsolidity/SMTCheckerTest.h b/compiler/test/libsolidity/SMTCheckerTest.h
new file mode 100644
index 00000000..d42572dc
--- /dev/null
+++ b/compiler/test/libsolidity/SMTCheckerTest.h
@@ -0,0 +1,70 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/SyntaxTest.h>
+
+#include <libsmtutil/SolverInterface.h>
+
+#include <libsolidity/formal/ModelChecker.h>
+
+#include <string>
+
+namespace solidity::frontend::test
+{
+
+class SMTCheckerTest: public SyntaxTest
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<SMTCheckerTest>(_config.filename);
+	}
+	SMTCheckerTest(std::string const& _filename);
+
+	void setupCompiler(CompilerStack& _compiler) override;
+	void filterObtainedErrors() override;
+
+	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const override;
+
+protected:
+	/*
+	Options that can be set in the test:
+	SMTEngine: `all`, `chc`, `bmc`, `none`, where the default is `all`.
+		Set in m_modelCheckerSettings.
+	SMTIgnoreCex: `yes`, `no`, where the default is `no`.
+		Set in m_ignoreCex.
+	SMTIgnoreInv: `yes`, `no`, where the default is `no`.
+		Set in m_modelCheckerSettings.
+	SMTShowUnproved: `yes`, `no`, where the default is `yes`.
+		Set in m_modelCheckerSettings.
+	SMTSolvers: `all`, `cvc4`, `z3`, `none`, where the default is `all`.
+		Set in m_modelCheckerSettings.
+	BMCLoopIterations: number of loop iterations for BMC engine, the default is 1.
+		Set in m_modelCheckerSettings.
+	*/
+
+	ModelCheckerSettings m_modelCheckerSettings;
+
+	bool m_ignoreCex = false;
+
+	std::vector<SyntaxTestError> m_unfilteredErrorList;
+};
+
+}
diff --git a/compiler/test/libsolidity/SemVerMatcher.cpp b/compiler/test/libsolidity/SemVerMatcher.cpp
new file mode 100644
index 00000000..c2fedc2d
--- /dev/null
+++ b/compiler/test/libsolidity/SemVerMatcher.cpp
@@ -0,0 +1,276 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <chris@ethereum.org>
+ * @date 2016
+ * Unit tests for the semantic versioning matcher.
+ */
+
+#include <string>
+#include <vector>
+#include <tuple>
+#include <liblangutil/Scanner.h>
+#include <liblangutil/SemVerHandler.h>
+#include <test/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(SemVerMatcher)
+
+namespace
+{
+
+SemVerMatchExpression parseExpression(std::string const& _input)
+{
+	CharStream stream(_input, "");
+	Scanner scanner{stream};
+	std::vector<std::string> literals;
+	std::vector<Token> tokens;
+	while (scanner.currentToken() != Token::EOS)
+	{
+		auto token = scanner.currentToken();
+		std::string literal = scanner.currentLiteral();
+		if (literal.empty() && TokenTraits::toString(token))
+			literal = TokenTraits::toString(token);
+		literals.push_back(literal);
+		tokens.push_back(token);
+		scanner.next();
+	}
+
+	try
+	{
+		auto matchExpression = SemVerMatchExpressionParser(tokens, literals).parse();
+
+		BOOST_CHECK_MESSAGE(
+			matchExpression.isValid(),
+			"Expression \"" + _input + "\" did not parse properly."
+		);
+
+		return matchExpression;
+	}
+	catch (SemVerError const&)
+	{
+		// Ignored, since a test case should have a parsable version
+		soltestAssert(false);
+	}
+
+	// FIXME: Workaround for spurious GCC 12.1 warning (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105794)
+	util::unreachable();
+}
+
+}
+
+BOOST_AUTO_TEST_CASE(exception_on_invalid_version_in_semverversion_constructor)
+{
+	BOOST_CHECK_EXCEPTION(
+		SemVerVersion version("1.2"),
+		SemVerError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == "Invalid versionString: 1.2"); return true; }
+	);
+
+	BOOST_CHECK_EXCEPTION(
+		SemVerVersion version("-1.2.0"),
+		SemVerError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == "Invalid versionString: -1.2.0"); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(positive_range)
+{
+	// Positive range tests
+	std::vector<std::pair<std::string, std::string>> tests = {
+		{"*", "1.2.3-foo"},
+		{"1.0.0 - 2.0.0", "1.2.3"},
+		{"1.0.0", "1.0.0"},
+		{"1.0", "1.0.0"},
+		{"1", "1.0.0"},
+		{">=*", "0.2.4"},
+		{"*", "1.2.3"},
+		{">=1.0.0", "1.0.0"},
+		{">=1.0.0", "1.0.1"},
+		{">=1.0.0", "1.1.0"},
+		{">1.0.0", "1.0.1"},
+		{">1.0.0", "1.1.0"},
+		{"<=2.0.0", "2.0.0"},
+		{"<=2.0.0", "1.9999.9999"},
+		{"<=2.0.0", "0.2.9"},
+		{"<2.0.0", "1.9999.9999"},
+		{"<2.0.0", "0.2.9"},
+		{"<1.0", "1.0.0-pre"},
+		{"<1", "1.0.0-pre"},
+		{">= 1.0.0", "1.0.0"},
+		{">=  1.0.0", "1.0.1"},
+		{">=   1.0.0", "1.1.0"},
+		{"> 1.0.0", "1.0.1"},
+		{">  1.0.0", "1.1.0"},
+		{"<=   2.0.0", "2.0.0"},
+		{"<= 2.0.0", "1.9999.9999"},
+		{"<=  2.0.0", "0.2.9"},
+		{"<    2.0.0", "1.9999.9999"},
+		{"<\t2.0.0", "0.2.9"},
+		{">=0.1.97", "0.1.97"},
+		{"0.1.20 || 1.2.4", "1.2.4"},
+		{">=0.2.3 || <0.0.1", "0.0.0"},
+		{">=0.2.3 || <0.0.1", "0.2.3"},
+		{">=0.2.3 || <0.0.1", "0.2.4"},
+		{"\"2.x.x\"", "2.1.3"},
+		{"1.2.x", "1.2.3"},
+		{"\"1.2.x\" || \"2.x\"", "2.1.3"},
+		{"\"1.2.x\" || \"2.x\"", "1.2.3"},
+		{"x", "1.2.3"},
+		{"2.*.*", "2.1.3"},
+		{"1.2.*", "1.2.3"},
+		{"1.2.* || 2.*", "2.1.3"},
+		{"1.2.* || 2.*", "1.2.3"},
+		{"*", "1.2.3"},
+		{"2", "2.1.2"},
+		{"2.3", "2.3.1"},
+		{"~2.4", "2.4.0"}, // >=2.4.0 <2.5.0
+		{"~2.4", "2.4.5"},
+		{"~1", "1.2.3"}, // >=1.0.0 <2.0.0
+		{"~1.0", "1.0.2"}, // >=1.0.0 <1.1.0,
+		{"~ 1.0", "1.0.2"},
+		{"~ 1.0.3", "1.0.12"},
+		{">=1", "1.0.0"},
+		{">= 1", "1.0.0"},
+		{"<1.2", "1.1.1"},
+		{"< 1.2", "1.1.1"},
+		{"=0.7.x", "0.7.2"},
+		{"<=0.7.x", "0.7.2"},
+		{">=0.7.x", "0.7.2"},
+		{"<=0.7.x", "0.6.2"},
+		{"~1.2.1 >=1.2.3", "1.2.3"},
+		{"~1.2.1 =1.2.3", "1.2.3"},
+		{"~1.2.1 1.2.3", "1.2.3"},
+		{"~1.2.1 >=1.2.3 1.2.3", "1.2.3"},
+		{"~1.2.1 1.2.3 >=1.2.3", "1.2.3"},
+		{">=\"1.2.1\" 1.2.3", "1.2.3"},
+		{"1.2.3 >=1.2.1", "1.2.3"},
+		{">=1.2.3 >=1.2.1", "1.2.3"},
+		{">=1.2.1 >=1.2.3", "1.2.3"},
+		{">=1.2", "1.2.8"},
+		{"^1.2.3", "1.8.1"},
+		{"^0.1.2", "0.1.2"},
+		{"^0.1", "0.1.2"},
+		{"^1.2", "1.4.2"},
+		{"^1.2", "1.2.0"},
+		{"^1", "1.2.0"},
+		{"<=1.2.3", "1.2.3-beta"},
+		{">1.2", "1.3.0-beta"},
+		{"<1.2.3", "1.2.3-beta"},
+		{"^1.2 ^1", "1.4.2"},
+		{"^0", "0.5.1"},
+		{"^0", "0.1.1"},
+	};
+	for (auto const& t: tests)
+	{
+		SemVerVersion version(t.second);
+		SemVerMatchExpression matchExpression = parseExpression(t.first);
+		BOOST_CHECK_MESSAGE(
+			matchExpression.matches(version),
+			"Version \"" + t.second + "\" did not satisfy expression \"" + t.first + "\""
+		);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(negative_range)
+{
+	// Negative range tests
+	std::vector<std::pair<std::string, std::string>> tests = {
+		{"^0^1", "0.0.0"},
+		{"^0^1", "1.0.0"},
+		{"1.0.0 - 2.0.0", "2.2.3"},
+		{"1.0", "1.0.0-pre"},
+		{"1", "1.0.0-pre"},
+		{"^1.2.3", "1.2.3-pre"},
+		{"^1.2", "1.2.0-pre"},
+		{"^1.2", "1.2.1-pre"},
+		{"^1.2.3", "1.2.3-beta"},
+		{"=0.7.x", "0.7.0-asdf"},
+		{">=0.7.x", "0.7.0-asdf"},
+		{"1.0.0", "1.0.1"},
+		{">=1.0.0", "0.0.0"},
+		{">=1.0.0", "0.0.1"},
+		{">=1.0.0", "0.1.0"},
+		{">1.0.0", "0.0.1"},
+		{">1.0.0", "0.1.0"},
+		{"<=2.0.0", "3.0.0"},
+		{"<=2.0.0", "2.9999.9999"},
+		{"<=2.0.0", "2.2.9"},
+		{"<2.0.0", "2.9999.9999"},
+		{"<2.0.0", "2.2.9"},
+		{">=0.1.97", "0.1.93"},
+		{"0.1.20 || 1.2.4", "1.2.3"},
+		{">=0.2.3 || <0.0.1", "0.0.3"},
+		{">=0.2.3 || <0.0.1", "0.2.2"},
+		{"\"2.x.x\"", "1.1.3"},
+		{"\"2.x.x\"", "3.1.3"},
+		{"1.2.x", "1.3.3"},
+		{"\"1.2.x\" || \"2.x\"", "3.1.3"},
+		{"\"1.2.x\" || \"2.x\"", "1.1.3"},
+		{"2.*.*", "1.1.3"},
+		{"2.*.*", "3.1.3"},
+		{"1.2.*", "1.3.3"},
+		{"1.2.* || 2.*", "3.1.3"},
+		{"1.2.* || 2.*", "1.1.3"},
+		{"2", "1.1.2"},
+		{"2.3", "2.4.1"},
+		{"~2.4", "2.5.0"}, // >=2.4.0 <2.5.0
+		{"~2.4", "2.3.9"},
+		{"~1", "0.2.3"}, // >=1.0.0 <2.0.0
+		{"~1.0", "1.1.0"}, // >=1.0.0 <1.1.0
+		{"<1", "1.0.0"},
+		{">=1.2", "1.1.1"},
+		{"=0.7.x", "0.8.2"},
+		{">=0.7.x", "0.6.2"},
+		{"<0.7.x", "0.7.2"},
+		{"=1.2.3", "1.2.3-beta"},
+		{">1.2", "1.2.8"},
+		{"^1.2.3", "2.0.0-alpha"},
+		{"^0.6", "0.6.2-alpha"},
+		{"^0.6", "0.6.0-alpha"},
+		{"^1.2", "1.2.1-pre"},
+		{"^1.2.3", "1.2.2"},
+		{"^1", "1.2.0-pre"},
+		{"^1", "1.2.0-pre"},
+		{"^1.2", "1.1.9"},
+		{"^0", "0.5.1-pre"},
+		{"^0", "0.0.0-pre"},
+		{"^0", "1.0.0"},
+	};
+	for (auto const& t: tests)
+	{
+		SemVerVersion version(t.second);
+		auto matchExpression = parseExpression(t.first);
+		BOOST_CHECK_MESSAGE(
+			!matchExpression.matches(version),
+			"Version \"" + t.second + "\" did satisfy expression \"" + t.first + "\" " +
+			"(although it should not)"
+		);
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SemanticTest.cpp b/compiler/test/libsolidity/SemanticTest.cpp
new file mode 100644
index 00000000..25113b68
--- /dev/null
+++ b/compiler/test/libsolidity/SemanticTest.cpp
@@ -0,0 +1,695 @@
+/*
+	This file is part of solidity.
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/libsolidity/SemanticTest.h>
+
+#include <libsolutil/Whiskers.h>
+#include <libyul/Exceptions.h>
+#include <test/Common.h>
+#include <test/libsolidity/util/BytesUtils.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <algorithm>
+#include <cctype>
+#include <fstream>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace solidity::util::formatting;
+using namespace solidity::frontend::test;
+using namespace boost::algorithm;
+using namespace boost::unit_test;
+using namespace std::string_literals;
+namespace fs = boost::filesystem;
+
+std::ostream& solidity::frontend::test::operator<<(std::ostream& _output, RequiresYulOptimizer _requiresYulOptimizer)
+{
+	switch (_requiresYulOptimizer)
+	{
+	case RequiresYulOptimizer::False: _output << "false"; break;
+	case RequiresYulOptimizer::MinimalStack: _output << "minimalStack"; break;
+	case RequiresYulOptimizer::Full: _output << "full"; break;
+	}
+	return _output;
+}
+
+SemanticTest::SemanticTest(
+	std::string const& _filename,
+	langutil::EVMVersion _evmVersion,
+	std::optional<uint8_t> _eofVersion,
+	std::vector<boost::filesystem::path> const& _vmPaths,
+	bool _enforceGasCost,
+	u256 _enforceGasCostMinValue
+):
+	SolidityExecutionFramework(_evmVersion, _eofVersion, _vmPaths, false),
+	EVMVersionRestrictedTestCase(_filename),
+	m_sources(m_reader.sources()),
+	m_lineOffset(m_reader.lineNumber()),
+	m_builtins(makeBuiltins()),
+	m_sideEffectHooks(makeSideEffectHooks()),
+	m_enforceGasCost(_enforceGasCost),
+	m_enforceGasCostMinValue(std::move(_enforceGasCostMinValue))
+{
+	static std::set<std::string> const compileViaYulAllowedValues{"also", "true", "false"};
+	static std::set<std::string> const yulRunTriggers{"also", "true"};
+	static std::set<std::string> const legacyRunTriggers{"also", "false", "default"};
+
+	m_requiresYulOptimizer = m_reader.enumSetting<RequiresYulOptimizer>(
+		"requiresYulOptimizer",
+		{
+			{toString(RequiresYulOptimizer::False), RequiresYulOptimizer::False},
+			{toString(RequiresYulOptimizer::MinimalStack), RequiresYulOptimizer::MinimalStack},
+			{toString(RequiresYulOptimizer::Full), RequiresYulOptimizer::Full},
+		},
+		toString(RequiresYulOptimizer::False)
+	);
+
+	m_runWithABIEncoderV1Only = m_reader.boolSetting("ABIEncoderV1Only", false);
+	if (m_runWithABIEncoderV1Only && !solidity::test::CommonOptions::get().useABIEncoderV1)
+		m_shouldRun = false;
+
+	std::string compileViaYul = m_reader.stringSetting("compileViaYul", "also");
+	if (m_runWithABIEncoderV1Only && compileViaYul != "false")
+		BOOST_THROW_EXCEPTION(std::runtime_error(
+			"ABIEncoderV1Only tests cannot be run via yul, "
+			"so they need to also specify ``compileViaYul: false``"
+		));
+	if (!util::contains(compileViaYulAllowedValues, compileViaYul))
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid compileViaYul value: " + compileViaYul + "."));
+	m_testCaseWantsYulRun = util::contains(yulRunTriggers, compileViaYul);
+	m_testCaseWantsLegacyRun = util::contains(legacyRunTriggers, compileViaYul);
+
+	auto revertStrings = revertStringsFromString(m_reader.stringSetting("revertStrings", "default"));
+	soltestAssert(revertStrings, "Invalid revertStrings setting.");
+	m_revertStrings = revertStrings.value();
+
+	m_allowNonExistingFunctions = m_reader.boolSetting("allowNonExistingFunctions", false);
+
+	parseExpectations(m_reader.stream());
+	soltestAssert(!m_tests.empty(), "No tests specified in " + _filename);
+
+	if (m_enforceGasCost)
+	{
+		m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+		m_compiler.setMetadataHash(CompilerStack::MetadataHash::None);
+	}
+}
+
+std::map<std::string, Builtin> SemanticTest::makeBuiltins()
+{
+	return {
+		{
+			"isoltest_builtin_test",
+			[](FunctionCall const&) -> std::optional<bytes>
+			{
+				return toBigEndian(u256(0x1234));
+			}
+		},
+		{
+			"isoltest_side_effects_test",
+			[](FunctionCall const& _call) -> std::optional<bytes>
+			{
+				if (_call.arguments.parameters.empty())
+					return toBigEndian(0);
+				else
+					return _call.arguments.rawBytes();
+			}
+		},
+		{
+			"balance",
+			[this](FunctionCall const& _call) -> std::optional<bytes>
+			{
+				soltestAssert(_call.arguments.parameters.size() <= 1, "Account address expected.");
+				h160 address;
+				if (_call.arguments.parameters.size() == 1)
+					address = h160(_call.arguments.parameters.at(0).rawString);
+				else
+					address = m_contractAddress;
+				return toBigEndian(balanceAt(address));
+			}
+		},
+		{
+			"storageEmpty",
+			[this](FunctionCall const& _call) -> std::optional<bytes>
+			{
+				soltestAssert(_call.arguments.parameters.empty(), "No arguments expected.");
+				return toBigEndian(u256(storageEmpty(m_contractAddress) ? 1 : 0));
+		 	}
+		},
+		{
+			"account",
+			[this](FunctionCall const& _call) -> std::optional<bytes>
+			{
+				soltestAssert(_call.arguments.parameters.size() == 1, "Account number expected.");
+				size_t accountNumber = static_cast<size_t>(stoi(_call.arguments.parameters.at(0).rawString));
+				// Need to pad it to 32-bytes to workaround limitations in BytesUtils::formatHex.
+				return toBigEndian(h256(ExecutionFramework::setAccount(accountNumber).asBytes(), h256::AlignRight));
+			}
+		},
+	};
+}
+
+std::vector<SideEffectHook> SemanticTest::makeSideEffectHooks() const
+{
+	using namespace std::placeholders;
+	return {
+		[](FunctionCall const& _call) -> std::vector<std::string>
+		{
+			if (_call.signature == "isoltest_side_effects_test")
+			{
+				std::vector<std::string> result;
+				for (auto const& argument: _call.arguments.parameters)
+					result.emplace_back(util::toHex(argument.rawBytes));
+				return result;
+			}
+			return {};
+		},
+		bind(&SemanticTest::eventSideEffectHook, this, _1)
+	};
+}
+
+std::string SemanticTest::formatEventParameter(std::optional<AnnotatedEventSignature> _signature, bool _indexed, size_t _index, bytes const& _data)
+{
+	auto isPrintableASCII = [](bytes const& s)
+	{
+		bool zeroes = true;
+		for (auto c: s)
+		{
+			if (static_cast<unsigned>(c) != 0x00)
+			{
+				zeroes = false;
+				if (static_cast<unsigned>(c) <= 0x1f || static_cast<unsigned>(c) >= 0x7f)
+					return false;
+			} else
+				break;
+		}
+		return !zeroes;
+	};
+
+	ABIType abiType(ABIType::Type::Hex);
+	if (isPrintableASCII(_data))
+		abiType = ABIType(ABIType::Type::String);
+	if (_signature.has_value())
+	{
+		std::vector<std::string> const& types = _indexed ? _signature->indexedTypes : _signature->nonIndexedTypes;
+		if (_index < types.size())
+		{
+			if (types.at(_index) == "bool")
+				abiType = ABIType(ABIType::Type::Boolean);
+		}
+	}
+	return BytesUtils::formatBytes(_data, abiType);
+}
+
+std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
+{
+	std::vector<std::string> sideEffects;
+	std::vector<LogRecord> recordedLogs = ExecutionFramework::recordedLogs();
+	for (LogRecord const& log: recordedLogs)
+	{
+		std::optional<AnnotatedEventSignature> eventSignature;
+		if (!log.topics.empty())
+			eventSignature = matchEvent(log.topics[0]);
+		std::stringstream sideEffect;
+		sideEffect << "emit ";
+		if (eventSignature.has_value())
+			sideEffect << eventSignature.value().signature;
+		else
+			sideEffect << "<anonymous>";
+
+		if (m_contractAddress != log.creator)
+			sideEffect << " from 0x" << log.creator;
+
+		std::vector<std::string> eventStrings;
+		size_t index{0};
+		for (h256 const& topic: log.topics)
+		{
+			if (!eventSignature.has_value() || index != 0)
+				eventStrings.push_back("#" + formatEventParameter(eventSignature, true, index, topic.asBytes()));
+			++index;
+		}
+
+		soltestAssert(log.data.size() % 32 == 0, "");
+		for (size_t index = 0; index < log.data.size() / 32; ++index)
+		{
+			auto begin = log.data.begin() + static_cast<long>(index * 32);
+			bytes const& data = bytes{begin, begin + 32};
+			eventStrings.emplace_back(formatEventParameter(eventSignature, false, index, data));
+		}
+
+		if (!eventStrings.empty())
+			sideEffect << ": ";
+		sideEffect << joinHumanReadable(eventStrings);
+		sideEffects.emplace_back(sideEffect.str());
+	}
+	return sideEffects;
+}
+
+std::optional<AnnotatedEventSignature> SemanticTest::matchEvent(util::h256 const& hash) const
+{
+	std::optional<AnnotatedEventSignature> result;
+	for (std::string& contractName: m_compiler.contractNames())
+	{
+		ContractDefinition const& contract = m_compiler.contractDefinition(contractName);
+		for (EventDefinition const* event: contract.events() + contract.usedInterfaceEvents())
+		{
+			FunctionTypePointer eventFunctionType = event->functionType(true);
+			if (!event->isAnonymous() && keccak256(eventFunctionType->externalSignature()) == hash)
+			{
+				AnnotatedEventSignature eventInfo;
+				eventInfo.signature = eventFunctionType->externalSignature();
+				for (auto const& param: event->parameters())
+					if (param->isIndexed())
+						eventInfo.indexedTypes.emplace_back(param->type()->toString(true));
+					else
+						eventInfo.nonIndexedTypes.emplace_back(param->type()->toString(true));
+				result = eventInfo;
+			}
+		}
+	}
+	return result;
+}
+
+frontend::OptimiserSettings SemanticTest::optimizerSettingsFor(RequiresYulOptimizer _requiresYulOptimizer)
+{
+	switch (_requiresYulOptimizer)
+	{
+	case RequiresYulOptimizer::False:
+		return OptimiserSettings::minimal();
+	case RequiresYulOptimizer::MinimalStack:
+	{
+		OptimiserSettings settings = OptimiserSettings::minimal();
+		settings.runYulOptimiser = true;
+		settings.yulOptimiserSteps = "uljmul jmul";
+		return settings;
+	}
+	case RequiresYulOptimizer::Full:
+		return OptimiserSettings::full();
+	}
+	unreachable();
+}
+
+TestCase::TestResult SemanticTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	TestResult result = TestResult::Success;
+
+	if (m_testCaseWantsLegacyRun && !m_eofVersion.has_value())
+		result = runTest(_stream, _linePrefix, _formatted, false /* _isYulRun */);
+
+	if (m_testCaseWantsYulRun && result == TestResult::Success)
+	{
+		if (solidity::test::CommonOptions::get().optimize)
+			result = runTest(_stream, _linePrefix, _formatted, true /* _isYulRun */);
+		else
+			result = tryRunTestWithYulOptimizer(_stream, _linePrefix, _formatted);
+	}
+
+	if (result != TestResult::Success)
+		solidity::test::CommonOptions::get().printSelectedOptions(
+			_stream,
+			_linePrefix,
+			{"evmVersion", "optimize", "useABIEncoderV1", "batch"}
+		);
+
+	return result;
+}
+
+TestCase::TestResult SemanticTest::runTest(
+	std::ostream& _stream,
+	std::string const& _linePrefix,
+	bool _formatted,
+	bool _isYulRun
+)
+{
+	bool success = true;
+	m_gasCostFailure = false;
+
+	selectVM(evmc_capabilities::EVMC_CAPABILITY_EVM1);
+
+	reset();
+
+	m_compileViaYul = _isYulRun;
+
+	if (_isYulRun)
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Running via Yul: " << std::endl;
+
+	for (TestFunctionCall& test: m_tests)
+		test.reset();
+
+	std::map<std::string, solidity::test::Address> libraries;
+
+	bool constructed = false;
+
+	for (TestFunctionCall& test: m_tests)
+	{
+		if (constructed)
+		{
+			soltestAssert(
+				test.call().kind != FunctionCall::Kind::Library,
+				"Libraries have to be deployed before any other call."
+			);
+			soltestAssert(
+				test.call().kind != FunctionCall::Kind::Constructor,
+				"Constructor has to be the first function call expect for library deployments."
+			);
+		}
+		else if (test.call().kind == FunctionCall::Kind::Library)
+		{
+			soltestAssert(
+				deploy(test.call().signature, 0, {}, libraries) && m_transactionSuccessful,
+				"Failed to deploy library " + test.call().signature);
+			// For convenience, in semantic tests we assume that an unqualified name like `L` is equivalent to one
+			// with an empty source unit name (`:L`). This is fine because the compiler never uses unqualified
+			// names in the Yul code it produces and does not allow `linkersymbol()` at all in inline assembly.
+			libraries[test.call().libraryFile + ":" + test.call().signature] = m_contractAddress;
+			continue;
+		}
+		else
+		{
+			if (test.call().kind == FunctionCall::Kind::Constructor)
+				deploy("", test.call().value.value, test.call().arguments.rawBytes(), libraries);
+			else
+				soltestAssert(deploy("", 0, bytes(), libraries), "Failed to deploy contract.");
+			constructed = true;
+		}
+
+		if (test.call().kind == FunctionCall::Kind::Constructor)
+		{
+			if (m_transactionSuccessful == test.call().expectations.failure)
+				success = false;
+			if (success && !checkGasCostExpectation(test, _isYulRun))
+			{
+				success = false;
+				m_gasCostFailure = true;
+			}
+
+			test.setFailure(!m_transactionSuccessful);
+			test.setRawBytes(bytes());
+		}
+		else
+		{
+			bytes output;
+			if (test.call().kind == FunctionCall::Kind::LowLevel)
+				output = callLowLevel(test.call().arguments.rawBytes(), test.call().value.value);
+			else if (test.call().kind == FunctionCall::Kind::Builtin)
+			{
+				std::optional<bytes> builtinOutput = m_builtins.at(test.call().signature)(test.call());
+				if (builtinOutput.has_value())
+				{
+					m_transactionSuccessful = true;
+					output = builtinOutput.value();
+				}
+				else
+					m_transactionSuccessful = false;
+			}
+			else
+			{
+				soltestAssert(
+					m_allowNonExistingFunctions ||
+					m_compiler.interfaceSymbols(m_compiler.lastContractName(m_sources.mainSourceFile))["methods"].isMember(test.call().signature),
+					"The function " + test.call().signature + " is not known to the compiler"
+				);
+
+				output = callContractFunctionWithValueNoEncoding(
+					test.call().signature,
+					test.call().value.value,
+					test.call().arguments.rawBytes()
+				);
+			}
+
+			bool outputMismatch = (output != test.call().expectations.rawBytes());
+			if (!outputMismatch && !checkGasCostExpectation(test, _isYulRun))
+			{
+				success = false;
+				m_gasCostFailure = true;
+			}
+
+			// Pre byzantium, it was not possible to return failure data, so we disregard
+			// output mismatch for those EVM versions.
+			if (test.call().expectations.failure && !m_transactionSuccessful && !m_evmVersion.supportsReturndata())
+				outputMismatch = false;
+			if (m_transactionSuccessful != !test.call().expectations.failure || outputMismatch)
+				success = false;
+
+			test.setFailure(!m_transactionSuccessful);
+			test.setRawBytes(std::move(output));
+			if (test.call().kind != FunctionCall::Kind::LowLevel)
+				test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName(m_sources.mainSourceFile)));
+		}
+
+		std::vector<std::string> effects;
+		for (SideEffectHook const& hook: m_sideEffectHooks)
+			effects += hook(test.call());
+		test.setSideEffects(std::move(effects));
+
+		success &= test.call().expectedSideEffects == test.call().actualSideEffects;
+	}
+
+	if (!success)
+	{
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << std::endl;
+		for (TestFunctionCall const& test: m_tests)
+		{
+			ErrorReporter errorReporter;
+			_stream << test.format(
+				errorReporter,
+				_linePrefix,
+				TestFunctionCall::RenderMode::ExpectedValuesExpectedGas,
+				_formatted,
+				/* _interactivePrint */ true
+			) << std::endl;
+			_stream << errorReporter.format(_linePrefix, _formatted);
+		}
+		_stream << std::endl;
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Obtained result:" << std::endl;
+		for (TestFunctionCall const& test: m_tests)
+		{
+			ErrorReporter errorReporter;
+			_stream << test.format(
+				errorReporter,
+				_linePrefix,
+				m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
+				_formatted,
+				/* _interactivePrint */ true
+			) << std::endl;
+			_stream << errorReporter.format(_linePrefix, _formatted);
+		}
+		AnsiColorized(_stream, _formatted, {BOLD, RED})
+			<< _linePrefix << std::endl
+			<< _linePrefix << "Attention: Updates on the test will apply the detected format displayed." << std::endl;
+		if (_isYulRun && m_testCaseWantsLegacyRun)
+		{
+			_stream << _linePrefix << std::endl << _linePrefix;
+			AnsiColorized(_stream, _formatted, {RED_BACKGROUND}) << "Note that the test passed without Yul.";
+			_stream << std::endl;
+		}
+		else if (!_isYulRun && m_testCaseWantsYulRun)
+			AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
+				<< _linePrefix << std::endl
+				<< _linePrefix << "Note that the test also has to pass via Yul." << std::endl;
+		return TestResult::Failure;
+	}
+
+	return TestResult::Success;
+}
+
+TestCase::TestResult SemanticTest::tryRunTestWithYulOptimizer(
+	std::ostream& _stream,
+	std::string const& _linePrefix,
+	bool _formatted
+)
+{
+	TestResult result{};
+	for (auto requiresYulOptimizer: {
+		RequiresYulOptimizer::False,
+		RequiresYulOptimizer::MinimalStack,
+		RequiresYulOptimizer::Full,
+	})
+	{
+		ScopedSaveAndRestore optimizerSettings(
+			m_optimiserSettings,
+			optimizerSettingsFor(requiresYulOptimizer)
+		);
+
+		try
+		{
+			result = runTest(_stream, _linePrefix, _formatted, true /* _isYulRun */);
+		}
+		catch (yul::StackTooDeepError const&)
+		{
+			if (requiresYulOptimizer == RequiresYulOptimizer::Full)
+				throw;
+			else
+				continue;
+		}
+
+		if (m_requiresYulOptimizer != requiresYulOptimizer && result != TestResult::FatalError)
+		{
+			soltestAssert(result == TestResult::Success || result == TestResult::Failure);
+
+			AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
+				<< _linePrefix << std::endl
+				<< _linePrefix << "requiresYulOptimizer is set to " << m_requiresYulOptimizer
+				<< " but should be " << requiresYulOptimizer << std::endl;
+			m_requiresYulOptimizer = requiresYulOptimizer;
+			return TestResult::Failure;
+		}
+
+		return result;
+	}
+	unreachable();
+}
+
+bool SemanticTest::checkGasCostExpectation(TestFunctionCall& io_test, bool _compileViaYul) const
+{
+	std::string setting =
+		(_compileViaYul ? "ir"s : "legacy"s) +
+		(m_optimiserSettings == OptimiserSettings::full() ? "Optimized" : "");
+
+	// We don't check gas if enforce gas cost is not active
+	// or test is run with abi encoder v1 only
+	// or gas used less than threshold for enforcing feature
+	// or the test has used up all available gas (test will fail anyway)
+	// or setting is "ir" and it's not included in expectations
+	// or if the called function is an isoltest builtin e.g. `smokeTest` or `storageEmpty`
+	if (
+		!m_enforceGasCost ||
+		m_gasUsed < m_enforceGasCostMinValue ||
+		m_gasUsed >= InitialGas ||
+		(setting == "ir" && io_test.call().expectations.gasUsed.count(setting) == 0) ||
+		io_test.call().kind == FunctionCall::Kind::Builtin
+	)
+		return true;
+
+	solAssert(!m_runWithABIEncoderV1Only, "");
+
+	io_test.setGasCost(setting, m_gasUsed);
+	return
+		io_test.call().expectations.gasUsed.count(setting) > 0 &&
+		m_gasUsed == io_test.call().expectations.gasUsed.at(setting);
+}
+
+void SemanticTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const
+{
+	if (m_sources.sources.empty())
+		return;
+
+	bool outputNames = (m_sources.sources.size() - m_sources.externalSources.size() != 1 || !m_sources.sources.begin()->first.empty());
+
+	std::set<std::string> externals;
+	for (auto const& [name, path]: m_sources.externalSources)
+	{
+		externals.insert(name);
+		std::string externalSource;
+		if (name == path)
+			externalSource = name;
+		else
+			externalSource = name + "=" + path.generic_string();
+
+		if (_formatted)
+			_stream << _linePrefix  << formatting::CYAN << "==== ExternalSource: " << externalSource << " ===="s << formatting::RESET << std::endl;
+		else
+			_stream << _linePrefix << "==== ExternalSource: " << externalSource << " ===="s << std::endl;
+	}
+
+	for (auto const& [name, source]: m_sources.sources)
+		if (externals.find(name) == externals.end())
+		{
+			if (_formatted)
+			{
+				if (source.empty())
+					continue;
+
+				if (outputNames)
+					_stream << _linePrefix << formatting::CYAN << "==== Source: " << name
+							<< " ====" << formatting::RESET << std::endl;
+
+				std::vector<char const*> sourceFormatting(source.length(), formatting::RESET);
+				_stream << _linePrefix << sourceFormatting.front() << source.front();
+				for (size_t i = 1; i < source.length(); i++)
+				{
+					if (sourceFormatting[i] != sourceFormatting[i - 1])
+						_stream << sourceFormatting[i];
+					if (source[i] != '\n')
+						_stream << source[i];
+					else
+					{
+						_stream << formatting::RESET << std::endl;
+						if (i + 1 < source.length())
+							_stream << _linePrefix << sourceFormatting[i];
+					}
+				}
+				_stream << formatting::RESET;
+			}
+			else
+			{
+				if (outputNames)
+					printPrefixed(_stream, "==== Source: " + name + " ====", _linePrefix);
+				printPrefixed(_stream, source, _linePrefix);
+			}
+		}
+}
+
+void SemanticTest::printUpdatedExpectations(std::ostream& _stream, std::string const&) const
+{
+	for (TestFunctionCall const& test: m_tests)
+		_stream << test.format(
+			"",
+			m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
+			/* _highlight = */ false
+		) << std::endl;
+}
+
+void SemanticTest::printUpdatedSettings(std::ostream& _stream, std::string const& _linePrefix)
+{
+	auto& settings = m_reader.settings();
+	if (settings.empty() && m_requiresYulOptimizer == RequiresYulOptimizer::False)
+		return;
+
+	_stream << _linePrefix << "// ====" << std::endl;
+	if (m_requiresYulOptimizer != RequiresYulOptimizer::False)
+		_stream << _linePrefix << "// requiresYulOptimizer: " << m_requiresYulOptimizer << std::endl;
+
+	for (auto const& [settingName, settingValue]: settings)
+		if (settingName != "requiresYulOptimizer")
+			_stream << _linePrefix << "// " << settingName << ": " << settingValue<< std::endl;
+}
+
+void SemanticTest::parseExpectations(std::istream& _stream)
+{
+	m_tests += TestFileParser{_stream, m_builtins}.parseFunctionCalls(m_lineOffset);
+}
+
+bool SemanticTest::deploy(
+	std::string const& _contractName,
+	u256 const& _value,
+	bytes const& _arguments,
+	std::map<std::string, solidity::test::Address> const& _libraries
+)
+{
+	auto output = compileAndRunWithoutCheck(m_sources.sources, _value, _contractName, _arguments, _libraries, m_sources.mainSourceFile);
+	return !output.empty() && m_transactionSuccessful;
+}
diff --git a/compiler/test/libsolidity/SemanticTest.h b/compiler/test/libsolidity/SemanticTest.h
new file mode 100644
index 00000000..efc2b590
--- /dev/null
+++ b/compiler/test/libsolidity/SemanticTest.h
@@ -0,0 +1,130 @@
+/*
+	This file is part of solidity.
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <test/libsolidity/util/TestFileParser.h>
+#include <test/libsolidity/util/TestFunctionCall.h>
+#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <liblangutil/Exceptions.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend::test
+{
+
+struct AnnotatedEventSignature
+{
+	std::string signature;
+	std::vector<std::string> indexedTypes;
+	std::vector<std::string> nonIndexedTypes;
+};
+
+enum class RequiresYulOptimizer
+{
+	False,
+	MinimalStack,
+	Full,
+};
+
+std::ostream& operator<<(std::ostream& _output, RequiresYulOptimizer _requiresYulOptimizer);
+
+/**
+ * Class that represents a semantic test (or end-to-end test) and allows running it as part of the
+ * boost unit test environment or isoltest. It reads the Solidity source and an additional comment
+ * section from the given file. This comment section should define a set of functions to be called
+ * and an expected result they return after being executed.
+ */
+class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrictedTestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _options)
+	{
+		return std::make_unique<SemanticTest>(
+			_options.filename,
+			_options.evmVersion,
+			_options.eofVersion,
+			_options.vmPaths,
+			_options.enforceGasCost,
+			_options.enforceGasCostMinValue
+		);
+	}
+
+	explicit SemanticTest(
+		std::string const& _filename,
+		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
+		std::vector<boost::filesystem::path> const& _vmPaths,
+		bool _enforceGasCost = false,
+		u256 _enforceGasCostMinValue = 100000
+	);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool _formatted = false) override;
+	void printSource(std::ostream &_stream, std::string const& _linePrefix = "", bool _formatted = false) const override;
+	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix = "") const override;
+	void printUpdatedSettings(std::ostream& _stream, std::string const& _linePrefix = "") override;
+
+	/// Instantiates a test file parser that parses the additional comment section at the end of
+	/// the input stream \param _stream. Each function call is represented using a `FunctionCallTest`
+	/// and added to the list of call to be executed when `run()` is called.
+	/// Throws if parsing expectations failed.
+	void parseExpectations(std::istream& _stream);
+
+	/// Compiles and deploys currently held source.
+	/// Returns true if deployment was successful, false otherwise.
+	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, solidity::test::Address> const& _libraries = {});
+
+private:
+	TestResult runTest(
+		std::ostream& _stream,
+		std::string const& _linePrefix,
+		bool _formatted,
+		bool _isYulRun
+	);
+	TestResult tryRunTestWithYulOptimizer(
+		std::ostream& _stream,
+		std::string const& _linePrefix,
+		bool _formatted
+	);
+	bool checkGasCostExpectation(TestFunctionCall& io_test, bool _compileViaYul) const;
+	std::map<std::string, Builtin> makeBuiltins();
+	std::vector<SideEffectHook> makeSideEffectHooks() const;
+	std::vector<std::string> eventSideEffectHook(FunctionCall const&) const;
+	std::optional<AnnotatedEventSignature> matchEvent(util::h256 const& hash) const;
+	static std::string formatEventParameter(std::optional<AnnotatedEventSignature> _signature, bool _indexed, size_t _index, bytes const& _data);
+
+	OptimiserSettings optimizerSettingsFor(RequiresYulOptimizer _requiresYulOptimizer);
+
+	SourceMap m_sources;
+	std::size_t m_lineOffset;
+	std::vector<TestFunctionCall> m_tests;
+	std::map<std::string, Builtin> const m_builtins;
+	std::vector<SideEffectHook> const m_sideEffectHooks;
+	bool m_testCaseWantsYulRun = true;
+	bool m_testCaseWantsLegacyRun = true;
+	bool m_runWithABIEncoderV1Only = false;
+	bool m_allowNonExistingFunctions = false;
+	bool m_gasCostFailure = false;
+	bool m_enforceGasCost = false;
+	RequiresYulOptimizer m_requiresYulOptimizer{};
+	u256 m_enforceGasCostMinValue;
+};
+
+}
diff --git a/compiler/test/libsolidity/SolidityCompiler.cpp b/compiler/test/libsolidity/SolidityCompiler.cpp
new file mode 100644
index 00000000..7cb95a99
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityCompiler.cpp
@@ -0,0 +1,73 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * Unit tests for the compiler itself.
+ */
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/Metadata.h>
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::frontend::test
+{
+
+class SolidityCompilerFixture: protected AnalysisFramework
+{
+	void setupCompiler(CompilerStack& _compiler) override
+	{
+		AnalysisFramework::setupCompiler(_compiler);
+
+		// FIXME: This test was probably supposed to respect CommonOptions::get().optimize but
+		// due to a bug it was always running with optimizer disabled and it does not pass with it.
+		_compiler.setOptimiserSettings(false);
+	}
+};
+
+BOOST_FIXTURE_TEST_SUITE(SolidityCompiler, SolidityCompilerFixture)
+
+BOOST_AUTO_TEST_CASE(does_not_include_creation_time_only_internal_functions)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint x;
+			constructor() { f(); }
+			function f() internal { unchecked { for (uint i = 0; i < 10; ++i) x += 3 + i; } }
+		}
+	)";
+
+	runFramework(sourceCode, PipelineStage::Compilation);
+	BOOST_REQUIRE_MESSAGE(
+		pipelineSuccessful(),
+		"Contract compilation failed:\n" + formatErrors(filteredErrors(), true /* _colored */)
+	);
+
+	bytes const& creationBytecode = solidity::test::bytecodeSansMetadata(compiler().object("C").bytecode);
+	bytes const& runtimeBytecode = solidity::test::bytecodeSansMetadata(compiler().runtimeObject("C").bytecode);
+	BOOST_CHECK(creationBytecode.size() >= 90);
+	BOOST_CHECK(creationBytecode.size() <= 120);
+	auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
+	unsigned threshold = evmVersion.hasPush0() ? 9 : 10;
+	BOOST_CHECK(runtimeBytecode.size() >= threshold);
+	BOOST_CHECK(runtimeBytecode.size() <= 30);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/SolidityEndToEndTest.cpp b/compiler/test/libsolidity/SolidityEndToEndTest.cpp
new file mode 100644
index 00000000..e34df030
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityEndToEndTest.cpp
@@ -0,0 +1,3842 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @author Gav Wood <g@ethdev.com>
+ * @date 2014
+ * Unit tests for the solidity expression compiler, testing the behaviour of the code.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+#include <test/Common.h>
+#include <test/EVMHost.h>
+
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/EVMVersion.h>
+
+#include <libevmasm/Assembly.h>
+
+#include <libsolutil/Keccak256.h>
+#include <libsolutil/ErrorCodes.h>
+
+#include <libyul/Exceptions.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <range/v3/view/transform.hpp>
+
+#include <functional>
+#include <numeric>
+#include <string>
+#include <tuple>
+
+using namespace std::placeholders;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::test;
+using namespace solidity::langutil;
+
+#define ALSO_VIA_YUL(CODE)                                      \
+{                                                               \
+	m_compileViaYul = false;                                    \
+	RUN_AND_RERUN_WITH_OPTIMIZER_ON_STACK_ERROR(CODE)           \
+                                                                \
+	m_compileViaYul = true;                                     \
+	reset();                                                    \
+	RUN_AND_RERUN_WITH_OPTIMIZER_ON_STACK_ERROR(CODE)           \
+}
+
+#define RUN_AND_RERUN_WITH_OPTIMIZER_ON_STACK_ERROR(CODE)       \
+{                                                               \
+	try                                                         \
+	{ CODE }                                                    \
+	catch (yul::StackTooDeepError const&)                       \
+	{                                                           \
+		if (m_optimiserSettings == OptimiserSettings::full())   \
+			throw;                                              \
+                                                                \
+		reset();                                                \
+		m_optimiserSettings = OptimiserSettings::full();        \
+		{ CODE }                                                \
+	}                                                           \
+}
+
+
+namespace solidity::frontend::test
+{
+
+struct SolidityEndToEndTestExecutionFramework: public SolidityExecutionFramework
+{
+};
+
+BOOST_FIXTURE_TEST_SUITE(SolidityEndToEndTest, SolidityEndToEndTestExecutionFramework)
+
+BOOST_AUTO_TEST_CASE(creation_code_optimizer)
+{
+	std::string codeC = R"(
+		contract C {
+			constructor(uint x) {
+			if (x == 0xFFFFFFFFFFFFFFFF42)
+				revert();
+			}
+		}
+	)";
+	std::string codeD = R"(
+		contract D {
+			function f() public pure returns (bytes memory) {
+				return type(C).creationCode;
+			}
+		}
+	)";
+
+	m_metadataHash = CompilerStack::MetadataHash::None;
+	ALSO_VIA_YUL({
+		bytes bytecodeC = compileContract(codeC);
+		reset();
+		compileAndRun(codeC + codeD);
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0x20, bytecodeC.size()) + encode(bytecodeC, false));
+	})
+}
+
+unsigned constexpr roundTo32(unsigned _num)
+{
+	return (_num + 31) / 32 * 32;
+}
+
+BOOST_AUTO_TEST_CASE(exp_operator)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) public returns(uint d) { return 2 ** a; }
+		}
+	)";
+	compileAndRun(sourceCode);
+	testContractAgainstCppOnRange("f(uint256)", [](u256 const& a) -> u256 { return u256(1 << a.convert_to<int>()); }, 0, 16);
+}
+
+BOOST_AUTO_TEST_CASE(exp_zero)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) public returns(uint d) { return a ** 0; }
+		}
+	)";
+	compileAndRun(sourceCode);
+	testContractAgainstCppOnRange("f(uint256)", [](u256 const&) -> u256 { return u256(1); }, 0, 16);
+}
+
+/* TODO let's add this back when I figure out the correct type conversion.
+BOOST_AUTO_TEST_CASE(conditional_expression_string_literal)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(bool cond) public returns (bytes32) {
+				return cond ? "true" : "false";
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	ABI_CHECK(callContractFunction("f(bool)", true), encodeArgs(string("true", 4)));
+	ABI_CHECK(callContractFunction("f(bool)", false), encodeArgs(string("false", 5)));
+}
+*/
+
+BOOST_AUTO_TEST_CASE(recursive_calls)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns(uint nfac) {
+				if (n <= 1) return 1;
+				else return n * f(n - 1);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		std::function<u256(u256)> recursive_calls_cpp = [&recursive_calls_cpp](u256 const& n) -> u256
+		{
+			if (n <= 1)
+				return 1;
+			else
+				return n * recursive_calls_cpp(n - 1);
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", recursive_calls_cpp, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(while_loop)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns(uint nfac) {
+				nfac = 1;
+				uint i = 2;
+				while (i <= n) nfac *= i++;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto while_loop_cpp = [](u256 const& n) -> u256
+		{
+			u256 nfac = 1;
+			u256 i = 2;
+			while (i <= n)
+				nfac *= i++;
+
+			return nfac;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", while_loop_cpp, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(do_while_loop)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns(uint nfac) {
+				nfac = 1;
+				uint i = 2;
+				do { nfac *= i++; } while (i <= n);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto do_while_loop_cpp = [](u256 const& n) -> u256
+		{
+			u256 nfac = 1;
+			u256 i = 2;
+			do
+			{
+				nfac *= i++;
+			}
+			while (i <= n);
+
+			return nfac;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", do_while_loop_cpp, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(do_while_loop_multiple_local_vars)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public pure returns(uint r) {
+				uint i = 0;
+				do
+				{
+					uint z = x * 2;
+					if (z < 4) break;
+					else {
+						uint k = z + 1;
+						if (k < 8) {
+							x++;
+							continue;
+						}
+					}
+					if (z > 12) return 0;
+					x++;
+					i++;
+				} while (true);
+				return 42;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto do_while = [](u256 n) -> u256
+		{
+			u256 i = 0;
+			do
+			{
+				u256 z = n * 2;
+				if (z < 4) break;
+				else {
+					u256 k = z + 1;
+					if (k < 8) {
+						n++;
+						continue;
+					}
+				}
+				if (z > 12) return 0;
+				n++;
+				i++;
+			} while (true);
+			return 42;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", do_while, 0, 12);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(nested_loops)
+{
+	// tests that break and continue statements in nested loops jump to the correct place
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public returns(uint y) {
+				while (x > 1) {
+					if (x == 10) break;
+					while (x > 5) {
+						if (x == 8) break;
+						x--;
+						if (x == 6) continue;
+						return x;
+					}
+					x--;
+					if (x == 3) continue;
+					break;
+				}
+				return x;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto nested_loops_cpp = [](u256 n) -> u256
+		{
+			while (n > 1)
+			{
+				if (n == 10)
+					break;
+				while (n > 5)
+				{
+					if (n == 8)
+						break;
+					n--;
+					if (n == 6)
+						continue;
+					return n;
+				}
+				n--;
+				if (n == 3)
+					continue;
+				break;
+			}
+
+			return n;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", nested_loops_cpp, 0, 12);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(nested_loops_multiple_local_vars)
+{
+	// tests that break and continue statements in nested loops jump to the correct place
+	// and free local variables properly
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public returns(uint y) {
+				while (x > 0) {
+					uint z = x + 10;
+					uint k = z + 1;
+					if (k > 20) {
+						break;
+						uint p = 100;
+						k += p;
+					}
+					if (k > 15) {
+						x--;
+						continue;
+						uint t = 1000;
+						x += t;
+					}
+					while (k > 10) {
+						uint m = k - 1;
+						if (m == 10) return x;
+						return k;
+						uint h = 10000;
+						z += h;
+					}
+					x--;
+					break;
+				}
+				return x;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto nested_loops_cpp = [](u256 n) -> u256
+		{
+			while (n > 0)
+			{
+				u256 z = n + 10;
+				u256 k = z + 1;
+				if (k > 20) break;
+				if (k > 15) {
+					n--;
+					continue;
+				}
+				while (k > 10)
+				{
+					u256 m = k - 1;
+					if (m == 10) return n;
+					return k;
+				}
+				n--;
+				break;
+			}
+
+			return n;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", nested_loops_cpp, 0, 12);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_multiple_local_vars)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public pure returns(uint r) {
+				for (uint i = 0; i < 12; i++)
+				{
+					uint z = x + 1;
+					if (z < 4) break;
+					else {
+						uint k = z * 2;
+						if (i + k < 10) {
+							x++;
+							continue;
+						}
+					}
+					if (z > 8) return 0;
+					x++;
+				}
+				return 42;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto for_loop = [](u256 n) -> u256
+		{
+			for (u256 i = 0; i < 12; i++)
+			{
+				u256 z = n + 1;
+				if (z < 4) break;
+				else {
+					u256 k = z * 2;
+					if (i + k < 10) {
+						n++;
+						continue;
+					}
+				}
+				if (z > 8) return 0;
+				n++;
+			}
+			return 42;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", for_loop, 0, 12);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(nested_for_loop_multiple_local_vars)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public pure returns(uint r) {
+				for (uint i = 0; i < 5; i++)
+				{
+					uint z = x + 1;
+					if (z < 3) {
+						break;
+						uint p = z + 2;
+					}
+					for (uint j = 0; j < 5; j++)
+					{
+						uint k = z * 2;
+						if (j + k < 8) {
+							x++;
+							continue;
+							uint t = z * 3;
+						}
+						x++;
+						if (x > 20) {
+							return 84;
+							uint h = x + 42;
+						}
+					}
+					if (x > 30) {
+						return 42;
+						uint b = 0xcafe;
+					}
+				}
+				return 42;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto for_loop = [](u256 n) -> u256
+		{
+			for (u256 i = 0; i < 5; i++)
+			{
+				u256 z = n + 1;
+				if (z < 3) break;
+				for (u256 j = 0; j < 5; j++)
+				{
+					u256 k = z * 2;
+					if (j + k < 8) {
+						n++;
+						continue;
+					}
+					n++;
+					if (n > 20) return 84;
+				}
+				if (n > 30) return 42;
+			}
+			return 42;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", for_loop, 0, 12);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(for_loop)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns(uint nfac) {
+				nfac = 1;
+				uint i;
+				for (i = 2; i <= n; i++)
+					nfac *= i;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto for_loop_cpp = [](u256 const& n) -> u256
+		{
+			u256 nfac = 1;
+			for (auto i = 2; i <= n; i++)
+				nfac *= i;
+			return nfac;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", for_loop_cpp, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_simple_init_expr)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns(uint nfac) {
+				nfac = 1;
+				uint256 i;
+				for (i = 2; i <= n; i++)
+					nfac *= i;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto for_loop_simple_init_expr_cpp = [](u256 const& n) -> u256
+		{
+			u256 nfac = 1;
+			u256 i;
+			for (i = 2; i <= n; i++)
+				nfac *= i;
+			return nfac;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", for_loop_simple_init_expr_cpp, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_break_continue)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint n) public returns (uint r)
+			{
+				uint i = 1;
+				uint k = 0;
+				for (i *= 5; k < n; i *= 7)
+				{
+					k++;
+					i += 4;
+					if (n % 3 == 0)
+						break;
+					i += 9;
+					if (n % 2 == 0)
+						continue;
+					i += 19;
+				}
+				return i;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto breakContinue = [](u256 const& n) -> u256
+		{
+			u256 i = 1;
+			u256 k = 0;
+			for (i *= 5; k < n; i *= 7)
+			{
+				k++;
+				i += 4;
+				if (n % 3 == 0)
+					break;
+				i += 9;
+				if (n % 2 == 0)
+					continue;
+				i += 19;
+			}
+			return i;
+		};
+
+		testContractAgainstCppOnRange("f(uint256)", breakContinue, 0, 10);
+	);
+}
+
+BOOST_AUTO_TEST_CASE(short_circuiting)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function run(uint x) public returns(uint y) {
+				x == 0 || ((x = 8) > 0);
+				return x;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		auto short_circuiting_cpp = [](u256 n) -> u256
+		{
+			(void)(n == 0 || (n = 8) > 0);
+			return n;
+		};
+
+		testContractAgainstCppOnRange("run(uint256)", short_circuiting_cpp, 0, 2);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(high_bits_cleaning)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function run() public returns(uint256 y) {
+				unchecked {
+					uint32 t = uint32(0xffffffff);
+					uint32 x = t + 10;
+					if (x >= 0xffffffff) return 0;
+					return x;
+				}
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	auto high_bits_cleaning_cpp = []() -> u256
+	{
+		uint32_t t = uint32_t(0xffffffff);
+		uint32_t x = t + 10;
+		if (x >= 0xffffffff)
+			return 0;
+		return x;
+	};
+	testContractAgainstCpp("run()", high_bits_cleaning_cpp);
+}
+
+BOOST_AUTO_TEST_CASE(sign_extension)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function run() public returns(uint256 y) {
+				unchecked {
+					int64 x = -int32(int64(0xff));
+					if (x >= 0xff) return 0;
+					return 0 - uint256(int256(x));
+				}
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	auto sign_extension_cpp = []() -> u256
+	{
+		int64_t x = -int32_t(0xff);
+		if (x >= 0xff)
+			return 0;
+		return u256(x) * -1;
+	};
+	testContractAgainstCpp("run()", sign_extension_cpp);
+}
+
+BOOST_AUTO_TEST_CASE(small_unsigned_types)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function run() public returns(uint256 y) {
+				unchecked {
+					uint32 t = uint32(0xffffff);
+					uint32 x = t * 0xffffff;
+					return x / 0x100;
+				}
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	auto small_unsigned_types_cpp = []() -> u256
+	{
+		uint32_t t = uint32_t(0xffffff);
+		uint32_t x = t * 0xffffff;
+		return x / 0x100;
+	};
+	testContractAgainstCpp("run()", small_unsigned_types_cpp);
+}
+
+BOOST_AUTO_TEST_CASE(mapping_state_inc_dec)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint value;
+			mapping(uint => uint) table;
+			function f(uint x) public returns (uint y) {
+				value = x;
+				if (x > 0) table[++value] = 8;
+				if (x > 1) value--;
+				if (x > 2) table[value]++;
+				table[value] += 10;
+				return --table[value++];
+			}
+		}
+	)";
+
+	u256 value;
+	std::map<u256, u256> table;
+	auto f = [&](u256 const& _x) -> u256
+	{
+		value = _x;
+		if (_x > 0)
+			table[++value] = 8;
+		if (_x > 1)
+			value --;
+		if (_x > 2)
+			table[value]++;
+		table[value] += 10;
+		return --table[value++];
+	};
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		value = 0;
+		table.clear();
+
+		testContractAgainstCppOnRange("f(uint256)", f, 0, 5);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(multi_level_mapping)
+{
+	char const* sourceCode = R"(
+		contract test {
+			mapping(uint => mapping(uint => uint)) table;
+			function f(uint x, uint y, uint z) public returns (uint w) {
+				if (z == 0) return table[x][y];
+				else return table[x][y] = z;
+			}
+		}
+	)";
+	std::map<u256, std::map<u256, u256>> table;
+	auto f = [&](u256 const& _x, u256 const& _y, u256 const& _z) -> u256
+	{
+		if (_z == 0) return table[_x][_y];
+		else return table[_x][_y] = _z;
+	};
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		table.clear();
+
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(9));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(7));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(4), u256(5), u256(0));
+		testContractAgainstCpp("f(uint256,uint256,uint256)", f, u256(5), u256(4), u256(0));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(constructor)
+{
+	char const* sourceCode = R"(
+		contract test {
+			mapping(uint => uint) data;
+			constructor() {
+				data[7] = 8;
+			}
+			function get(uint key) public returns (uint value) {
+				return data[key];
+			}
+		}
+	)";
+
+	std::map<u256, uint8_t> data;
+	data[7] = 8;
+	auto get = [&](u256 const& _x) -> u256
+	{
+		return data[_x];
+	};
+
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		testContractAgainstCpp("get(uint256)", get, u256(6));
+		testContractAgainstCpp("get(uint256)", get, u256(7));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(send_ether)
+{
+	char const* sourceCode = R"(
+		contract test {
+			constructor() payable {}
+			function a(address payable addr, uint amount) public returns (uint ret) {
+				addr.send(amount);
+				return address(this).balance;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		u256 amount(250);
+		compileAndRun(sourceCode, amount + 1);
+		h160 address(23);
+		ABI_CHECK(callContractFunction("a(address,uint256)", address, amount), encodeArgs(1));
+		BOOST_CHECK_EQUAL(balanceAt(address), amount);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(transfer_ether)
+{
+	char const* sourceCode = R"(
+		contract A {
+			constructor() payable {}
+			function a(address payable addr, uint amount) public returns (uint) {
+				addr.transfer(amount);
+				return address(this).balance;
+			}
+			function b(address payable addr, uint amount) public {
+				addr.transfer(amount);
+			}
+		}
+
+		contract B {
+		}
+
+		contract C {
+			receive () external payable {
+				revert();
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "B");
+		h160 const nonPayableRecipient = m_contractAddress;
+		compileAndRun(sourceCode, 0, "C");
+		h160 const oogRecipient = m_contractAddress;
+		compileAndRun(sourceCode, 20, "A");
+		h160 payableRecipient(23);
+		ABI_CHECK(callContractFunction("a(address,uint256)", payableRecipient, 10), encodeArgs(10));
+		BOOST_CHECK_EQUAL(balanceAt(payableRecipient), 10);
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
+		ABI_CHECK(callContractFunction("b(address,uint256)", nonPayableRecipient, 10), encodeArgs());
+		ABI_CHECK(callContractFunction("b(address,uint256)", oogRecipient, 10), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function multiply(uint a, uint b) public returns (uint c) {
+				return a * b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) public returns (uint c) {
+				return h.multiply(a, b);
+			}
+			function getHelper() public returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) public {
+				h = Helper(haddress);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_with_complex_parameters)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function sel(uint a, bool select, uint b) public returns (uint c) {
+				if (select) return a; else return b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, bool select, uint b) public returns (uint c) {
+				return h.sel(a, select, b) * 3;
+			}
+			function getHelper() public returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) public {
+				h = Helper(haddress);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction("callHelper(uint256,bool,uint256)", a, true, b) == encodeArgs(a * 3));
+	BOOST_REQUIRE(callContractFunction("callHelper(uint256,bool,uint256)", a, false, b) == encodeArgs(b * 3));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_accessing_this)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function getAddress() public returns (address addr) {
+				return address(this);
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper() public returns (address addr) {
+				return h.getAddress();
+			}
+			function getHelper() public returns (address addr) {
+				return address(h);
+			}
+			function setHelper(address addr) public {
+				h = Helper(addr);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	BOOST_REQUIRE(callContractFunction("callHelper()") == encodeArgs(c_helperAddress));
+}
+
+BOOST_AUTO_TEST_CASE(calls_to_this)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function invoke(uint a, uint b) public returns (uint c) {
+				return this.multiply(a, b, 10);
+			}
+			function multiply(uint a, uint b, uint8 c) public returns (uint ret) {
+				return a * b + c;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) public returns (uint ret) {
+				return h.invoke(a, b);
+			}
+			function getHelper() public returns (address addr) {
+				return address(h);
+			}
+			function setHelper(address addr) public {
+				h = Helper(addr);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 10));
+}
+
+BOOST_AUTO_TEST_CASE(inter_contract_calls_with_local_vars)
+{
+	// note that a reference to another contract's function occupies two stack slots,
+	// so this tests correct stack slot allocation
+	char const* sourceCode = R"(
+		contract Helper {
+			function multiply(uint a, uint b) public returns (uint c) {
+				return a * b;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(uint a, uint b) public returns (uint c) {
+				uint8 y = 9;
+				uint256 ret = h.multiply(a, b);
+				return ret + y;
+			}
+			function getHelper() public returns (address haddress) {
+				return address(h);
+			}
+			function setHelper(address haddress) public {
+				h = Helper(haddress);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	u256 a(3456789);
+	u256 b("0x282837623374623234aa74");
+	BOOST_REQUIRE(callContractFunction("callHelper(uint256,uint256)", a, b) == encodeArgs(a * b + 9));
+}
+
+BOOST_AUTO_TEST_CASE(fixed_bytes_in_calls)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			function invoke(bytes3 x, bool stop) public returns (bytes4 ret) {
+				return x;
+			}
+		}
+		contract Main {
+			Helper h;
+			function callHelper(bytes2 x, bool stop) public returns (bytes5 ret) {
+				return h.invoke(x, stop);
+			}
+			function getHelper() public returns (address addr) {
+				return address(h);
+			}
+			function setHelper(address addr) public {
+				h = Helper(addr);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 0, "Main");
+	BOOST_REQUIRE(callContractFunction("setHelper(address)", c_helperAddress) == bytes());
+	BOOST_REQUIRE(callContractFunction("getHelper()", c_helperAddress) == encodeArgs(c_helperAddress));
+	ABI_CHECK(callContractFunction("callHelper(bytes2,bool)", std::string("\0a", 2), true), encodeArgs(std::string("\0a\0\0\0", 5)));
+}
+
+BOOST_AUTO_TEST_CASE(constructor_with_long_arguments)
+{
+	char const* sourceCode = R"(
+		contract Main {
+			string public a;
+			string public b;
+
+			constructor(string memory _a, string memory _b) {
+				a = _a;
+				b = _b;
+			}
+		}
+	)";
+	std::string a = "01234567890123gabddunaouhdaoneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012oneudapcgadi4567890789012oneudapcgadi45678907890123456789abcd123456787890123456789abcd90123456789012345678901234567890123456789aboneudapcgadi4567890789012cdef";
+	std::string b = "AUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PYAUTAHIACIANOTUHAOCUHAOEUNAOEHUNTHDYDHPYDRCPYDRSTITOEUBXHUDGO>PY";
+
+	compileAndRun(sourceCode, 0, "Main", encodeArgs(
+		u256(0x40),
+		u256(0x40 + 0x20 + ((a.length() + 31) / 32) * 32),
+		u256(a.length()),
+		a,
+		u256(b.length()),
+		b
+	));
+	ABI_CHECK(callContractFunction("a()"), encodeDyn(a));
+	ABI_CHECK(callContractFunction("b()"), encodeDyn(b));
+}
+
+BOOST_AUTO_TEST_CASE(contracts_as_addresses)
+{
+	char const* sourceCode = R"(
+		contract helper {
+			receive() external payable { } // can receive ether
+		}
+		contract test {
+			helper h;
+			constructor() payable { h = new helper(); payable(h).send(5); }
+			function getBalance() public returns (uint256 myBalance, uint256 helperBalance) {
+				myBalance = address(this).balance;
+				helperBalance = address(h).balance;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 20);
+	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 20 - 5);
+	BOOST_REQUIRE(callContractFunction("getBalance()") == encodeArgs(u256(20 - 5), u256(5)));
+}
+
+BOOST_AUTO_TEST_CASE(blockhash)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint256 counter;
+			function g() public returns (bool) { counter++; return true; }
+			function f() public returns (bytes32[] memory r) {
+				r = new bytes32[](259);
+				for (uint i = 0; i < 259; i++) {
+					unchecked {
+						r[i] = blockhash(block.number - 257 + i);
+					}
+				}
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	// generate a sufficient amount of blocks
+	while (blockNumber() < u256(255))
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(true));
+
+	std::vector<u256> hashes;
+	// ``blockhash()`` is only valid for the last 256 blocks, otherwise zero
+	hashes.emplace_back(0);
+	for (u256 i = blockNumber() - u256(255); i <= blockNumber(); i++)
+		hashes.emplace_back(blockHash(i));
+	// the current block hash is not yet known at execution time and therefore zero
+	hashes.emplace_back(0);
+	// future block hashes are zero
+	hashes.emplace_back(0);
+
+	ABI_CHECK(callContractFunction("f()"), encodeDyn(hashes));
+}
+
+BOOST_AUTO_TEST_CASE(internal_constructor)
+{
+	char const* sourceCode = R"(
+		abstract contract C {
+			constructor() {}
+		}
+	)";
+	// via yul disabled because it will throw an error instead of
+	// returning empty bytecode.
+	BOOST_CHECK(compileAndRunWithoutCheck({{"", sourceCode}}, 0, "C").empty());
+}
+
+BOOST_AUTO_TEST_CASE(default_fallback_throws)
+{
+	char const* sourceCode = R"YY(
+		contract A {
+			function f() public returns (bool) {
+				(bool success,) = address(this).call("");
+				return success;
+			}
+		}
+	)YY";
+	compileAndRun(sourceCode);
+	ABI_CHECK(callContractFunction("f()"), encodeArgs(0));
+
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+	{
+		char const* sourceCode = R"YY(
+			contract A {
+				function f() public returns (bool) {
+					(bool success, bytes memory data) = address(this).staticcall("");
+					assert(data.length == 0);
+					return success;
+				}
+			}
+		)YY";
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(empty_name_input_parameter_with_named_one)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint, uint k) public returns(uint ret_k, uint ret_g){
+				uint g = 8;
+				ret_k = k;
+				ret_g = g;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		BOOST_CHECK(callContractFunction("f(uint256,uint256)", 5, 9) != encodeArgs(5, 8));
+		ABI_CHECK(callContractFunction("f(uint256,uint256)", 5, 9), encodeArgs(9, 8));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(generic_call)
+{
+	char const* sourceCode = R"**(
+			contract receiver {
+				uint public received;
+				function recv(uint256 x) public payable { received = x; }
+			}
+			contract sender {
+				constructor() payable {}
+				function doSend(address rec) public returns (uint d)
+				{
+					bytes4 signature = bytes4(bytes32(keccak256("recv(uint256)")));
+					rec.call{value: 2}(abi.encodeWithSelector(signature, 23));
+					return receiver(rec).received();
+				}
+			}
+	)**";
+	compileAndRun(sourceCode, 0, "receiver");
+	h160 const c_receiverAddress = m_contractAddress;
+	compileAndRun(sourceCode, 50, "sender");
+	BOOST_REQUIRE(callContractFunction("doSend(address)", c_receiverAddress) == encodeArgs(23));
+	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 50 - 2);
+}
+
+BOOST_AUTO_TEST_CASE(generic_delegatecall)
+{
+	char const* sourceCode = R"**(
+			contract Receiver {
+				uint public received;
+				address public sender;
+				uint public value;
+				constructor() payable {}
+				function recv(uint256 x) public payable { received = x; sender = msg.sender; value = msg.value; }
+			}
+			contract Sender {
+				uint public received;
+				address public sender;
+				uint public value;
+				constructor() payable {}
+				function doSend(address rec) public payable
+				{
+					bytes4 signature = bytes4(bytes32(keccak256("recv(uint256)")));
+					(bool success,) = rec.delegatecall(abi.encodeWithSelector(signature, 23));
+					success;
+				}
+			}
+	)**";
+
+	for (auto v2: {false, true})
+	{
+		std::string source = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n" + std::string(sourceCode);
+
+		compileAndRun(source, 0, "Receiver");
+		h160 const c_receiverAddress = m_contractAddress;
+		compileAndRun(source, 50, "Sender");
+		h160 const c_senderAddress = m_contractAddress;
+		BOOST_CHECK(m_sender != c_senderAddress); // just for sanity
+		ABI_CHECK(callContractFunctionWithValue("doSend(address)", 11, c_receiverAddress), encodeArgs());
+		ABI_CHECK(callContractFunction("received()"), encodeArgs(u256(23)));
+		ABI_CHECK(callContractFunction("sender()"), encodeArgs(m_sender));
+		ABI_CHECK(callContractFunction("value()"), encodeArgs(u256(11)));
+		m_contractAddress = c_receiverAddress;
+		ABI_CHECK(callContractFunction("received()"), encodeArgs(u256(0)));
+		ABI_CHECK(callContractFunction("sender()"), encodeArgs(u256(0)));
+		ABI_CHECK(callContractFunction("value()"), encodeArgs(u256(0)));
+		BOOST_CHECK(storageEmpty(c_receiverAddress));
+		BOOST_CHECK(!storageEmpty(c_senderAddress));
+		BOOST_CHECK_EQUAL(balanceAt(c_receiverAddress), 0);
+		BOOST_CHECK_EQUAL(balanceAt(c_senderAddress), 50 + 11);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(generic_staticcall)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+	{
+		char const* sourceCode = R"**(
+				contract A {
+					uint public x;
+					constructor() { x = 42; }
+					function pureFunction(uint256 p) public pure returns (uint256) { return p; }
+					function viewFunction(uint256 p) public view returns (uint256) { return p + x; }
+					function nonpayableFunction(uint256 p) public returns (uint256) { x = p; return x; }
+					function assertFunction(uint256 p) public view returns (uint256) { assert(x == p); return x; }
+				}
+				contract C {
+					function f(address a) public view returns (bool, bytes memory)
+					{
+						return a.staticcall(abi.encodeWithSignature("pureFunction(uint256)", 23));
+					}
+					function g(address a) public view returns (bool, bytes memory)
+					{
+						return a.staticcall(abi.encodeWithSignature("viewFunction(uint256)", 23));
+					}
+					function h(address a) public view returns (bool, bytes memory)
+					{
+						return a.staticcall(abi.encodeWithSignature("nonpayableFunction(uint256)", 23));
+					}
+					function i(address a, uint256 v) public view returns (bool, bytes memory)
+					{
+						return a.staticcall(abi.encodeWithSignature("assertFunction(uint256)", v));
+					}
+				}
+		)**";
+		compileAndRun(sourceCode, 0, "A");
+		h160 const c_addressA = m_contractAddress;
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("f(address)", c_addressA), encodeArgs(true, 0x40, 0x20, 23));
+		ABI_CHECK(callContractFunction("g(address)", c_addressA), encodeArgs(true, 0x40, 0x20, 23 + 42));
+		ABI_CHECK(callContractFunction("h(address)", c_addressA), encodeArgs(false, 0x40, 0x00));
+		ABI_CHECK(callContractFunction("i(address,uint256)", c_addressA, 42), encodeArgs(true, 0x40, 0x20, 42));
+		ABI_CHECK(callContractFunction("i(address,uint256)", c_addressA, 23), encodeArgs(false, 0x40, 0x24) + panicData(PanicCode::Assert) + bytes(32 - 4, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(library_call_protection)
+{
+	// This tests code that reverts a call if it is a direct call to a library
+	// as opposed to a delegatecall.
+	char const* sourceCode = R"(
+		library Lib {
+			struct S { uint x; }
+			// a direct call to this should revert
+			function np(S storage s) public returns (address) { s.x = 3; return msg.sender; }
+			// a direct call to this is fine
+			function v(S storage) public view returns (address) { return msg.sender; }
+			// a direct call to this is fine
+			function pu() public pure returns (uint) { return 2; }
+		}
+		contract Test {
+			Lib.S public s;
+			function np() public returns (address) { return Lib.np(s); }
+			function v() public view returns (address) { return Lib.v(s); }
+			function pu() public pure returns (uint) { return Lib.pu(); }
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "Lib");
+		ABI_CHECK(callContractFunction("np(Lib.S storage)", 0), encodeArgs());
+		ABI_CHECK(callContractFunction("v(Lib.S storage)", 0), encodeArgs(m_sender));
+		ABI_CHECK(callContractFunction("pu()"), encodeArgs(2));
+		compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
+		ABI_CHECK(callContractFunction("s()"), encodeArgs(0));
+		ABI_CHECK(callContractFunction("np()"), encodeArgs(m_sender));
+		ABI_CHECK(callContractFunction("s()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("v()"), encodeArgs(m_sender));
+		ABI_CHECK(callContractFunction("pu()"), encodeArgs(2));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bytes_from_calldata_to_memory)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f() public returns (bytes32) {
+				return keccak256(abi.encodePacked("abc", msg.data));
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		bytes calldata1 = util::selectorFromSignatureH32("f()").asBytes() + bytes(61, 0x22) + bytes(12, 0x12);
+		sendMessage(calldata1, false);
+		BOOST_CHECK(m_transactionSuccessful);
+		BOOST_CHECK(m_output == encodeArgs(util::keccak256(bytes{'a', 'b', 'c'} + calldata1)));
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_forward_bytes_length)
+{
+	char const* sourceCode = R"(
+		contract receiver {
+			uint public calledLength;
+			fallback() external { calledLength = msg.data.length; }
+		}
+		contract sender {
+			receiver rec;
+			constructor() { rec = new receiver(); }
+			function viaCalldata() public returns (uint) {
+				(bool success,) = address(rec).call(msg.data);
+				require(success);
+				return rec.calledLength();
+			}
+			function viaMemory() public returns (uint) {
+				bytes memory x = msg.data;
+				(bool success,) = address(rec).call(x);
+				require(success);
+				return rec.calledLength();
+			}
+			bytes s;
+			function viaStorage() public returns (uint) {
+				s = msg.data;
+				(bool success,) = address(rec).call(s);
+				require(success);
+				return rec.calledLength();
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "sender");
+
+		// No additional data, just function selector
+		ABI_CHECK(callContractFunction("viaCalldata()"), encodeArgs(4));
+		ABI_CHECK(callContractFunction("viaMemory()"), encodeArgs(4));
+		ABI_CHECK(callContractFunction("viaStorage()"), encodeArgs(4));
+
+		// Some additional unpadded data
+		bytes unpadded = asBytes(std::string("abc"));
+		ABI_CHECK(callContractFunctionNoEncoding("viaCalldata()", unpadded), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("viaMemory()", unpadded), encodeArgs(7));
+		ABI_CHECK(callContractFunctionNoEncoding("viaStorage()", unpadded), encodeArgs(7));
+	);
+}
+
+BOOST_AUTO_TEST_CASE(copying_bytes_multiassign)
+{
+	char const* sourceCode = R"(
+		contract receiver {
+			uint public received;
+			function recv(uint x) public { received += x + 1; }
+			fallback() external { received = 0x80; }
+		}
+		contract sender {
+			constructor() { rec = new receiver(); }
+			fallback() external { savedData1 = savedData2 = msg.data; }
+			function forward(bool selector) public returns (bool) {
+				if (selector) { address(rec).call(savedData1); delete savedData1; }
+				else { address(rec).call(savedData2); delete savedData2; }
+				return true;
+			}
+			function val() public returns (uint) { return rec.received(); }
+			receiver rec;
+			bytes savedData1;
+			bytes savedData2;
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "sender");
+		ABI_CHECK(callContractFunction("recv(uint256)", 7), bytes());
+		ABI_CHECK(callContractFunction("val()"), encodeArgs(0));
+		ABI_CHECK(callContractFunction("forward(bool)", true), encodeArgs(true));
+		ABI_CHECK(callContractFunction("val()"), encodeArgs(8));
+		ABI_CHECK(callContractFunction("forward(bool)", false), encodeArgs(true));
+		ABI_CHECK(callContractFunction("val()"), encodeArgs(16));
+		ABI_CHECK(callContractFunction("forward(bool)", true), encodeArgs(true));
+		ABI_CHECK(callContractFunction("val()"), encodeArgs(0x80));
+	);
+}
+
+BOOST_AUTO_TEST_CASE(copy_from_calldata_removes_bytes_data)
+{
+	char const* sourceCode = R"(
+		contract c {
+			function set() public returns (bool) { data = msg.data; return true; }
+			fallback() external { data = msg.data; }
+			bytes data;
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("set()", 1, 2, 3, 4, 5), encodeArgs(true));
+		BOOST_CHECK(!storageEmpty(m_contractAddress));
+		sendMessage(bytes(), false);
+		BOOST_CHECK(m_transactionSuccessful);
+		BOOST_CHECK(m_output.empty());
+		BOOST_CHECK(storageEmpty(m_contractAddress));
+	);
+}
+
+BOOST_AUTO_TEST_CASE(struct_referencing)
+{
+	static char const* sourceCode = R"(
+		pragma abicoder v2;
+		interface I {
+			struct S { uint a; }
+		}
+		library L {
+			struct S { uint b; uint a; }
+			function f() public pure returns (S memory) {
+				S memory s;
+				s.a = 3;
+				return s;
+			}
+			function g() public pure returns (I.S memory) {
+				I.S memory s;
+				s.a = 4;
+				return s;
+			}
+			// argument-dependent lookup tests
+			function a(I.S memory) public pure returns (uint) { return 1; }
+			function a(S memory) public pure returns (uint) { return 2; }
+		}
+		contract C is I {
+			function f() public pure returns (S memory) {
+				S memory s;
+				s.a = 1;
+				return s;
+			}
+			function g() public pure returns (I.S memory) {
+				I.S memory s;
+				s.a = 2;
+				return s;
+			}
+			function h() public pure returns (L.S memory) {
+				L.S memory s;
+				s.a = 5;
+				return s;
+			}
+			function x() public pure returns (L.S memory) {
+				return L.f();
+			}
+			function y() public pure returns (I.S memory) {
+				return L.g();
+			}
+			function a1() public pure returns (uint) { S memory s; return L.a(s); }
+			function a2() public pure returns (uint) { L.S memory s; return L.a(s); }
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "L");
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 3));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(4));
+		compileAndRun(sourceCode, 0, "C", bytes(), std::map<std::string, h160>{ {":L", m_contractAddress}});
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(2));
+		ABI_CHECK(callContractFunction("h()"), encodeArgs(0, 5));
+		ABI_CHECK(callContractFunction("x()"), encodeArgs(0, 3));
+		ABI_CHECK(callContractFunction("y()"), encodeArgs(4));
+		ABI_CHECK(callContractFunction("a1()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("a2()"), encodeArgs(2));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(enum_referencing)
+{
+	char const* sourceCode = R"(
+		interface I {
+			enum Direction { A, B, Left, Right }
+		}
+		library L {
+			enum Direction { Left, Right }
+			function f() public pure returns (Direction) {
+				return Direction.Right;
+			}
+			function g() public pure returns (I.Direction) {
+				return I.Direction.Right;
+			}
+		}
+		contract C is I {
+			function f() public pure returns (Direction) {
+				return Direction.Right;
+			}
+			function g() public pure returns (I.Direction) {
+				return I.Direction.Right;
+			}
+			function h() public pure returns (L.Direction) {
+				return L.Direction.Right;
+			}
+			function x() public pure returns (L.Direction) {
+				return L.f();
+			}
+			function y() public pure returns (I.Direction) {
+				return L.g();
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "L");
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
+		compileAndRun(sourceCode, 0, "C", bytes(), std::map<std::string, h160>{{":L", m_contractAddress}});
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(3));
+		ABI_CHECK(callContractFunction("h()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("x()"), encodeArgs(1));
+		ABI_CHECK(callContractFunction("y()"), encodeArgs(3));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(bytes_in_arguments)
+{
+	char const* sourceCode = R"(
+		contract c {
+			uint result;
+			function f(uint a, uint b) public { result += a + b; }
+			function g(uint a) public { result *= a; }
+			function test(uint a, bytes calldata data1, bytes calldata data2, uint b) external returns (uint r_a, uint r, uint r_b, uint l) {
+				r_a = a;
+				address(this).call(data1);
+				address(this).call(data2);
+				r = result;
+				r_b = b;
+				l = data1.length;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+
+		std::string innercalldata1 = asString(util::selectorFromSignatureH32("f(uint256,uint256)").asBytes() + encodeArgs(8, 9));
+		std::string innercalldata2 = asString(util::selectorFromSignatureH32("g(uint256)").asBytes() + encodeArgs(3));
+		bytes calldata = encodeArgs(
+			12, 32 * 4, u256(32 * 4 + 32 + (innercalldata1.length() + 31) / 32 * 32), 13,
+			u256(innercalldata1.length()), innercalldata1,
+			u256(innercalldata2.length()), innercalldata2);
+		ABI_CHECK(
+			callContractFunction("test(uint256,bytes,bytes,uint256)", calldata),
+			encodeArgs(12, (8 + 9) * 3, 13, u256(innercalldata1.length()))
+		);
+	);
+}
+
+BOOST_AUTO_TEST_CASE(array_copy_storage_abi)
+{
+	// NOTE: This does not really test copying from storage to ABI directly,
+	// because it will always copy to memory first.
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract c {
+			uint8[] x;
+			uint16[] y;
+			uint24[] z;
+			uint24[][] w;
+			function test1() public returns (uint8[] memory) {
+				for (uint i = 0; i < 101; ++i)
+					x.push(uint8(i));
+				return x;
+			}
+			function test2() public returns (uint16[] memory) {
+				for (uint i = 0; i < 101; ++i)
+					y.push(uint16(i));
+				return y;
+			}
+			function test3() public returns (uint24[] memory) {
+				for (uint i = 0; i < 101; ++i)
+					z.push(uint24(i));
+				return z;
+			}
+			function test4() public returns (uint24[][] memory) {
+				w = new uint24[][](5);
+				for (uint i = 0; i < 5; ++i)
+					for (uint j = 0; j < 101; ++j)
+						w[i].push(uint24(j));
+				return w;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode);
+		bytes valueSequence;
+		for (size_t i = 0; i < 101; ++i)
+			valueSequence += toBigEndian(u256(i));
+		ABI_CHECK(callContractFunction("test1()"), encodeArgs(0x20, 101) + valueSequence);
+		ABI_CHECK(callContractFunction("test2()"), encodeArgs(0x20, 101) + valueSequence);
+		ABI_CHECK(callContractFunction("test3()"), encodeArgs(0x20, 101) + valueSequence);
+		ABI_CHECK(callContractFunction("test4()"),
+			encodeArgs(0x20, 5, 0xa0, 0xa0 + 102 * 32 * 1, 0xa0 + 102 * 32 * 2, 0xa0 + 102 * 32 * 3, 0xa0 + 102 * 32 * 4) +
+			encodeArgs(101) + valueSequence +
+			encodeArgs(101) + valueSequence +
+			encodeArgs(101) + valueSequence +
+			encodeArgs(101) + valueSequence +
+			encodeArgs(101) + valueSequence
+		);
+	);
+}
+
+//BOOST_AUTO_TEST_CASE(assignment_to_const_array_vars)
+//{
+//	char const* sourceCode = R"(
+//		contract C {
+//			uint[3] constant x = [uint(1), 2, 3];
+//			uint constant y = x[0] + x[1] + x[2];
+//			function f() public returns (uint) { return y; }
+//		}
+//	)";
+//	compileAndRun(sourceCode);
+//	ABI_CHECK(callContractFunction("f()"), encodeArgs(1 + 2 + 3));
+//}
+
+// Disabled until https://github.com/ethereum/solidity/issues/715 is implemented
+//BOOST_AUTO_TEST_CASE(constant_struct)
+//{
+//	char const* sourceCode = R"(
+//		contract C {
+//			struct S { uint x; uint[] y; }
+//			S constant x = S(5, new uint[](4));
+//			function f() public returns (uint) { return x.x; }
+//		}
+//	)";
+//	compileAndRun(sourceCode);
+//	ABI_CHECK(callContractFunction("f()"), encodeArgs(5));
+//}
+
+BOOST_AUTO_TEST_CASE(evm_exceptions_in_constructor_out_of_baund)
+{
+	char const* sourceCode = R"(
+		contract A {
+			uint public test = 1;
+			uint[3] arr;
+			constructor()
+			{
+				uint index = 5;
+				test = arr[index];
+				++test;
+			}
+		}
+	)";
+	ABI_CHECK(compileAndRunWithoutCheck({{"", sourceCode}}, 0, "A"), panicData(PanicCode::ArrayOutOfBounds));
+	BOOST_CHECK(!m_transactionSuccessful);
+}
+
+BOOST_AUTO_TEST_CASE(failing_send)
+{
+	char const* sourceCode = R"(
+		contract Helper {
+			uint[] data;
+			fallback () external {
+				data[9]; // trigger exception
+			}
+		}
+		contract Main {
+			constructor() payable {}
+			function callHelper(address payable _a) public returns (bool r, uint bal) {
+				r = !_a.send(5);
+				bal = address(this).balance;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Helper");
+	h160 const c_helperAddress = m_contractAddress;
+	compileAndRun(sourceCode, 20, "Main");
+	BOOST_REQUIRE(callContractFunction("callHelper(address)", c_helperAddress) == encodeArgs(true, 20));
+}
+
+BOOST_AUTO_TEST_CASE(return_multiple_strings_of_various_sizes)
+{
+	char const* sourceCode = R"(
+		contract Main {
+			string public s1;
+			string public s2;
+			function set(string calldata _s1, uint x, string calldata _s2) external returns (uint) {
+				s1 = _s1;
+				s2 = _s2;
+				return x;
+			}
+			function get() public returns (string memory r1, string memory r2) {
+				r1 = s1;
+				r2 = s2;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Main");
+	std::string s1(
+		"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
+		"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
+		"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
+		"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
+	);
+	std::string s2(
+		"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
+		"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
+		"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
+		"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
+		"ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ"
+	);
+	std::vector<size_t> lengths{0, 30, 32, 63, 64, 65, 210, 300};
+	for (auto l1: lengths)
+		for (auto l2: lengths)
+		{
+			bytes dyn1 = encodeArgs(u256(l1), s1.substr(0, l1));
+			bytes dyn2 = encodeArgs(u256(l2), s2.substr(0, l2));
+			bytes args = encodeArgs(u256(0x60), u256(l1), u256(0x60 + dyn1.size())) + dyn1 + dyn2;
+			BOOST_REQUIRE(
+				callContractFunction("set(string,uint256,string)", asString(args)) ==
+				encodeArgs(u256(l1))
+			);
+			bytes result = encodeArgs(u256(0x40), u256(0x40 + dyn1.size())) + dyn1 + dyn2;
+			ABI_CHECK(callContractFunction("get()"), result);
+			ABI_CHECK(callContractFunction("s1()"), encodeArgs(0x20) + dyn1);
+			ABI_CHECK(callContractFunction("s2()"), encodeArgs(0x20) + dyn2);
+		}
+}
+
+BOOST_AUTO_TEST_CASE(accessor_involving_strings)
+{
+	char const* sourceCode = R"(
+		contract Main {
+			struct stringData { string a; uint b; string c; }
+			mapping(uint => stringData[]) public data;
+			function set(uint x, uint y, string calldata a, uint b, string calldata c) external returns (bool) {
+				while (data[x].length < y + 1)
+					data[x].push();
+				data[x][y].a = a;
+				data[x][y].b = b;
+				data[x][y].c = c;
+				return true;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Main");
+	std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+	std::string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
+	bytes s1Data = encodeArgs(u256(s1.length()), s1);
+	bytes s2Data = encodeArgs(u256(s2.length()), s2);
+	u256 b = 765;
+	u256 x = 7;
+	u256 y = 123;
+	bytes args = encodeArgs(x, y, u256(0xa0), b, u256(0xa0 + s1Data.size()), s1Data, s2Data);
+	bytes result = encodeArgs(u256(0x60), b, u256(0x60 + s1Data.size()), s1Data, s2Data);
+	BOOST_REQUIRE(callContractFunction("set(uint256,uint256,string,uint256,string)", asString(args)) == encodeArgs(true));
+	BOOST_REQUIRE(callContractFunction("data(uint256,uint256)", x, y) == result);
+}
+
+BOOST_AUTO_TEST_CASE(bytes_in_function_calls)
+{
+	char const* sourceCode = R"(
+		contract Main {
+			string public s1;
+			string public s2;
+			function set(string memory _s1, uint x, string memory _s2) public returns (uint) {
+				s1 = _s1;
+				s2 = _s2;
+				return x;
+			}
+			function setIndirectFromMemory(string memory _s1, uint x, string memory _s2) public returns (uint) {
+				return this.set(_s1, x, _s2);
+			}
+			function setIndirectFromCalldata(string calldata _s1, uint x, string calldata _s2) external returns (uint) {
+				return this.set(_s1, x, _s2);
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Main");
+	std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+	std::string s2("ABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZABCDEFGHIJKLMNOPQRSTUVXYZ");
+	std::vector<size_t> lengths{0, 31, 64, 65};
+	for (auto l1: lengths)
+		for (auto l2: lengths)
+		{
+			bytes dyn1 = encodeArgs(u256(l1), s1.substr(0, l1));
+			bytes dyn2 = encodeArgs(u256(l2), s2.substr(0, l2));
+			bytes args1 = encodeArgs(u256(0x60), u256(l1), u256(0x60 + dyn1.size())) + dyn1 + dyn2;
+			BOOST_REQUIRE(
+				callContractFunction("setIndirectFromMemory(string,uint256,string)", asString(args1)) ==
+				encodeArgs(u256(l1))
+			);
+			ABI_CHECK(callContractFunction("s1()"), encodeArgs(0x20) + dyn1);
+			ABI_CHECK(callContractFunction("s2()"), encodeArgs(0x20) + dyn2);
+			// swapped
+			bytes args2 = encodeArgs(u256(0x60), u256(l1), u256(0x60 + dyn2.size())) + dyn2 + dyn1;
+			BOOST_REQUIRE(
+				callContractFunction("setIndirectFromCalldata(string,uint256,string)", asString(args2)) ==
+				encodeArgs(u256(l1))
+			);
+			ABI_CHECK(callContractFunction("s1()"), encodeArgs(0x20) + dyn2);
+			ABI_CHECK(callContractFunction("s2()"), encodeArgs(0x20) + dyn1);
+		}
+}
+
+BOOST_AUTO_TEST_CASE(return_bytes_internal)
+{
+	char const* sourceCode = R"(
+		contract Main {
+			bytes s1;
+			function doSet(bytes memory _s1) public returns (bytes memory _r1) {
+				s1 = _s1;
+				_r1 = s1;
+			}
+			function set(bytes calldata _s1) external returns (uint _r, bytes memory _r1) {
+				_r1 = doSet(_s1);
+				_r = _r1.length;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Main");
+	std::string s1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
+	std::vector<size_t> lengths{0, 31, 64, 65};
+	for (auto l1: lengths)
+	{
+		bytes dyn1 = encodeArgs(u256(l1), s1.substr(0, l1));
+		bytes args1 = encodeArgs(u256(0x20)) + dyn1;
+		BOOST_REQUIRE(
+			callContractFunction("set(bytes)", asString(args1)) ==
+			encodeArgs(u256(l1), u256(0x40)) + dyn1
+		);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(calldata_struct_short)
+{
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract C {
+			struct S { uint256 a; uint256 b; }
+			function f(S calldata) external pure returns (uint256) {
+				return msg.data.length;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+
+	// double check that the valid case goes through
+	ABI_CHECK(callContractFunction("f((uint256,uint256))", u256(1), u256(2)), encodeArgs(0x44));
+
+	ABI_CHECK(callContractFunctionNoEncoding("f((uint256,uint256))", bytes(63,0)), encodeArgs());
+	ABI_CHECK(callContractFunctionNoEncoding("f((uint256,uint256))", bytes(33,0)), encodeArgs());
+	ABI_CHECK(callContractFunctionNoEncoding("f((uint256,uint256))", bytes(32,0)), encodeArgs());
+	ABI_CHECK(callContractFunctionNoEncoding("f((uint256,uint256))", bytes(31,0)), encodeArgs());
+	ABI_CHECK(callContractFunctionNoEncoding("f((uint256,uint256))", bytes()), encodeArgs());
+}
+
+BOOST_AUTO_TEST_CASE(calldata_struct_function_type)
+{
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract C {
+			struct S { function (uint) external returns (uint) fn; }
+			function f(S calldata s) external returns (uint256) {
+				return s.fn(42);
+			}
+			function g(uint256 a) external returns (uint256) {
+				return a * 3;
+			}
+			function h(uint256 a) external returns (uint256) {
+				return 23;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+
+	bytes fn_C_g = m_contractAddress.asBytes() + util::selectorFromSignatureH32("g(uint256)").asBytes() + bytes(8,0);
+	bytes fn_C_h = m_contractAddress.asBytes() + util::selectorFromSignatureH32("h(uint256)").asBytes() + bytes(8,0);
+	ABI_CHECK(callContractFunctionNoEncoding("f((function))", fn_C_g), encodeArgs(42 * 3));
+	ABI_CHECK(callContractFunctionNoEncoding("f((function))", fn_C_h), encodeArgs(23));
+}
+
+BOOST_AUTO_TEST_CASE(calldata_array_dynamic_three_dimensional)
+{
+	std::vector<std::vector<std::vector<u256>>> data {
+		{
+			{ 0x010A01, 0x010A02, 0x010A03 },
+			{ 0x010B01, 0x010B02, 0x010B03 }
+		},
+		{
+			{ 0x020A01, 0x020A02, 0x020A03 },
+			{ 0x020B01, 0x020B02, 0x020B03 }
+		}
+	};
+
+	for (bool outerDynamicallySized: { true, false })
+	for (bool middleDynamicallySized: { true, false })
+	for (bool innerDynamicallySized: { true, false })
+	{
+		// only test dynamically encoded arrays
+		if (!outerDynamicallySized && !middleDynamicallySized && !innerDynamicallySized)
+			continue;
+
+		std::string arrayType = "uint256";
+		arrayType += innerDynamicallySized ? "[]" : "[3]";
+		arrayType += middleDynamicallySized ? "[]" : "[2]";
+		arrayType += outerDynamicallySized ? "[]" : "[2]";
+
+		std::string sourceCode = R"(
+			pragma abicoder v2;
+			contract C {
+				function test()" + arrayType + R"( calldata a) external returns (uint256) {
+					return a.length;
+				}
+				function test()" + arrayType + R"( calldata a, uint256 i) external returns (uint256) {
+					return a[i].length;
+				}
+				function test()" + arrayType + R"( calldata a, uint256 i, uint256 j) external returns (uint256) {
+					return a[i][j].length;
+				}
+				function test()" + arrayType + R"( calldata a, uint256 i, uint256 j, uint256 k) external returns (uint256) {
+					return a[i][j][k];
+				}
+				function reenc()" + arrayType + R"( calldata a, uint256 i, uint256 j, uint256 k) external returns (uint256) {
+					return this.test(a, i, j, k);
+				}
+			}
+		)";
+		compileAndRun(sourceCode, 0, "C");
+
+		bytes encoding = encodeArray(
+			outerDynamicallySized,
+			middleDynamicallySized || innerDynamicallySized,
+			data | ranges::views::transform([&](auto const& _middleData) {
+				return encodeArray(
+					middleDynamicallySized,
+					innerDynamicallySized,
+					_middleData | ranges::views::transform([&](auto const& _values) {
+						return encodeArray(innerDynamicallySized, false, _values);
+					})
+				);
+			})
+		);
+
+		ABI_CHECK(callContractFunction("test(" + arrayType + ")", 0x20, encoding), encodeArgs(data.size()));
+		for (size_t i = 0; i < data.size(); i++)
+		{
+			ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256)", 0x40, i, encoding), encodeArgs(data[i].size()));
+			for (size_t j = 0; j < data[i].size(); j++)
+			{
+				ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256,uint256)", 0x60, i, j, encoding), encodeArgs(data[i][j].size()));
+				for (size_t k = 0; k < data[i][j].size(); k++)
+				{
+					ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256,uint256,uint256)", 0x80, i, j, k, encoding), encodeArgs(data[i][j][k]));
+					ABI_CHECK(callContractFunction("reenc(" + arrayType + ",uint256,uint256,uint256)", 0x80, i, j, k, encoding), encodeArgs(data[i][j][k]));
+				}
+				ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256,uint256,uint256)", 0x80, i, j, data[i][j].size(), encoding), panicData(PanicCode::ArrayOutOfBounds));
+			}
+			ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256,uint256)", 0x60, i, data[i].size(), encoding), panicData(PanicCode::ArrayOutOfBounds));
+		}
+		ABI_CHECK(callContractFunction("test(" + arrayType + ",uint256)", 0x40, data.size(), encoding), panicData(PanicCode::ArrayOutOfBounds));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(literal_strings)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			string public long;
+			string public medium;
+			string public short;
+			string public empty;
+			function f() public returns (string memory) {
+				long = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+				medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
+				short = "123";
+				empty = "";
+				return "Hello, World!";
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+	std::string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+	std::string medium = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
+	std::string shortStr = "123";
+	std::string hello = "Hello, World!";
+
+	ABI_CHECK(callContractFunction("f()"), encodeDyn(hello));
+	ABI_CHECK(callContractFunction("long()"), encodeDyn(longStr));
+	ABI_CHECK(callContractFunction("medium()"), encodeDyn(medium));
+	ABI_CHECK(callContractFunction("short()"), encodeDyn(shortStr));
+	ABI_CHECK(callContractFunction("empty()"), encodeDyn(std::string()));
+}
+
+BOOST_AUTO_TEST_CASE(initialise_string_constant)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			string public short = "abcdef";
+			string public long = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+	std::string longStr = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+	std::string shortStr = "abcdef";
+
+	ABI_CHECK(callContractFunction("long()"), encodeDyn(longStr));
+	ABI_CHECK(callContractFunction("short()"), encodeDyn(shortStr));
+}
+
+BOOST_AUTO_TEST_CASE(string_as_mapping_key)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			mapping(string => uint) data;
+			function set(string memory _s, uint _v) public { data[_s] = _v; }
+			function get(string memory _s) public returns (uint) { return data[_s]; }
+		}
+	)";
+
+	std::vector<std::string> strings{
+		"Hello, World!",
+		"Hello,                            World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
+		"",
+		"1"
+	};
+
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "Test");
+		for (unsigned i = 0; i < strings.size(); i++)
+			ABI_CHECK(callContractFunction(
+				"set(string,uint256)",
+				u256(0x40),
+				u256(7 + i),
+				u256(strings[i].size()),
+				strings[i]
+			), encodeArgs());
+		for (unsigned i = 0; i < strings.size(); i++)
+			ABI_CHECK(callContractFunction(
+				"get(string)",
+				u256(0x20),
+				u256(strings[i].size()),
+				strings[i]
+			), encodeArgs(u256(7 + i)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(string_as_public_mapping_key)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			mapping(string => uint) public data;
+			function set(string memory _s, uint _v) public { data[_s] = _v; }
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+	std::vector<std::string> strings{
+		"Hello, World!",
+		"Hello,                            World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
+		"",
+		"1"
+	};
+	for (unsigned i = 0; i < strings.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"set(string,uint256)",
+			u256(0x40),
+			u256(7 + i),
+			u256(strings[i].size()),
+			strings[i]
+		), encodeArgs());
+	for (unsigned i = 0; i < strings.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"data(string)",
+			u256(0x20),
+			u256(strings[i].size()),
+			strings[i]
+		), encodeArgs(u256(7 + i)));
+}
+
+BOOST_AUTO_TEST_CASE(nested_string_as_public_mapping_key)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			mapping(string => mapping(string => uint)) public data;
+			function set(string memory _s, string memory _s2, uint _v) public {
+				data[_s][_s2] = _v; }
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+	std::vector<std::string> strings{
+		"Hello, World!",
+		"Hello,                            World!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1111",
+		"",
+		"1",
+		"last one"
+	};
+	for (unsigned i = 0; i + 1 < strings.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"set(string,string,uint256)",
+			u256(0x60),
+			u256(roundTo32(static_cast<unsigned>(0x80 + strings[i].size()))),
+			u256(7 + i),
+			u256(strings[i].size()),
+			strings[i],
+			u256(strings[i+1].size()),
+			strings[i+1]
+		), encodeArgs());
+	for (unsigned i = 0; i + 1 < strings.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"data(string,string)",
+			u256(0x40),
+			u256(roundTo32(static_cast<unsigned>(0x60 + strings[i].size()))),
+			u256(strings[i].size()),
+			strings[i],
+			u256(strings[i+1].size()),
+			strings[i+1]
+		), encodeArgs(u256(7 + i)));
+}
+
+BOOST_AUTO_TEST_CASE(nested_mixed_string_as_public_mapping_key)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			mapping(string =>
+				mapping(int =>
+					mapping(address =>
+						mapping(bytes => int)))) public data;
+
+			function set(
+				string memory _s1,
+				int _s2,
+				address _s3,
+				bytes memory _s4,
+				int _value
+			) public
+			{
+				data[_s1][_s2][_s3][_s4] = _value;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "Test");
+
+	struct Index
+	{
+		std::string s1;
+		int s2;
+		int s3;
+		std::string s4;
+	};
+
+	std::vector<Index> data{
+		{ "aabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcbc", 4, 23, "efg" },
+		{ "tiaron", 456, 63245, "908apzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapzapz" },
+		{ "", 2345, 12934, "665i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i65i5iart" },
+		{ "¡¿…", 9781, 8148, "" },
+		{ "ρν♀♀ω₂₃♀", 929608, 303030, "" }
+	};
+
+	for (size_t i = 0; i + 1 < data.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"set(string,int256,address,bytes,int256)",
+			u256(0xA0),
+			u256(data[i].s2),
+			u256(data[i].s3),
+			u256(roundTo32(static_cast<unsigned>(0xC0 + data[i].s1.size()))),
+			u256(i - 3),
+			u256(data[i].s1.size()),
+			data[i].s1,
+			u256(data[i].s4.size()),
+			data[i].s4
+		), encodeArgs());
+	for (size_t i = 0; i + 1 < data.size(); i++)
+		ABI_CHECK(callContractFunction(
+			"data(string,int256,address,bytes)",
+			u256(0x80),
+			u256(data[i].s2),
+			u256(data[i].s3),
+			u256(roundTo32(static_cast<unsigned>(0xA0 + data[i].s1.size()))),
+			u256(data[i].s1.size()),
+			data[i].s1,
+			u256(data[i].s4.size()),
+			data[i].s4
+		), encodeArgs(u256(i - 3)));
+}
+
+BOOST_AUTO_TEST_CASE(library_call)
+{
+	char const* sourceCode = R"(
+		library Lib { function m(uint x, uint y) public returns (uint) { return x * y; } }
+		contract Test {
+			function f(uint x) public returns (uint) {
+				return Lib.m(x, 9);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "Lib");
+		compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
+		ABI_CHECK(callContractFunction("f(uint256)", u256(33)), encodeArgs(u256(33) * 9));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(library_function_external)
+{
+	char const* sourceCode = R"(
+		library Lib { function m(bytes calldata b) external pure returns (bytes1) { return b[2]; } }
+		contract Test {
+			function f(bytes memory b) public pure returns (bytes1) {
+				return Lib.m(b);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "Lib");
+		compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
+		ABI_CHECK(callContractFunction("f(bytes)", u256(0x20), u256(5), "abcde"), encodeArgs("c"));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(using_library_mappings_external)
+{
+	char const* libSourceCode = R"(
+			library Lib {
+				function set(mapping(uint => uint) storage m, uint key, uint value) external
+				{
+					m[key] = value * 2;
+				}
+			}
+		)";
+	char const* sourceCode = R"(
+			library Lib {
+				function set(mapping(uint => uint) storage m, uint key, uint value) external {}
+			}
+			contract Test {
+				mapping(uint => uint) m1;
+				mapping(uint => uint) m2;
+				function f() public returns (uint, uint, uint, uint, uint, uint)
+				{
+					Lib.set(m1, 0, 1);
+					Lib.set(m1, 2, 42);
+					Lib.set(m2, 0, 23);
+					Lib.set(m2, 2, 99);
+					return (m1[0], m1[1], m1[2], m2[0], m2[1], m2[2]);
+				}
+			}
+		)";
+	for (auto v2: {false, true})
+	{
+		std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
+		compileAndRun(prefix + libSourceCode, 0, "Lib");
+		compileAndRun(prefix + sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":Lib", m_contractAddress}});
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(2), u256(0), u256(84), u256(46), u256(0), u256(198)));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(short_strings)
+{
+	// This test verifies that the byte array encoding that combines length and data works
+	// correctly.
+	char const* sourceCode = R"(
+		contract A {
+			bytes public data1 = "123";
+			bytes data2;
+			function lengthChange() public returns (uint)
+			{
+				// store constant in short and long string
+				data1 = "123";
+				if (!equal(data1, "123")) return 1;
+				data2 = "12345678901234567890123456789012345678901234567890a";
+				if (data2[17] != "8") return 3;
+				if (data2.length != 51) return 4;
+				if (data2[data2.length - 1] != "a") return 5;
+				// change length: short -> short
+				while (data1.length < 5)
+					data1.push();
+				if (data1.length != 5) return 6;
+				data1[4] = "4";
+				if (data1[0] != "1") return 7;
+				if (data1[4] != "4") return 8;
+				// change length: short -> long
+				while (data1.length < 80)
+					data1.push();
+				if (data1.length != 80) return 9;
+				while (data1.length > 70)
+					data1.pop();
+				if (data1.length != 70) return 9;
+				if (data1[0] != "1") return 10;
+				if (data1[4] != "4") return 11;
+				for (uint i = 0; i < data1.length; i ++)
+					data1[i] = bytes1(uint8(i * 3));
+				if (uint8(data1[4]) != 4 * 3) return 12;
+				if (uint8(data1[67]) != 67 * 3) return 13;
+				// change length: long -> short
+				while (data1.length > 22)
+					data1.pop();
+				if (data1.length != 22) return 14;
+				if (uint8(data1[21]) != 21 * 3) return 15;
+				if (uint8(data1[2]) != 2 * 3) return 16;
+				// change length: short -> shorter
+				while (data1.length > 19)
+					data1.pop();
+				if (data1.length != 19) return 17;
+				if (uint8(data1[7]) != 7 * 3) return 18;
+				// and now again to original size
+				while (data1.length < 22)
+					data1.push();
+				if (data1.length != 22) return 19;
+				if (data1[21] != 0) return 20;
+				while (data1.length > 0)
+					data1.pop();
+				while (data2.length > 0)
+					data2.pop();
+			}
+			function copy() public returns (uint) {
+				bytes memory x = "123";
+				bytes memory y = "012345678901234567890123456789012345678901234567890123456789";
+				bytes memory z = "1234567";
+				data1 = x;
+				data2 = y;
+				if (!equal(data1, x)) return 1;
+				if (!equal(data2, y)) return 2;
+				// lengthen
+				data1 = y;
+				if (!equal(data1, y)) return 3;
+				// shorten
+				data1 = x;
+				if (!equal(data1, x)) return 4;
+				// change while keeping short
+				data1 = z;
+				if (!equal(data1, z)) return 5;
+				// copy storage -> storage
+				data1 = x;
+				data2 = y;
+				// lengthen
+				data1 = data2;
+				if (!equal(data1, y)) return 6;
+				// shorten
+				data1 = x;
+				data2 = data1;
+				if (!equal(data2, x)) return 7;
+				bytes memory c = data2;
+				data1 = c;
+				if (!equal(data1, x)) return 8;
+				data1 = "";
+				data2 = "";
+			}
+			function deleteElements() public returns (uint) {
+				data1 = "01234";
+				delete data1[2];
+				if (data1[2] != 0) return 1;
+				if (data1[0] != "0") return 2;
+				if (data1[3] != "3") return 3;
+				delete data1;
+				if (data1.length != 0) return 4;
+			}
+
+			function equal(bytes storage a, bytes memory b) internal returns (bool) {
+				if (a.length != b.length) return false;
+				for (uint i = 0; i < a.length; ++i) if (a[i] != b[i]) return false;
+				return true;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "A");
+		ABI_CHECK(callContractFunction("data1()"), encodeDyn(std::string("123")));
+		ABI_CHECK(callContractFunction("lengthChange()"), encodeArgs(u256(0)));
+		BOOST_CHECK(storageEmpty(m_contractAddress));
+		ABI_CHECK(callContractFunction("deleteElements()"), encodeArgs(u256(0)));
+		BOOST_CHECK(storageEmpty(m_contractAddress));
+		ABI_CHECK(callContractFunction("copy()"), encodeArgs(u256(0)));
+		BOOST_CHECK(storageEmpty(m_contractAddress));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(calldata_offset)
+{
+	// This tests a specific bug that was caused by not using the correct memory offset in the
+	// calldata unpacker.
+	char const* sourceCode = R"(
+		contract CB
+		{
+			address[] _arr;
+			string public last = "nd";
+			constructor(address[] memory guardians)
+			{
+				_arr = guardians;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "CB", encodeArgs(u256(0x20), u256(0x00)));
+	ABI_CHECK(callContractFunction("last()", encodeArgs()), encodeDyn(std::string("nd")));
+}
+
+BOOST_AUTO_TEST_CASE(reject_ether_sent_to_library)
+{
+	char const* sourceCode = R"(
+		library lib {}
+		contract c {
+			constructor() payable {}
+			function f(address payable x) public returns (bool) {
+				return x.send(1);
+			}
+			receive () external payable {}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "lib");
+		Address libraryAddress = m_contractAddress;
+		compileAndRun(sourceCode, 10, "c");
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
+		BOOST_CHECK_EQUAL(balanceAt(libraryAddress), 0);
+		ABI_CHECK(callContractFunction("f(address)", encodeArgs(libraryAddress)), encodeArgs(false));
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
+		BOOST_CHECK_EQUAL(balanceAt(libraryAddress), 0);
+		ABI_CHECK(callContractFunction("f(address)", encodeArgs(m_contractAddress)), encodeArgs(true));
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
+		BOOST_CHECK_EQUAL(balanceAt(libraryAddress), 0);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(create_memory_array_allocation_size)
+{
+	// Check allocation size of byte array. Should be 32 plus length rounded up to next
+	// multiple of 32
+	char const* sourceCode = R"(
+		contract C {
+			function f() public pure returns (uint d1, uint d2, uint d3, uint memsize) {
+				bytes memory b1 = new bytes(31);
+				bytes memory b2 = new bytes(32);
+				bytes memory b3 = new bytes(256);
+				bytes memory b4 = new bytes(31);
+				assembly {
+					d1 := sub(b2, b1)
+					d2 := sub(b3, b2)
+					d3 := sub(b4, b3)
+					memsize := msize()
+				}
+			}
+		}
+	)";
+	if (!m_optimiserSettings.runYulOptimiser)
+	{
+		compileAndRun(sourceCode);
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0x40, 0x40, 0x20 + 256, 0x260));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(inline_long_string_return)
+{
+		char const* sourceCode = R"(
+		contract C {
+			function f() public returns (string memory) {
+				return (["somethingShort", "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"][1]);
+			}
+		}
+	)";
+
+	std::string strLong = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678900123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunction("f()"), encodeDyn(strLong));
+}
+
+BOOST_AUTO_TEST_CASE(index_access_with_type_conversion)
+{
+	// Test for a bug where higher order bits cleanup was not done for array index access.
+	char const* sourceCode = R"(
+			contract C {
+				function f(uint x) public returns (uint[256] memory r){
+					r[uint8(x)] = 2;
+				}
+			}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	// neither of the two should throw due to out-of-bounds access
+	BOOST_CHECK(callContractFunction("f(uint256)", u256(0x01)).size() == 256 * 32);
+	BOOST_CHECK(callContractFunction("f(uint256)", u256(0x101)).size() == 256 * 32);
+}
+
+BOOST_AUTO_TEST_CASE(correctly_initialize_memory_array_in_constructor)
+{
+	// Memory arrays are initialized using calldatacopy past the size of the calldata.
+	// This test checks that it also works in the constructor context.
+	char const* sourceCode = R"(
+		contract C {
+			bool public success;
+			constructor() {
+				// Make memory dirty.
+				assembly {
+					for { let i := 0 } lt(i, 64) { i := add(i, 1) } {
+						mstore(msize(), not(0))
+					}
+				}
+				uint16[3] memory c;
+				require(c[0] == 0 && c[1] == 0 && c[2] == 0);
+				uint16[] memory x = new uint16[](3);
+				require(x[0] == 0 && x[1] == 0 && x[2] == 0);
+				success = true;
+			}
+		}
+	)";
+	// Cannot run against yul optimizer because of msize
+	if (!m_optimiserSettings.runYulOptimiser)
+	{
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("success()"), encodeArgs(u256(1)));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(mutex)
+{
+	char const* sourceCode = R"(
+		contract mutexed {
+			bool locked;
+			modifier protected {
+				if (locked) revert();
+				locked = true;
+				_;
+				locked = false;
+			}
+		}
+		contract Fund is mutexed {
+			uint shares;
+			constructor() payable { shares = msg.value; }
+			function withdraw(uint amount) public protected returns (uint) {
+				// NOTE: It is very bad practice to write this function this way.
+				// Please refer to the documentation of how to do this properly.
+				if (amount > shares) revert();
+				(bool success,) = msg.sender.call{value: amount}("");
+				require(success);
+				shares -= amount;
+				return shares;
+			}
+			function withdrawUnprotected(uint amount) public returns (uint) {
+				// NOTE: It is very bad practice to write this function this way.
+				// Please refer to the documentation of how to do this properly.
+				if (amount > shares) revert();
+				(bool success,) = msg.sender.call{value: amount}("");
+				require(success);
+				shares -= amount;
+				return shares;
+			}
+		}
+		contract Attacker {
+			Fund public fund;
+			uint callDepth;
+			bool protected;
+			function setProtected(bool _protected) public { protected = _protected; }
+			constructor(Fund _fund) { fund = _fund; }
+			function attack() public returns (uint) {
+				callDepth = 0;
+				return attackInternal();
+			}
+			function attackInternal() internal returns (uint) {
+				if (protected)
+					return fund.withdraw(10);
+				else
+					return fund.withdrawUnprotected(10);
+			}
+			fallback() external payable {
+				callDepth++;
+				if (callDepth < 4)
+					attackInternal();
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 500, "Fund");
+	h160 const fund = m_contractAddress;
+	BOOST_CHECK_EQUAL(balanceAt(fund), 500);
+	compileAndRun(sourceCode, 0, "Attacker", encodeArgs(fund));
+	ABI_CHECK(callContractFunction("setProtected(bool)", true), encodeArgs());
+	ABI_CHECK(callContractFunction("attack()"), encodeArgs());
+	BOOST_CHECK_EQUAL(balanceAt(fund), 500);
+	ABI_CHECK(callContractFunction("setProtected(bool)", false), encodeArgs());
+	ABI_CHECK(callContractFunction("attack()"), encodeArgs(u256(460)));
+	BOOST_CHECK_EQUAL(balanceAt(fund), 460);
+}
+
+BOOST_AUTO_TEST_CASE(payable_function)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint public a;
+			function f() payable public returns (uint) {
+				return msg.value;
+			}
+			fallback() external payable {
+				a = msg.value + 1;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunctionWithValue("f()", 27), encodeArgs(u256(27)));
+	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 27);
+	ABI_CHECK(callContractFunctionWithValue("", 27), encodeArgs());
+	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 27 + 27);
+	ABI_CHECK(callContractFunction("a()"), encodeArgs(u256(28)));
+	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 27 + 27);
+}
+
+BOOST_AUTO_TEST_CASE(non_payable_throw)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint public a;
+			function f() public returns (uint) {
+				return msgvalue();
+			}
+			function msgvalue() internal returns (uint) {
+				return msg.value;
+			}
+			fallback() external {
+				update();
+			}
+			function update() internal {
+				a = msg.value + 1;
+			}
+
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunctionWithValue("f()", 27), encodeArgs());
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 0);
+		ABI_CHECK(callContractFunction(""), encodeArgs());
+		ABI_CHECK(callContractFunction("a()"), encodeArgs(u256(1)));
+		ABI_CHECK(callContractFunctionWithValue("", 27), encodeArgs());
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 0);
+		ABI_CHECK(callContractFunction("a()"), encodeArgs(u256(1)));
+		ABI_CHECK(callContractFunctionWithValue("a()", 27), encodeArgs());
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 0);
+	)
+}
+
+BOOST_AUTO_TEST_CASE(mem_resize_is_not_paid_at_call)
+{
+	// This tests that memory resize for return values is not paid during the call, which would
+	// make the gas calculation overly complex. We access the end of the output area before
+	// the call is made.
+	// Tests that this also survives the optimizer.
+	char const* sourceCode = R"(
+		contract C {
+			function f() public returns (uint[200] memory) {}
+		}
+		contract D {
+			function f(C c) public returns (uint) { c.f(); return 7; }
+		}
+	)";
+
+	compileAndRun(sourceCode, 0, "C");
+	h160 const cAddr = m_contractAddress;
+	compileAndRun(sourceCode, 0, "D");
+	ABI_CHECK(callContractFunction("f(address)", cAddr), encodeArgs(u256(7)));
+}
+
+BOOST_AUTO_TEST_CASE(receive_external_function_type)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function g() public returns (uint) { return 7; }
+			function f(function() external returns (uint) g) public returns (uint) {
+				return g();
+			}
+		}
+	)";
+
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction(
+			"f(function)",
+			m_contractAddress.asBytes() + util::selectorFromSignatureH32("g()").asBytes() + bytes(32 - 4 - 20, 0)
+		), encodeArgs(u256(7)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(return_external_function_type)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function g() public {}
+			function f() public returns (function() external) {
+				return this.g;
+			}
+		}
+	)";
+
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(
+		callContractFunction("f()"),
+		m_contractAddress.asBytes() + util::selectorFromSignatureH32("g()").asBytes() + bytes(32 - 4 - 20, 0)
+	);
+}
+
+// TODO: store attached internal library functions
+
+BOOST_AUTO_TEST_CASE(shift_bytes)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function left(bytes20 x, uint8 y) public returns (bytes20) {
+				return x << y;
+			}
+			function right(bytes20 x, uint8 y) public returns (bytes20) {
+				return x >> y;
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunction("left(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs("901234567890" + std::string(8, 0)));
+	ABI_CHECK(callContractFunction("right(bytes20,uint8)", "12345678901234567890", 8 * 8), encodeArgs(std::string(8, 0) + "123456789012"));
+}
+
+BOOST_AUTO_TEST_CASE(contracts_separated_with_comment)
+{
+	char const* sourceCode = R"(
+		contract C1 {}
+		/**
+		**/
+		contract C2 {}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C1");
+		compileAndRun(sourceCode, 0, "C2");
+	)
+}
+
+BOOST_AUTO_TEST_CASE(include_creation_bytecode_only_once)
+{
+	char const* sourceCode = R"(
+		contract D {
+			bytes a = hex"1237651237125387136581271652831736512837126583171583712358126123765123712538713658127165283173651283712658317158371235812612376512371253871365812716528317365128371265831715837123581261237651237125387136581271652831736512837126583171583712358126";
+			bytes b = hex"1237651237125327136581271252831736512837126583171383712358126123765125712538713658127165253173651283712658357158371235812612376512371a5387136581271652a317365128371265a317158371235812612a765123712538a13658127165a83173651283712a58317158371235a126";
+			constructor(uint) {}
+		}
+		contract Double {
+			function f() public {
+				new D(2);
+			}
+			function g() public {
+				new D(3);
+			}
+		}
+		contract Single {
+			function f() public {
+				new D(2);
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK_LE(
+		double(m_compiler.object("Double").bytecode.size()),
+		1.2 * double(m_compiler.object("Single").bytecode.size())
+	);
+}
+
+BOOST_AUTO_TEST_CASE(revert_with_cause)
+{
+	char const* sourceCode = R"(
+		contract D {
+			string constant msg1 = "test1234567890123456789012345678901234567890";
+			string msg2 = "test1234567890123456789012345678901234567890";
+			function f() public {
+				revert("test123");
+			}
+			function g() public {
+				revert("test1234567890123456789012345678901234567890");
+			}
+			function h() public {
+				revert(msg1);
+			}
+			function i() public {
+				revert(msg2);
+			}
+			function j() public {
+				string memory msg3 = "test1234567890123456789012345678901234567890";
+				revert(msg3);
+			}
+		}
+		contract C {
+			D d = new D();
+			function forward(address target, bytes memory data) internal returns (bool success, bytes memory retval) {
+				uint retsize;
+				assembly {
+					success := call(not(0), target, 0, add(data, 0x20), mload(data), 0, 0)
+					retsize := returndatasize()
+				}
+				retval = new bytes(retsize);
+				assembly {
+					returndatacopy(add(retval, 0x20), 0, returndatasize())
+				}
+			}
+			function f() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function g() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function h() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function i() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function j() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		compileAndRun(sourceCode, 0, "C");
+		bytes const errorSignature = bytes{0x08, 0xc3, 0x79, 0xa0};
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 7, "test123") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(0, 0x40, 0x84) + errorSignature + encodeArgs(0x20, 44, "test1234567890123456789012345678901234567890") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("h()"), encodeArgs(0, 0x40, 0x84) + errorSignature + encodeArgs(0x20, 44, "test1234567890123456789012345678901234567890") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("i()"), encodeArgs(0, 0x40, 0x84) + errorSignature + encodeArgs(0x20, 44, "test1234567890123456789012345678901234567890") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("j()"), encodeArgs(0, 0x40, 0x84) + errorSignature + encodeArgs(0x20, 44, "test1234567890123456789012345678901234567890") + bytes(28, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(require_with_message)
+{
+	char const* sourceCode = R"(
+		contract D {
+			bool flag = false;
+			string storageError = "abc";
+			string constant constantError = "abc";
+			function f(uint x) public {
+				require(x > 7, "failed");
+			}
+			function g() public {
+				// As a side-effect of internalFun, the flag will be set to true
+				// (even if the condition is true),
+				// but it will only throw in the next evaluation.
+				bool flagCopy = flag;
+				require(flagCopy == false, internalFun());
+			}
+			function internalFun() public returns (string memory) {
+				flag = true;
+				return "only on second run";
+			}
+			function h() public {
+				require(false, storageError);
+			}
+			function i() public {
+				require(false, constantError);
+			}
+			function j() public {
+				string memory errMsg = "msg";
+				require(false, errMsg);
+			}
+		}
+		contract C {
+			D d = new D();
+			function forward(address target, bytes memory data) internal returns (bool success, bytes memory retval) {
+				uint retsize;
+				assembly {
+					success := call(not(0), target, 0, add(data, 0x20), mload(data), 0, 0)
+					retsize := returndatasize()
+				}
+				retval = new bytes(retsize);
+				assembly {
+					returndatacopy(add(retval, 0x20), 0, returndatasize())
+				}
+			}
+			function f(uint x) public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function g() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function h() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function i() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function j() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		compileAndRun(sourceCode, 0, "C");
+		bytes const errorSignature = bytes{0x08, 0xc3, 0x79, 0xa0};
+		ABI_CHECK(callContractFunction("f(uint256)", 8), encodeArgs(1, 0x40, 0));
+		ABI_CHECK(callContractFunction("f(uint256)", 5), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 6, "failed") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(1, 0x40, 0));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 18, "only on second run") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("h()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 3, "abc") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("i()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 3, "abc") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("j()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 3, "msg") + bytes(28, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(bubble_up_error_messages)
+{
+	char const* sourceCode = R"(
+		contract D {
+			function f() public {
+				revert("message");
+			}
+			function g() public {
+				this.f();
+			}
+		}
+		contract C {
+			D d = new D();
+			function forward(address target, bytes memory data) internal returns (bool success, bytes memory retval) {
+				uint retsize;
+				assembly {
+					success := call(not(0), target, 0, add(data, 0x20), mload(data), 0, 0)
+					retsize := returndatasize()
+				}
+				retval = new bytes(retsize);
+				assembly {
+					returndatacopy(add(retval, 0x20), 0, returndatasize())
+				}
+			}
+			function f() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+			function g() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		compileAndRun(sourceCode, 0, "C");
+		bytes const errorSignature = bytes{0x08, 0xc3, 0x79, 0xa0};
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 7, "message") + bytes(28, 0));
+		ABI_CHECK(callContractFunction("g()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 7, "message") + bytes(28, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(bubble_up_error_messages_through_transfer)
+{
+	char const* sourceCode = R"(
+		contract D {
+			receive() external payable {
+				revert("message");
+			}
+			function f() public {
+				payable(this).transfer(0);
+			}
+		}
+		contract C {
+			D d = new D();
+			function forward(address target, bytes memory data) internal returns (bool success, bytes memory retval) {
+				uint retsize;
+				assembly {
+					success := call(not(0), target, 0, add(data, 0x20), mload(data), 0, 0)
+					retsize := returndatasize()
+				}
+				retval = new bytes(retsize);
+				assembly {
+					returndatacopy(add(retval, 0x20), 0, returndatasize())
+				}
+			}
+			function f() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		compileAndRun(sourceCode, 0, "C");
+		bytes const errorSignature = bytes{0x08, 0xc3, 0x79, 0xa0};
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 7, "message") + bytes(28, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(bubble_up_error_messages_through_create)
+{
+	char const* sourceCode = R"(
+		contract E {
+			constructor() {
+				revert("message");
+			}
+		}
+		contract D {
+			function f() public {
+				E x = new E();
+			}
+		}
+		contract C {
+			D d = new D();
+			function forward(address target, bytes memory data) internal returns (bool success, bytes memory retval) {
+				uint retsize;
+				assembly {
+					success := call(not(0), target, 0, add(data, 0x20), mload(data), 0, 0)
+					retsize := returndatasize()
+				}
+				retval = new bytes(retsize);
+				assembly {
+					returndatacopy(add(retval, 0x20), 0, returndatasize())
+				}
+			}
+			function f() public returns (bool, bytes memory) {
+				return forward(address(d), msg.data);
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		compileAndRun(sourceCode, 0, "C");
+		bytes const errorSignature = bytes{0x08, 0xc3, 0x79, 0xa0};
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(0, 0x40, 0x64) + errorSignature + encodeArgs(0x20, 7, "message") + bytes(28, 0));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(interface_contract)
+{
+	char const* sourceCode = R"(
+		interface I {
+			event A();
+			function f() external returns (bool);
+			fallback() external payable;
+		}
+
+		contract A is I {
+			function f() public override returns (bool) {
+				return g();
+			}
+
+			function g() public returns (bool) {
+				return true;
+			}
+
+			fallback() override external payable {
+			}
+		}
+
+		contract C {
+			function f(address payable _interfaceAddress) public returns (bool) {
+				I i = I(_interfaceAddress);
+				return i.f();
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "A");
+	h160 const recipient = m_contractAddress;
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunction("f(address)", recipient), encodeArgs(true));
+}
+
+BOOST_AUTO_TEST_CASE(bare_call_invalid_address)
+{
+	char const* sourceCode = R"YY(
+		contract C {
+			/// Calling into non-existent account is successful (creates the account)
+			function f() external returns (bool) {
+				(bool success,) = address(0x4242).call("");
+				return success;
+			}
+			function h() external returns (bool) {
+				(bool success,) = address(0x4242).delegatecall("");
+				return success;
+			}
+		}
+	)YY";
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(1)));
+	ABI_CHECK(callContractFunction("h()"), encodeArgs(u256(1)));
+
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+	{
+		char const* sourceCode = R"YY(
+			contract C {
+				function f() external returns (bool, bytes memory) {
+					return address(0x4242).staticcall("");
+				}
+			}
+		)YY";
+		compileAndRun(sourceCode, 0, "C");
+		ABI_CHECK(callContractFunction("f()"), encodeArgs(u256(1), 0x40, 0x00));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(bare_call_return_data)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+	{
+		std::vector<std::string> calltypes = {"call", "delegatecall"};
+		if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+			calltypes.emplace_back("staticcall");
+		for (std::string const& calltype: calltypes)
+		{
+			std::string sourceCode = R"DELIMITER(
+				contract A {
+					constructor() {
+					}
+					function return_bool() public pure returns(bool) {
+						return true;
+					}
+					function return_int32() public pure returns(int32) {
+						return -32;
+					}
+					function return_uint32() public pure returns(uint32) {
+						return 0x3232;
+					}
+					function return_int256() public pure returns(int256) {
+						return -256;
+					}
+					function return_uint256() public pure returns(uint256) {
+						return 0x256256;
+					}
+					function return_bytes4() public pure returns(bytes4) {
+						return 0xabcd0012;
+					}
+					function return_multi() public pure returns(bool, uint32, bytes4) {
+						return (false, 0x3232, 0xabcd0012);
+					}
+					function return_bytes() public pure returns(bytes memory b) {
+						b = new bytes(2);
+						b[0] = 0x42;
+						b[1] = 0x21;
+					}
+				}
+				contract C {
+					A addr;
+					constructor() {
+						addr = new A();
+					}
+					function f(string memory signature) public returns (bool, bytes memory) {
+						return address(addr).)DELIMITER" + calltype + R"DELIMITER((abi.encodeWithSignature(signature));
+					}
+					function check_bool() external returns (bool) {
+						(bool success, bytes memory data) = f("return_bool()");
+						assert(success);
+						bool a = abi.decode(data, (bool));
+						assert(a);
+						return true;
+					}
+					function check_int32() external returns (bool) {
+						(bool success, bytes memory data) = f("return_int32()");
+						assert(success);
+						int32 a = abi.decode(data, (int32));
+						assert(a == -32);
+						return true;
+					}
+					function check_uint32() external returns (bool) {
+						(bool success, bytes memory data) = f("return_uint32()");
+						assert(success);
+						uint32 a = abi.decode(data, (uint32));
+						assert(a == 0x3232);
+						return true;
+					}
+					function check_int256() external returns (bool) {
+						(bool success, bytes memory data) = f("return_int256()");
+						assert(success);
+						int256 a = abi.decode(data, (int256));
+						assert(a == -256);
+						return true;
+					}
+					function check_uint256() external returns (bool) {
+						(bool success, bytes memory data) = f("return_uint256()");
+						assert(success);
+						uint256 a = abi.decode(data, (uint256));
+						assert(a == 0x256256);
+						return true;
+					}
+					function check_bytes4() external returns (bool) {
+						(bool success, bytes memory data) = f("return_bytes4()");
+						assert(success);
+						bytes4 a = abi.decode(data, (bytes4));
+						assert(a == 0xabcd0012);
+						return true;
+					}
+					function check_multi() external returns (bool) {
+						(bool success, bytes memory data) = f("return_multi()");
+						assert(success);
+						(bool a, uint32 b, bytes4 c) = abi.decode(data, (bool, uint32, bytes4));
+						assert(a == false && b == 0x3232 && c == 0xabcd0012);
+						return true;
+					}
+					function check_bytes() external returns (bool) {
+						(bool success, bytes memory data) = f("return_bytes()");
+						assert(success);
+						(bytes memory d) = abi.decode(data, (bytes));
+						assert(d.length == 2 && d[0] == 0x42 && d[1] == 0x21);
+						return true;
+					}
+				}
+			)DELIMITER";
+			ALSO_VIA_YUL(
+				compileAndRun(sourceCode, 0, "C");
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bool()"))), encodeArgs(true, 0x40, 0x20, true));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_int32()"))), encodeArgs(true, 0x40, 0x20, u256(-32)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_uint32()"))), encodeArgs(true, 0x40, 0x20, u256(0x3232)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_int256()"))), encodeArgs(true, 0x40, 0x20, u256(-256)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_uint256()"))), encodeArgs(true, 0x40, 0x20, u256(0x256256)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bytes4()"))), encodeArgs(true, 0x40, 0x20, u256(0xabcd0012) << (28*8)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_multi()"))), encodeArgs(true, 0x40, 0x60, false, u256(0x3232), u256(0xabcd0012) << (28*8)));
+				ABI_CHECK(callContractFunction("f(string)", encodeDyn(std::string("return_bytes()"))), encodeArgs(true, 0x40, 0x60, 0x20, 0x02, encode(bytes{0x42,0x21}, false)));
+				ABI_CHECK(callContractFunction("check_bool()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_int32()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_uint32()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_int256()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_uint256()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_bytes4()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_multi()"), encodeArgs(true));
+				ABI_CHECK(callContractFunction("check_bytes()"), encodeArgs(true));
+			)
+		}
+	}
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePacked)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f0() public pure returns (bytes memory) {
+				return abi.encodePacked();
+			}
+			function f1() public pure returns (bytes memory) {
+				return abi.encodePacked(uint8(1), uint8(2));
+			}
+			function f2() public pure returns (bytes memory) {
+				string memory x = "abc";
+				return abi.encodePacked(uint8(1), x, uint8(2));
+			}
+			function f3() public pure returns (bytes memory r) {
+				// test that memory is properly allocated
+				string memory x = "abc";
+				r = abi.encodePacked(uint8(1), x, uint8(2));
+				bytes memory y = "def";
+				require(y[0] == "d");
+				y[0] = "e";
+				require(y[0] == "e");
+			}
+			function f4() public pure returns (bytes memory) {
+				string memory x = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+				return abi.encodePacked(uint16(0x0701), x, uint16(0x1201));
+			}
+			function f_literal() public pure returns (bytes memory) {
+				return abi.encodePacked(uint8(0x01), "abc", uint8(0x02));
+			}
+			function f_calldata() public pure returns (bytes memory) {
+				return abi.encodePacked(uint8(0x01), msg.data, uint8(0x02));
+			}
+		}
+	)";
+	for (auto v2: {false, true})
+	{
+		ALSO_VIA_YUL(
+			std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
+			compileAndRun(prefix + sourceCode, 0, "C");
+			ABI_CHECK(callContractFunction("f0()"), encodeArgs(0x20, 0));
+			ABI_CHECK(callContractFunction("f1()"), encodeArgs(0x20, 2, "\x01\x02"));
+			ABI_CHECK(callContractFunction("f2()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02"));
+			ABI_CHECK(callContractFunction("f3()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02"));
+			ABI_CHECK(callContractFunction("f4()"), encodeArgs(0x20, 2 + 26 + 26 + 2, "\x07\x01" "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" "\x12\x01"));
+			ABI_CHECK(callContractFunction("f_literal()"), encodeArgs(0x20, 5, "\x01" "abc" "\x02"));
+			ABI_CHECK(callContractFunction("f_calldata()"), encodeArgs(0x20, 6, "\x01" "\xa5\xbf\xa1\xee" "\x02"));
+		)
+	}
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePacked_from_storage)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint24[9] small_fixed;
+			int24[9] small_fixed_signed;
+			uint24[] small_dyn;
+			uint248[5] large_fixed;
+			uint248[] large_dyn;
+			bytes bytes_storage;
+			function sf() public returns (bytes memory) {
+				small_fixed[0] = 0xfffff1;
+				small_fixed[2] = 0xfffff2;
+				small_fixed[5] = 0xfffff3;
+				small_fixed[8] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), small_fixed, uint8(0x02));
+			}
+			function sd() public returns (bytes memory) {
+				small_dyn.push(0xfffff1);
+				small_dyn.push(0x00);
+				small_dyn.push(0xfffff2);
+				small_dyn.push(0x00);
+				small_dyn.push(0x00);
+				small_dyn.push(0xfffff3);
+				small_dyn.push(0x00);
+				small_dyn.push(0x00);
+				small_dyn.push(0xfffff4);
+				return abi.encodePacked(uint8(0x01), small_dyn, uint8(0x02));
+			}
+			function sfs() public returns (bytes memory) {
+				small_fixed_signed[0] = -2;
+				small_fixed_signed[2] = 0xffff2;
+				small_fixed_signed[5] = -200;
+				small_fixed_signed[8] = 0xffff4;
+				return abi.encodePacked(uint8(0x01), small_fixed_signed, uint8(0x02));
+			}
+			function lf() public returns (bytes memory) {
+				large_fixed[0] = 2**248-1;
+				large_fixed[1] = 0xfffff2;
+				large_fixed[2] = 2**248-2;
+				large_fixed[4] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), large_fixed, uint8(0x02));
+			}
+			function ld() public returns (bytes memory) {
+				large_dyn.push(2**248-1);
+				large_dyn.push(0xfffff2);
+				large_dyn.push(2**248-2);
+				large_dyn.push(0);
+				large_dyn.push(0xfffff4);
+				return abi.encodePacked(uint8(0x01), large_dyn, uint8(0x02));
+			}
+			function bytes_short() public returns (bytes memory) {
+				bytes_storage = "abcd";
+				return abi.encodePacked(uint8(0x01), bytes_storage, uint8(0x02));
+			}
+			function bytes_long() public returns (bytes memory) {
+				bytes_storage = "0123456789012345678901234567890123456789";
+				return abi.encodePacked(uint8(0x01), bytes_storage, uint8(0x02));
+			}
+		}
+	)";
+	for (auto v2: {false, true})
+	{
+		ALSO_VIA_YUL(
+			std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
+			compileAndRun(prefix + sourceCode, 0, "C");
+			bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4);
+			bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02");
+			ABI_CHECK(callContractFunction("sf()"), encoded);
+			ABI_CHECK(callContractFunction("sd()"), encoded);
+			ABI_CHECK(callContractFunction("sfs()"), encodeArgs(0x20, 0x122, "\x01" + asString(encodeArgs(
+				u256(-2), 0, 0xffff2, 0, 0, u256(-200), 0, 0, 0xffff4
+			)) + "\x02"));
+			payload = encodeArgs(
+				u256("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+				0xfffff2,
+				u256("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
+				0,
+				0xfffff4
+			);
+			ABI_CHECK(callContractFunction("lf()"), encodeArgs(0x20, 5 * 32 + 2, "\x01" + asString(encodeArgs(payload)) + "\x02"));
+			ABI_CHECK(callContractFunction("ld()"), encodeArgs(0x20, 5 * 32 + 2, "\x01" + asString(encodeArgs(payload)) + "\x02"));
+			ABI_CHECK(callContractFunction("bytes_short()"), encodeArgs(0x20, 6, "\x01" "abcd\x02"));
+			ABI_CHECK(callContractFunction("bytes_long()"), encodeArgs(0x20, 42, "\x01" "0123456789012345678901234567890123456789\x02"));
+		)
+	}
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePacked_from_memory)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function sf() public pure returns (bytes memory) {
+				uint24[9] memory small_fixed;
+				small_fixed[0] = 0xfffff1;
+				small_fixed[2] = 0xfffff2;
+				small_fixed[5] = 0xfffff3;
+				small_fixed[8] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), small_fixed, uint8(0x02));
+			}
+			function sd() public pure returns (bytes memory) {
+				uint24[] memory small_dyn = new uint24[](9);
+				small_dyn[0] = 0xfffff1;
+				small_dyn[2] = 0xfffff2;
+				small_dyn[5] = 0xfffff3;
+				small_dyn[8] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), small_dyn, uint8(0x02));
+			}
+			function sfs() public pure returns (bytes memory) {
+				int24[9] memory small_fixed_signed;
+				small_fixed_signed[0] = -2;
+				small_fixed_signed[2] = 0xffff2;
+				small_fixed_signed[5] = -200;
+				small_fixed_signed[8] = 0xffff4;
+				return abi.encodePacked(uint8(0x01), small_fixed_signed, uint8(0x02));
+			}
+			function lf() public pure returns (bytes memory) {
+				uint248[5] memory large_fixed;
+				large_fixed[0] = 2**248-1;
+				large_fixed[1] = 0xfffff2;
+				large_fixed[2] = 2**248-2;
+				large_fixed[4] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), large_fixed, uint8(0x02));
+			}
+			function ld() public pure returns (bytes memory) {
+				uint248[] memory large_dyn = new uint248[](5);
+				large_dyn[0] = 2**248-1;
+				large_dyn[1] = 0xfffff2;
+				large_dyn[2] = 2**248-2;
+				large_dyn[4] = 0xfffff4;
+				return abi.encodePacked(uint8(0x01), large_dyn, uint8(0x02));
+			}
+		}
+	)";
+	for (auto v2: {false, true})
+	{
+		ALSO_VIA_YUL(
+			std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
+			compileAndRun(prefix + sourceCode, 0, "C");
+			bytes payload = encodeArgs(0xfffff1, 0, 0xfffff2, 0, 0, 0xfffff3, 0, 0, 0xfffff4);
+			bytes encoded = encodeArgs(0x20, 0x122, "\x01" + asString(payload) + "\x02");
+			ABI_CHECK(callContractFunction("sf()"), encoded);
+			ABI_CHECK(callContractFunction("sd()"), encoded);
+			ABI_CHECK(callContractFunction("sfs()"), encodeArgs(0x20, 0x122, "\x01" + asString(encodeArgs(
+				u256(-2), 0, 0xffff2, 0, 0, u256(-200), 0, 0, 0xffff4
+			)) + "\x02"));
+			payload = encodeArgs(
+				u256("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+				0xfffff2,
+				u256("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
+				0,
+				0xfffff4
+			);
+			ABI_CHECK(callContractFunction("lf()"), encodeArgs(0x20, 5 * 32 + 2, "\x01" + asString(encodeArgs(payload)) + "\x02"));
+			ABI_CHECK(callContractFunction("ld()"), encodeArgs(0x20, 5 * 32 + 2, "\x01" + asString(encodeArgs(payload)) + "\x02"));
+		)
+	}
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePacked_functionPtr)
+{
+	char const* sourceCode = R"(
+		contract C {
+			C other = C(0x1112131400000000000011121314000000000087);
+			function testDirect() public view returns (bytes memory) {
+				return abi.encodePacked(uint8(8), other.f, uint8(2));
+			}
+			function testFixedArray() public view returns (bytes memory) {
+				function () external pure returns (bytes memory)[1] memory x;
+				x[0] = other.f;
+				return abi.encodePacked(uint8(8), x, uint8(2));
+			}
+			function testDynamicArray() public view returns (bytes memory) {
+				function () external pure returns (bytes memory)[] memory x = new function() external pure returns (bytes memory)[](1);
+				x[0] = other.f;
+				return abi.encodePacked(uint8(8), x, uint8(2));
+			}
+			function f() public pure returns (bytes memory) {}
+		}
+	)";
+	for (auto v2: {false, true})
+	{
+		ALSO_VIA_YUL(
+			std::string prefix = "pragma abicoder " + std::string(v2 ? "v2" : "v1") + ";\n";
+			compileAndRun(prefix + sourceCode, 0, "C");
+			std::string directEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "02"));
+			ABI_CHECK(callContractFunction("testDirect()"), encodeArgs(0x20, directEncoding.size(), directEncoding));
+			std::string arrayEncoding = asString(fromHex("08" "1112131400000000000011121314000000000087" "26121ff0" "0000000000000000" "02"));
+			ABI_CHECK(callContractFunction("testFixedArray()"), encodeArgs(0x20, arrayEncoding.size(), arrayEncoding));
+			ABI_CHECK(callContractFunction("testDynamicArray()"), encodeArgs(0x20, arrayEncoding.size(), arrayEncoding));
+		)
+	}
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePackedV2_structs)
+{
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract C {
+			struct S {
+				uint8 a;
+				int16 b;
+				uint8[2] c;
+				int16[] d;
+			}
+			S s;
+			event E(S indexed);
+			constructor() {
+				s.a = 0x12;
+				s.b = -7;
+				s.c[0] = 2;
+				s.c[1] = 3;
+				s.d.push(-7);
+				s.d.push(-8);
+			}
+			function testStorage() public {
+				emit E(s);
+			}
+			function testMemory() public {
+				S memory m = s;
+				emit E(m);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C");
+		bytes structEnc = encodeArgs(int(0x12), u256(-7), int(2), int(3), u256(-7), u256(-8));
+		ABI_CHECK(callContractFunction("testStorage()"), encodeArgs());
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16,uint8[2],int16[]))")));
+		BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
+		ABI_CHECK(callContractFunction("testMemory()"), encodeArgs());
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16,uint8[2],int16[]))")));
+		BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePackedV2_nestedArray)
+{
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract C {
+			struct S {
+				uint8 a;
+				int16 b;
+			}
+			event E(S[2][][3] indexed);
+			function testNestedArrays() public {
+				S[2][][3] memory x;
+				x[1] = new S[2][](2);
+				x[1][0][0].a = 1;
+				x[1][0][0].b = 2;
+				x[1][0][1].a = 3;
+				x[1][1][1].b = 4;
+				emit E(x);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C");
+		bytes structEnc = encodeArgs(1, 2, 3, 0, 0, 0, 0, 4);
+		ABI_CHECK(callContractFunction("testNestedArrays()"), encodeArgs());
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E((uint8,int16)[2][][3])")));
+		BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(structEnc)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(abi_encodePackedV2_arrayOfStrings)
+{
+	char const* sourceCode = R"(
+		pragma abicoder v2;
+		contract C {
+			string[] x;
+			event E(string[] indexed);
+			constructor() {
+				x.push("abc");
+				x.push("0123456789012345678901234567890123456789");
+			}
+			function testStorage() public {
+				emit E(x);
+			}
+			function testMemory() public {
+				string[] memory y = x;
+				emit E(y);
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "C");
+		bytes arrayEncoding = encodeArgs("abc", "0123456789012345678901234567890123456789");
+		ABI_CHECK(callContractFunction("testStorage()"), encodeArgs());
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E(string[])")));
+		BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(arrayEncoding)));
+		ABI_CHECK(callContractFunction("testMemory()"), encodeArgs());
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 2);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("E(string[])")));
+		BOOST_CHECK_EQUAL(logTopic(0, 1), util::keccak256(asString(arrayEncoding)));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(code_access)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function lengths() public pure returns (bool) {
+				uint crLen = type(D).creationCode.length;
+				uint runLen = type(D).runtimeCode.length;
+				require(runLen < crLen);
+				require(crLen >= 0x20);
+				require(runLen >= 0x20);
+				return true;
+			}
+			function creation() public pure returns (bytes memory) {
+				return type(D).creationCode;
+			}
+			function runtime() public pure returns (bytes memory) {
+				return type(D).runtimeCode;
+			}
+			function runtimeAllocCheck() public pure returns (bytes memory) {
+				uint[] memory a = new uint[](2);
+				bytes memory c = type(D).runtimeCode;
+				uint[] memory b = new uint[](2);
+				a[0] = 0x1111;
+				a[1] = 0x2222;
+				b[0] = 0x3333;
+				b[1] = 0x4444;
+				return c;
+			}
+		}
+		contract D {
+			function f() public pure returns (uint) { return 7; }
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	ABI_CHECK(callContractFunction("lengths()"), encodeArgs(true));
+	bytes codeCreation = callContractFunction("creation()");
+	bytes codeRuntime1 = callContractFunction("runtime()");
+	bytes codeRuntime2 = callContractFunction("runtimeAllocCheck()");
+	ABI_CHECK(codeRuntime1, codeRuntime2);
+}
+
+BOOST_AUTO_TEST_CASE(contract_name)
+{
+	char const* sourceCode = R"(
+		contract C {
+			string public nameAccessor = type(C).name;
+			string public constant constantNameAccessor = type(C).name;
+
+			function name() public virtual pure returns (string memory) {
+				return type(C).name;
+			}
+		}
+		contract D is C {
+			function name() public override pure returns (string memory) {
+				return type(D).name;
+			}
+			function name2() public pure returns (string memory) {
+				return type(C).name;
+			}
+		}
+		contract ThisIsAVeryLongContractNameExceeding256bits {
+			string public nameAccessor = type(ThisIsAVeryLongContractNameExceeding256bits).name;
+			string public constant constantNameAccessor = type(ThisIsAVeryLongContractNameExceeding256bits).name;
+
+			function name() public pure returns (string memory) {
+				return type(ThisIsAVeryLongContractNameExceeding256bits).name;
+			}
+		}
+	)";
+
+	compileAndRun(sourceCode, 0, "C");
+	bytes argsC = encodeArgs(u256(0x20), u256(1), "C");
+	ABI_CHECK(callContractFunction("name()"), argsC);
+	ABI_CHECK(callContractFunction("nameAccessor()"), argsC);
+	ABI_CHECK(callContractFunction("constantNameAccessor()"), argsC);
+
+	compileAndRun(sourceCode, 0, "D");
+	bytes argsD = encodeArgs(u256(0x20), u256(1), "D");
+	ABI_CHECK(callContractFunction("name()"), argsD);
+	ABI_CHECK(callContractFunction("name2()"), argsC);
+
+	std::string longName = "ThisIsAVeryLongContractNameExceeding256bits";
+	compileAndRun(sourceCode, 0, longName);
+	bytes argsLong = encodeArgs(u256(0x20), u256(longName.length()), longName);
+	ABI_CHECK(callContractFunction("name()"), argsLong);
+	ABI_CHECK(callContractFunction("nameAccessor()"), argsLong);
+	ABI_CHECK(callContractFunction("constantNameAccessor()"), argsLong);
+}
+
+BOOST_AUTO_TEST_CASE(event_wrong_abi_name)
+{
+	char const* sourceCode = R"(
+		library ClientReceipt {
+			event Deposit(Test indexed _from, bytes32 indexed _id, uint _value);
+			function deposit(bytes32 _id) public {
+				Test a;
+				emit Deposit(a, _id, msg.value);
+			}
+		}
+		contract Test {
+			function f() public {
+				ClientReceipt.deposit("123");
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		compileAndRun(sourceCode, 0, "ClientReceipt", bytes());
+		compileAndRun(sourceCode, 0, "Test", bytes(), std::map<std::string, h160>{{":ClientReceipt", m_contractAddress}});
+
+		callContractFunction("f()");
+		BOOST_REQUIRE_EQUAL(numLogs(), 1);
+		BOOST_CHECK_EQUAL(logAddress(0), m_contractAddress);
+		BOOST_REQUIRE_EQUAL(numLogTopics(0), 3);
+		BOOST_CHECK_EQUAL(logTopic(0, 0), util::keccak256(std::string("Deposit(address,bytes32,uint256)")));
+	)
+}
+
+BOOST_AUTO_TEST_CASE(dirty_scratch_space_prior_to_constant_optimiser)
+{
+	char const* sourceCode = R"(
+		contract C {
+			event X(uint);
+			constructor() {
+				assembly {
+					// make scratch space dirty
+					mstore(0, 0x4242424242424242424242424242424242424242424242424242424242424242)
+				}
+				uint x = 0x0000000000001234123412431234123412412342112341234124312341234124;
+				// This is just to create many instances of x
+				unchecked { emit X(x + f() * g(tx.origin) ^ h(block.number)); }
+				assembly {
+					// make scratch space dirty
+					mstore(0, 0x4242424242424242424242424242424242424242424242424242424242424242)
+				}
+				emit X(x);
+			}
+			function f() internal pure returns (uint) {
+				return 0x0000000000001234123412431234123412412342112341234124312341234124;
+			}
+			function g(address a) internal pure returns (uint) {
+				unchecked { return uint(uint160(a)) * 0x0000000000001234123412431234123412412342112341234124312341234124; }
+			}
+			function h(uint a) internal pure returns (uint) {
+				unchecked { return a * 0x0000000000001234123412431234123412412342112341234124312341234124; }
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	BOOST_REQUIRE_EQUAL(numLogs(), 2);
+	BOOST_CHECK_EQUAL(logAddress(1), m_contractAddress);
+	ABI_CHECK(
+		logData(1),
+		encodeArgs(u256("0x0000000000001234123412431234123412412342112341234124312341234124"))
+	);
+}
+
+BOOST_AUTO_TEST_CASE(strip_reason_strings)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f(bool _x) public pure returns (uint) {
+				require(_x, "some reason");
+				return 7;
+			}
+			function g(bool _x) public pure returns (uint) {
+				string memory x = "some indirect reason";
+				require(_x, x);
+				return 8;
+			}
+			function f1(bool _x) public pure returns (uint) {
+				if (!_x) revert( /* */ "some reason" /* */ );
+				return 9;
+			}
+			function g1(bool _x) public pure returns (uint) {
+				string memory x = "some indirect reason";
+				if (!_x) revert(x);
+				return 10;
+			}
+		}
+	)";
+	ALSO_VIA_YUL(
+		m_revertStrings = RevertStrings::Default;
+		compileAndRun(sourceCode, 0, "C");
+
+		if (
+			m_optimiserSettings == OptimiserSettings::minimal() ||
+			m_optimiserSettings == OptimiserSettings::none()
+		)
+			// check that the reason string IS part of the binary.
+			BOOST_CHECK(util::toHex(m_output).find("736f6d6520726561736f6e") != std::string::npos);
+
+		m_revertStrings = RevertStrings::Strip;
+		compileAndRun(sourceCode, 0, "C");
+		// check that the reason string is NOT part of the binary.
+		BOOST_CHECK(util::toHex(m_output).find("736f6d6520726561736f6e") == std::string::npos);
+
+		ABI_CHECK(callContractFunction("f(bool)", true), encodeArgs(7));
+		ABI_CHECK(callContractFunction("f(bool)", false), encodeArgs());
+		ABI_CHECK(callContractFunction("g(bool)", true), encodeArgs(8));
+		ABI_CHECK(callContractFunction("g(bool)", false), encodeArgs());
+		ABI_CHECK(callContractFunction("f1(bool)", true), encodeArgs(9));
+		ABI_CHECK(callContractFunction("f1(bool)", false), encodeArgs());
+		ABI_CHECK(callContractFunction("g1(bool)", true), encodeArgs(10));
+		ABI_CHECK(callContractFunction("g1(bool)", false), encodeArgs());
+	)
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityExecutionFramework.cpp b/compiler/test/libsolidity/SolidityExecutionFramework.cpp
new file mode 100644
index 00000000..27fb39c1
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityExecutionFramework.cpp
@@ -0,0 +1,103 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2016
+ * Framework for executing Solidity contracts and testing them against C++ implementation.
+ */
+
+#include <test/libsolidity/SolidityExecutionFramework.h>
+#include <test/libsolidity/util/Common.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <libyul/Exceptions.h>
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <boost/test/framework.hpp>
+
+#include <cstdlib>
+#include <iostream>
+
+using namespace solidity;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::langutil;
+using namespace solidity::test;
+
+bytes SolidityExecutionFramework::multiSourceCompileContract(
+	std::map<std::string, std::string> const& _sourceCode,
+	std::optional<std::string> const& _mainSourceName,
+	std::string const& _contractName,
+	std::map<std::string, Address> const& _libraryAddresses
+)
+{
+	if (_mainSourceName.has_value())
+		solAssert(_sourceCode.find(_mainSourceName.value()) != _sourceCode.end(), "");
+
+	m_compiler.reset();
+	m_compiler.setSources(withPreamble(
+		_sourceCode,
+		solidity::test::CommonOptions::get().useABIEncoderV1 // _addAbicoderV1Pragma
+	));
+	m_compiler.setLibraries(_libraryAddresses);
+	m_compiler.setRevertStringBehaviour(m_revertStrings);
+	m_compiler.setEVMVersion(m_evmVersion);
+	m_compiler.setEOFVersion(m_eofVersion);
+	m_compiler.setOptimiserSettings(m_optimiserSettings);
+	m_compiler.enableEvmBytecodeGeneration(true);
+	m_compiler.setViaIR(m_compileViaYul);
+	m_compiler.setRevertStringBehaviour(m_revertStrings);
+	if (!m_appendCBORMetadata) {
+		m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+	}
+	m_compiler.setMetadataHash(m_metadataHash);
+
+	if (!m_compiler.compile())
+	{
+		// The testing framework expects an exception for
+		// "unimplemented" yul IR generation.
+		if (m_compileViaYul)
+			for (auto const& error: m_compiler.errors())
+				if (error->type() == langutil::Error::Type::CodeGenerationError)
+					BOOST_THROW_EXCEPTION(*error);
+		langutil::SourceReferenceFormatter{std::cerr, m_compiler, true, false}
+			.printErrorInformation(m_compiler.errors());
+		BOOST_ERROR("Compiling contract failed");
+	}
+	std::string contractName(_contractName.empty() ? m_compiler.lastContractName(_mainSourceName) : _contractName);
+	evmasm::LinkerObject obj = m_compiler.object(contractName);
+	BOOST_REQUIRE(obj.linkReferences.empty());
+	if (m_showMetadata)
+		std::cout << "metadata: " << m_compiler.metadata(contractName) << std::endl;
+	return obj.bytecode;
+}
+
+bytes SolidityExecutionFramework::compileContract(
+	std::string const& _sourceCode,
+	std::string const& _contractName,
+	std::map<std::string, Address> const& _libraryAddresses
+)
+{
+	return multiSourceCompileContract(
+		{{"", _sourceCode}},
+		std::nullopt,
+		_contractName,
+		_libraryAddresses
+	);
+}
diff --git a/compiler/test/libsolidity/SolidityExecutionFramework.h b/compiler/test/libsolidity/SolidityExecutionFramework.h
new file mode 100644
index 00000000..f91ba758
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityExecutionFramework.h
@@ -0,0 +1,93 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Framework for executing Solidity contracts and testing them against C++ implementation.
+ */
+
+#pragma once
+
+#include <functional>
+
+#include <test/ExecutionFramework.h>
+
+#include <libsolidity/interface/CompilerStack.h>
+#include <libsolidity/interface/DebugSettings.h>
+
+#include <libyul/YulStack.h>
+
+namespace solidity::frontend::test
+{
+
+class SolidityExecutionFramework: public solidity::test::ExecutionFramework
+{
+
+public:
+	SolidityExecutionFramework(): m_showMetadata(solidity::test::CommonOptions::get().showMetadata) {}
+	explicit SolidityExecutionFramework(
+		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
+		std::vector<boost::filesystem::path> const& _vmPaths,
+		bool _appendCBORMetadata = true
+	):
+		ExecutionFramework(_evmVersion, _vmPaths),
+		m_eofVersion(_eofVersion),
+		m_showMetadata(solidity::test::CommonOptions::get().showMetadata),
+		m_appendCBORMetadata(_appendCBORMetadata)
+	{}
+
+	bytes const& compileAndRunWithoutCheck(
+		std::map<std::string, std::string> const& _sourceCode,
+		u256 const& _value = 0,
+		std::string const& _contractName = "",
+		bytes const& _arguments = {},
+		std::map<std::string, solidity::test::Address> const& _libraryAddresses = {},
+		std::optional<std::string> const& _sourceName = std::nullopt
+	) override
+	{
+		bytes bytecode = multiSourceCompileContract(_sourceCode, _sourceName, _contractName, _libraryAddresses);
+		sendMessage(bytecode + _arguments, true, _value);
+		return m_output;
+	}
+
+	bytes compileContract(
+		std::string const& _sourceCode,
+		std::string const& _contractName = "",
+		std::map<std::string, solidity::test::Address> const& _libraryAddresses = {}
+	);
+
+	bytes multiSourceCompileContract(
+		std::map<std::string, std::string> const& _sources,
+		std::optional<std::string> const& _mainSourceName = std::nullopt,
+		std::string const& _contractName = "",
+		std::map<std::string, solidity::test::Address> const& _libraryAddresses = {}
+	);
+
+protected:
+	using CompilerStack = solidity::frontend::CompilerStack;
+	std::optional<uint8_t> m_eofVersion;
+	CompilerStack m_compiler;
+	bool m_compileViaYul = false;
+	bool m_showMetadata = false;
+	bool m_appendCBORMetadata = true;
+	CompilerStack::MetadataHash m_metadataHash = CompilerStack::MetadataHash::IPFS;
+	RevertStrings m_revertStrings = RevertStrings::Default;
+};
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityExpressionCompiler.cpp b/compiler/test/libsolidity/SolidityExpressionCompiler.cpp
new file mode 100644
index 00000000..1df1d943
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityExpressionCompiler.cpp
@@ -0,0 +1,718 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Unit tests for the solidity expression compiler.
+ */
+
+#include <string>
+
+#include <liblangutil/Scanner.h>
+#include <libsolidity/parsing/Parser.h>
+#include <libsolidity/analysis/NameAndTypeResolver.h>
+#include <libsolidity/analysis/Scoper.h>
+#include <libsolidity/analysis/SyntaxChecker.h>
+#include <libsolidity/analysis/DeclarationTypeChecker.h>
+#include <libsolidity/codegen/CompilerContext.h>
+#include <libsolidity/codegen/ExpressionCompiler.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/TypeProvider.h>
+#include <libsolidity/analysis/TypeChecker.h>
+#include <liblangutil/ErrorReporter.h>
+#include <libevmasm/LinkerObject.h>
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::evmasm;
+using namespace solidity::langutil;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+/// Helper class that extracts the first expression in an AST.
+class FirstExpressionExtractor: private ASTVisitor
+{
+public:
+	FirstExpressionExtractor(ASTNode& _node): m_expression(nullptr) { _node.accept(*this); }
+	Expression* expression() const { return m_expression; }
+private:
+	bool visit(Assignment& _expression) override { return checkExpression(_expression); }
+	bool visit(UnaryOperation& _expression) override { return checkExpression(_expression); }
+	bool visit(BinaryOperation& _expression) override { return checkExpression(_expression); }
+	bool visit(FunctionCall& _expression) override { return checkExpression(_expression); }
+	bool visit(MemberAccess& _expression) override { return checkExpression(_expression); }
+	bool visit(IndexAccess& _expression) override { return checkExpression(_expression); }
+	bool visit(Identifier& _expression) override { return checkExpression(_expression); }
+	bool visit(ElementaryTypeNameExpression& _expression) override { return checkExpression(_expression); }
+	bool visit(Literal& _expression) override { return checkExpression(_expression); }
+	bool checkExpression(Expression& _expression)
+	{
+		if (m_expression == nullptr)
+			m_expression = &_expression;
+		return false;
+	}
+private:
+	Expression* m_expression;
+};
+
+Declaration const& resolveDeclaration(
+	SourceUnit const& _sourceUnit,
+	std::vector<std::string> const& _namespacedName,
+	NameAndTypeResolver const& _resolver
+)
+{
+	ASTNode const* scope = &_sourceUnit;
+	// bracers are required, cause msvc couldn't handle this macro in for statement
+	for (std::string const& namePart: _namespacedName)
+	{
+		auto declarations = _resolver.resolveName(namePart, scope);
+		BOOST_REQUIRE(!declarations.empty());
+		BOOST_REQUIRE(scope = *declarations.begin());
+	}
+	BOOST_REQUIRE(scope);
+	return dynamic_cast<Declaration const&>(*scope);
+}
+
+bytes compileFirstExpression(
+	std::string const& _sourceCode,
+	std::vector<std::vector<std::string>> _functions = {},
+	std::vector<std::vector<std::string>> _localVariables = {}
+)
+{
+	std::string sourceCode = "pragma solidity >=0.0; // SPDX-License-Identifier: GPL-3\n" + _sourceCode;
+	CharStream stream(sourceCode, "");
+
+	ASTPointer<SourceUnit> sourceUnit;
+	try
+	{
+		ErrorList errors;
+		ErrorReporter errorReporter(errors);
+		sourceUnit = Parser(errorReporter, solidity::test::CommonOptions::get().evmVersion()).parse(stream);
+		if (!sourceUnit)
+			return bytes();
+	}
+	catch (boost::exception const& _e)
+	{
+		std::string msg = "Parsing source code failed with:\n" + boost::diagnostic_information(_e);
+		BOOST_FAIL(msg);
+	}
+	catch (...)
+	{
+		std::string msg = "Parsing source code failed with:\n" + boost::current_exception_diagnostic_information();
+		BOOST_FAIL(msg);
+	}
+
+	ErrorList errors;
+	ErrorReporter errorReporter(errors);
+	GlobalContext globalContext(solidity::test::CommonOptions::get().evmVersion());
+	Scoper::assignScopes(*sourceUnit);
+	BOOST_REQUIRE(SyntaxChecker(errorReporter, false).checkSyntax(*sourceUnit));
+	NameAndTypeResolver resolver(globalContext, solidity::test::CommonOptions::get().evmVersion(), errorReporter, false);
+	resolver.registerDeclarations(*sourceUnit);
+	BOOST_REQUIRE_MESSAGE(resolver.resolveNamesAndTypes(*sourceUnit), "Resolving names failed");
+	DeclarationTypeChecker declarationTypeChecker(errorReporter, solidity::test::CommonOptions::get().evmVersion());
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		BOOST_REQUIRE(declarationTypeChecker.check(*node));
+	TypeChecker typeChecker(solidity::test::CommonOptions::get().evmVersion(), errorReporter);
+	BOOST_REQUIRE(typeChecker.checkTypeRequirements(*sourceUnit));
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			FirstExpressionExtractor extractor(*contract);
+			BOOST_REQUIRE(extractor.expression() != nullptr);
+
+			CompilerContext context(
+				solidity::test::CommonOptions::get().evmVersion(),
+				RevertStrings::Default
+			);
+			context.resetVisitedNodes(contract);
+			context.setMostDerivedContract(*contract);
+			context.setArithmetic(Arithmetic::Wrapping);
+			size_t parametersSize = _localVariables.size(); // assume they are all one slot on the stack
+			context.adjustStackOffset(static_cast<int>(parametersSize));
+			for (std::vector<std::string> const& variable: _localVariables)
+				context.addVariable(
+					dynamic_cast<VariableDeclaration const&>(resolveDeclaration(*sourceUnit, variable, resolver)),
+					static_cast<unsigned>(parametersSize--)
+				);
+
+			ExpressionCompiler(
+				context,
+				solidity::test::CommonOptions::get().optimize
+			).compile(*extractor.expression());
+
+			for (std::vector<std::string> const& function: _functions)
+				context << context.functionEntryLabel(dynamic_cast<FunctionDefinition const&>(
+					resolveDeclaration(*sourceUnit, function, resolver)
+				));
+
+			context.appendMissingLowLevelFunctions();
+			// NOTE: We intentionally disable optimisations for utility functions to simplify the tests
+			context.appendYulUtilityFunctions({});
+			BOOST_REQUIRE(context.appendYulUtilityFunctionsRan());
+
+			BOOST_REQUIRE(context.assemblyPtr());
+			LinkerObject const& object = context.assemblyPtr()->assemble();
+			BOOST_REQUIRE(object.immutableReferences.empty());
+			bytes instructions = object.bytecode;
+			// debug
+			// cout << evmasm::disassemble(instructions) << endl;
+			return instructions;
+		}
+	BOOST_FAIL("No contract found in source.");
+	return bytes();
+}
+
+} // end anonymous namespace
+
+BOOST_AUTO_TEST_SUITE(SolidityExpressionCompiler)
+
+BOOST_AUTO_TEST_CASE(literal_true)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { bool x = true; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({uint8_t(Instruction::PUSH1), 0x1});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(literal_false)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { bool x = false; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation = solidity::test::CommonOptions::get().evmVersion().hasPush0() ?
+		bytes{uint8_t(Instruction::PUSH0)} :
+		bytes{uint8_t(Instruction::PUSH1), 0x0};
+
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(int_literal)
+{
+	char const* sourceCode = R"(
+		contract test {
+		  function f() public { uint x = 0x12345678901234567890; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({uint8_t(Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90,
+													   0x12, 0x34, 0x56, 0x78, 0x90});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(int_with_wei_ether_subdenomination)
+{
+	char const* sourceCode = R"(
+		contract test {
+			constructor() {
+				 uint x = 1 wei;
+			}
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({uint8_t(Instruction::PUSH1), 0x1});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(int_with_gwei_ether_subdenomination)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public {
+				uint x = 1 gwei;
+			}
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({uint8_t(Instruction::PUSH4), 0x3b, 0x9a, 0xca, 0x00});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(int_with_ether_ether_subdenomination)
+{
+	char const* sourceCode = R"(
+		contract test {
+			constructor() {
+				 uint x = 1 ether;
+			}
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation({uint8_t(Instruction::PUSH8), 0xd, 0xe0, 0xb6, 0xb3, 0xa7, 0x64, 0x00, 0x00});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(comparison)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { bool x = (0x10aa < 0x11aa) != true; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation;
+	if (solidity::test::CommonOptions::get().optimize)
+		expectation = {
+			uint8_t(Instruction::PUSH2), 0x11, 0xaa,
+			uint8_t(Instruction::PUSH2), 0x10, 0xaa,
+			uint8_t(Instruction::LT), uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH1), 0x1,
+			uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::EQ),
+			uint8_t(Instruction::ISZERO)
+		};
+	else
+		expectation = {
+			uint8_t(Instruction::PUSH1), 0x1, uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH2), 0x11, 0xaa,
+			uint8_t(Instruction::PUSH2), 0x10, 0xaa,
+			uint8_t(Instruction::LT), uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::EQ),
+			uint8_t(Instruction::ISZERO)
+		};
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(short_circuiting)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { bool x = true != (4 <= 8 + 10 || 9 != 2); }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation{
+		uint8_t(Instruction::PUSH1), 0x12, // 8 + 10
+		uint8_t(Instruction::PUSH1), 0x4,
+		uint8_t(Instruction::GT),
+		uint8_t(Instruction::ISZERO), // after this we have 4 <= 8 + 10
+		uint8_t(Instruction::DUP1),
+		uint8_t(Instruction::PUSH1), 0x11,
+		uint8_t(Instruction::JUMPI), // short-circuit if it is true
+		uint8_t(Instruction::POP),
+		uint8_t(Instruction::PUSH1), 0x2,
+		uint8_t(Instruction::PUSH1), 0x9,
+		uint8_t(Instruction::EQ),
+		uint8_t(Instruction::ISZERO), // after this we have 9 != 2
+		uint8_t(Instruction::JUMPDEST),
+		uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+		uint8_t(Instruction::PUSH1), 0x1, uint8_t(Instruction::ISZERO), uint8_t(Instruction::ISZERO),
+		uint8_t(Instruction::EQ),
+		uint8_t(Instruction::ISZERO)
+	};
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(arithmetic)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint y) public { unchecked { ((((((((y ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); } }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}});
+	bool hasPush0 = solidity::test::CommonOptions::get().evmVersion().hasPush0();
+	bytes push0Bytes = hasPush0 ?
+		bytes{uint8_t(Instruction::PUSH0)} :
+		bytes{uint8_t(Instruction::PUSH1), 0x0};
+	uint8_t size = hasPush0 ? 0x65: 0x67;
+	bytes panic =
+		bytes{
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::PUSH32)
+		} +
+		util::fromHex("4E487B7100000000000000000000000000000000000000000000000000000000") +
+		  push0Bytes +
+		bytes{
+			uint8_t(Instruction::MSTORE),
+			uint8_t(Instruction::PUSH1), 0x12,
+			uint8_t(Instruction::PUSH1), 0x4,
+			uint8_t(Instruction::MSTORE),
+			uint8_t(Instruction::PUSH1), 0x24
+		} +
+		push0Bytes +
+		bytes{
+			uint8_t(Instruction::REVERT),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::JUMP),
+			uint8_t(Instruction::JUMPDEST)
+		};
+
+	bytes expectation;
+	if (solidity::test::CommonOptions::get().optimize)
+		expectation = bytes{
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::PUSH1), 0x3,
+			uint8_t(Instruction::PUSH1), 0x5,
+			uint8_t(Instruction::DUP4),
+			uint8_t(Instruction::PUSH1), 0x8,
+			uint8_t(Instruction::XOR),
+			uint8_t(Instruction::PUSH1), 0x7,
+			uint8_t(Instruction::AND),
+			uint8_t(Instruction::PUSH1), 0x6,
+			uint8_t(Instruction::OR),
+			uint8_t(Instruction::SUB),
+			uint8_t(Instruction::PUSH1), 0x4,
+			uint8_t(Instruction::ADD),
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH1), 0x20,
+			uint8_t(Instruction::JUMPI),
+			uint8_t(Instruction::PUSH1), 0x1f,
+			uint8_t(Instruction::PUSH1), 0x36,
+			uint8_t(Instruction::JUMP),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::MOD),
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH1), 0x2e,
+			uint8_t(Instruction::JUMPI),
+			uint8_t(Instruction::PUSH1), 0x2d,
+			uint8_t(Instruction::PUSH1), 0x36,
+			uint8_t(Instruction::JUMP),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::DIV),
+			uint8_t(Instruction::PUSH1), 0x1,
+			uint8_t(Instruction::MUL),
+			uint8_t(Instruction::PUSH1), size,
+			uint8_t(Instruction::JUMP)
+		} + panic;
+	else
+		expectation = bytes{
+			uint8_t(Instruction::PUSH1), 0x1,
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::PUSH1), 0x3,
+			uint8_t(Instruction::PUSH1), 0x4,
+			uint8_t(Instruction::PUSH1), 0x5,
+			uint8_t(Instruction::PUSH1), 0x6,
+			uint8_t(Instruction::PUSH1), 0x7,
+			uint8_t(Instruction::PUSH1), 0x8,
+			uint8_t(Instruction::DUP9),
+			uint8_t(Instruction::XOR),
+			uint8_t(Instruction::AND),
+			uint8_t(Instruction::OR),
+			uint8_t(Instruction::SUB),
+			uint8_t(Instruction::ADD),
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH1), 0x22,
+			uint8_t(Instruction::JUMPI),
+			uint8_t(Instruction::PUSH1), 0x21,
+			uint8_t(Instruction::PUSH1), 0x36,
+			uint8_t(Instruction::JUMP),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::MOD),
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::ISZERO),
+			uint8_t(Instruction::PUSH1), 0x30,
+			uint8_t(Instruction::JUMPI),
+			uint8_t(Instruction::PUSH1), 0x2f,
+			uint8_t(Instruction::PUSH1), 0x36,
+			uint8_t(Instruction::JUMP),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::JUMPDEST),
+			uint8_t(Instruction::DIV),
+			uint8_t(Instruction::MUL),
+			uint8_t(Instruction::PUSH1), size,
+			uint8_t(Instruction::JUMP)
+		} + panic;
+
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(unary_operators)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(int y) public { unchecked { !(~- y == 2); } }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}});
+
+	bytes push0Bytes = solidity::test::CommonOptions::get().evmVersion().hasPush0() ?
+		bytes{uint8_t(Instruction::PUSH0)} :
+		bytes{uint8_t(Instruction::PUSH1), 0x0};
+
+	bytes expectation;
+	if (solidity::test::CommonOptions::get().optimize)
+		expectation = bytes{
+			uint8_t(Instruction::DUP1),
+		} +
+		push0Bytes +
+		bytes{
+			uint8_t(Instruction::SUB),
+			uint8_t(Instruction::NOT),
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::EQ),
+			uint8_t(Instruction::ISZERO)
+		};
+	else
+		expectation = bytes{
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::DUP2),
+		} +
+		push0Bytes +
+		bytes{
+			uint8_t(Instruction::SUB),
+			uint8_t(Instruction::NOT),
+			uint8_t(Instruction::EQ),
+			uint8_t(Instruction::ISZERO)
+		};
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(unary_inc_dec)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) public returns (uint x) { unchecked { x = --a ^ (a-- ^ (++a ^ a++)); } }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "x"}});
+
+	// Stack: a, x
+	bytes expectation{
+		uint8_t(Instruction::DUP2),
+		uint8_t(Instruction::DUP1),
+		uint8_t(Instruction::PUSH1), 0x1,
+		uint8_t(Instruction::ADD),
+		// Stack here: a x a (a+1)
+		uint8_t(Instruction::SWAP3),
+		uint8_t(Instruction::POP), // first ++
+		// Stack here: (a+1) x a
+		uint8_t(Instruction::DUP3),
+		uint8_t(Instruction::PUSH1), 0x1,
+		uint8_t(Instruction::ADD),
+		// Stack here: (a+1) x a (a+2)
+		uint8_t(Instruction::SWAP3),
+		uint8_t(Instruction::POP),
+		// Stack here: (a+2) x a
+		uint8_t(Instruction::DUP3), // second ++
+		uint8_t(Instruction::XOR),
+		// Stack here: (a+2) x a^(a+2)
+		uint8_t(Instruction::DUP3),
+		uint8_t(Instruction::DUP1),
+		uint8_t(Instruction::PUSH1), 0x1,
+		uint8_t(Instruction::SWAP1),
+		uint8_t(Instruction::SUB),
+		// Stack here: (a+2) x a^(a+2) (a+2) (a+1)
+		uint8_t(Instruction::SWAP4),
+		uint8_t(Instruction::POP), // first --
+		uint8_t(Instruction::XOR),
+		// Stack here: (a+1) x a^(a+2)^(a+2)
+		uint8_t(Instruction::DUP3),
+		uint8_t(Instruction::PUSH1), 0x1,
+		uint8_t(Instruction::SWAP1),
+		uint8_t(Instruction::SUB),
+		// Stack here: (a+1) x a^(a+2)^(a+2) a
+		uint8_t(Instruction::SWAP3),
+		uint8_t(Instruction::POP), // second ++
+		// Stack here: a x a^(a+2)^(a+2)
+		uint8_t(Instruction::DUP3), // will change
+		uint8_t(Instruction::XOR),
+		uint8_t(Instruction::SWAP1),
+		uint8_t(Instruction::POP),
+		uint8_t(Instruction::DUP1)
+	};
+	// Stack here: a x a^(a+2)^(a+2)^a
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(assignment)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a, uint b) public { unchecked { (a += b) * 2; } }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}});
+
+	// Stack: a, b
+	bytes expectation;
+	if (solidity::test::CommonOptions::get().optimize)
+		expectation = {
+			uint8_t(Instruction::DUP1),
+			uint8_t(Instruction::DUP3),
+			uint8_t(Instruction::ADD),
+			uint8_t(Instruction::SWAP2),
+			uint8_t(Instruction::POP),
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::MUL)
+		};
+	else
+		expectation = {
+			uint8_t(Instruction::PUSH1), 0x2,
+			uint8_t(Instruction::DUP2),
+			uint8_t(Instruction::DUP4),
+			uint8_t(Instruction::ADD),
+			// Stack here: a b 2 a+b
+			uint8_t(Instruction::SWAP3),
+			uint8_t(Instruction::POP),
+			uint8_t(Instruction::DUP3),
+			// Stack here: a+b b 2 a+b
+			uint8_t(Instruction::MUL)
+		};
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(negative_literals_8bits)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { int8 x = -0x80; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation(bytes({uint8_t(Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80));
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(negative_literals_16bits)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { int64 x = ~0xabc; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation(bytes({uint8_t(Instruction::PUSH32)}) + bytes(30, 0xff) + bytes{0xf5, 0x43});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(intermediately_overflowing_literals)
+{
+	// first literal itself is too large for 256 bits but it fits after all constant operations
+	// have been applied
+	char const* sourceCode = R"(
+		contract test {
+			function f() public { uint8 x = (0x00ffffffffffffffffffffffffffffffffffffffff * 0xffffffffffffffffffffffffff01) & 0xbf; }
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode);
+
+	bytes expectation(bytes({uint8_t(Instruction::PUSH1), 0xbf}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(blockhash)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public {
+				blockhash(3);
+			}
+		}
+	)";
+
+	bytes code = compileFirstExpression(sourceCode, {}, {});
+
+	bytes expectation({uint8_t(Instruction::PUSH1), 0x03,
+					   uint8_t(Instruction::BLOCKHASH)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(
+	blobhash,
+	*boost::unit_test::precondition(minEVMVersionCheck(EVMVersion::cancun()))
+)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public {
+				blobhash(3);
+			}
+		}
+	)";
+
+	bytes code = compileFirstExpression(sourceCode, {}, {});
+
+	bytes expectation({
+		uint8_t(Instruction::PUSH1), 0x03,
+		uint8_t(Instruction::BLOBHASH)
+	});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(gas_left)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public returns (uint256 val) {
+				return gasleft();
+			}
+		}
+	)";
+	bytes code = compileFirstExpression(sourceCode, {}, {});
+
+	bytes expectation = bytes({uint8_t(Instruction::GAS)});
+	BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+}
+
+BOOST_AUTO_TEST_CASE(selfbalance)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f() public returns (uint) {
+				return address(this).balance;
+			}
+		}
+	)";
+
+	bytes code = compileFirstExpression(sourceCode, {}, {});
+
+	if (solidity::test::CommonOptions::get().evmVersion().hasSelfBalance())
+	{
+		bytes expectation({uint8_t(Instruction::SELFBALANCE)});
+		BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end());
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityNameAndTypeResolution.cpp b/compiler/test/libsolidity/SolidityNameAndTypeResolution.cpp
new file mode 100644
index 00000000..4104d70c
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityNameAndTypeResolution.cpp
@@ -0,0 +1,512 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Unit tests for the name and type resolution of the solidity parser.
+ */
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <test/Common.h>
+
+#include <libsolidity/ast/AST.h>
+
+#include <libsolutil/Keccak256.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+
+using namespace solidity::langutil;
+
+namespace solidity::frontend::test
+{
+
+BOOST_FIXTURE_TEST_SUITE(SolidityNameAndTypeResolution, AnalysisFramework)
+
+BOOST_AUTO_TEST_CASE(function_no_implementation)
+{
+	char const* text = R"(
+		abstract contract test {
+			function functionName(bytes32 input) public virtual returns (bytes32 out);
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	std::vector<ASTPointer<ASTNode>> nodes = sourceUnit->nodes();
+	ContractDefinition* contract = dynamic_cast<ContractDefinition*>(nodes[1].get());
+	BOOST_REQUIRE(contract);
+	BOOST_CHECK(!contract->annotation().unimplementedDeclarations->empty());
+	BOOST_CHECK(!contract->definedFunctions()[0]->isImplemented());
+}
+
+BOOST_AUTO_TEST_CASE(abstract_contract)
+{
+	char const* text = R"(
+		abstract contract base { function foo() public virtual; }
+		contract derived is base { function foo() public override {} }
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	std::vector<ASTPointer<ASTNode>> nodes = sourceUnit->nodes();
+	ContractDefinition* base = dynamic_cast<ContractDefinition*>(nodes[1].get());
+	ContractDefinition* derived = dynamic_cast<ContractDefinition*>(nodes[2].get());
+	BOOST_REQUIRE(base);
+	BOOST_CHECK(!base->annotation().unimplementedDeclarations->empty());
+	BOOST_CHECK(!base->definedFunctions()[0]->isImplemented());
+	BOOST_REQUIRE(derived);
+	BOOST_CHECK(derived->annotation().unimplementedDeclarations->empty());
+	BOOST_CHECK(derived->definedFunctions()[0]->isImplemented());
+}
+
+BOOST_AUTO_TEST_CASE(abstract_contract_with_overload)
+{
+	char const* text = R"(
+		abstract contract base { function foo(bool) public virtual; }
+		abstract contract derived is base { function foo(uint) public {} }
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	std::vector<ASTPointer<ASTNode>> nodes = sourceUnit->nodes();
+	ContractDefinition* base = dynamic_cast<ContractDefinition*>(nodes[1].get());
+	ContractDefinition* derived = dynamic_cast<ContractDefinition*>(nodes[2].get());
+	BOOST_REQUIRE(base);
+	BOOST_CHECK(!base->annotation().unimplementedDeclarations->empty());
+	BOOST_REQUIRE(derived);
+	BOOST_CHECK(!derived->annotation().unimplementedDeclarations->empty());
+}
+
+BOOST_AUTO_TEST_CASE(implement_abstract_via_constructor)
+{
+	char const* text = R"(
+		abstract contract base { function foo() public virtual; }
+		abstract contract foo is base { constructor() {} }
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	std::vector<ASTPointer<ASTNode>> nodes = sourceUnit->nodes();
+	BOOST_CHECK_EQUAL(nodes.size(), 3);
+	ContractDefinition* derived = dynamic_cast<ContractDefinition*>(nodes[2].get());
+	BOOST_REQUIRE(derived);
+	BOOST_CHECK(!derived->annotation().unimplementedDeclarations->empty());
+}
+
+BOOST_AUTO_TEST_CASE(function_canonical_signature)
+{
+	char const* text = R"(
+		contract Test {
+			function foo(uint256 arg1, uint64 arg2, bool arg3) public returns (uint256 ret) {
+				ret = arg1 + arg2;
+			}
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			BOOST_CHECK_EQUAL("foo(uint256,uint64,bool)", functions[0]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(function_canonical_signature_type_aliases)
+{
+	char const* text = R"(
+		contract Test {
+			function boo(uint, bytes32, address) public returns (uint ret) {
+				ret = 5;
+			}
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			if (functions.empty())
+				continue;
+			BOOST_CHECK_EQUAL("boo(uint256,bytes32,address)", functions[0]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(function_external_types)
+{
+	char const* text = R"(
+		contract C {
+			uint a;
+		}
+		contract Test {
+			function boo(uint, bool, bytes8, bool[2] calldata, uint[] calldata, C, address[] calldata) external returns (uint ret) {
+				ret = 5;
+			}
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			if (functions.empty())
+				continue;
+			BOOST_CHECK_EQUAL("boo(uint256,bool,bytes8,bool[2],uint256[],address,address[])", functions[0]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(enum_external_type)
+{
+	char const* text = R"(
+		// test for bug #1801
+		contract Test {
+			enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
+			function boo(ActionChoices enumArg) external returns (uint ret) {
+				ret = 5;
+			}
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			if (functions.empty())
+				continue;
+			BOOST_CHECK_EQUAL("boo(uint8)", functions[0]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(external_struct_signatures)
+{
+	char const* text = R"(
+		pragma abicoder v2;
+		contract Test {
+			enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
+			struct Simple { uint i; }
+			struct Nested { X[2][] a; uint y; }
+			struct X { bytes32 x; Test t; Simple[] s; }
+			function f(ActionChoices, uint, Simple calldata) external {}
+			function g(Test, Nested calldata) external {}
+			function h(function(Nested memory) external returns (uint)[] calldata) external {}
+			function i(Nested[] calldata) external {}
+		}
+	)";
+	// Ignore analysis errors. This test only checks that correct signatures
+	// are generated for external structs, but they are not yet supported
+	// in code generation and therefore cause an error in the TypeChecker.
+	SourceUnit const* sourceUnit = runAnalysisAndExpectNoParsingErrors(text, false, true, true).first;
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			BOOST_REQUIRE(!functions.empty());
+			BOOST_CHECK_EQUAL("f(uint8,uint256,(uint256))", functions[0]->externalSignature());
+			BOOST_CHECK_EQUAL("g(address,((bytes32,address,(uint256)[])[2][],uint256))", functions[1]->externalSignature());
+			BOOST_CHECK_EQUAL("h(function[])", functions[2]->externalSignature());
+			BOOST_CHECK_EQUAL("i(((bytes32,address,(uint256)[])[2][],uint256)[])", functions[3]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(external_struct_signatures_in_libraries)
+{
+	char const* text = R"(
+		pragma abicoder v2;
+		library Test {
+			enum ActionChoices { GoLeft, GoRight, GoStraight, Sit }
+			struct Simple { uint i; }
+			struct Nested { X[2][] a; uint y; }
+			struct X { bytes32 x; Test t; Simple[] s; }
+			function f(ActionChoices, uint, Simple calldata) external {}
+			function g(Test, Nested calldata) external {}
+			function h(function(Nested memory) external returns (uint)[] calldata) external {}
+			function i(Nested[] calldata) external {}
+		}
+	)";
+	// Ignore analysis errors. This test only checks that correct signatures
+	// are generated for external structs, but calldata structs are not yet supported
+	// in code generation and therefore cause an error in the TypeChecker.
+	SourceUnit const* sourceUnit = runAnalysisAndExpectNoParsingErrors(text, false, true, true).first;
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			BOOST_REQUIRE(!functions.empty());
+			BOOST_CHECK_EQUAL("f(Test.ActionChoices,uint256,Test.Simple)", functions[0]->externalSignature());
+			BOOST_CHECK_EQUAL("g(Test,Test.Nested)", functions[1]->externalSignature());
+			BOOST_CHECK_EQUAL("h(function[])", functions[2]->externalSignature());
+			BOOST_CHECK_EQUAL("i(Test.Nested[])", functions[3]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(struct_with_mapping_in_library)
+{
+	char const* text = R"(
+		library Test {
+			struct Nested { mapping(uint => uint)[2][] a; uint y; }
+			struct X { Nested n; }
+			function f(X storage x) external {}
+		}
+	)";
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+		{
+			auto functions = contract->definedFunctions();
+			BOOST_REQUIRE(!functions.empty());
+			BOOST_CHECK_EQUAL("f(Test.X storage)", functions[0]->externalSignature());
+		}
+}
+
+BOOST_AUTO_TEST_CASE(state_variable_accessors)
+{
+	char const* text = R"(
+		contract test {
+			function fun() public {
+				uint64(2);
+			}
+			uint256 public foo;
+			mapping(uint=>bytes4) public map;
+			mapping(uint=>mapping(uint=>bytes4)) public multiple_map;
+		}
+	)";
+
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	ContractDefinition const* contract;
+	BOOST_REQUIRE((contract = retrieveContractByName(*sourceUnit, "test")) != nullptr);
+	FunctionTypePointer function = retrieveFunctionBySignature(*contract, "foo()");
+	BOOST_REQUIRE(function && function->hasDeclaration());
+	auto returnParams = function->returnParameterTypes();
+	BOOST_CHECK_EQUAL(returnParams.at(0)->canonicalName(), "uint256");
+	BOOST_CHECK(function->stateMutability() == StateMutability::View);
+
+	function = retrieveFunctionBySignature(*contract, "map(uint256)");
+	BOOST_REQUIRE(function && function->hasDeclaration());
+	auto params = function->parameterTypes();
+	BOOST_CHECK_EQUAL(params.at(0)->canonicalName(), "uint256");
+	returnParams = function->returnParameterTypes();
+	BOOST_CHECK_EQUAL(returnParams.at(0)->canonicalName(), "bytes4");
+	BOOST_CHECK(function->stateMutability() == StateMutability::View);
+
+	function = retrieveFunctionBySignature(*contract, "multiple_map(uint256,uint256)");
+	BOOST_REQUIRE(function && function->hasDeclaration());
+	params = function->parameterTypes();
+	BOOST_CHECK_EQUAL(params.at(0)->canonicalName(), "uint256");
+	BOOST_CHECK_EQUAL(params.at(1)->canonicalName(), "uint256");
+	returnParams = function->returnParameterTypes();
+	BOOST_CHECK_EQUAL(returnParams.at(0)->canonicalName(), "bytes4");
+	BOOST_CHECK(function->stateMutability() == StateMutability::View);
+}
+
+BOOST_AUTO_TEST_CASE(private_state_variable)
+{
+	char const* text = R"(
+		contract test {
+			function fun() public {
+				uint64(2);
+			}
+			uint256 private foo;
+			uint256 internal bar;
+		}
+	)";
+
+	auto [sourceUnit, errors] = runAnalysisAndExpectNoParsingErrors(text);
+	soltestAssert(sourceUnit);
+	soltestAssert(errors.empty(), "Unexpected error: " + formatErrors(errors));
+
+	ContractDefinition const* contract;
+	BOOST_CHECK((contract = retrieveContractByName(*sourceUnit, "test")) != nullptr);
+	FunctionTypePointer function;
+	function = retrieveFunctionBySignature(*contract, "foo()");
+	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of a private variable should not exist");
+	function = retrieveFunctionBySignature(*contract, "bar()");
+	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of an internal variable should not exist");
+}
+
+BOOST_AUTO_TEST_CASE(string)
+{
+	char const* sourceCode = R"(
+		contract C {
+			string s;
+			function f(string calldata x) external { s = x; }
+		}
+	)";
+	CHECK_SUCCESS(sourceCode);
+}
+
+BOOST_AUTO_TEST_CASE(dynamic_return_types_not_possible)
+{
+	char const* sourceCode = R"(
+		abstract contract C {
+			function f(uint) public virtual returns (string memory);
+			function g() public {
+				string memory x = this.f(2);
+				// we can assign to x but it is not usable.
+				bytes(x).length;
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion() == EVMVersion::homestead())
+		CHECK_ERROR(sourceCode, TypeError, "Type inaccessible dynamic type is not implicitly convertible to expected type string memory.");
+	else
+		CHECK_SUCCESS_NO_WARNINGS(sourceCode);
+}
+
+BOOST_AUTO_TEST_CASE(warn_nonpresent_pragma)
+{
+	char const* text = R"(
+		// SPDX-License-Identifier: GPL-3.0
+		contract C {}
+	)";
+	auto sourceAndError = runAnalysisAndExpectNoParsingErrors(text, true, false);
+	BOOST_REQUIRE(!sourceAndError.second.empty());
+	BOOST_REQUIRE(!!sourceAndError.first);
+	BOOST_CHECK(searchErrorMessage(*sourceAndError.second.front(), "Source file does not specify required compiler version!"));
+}
+
+BOOST_AUTO_TEST_CASE(getter_is_memory_type)
+{
+	char const* text = R"(
+		contract C {
+			struct S { string m; }
+			string[] public x;
+			S[] public y;
+		}
+	)";
+	CHECK_SUCCESS_NO_WARNINGS(text);
+	// Check that the getters return a memory strings, not a storage strings.
+	ContractDefinition const& c = dynamic_cast<ContractDefinition const&>(*compiler().ast("").nodes().at(1));
+	BOOST_CHECK(c.interfaceFunctions().size() == 2);
+	for (auto const& f: c.interfaceFunctions())
+	{
+		auto const& retType = f.second->returnParameterTypes().at(0);
+		BOOST_CHECK(retType->dataStoredIn(DataLocation::Memory));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(address_staticcall)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f() public view returns(bool) {
+				(bool success,) = address(0x4242).staticcall("");
+				return success;
+			}
+		}
+	)";
+
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+		CHECK_SUCCESS_NO_WARNINGS(sourceCode);
+	else
+		CHECK_ERROR(sourceCode, TypeError, "\"staticcall\" is not supported by the VM version.");
+}
+
+BOOST_AUTO_TEST_CASE(address_staticcall_value)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+	{
+		char const* sourceCode = R"(
+			contract C {
+				function f() public view {
+					address(0x4242).staticcall.value;
+				}
+			}
+		)";
+		CHECK_ERROR(sourceCode, TypeError, "Member \"value\" is only available for payable functions.");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(address_call_full_return_type)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f() public {
+				(bool success, bytes memory m) = address(0x4242).call("");
+				success; m;
+			}
+		}
+	)";
+
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+		CHECK_SUCCESS_NO_WARNINGS(sourceCode);
+	else
+		CHECK_ERROR(sourceCode, TypeError, "Type inaccessible dynamic type is not implicitly convertible to expected type bytes memory.");
+}
+
+BOOST_AUTO_TEST_CASE(address_delegatecall_full_return_type)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f() public {
+				(bool success, bytes memory m) = address(0x4242).delegatecall("");
+				success; m;
+			}
+		}
+	)";
+
+	if (solidity::test::CommonOptions::get().evmVersion().supportsReturndata())
+		CHECK_SUCCESS_NO_WARNINGS(sourceCode);
+	else
+		CHECK_ERROR(sourceCode, TypeError, "Type inaccessible dynamic type is not implicitly convertible to expected type bytes memory.");
+}
+
+
+BOOST_AUTO_TEST_CASE(address_staticcall_full_return_type)
+{
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+	{
+		char const* sourceCode = R"(
+			contract C {
+				function f() public view {
+					(bool success, bytes memory m) = address(0x4242).staticcall("");
+					success; m;
+				}
+			}
+		)";
+
+		CHECK_SUCCESS_NO_WARNINGS(sourceCode);
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityOptimizer.cpp b/compiler/test/libsolidity/SolidityOptimizer.cpp
new file mode 100644
index 00000000..27f1a7e8
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityOptimizer.cpp
@@ -0,0 +1,729 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Tests for the Solidity optimizer.
+ */
+
+#include <test/Metadata.h>
+#include <test/libsolidity/SolidityExecutionFramework.h>
+
+#include <libevmasm/Instruction.h>
+#include <libevmasm/Disassemble.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <chrono>
+#include <string>
+#include <tuple>
+#include <memory>
+#include <limits>
+
+using namespace solidity::util;
+using namespace solidity::evmasm;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+class OptimizerTestFramework: public SolidityExecutionFramework
+{
+public:
+	bytes const& compileAndRunWithOptimizer(
+		std::string const& _sourceCode,
+		u256 const& _value = 0,
+		std::string const& _contractName = "",
+		bool const _optimize = true,
+		unsigned const _optimizeRuns = 200
+	)
+	{
+		OptimiserSettings previousSettings = std::move(m_optimiserSettings);
+		// This uses "none" / "full" while most other test frameworks use
+		// "minimal" / "standard".
+		m_optimiserSettings = _optimize ? OptimiserSettings::full() : OptimiserSettings::none();
+		m_optimiserSettings.expectedExecutionsPerDeployment = _optimizeRuns;
+		bytes const& ret = compileAndRun(_sourceCode, _value, _contractName);
+		m_optimiserSettings = std::move(previousSettings);
+		return ret;
+	}
+
+	/// Compiles the source code with and without optimizing.
+	void compileBothVersions(
+		std::string const& _sourceCode,
+		u256 const& _value = 0,
+		std::string const& _contractName = "",
+		unsigned const _optimizeRuns = 200
+	)
+	{
+		m_nonOptimizedBytecode = compileAndRunWithOptimizer("pragma solidity >=0.0;\n" + _sourceCode, _value, _contractName, false, _optimizeRuns);
+		m_nonOptimizedContract = m_contractAddress;
+		m_optimizedBytecode = compileAndRunWithOptimizer("pragma solidity >=0.0;\n" + _sourceCode, _value, _contractName, true, _optimizeRuns);
+		size_t nonOptimizedSize = numInstructions(m_nonOptimizedBytecode);
+		size_t optimizedSize = numInstructions(m_optimizedBytecode);
+		BOOST_CHECK_MESSAGE(
+			_optimizeRuns < 50 || optimizedSize < nonOptimizedSize,
+			std::string("Optimizer did not reduce bytecode size. Non-optimized size: ") +
+			std::to_string(nonOptimizedSize) + " - optimized size: " +
+			std::to_string(optimizedSize)
+		);
+		m_optimizedContract = m_contractAddress;
+	}
+
+	template <class... Args>
+	void compareVersions(std::string _sig, Args const&... _arguments)
+	{
+		m_contractAddress = m_nonOptimizedContract;
+		bytes nonOptimizedOutput = callContractFunction(_sig, _arguments...);
+		m_gasUsedNonOptimized = m_gasUsed;
+		m_contractAddress = m_optimizedContract;
+		bytes optimizedOutput = callContractFunction(_sig, _arguments...);
+		m_gasUsedOptimized = m_gasUsed;
+		BOOST_CHECK_MESSAGE(!optimizedOutput.empty(), "No optimized output for " + _sig);
+		BOOST_CHECK_MESSAGE(!nonOptimizedOutput.empty(), "No un-optimized output for " + _sig);
+		BOOST_CHECK_MESSAGE(nonOptimizedOutput == optimizedOutput, "Computed values do not match."
+							"\nNon-Optimized: " + util::toHex(nonOptimizedOutput) +
+							"\nOptimized:     " + util::toHex(optimizedOutput));
+	}
+
+	/// @returns the number of instructions in the given bytecode, not taking the metadata hash
+	/// into account.
+	size_t numInstructions(bytes const& _bytecode, std::optional<Instruction> _which = std::optional<Instruction>{})
+	{
+		bytes realCode = bytecodeSansMetadata(_bytecode);
+		BOOST_REQUIRE_MESSAGE(!realCode.empty(), "Invalid or missing metadata in bytecode.");
+		size_t instructions = 0;
+		evmasm::eachInstruction(realCode, m_evmVersion, [&](Instruction _instr, u256 const&) {
+			if (!_which || *_which == _instr)
+				instructions++;
+		});
+		return instructions;
+	}
+
+protected:
+	u256 m_gasUsedOptimized;
+	u256 m_gasUsedNonOptimized;
+	bytes m_nonOptimizedBytecode;
+	bytes m_optimizedBytecode;
+	h160 m_optimizedContract;
+	h160 m_nonOptimizedContract;
+};
+
+BOOST_FIXTURE_TEST_SUITE(SolidityOptimizer, OptimizerTestFramework)
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint a) public returns (uint b) {
+				return a;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", u256(7));
+}
+
+BOOST_AUTO_TEST_CASE(identities)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f(int a) public returns (int b) {
+				return int(0) | (int(1) * (int(0) ^ (0 + a)));
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(int256)", u256(0x12334664));
+}
+
+BOOST_AUTO_TEST_CASE(unused_expressions)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint data;
+			function f() public returns (uint a, uint b) {
+				10 + 20;
+				data;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f()");
+}
+
+BOOST_AUTO_TEST_CASE(constant_folding_both_sides)
+{
+	// if constants involving the same associative and commutative operator are applied from both
+	// sides, the operator should be applied only once, because the expression compiler pushes
+	// literals as late as possible
+	char const* sourceCode = R"(
+		contract test {
+			function f(uint x) public returns (uint y) {
+				return 98 ^ (7 * ((1 | (x | 1000)) * 40) ^ 102);
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 7);
+}
+
+BOOST_AUTO_TEST_CASE(storage_access)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint8[40] data;
+			function f(uint x) public returns (uint y) {
+				data[2] = data[7] = uint8(x);
+				data[4] = data[2] * 10 + data[3];
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 7);
+}
+
+BOOST_AUTO_TEST_CASE(array_copy)
+{
+	char const* sourceCode = R"(
+		contract test {
+			bytes2[] data1;
+			bytes5[] data2;
+			function f(uint x) public returns (uint l, uint y) {
+				for (uint i = 0; i < msg.data.length; i++)
+					data1.push();
+				for (uint i = 0; i < msg.data.length; ++i)
+					data1[i] = msg.data[i];
+				data2 = data1;
+				l = data2.length;
+				y = uint(uint40(data2[x]));
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 0);
+	compareVersions("f(uint256)", 10);
+	compareVersions("f(uint256)", 35);
+}
+
+BOOST_AUTO_TEST_CASE(function_calls)
+{
+	char const* sourceCode = R"(
+		contract test {
+			function f1(uint x) public returns (uint) { unchecked { return x*x; } }
+			function f(uint x) public returns (uint) { unchecked { return f1(7+x) - this.f1(x**9); } }
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 0);
+	compareVersions("f(uint256)", 10);
+	compareVersions("f(uint256)", 36);
+}
+
+BOOST_AUTO_TEST_CASE(storage_write_in_loops)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint d;
+			function f(uint a) public returns (uint r) {
+				uint x = d;
+				for (uint i = 1; i < a * a; i++) {
+					r = d;
+					d = i;
+				}
+
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 0);
+	compareVersions("f(uint256)", 10);
+	compareVersions("f(uint256)", 36);
+}
+
+// Test disabled with https://github.com/ethereum/solidity/pull/762
+// Information in joining branches is not retained anymore.
+BOOST_AUTO_TEST_CASE(retain_information_in_branches)
+{
+	// This tests that the optimizer knows that we already have "z == keccak256(abi.encodePacked(y))" inside both branches.
+	char const* sourceCode = R"(
+		contract c {
+			bytes32 d;
+			uint a;
+			function f(uint x, bytes32 y) public returns (uint r_a, bytes32 r_d) {
+				bytes32 z = keccak256(abi.encodePacked(y));
+				if (x > 8) {
+					z = keccak256(abi.encodePacked(y));
+					a = x;
+				} else {
+					z = keccak256(abi.encodePacked(y));
+					a = x;
+				}
+				r_a = a;
+				r_d = d;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256,bytes32)", 0, "abc");
+	compareVersions("f(uint256,bytes32)", 8, "def");
+	compareVersions("f(uint256,bytes32)", 10, "ghi");
+
+	bytes optimizedBytecode = compileAndRunWithOptimizer(sourceCode, 0, "c", true);
+	size_t numSHA3s = 0;
+	eachInstruction(optimizedBytecode, m_evmVersion, [&](Instruction _instr, u256 const&) {
+		if (_instr == Instruction::KECCAK256)
+			numSHA3s++;
+	});
+// TEST DISABLED - OPTIMIZER IS NOT EFFECTIVE ON THIS ONE ANYMORE
+//	BOOST_CHECK_EQUAL(1, numSHA3s);
+}
+
+BOOST_AUTO_TEST_CASE(store_tags_as_unions)
+{
+	// This calls the same function from two sources and both calls have a certain Keccak-256 on
+	// the stack at the same position.
+	// Without storing tags as unions, the return from the shared function would not know where to
+	// jump and thus all jumpdests are forced to clear their state and we do not know about the
+	// sha3 anymore.
+	// Note that, for now, this only works if the functions have the same number of return
+	// parameters since otherwise, the return jump addresses are at different stack positions
+	// which triggers the "unknown jump target" situation.
+	char const* sourceCode = R"(
+		contract test {
+			bytes32 data;
+			function f(uint x, bytes32 y) external returns (uint r_a, bytes32 r_d) {
+				r_d = keccak256(abi.encodePacked(y));
+				shared(y);
+				r_d = keccak256(abi.encodePacked(y));
+				r_a = 5;
+			}
+			function g(uint x, bytes32 y) external returns (uint r_a, bytes32 r_d) {
+				r_d = keccak256(abi.encodePacked(y));
+				shared(y);
+				r_d = bytes32(uint(keccak256(abi.encodePacked(y))) + 2);
+				r_a = 7;
+			}
+			function shared(bytes32 y) internal {
+				data = keccak256(abi.encodePacked(y));
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256,bytes32)", 7, "abc");
+
+	bytes optimizedBytecode = compileAndRunWithOptimizer(sourceCode, 0, "test", true);
+	size_t numSHA3s = 0;
+	eachInstruction(optimizedBytecode, m_evmVersion, [&](Instruction _instr, u256 const&) {
+		if (_instr == Instruction::KECCAK256)
+			numSHA3s++;
+	});
+// TEST DISABLED UNTIL 93693404 IS IMPLEMENTED
+//	BOOST_CHECK_EQUAL(2, numSHA3s);
+}
+
+BOOST_AUTO_TEST_CASE(incorrect_storage_access_bug)
+{
+	// This bug appeared because a Keccak-256 operation with too low sequence number was used,
+	// resulting in memory not being rewritten before the Keccak-256. The fix was to
+	// take the max of the min sequence numbers when merging the states.
+	char const* sourceCode = R"(
+		contract C
+		{
+			mapping(uint => uint) data;
+			function f() public returns (uint)
+			{
+				if (data[block.timestamp] == 0)
+					data[type(uint).max - 6] = 5;
+				return data[block.timestamp];
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f()");
+}
+
+BOOST_AUTO_TEST_CASE(sequence_number_for_calls)
+{
+	// This is a test for a bug that was present because we did not increment the sequence
+	// number for CALLs - CALLs can read and write from memory (and DELEGATECALLs can do the same
+	// to storage), so the sequence number should be incremented.
+	char const* sourceCode = R"(
+		contract test {
+			function f(string memory a, string memory b) public returns (bool) { return sha256(bytes(a)) == sha256(bytes(b)); }
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(string,string)", 0x40, 0x80, 3, "abc", 3, "def");
+}
+
+BOOST_AUTO_TEST_CASE(computing_constants)
+{
+	char const* sourceCode = R"(
+		contract C {
+			uint m_a;
+			uint m_b;
+			uint m_c;
+			uint m_d;
+			constructor() {
+				set();
+			}
+			function set() public returns (uint) {
+				m_a = 0x77abc0000000000000000000000000000000000000000000000000000000001;
+				m_b = 0x817416927846239487123469187231298734162934871263941234127518276;
+				g();
+				return 1;
+			}
+			function g() public {
+				m_b = 0x817416927846239487123469187231298734162934871263941234127518276;
+				m_c = 0x817416927846239487123469187231298734162934871263941234127518276;
+				h();
+			}
+			function h() public {
+				m_d = 0xff05694900000000000000000000000000000000000000000000000000000000;
+			}
+			function get() public returns (uint ra, uint rb, uint rc, uint rd) {
+				ra = m_a;
+				rb = m_b;
+				rc = m_c;
+				rd = m_d;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode, 0, "C", 1);
+	compareVersions("get()");
+	compareVersions("set()");
+	compareVersions("get()");
+
+	bytes optimizedBytecode = compileAndRunWithOptimizer(sourceCode, 0, "C", true, 1);
+	bytes complicatedConstant = toBigEndian(u256("0x817416927846239487123469187231298734162934871263941234127518276"));
+	unsigned occurrences = 0;
+	for (auto iter = optimizedBytecode.cbegin(); iter < optimizedBytecode.cend(); ++occurrences)
+	{
+		iter = search(iter, optimizedBytecode.cend(), complicatedConstant.cbegin(), complicatedConstant.cend());
+		if (iter < optimizedBytecode.cend())
+			++iter;
+	}
+	BOOST_CHECK_EQUAL(2, occurrences);
+
+	bytes constantWithZeros = toBigEndian(u256("0x77abc0000000000000000000000000000000000000000000000000000000001"));
+	BOOST_CHECK(search(
+		optimizedBytecode.cbegin(),
+		optimizedBytecode.cend(),
+		constantWithZeros.cbegin(),
+		constantWithZeros.cend()
+	) == optimizedBytecode.cend());
+}
+
+
+BOOST_AUTO_TEST_CASE(constant_optimization_early_exit)
+{
+	// This tests that the constant optimizer does not try to find the best representation
+	// indefinitely but instead stops after some number of iterations.
+	char const* sourceCode = R"(
+	contract HexEncoding {
+		function hexEncodeTest(address addr) public returns (bytes32 ret) {
+			uint x = uint(uint160(addr)) / 2**32;
+
+			// Nibble interleave
+			x = x & 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff;
+			x = (x | (x * 2**64)) & 0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff;
+			x = (x | (x * 2**32)) & 0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff;
+			x = (x | (x * 2**16)) & 0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff;
+			x = (x | (x * 2** 8)) & 0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff;
+			x = (x | (x * 2** 4)) & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
+
+			// Hex encode
+			uint h = (x & 0x0808080808080808080808080808080808080808080808080808080808080808) / 8;
+			uint i = (x & 0x0404040404040404040404040404040404040404040404040404040404040404) / 4;
+			uint j = (x & 0x0202020202020202020202020202020202020202020202020202020202020202) / 2;
+			x = x + (h & (i | j)) * 0x27 + 0x3030303030303030303030303030303030303030303030303030303030303030;
+
+			// Store and load next batch
+			assembly {
+				mstore(0, x)
+			}
+			x = uint160(addr) * 2**96;
+
+			// Nibble interleave
+			x = x & 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff;
+			x = (x | (x * 2**64)) & 0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff;
+			x = (x | (x * 2**32)) & 0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff;
+			x = (x | (x * 2**16)) & 0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff;
+			x = (x | (x * 2** 8)) & 0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff;
+			x = (x | (x * 2** 4)) & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
+
+			// Hex encode
+			h = (x & 0x0808080808080808080808080808080808080808080808080808080808080808) / 8;
+			i = (x & 0x0404040404040404040404040404040404040404040404040404040404040404) / 4;
+			j = (x & 0x0202020202020202020202020202020202020202020202020202020202020202) / 2;
+			x = x + (h & (i | j)) * 0x27 + 0x3030303030303030303030303030303030303030303030303030303030303030;
+
+			// Store and hash
+			assembly {
+				mstore(32, x)
+				ret := keccak256(0, 40)
+			}
+		}
+	}
+	)";
+	auto start = std::chrono::steady_clock::now();
+	compileBothVersions(sourceCode);
+	double duration = std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+	// Since run time on an ASan build is not really realistic, we disable this test for those builds.
+	size_t maxDuration = 20;
+#if !defined(__SANITIZE_ADDRESS__) && defined(__has_feature)
+#if __has_feature(address_sanitizer)
+#define __SANITIZE_ADDRESS__ 1
+#endif
+#endif
+#if __SANITIZE_ADDRESS__
+	maxDuration = std::numeric_limits<size_t>::max();
+	BOOST_TEST_MESSAGE("Disabled constant optimizer run time check for address sanitizer build.");
+#endif
+	BOOST_CHECK_MESSAGE(duration <= double(maxDuration), "Compilation of constants took longer than 20 seconds.");
+	compareVersions("hexEncodeTest(address)", u256(0x123456789));
+}
+
+BOOST_AUTO_TEST_CASE(inconsistency)
+{
+	// This is a test of a bug in the optimizer.
+	char const* sourceCode = R"(
+		contract Inconsistency {
+			struct Value {
+				uint badnum;
+				uint number;
+			}
+
+			struct Container {
+				uint[] valueIndices;
+				Value[] values;
+			}
+
+			Container[] containers;
+			uint[] valueIndices;
+			uint INDEX_ZERO = 0;
+			uint  debug;
+
+			// Called with params: containerIndex=0, valueIndex=0
+			function levelIII(uint containerIndex, uint valueIndex) private {
+				Container storage container = containers[containerIndex];
+				Value storage value = container.values[valueIndex];
+				debug = container.valueIndices[value.number];
+			}
+			function levelII() private {
+				for (uint i = 0; i < valueIndices.length; i++) {
+					levelIII(INDEX_ZERO, valueIndices[i]);
+				}
+			}
+
+			function trigger() public returns (uint) {
+				Container storage container = containers.push();
+
+				container.values.push(Value({
+					badnum: 9000,
+					number: 0
+				}));
+
+				container.valueIndices.push();
+				valueIndices.push();
+
+				levelII();
+				return debug;
+			}
+
+			function DoNotCallButDoNotDelete() public {
+				levelII();
+				levelIII(1, 2);
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("trigger()");
+}
+
+BOOST_AUTO_TEST_CASE(dead_code_elimination_across_assemblies)
+{
+	// This tests that a runtime-function that is stored in storage in the constructor
+	// is not removed as part of dead code elimination.
+	char const* sourceCode = R"(
+		contract DCE {
+			function () internal returns (uint) stored;
+			constructor() {
+				stored = f;
+			}
+			function f() internal returns (uint) { return 7; }
+			function test() public returns (uint) { return stored(); }
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("test()");
+}
+
+BOOST_AUTO_TEST_CASE(invalid_state_at_control_flow_join)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			uint256 public totalSupply = 100;
+			function f() public returns (uint r) {
+				if (false)
+					r = totalSupply;
+				totalSupply -= 10;
+			}
+			function test() public returns (uint) {
+				f();
+				return this.totalSupply();
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("test()");
+}
+
+BOOST_AUTO_TEST_CASE(init_empty_dynamic_arrays)
+{
+	// This is not so much an optimizer test, but rather a test
+	// that allocating empty arrays is implemented efficiently.
+	// In particular, initializing a dynamic memory array does
+	// not use any memory.
+	char const* sourceCode = R"(
+		contract Test {
+			function f() public pure returns (uint r) {
+				uint[][] memory x = new uint[][](20000);
+				return x.length;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f()");
+	BOOST_CHECK_LE(m_gasUsedNonOptimized, 1900000);
+	BOOST_CHECK_LE(1600000, m_gasUsedNonOptimized);
+}
+
+BOOST_AUTO_TEST_CASE(optimise_multi_stores)
+{
+	char const* sourceCode = R"(
+		contract Test {
+			struct S { uint16 a; uint16 b; uint16[3] c; uint[] dyn; }
+			uint padding;
+			S[] s;
+			function f() public returns (uint16, uint16, uint16[3] memory, uint) {
+				uint16[3] memory c;
+				c[0] = 7;
+				c[1] = 8;
+				c[2] = 9;
+				s.push(S(1, 2, c, new uint[](4)));
+				return (s[0].a, s[0].b, s[0].c, s[0].dyn[2]);
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f()");
+	BOOST_CHECK_EQUAL(numInstructions(m_nonOptimizedBytecode, Instruction::SSTORE), 8);
+	BOOST_CHECK_EQUAL(numInstructions(m_optimizedBytecode, Instruction::SSTORE), 7);
+}
+
+BOOST_AUTO_TEST_CASE(optimise_constant_to_codecopy)
+{
+	char const* sourceCode = R"(
+		contract C {
+			// We use the state variable so that the functions won't be deemed identical
+			// and be optimised out to the same implementation.
+			uint a;
+			function f() public returns (uint) {
+				a = 1;
+				// This cannot be represented well with the `CalculateMethod`,
+				// hence the decision will be between `LiteralMethod` and `CopyMethod`.
+				return 0x1234123412431234123412412342112341234124312341234124;
+			}
+			function g() public returns (uint) {
+				a = 2;
+				return 0x1234123412431234123412412342112341234124312341234124;
+			}
+			function h() public returns (uint) {
+				a = 3;
+				return 0x1234123412431234123412412342112341234124312341234124;
+			}
+			function i() public returns (uint) {
+				a = 4;
+				return 0x1234123412431234123412412342112341234124312341234124;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode, 0, "C", 50);
+	compareVersions("f()");
+	compareVersions("g()");
+	compareVersions("h()");
+	compareVersions("i()");
+	// This is counting in the deployed code.
+	BOOST_CHECK_EQUAL(numInstructions(m_nonOptimizedBytecode, Instruction::CODECOPY), 0);
+	BOOST_CHECK_EQUAL(numInstructions(m_optimizedBytecode, Instruction::CODECOPY), 4);
+}
+
+BOOST_AUTO_TEST_CASE(byte_access)
+{
+	char const* sourceCode = R"(
+		contract C
+		{
+			function f(bytes32 x) public returns (bytes1 r)
+			{
+				assembly { r := and(byte(x, 31), 0xff) }
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(bytes32)", u256("0x1223344556677889900112233445566778899001122334455667788990011223"));
+}
+
+BOOST_AUTO_TEST_CASE(shift_optimizer_bug)
+{
+	char const* sourceCode = R"(
+		contract C
+		{
+			function f(uint x) public returns (uint)
+			{
+				return (x << 1) << type(uint).max;
+			}
+			function g(uint x) public returns (uint)
+			{
+				return (x >> 1) >> type(uint).max;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("f(uint256)", 7);
+	compareVersions("g(uint256)", u256(-1));
+}
+
+BOOST_AUTO_TEST_CASE(avoid_double_cleanup)
+{
+	char const* sourceCode = R"(
+		contract C {
+			receive() external payable {
+				abi.encodePacked(uint200(0));
+			}
+		}
+	)";
+	compileBothVersions(sourceCode, 0, "C", 50);
+	// Check that there is no double AND instruction in the resulting code
+	BOOST_CHECK_EQUAL(numInstructions(m_nonOptimizedBytecode, Instruction::AND), 1);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityParser.cpp b/compiler/test/libsolidity/SolidityParser.cpp
new file mode 100644
index 00000000..e0f010c4
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityParser.cpp
@@ -0,0 +1,615 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Unit tests for the solidity parser.
+ */
+
+#include <string>
+#include <memory>
+#include <liblangutil/Scanner.h>
+#include <libsolidity/parsing/Parser.h>
+#include <liblangutil/ErrorReporter.h>
+#include <test/Common.h>
+#include <test/libsolidity/ErrorCheck.h>
+#include <libsolidity/ast/ASTVisitor.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+ASTPointer<ContractDefinition> parseText(std::string const& _source, ErrorList& _errors)
+{
+	ErrorReporter errorReporter(_errors);
+	auto charStream = CharStream(_source, "");
+	ASTPointer<SourceUnit> sourceUnit = Parser(
+		errorReporter,
+		solidity::test::CommonOptions::get().evmVersion()
+	).parse(charStream);
+	if (!sourceUnit)
+		return ASTPointer<ContractDefinition>();
+	for (ASTPointer<ASTNode> const& node: sourceUnit->nodes())
+		if (ASTPointer<ContractDefinition> contract = std::dynamic_pointer_cast<ContractDefinition>(node))
+			return contract;
+	BOOST_FAIL("No contract found in source.");
+	return ASTPointer<ContractDefinition>();
+}
+
+bool successParse(std::string const& _source)
+{
+	ErrorList errors;
+	try
+	{
+		auto sourceUnit = parseText(_source, errors);
+		if (!sourceUnit)
+			return false;
+	}
+	catch (FatalError const& /*_exception*/)
+	{
+		if (Error::containsErrorOfType(errors, Error::Type::ParserError))
+			return false;
+	}
+	if (Error::containsErrorOfType(errors, Error::Type::ParserError))
+		return false;
+
+	BOOST_CHECK(!Error::containsErrors(errors));
+	return true;
+}
+
+Error getError(std::string const& _source)
+{
+	ErrorList errors;
+	try
+	{
+		parseText(_source, errors);
+	}
+	catch (FatalError const& /*_exception*/)
+	{
+		// no-op
+	}
+	Error const* error = Error::containsErrorOfType(errors, Error::Type::ParserError);
+	BOOST_REQUIRE(error);
+	return *error;
+}
+
+void checkFunctionNatspec(
+	FunctionDefinition const* _function,
+	std::string const& _expectedDoc
+)
+{
+	auto doc = _function->documentation()->text();
+	BOOST_CHECK_MESSAGE(doc != nullptr, "Function does not have Natspec Doc as expected");
+	BOOST_CHECK_EQUAL(*doc, _expectedDoc);
+}
+
+}
+
+#define CHECK_PARSE_ERROR(source, substring) \
+do \
+{\
+	Error err = getError((source)); \
+	BOOST_CHECK(searchErrorMessage(err, (substring))); \
+}\
+while(0)
+
+
+BOOST_AUTO_TEST_SUITE(SolidityParser)
+
+BOOST_AUTO_TEST_CASE(reserved_keywords)
+{
+	BOOST_CHECK(!TokenTraits::isReservedKeyword(Token::Identifier));
+	BOOST_CHECK(TokenTraits::isReservedKeyword(Token::After));
+	BOOST_CHECK(!TokenTraits::isReservedKeyword(Token::Unchecked));
+	BOOST_CHECK(TokenTraits::isReservedKeyword(Token::Var));
+	BOOST_CHECK(TokenTraits::isReservedKeyword(Token::Reference));
+	BOOST_CHECK(!TokenTraits::isReservedKeyword(Token::Illegal));
+}
+
+BOOST_AUTO_TEST_CASE(function_natspec_documentation)
+{
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is a test function
+			function functionName(bytes32 input) public returns (bytes32 out) {}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	FunctionDefinition const* function = nullptr;
+	auto functions = contract->definedFunctions();
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is a test function");
+}
+
+BOOST_AUTO_TEST_CASE(function_normal_comments)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			// We won't see this comment
+			function functionName(bytes32 input) public returns (bytes32 out) {}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	BOOST_CHECK_MESSAGE(function->documentation() == nullptr,
+						"Should not have gotten a Natspecc comment for this function");
+}
+
+BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is test function 1
+			function functionName1(bytes32 input) public returns (bytes32 out) {}
+			/// This is test function 2
+			function functionName2(bytes32 input) public returns (bytes32 out) {}
+			// nothing to see here
+			function functionName3(bytes32 input) public returns (bytes32 out) {}
+			/// This is test function 4
+			function functionName4(bytes32 input) public returns (bytes32 out) {}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is test function 1");
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(1), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is test function 2");
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(2), "Failed to retrieve function");
+	BOOST_CHECK_MESSAGE(function->documentation() == nullptr,
+						"Should not have gotten natspec comment for functionName3()");
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(3), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is test function 4");
+}
+
+BOOST_AUTO_TEST_CASE(multiline_function_documentation)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			/// This is a test function
+			/// and it has 2 lines
+			function functionName1(bytes32 input) public returns (bytes32 out) {}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is a test function\n"
+						 " and it has 2 lines");
+}
+
+BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			/// fun1 description
+			function fun1(uint256 a) {
+				uint b;
+				// I should not interfere with actual natspec comments (natspec comments on local variables not allowed anymore)
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+			/// This is a test function
+			/// and it has 2 lines
+			function fun(bytes32 input) public returns (bytes32 out) {}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	checkFunctionNatspec(function, "fun1 description");
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(1), "Failed to retrieve function");
+	checkFunctionNatspec(function, "This is a test function\n"
+						 " and it has 2 lines");
+}
+
+BOOST_AUTO_TEST_CASE(natspec_docstring_between_keyword_and_signature)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function ///I am in the wrong place
+			fun1(uint256 a) {
+				uint b;
+				// I should not interfere with actual natspec comments (natspec comments on local variables not allowed anymore)
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	BOOST_CHECK_MESSAGE(!function->documentation(),
+						"Shouldn't get natspec docstring for this function");
+}
+
+BOOST_AUTO_TEST_CASE(natspec_docstring_after_signature)
+{
+	FunctionDefinition const* function = nullptr;
+	char const* text = R"(
+		contract test {
+			uint256 stateVar;
+			function fun1(uint256 a) {
+				// I should have been above the function signature (natspec comments on local variables not allowed anymore)
+				uint b;
+				// I should not interfere with actual natspec comments (natspec comments on local variables not allowed anymore)
+				uint256 c;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+	ErrorList errors;
+	ASTPointer<ContractDefinition> contract = parseText(text, errors);
+	auto functions = contract->definedFunctions();
+
+	BOOST_REQUIRE_MESSAGE(function = functions.at(0), "Failed to retrieve function");
+	BOOST_CHECK_MESSAGE(!function->documentation(),
+						"Shouldn't get natspec docstring for this function");
+}
+
+BOOST_AUTO_TEST_CASE(variable_definition)
+{
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint b;
+				uint256 c;
+				mapping(address=>bytes32) d;
+				customtype varname;
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(variable_definition_with_initialization)
+{
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint b = 2;
+				uint256 c = 0x87;
+				mapping(address=>bytes32) d;
+				bytes7 name = "Solidity";
+				customtype varname;
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(operator_expression)
+{
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 x = (1 + 4) || false && (1 - 12) + -9;
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(complex_expression)
+{
+	char const* text = R"(
+		contract test {
+			function fun(uint256 a) {
+				uint256 x = (1 + 4).member(++67)[a/=9] || true;
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(statement_starting_with_type_conversion)
+{
+	char const* text = R"(
+		contract test {
+			function fun() {
+				uint64(2);
+				uint64[7](3);
+				uint64[](3);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(type_conversion_to_dynamic_array)
+{
+	char const* text = R"(
+		contract test {
+			function fun() {
+				uint x = uint64[](3);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(import_directive)
+{
+	char const* text = R"(
+		import "abc";
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_contracts)
+{
+	char const* text = R"(
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract test2 {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_contracts_and_imports)
+{
+	char const* text = R"(
+		import "abc";
+		contract test {
+			function fun() {
+				uint64(2);
+			}
+		}
+		import "def";
+		contract test2 {
+			function fun() {
+				uint64(2);
+			}
+		}
+		import "ghi";
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(contract_inheritance)
+{
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(contract_multiple_inheritance)
+{
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base, nonExisting {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(contract_multiple_inheritance_with_arguments)
+{
+	char const* text = R"(
+		contract base {
+			function fun() {
+				uint64(2);
+			}
+		}
+		contract derived is base(2), nonExisting("abc", "def", base.fun()) {
+			function fun() {
+				uint64(2);
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(keyword_is_reserved)
+{
+	auto keywords = {
+		"after",
+		"alias",
+		"apply",
+		"auto",
+		"byte",
+		"case",
+		"copyof",
+		"default",
+		"define",
+		"final",
+		"implements",
+		"in",
+		"inline",
+		"let",
+		"macro",
+		"match",
+		"mutable",
+		"null",
+		"of",
+		"partial",
+		"promise",
+		"reference",
+		"relocatable",
+		"sealed",
+		"sizeof",
+		"static",
+		"supports",
+		"switch",
+		"typedef",
+		"typeof",
+		"var"
+	};
+
+	BOOST_CHECK_EQUAL(std::size(keywords), static_cast<int>(Token::Var) - static_cast<int>(Token::After) + 1);
+
+	for (auto const& keyword: keywords)
+	{
+		auto text = std::string("contract ") + keyword + " {}";
+		CHECK_PARSE_ERROR(text.c_str(), std::string("Expected identifier but got reserved keyword '") + keyword + "'");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(member_access_parser_ambiguity)
+{
+	char const* text = R"(
+		contract C {
+			struct S { uint a; uint b; uint[][][] c; }
+			function f() {
+				C.S x;
+				C.S memory y;
+				C.S[10] memory z;
+				C.S[10](x);
+				x.a = 2;
+				x.c[1][2][3] = 9;
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(using_for)
+{
+	char const* text = R"(
+		contract C {
+			struct s { uint a; }
+			using LibraryName for uint;
+			using Library2 for *;
+			using Lib for s;
+			function f() {
+			}
+		}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(complex_import)
+{
+	char const* text = R"(
+		import "abc" as x;
+		import * as x from "abc";
+		import {a as b, c as d, f} from "def";
+		contract x {}
+	)";
+	BOOST_CHECK(successParse(text));
+}
+
+BOOST_AUTO_TEST_CASE(inline_asm_end_location)
+{
+	auto sourceCode = std::string(R"(
+	contract C {
+		function f() public pure returns (uint y) {
+			uint a;
+			assembly { a := 0x12345678 }
+			uint z = a;
+			y = z;
+		}
+	}
+	)");
+	ErrorList errors;
+	auto contract = parseText(sourceCode, errors);
+
+	class CheckInlineAsmLocation: public ASTConstVisitor
+	{
+	public:
+		explicit CheckInlineAsmLocation(std::string _sourceCode): m_sourceCode(_sourceCode) {}
+		bool visited = false;
+		bool visit(InlineAssembly const& _inlineAsm) override
+		{
+			auto loc = _inlineAsm.location();
+			auto asmStr = m_sourceCode.substr(static_cast<size_t>(loc.start), static_cast<size_t>(loc.end - loc.start));
+			BOOST_CHECK_EQUAL(asmStr, "assembly { a := 0x12345678 }");
+			visited = true;
+
+			return false;
+		}
+		std::string m_sourceCode;
+	};
+
+	CheckInlineAsmLocation visitor{sourceCode};
+	contract->accept(visitor);
+
+	BOOST_CHECK_MESSAGE(visitor.visited, "No inline asm block found?!");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SolidityTypes.cpp b/compiler/test/libsolidity/SolidityTypes.cpp
new file mode 100644
index 00000000..e4523292
--- /dev/null
+++ b/compiler/test/libsolidity/SolidityTypes.cpp
@@ -0,0 +1,287 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ * Unit tests for the type system of Solidity.
+ */
+
+#include <libsolidity/ast/Types.h>
+#include <libsolidity/ast/TypeProvider.h>
+#include <libsolidity/ast/AST.h>
+#include <libsolutil/Keccak256.h>
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(SolidityTypes)
+
+BOOST_AUTO_TEST_CASE(int_types)
+{
+	BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::Int, 0, 0)) == *TypeProvider::integer(256, IntegerType::Modifier::Signed));
+	for (unsigned i = 8; i <= 256; i += 8)
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::IntM, i, 0)) == *TypeProvider::integer(i, IntegerType::Modifier::Signed));
+}
+
+BOOST_AUTO_TEST_CASE(uint_types)
+{
+	BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::UInt, 0, 0)) == *TypeProvider::integer(256, IntegerType::Modifier::Unsigned));
+	for (unsigned i = 8; i <= 256; i += 8)
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::UIntM, i, 0)) == *TypeProvider::integer(i, IntegerType::Modifier::Unsigned));
+}
+
+BOOST_AUTO_TEST_CASE(byte_types)
+{
+	for (unsigned i = 1; i <= 32; i++)
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::BytesM, i, 0)) == *TypeProvider::fixedBytes(i));
+}
+
+BOOST_AUTO_TEST_CASE(fixed_types)
+{
+	BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::Fixed, 0, 0)) == *TypeProvider::fixedPoint(128, 18, FixedPointType::Modifier::Signed));
+	for (unsigned i = 8; i <= 256; i += 8)
+	{
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::FixedMxN, i, 0)) == *TypeProvider::fixedPoint(i, 0, FixedPointType::Modifier::Signed));
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::FixedMxN, i, 2)) == *TypeProvider::fixedPoint(i, 2, FixedPointType::Modifier::Signed));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(ufixed_types)
+{
+	BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::UFixed, 0, 0)) == *TypeProvider::fixedPoint(128, 18, FixedPointType::Modifier::Unsigned));
+	for (unsigned i = 8; i <= 256; i += 8)
+	{
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::UFixedMxN, i, 0)) == *TypeProvider::fixedPoint(i, 0, FixedPointType::Modifier::Unsigned));
+		BOOST_CHECK(*TypeProvider::fromElementaryTypeName(ElementaryTypeNameToken(Token::UFixedMxN, i, 2)) == *TypeProvider::fixedPoint(i, 2, FixedPointType::Modifier::Unsigned));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(storage_layout_simple)
+{
+	MemberList members(MemberList::MemberMap({
+		{"first", TypeProvider::fromElementaryTypeName("uint128")},
+		{"second", TypeProvider::fromElementaryTypeName("uint120")},
+		{"wraps", TypeProvider::fromElementaryTypeName("uint16")}
+	}));
+	BOOST_REQUIRE_EQUAL(u256(2), members.storageSize());
+	BOOST_REQUIRE(members.memberStorageOffset("first") != nullptr);
+	BOOST_REQUIRE(members.memberStorageOffset("second") != nullptr);
+	BOOST_REQUIRE(members.memberStorageOffset("wraps") != nullptr);
+	BOOST_CHECK(*members.memberStorageOffset("first") == std::make_pair(u256(0), unsigned(0)));
+	BOOST_CHECK(*members.memberStorageOffset("second") == std::make_pair(u256(0), unsigned(16)));
+	BOOST_CHECK(*members.memberStorageOffset("wraps") == std::make_pair(u256(1), unsigned(0)));
+}
+
+BOOST_AUTO_TEST_CASE(storage_layout_mapping)
+{
+	MemberList members(MemberList::MemberMap({
+		{"first", TypeProvider::fromElementaryTypeName("uint128")},
+		{"second", TypeProvider::mapping(
+			TypeProvider::fromElementaryTypeName("uint8"),
+			"",
+			TypeProvider::fromElementaryTypeName("uint8"),
+			""
+		)},
+		{"third", TypeProvider::fromElementaryTypeName("uint16")},
+		{"final", TypeProvider::mapping(
+			TypeProvider::fromElementaryTypeName("uint8"),
+			"",
+			TypeProvider::fromElementaryTypeName("uint8"),
+			""
+		)},
+	}));
+	BOOST_REQUIRE_EQUAL(u256(4), members.storageSize());
+	BOOST_REQUIRE(members.memberStorageOffset("first") != nullptr);
+	BOOST_REQUIRE(members.memberStorageOffset("second") != nullptr);
+	BOOST_REQUIRE(members.memberStorageOffset("third") != nullptr);
+	BOOST_REQUIRE(members.memberStorageOffset("final") != nullptr);
+	BOOST_CHECK(*members.memberStorageOffset("first") == std::make_pair(u256(0), unsigned(0)));
+	BOOST_CHECK(*members.memberStorageOffset("second") == std::make_pair(u256(1), unsigned(0)));
+	BOOST_CHECK(*members.memberStorageOffset("third") == std::make_pair(u256(2), unsigned(0)));
+	BOOST_CHECK(*members.memberStorageOffset("final") == std::make_pair(u256(3), unsigned(0)));
+}
+
+BOOST_AUTO_TEST_CASE(storage_layout_arrays)
+{
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(1), 32).storageSize() == 1);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(1), 33).storageSize() == 2);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(2), 31).storageSize() == 2);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(7), 8).storageSize() == 2);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(7), 9).storageSize() == 3);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(31), 9).storageSize() == 9);
+	BOOST_CHECK(ArrayType(DataLocation::Storage, TypeProvider::fixedBytes(32), 9).storageSize() == 9);
+}
+
+BOOST_AUTO_TEST_CASE(type_identifier_escaping)
+{
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier("("), "$_");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier(")"), "_$");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier(","), "_$_");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier("$"), "$$$");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier(")$("), "_$$$$$_");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier("()"), "$__$");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier("(,)"), "$__$__$");
+	BOOST_CHECK_EQUAL(Type::escapeIdentifier("(,$,)"), "$__$_$$$_$__$");
+	BOOST_CHECK_EQUAL(
+		Type::escapeIdentifier("((__(_$_$$,__($$,,,$$),$,,,)))$$,$$"),
+		"$_$___$__$$$_$$$$$$_$___$_$$$$$$_$__$__$_$$$$$$_$_$_$$$_$__$__$__$_$_$$$$$$$_$_$$$$$$"
+	);
+}
+
+BOOST_AUTO_TEST_CASE(type_identifiers)
+{
+	int64_t id = 0;
+
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("uint128")->identifier(), "t_uint128");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("int128")->identifier(), "t_int128");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("address")->identifier(), "t_address");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("uint8")->identifier(), "t_uint8");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("ufixed64x2")->identifier(), "t_ufixed64x2");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("fixed128x8")->identifier(), "t_fixed128x8");
+	BOOST_CHECK_EQUAL(RationalNumberType(rational(7, 1)).identifier(), "t_rational_7_by_1");
+	BOOST_CHECK_EQUAL(RationalNumberType(rational(200, 77)).identifier(), "t_rational_200_by_77");
+	BOOST_CHECK_EQUAL(RationalNumberType(rational(2 * 200, 2 * 77)).identifier(), "t_rational_200_by_77");
+	BOOST_CHECK_EQUAL(RationalNumberType(rational(-2 * 200, 2 * 77)).identifier(), "t_rational_minus_200_by_77");
+	BOOST_CHECK_EQUAL(
+		StringLiteralType(Literal(++id, SourceLocation{}, Token::StringLiteral, std::make_shared<std::string>("abc - def"))).identifier(),
+		 "t_stringliteral_196a9142ee0d40e274a6482393c762b16dd8315713207365e1e13d8d85b74fc4"
+	);
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes1")->identifier(), "t_bytes1");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes8")->identifier(), "t_bytes8");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes32")->identifier(), "t_bytes32");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bool")->identifier(), "t_bool");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes")->identifier(), "t_bytes_storage_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes memory")->identifier(), "t_bytes_memory_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes storage")->identifier(), "t_bytes_storage_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("bytes calldata")->identifier(), "t_bytes_calldata_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("string")->identifier(), "t_string_storage_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("string memory")->identifier(), "t_string_memory_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("string storage")->identifier(), "t_string_storage_ptr");
+	BOOST_CHECK_EQUAL(TypeProvider::fromElementaryTypeName("string calldata")->identifier(), "t_string_calldata_ptr");
+	ArrayType largeintArray(DataLocation::Memory, TypeProvider::fromElementaryTypeName("int128"), u256("2535301200456458802993406410752"));
+	BOOST_CHECK_EQUAL(largeintArray.identifier(), "t_array$_t_int128_$2535301200456458802993406410752_memory_ptr");
+	Type const* stringArray = TypeProvider::array(DataLocation::Storage, TypeProvider::fromElementaryTypeName("string"), u256("20"));
+	Type const* multiArray = TypeProvider::array(DataLocation::Storage, stringArray);
+	BOOST_CHECK_EQUAL(multiArray->identifier(), "t_array$_t_array$_t_string_storage_$20_storage_$dyn_storage_ptr");
+
+	ContractDefinition c(++id, SourceLocation{}, std::make_shared<std::string>("MyContract$"), SourceLocation{}, {}, {}, {}, ContractKind::Contract);
+	BOOST_CHECK_EQUAL(c.type()->identifier(), "t_type$_t_contract$_MyContract$$$_$2_$");
+	BOOST_CHECK_EQUAL(ContractType(c, true).identifier(), "t_super$_MyContract$$$_$2");
+
+	StructDefinition s(++id, {}, std::make_shared<std::string>("Struct"), {}, {}, {});
+	s.annotation().recursive = false;
+	BOOST_CHECK_EQUAL(s.type()->identifier(), "t_type$_t_struct$_Struct_$3_storage_ptr_$");
+
+	EnumDefinition e(++id, {}, std::make_shared<std::string>("Enum"), {}, {}, {});
+	BOOST_CHECK_EQUAL(e.type()->identifier(), "t_type$_t_enum$_Enum_$4_$");
+
+	TupleType t({e.type(), s.type(), stringArray, nullptr});
+	BOOST_CHECK_EQUAL(t.identifier(), "t_tuple$_t_type$_t_enum$_Enum_$4_$_$_t_type$_t_struct$_Struct_$3_storage_ptr_$_$_t_array$_t_string_storage_$20_storage_ptr_$__$");
+
+	Type const* keccak256fun = TypeProvider::function(strings{}, strings{}, FunctionType::Kind::KECCAK256);
+	BOOST_CHECK_EQUAL(keccak256fun->identifier(), "t_function_keccak256_nonpayable$__$returns$__$");
+
+	FunctionType metaFun(TypePointers{keccak256fun}, TypePointers{s.type()}, strings{""}, strings{""});
+	BOOST_CHECK_EQUAL(metaFun.identifier(), "t_function_internal_nonpayable$_t_function_keccak256_nonpayable$__$returns$__$_$returns$_t_type$_t_struct$_Struct_$3_storage_ptr_$_$");
+
+	Type const* m = TypeProvider::mapping(TypeProvider::fromElementaryTypeName("bytes32"), "", s.type(), "");
+	MappingType m2(TypeProvider::fromElementaryTypeName("uint64"), "", m, "");
+	BOOST_CHECK_EQUAL(m2.identifier(), "t_mapping$_t_uint64_$_t_mapping$_t_bytes32_$_t_type$_t_struct$_Struct_$3_storage_ptr_$_$_$");
+
+	// TypeType is tested with contract
+
+	auto emptyParams = std::make_shared<ParameterList>(++id, SourceLocation(), std::vector<ASTPointer<VariableDeclaration>>());
+	ModifierDefinition mod(++id, SourceLocation{}, std::make_shared<std::string>("modif"), SourceLocation{}, {}, emptyParams, {}, {}, {});
+	BOOST_CHECK_EQUAL(ModifierType(mod).identifier(), "t_modifier$__$");
+
+	SourceUnit su(++id, {}, {}, {}, {});
+	BOOST_CHECK_EQUAL(ModuleType(su).identifier(), "t_module_7");
+	BOOST_CHECK_EQUAL(MagicType(MagicType::Kind::Block).identifier(), "t_magic_block");
+	BOOST_CHECK_EQUAL(MagicType(MagicType::Kind::Message).identifier(), "t_magic_message");
+	BOOST_CHECK_EQUAL(MagicType(MagicType::Kind::Transaction).identifier(), "t_magic_transaction");
+
+	BOOST_CHECK_EQUAL(InaccessibleDynamicType().identifier(), "t_inaccessible");
+}
+
+BOOST_AUTO_TEST_CASE(encoded_sizes)
+{
+	BOOST_CHECK_EQUAL(IntegerType(16).calldataEncodedSize(true), 32);
+	BOOST_CHECK_EQUAL(IntegerType(16).calldataEncodedSize(false), 2);
+
+	BOOST_CHECK_EQUAL(FixedBytesType(16).calldataEncodedSize(true), 32);
+	BOOST_CHECK_EQUAL(FixedBytesType(16).calldataEncodedSize(false), 16);
+
+	BOOST_CHECK_EQUAL(BoolType().calldataEncodedSize(true), 32);
+	BOOST_CHECK_EQUAL(BoolType().calldataEncodedSize(false), 1);
+
+	ArrayType const* uint24Array = TypeProvider::array(
+		DataLocation::Memory,
+		TypeProvider::uint(24),
+		9
+	);
+	BOOST_CHECK_EQUAL(uint24Array->calldataEncodedSize(true), 9 * 32);
+	BOOST_CHECK_EQUAL(uint24Array->calldataEncodedSize(false), 9 * 32);
+
+	ArrayType twoDimArray(DataLocation::Memory, uint24Array, 3);
+	BOOST_CHECK_EQUAL(twoDimArray.calldataEncodedSize(true),  9 * 3 * 32);
+	BOOST_CHECK_EQUAL(twoDimArray.calldataEncodedSize(false), 9 * 3 * 32);
+}
+
+BOOST_AUTO_TEST_CASE(helper_bool_result)
+{
+	BoolResult r1{true};
+	BoolResult r2 = BoolResult::err("Failure.");
+	r1.merge(r2, std::logical_and<bool>());
+	BOOST_REQUIRE_EQUAL(r1.get(), false);
+	BOOST_REQUIRE_EQUAL(r1.message(), "Failure.");
+
+	BoolResult r3{false};
+	BoolResult r4{true};
+	r3.merge(r4, std::logical_and<bool>());
+	BOOST_REQUIRE_EQUAL(r3.get(), false);
+	BOOST_REQUIRE_EQUAL(r3.message(), "");
+
+	BoolResult r5{true};
+	BoolResult r6{true};
+	r5.merge(r6, std::logical_and<bool>());
+	BOOST_REQUIRE_EQUAL(r5.get(), true);
+	BOOST_REQUIRE_EQUAL(r5.message(), "");
+}
+
+BOOST_AUTO_TEST_CASE(helper_string_result)
+{
+	using StringResult = util::Result<std::string>;
+
+	StringResult r1{std::string{"Success"}};
+	StringResult r2 = StringResult::err("Failure");
+
+	BOOST_REQUIRE_EQUAL(r1.get(), "Success");
+	BOOST_REQUIRE_EQUAL(r2.get(), "");
+
+	r1.merge(r2, [](std::string const&, std::string const& _rhs) { return _rhs; });
+
+	BOOST_REQUIRE_EQUAL(r1.get(), "");
+	BOOST_REQUIRE_EQUAL(r1.message(), "Failure");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/StandardCompiler.cpp b/compiler/test/libsolidity/StandardCompiler.cpp
new file mode 100644
index 00000000..ab013692
--- /dev/null
+++ b/compiler/test/libsolidity/StandardCompiler.cpp
@@ -0,0 +1,1786 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @date 2017
+ * Unit tests for interface/StandardCompiler.h.
+ */
+
+#include <string>
+#include <boost/test/unit_test.hpp>
+#include <libsolidity/interface/OptimiserSettings.h>
+#include <libsolidity/interface/StandardCompiler.h>
+#include <libsolidity/interface/Version.h>
+#include <libsolutil/JSON.h>
+#include <libsolutil/CommonData.h>
+#include <test/Metadata.h>
+
+#include <algorithm>
+#include <set>
+
+using namespace solidity::evmasm;
+using namespace std::string_literals;
+
+namespace solidity::frontend::test
+{
+
+namespace
+{
+
+langutil::Error::Severity str2Severity(std::string const& _cat)
+{
+	std::map<std::string, langutil::Error::Severity> cats{
+		{"info", langutil::Error::Severity::Info},
+		{"Info", langutil::Error::Severity::Info},
+		{"warning", langutil::Error::Severity::Warning},
+		{"Warning", langutil::Error::Severity::Warning},
+		{"error", langutil::Error::Severity::Error},
+		{"Error", langutil::Error::Severity::Error}
+	};
+	return cats.at(_cat);
+}
+
+/// Helper to match a specific error type and message
+bool containsError(Json::Value const& _compilerResult, std::string const& _type, std::string const& _message)
+{
+	if (!_compilerResult.isMember("errors"))
+		return false;
+
+	for (auto const& error: _compilerResult["errors"])
+	{
+		BOOST_REQUIRE(error.isObject());
+		BOOST_REQUIRE(error["type"].isString());
+		BOOST_REQUIRE(error["message"].isString());
+		if ((error["type"].asString() == _type) && (error["message"].asString() == _message))
+			return true;
+	}
+
+	return false;
+}
+
+bool containsAtMostWarnings(Json::Value const& _compilerResult)
+{
+	if (!_compilerResult.isMember("errors"))
+		return true;
+
+	for (auto const& error: _compilerResult["errors"])
+	{
+		BOOST_REQUIRE(error.isObject());
+		BOOST_REQUIRE(error["severity"].isString());
+		if (langutil::Error::isError(str2Severity(error["severity"].asString())))
+			return false;
+	}
+
+	return true;
+}
+
+Json::Value getContractResult(Json::Value const& _compilerResult, std::string const& _file, std::string const& _name)
+{
+	if (
+		!_compilerResult["contracts"].isObject() ||
+		!_compilerResult["contracts"][_file].isObject() ||
+		!_compilerResult["contracts"][_file][_name].isObject()
+	)
+		return Json::Value();
+	return _compilerResult["contracts"][_file][_name];
+}
+
+void checkLinkReferencesSchema(Json::Value const& _contractResult)
+{
+	BOOST_TEST_REQUIRE(_contractResult.isObject());
+	BOOST_TEST_REQUIRE(_contractResult["evm"]["bytecode"].isObject());
+
+	Json::Value const& linkReferenceResult = _contractResult["evm"]["bytecode"]["linkReferences"];
+	BOOST_TEST_REQUIRE(linkReferenceResult.isObject());
+
+	for (std::string const& fileName: linkReferenceResult.getMemberNames())
+	{
+		BOOST_TEST_REQUIRE(linkReferenceResult[fileName].isObject());
+		for (std::string const& libraryName: linkReferenceResult[fileName].getMemberNames())
+		{
+			BOOST_TEST_REQUIRE(linkReferenceResult[fileName][libraryName].isArray());
+			BOOST_TEST_REQUIRE(!linkReferenceResult[fileName][libraryName].empty());
+			for (int i = 0; i < static_cast<int>(linkReferenceResult.size()); ++i)
+			{
+				BOOST_TEST_REQUIRE(linkReferenceResult[fileName][libraryName][i].isObject());
+				BOOST_TEST_REQUIRE(linkReferenceResult[fileName][libraryName][i].size() == 2);
+				BOOST_TEST_REQUIRE(linkReferenceResult[fileName][libraryName][i]["length"].isUInt());
+				BOOST_TEST_REQUIRE(linkReferenceResult[fileName][libraryName][i]["start"].isUInt());
+			}
+		}
+	}
+}
+
+void expectLinkReferences(Json::Value const& _contractResult, std::map<std::string, std::set<std::string>> const& _expectedLinkReferences)
+{
+	checkLinkReferencesSchema(_contractResult);
+
+	Json::Value const& linkReferenceResult = _contractResult["evm"]["bytecode"]["linkReferences"];
+	BOOST_TEST(linkReferenceResult.size() == _expectedLinkReferences.size());
+
+	for (auto const& [fileName, libraries]: _expectedLinkReferences)
+	{
+		BOOST_TEST(linkReferenceResult.isMember(fileName));
+		BOOST_TEST(linkReferenceResult[fileName].size() == libraries.size());
+		for (std::string const& libraryName: libraries)
+			BOOST_TEST(linkReferenceResult[fileName].isMember(libraryName));
+	}
+}
+
+Json::Value compile(std::string _input)
+{
+	StandardCompiler compiler;
+	std::string output = compiler.compile(std::move(_input));
+	Json::Value ret;
+	BOOST_REQUIRE(util::jsonParseStrict(output, ret));
+	return ret;
+}
+
+} // end anonymous namespace
+
+BOOST_AUTO_TEST_SUITE(StandardCompiler)
+
+BOOST_AUTO_TEST_CASE(assume_object_input)
+{
+	Json::Value result;
+
+	/// Use the native JSON interface of StandardCompiler to trigger these
+	frontend::StandardCompiler compiler;
+	result = compiler.compile(Json::Value());
+	BOOST_CHECK(containsError(result, "JSONError", "Input is not a JSON object."));
+	result = compiler.compile(Json::Value("INVALID"));
+	BOOST_CHECK(containsError(result, "JSONError", "Input is not a JSON object."));
+
+	/// Use the string interface of StandardCompiler to trigger these
+	result = compile("");
+	BOOST_CHECK(containsError(result, "JSONError", "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n* Line 1, Column 1\n  A valid JSON document must be either an array or an object value.\n"));
+	result = compile("invalid");
+	BOOST_CHECK(containsError(result, "JSONError", "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n* Line 1, Column 2\n  Extra non-whitespace after JSON value.\n"));
+	result = compile("\"invalid\"");
+	BOOST_CHECK(containsError(result, "JSONError", "* Line 1, Column 1\n  A valid JSON document must be either an array or an object value.\n"));
+	BOOST_CHECK(!containsError(result, "JSONError", "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n"));
+	result = compile("{}");
+	BOOST_CHECK(!containsError(result, "JSONError", "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n"));
+	BOOST_CHECK(!containsAtMostWarnings(result));
+}
+
+BOOST_AUTO_TEST_CASE(invalid_language)
+{
+	char const* input = R"(
+	{
+		"language": "INVALID",
+		"sources": { "name": { "content": "abc" } }
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Only \"Solidity\", \"Yul\", \"SolidityAST\" or \"EVMAssembly\" is supported as a language."));
+}
+
+BOOST_AUTO_TEST_CASE(valid_language)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity"
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(!containsError(result, "JSONError", "Only \"Solidity\" or \"Yul\" is supported as a language."));
+}
+
+BOOST_AUTO_TEST_CASE(no_sources)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity"
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "No input sources specified."));
+}
+
+BOOST_AUTO_TEST_CASE(no_sources_empty_object)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "No input sources specified."));
+}
+
+BOOST_AUTO_TEST_CASE(no_sources_empty_array)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": []
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "\"sources\" is not a JSON object."));
+}
+
+BOOST_AUTO_TEST_CASE(sources_is_array)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": ["aa", "bb"]
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "\"sources\" is not a JSON object."));
+}
+
+BOOST_AUTO_TEST_CASE(unexpected_trailing_test)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"A": {
+				"content": "contract A { function f() {} }"
+			}
+		}
+	}
+	}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "* Line 10, Column 2\n  Extra non-whitespace after JSON value.\n"));
+}
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_enabled_not_boolean)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"optimizer": {
+				"enabled": "wrong"
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "The \"enabled\" setting must be a Boolean."));
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_runs_not_a_number)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"optimizer": {
+				"enabled": true,
+				"runs": "not a number"
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "The \"runs\" setting must be an unsigned number."));
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_runs_not_an_unsigned_number)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"optimizer": {
+				"enabled": true,
+				"runs": -1
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "The \"runs\" setting must be an unsigned number."));
+}
+
+BOOST_AUTO_TEST_CASE(basic_compilation)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		},
+		"settings": {
+			"outputSelection": {
+				"fileA": {
+					"A": [ "abi", "devdoc", "userdoc", "evm.bytecode", "evm.assembly", "evm.gasEstimates", "evm.legacyAssembly", "metadata" ],
+					"": [ "ast" ]
+				}
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+	BOOST_CHECK(contract["devdoc"].isObject());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["devdoc"]), R"({"kind":"dev","methods":{},"version":1})");
+	BOOST_CHECK(contract["userdoc"].isObject());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["userdoc"]), R"({"kind":"user","methods":{},"version":1})");
+	BOOST_CHECK(contract["evm"].isObject());
+	/// @TODO check evm.methodIdentifiers, legacyAssembly, bytecode, deployedBytecode
+	BOOST_CHECK(contract["evm"]["bytecode"].isObject());
+	BOOST_CHECK(contract["evm"]["bytecode"]["object"].isString());
+	BOOST_CHECK_EQUAL(
+		solidity::test::bytecodeSansMetadata(contract["evm"]["bytecode"]["object"].asString()),
+		std::string("6080604052348015600e575f80fd5b5060") +
+		(VersionIsRelease ? "3e" : util::toHex(bytes{uint8_t(60 + VersionStringStrict.size())})) +
+		"80601a5f395ff3fe60806040525f80fdfe"
+	);
+	BOOST_CHECK(contract["evm"]["assembly"].isString());
+	BOOST_CHECK(contract["evm"]["assembly"].asString().find(
+		"    /* \"fileA\":0:14  contract A { } */\n  mstore(0x40, 0x80)\n  "
+		"callvalue\n  dup1\n  "
+		"iszero\n  tag_1\n  jumpi\n  "
+		"0x00\n  "
+		"dup1\n  revert\n"
+		"tag_1:\n  pop\n  dataSize(sub_0)\n  dup1\n  "
+		"dataOffset(sub_0)\n  0x00\n  codecopy\n  0x00\n  return\nstop\n\nsub_0: assembly {\n        "
+		"/* \"fileA\":0:14  contract A { } */\n      mstore(0x40, 0x80)\n      "
+		"0x00\n      "
+		"dup1\n      revert\n\n    auxdata: 0xa26469706673582212"
+	) == 0);
+	BOOST_CHECK(contract["evm"]["gasEstimates"].isObject());
+	BOOST_CHECK_EQUAL(contract["evm"]["gasEstimates"].size(), 1);
+	BOOST_CHECK(contract["evm"]["gasEstimates"]["creation"].isObject());
+	BOOST_CHECK_EQUAL(contract["evm"]["gasEstimates"]["creation"].size(), 3);
+	BOOST_CHECK(contract["evm"]["gasEstimates"]["creation"]["codeDepositCost"].isString());
+	BOOST_CHECK(contract["evm"]["gasEstimates"]["creation"]["executionCost"].isString());
+	BOOST_CHECK(contract["evm"]["gasEstimates"]["creation"]["totalCost"].isString());
+	BOOST_CHECK_EQUAL(
+		u256(contract["evm"]["gasEstimates"]["creation"]["codeDepositCost"].asString()) +
+		u256(contract["evm"]["gasEstimates"]["creation"]["executionCost"].asString()),
+		u256(contract["evm"]["gasEstimates"]["creation"]["totalCost"].asString())
+	);
+	// Lets take the top level `.code` section (the "deployer code"), that should expose most of the features of
+	// the assembly JSON. What we want to check here is Operation, Push, PushTag, PushSub, PushSubSize and Tag.
+	BOOST_CHECK(contract["evm"]["legacyAssembly"].isObject());
+	BOOST_CHECK(contract["evm"]["legacyAssembly"][".code"].isArray());
+	BOOST_CHECK_EQUAL(
+		util::jsonCompactPrint(contract["evm"]["legacyAssembly"][".code"]),
+		"[{\"begin\":0,\"end\":14,\"name\":\"PUSH\",\"source\":0,\"value\":\"80\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH\",\"source\":0,\"value\":\"40\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"MSTORE\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"CALLVALUE\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"DUP1\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"ISZERO\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH [tag]\",\"source\":0,\"value\":\"1\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"JUMPI\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH\",\"source\":0,\"value\":\"0\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"DUP1\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"REVERT\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"tag\",\"source\":0,\"value\":\"1\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"JUMPDEST\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"POP\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH #[$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"DUP1\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH [$]\",\"source\":0,\"value\":\"0000000000000000000000000000000000000000000000000000000000000000\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH\",\"source\":0,\"value\":\"0\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"CODECOPY\",\"source\":0},"
+		"{\"begin\":0,\"end\":14,\"name\":\"PUSH\",\"source\":0,\"value\":\"0\"},"
+		"{\"begin\":0,\"end\":14,\"name\":\"RETURN\",\"source\":0}]"
+	);
+	BOOST_CHECK(contract["metadata"].isString());
+	BOOST_CHECK(solidity::test::isValidMetadata(contract["metadata"].asString()));
+	BOOST_CHECK(result["sources"].isObject());
+	BOOST_CHECK(result["sources"]["fileA"].isObject());
+	BOOST_CHECK(result["sources"]["fileA"]["ast"].isObject());
+	BOOST_CHECK_EQUAL(
+		util::jsonCompactPrint(result["sources"]["fileA"]["ast"]),
+		"{\"absolutePath\":\"fileA\",\"exportedSymbols\":{\"A\":[1]},\"id\":2,\"nodeType\":\"SourceUnit\",\"nodes\":[{\"abstract\":false,"
+		"\"baseContracts\":[],\"canonicalName\":\"A\",\"contractDependencies\":[],"
+		"\"contractKind\":\"contract\",\"fullyImplemented\":true,\"id\":1,"
+		"\"linearizedBaseContracts\":[1],\"name\":\"A\",\"nameLocation\":\"9:1:0\",\"nodeType\":\"ContractDefinition\",\"nodes\":[],\"scope\":2,"
+		"\"src\":\"0:14:0\",\"usedErrors\":[],\"usedEvents\":[]}],\"src\":\"0:14:0\"}"
+	);
+}
+
+BOOST_AUTO_TEST_CASE(compilation_error)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { function }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(result.isMember("errors"));
+	BOOST_CHECK(result["errors"].size() >= 1);
+	for (auto const& error: result["errors"])
+	{
+		BOOST_REQUIRE(error.isObject());
+		BOOST_REQUIRE(error["message"].isString());
+		if (error["message"].asString().find("pre-release compiler") == std::string::npos)
+		{
+			BOOST_CHECK_EQUAL(
+				util::jsonCompactPrint(error),
+				"{\"component\":\"general\",\"errorCode\":\"2314\",\"formattedMessage\":\"ParserError: Expected identifier but got '}'\\n"
+				" --> fileA:1:23:\\n  |\\n1 | contract A { function }\\n  |                       ^\\n\\n\",\"message\":\"Expected identifier but got '}'\","
+				"\"severity\":\"error\",\"sourceLocation\":{\"end\":23,\"file\":\"fileA\",\"start\":22},\"type\":\"ParserError\"}"
+			);
+		}
+	}
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_explicit)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_all_contracts)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": {
+					"*": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_all_files_single_contract)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"*": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_all_files_all_contracts)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"*": {
+					"*": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_dependent_contract)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"*": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract B { } contract A { function f() public { new B(); } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[{\"inputs\":[],\"name\":\"f\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]");
+}
+
+BOOST_AUTO_TEST_CASE(output_selection_dependent_contract_with_import)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"*": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "import \"fileB\"; contract A { function f() public { new B(); } }"
+			},
+			"fileB": {
+				"content": "contract B { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[{\"inputs\":[],\"name\":\"f\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]");
+}
+
+BOOST_AUTO_TEST_CASE(filename_with_colon)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"http://github.com/ethereum/solidity/std/StandardToken.sol": {
+					"A": [
+						"abi"
+					]
+				}
+			}
+		},
+		"sources": {
+			"http://github.com/ethereum/solidity/std/StandardToken.sol": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "http://github.com/ethereum/solidity/std/StandardToken.sol", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["abi"].isArray());
+	BOOST_CHECK_EQUAL(util::jsonCompactPrint(contract["abi"]), "[]");
+}
+
+BOOST_AUTO_TEST_CASE(library_filename_with_colon)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": {
+					"A": [
+						"evm.bytecode"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "import \"git:library.sol\"; contract A { function f() public returns (uint) { return L.g(); } }"
+			},
+			"git:library.sol": {
+				"content": "library L { function g() public returns (uint) { return 1; } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	expectLinkReferences(contract, {{"git:library.sol", {"L"}}});
+}
+
+BOOST_AUTO_TEST_CASE(libraries_invalid_top_level)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": "42"
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "\"libraries\" is not a JSON object."));
+}
+
+BOOST_AUTO_TEST_CASE(libraries_invalid_entry)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": {
+				"L": "42"
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Library entry is not a JSON object."));
+}
+
+BOOST_AUTO_TEST_CASE(libraries_invalid_hex)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": {
+				"library.sol": {
+					"L": "0x4200000000000000000000000000000000000xx1"
+				}
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Invalid library address (\"0x4200000000000000000000000000000000000xx1\") supplied."));
+}
+
+BOOST_AUTO_TEST_CASE(libraries_invalid_length)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": {
+				"library.sol": {
+					"L1": "0x42",
+					"L2": "0x4200000000000000000000000000000000000001ff"
+				}
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Library address is of invalid length."));
+}
+
+BOOST_AUTO_TEST_CASE(libraries_missing_hex_prefix)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": {
+				"library.sol": {
+					"L": "4200000000000000000000000000000000000001"
+				}
+			}
+		},
+		"sources": {
+			"empty": {
+				"content": ""
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Library address is not prefixed with \"0x\"."));
+}
+
+BOOST_AUTO_TEST_CASE(library_linking)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"libraries": {
+				"library.sol": {
+					"L": "0x4200000000000000000000000000000000000001"
+				}
+			},
+			"outputSelection": {
+				"fileA": {
+					"A": [
+						"evm.bytecode"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "import \"library.sol\"; import \"library2.sol\"; contract A { function f() public returns (uint) { L2.g(); return L.g(); } }"
+			},
+			"library.sol": {
+				"content": "library L { function g() public returns (uint) { return 1; } }"
+			},
+			"library2.sol": {
+				"content": "library L2 { function g() public { } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_TEST(containsAtMostWarnings(result));
+	Json::Value contractResult = getContractResult(result, "fileA", "A");
+	expectLinkReferences(contractResult, {{"library2.sol", {"L2"}}});
+}
+
+BOOST_AUTO_TEST_CASE(linking_yul)
+{
+	char const* input = R"(
+	{
+		"language": "Yul",
+		"settings": {
+			"libraries": {
+				"fileB": {
+					"L": "0x4200000000000000000000000000000000000001"
+				}
+			},
+			"outputSelection": {
+				"fileA": {
+					"*": [
+						"evm.bytecode.linkReferences"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "object \"a\" { code { let addr := linkersymbol(\"fileB:L\") sstore(0, addr) } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_TEST(containsAtMostWarnings(result));
+	Json::Value contractResult = getContractResult(result, "fileA", "a");
+	expectLinkReferences(contractResult, {});
+}
+
+BOOST_AUTO_TEST_CASE(linking_yul_empty_link_reference)
+{
+	char const* input = R"(
+	{
+		"language": "Yul",
+		"settings": {
+			"libraries": {
+				"": {
+					"": "0x4200000000000000000000000000000000000001"
+				}
+			},
+			"outputSelection": {
+				"fileA": {
+					"*": [
+						"evm.bytecode.linkReferences"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "object \"a\" { code { let addr := linkersymbol(\"\") sstore(0, addr) } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_TEST(containsAtMostWarnings(result));
+	Json::Value contractResult = getContractResult(result, "fileA", "a");
+	expectLinkReferences(contractResult, {{"", {""}}});
+}
+
+BOOST_AUTO_TEST_CASE(linking_yul_no_filename_in_link_reference)
+{
+	char const* input = R"(
+	{
+		"language": "Yul",
+		"settings": {
+			"libraries": {
+				"": {
+					"L": "0x4200000000000000000000000000000000000001"
+				}
+			},
+			"outputSelection": {
+				"fileA": {
+					"*": [
+						"evm.bytecode.linkReferences"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "object \"a\" { code { let addr := linkersymbol(\"L\") sstore(0, addr) } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_TEST(containsAtMostWarnings(result));
+	Json::Value contractResult = getContractResult(result, "fileA", "a");
+	expectLinkReferences(contractResult, {{"", {"L"}}});
+}
+
+BOOST_AUTO_TEST_CASE(linking_yul_same_library_name_different_files)
+{
+	char const* input = R"(
+	{
+		"language": "Yul",
+		"settings": {
+			"libraries": {
+				"fileB": {
+					"L": "0x4200000000000000000000000000000000000001"
+				}
+			},
+			"outputSelection": {
+				"fileA": {
+					"*": [
+						"evm.bytecode.linkReferences"
+					]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "object \"a\" { code { let addr := linkersymbol(\"fileC:L\") sstore(0, addr) } }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_TEST(containsAtMostWarnings(result));
+	Json::Value contractResult = getContractResult(result, "fileA", "a");
+	expectLinkReferences(contractResult, {{"fileC", {"L"}}});
+}
+
+BOOST_AUTO_TEST_CASE(evm_version)
+{
+	auto inputForVersion = [](std::string const& _version)
+	{
+		return R"(
+			{
+				"language": "Solidity",
+				"sources": { "fileA": { "content": "contract A { }" } },
+				"settings": {
+					)" + _version + R"(
+					"outputSelection": {
+						"fileA": {
+							"A": [ "metadata" ]
+						}
+					}
+				}
+			}
+		)";
+	};
+	Json::Value result;
+	result = compile(inputForVersion("\"evmVersion\": \"homestead\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"homestead\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"tangerineWhistle\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"tangerineWhistle\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"spuriousDragon\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"spuriousDragon\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"byzantium\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"byzantium\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"constantinople\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"constantinople\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"petersburg\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"petersburg\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"istanbul\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"istanbul\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"berlin\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"berlin\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"london\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"london\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"paris\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"paris\"") != std::string::npos);
+	result = compile(inputForVersion("\"evmVersion\": \"shanghai\","));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"shanghai\"") != std::string::npos);
+	// test default
+	result = compile(inputForVersion(""));
+	BOOST_CHECK(result["contracts"]["fileA"]["A"]["metadata"].asString().find("\"evmVersion\":\"shanghai\"") != std::string::npos);
+	// test invalid
+	result = compile(inputForVersion("\"evmVersion\": \"invalid\","));
+	BOOST_CHECK(result["errors"][0]["message"].asString() == "Invalid EVM version requested.");
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_settings_default_disabled)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": { "A": [ "metadata" ] }
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	Json::Value metadata;
+	BOOST_CHECK(util::jsonParseStrict(contract["metadata"].asString(), metadata));
+
+	Json::Value const& optimizer = metadata["settings"]["optimizer"];
+	BOOST_CHECK(optimizer.isMember("enabled"));
+	BOOST_CHECK(optimizer["enabled"].asBool() == false);
+	BOOST_CHECK(!optimizer.isMember("details"));
+	BOOST_CHECK(optimizer["runs"].asUInt() == 200);
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_settings_default_enabled)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": { "A": [ "metadata" ] }
+			},
+			"optimizer": { "enabled": true }
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	Json::Value metadata;
+	BOOST_CHECK(util::jsonParseStrict(contract["metadata"].asString(), metadata));
+
+	Json::Value const& optimizer = metadata["settings"]["optimizer"];
+	BOOST_CHECK(optimizer.isMember("enabled"));
+	BOOST_CHECK(optimizer["enabled"].asBool() == true);
+	BOOST_CHECK(!optimizer.isMember("details"));
+	BOOST_CHECK(optimizer["runs"].asUInt() == 200);
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_settings_details_exactly_as_default_disabled)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": { "A": [ "metadata" ] }
+			},
+			"optimizer": { "details": {
+				"constantOptimizer" : false,
+				"cse" : false,
+				"deduplicate" : false,
+				"jumpdestRemover" : true,
+				"orderLiterals" : false,
+				"peephole" : true
+			} }
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	Json::Value metadata;
+	BOOST_CHECK(util::jsonParseStrict(contract["metadata"].asString(), metadata));
+
+	Json::Value const& optimizer = metadata["settings"]["optimizer"];
+	BOOST_CHECK(optimizer.isMember("enabled"));
+	// enabled is switched to false instead!
+	BOOST_CHECK(optimizer["enabled"].asBool() == false);
+	BOOST_CHECK(!optimizer.isMember("details"));
+	BOOST_CHECK(optimizer["runs"].asUInt() == 200);
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_settings_details_different)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": { "A": [ "metadata" ] }
+			},
+			"optimizer": { "runs": 600, "details": {
+				"constantOptimizer" : true,
+				"cse" : false,
+				"deduplicate" : true,
+				"jumpdestRemover" : true,
+				"orderLiterals" : false,
+				"peephole" : true,
+				"yul": true,
+				"inliner": true
+			} }
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	Json::Value metadata;
+	BOOST_CHECK(util::jsonParseStrict(contract["metadata"].asString(), metadata));
+
+	Json::Value const& optimizer = metadata["settings"]["optimizer"];
+	BOOST_CHECK(!optimizer.isMember("enabled"));
+	BOOST_CHECK(optimizer.isMember("details"));
+	BOOST_CHECK(optimizer["details"]["constantOptimizer"].asBool() == true);
+	BOOST_CHECK(optimizer["details"]["cse"].asBool() == false);
+	BOOST_CHECK(optimizer["details"]["deduplicate"].asBool() == true);
+	BOOST_CHECK(optimizer["details"]["jumpdestRemover"].asBool() == true);
+	BOOST_CHECK(optimizer["details"]["orderLiterals"].asBool() == false);
+	BOOST_CHECK(optimizer["details"]["peephole"].asBool() == true);
+	BOOST_CHECK(optimizer["details"]["yul"].asBool() == true);
+	BOOST_CHECK(optimizer["details"]["yulDetails"].isObject());
+	BOOST_CHECK(
+		util::convertContainer<std::set<std::string>>(optimizer["details"]["yulDetails"].getMemberNames()) ==
+		(std::set<std::string>{"stackAllocation", "optimizerSteps"})
+	);
+	BOOST_CHECK(optimizer["details"]["yulDetails"]["stackAllocation"].asBool() == true);
+	BOOST_CHECK(
+		optimizer["details"]["yulDetails"]["optimizerSteps"].asString() ==
+		OptimiserSettings::DefaultYulOptimiserSteps + ":"s + OptimiserSettings::DefaultYulOptimiserCleanupSteps
+ 	);
+	BOOST_CHECK_EQUAL(optimizer["details"].getMemberNames().size(), 10);
+	BOOST_CHECK(optimizer["runs"].asUInt() == 600);
+}
+
+BOOST_AUTO_TEST_CASE(metadata_without_compilation)
+{
+	// NOTE: the contract code here should fail to compile due to "out of stack"
+	// If the metadata is successfully returned, that means no compilation was attempted.
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"fileA": { "A": [ "metadata" ] }
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A {
+  function x(uint a, uint b, uint c, uint d, uint e, uint f, uint g, uint h, uint i, uint j, uint k, uint l, uint m, uint n, uint o, uint p) pure public {}
+  function y() pure public {
+    uint a; uint b; uint c; uint d; uint e; uint f; uint g; uint h; uint i; uint j; uint k; uint l; uint m; uint n; uint o; uint p;
+    x(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
+  }
+}"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	BOOST_CHECK(solidity::test::isValidMetadata(contract["metadata"].asString()));
+}
+
+
+BOOST_AUTO_TEST_CASE(license_in_metadata)
+{
+	std::string const input = R"(
+			{
+				"language": "Solidity",
+				"sources": {
+					"fileA": { "content": "import \"fileB\"; contract A { } // SPDX-License-Identifier: GPL-3.0 \n" },
+					"fileB": { "content": "import \"fileC\"; /* SPDX-License-Identifier: MIT */ contract B { }" },
+					"fileC": { "content": "import \"fileD\"; /* SPDX-License-Identifier: MIT AND GPL-3.0 */ contract C { }" },
+					"fileD": { "content": "// SPDX-License-Identifier: (GPL-3.0+ OR MIT) AND MIT \n import \"fileE\"; contract D { }" },
+					"fileE": { "content": "import \"fileF\"; /// SPDX-License-Identifier: MIT   \n contract E { }" },
+					"fileF": { "content": "/*\n * SPDX-License-Identifier: MIT\n */ contract F { }" }
+				},
+				"settings": {
+					"outputSelection": {
+						"fileA": {
+							"*": [ "metadata" ]
+						}
+					}
+				}
+			}
+		)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	Json::Value metadata;
+	BOOST_REQUIRE(util::jsonParseStrict(contract["metadata"].asString(), metadata));
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileA"]["license"], "GPL-3.0");
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileB"]["license"], "MIT");
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileC"]["license"], "MIT AND GPL-3.0");
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileD"]["license"], "(GPL-3.0+ OR MIT) AND MIT");
+	// This is actually part of the docstring, but still picked up
+	// because the source location of the contract does not cover the docstring.
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileE"]["license"], "MIT");
+	BOOST_CHECK_EQUAL(metadata["sources"]["fileF"]["license"], "MIT");
+}
+
+BOOST_AUTO_TEST_CASE(common_pattern)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"outputSelection": {
+				"*": {
+					"*": [ "evm.bytecode.object", "metadata" ]
+				}
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A { function f() pure public {} }"
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_CHECK(contract.isObject());
+	BOOST_CHECK(contract["metadata"].isString());
+	BOOST_CHECK(solidity::test::isValidMetadata(contract["metadata"].asString()));
+	BOOST_CHECK(contract["evm"]["bytecode"].isObject());
+	BOOST_CHECK(contract["evm"]["bytecode"]["object"].isString());
+}
+
+BOOST_AUTO_TEST_CASE(use_stack_optimization)
+{
+	// NOTE: the contract code here should fail to compile due to "out of stack"
+	// If we enable stack optimization, though, it will compile.
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"settings": {
+			"optimizer": { "enabled": true, "details": { "yul": true } },
+			"outputSelection": {
+				"fileA": { "A": [ "evm.bytecode.object" ] }
+			}
+		},
+		"sources": {
+			"fileA": {
+				"content": "contract A {
+					function y() public {
+						assembly {
+							function fun() -> a3, b3, c3, d3, e3, f3, g3, h3, i3, j3, k3, l3, m3, n3, o3, p3
+							{
+								let a := 1
+								let b := 1
+								let z3 := 1
+								sstore(a, b)
+								sstore(add(a, 1), b)
+								sstore(add(a, 2), b)
+								sstore(add(a, 3), b)
+								sstore(add(a, 4), b)
+								sstore(add(a, 5), b)
+								sstore(add(a, 6), b)
+								sstore(add(a, 7), b)
+								sstore(add(a, 8), b)
+								sstore(add(a, 9), b)
+								sstore(add(a, 10), b)
+								sstore(add(a, 11), b)
+								sstore(add(a, 12), b)
+							}
+							let a1, b1, c1, d1, e1, f1, g1, h1, i1, j1, k1, l1, m1, n1, o1, p1 := fun()
+							let a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2 := fun()
+							sstore(a1, a2)
+						}
+					}
+				}"
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_CHECK(containsAtMostWarnings(result));
+	Json::Value contract = getContractResult(result, "fileA", "A");
+	BOOST_REQUIRE(contract.isObject());
+	BOOST_REQUIRE(contract["evm"]["bytecode"]["object"].isString());
+	BOOST_CHECK(contract["evm"]["bytecode"]["object"].asString().length() > 20);
+
+	// Now disable stack optimizations and UnusedFunctionParameterPruner (p)
+	// results in "stack too deep"
+	std::string optimiserSteps = OptimiserSettings::DefaultYulOptimiserSteps;
+	optimiserSteps.erase(
+		remove_if(optimiserSteps.begin(), optimiserSteps.end(), [](char ch) { return ch == 'p'; }),
+		optimiserSteps.end()
+	);
+	parsedInput["settings"]["optimizer"]["details"]["yulDetails"]["stackAllocation"] = false;
+	parsedInput["settings"]["optimizer"]["details"]["yulDetails"]["optimizerSteps"] = optimiserSteps;
+
+	result = compiler.compile(parsedInput);
+	BOOST_REQUIRE(result["errors"].isArray());
+	BOOST_CHECK(result["errors"][0]["severity"] == "error");
+	BOOST_REQUIRE(result["errors"][0]["message"].isString());
+	BOOST_CHECK(result["errors"][0]["message"].asString().find("When compiling inline assembly") != std::string::npos);
+	BOOST_CHECK(result["errors"][0]["type"] == "CompilerError");
+}
+
+BOOST_AUTO_TEST_CASE(standard_output_selection_wildcard)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+			"sources":
+		{
+			"A":
+			{
+				"content": "pragma solidity >=0.0; contract C { function f() public pure {} }"
+			}
+		},
+		"settings":
+		{
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["A"].isObject());
+	BOOST_REQUIRE(result["contracts"]["A"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["A"]["C"].isObject());
+	BOOST_REQUIRE(result["contracts"]["A"]["C"]["evm"].isObject());
+	BOOST_REQUIRE(result["contracts"]["A"]["C"]["evm"]["bytecode"].isObject());
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 1);
+	BOOST_REQUIRE(result["sources"]["A"].isObject());
+
+}
+
+BOOST_AUTO_TEST_CASE(standard_output_selection_wildcard_colon_source)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{
+			":A":
+			{
+				"content": "pragma solidity >=0.0; contract C { function f() public pure {} }"
+			}
+		},
+		"settings":
+		{
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"][":A"].isObject());
+	BOOST_REQUIRE(result["contracts"][":A"].size() == 1);
+	BOOST_REQUIRE(result["contracts"][":A"]["C"].isObject());
+	BOOST_REQUIRE(result["contracts"][":A"]["C"]["evm"].isObject());
+	BOOST_REQUIRE(result["contracts"][":A"]["C"]["evm"]["bytecode"].isObject());
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 1);
+	BOOST_REQUIRE(result["sources"][":A"].isObject());
+}
+
+BOOST_AUTO_TEST_CASE(standard_output_selection_wildcard_empty_source)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{
+			"":
+			{
+				"content": "pragma solidity >=0.0; contract C { function f() public pure {} }"
+			}
+		},
+		"settings":
+		{
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"][""].isObject());
+	BOOST_REQUIRE(result["contracts"][""].size() == 1);
+	BOOST_REQUIRE(result["contracts"][""]["C"].isObject());
+	BOOST_REQUIRE(result["contracts"][""]["C"]["evm"].isObject());
+	BOOST_REQUIRE(result["contracts"][""]["C"]["evm"]["bytecode"].isObject());
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 1);
+	BOOST_REQUIRE(result["sources"][""].isObject());
+}
+
+BOOST_AUTO_TEST_CASE(standard_output_selection_wildcard_multiple_sources)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{
+			"A":
+			{
+				"content": "pragma solidity >=0.0; contract C { function f() public pure {} }"
+			},
+			"B":
+			{
+				"content": "pragma solidity >=0.0; contract D { function f() public pure {} }"
+			}
+		},
+		"settings":
+		{
+			"outputSelection":
+			{
+				"*": { "D": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["B"].isObject());
+	BOOST_REQUIRE(result["contracts"]["B"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["B"]["D"].isObject());
+	BOOST_REQUIRE(result["contracts"]["B"]["D"]["evm"].isObject());
+	BOOST_REQUIRE(result["contracts"]["B"]["D"]["evm"]["bytecode"].isObject());
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 2);
+	BOOST_REQUIRE(result["sources"]["A"].isObject());
+	BOOST_REQUIRE(result["sources"]["B"].isObject());
+}
+
+BOOST_AUTO_TEST_CASE(stopAfter_invalid_value)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
+		"settings":
+		{
+			"stopAfter": "rrr",
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Invalid value for \"settings.stopAfter\". Only valid value is \"parsing\"."));
+}
+
+BOOST_AUTO_TEST_CASE(stopAfter_invalid_type)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
+		"settings":
+		{
+			"stopAfter": 3,
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "\"settings.stopAfter\" must be a string."));
+}
+
+BOOST_AUTO_TEST_CASE(stopAfter_bin_conflict)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources":
+		{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
+		"settings":
+		{
+			"stopAfter": "parsing",
+			"outputSelection":
+			{
+				"*": { "C": ["evm.bytecode"] }
+			}
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(containsError(result, "JSONError", "Requested output selection conflicts with \"settings.stopAfter\"."));
+}
+
+BOOST_AUTO_TEST_CASE(stopAfter_ast_output)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"a.sol": {
+				"content": "// SPDX-License-Identifier: GPL-3.0\nimport \"tes32.sol\";\n contract C is X { constructor() {} }"
+			}
+		},
+		"settings": {
+			"stopAfter": "parsing",
+			"outputSelection": { "*": { "": [ "ast" ] } }
+		}
+	}
+	)";
+	Json::Value result = compile(input);
+	BOOST_CHECK(result["sources"].isObject());
+	BOOST_CHECK(result["sources"]["a.sol"].isObject());
+	BOOST_CHECK(result["sources"]["a.sol"]["ast"].isObject());
+}
+
+BOOST_AUTO_TEST_CASE(dependency_tracking_of_abstract_contract)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"BlockRewardAuRaBase.sol": {
+				"content": " contract Sacrifice { constructor() payable {} } abstract contract BlockRewardAuRaBase { function _transferNativeReward() internal { new Sacrifice(); } function _distributeTokenRewards() internal virtual; } "
+			},
+			"BlockRewardAuRaCoins.sol": {
+				"content": " import \"./BlockRewardAuRaBase.sol\"; contract BlockRewardAuRaCoins is BlockRewardAuRaBase { function transferReward() public { _transferNativeReward(); } function _distributeTokenRewards() internal override {} } "
+			}
+		},
+		"settings": {
+			"outputSelection": {
+				"BlockRewardAuRaCoins.sol": {
+					"BlockRewardAuRaCoins": ["ir", "evm.bytecode.sourceMap"]
+				}
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"].isObject());
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"]["BlockRewardAuRaCoins"].isObject());
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"]["BlockRewardAuRaCoins"]["evm"].isObject());
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"]["BlockRewardAuRaCoins"]["ir"].isString());
+	BOOST_REQUIRE(result["contracts"]["BlockRewardAuRaCoins.sol"]["BlockRewardAuRaCoins"]["evm"]["bytecode"].isObject());
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 2);
+}
+
+BOOST_AUTO_TEST_CASE(dependency_tracking_of_abstract_contract_yul)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"A.sol": {
+				"content": "contract A {} contract B {} contract C { constructor() { new B(); } } contract D {}"
+			}
+		},
+		"settings": {
+			"outputSelection": {
+				"A.sol": {
+					"C": ["ir"]
+				}
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	BOOST_REQUIRE(result["contracts"].isObject());
+	BOOST_REQUIRE(result["contracts"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["A.sol"].isObject());
+	BOOST_REQUIRE(result["contracts"]["A.sol"].size() == 1);
+	BOOST_REQUIRE(result["contracts"]["A.sol"]["C"].isObject());
+	BOOST_REQUIRE(result["contracts"]["A.sol"]["C"]["ir"].isString());
+
+	const std::string& irCode = result["contracts"]["A.sol"]["C"]["ir"].asString();
+
+	// Make sure C and B contracts are deployed
+	BOOST_REQUIRE(irCode.find("object \"C") != std::string::npos);
+	BOOST_REQUIRE(irCode.find("object \"B") != std::string::npos);
+
+	// Make sure A and D are NOT deployed as they were not requested and are not
+	// in any dependency
+	BOOST_REQUIRE(irCode.find("object \"A") == std::string::npos);
+	BOOST_REQUIRE(irCode.find("object \"D") == std::string::npos);
+
+
+	BOOST_REQUIRE(result["sources"].isObject());
+	BOOST_REQUIRE(result["sources"].size() == 1);
+}
+
+BOOST_AUTO_TEST_CASE(source_location_of_bare_block)
+{
+	char const* input = R"(
+	{
+		"language": "Solidity",
+		"sources": {
+			"A.sol": {
+				"content": "contract A { constructor() { uint x = 2; { uint y = 3; } } }"
+			}
+		},
+		"settings": {
+			"outputSelection": {
+				"A.sol": {
+					"A": ["evm.bytecode.sourceMap"]
+				}
+			}
+		}
+	}
+	)";
+
+	Json::Value parsedInput;
+	BOOST_REQUIRE(util::jsonParseStrict(input, parsedInput));
+
+	solidity::frontend::StandardCompiler compiler;
+	Json::Value result = compiler.compile(parsedInput);
+
+	std::string sourceMap = result["contracts"]["A.sol"]["A"]["evm"]["bytecode"]["sourceMap"].asString();
+
+	// Check that the bare block's source location is referenced.
+	std::string sourceRef =
+		";" +
+		std::to_string(std::string{"contract A { constructor() { uint x = 2; "}.size()) +
+		":" +
+		std::to_string(std::string{"{ uint y = 3; }"}.size());
+	BOOST_REQUIRE(sourceMap.find(sourceRef) != std::string::npos);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libsolidity/SyntaxTest.cpp b/compiler/test/libsolidity/SyntaxTest.cpp
new file mode 100644
index 00000000..f17898c0
--- /dev/null
+++ b/compiler/test/libsolidity/SyntaxTest.cpp
@@ -0,0 +1,151 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/SyntaxTest.h>
+
+#include <test/libsolidity/util/Common.h>
+#include <test/Common.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/throw_exception.hpp>
+#include <fstream>
+#include <memory>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::util::formatting;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace boost::unit_test;
+namespace fs = boost::filesystem;
+
+SyntaxTest::SyntaxTest(
+	std::string const& _filename,
+	langutil::EVMVersion _evmVersion,
+	Error::Severity _minSeverity
+):
+	CommonSyntaxTest(_filename, _evmVersion),
+	m_minSeverity(_minSeverity)
+{
+	static std::set<std::string> const compileViaYulAllowedValues{"true", "false"};
+
+	m_compileViaYul = m_reader.stringSetting("compileViaYul", "false");
+	if (!util::contains(compileViaYulAllowedValues, m_compileViaYul))
+		BOOST_THROW_EXCEPTION(std::runtime_error("Invalid compileViaYul value: " + m_compileViaYul + "."));
+	m_optimiseYul = m_reader.boolSetting("optimize-yul", true);
+}
+
+void SyntaxTest::setupCompiler(CompilerStack& _compiler)
+{
+	AnalysisFramework::setupCompiler(_compiler);
+
+	_compiler.setEVMVersion(m_evmVersion);
+	_compiler.setOptimiserSettings(
+		m_optimiseYul ?
+		OptimiserSettings::full() :
+		OptimiserSettings::minimal()
+	);
+	_compiler.setViaIR(m_compileViaYul == "true");
+	_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+	_compiler.setMetadataHash(CompilerStack::MetadataHash::None);
+}
+
+void SyntaxTest::parseAndAnalyze()
+{
+	try
+	{
+		runFramework(withPreamble(m_sources.sources), PipelineStage::Compilation);
+		if (!pipelineSuccessful() && stageSuccessful(PipelineStage::Analysis) && !compiler().isExperimentalAnalysis())
+		{
+			ErrorList const& errors = compiler().errors();
+			auto codeGeneretionErrorCount = count_if(errors.cbegin(), errors.cend(), [](auto const& error) {
+				return error->type() == Error::Type::CodeGenerationError;
+			});
+			auto errorCount = count_if(errors.cbegin(), errors.cend(), [](auto const& error) {
+				return Error::isError(error->type());
+			});
+			// failing compilation after successful analysis is a rare case,
+			// it assumes that errors contain exactly one error, and the error is of type Error::Type::CodeGenerationError
+			if (codeGeneretionErrorCount != 1 || errorCount != 1)
+				BOOST_THROW_EXCEPTION(std::runtime_error("Compilation failed even though analysis was successful."));
+		}
+	}
+	catch (UnimplementedFeatureError const& _e)
+	{
+		m_errorList.emplace_back(SyntaxTestError{
+			Error::Type::UnimplementedFeatureError,
+			std::nullopt,
+			errorMessage(_e),
+			"",
+			-1,
+			-1
+		});
+	}
+
+	filterObtainedErrors();
+}
+
+void SyntaxTest::filterObtainedErrors()
+{
+	for (auto const& currentError: filteredErrors())
+	{
+		if (currentError->severity() < m_minSeverity)
+			continue;
+
+		int locationStart = -1;
+		int locationEnd = -1;
+		std::string sourceName;
+		if (SourceLocation const* location = currentError->sourceLocation())
+		{
+			locationStart = location->start;
+			locationEnd = location->end;
+			solAssert(location->sourceName, "");
+			sourceName = *location->sourceName;
+			if(m_sources.sources.count(sourceName) == 1)
+			{
+				int preambleSize =
+						static_cast<int>(compiler().charStream(sourceName).size()) -
+						static_cast<int>(m_sources.sources[sourceName].size());
+				solAssert(preambleSize >= 0, "");
+
+				// ignore the version & license pragma inserted by the testing tool when calculating locations.
+				if (location->start != -1)
+				{
+					solAssert(location->start >= preambleSize, "");
+					locationStart = location->start - preambleSize;
+				}
+				if (location->end != -1)
+				{
+					solAssert(location->end >= preambleSize, "");
+					locationEnd = location->end - preambleSize;
+				}
+			}
+		}
+		m_errorList.emplace_back(SyntaxTestError{
+			currentError->type(),
+			currentError->errorId(),
+			errorMessage(*currentError),
+			sourceName,
+			locationStart,
+			locationEnd
+		});
+	}
+}
diff --git a/compiler/test/libsolidity/SyntaxTest.h b/compiler/test/libsolidity/SyntaxTest.h
new file mode 100644
index 00000000..95df3c6c
--- /dev/null
+++ b/compiler/test/libsolidity/SyntaxTest.h
@@ -0,0 +1,60 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/libsolidity/AnalysisFramework.h>
+#include <test/TestCase.h>
+#include <test/CommonSyntaxTest.h>
+#include <liblangutil/Exceptions.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace solidity::frontend::test
+{
+
+using solidity::test::SyntaxTestError;
+
+class SyntaxTest: public AnalysisFramework, public solidity::test::CommonSyntaxTest
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<SyntaxTest>(_config.filename, _config.evmVersion);
+	}
+	SyntaxTest(
+		std::string const& _filename,
+		langutil::EVMVersion _evmVersion,
+		langutil::Error::Severity _minSeverity = langutil::Error::Severity::Info
+	);
+
+protected:
+	void setupCompiler(CompilerStack& _compiler) override;
+	void parseAndAnalyze() override;
+	virtual void filterObtainedErrors();
+
+	bool m_optimiseYul{};
+	std::string m_compileViaYul{};
+	langutil::Error::Severity m_minSeverity{};
+};
+
+}
diff --git a/compiler/test/libsolidity/ViewPureChecker.cpp b/compiler/test/libsolidity/ViewPureChecker.cpp
new file mode 100644
index 00000000..3d0e024d
--- /dev/null
+++ b/compiler/test/libsolidity/ViewPureChecker.cpp
@@ -0,0 +1,151 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for the view and pure checker.
+ */
+
+#include <test/libsolidity/AnalysisFramework.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <tuple>
+
+using namespace solidity::langutil;
+
+namespace solidity::frontend::test
+{
+
+BOOST_FIXTURE_TEST_SUITE(ViewPureChecker, AnalysisFramework)
+
+BOOST_AUTO_TEST_CASE(environment_access)
+{
+	std::vector<std::string> view{
+		"block.coinbase",
+		"block.timestamp",
+		"block.difficulty",
+		"block.number",
+		"block.gaslimit",
+		"blockhash(7)",
+		"gasleft()",
+		"msg.value",
+		"msg.sender",
+		"tx.origin",
+		"tx.gasprice",
+		"this",
+		"address(1).balance",
+	};
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+		view.emplace_back("address(0x4242).staticcall(\"\")");
+	if (solidity::test::CommonOptions::get().evmVersion().hasBlobHash())
+		view.emplace_back("blobhash(7)");
+
+	// ``block.blockhash`` and ``blockhash`` are tested separately below because their usage will
+	// produce warnings that can't be handled in a generic way.
+	std::vector<std::string> pure{
+		"msg.data",
+		"msg.data[0]",
+		"msg.sig",
+		"msg",
+		"block",
+		"tx"
+	};
+	for (std::string const& x: view)
+	{
+		CHECK_ERROR(
+			"contract C { function f() pure public { " + x + "; } }",
+			TypeError,
+			"Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires \"view\""
+		);
+	}
+	for (std::string const& x: pure)
+	{
+		CHECK_WARNING(
+			"contract C { function f() view public { " + x + "; } }",
+			"Function state mutability can be restricted to pure"
+		);
+	}
+
+	CHECK_WARNING_ALLOW_MULTI(
+		"contract C { function f() view public { blockhash; } }",
+		(std::vector<std::string>{
+			"Function state mutability can be restricted to pure",
+			"Statement has no effect."
+	}));
+
+	CHECK_ERROR(
+		"contract C { function f() view public { block.blockhash; } }",
+		TypeError,
+		"\"block.blockhash()\" has been deprecated in favor of \"blockhash()\""
+	);
+
+	std::string baseFeeContract = "contract C { function f() view public { block.basefee; } }";
+	if (!solidity::test::CommonOptions::get().evmVersion().hasBaseFee())
+		CHECK_ERROR(
+			baseFeeContract,
+			TypeError,
+			"\"basefee\" is not supported by the VM version."
+		);
+	else
+		CHECK_SUCCESS_NO_WARNINGS(baseFeeContract);
+
+	std::string blobBaseFeeContract = "contract C { function f() view public { block.blobbasefee; } }";
+	if (!solidity::test::CommonOptions::get().evmVersion().hasBlobBaseFee())
+		CHECK_ERROR(
+			blobBaseFeeContract,
+			TypeError,
+			"\"blobbasefee\" is not supported by the VM version."
+		);
+	else
+		CHECK_SUCCESS_NO_WARNINGS(blobBaseFeeContract);
+}
+
+BOOST_AUTO_TEST_CASE(address_staticcall)
+{
+	std::string text = R"(
+		contract C {
+			function i() view public returns (bool) {
+				(bool success,) = address(0x4242).staticcall("");
+				return success;
+			}
+		}
+	)";
+	if (!solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+		CHECK_ERROR(text, TypeError, "\"staticcall\" is not supported by the VM version.");
+	else
+		CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+
+BOOST_AUTO_TEST_CASE(assembly_staticcall)
+{
+	std::string text = R"(
+		contract C {
+			function i() view public {
+				assembly { pop(staticcall(gas(), 1, 2, 3, 4, 5)) }
+			}
+		}
+	)";
+	if (solidity::test::CommonOptions::get().evmVersion().hasStaticCall())
+		CHECK_SUCCESS_NO_WARNINGS(text);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/analysis/FunctionCallGraph.cpp b/compiler/test/libsolidity/analysis/FunctionCallGraph.cpp
new file mode 100644
index 00000000..d9193276
--- /dev/null
+++ b/compiler/test/libsolidity/analysis/FunctionCallGraph.cpp
@@ -0,0 +1,2235 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for libsolidity/analysis/FunctionCallGraph.h
+
+#include <libsolidity/analysis/FunctionCallGraph.h>
+
+#include <test/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/CommonData.h>
+
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/CompilerStack.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <range/v3/action/sort.hpp>
+#include <range/v3/algorithm/all_of.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/join.hpp>
+#include <range/v3/view/map.hpp>
+#include <range/v3/view/remove_if.hpp>
+#include <range/v3/view/set_algorithm.hpp>
+#include <range/v3/view/transform.hpp>
+
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <tuple>
+#include <vector>
+
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace std::string_literals;
+
+using EdgeMap = std::map<
+	CallGraph::Node,
+	std::set<CallGraph::Node, CallGraph::CompareByID>,
+	CallGraph::CompareByID
+>;
+using EdgeNames = std::set<std::tuple<std::string, std::string>>;
+using CallGraphMap = std::map<std::string, CallGraph const*>;
+
+namespace
+{
+
+std::unique_ptr<CompilerStack> parseAndAnalyzeContracts(std::string _sourceCode)
+{
+	ReadCallback::Callback fileReader = [](std::string const&, std::string const&)
+	{
+		soltestAssert(false, "For simplicity this test suite supports only files without imports.");
+		return ReadCallback::Result{true, ""};
+	};
+
+	auto compilerStack = std::make_unique<CompilerStack>(fileReader);
+	compilerStack->setSources({{"", _sourceCode}});
+
+	// NOTE: The code in test cases is expected to be correct so we can keep error handling simple
+	// here and just assert that there are no errors.
+	bool success = compilerStack->parseAndAnalyze();
+	soltestAssert(success, "");
+
+	soltestAssert(
+		ranges::all_of(
+			compilerStack->ast("").nodes(),
+			[](auto const& _node){ return !dynamic_cast<ImportDirective const*>(_node.get()); }
+		),
+		"For simplicity this test suite supports only files without imports."
+	);
+
+	return compilerStack;
+}
+
+EdgeNames edgeNames(EdgeMap const& _edgeMap)
+{
+	EdgeNames names;
+
+	for (auto const& [edgeStart, allEnds]: _edgeMap)
+		for (auto const& edgeEnd: allEnds)
+			names.emplace(toString(edgeStart), toString(edgeEnd));
+
+	return names;
+}
+
+std::tuple<CallGraphMap, CallGraphMap> collectGraphs(CompilerStack const& _compilerStack)
+{
+	soltestAssert(_compilerStack.state() >= CompilerStack::State::AnalysisSuccessful);
+
+	std::tuple<CallGraphMap, CallGraphMap> graphs;
+
+	for (std::string const& fullyQualifiedContractName: _compilerStack.contractNames())
+	{
+		soltestAssert(std::get<0>(graphs).count(fullyQualifiedContractName) == 0 && std::get<1>(graphs).count(fullyQualifiedContractName) == 0, "");
+
+		// This relies on two assumptions: (1) CompilerStack received an empty string as a path for
+		// the contract and (2) contracts used in test cases have no imports.
+		soltestAssert(fullyQualifiedContractName.size() > 0 && fullyQualifiedContractName[0] == ':', "");
+		std::string contractName = fullyQualifiedContractName.substr(1);
+
+		std::get<0>(graphs).emplace(contractName, _compilerStack.contractDefinition(fullyQualifiedContractName).annotation().creationCallGraph->get());
+		std::get<1>(graphs).emplace(contractName, _compilerStack.contractDefinition(fullyQualifiedContractName).annotation().deployedCallGraph->get());
+	}
+
+	return graphs;
+}
+
+void checkCallGraphExpectations(
+	CallGraphMap const& _callGraphs,
+	std::map<std::string, EdgeNames> const& _expectedEdges,
+	std::map<std::string, std::set<std::string>> const& _expectedCreatedContractSets = {},
+	std::map<std::string, std::set<std::string>> const& _expectedEmittedEventSets = {}
+)
+{
+	auto getContractName = [](ContractDefinition const* _contract){ return _contract->name(); };
+	auto eventToString = [](EventDefinition const* _event){ return toString(CallGraph::Node(_event)); };
+	auto notEmpty = [](std::set<std::string> const& _set){ return !_set.empty(); };
+
+	soltestAssert(
+		(_expectedCreatedContractSets | ranges::views::values | ranges::views::remove_if(notEmpty)).empty(),
+		"Contracts that are not expected to create other contracts should not be included in _expectedCreatedContractSets."
+	);
+	soltestAssert(
+		(_expectedEdges | ranges::views::keys | ranges::to<std::set>()) == (_callGraphs | ranges::views::keys | ranges::to<std::set>()) &&
+		(ranges::views::set_difference(_expectedCreatedContractSets | ranges::views::keys, _expectedEdges | ranges::views::keys)).empty(),
+		"Contracts listed in expectations do not match contracts actually found in the source file or in other expectations."
+	);
+	for (std::string const& contractName: _expectedEdges | ranges::views::keys)
+	{
+		soltestAssert(
+			(ranges::views::set_difference(valueOrDefault(_expectedCreatedContractSets, contractName, {}), _expectedEdges | ranges::views::keys)).empty(),
+			"Inconsistent expectations: contract expected to be created but not to be present in the source file."
+		);
+	}
+
+	std::map<std::string, EdgeNames> edges;
+	std::map<std::string, std::set<std::string>> createdContractSets;
+	std::map<std::string, std::set<std::string>> emittedEventSets;
+	for (std::string const& contractName: _expectedEdges | ranges::views::keys)
+	{
+		soltestAssert(_callGraphs.at(contractName) != nullptr, "");
+		CallGraph const& callGraph = *_callGraphs.at(contractName);
+
+		edges[contractName] = edgeNames(callGraph.edges);
+		if (!callGraph.bytecodeDependency.empty())
+			createdContractSets[contractName] = callGraph.bytecodeDependency |
+				ranges::views::keys |
+				ranges::views::transform(getContractName) |
+				ranges::to<std::set<std::string>>();
+		if (!callGraph.emittedEvents.empty())
+			emittedEventSets[contractName] = callGraph.emittedEvents |
+				 ranges::views::transform(eventToString) |
+				 ranges::to<std::set<std::string>>();
+	}
+
+	BOOST_CHECK_EQUAL(edges, _expectedEdges);
+	BOOST_CHECK_EQUAL(createdContractSets, _expectedCreatedContractSets);
+	BOOST_CHECK_EQUAL(emittedEventSets, _expectedEmittedEventSets);
+}
+
+std::ostream& operator<<(std::ostream& _out, EdgeNames const& _edgeNames)
+{
+	for (auto const& [from, to]: _edgeNames)
+		_out << "    " << from << " -> " << to << std::endl;
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, std::set<std::string> const& _set)
+{
+	_out << "{" << (_set | ranges::views::join(", ") | ranges::to<std::string>()) << "}";
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, std::map<std::string, EdgeNames> const& _edgeSets)
+{
+	// Extra newline for error report readability. Otherwise the first line does not start at the first column.
+	_out << std::endl;
+
+	for (auto const &[contractName, edges]: _edgeSets)
+	{
+		_out << contractName << ":" << std::endl;
+		_out << edges;
+	}
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, std::map<std::string, std::set<std::string>> const& _map)
+{
+	// Extra newline for error report readability. Otherwise the first line does not start at the first column.
+	_out << std::endl;
+
+	for (auto const &[key, value]: _map)
+		_out << key << ": " << value << std::endl;
+	return _out;
+}
+
+} // namespace
+
+namespace boost::test_tools::tt_detail
+{
+
+// Boost won't find the << operator unless we put it in the std namespace which is illegal.
+// The recommended solution is to overload print_log_value<> struct and make it use our operator.
+
+template<>
+struct print_log_value<EdgeNames>
+{
+	void operator()(std::ostream& _output, EdgeNames const& _edgeNames) { ::operator<<(_output, _edgeNames); }
+};
+
+template<>
+struct print_log_value<std::set<std::string>>
+{
+	void operator()(std::ostream& _output, std::set<std::string> const& _set) { ::operator<<(_output, _set); }
+};
+
+template<>
+struct print_log_value<std::map<std::string, EdgeNames>>
+{
+	void operator()(std::ostream& _output, std::map<std::string, EdgeNames> const& _edgeSets) { ::operator<<(_output, _edgeSets); }
+};
+
+template<>
+struct print_log_value<std::map<std::string, std::set<std::string>>>
+{
+	void operator()(std::ostream& _output, std::map<std::string, std::set<std::string>> const& _map) { ::operator<<(_output, _map); }
+};
+
+} // namespace boost::test_tools::tt_detail
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(FunctionCallGraphTest)
+
+BOOST_AUTO_TEST_CASE(only_definitions)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() {}
+
+		library L {
+			function ext() external {}
+			function pub() public {}
+			function inr() internal {}
+			function prv() private {}
+		}
+
+		contract C {
+			function ext() external {}
+			function pub() public {}
+			function inr() internal {}
+			function prv() private {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+			{"Entry", "function C.pub()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+			{"Entry", "function L.pub()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(ordinary_calls)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() {}
+
+		library L {
+			function ext() external { pub(); inr(); }
+			function pub() public { inr(); }
+			function inr() internal { prv(); }
+			function prv() private { free(); free(); }
+		}
+
+		contract C {
+			function ext() external { pub(); }
+			function pub() public { inr(); prv(); free(); }
+			function inr() internal { prv(); L.inr(); }
+			function prv() private { free(); free(); }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+			{"Entry", "function C.pub()"},
+			{"function C.ext()", "function C.pub()"},
+			{"function C.pub()", "function C.inr()"},
+			{"function C.pub()", "function C.prv()"},
+			{"function C.pub()", "function free()"},
+			{"function C.inr()", "function C.prv()"},
+			{"function C.inr()", "function L.inr()"},
+			{"function C.prv()", "function free()"},
+			{"function L.inr()", "function L.prv()"},
+			{"function L.prv()", "function free()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+			{"Entry", "function L.pub()"},
+			{"function L.ext()", "function L.pub()"},
+			{"function L.ext()", "function L.inr()"},
+			{"function L.pub()", "function L.inr()"},
+			{"function L.inr()", "function L.prv()"},
+			{"function L.prv()", "function free()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(call_chains_through_externals)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		library L {
+			function ext() external { C(address(0x0)).ext(); }
+			function pub() public {}
+			function inr() internal {}
+			function prv() private {}
+		}
+
+		contract C {
+			function ext() external {}
+			function pub() public {}
+			function inr() internal {}
+			function prv() private {}
+
+			function ext2() external { this.ext(); this.pub(); L.ext(); L.pub(); }
+			function pub2() public { this.ext(); this.pub(); L.ext(); L.pub(); }
+			function pub3() public { C(address(0x0)).ext(); }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+			{"Entry", "function C.ext2()"},
+			{"Entry", "function C.pub()"},
+			{"Entry", "function C.pub2()"},
+			{"Entry", "function C.pub3()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+			{"Entry", "function L.pub()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(calls_from_constructors)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() returns (uint) {}
+
+		library L {
+			function ext() external {}
+		}
+
+		contract C {
+			constructor() { this.ext(); inr(); L.ext(); free(); }
+
+			function ext() external {}
+			function inr() internal {}
+		}
+
+		contract D {
+			uint a = this.ext();
+			uint b = inr();
+			uint c = free();
+
+			function ext() external returns (uint) {}
+			function inr() internal returns (uint) {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {
+			{"Entry", "constructor of C"},
+			{"constructor of C", "function C.inr()"},
+			{"constructor of C", "function free()"},
+		}},
+		{"D", {
+			{"Entry", "function D.inr()"},
+			{"Entry", "function free()"},
+		}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+		}},
+		{"D", {
+			{"Entry", "function D.ext()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(calls_to_constructors)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() { new D(); }
+
+		library L {
+			function ext() external { new C(); new D(); inr(); }
+			function inr() internal { new C(); new D(); free(); }
+		}
+
+		contract C {
+			constructor() { new D(); }
+
+			function ext() external { new D(); inr(); }
+			function inr() internal { new D(); free(); }
+		}
+
+		contract D {}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {
+			{"Entry", "constructor of C"},
+		}},
+		{"D", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+			{"function C.ext()", "function C.inr()"},
+			{"function C.inr()", "function free()"},
+		}},
+		{"D", {}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+			{"function L.ext()", "function L.inr()"},
+			{"function L.inr()", "function free()"},
+		}},
+	};
+
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAtCreation = {
+		{"C", {"D"}},
+	};
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAfterDeployment = {
+		{"C", {"D"}},
+		{"L", {"C", "D"}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges, expectedCreatedContractsAtCreation);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges, expectedCreatedContractsAfterDeployment);
+}
+
+BOOST_AUTO_TEST_CASE(inherited_constructors)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() {}
+
+		library L {
+			function ext() external { inr(); }
+			function inr() internal { free(); }
+		}
+
+		contract C {
+			constructor() { inrC(); free(); }
+
+			function extC() external returns (uint) { inrC(); }
+			function inrC() internal returns (uint) { free(); }
+		}
+
+		contract D {
+			constructor() { L.ext(); }
+		}
+
+		contract E is C {
+			uint e2 = this.extE();
+			uint i2 = inrE();
+
+			function extE() external returns (uint) { inrE(); }
+			function inrE() internal returns (uint) { free(); }
+		}
+
+		contract F is C, D(), E {
+			uint e3 = this.extF();
+			uint i3 = inrF();
+
+			constructor() E() C() {}
+
+			function extF() external returns (uint) { inrF(); }
+			function inrF() internal returns (uint) { free(); }
+		}
+
+		contract G is E() {
+			function extG() external returns (uint) { new F(); }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {
+			{"Entry", "constructor of C"},
+			{"constructor of C", "function C.inrC()"},
+			{"constructor of C", "function free()"},
+			{"function C.inrC()", "function free()"},
+		}},
+		{"D", {
+			{"Entry", "constructor of D"},
+		}},
+		{"E", {
+			{"Entry", "constructor of C"},
+			{"Entry", "function E.inrE()"},
+			{"constructor of C", "function C.inrC()"},
+			{"constructor of C", "function free()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+		}},
+		{"F", {
+			{"Entry", "constructor of C"},
+			{"Entry", "constructor of D"},
+			{"Entry", "constructor of F"},
+			{"Entry", "function E.inrE()"},
+			{"Entry", "function F.inrF()"},
+			{"constructor of C", "function C.inrC()"},
+			{"constructor of C", "function free()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+			{"function F.inrF()", "function free()"},
+		}},
+		{"G", {
+			{"Entry", "constructor of C"},
+			{"Entry", "function E.inrE()"},
+			{"constructor of C", "function C.inrC()"},
+			{"constructor of C", "function free()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+		}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.extC()"},
+			{"function C.extC()", "function C.inrC()"},
+			{"function C.inrC()", "function free()"},
+		}},
+		{"D", {}},
+		{"E", {
+			{"Entry", "function C.extC()"},
+			{"Entry", "function E.extE()"},
+			{"function C.extC()", "function C.inrC()"},
+			{"function E.extE()", "function E.inrE()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+		}},
+		{"F", {
+			{"Entry", "function C.extC()"},
+			{"Entry", "function E.extE()"},
+			{"Entry", "function F.extF()"},
+			{"function C.extC()", "function C.inrC()"},
+			{"function E.extE()", "function E.inrE()"},
+			{"function F.extF()", "function F.inrF()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+			{"function F.inrF()", "function free()"},
+		}},
+		{"G", {
+			{"Entry", "function C.extC()"},
+			{"Entry", "function E.extE()"},
+			{"Entry", "function G.extG()"},
+			{"function C.extC()", "function C.inrC()"},
+			{"function E.extE()", "function E.inrE()"},
+			{"function C.inrC()", "function free()"},
+			{"function E.inrE()", "function free()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+			{"function L.ext()", "function L.inr()"},
+			{"function L.inr()", "function free()"},
+		}},
+	};
+
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAtCreation = {};
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAfterDeployment = {
+		{"G", {"F"}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges, expectedCreatedContractsAtCreation);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges, expectedCreatedContractsAfterDeployment);
+}
+
+BOOST_AUTO_TEST_CASE(inheritance_specifiers)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function fD() returns (uint) {}
+		function fE() returns (uint) {}
+		function fFD() returns (uint) {}
+		function fFE() returns (uint) {}
+		function fG() returns (uint) {}
+
+		function fVarC() returns (uint) {}
+		function fVarD() returns (uint) {}
+		function fVarE() returns (uint) {}
+		function fVarF() returns (uint) {}
+
+		contract C {
+			uint c = fVarC();
+
+			constructor (uint) {}
+		}
+
+		contract D is C(fD()) {
+			uint d = fVarD();
+
+			constructor (uint) {}
+		}
+
+		abstract contract E is C {
+			uint e = fVarE();
+
+			constructor (uint) {}
+		}
+
+		contract F is D(fFD()), E {
+			uint f = fVarF();
+
+			constructor (uint) E(fFE()) {}
+		}
+
+		contract G is D(fG()), E(fG()) {}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {
+			{"Entry", "constructor of C"},
+			{"Entry", "function fVarC()"},
+		}},
+		{"D", {
+			{"Entry", "constructor of C"},
+			{"Entry", "constructor of D"},
+			{"Entry", "function fVarC()"},
+			{"Entry", "function fVarD()"},
+			{"constructor of D", "function fD()"},
+		}},
+		{"E", {
+			{"Entry", "constructor of C"},
+			{"Entry", "constructor of E"},
+			{"Entry", "function fVarC()"},
+			{"Entry", "function fVarE()"},
+		}},
+		{"F", {
+			{"Entry", "constructor of C"},
+			{"Entry", "constructor of D"},
+			{"Entry", "constructor of E"},
+			{"Entry", "constructor of F"},
+			{"Entry", "function fVarC()"},
+			{"Entry", "function fVarD()"},
+			{"Entry", "function fVarE()"},
+			{"Entry", "function fVarF()"},
+			{"constructor of D", "function fD()"},
+			{"constructor of F", "function fFD()"},
+			{"constructor of F", "function fFE()"},
+		}},
+		{"G", {
+			{"Entry", "constructor of C"},
+			{"Entry", "constructor of D"},
+			{"Entry", "constructor of E"},
+			// G, unlike F, has no constructor so fG() gets an edge from Entry.
+			{"Entry", "function fG()"},
+			{"Entry", "function fVarC()"},
+			{"Entry", "function fVarD()"},
+			{"Entry", "function fVarE()"},
+			{"constructor of D", "function fD()"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"E", {}},
+		{"F", {}},
+		{"G", {}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(inherited_functions_virtual_and_super)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			function f() internal {}
+			function g() internal virtual {}
+			function h() internal virtual {}
+
+			function ext() external virtual {}
+		}
+
+		contract D {
+			function h() internal virtual {}
+
+			function ext() external virtual {}
+		}
+
+		contract E is C, D {
+			function g() internal override {}
+			function h() internal override(C, D) {}
+			function i() internal {}
+
+			function ext() external override(C, D) {}
+
+			function callF() external { f(); }
+			function callG() external { g(); }
+			function callH() external { h(); }
+			function callI() external { i(); }
+			function callCF() external { C.f(); }
+			function callCG() external { C.g(); }
+			function callCH() external { C.h(); }
+			function callDH() external { D.h(); }
+			function callEI() external { E.i(); }
+			function callSuperF() external { super.f(); }
+			function callSuperG() external { super.g(); }
+			function callSuperH() external { super.h(); }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"E", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+		}},
+		{"D", {
+			{"Entry", "function D.ext()"},
+		}},
+		{"E", {
+			{"Entry", "function E.callF()"},
+			{"Entry", "function E.callG()"},
+			{"Entry", "function E.callH()"},
+			{"Entry", "function E.callI()"},
+			{"Entry", "function E.callCF()"},
+			{"Entry", "function E.callCG()"},
+			{"Entry", "function E.callCH()"},
+			{"Entry", "function E.callDH()"},
+			{"Entry", "function E.callEI()"},
+			{"Entry", "function E.callSuperF()"},
+			{"Entry", "function E.callSuperG()"},
+			{"Entry", "function E.callSuperH()"},
+			{"Entry", "function E.ext()"},
+			{"function E.callF()", "function C.f()"},
+			{"function E.callG()", "function E.g()"},
+			{"function E.callH()", "function E.h()"},
+			{"function E.callI()", "function E.i()"},
+			{"function E.callCF()", "function C.f()"},
+			{"function E.callCG()", "function C.g()"},
+			{"function E.callCH()", "function C.h()"},
+			{"function E.callDH()", "function D.h()"},
+			{"function E.callEI()", "function E.i()"},
+			{"function E.callSuperF()", "function C.f()"},
+			{"function E.callSuperG()", "function C.g()"},
+			{"function E.callSuperH()", "function D.h()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(overloaded_functions)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		enum E {E1, E2, E3}
+
+		function free() {}
+		function free(uint) {}
+		function free(bytes memory) {}
+		function free(E) {}
+
+		contract C {
+			function f(E) internal {}
+			function f(bool) external {}
+		}
+
+		contract D is C {
+			function ext1() external { free(); free(123); free("123"); }
+			function ext2() external { f(); f(123); f("123"); }
+			function ext3() external { free(E.E2); f(E.E2); }
+			function ext4() external { this.f(false); }
+
+			function f() internal {}
+			function f(uint) internal {}
+			function f(bytes memory) internal {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.f(bool)"},
+		}},
+		{"D", {
+			{"Entry", "function C.f(bool)"},
+			{"Entry", "function D.ext1()"},
+			{"Entry", "function D.ext2()"},
+			{"Entry", "function D.ext3()"},
+			{"Entry", "function D.ext4()"},
+			{"function D.ext1()", "function free()"},
+			{"function D.ext1()", "function free(uint256)"},
+			{"function D.ext1()", "function free(bytes)"},
+			{"function D.ext2()", "function D.f()"},
+			{"function D.ext2()", "function D.f(uint256)"},
+			{"function D.ext2()", "function D.f(bytes)"},
+			{"function D.ext3()", "function free(enum E)"},
+			{"function D.ext3()", "function C.f(enum E)"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(modifiers)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		library L {
+			modifier m() { g(); _; }
+
+			function f() m internal {}
+			function g() internal {}
+		}
+
+		contract C {
+			modifier m1() virtual { _; }
+
+			function q() m1 internal virtual { L.f(); }
+		}
+
+		contract D is C {
+			modifier m2() { q(); _; new C(); }
+
+			function p() m2 internal { C.q(); }
+			function q() m2 internal override virtual {}
+		}
+
+		contract E is D {
+			modifier m1() override { _; }
+			modifier m3() { p(); _; }
+
+			constructor() D() m1 E.m3 {}
+			function ext() external m1 E.m3 { inr(); }
+			function inr() internal m1 E.m3 { L.f(); }
+
+			function q() internal override {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"L", {}},
+		{"E", {
+			{"Entry", "constructor of E"},
+			{"constructor of E", "modifier E.m1"},
+			{"constructor of E", "modifier E.m3"},
+			{"function C.q()", "modifier E.m1"},
+			{"function C.q()", "function L.f()"},
+			{"function D.p()", "modifier D.m2"},
+			{"function D.p()", "function C.q()"},
+			{"function L.f()", "modifier L.m"},
+			{"modifier L.m", "function L.g()"},
+			{"modifier D.m2", "function E.q()"},
+			{"modifier E.m3", "function D.p()"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"L", {}},
+		{"E", {
+			{"Entry", "function E.ext()"},
+			{"function C.q()", "modifier E.m1"},
+			{"function C.q()", "function L.f()"},
+			{"function D.p()", "modifier D.m2"},
+			{"function D.p()", "function C.q()"},
+			{"function L.f()", "modifier L.m"},
+			{"function E.ext()", "function E.inr()"},
+			{"function E.ext()", "modifier E.m1"},
+			{"function E.ext()", "modifier E.m3"},
+			{"function E.inr()", "modifier E.m1"},
+			{"function E.inr()", "modifier E.m3"},
+			{"function E.inr()", "function L.f()"},
+			{"modifier L.m", "function L.g()"},
+			{"modifier D.m2", "function E.q()"},
+			{"modifier E.m3", "function D.p()"},
+		}},
+	};
+
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAtCreation = {{"E", {"C"}}};
+	std::map<std::string, std::set<std::string>> expectedCreatedContractsAfterDeployment = {{"E", {"C"}}};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges, expectedCreatedContractsAtCreation);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges, expectedCreatedContractsAfterDeployment);
+}
+
+BOOST_AUTO_TEST_CASE(events)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() { emit L.Ev(); }
+
+		library L {
+			event Ev();
+			event Ev(bytes4, string indexed);
+
+			function ext() external { emit Ev(); }
+			function inr() internal { emit Ev(0x12345678, "a"); emit L.Ev(); }
+		}
+
+		contract C {
+			event EvC(uint) anonymous;
+
+			modifier m() { emit EvC(1); _; }
+		}
+
+		contract D is C {
+			event EvD1(uint);
+			event EvD2(uint);
+
+			function ext() m external { emit D.EvD1(1); emit EvC(f()); inr(); }
+			function inr() m internal { emit EvD1(1); emit C.EvC(f()); L.inr(); free(); EvD2; }
+
+			function f() internal returns (uint) {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {}},
+		{"D", {
+			{"Entry", "function D.ext()"},
+			{"function D.ext()", "function D.inr()"},
+			{"function D.ext()", "modifier C.m"},
+			{"function D.ext()", "function D.f()"},
+			{"function D.inr()", "function L.inr()"},
+			{"function D.inr()", "function free()"},
+			{"function D.inr()", "modifier C.m"},
+			{"function D.inr()", "function D.f()"},
+		}},
+		{"L", {
+			{"Entry", "function L.ext()"},
+		}},
+	};
+
+	std::map<std::string, std::set<std::string>> expectedCreationEvents = {};
+	std::map<std::string, std::set<std::string>> expectedDeployedEvents = {
+		{"D", {
+			"event D.EvD1(uint256)",
+			"event C.EvC(uint256)",
+			"event L.Ev(bytes4,string)",
+			"event L.Ev()",
+		}},
+		{"L", {
+			"event L.Ev()",
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges, {}, expectedCreationEvents);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges, {}, expectedDeployedEvents);
+}
+
+BOOST_AUTO_TEST_CASE(cycles)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free1() { free1(); }
+		function free2() { free3(); }
+		function free3() { free2(); }
+
+		library L {
+			function inr1() internal { inr1(); }
+			function inr2() internal { inr3(); }
+			function inr3() internal { inr2(); }
+		}
+
+		contract C {
+			function virt() internal virtual { virt(); }
+		}
+
+		contract D is C {
+			function init() external { this.ext1(); inr1(); inr2(); L.inr1(); L.inr2(); free1(); free2(); virt(); }
+
+			function ext1() external { this.ext1(); }
+			function ext2() external { this.ext3(); }
+			function ext3() external { this.ext2(); }
+			function inr1() internal { inr1(); }
+			function inr2() internal { inr3(); }
+			function inr3() internal { inr2(); }
+			function inr3(uint) internal {}
+
+			function virt() internal override { C.virt(); }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"L", {}},
+		{"C", {}},
+		{"D", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"L", {}},
+		{"C", {}},
+		{"D", {
+			{"Entry", "function D.init()"},
+			{"Entry", "function D.ext1()"},
+			{"Entry", "function D.ext2()"},
+			{"Entry", "function D.ext3()"},
+			{"function D.init()", "function D.inr1()"},
+			{"function D.init()", "function D.inr2()"},
+			{"function D.init()", "function D.virt()"},
+			{"function D.init()", "function L.inr1()"},
+			{"function D.init()", "function L.inr2()"},
+			{"function D.init()", "function free1()"},
+			{"function D.init()", "function free2()"},
+			{"function D.inr1()", "function D.inr1()"},
+			{"function D.inr2()", "function D.inr3()"},
+			{"function D.inr3()", "function D.inr2()"},
+			{"function D.virt()", "function C.virt()"},
+			{"function C.virt()", "function D.virt()"},
+			{"function L.inr1()", "function L.inr1()"},
+			{"function L.inr2()", "function L.inr3()"},
+			{"function L.inr3()", "function L.inr2()"},
+			{"function free1()", "function free1()"},
+			{"function free2()", "function free3()"},
+			{"function free3()", "function free2()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(interfaces_and_abstract_contracts)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		interface I {
+			event Ev(uint);
+
+			function ext1() external;
+			function ext2() external;
+		}
+
+		interface J is I {
+			function ext2() external override;
+			function ext3() external;
+		}
+
+		abstract contract C is J {
+			modifier m() virtual;
+
+			function ext3() external override virtual;
+			function ext4() external { inr2();}
+			function inr1() internal virtual;
+			function inr2() m internal { inr1(); this.ext1(); this.ext2(); this.ext3(); }
+		}
+
+		contract D is C {
+			function ext1() public override { emit I.Ev(1); inr1(); inr2(); }
+			function ext2() external override { I(this).ext1(); }
+			function ext3() external override {}
+			function inr1() internal override {}
+
+			modifier m() override { _; }
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"I", {}},
+		{"J", {}},
+		{"C", {}},
+		{"D", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"I", {
+			{"Entry", "function I.ext1()"},
+			{"Entry", "function I.ext2()"},
+		}},
+		{"J", {
+			{"Entry", "function I.ext1()"},
+			{"Entry", "function J.ext2()"},
+			{"Entry", "function J.ext3()"},
+		}},
+		{"C", {
+			{"Entry", "function I.ext1()"},
+			{"Entry", "function J.ext2()"},
+			{"Entry", "function C.ext3()"},
+			{"Entry", "function C.ext4()"},
+			{"function C.ext4()", "function C.inr2()"},
+			{"function C.inr2()", "function C.inr1()"},
+			{"function C.inr2()", "modifier C.m"},
+		}},
+		{"D", {
+			{"Entry", "function D.ext1()"},
+			{"Entry", "function D.ext2()"},
+			{"Entry", "function D.ext3()"},
+			{"Entry", "function C.ext4()"},
+			{"function C.ext4()", "function C.inr2()"},
+			{"function C.inr2()", "function D.inr1()"},
+			{"function C.inr2()", "modifier D.m"},
+			{"function D.ext1()", "function D.inr1()"},
+			{"function D.ext1()", "function C.inr2()"},
+		}},
+	};
+
+	std::map<std::string, std::set<std::string>> expectedCreationEvents = {};
+	std::map<std::string, std::set<std::string>> expectedDeployedEvents = {
+		{"D", {
+			"event I.Ev(uint256)",
+		}},
+	};
+
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges, {}, expectedCreationEvents);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges, {}, expectedDeployedEvents);
+}
+
+BOOST_AUTO_TEST_CASE(indirect_calls)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free1() {}
+		function free2() {}
+		function free3() {}
+
+		library L {
+			function ext() external {}
+			function inr1() internal {}
+			function inr2() internal {}
+			function inr3() internal {}
+
+			function access() public {
+				free1;
+				inr1;
+				L.ext;
+			}
+
+			function expression() public {
+				(free2)();
+				(inr2)();
+			}
+		}
+
+		contract C {
+			function ext1() external {}
+			function ext2() external {}
+			function ext3() external {}
+			function inr1() internal {}
+			function inr2() internal {}
+			function inr3() internal {}
+
+			function access() public {
+				this.ext1;
+				inr1;
+				free1;
+				L.inr1;
+				L.ext;
+			}
+
+			function expression() public {
+				(this.ext2)();
+				(inr2)();
+				(free2)();
+				(L.inr2)();
+				(L.ext)();
+			}
+		}
+
+		contract D is C {
+			constructor() {
+				access();
+				expression();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"L", {}},
+		{"C", {}},
+		{"D", {
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function C.inr1()"},
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"Entry", "constructor of D"},
+			{"constructor of D", "function C.access()"},
+			{"constructor of D", "function C.expression()"},
+			{"function C.expression()", "InternalDispatch"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"L", {
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"Entry", "function L.ext()"},
+			{"Entry", "function L.access()"},
+			{"Entry", "function L.expression()"},
+			{"function L.expression()", "InternalDispatch"},
+		}},
+		{"C", {
+			{"InternalDispatch", "function C.inr1()"},
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"Entry", "function C.ext1()"},
+			{"Entry", "function C.ext2()"},
+			{"Entry", "function C.ext3()"},
+			{"Entry", "function C.access()"},
+			{"Entry", "function C.expression()"},
+			{"function C.expression()", "InternalDispatch"},
+		}},
+		{"D", {
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function C.inr1()"},
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"Entry", "function C.ext1()"},
+			{"Entry", "function C.ext2()"},
+			{"Entry", "function C.ext3()"},
+			{"Entry", "function C.access()"},
+			{"Entry", "function C.expression()"},
+			{"function C.expression()", "InternalDispatch"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(calls_via_pointers)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free1() {}
+		function free2() {}
+		function free3() {}
+
+		library L {
+			function inr1() internal {}
+			function inr2() internal {}
+			function inr3() internal {}
+
+			function callPtrs(
+				function () external e,
+				function () internal i,
+				function () internal f,
+				function () internal l
+			) internal
+			{
+				e();
+				i();
+				f();
+				l();
+			}
+		}
+
+		contract C {
+			function ext1() external {}
+			function ext2() external {}
+			function ext3() external {}
+			function inr1() internal {}
+			function inr2() internal {}
+			function inr3() internal {}
+
+			function getPtrs2() internal returns (
+				function () external,
+				function () internal,
+				function () internal,
+				function () internal
+			)
+			{
+				return (this.ext2, inr2, free2, L.inr2);
+			}
+
+			function testLocalVars() public {
+				(function () external e, function () i, function () f, function () l) = getPtrs2();
+				L.callPtrs(e, i, f, l);
+			}
+		}
+
+		contract D is C {
+			function () external m_e = this.ext1;
+			function () internal m_i = inr1;
+			function () internal m_f = free1;
+			function () internal m_l = L.inr1;
+			function () internal immutable m_imm = inr1;
+
+			function callStatePtrs() internal {
+				m_e();
+				m_i();
+				m_f();
+				m_l();
+			}
+
+			function updateStatePtrs(
+				function () external e,
+				function () internal i,
+				function () internal f,
+				function () internal l
+			) internal
+			{
+				m_e = e;
+				m_i = i;
+				m_f = f;
+				m_l = l;
+			}
+
+			function testStateVars() public {
+				(function () external e, function () i, function () f, function () l) = getPtrs2();
+				updateStatePtrs(e, i, f, l);
+				callStatePtrs();
+			}
+
+			function testImmutablePtr() public {
+				m_imm();
+			}
+
+			constructor() {
+				testStateVars();
+				testLocalVars();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"L", {}},
+		{"C", {}},
+		{"D", {
+			{"InternalDispatch", "function C.inr1()"},
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"Entry", "constructor of D"},
+			{"constructor of D", "function C.testLocalVars()"},
+			{"constructor of D", "function D.testStateVars()"},
+			{"function C.testLocalVars()", "function C.getPtrs2()"},
+			{"function C.testLocalVars()", "function L.callPtrs(function () external,function (),function (),function ())"},
+			{"function D.testStateVars()", "function C.getPtrs2()"},
+			{"function D.testStateVars()", "function D.updateStatePtrs(function () external,function (),function (),function ())"},
+			{"function D.testStateVars()", "function D.callStatePtrs()"},
+			{"function D.callStatePtrs()", "InternalDispatch"},
+			{"function L.callPtrs(function () external,function (),function (),function ())", "InternalDispatch"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"L", {}},
+		{"C", {
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function free2()"},
+			{"Entry", "function C.ext1()"},
+			{"Entry", "function C.ext2()"},
+			{"Entry", "function C.ext3()"},
+			{"Entry", "function C.testLocalVars()"},
+			{"function C.testLocalVars()", "function C.getPtrs2()"},
+			{"function C.testLocalVars()", "function L.callPtrs(function () external,function (),function (),function ())"},
+			{"function L.callPtrs(function () external,function (),function (),function ())", "InternalDispatch"},
+		}},
+		{"D", {
+			{"InternalDispatch", "function C.inr1()"},
+			{"InternalDispatch", "function C.inr2()"},
+			{"InternalDispatch", "function L.inr1()"},
+			{"InternalDispatch", "function L.inr2()"},
+			{"InternalDispatch", "function free1()"},
+			{"InternalDispatch", "function free2()"},
+			{"Entry", "function C.ext1()"},
+			{"Entry", "function C.ext2()"},
+			{"Entry", "function C.ext3()"},
+			{"Entry", "function C.testLocalVars()"},
+			{"Entry", "function D.testStateVars()"},
+			{"Entry", "function D.testImmutablePtr()"},
+			{"function C.testLocalVars()", "function C.getPtrs2()"},
+			{"function C.testLocalVars()", "function L.callPtrs(function () external,function (),function (),function ())"},
+			{"function D.testStateVars()", "function C.getPtrs2()"},
+			{"function D.testStateVars()", "function D.updateStatePtrs(function () external,function (),function (),function ())"},
+			{"function D.testStateVars()", "function D.callStatePtrs()"},
+			{"function D.testImmutablePtr()", "InternalDispatch"},
+			{"function D.callStatePtrs()", "InternalDispatch"},
+			{"function L.callPtrs(function () external,function (),function (),function ())", "InternalDispatch"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(pointer_to_overridden_function)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			function f() internal virtual {}
+		}
+
+		contract D is C {
+			function f() internal override {}
+
+			function getF() internal returns (function ()) {
+				return C.f;
+			}
+
+			function getSuperF() internal returns (function ()) {
+				return super.f;
+			}
+
+			function test1() public {
+				getF()();
+			}
+
+			function test2() public {
+				getSuperF()();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {}},
+		{"D", {
+			{"InternalDispatch", "function C.f()"},
+			{"Entry", "function D.test1()"},
+			{"Entry", "function D.test2()"},
+			{"function D.test1()", "function D.getF()"},
+			{"function D.test1()", "InternalDispatch"},
+			{"function D.test2()", "function D.getSuperF()"},
+			{"function D.test2()", "InternalDispatch"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(pointer_to_nonexistent_function)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		interface I {
+			function f() external;
+		}
+
+		abstract contract C is I {
+			function g() internal virtual;
+
+			function getF() internal returns (function () external) { return this.f; }
+			function getG() internal returns (function () internal) { return g; }
+
+			function testInterface() public {
+				getF()();
+				getG()();
+			}
+
+			function testBadPtr() public {
+				function () ptr;
+				ptr();
+			}
+		}
+
+		contract D is C {
+			function f() public override {}
+			function g() internal override {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"I", {}},
+		{"C", {}},
+		{"D", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"I", {
+			{"Entry", "function I.f()"},
+			  }},
+		{"C", {
+			{"InternalDispatch", "function C.g()"},
+			{"Entry", "function C.testInterface()"},
+			{"Entry", "function C.testBadPtr()"},
+			{"Entry", "function I.f()"},
+			{"function C.testInterface()", "function C.getF()"},
+			{"function C.testInterface()", "function C.getG()"},
+			{"function C.testInterface()", "InternalDispatch"},
+			{"function C.testBadPtr()", "InternalDispatch"},
+		}},
+		{"D", {
+			{"InternalDispatch", "function D.g()"},
+			{"Entry", "function C.testInterface()"},
+			{"Entry", "function C.testBadPtr()"},
+			{"Entry", "function D.f()"},
+			{"function C.testInterface()", "function C.getF()"},
+			{"function C.testInterface()", "function C.getG()"},
+			{"function C.testInterface()", "InternalDispatch"},
+			{"function C.testBadPtr()", "InternalDispatch"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(function_self_reference)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			function f() public returns (bool ret) {
+				return f == f;
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.f()"},
+			{"InternalDispatch", "function C.f()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(pointer_cycle)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			function () ptr = f;
+
+			function f() internal { ptr(); }
+
+			function test() public {
+				ptr();
+			}
+		}
+	)"s);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {
+			{"InternalDispatch", "function C.f()"},
+			{"function C.f()", "InternalDispatch"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"InternalDispatch", "function C.f()"},
+			{"Entry", "function C.test()"},
+			{"function C.test()", "InternalDispatch"},
+			{"function C.f()", "InternalDispatch"},
+		}},
+	};
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(using_for)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		struct S {
+			uint x;
+		}
+
+		library L {
+			function ext(S memory _s) external {}
+			function inr(S memory _s) internal {}
+		}
+
+		contract C {
+			using L for S;
+
+			function pub() public {
+				S memory s = S(42);
+
+				s.ext();
+				s.inr();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"L", {}},
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"L", {
+			{"Entry", "function L.ext(struct S)"},
+		}},
+		{"C", {
+			{"Entry", "function C.pub()"},
+			{"function C.pub()", "function L.inr(struct S)"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(user_defined_binary_operator)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		type Int is int128;
+		using {add as +} for Int global;
+
+		function add(Int, Int) pure returns (Int) {
+			return Int.wrap(0);
+		}
+
+		contract C {
+			function pub() public {
+				Int.wrap(0) + Int.wrap(1);
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.pub()"},
+			{"function C.pub()", "function add(Int,Int)"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(user_defined_unary_operator)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		type Int is int128;
+		using {sub as -} for Int global;
+
+		function sub(Int) pure returns (Int) {
+			return Int.wrap(0);
+		}
+
+		contract C {
+			function pub() public {
+				-Int.wrap(1);
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.pub()"},
+			{"function C.pub()", "function sub(Int)"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(getters)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			uint public variable;
+			uint[][] public array;
+			mapping(bytes => bytes) public map;
+
+			function test() public {
+				this.variable();
+				this.array(1, 2);
+				this.map("value");
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {{"Entry", "function C.test()"}}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(fallback_and_receive)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			function ext() external {}
+			function inr() internal {}
+
+			fallback() external {
+				this.ext();
+				inr();
+			}
+
+			receive() external payable {
+				this.ext();
+				inr();
+			}
+		}
+
+		contract D {
+			fallback(bytes calldata) external returns (bytes memory) {}
+
+			function test() public {
+				(bool success, bytes memory result) = address(this).call("abc");
+			}
+		}
+
+		contract E is C {}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"E", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "function C.ext()"},
+			{"Entry", "receive of C"},
+			{"Entry", "fallback of C"},
+			{"fallback of C", "function C.inr()"},
+			{"receive of C", "function C.inr()"},
+		}},
+		{"D", {
+			{"Entry", "function D.test()"},
+			{"Entry", "fallback of D"},
+		}},
+		{"E", {
+			{"Entry", "function C.ext()"},
+			{"Entry", "fallback of C"},
+			{"Entry", "receive of C"},
+			{"fallback of C", "function C.inr()"},
+			{"receive of C", "function C.inr()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(virtual_fallback_and_receive)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		contract C {
+			fallback() external virtual {}
+			receive() external payable virtual {}
+		}
+
+		contract D is C {}
+
+		contract E is D {
+			fallback() external virtual override {}
+			receive() external payable virtual override {}
+		}
+
+		contract F is E {
+			fallback() external override {}
+			receive() external payable override {}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"C", {}},
+		{"D", {}},
+		{"E", {}},
+		{"F", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"C", {
+			{"Entry", "receive of C"},
+			{"Entry", "fallback of C"},
+		}},
+		{"D", {
+			{"Entry", "receive of C"},
+			{"Entry", "fallback of C"},
+		}},
+		{"E", {
+			{"Entry", "receive of E"},
+			{"Entry", "fallback of E"},
+		}},
+		{"F", {
+			{"Entry", "receive of F"},
+			{"Entry", "fallback of F"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(builtins)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		interface I {}
+
+		contract C {
+			function accessBuiltin() public payable {
+				abi.decode;
+				abi.encode;
+				abi.encodePacked;
+				abi.encodeWithSelector;
+				abi.encodeWithSignature;
+				block.basefee;
+				block.chainid;
+				block.coinbase;
+				block.difficulty;
+				block.prevrandao;
+				block.gaslimit;
+				block.number;
+				block.timestamp;
+				gasleft;
+				msg.data;
+				msg.sender;
+				msg.value;
+				tx.gasprice;
+				tx.origin;
+				blockhash;
+				keccak256;
+				sha256;
+				ripemd160;
+				ecrecover;
+				addmod;
+				mulmod;
+				this;
+				super;
+				selfdestruct;
+				address(0).balance;
+				address(0).code;
+				address(0).codehash;
+				payable(0).send;
+				payable(0).transfer;
+				address(0).call;
+				address(0).delegatecall;
+				address(0).staticcall;
+				type(C).name;
+				type(I).interfaceId;
+				type(uint).min;
+				type(uint).max;
+				assert;
+			}
+
+			function callBuiltin() public payable {
+				bytes memory data;
+
+				abi.decode(data, (uint));
+				abi.encode(0);
+				abi.encodePacked(data);
+				abi.encodeWithSelector(0x12345678);
+				abi.encodeWithSignature("abc");
+				gasleft();
+				blockhash(0);
+				keccak256(data);
+				sha256(data);
+				ripemd160(data);
+				ecrecover(0x0, 0, 0, 0);
+				addmod(1, 2, 3);
+				mulmod(1, 2, 3);
+				selfdestruct(payable(0));
+				payable(0).send(0);
+				payable(0).transfer(0);
+				address(0).call(data);
+				address(0).delegatecall(data);
+				address(0).staticcall(data);
+				assert(true);
+				require(true);
+				revert();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"I", {}},
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"I", {}},
+		{"C", {
+			{"Entry", "function C.accessBuiltin()"},
+			{"Entry", "function C.callBuiltin()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(conversions_and_struct_array_constructors)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		interface I {}
+
+		enum E {A, B, C}
+
+		struct S {
+			uint a;
+			E b;
+		}
+
+		contract C is I {
+			uint[] u;
+
+			function convert() public payable {
+				uint(0);
+				int(0);
+				bool(true);
+				bytes16(0);
+				payable(address(0));
+				E(0);
+				C(address(C(address(0))));
+				I(C(address(0)));
+
+				bytes memory b;
+				string(b);
+				bytes(b);
+			}
+
+			function create() public payable {
+				S(1, E.A);
+
+				uint[3] memory u3;
+				uint[3](u3);
+				uint[](new uint[](3));
+			}
+
+			function pushPop() public payable {
+				u.push();
+				u.push(1);
+				u.pop();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"I", {}},
+		{"C", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"I", {}},
+		{"C", {
+			{"Entry", "function C.convert()"},
+			{"Entry", "function C.create()"},
+			{"Entry", "function C.pushPop()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(immutable_initialization)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() pure returns (uint) { return 42; }
+
+		contract Base {
+			function ext() external pure returns (uint) { free(); }
+			function inr() internal pure returns (uint) { free(); }
+		}
+
+		contract C is Base {
+			uint immutable extImmutable = this.ext();
+			uint immutable inrImmutable = inr();
+		}
+
+		contract D is Base {
+			uint immutable extImmutable;
+			uint immutable inrImmutable;
+
+			constructor () {
+				extImmutable = this.ext();
+				inrImmutable = inr();
+			}
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"Base", {}},
+		{"C", {
+			{"Entry", "function Base.inr()"},
+			{"function Base.inr()", "function free()"},
+		}},
+		{"D", {
+			{"Entry", "constructor of D"},
+			{"constructor of D", "function Base.inr()"},
+			{"function Base.inr()", "function free()"},
+		}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"Base", {
+			{"Entry", "function Base.ext()"},
+			{"function Base.ext()", "function free()"},
+		}},
+		{"C", {
+			{"Entry", "function Base.ext()"},
+			{"function Base.ext()", "function free()"},
+		}},
+		{"D", {
+			{"Entry", "function Base.ext()"},
+			{"function Base.ext()", "function free()"},
+		}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_CASE(function_selector_access)
+{
+	std::unique_ptr<CompilerStack> compilerStack = parseAndAnalyzeContracts(R"(
+		function free() pure {}
+
+		bytes4 constant extFreeConst = Base.ext.selector;
+		bytes4 constant pubFreeConst = Base.pub.selector;
+
+		contract Base {
+			function ext() external pure { free(); extFreeConst; }
+			function pub() public pure { free(); pubFreeConst; }
+		}
+
+		contract C is Base {
+			bytes4 constant extConst = Base.ext.selector;
+			bytes4 constant pubConst = Base.pub.selector;
+		}
+
+		contract D is Base {
+			bytes4 immutable extImmutable = Base.ext.selector;
+			bytes4 immutable pubImmutable = Base.pub.selector;
+		}
+
+		contract E is Base {
+			bytes4 extVar = Base.ext.selector;
+			bytes4 pubVar = Base.pub.selector;
+		}
+
+		contract F is Base {
+			function f() public pure returns (bytes4, bytes4) {
+				return (Base.ext.selector, Base.pub.selector);
+			}
+		}
+
+		library L {
+			bytes4 constant extConst = Base.ext.selector;
+			bytes4 constant pubConst = Base.pub.selector;
+		}
+	)"s);
+	std::tuple<CallGraphMap, CallGraphMap> graphs = collectGraphs(*compilerStack);
+
+	std::map<std::string, EdgeNames> expectedCreationEdges = {
+		{"Base", {}},
+		{"C", {}},
+		{"D", {
+			{"InternalDispatch", "function Base.pub()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"E", {
+			{"InternalDispatch", "function Base.pub()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"F", {}},
+		{"L", {}},
+	};
+
+	std::map<std::string, EdgeNames> expectedDeployedEdges = {
+		{"Base", {
+			{"Entry", "function Base.ext()"},
+			{"Entry", "function Base.pub()"},
+			{"function Base.ext()", "function free()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"C", {
+			{"Entry", "function Base.ext()"},
+			{"Entry", "function Base.pub()"},
+			{"function Base.ext()", "function free()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"D", {
+			{"InternalDispatch", "function Base.pub()"},
+			{"Entry", "function Base.ext()"},
+			{"Entry", "function Base.pub()"},
+			{"function Base.ext()", "function free()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"E", {
+			{"InternalDispatch", "function Base.pub()"},
+			{"Entry", "function Base.ext()"},
+			{"Entry", "function Base.pub()"},
+			{"function Base.ext()", "function free()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"F", {
+			{"InternalDispatch", "function Base.pub()"},
+			{"Entry", "function Base.ext()"},
+			{"Entry", "function Base.pub()"},
+			{"Entry", "function F.f()"},
+			{"function Base.ext()", "function free()"},
+			{"function Base.pub()", "function free()"},
+		}},
+		{"L", {}},
+	};
+
+	checkCallGraphExpectations(std::get<0>(graphs), expectedCreationEdges);
+	checkCallGraphExpectations(std::get<1>(graphs), expectedDeployedEdges);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/libsolidity/astPropertyTests/blank_test_case.sol b/compiler/test/libsolidity/astPropertyTests/blank_test_case.sol
new file mode 100644
index 00000000..fc2fa580
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/blank_test_case.sol
@@ -0,0 +1,9 @@
+/// TestCase1: name
+contract C {
+    ///
+    ///
+    function f() public pure { }
+}
+// ----
+// TestCase1: C
+//
diff --git a/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_negative_cases.sol b/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_negative_cases.sol
new file mode 100644
index 00000000..cfdda381
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_negative_cases.sol
@@ -0,0 +1,166 @@
+type UINT is uint;
+
+function add(UINT x, UINT y) pure returns (UINT) {
+    return UINT.wrap(UINT.unwrap(x) + UINT.unwrap(y));
+}
+
+function lt(UINT x, UINT y) pure returns (bool) {
+    return UINT.unwrap(x) < UINT.unwrap(y);
+}
+
+using {lt as <, add as +} for UINT global;
+
+function g() pure returns (bool) {
+    return false;
+}
+
+function h() pure returns (uint) {
+    return 13;
+}
+
+contract C {
+    uint z = 0;
+
+    function modifyStateVarZ() public returns (uint) {
+        z = type(uint).max;
+        return z;
+    }
+
+    struct S {
+        uint x;
+    }
+
+    function f() public {
+        /// AdditionLoopExpression: isSimpleCounterLoop
+        for(uint i = 0; i < 42; i = i + 1) {
+        }
+        /// ShortHandAdditionLoopExpression: isSimpleCounterLoop
+        for(uint i = 0; i < 42; i += 1) {
+        }
+        /// SimplePreDecrement: isSimpleCounterLoop
+        for(uint i = 42; i > 0; --i) {
+        }
+        /// SimplePosDecrement: isSimpleCounterLoop
+        for(uint i = 42; i > 0; i--) {
+        }
+        /// MultiplicationLoopExpression: isSimpleCounterLoop
+        for(uint i = 1; i < 42; i = i * 2) {
+        }
+        /// CounterIncrementLoopBody: isSimpleCounterLoop
+        for(uint i = 0; i < 42; ++i) {
+            i++;
+        }
+        /// CounterAssignmentLoopBody: isSimpleCounterLoop
+        for(uint i = 0; i < 42; ++i) {
+            i = 43;
+        }
+        /// CounterAssignmentInlineAssemblyLoopBody: isSimpleCounterLoop
+        for(uint i = 0; i < 42; ++i) {
+            assembly {
+                i := add(i, 1)
+            }
+        }
+        uint j = type(uint).max;
+        /// ExternalCounterLoopExpression: isSimpleCounterLoop
+        for (uint i = 0; i < 10; ++j) {
+        }
+        uint x;
+        /// CounterIncrementRHSAssignment: isSimpleCounterLoop
+        for(uint i = 0; i < 10; ++i) {
+            x = i++;
+        }
+        /// NoEffectLoopExpression: isSimpleCounterLoop
+        for(uint i = 0; i < 42; i) {
+        }
+        /// EmptyLoopExpression: isSimpleCounterLoop
+        for(uint i = 0; i < 10; ) {
+        }
+        j = 0;
+        /// EmptyConditionExpression: isSimpleCounterLoop
+        for(uint i = 0; ; ++i) {
+        }
+        uint y = type(uint8).max + 1;
+        /// DifferentCommonTypeCondition: isSimpleCounterLoop
+        for(uint8 i = 0; i < y; ++i) {
+        }
+        /// LessThanOrEqualCondition: isSimpleCounterLoop
+        for(uint i = 0; i <= 10; ++i) {
+        }
+        /// ComplexExpressionCondition: isSimpleCounterLoop
+        for(uint i = 0; (i < 10 || g()); ++i) {
+        }
+        /// FreeFunctionConditionLHS: isSimpleCounterLoop
+        for(uint i = 0; h() < 100; ++i) {
+        }
+        /// FreeFunctionConditionDifferentCommonTypeLHS: isSimpleCounterLoop
+        for(uint8 i = 0; i < h(); ++i) {
+        }
+        /// NonIntegerTypeCondition: isSimpleCounterLoop
+        for(uint i = 0; address(this) < msg.sender; ++i) {
+        }
+        UINT ZERO = UINT.wrap(0);
+        UINT ONE = UINT.wrap(1);
+        UINT TEN = UINT.wrap(10);
+        /// UDVTOperators: isSimpleCounterLoop
+        for(UINT i = ZERO; i < TEN; i = i + ONE) {
+        }
+        /// CounterAssignmentConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < (i = i + 1); ++i) {
+        }
+        /// LiteralDifferentCommonTypeConditionRHS: isSimpleCounterLoop
+        for(uint8 i = 0; i < 257 ; ++i) {
+        }
+        /// StateVarCounterModifiedFunctionConditionRHS: isSimpleCounterLoop
+        for (z = 1; z < modifyStateVarZ(); ++z) {
+        }
+        /// StateVarCounterModifiedFunctionLoopBody: isSimpleCounterLoop
+        for (z = 1; z < 2048; ++z) {
+            modifyStateVarZ();
+        }
+        /// NonIntegerCounter: isSimpleCounterLoop
+        for (address i = address(0x123); i < address(this); i = address(0x123 + 1)) {
+        }
+        /// AssemblyAfterAssignmentToCounter: isSimpleCounterLoop
+        for (uint i = 0; i < 42; ++i) {
+            i = type(uint).max;
+            assembly {}
+        }
+        uint k = type(uint).max;
+        /// ExpressionIncrement: isSimpleCounterLoop
+        for (uint i = 0; i < 10; ++(k)) {
+        }
+        S memory s = S(type(uint).max);
+        /// StructMemberAccessIncrement: isSimpleCounterLoop
+        for (uint i = 0; i < 10; ++s.x) {
+        }
+    }
+}
+// ----
+// AdditionLoopExpression: false
+// ShortHandAdditionLoopExpression: false
+// SimplePreDecrement: false
+// SimplePosDecrement: false
+// MultiplicationLoopExpression: false
+// CounterIncrementLoopBody: false
+// CounterAssignmentLoopBody: false
+// CounterAssignmentInlineAssemblyLoopBody: false
+// ExternalCounterLoopExpression: false
+// CounterIncrementRHSAssignment: false
+// NoEffectLoopExpression: false
+// DifferentCommonTypeCondition: false
+// EmptyLoopExpression: false
+// EmptyConditionExpression: false
+// LessThanOrEqualCondition: false
+// ComplexExpressionCondition: false
+// FreeFunctionConditionLHS: false
+// FreeFunctionConditionDifferentCommonTypeLHS: false
+// NonIntegerTypeCondition: false
+// UDVTOperators: false
+// CounterAssignmentConditionRHS: false
+// LiteralDifferentCommonTypeConditionRHS: false
+// StateVarCounterModifiedFunctionConditionRHS: false
+// StateVarCounterModifiedFunctionLoopBody: false
+// NonIntegerCounter: false
+// AssemblyAfterAssignmentToCounter: false
+// ExpressionIncrement: false
+// StructMemberAccessIncrement: false
diff --git a/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_positive_cases.sol b/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_positive_cases.sol
new file mode 100644
index 00000000..c7ab53d2
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/forLoop/isSimpleCounterLoop_positive_cases.sol
@@ -0,0 +1,72 @@
+function h() pure returns (uint) {
+    return 13;
+}
+
+contract C {
+    uint[] dynArray;
+
+    function f() public {
+        /// SimplePreIncrement: isSimpleCounterLoop
+        for(uint i = 0; i < 42; ++i) {
+        }
+        /// SimplePosIncrement: isSimpleCounterLoop
+        for(int i = 0; i < 42; i++) {
+        }
+        uint x;
+        /// CounterReadLoopBody: isSimpleCounterLoop
+        for(uint i = 0; i < 42; i++) {
+            x = i;
+        }
+        /// LocalVarConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < x; i++) {
+        }
+        x = 0;
+        /// EmptyInitExpression: isSimpleCounterLoop
+        for(; x < 10; ++x) {
+        }
+        uint[8] memory array;
+        /// StaticArrayLengthConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < array.length; i++) {
+        }
+        dynArray.push();
+        /// DynamicArrayLengthConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < dynArray.length; i++) {
+            dynArray.push(i);
+        }
+        /// CounterReadInlineAssembly: isSimpleCounterLoop
+        for(uint i = 0; i < 42; ++i) {
+            assembly {
+                x := i
+            }
+        }
+        /// BinaryOperationConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < i + 1; i++) {
+        }
+        /// FreeFunctionConditionRHS: isSimpleCounterLoop
+        for(uint i = 0; i < h(); ++i) {
+        }
+    }
+    function functionParamLoopCounter(uint i) public pure {
+        /// FunctionParameterLoopCounter: isSimpleCounterLoop
+        for (i = 0; i < 42; ++i){
+        }
+    }
+    function functionReturnLoopCounter() public pure returns (uint i) {
+        /// FunctionReturnLoopCounter: isSimpleCounterLoop
+        for (i = 0; i < 42; ++i){
+        }
+    }
+}
+// ----
+// SimplePreIncrement: true
+// SimplePosIncrement: true
+// CounterReadLoopBody: true
+// LocalVarConditionRHS: true
+// EmptyInitExpression: true
+// StaticArrayLengthConditionRHS: true
+// DynamicArrayLengthConditionRHS: true
+// CounterReadInlineAssembly: true
+// BinaryOperationConditionRHS: true
+// FreeFunctionConditionRHS: true
+// FunctionParameterLoopCounter: true
+// FunctionReturnLoopCounter: true
diff --git a/compiler/test/libsolidity/astPropertyTests/multiple_nested_properties_per_node.sol b/compiler/test/libsolidity/astPropertyTests/multiple_nested_properties_per_node.sol
new file mode 100644
index 00000000..09841828
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/multiple_nested_properties_per_node.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        /// TestCase1: condition.operator
+        /// TestCase2: initializationExpression.initialValue.value
+        /// TestCase3: loopExpression.expression.subExpression.name
+        for(uint i = 1; i < 42; i++) {
+        }
+    }
+}
+// ----
+// TestCase1: <
+// TestCase2: 1
+// TestCase3: i
diff --git a/compiler/test/libsolidity/astPropertyTests/multiple_properties_per_node.sol b/compiler/test/libsolidity/astPropertyTests/multiple_properties_per_node.sol
new file mode 100644
index 00000000..c62aa6ac
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/multiple_properties_per_node.sol
@@ -0,0 +1,11 @@
+contract C {
+    /// TestCase1: name
+    /// TestCase2: functionSelector
+    /// TestCase3: visibility
+    function singleFunction() public pure {
+    }
+}
+// ----
+// TestCase1: singleFunction
+// TestCase2: 3d33252c
+// TestCase3: public
diff --git a/compiler/test/libsolidity/astPropertyTests/nested_properties.sol b/compiler/test/libsolidity/astPropertyTests/nested_properties.sol
new file mode 100644
index 00000000..324fe64c
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/nested_properties.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public pure {
+        /// TestCase1: condition.operator
+        for(uint i = 0; i < 42; ++i) {
+        }
+        /// TestCase2: initializationExpression.initialValue.value
+        for(uint i = 1; i < 42; i = i * 2) {
+        }
+        /// TestCase3: loopExpression.expression.subExpression.name
+        for(uint i = 0; i < 42; i++) {
+        }
+    }
+}
+// ----
+// TestCase1: <
+// TestCase2: 1
+// TestCase3: i
diff --git a/compiler/test/libsolidity/astPropertyTests/property_expectation_with_colon.sol b/compiler/test/libsolidity/astPropertyTests/property_expectation_with_colon.sol
new file mode 100644
index 00000000..7e228a56
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/property_expectation_with_colon.sol
@@ -0,0 +1,9 @@
+/// TestCase1: nameLocation
+/// TestCase2: src
+contract C {
+    function f() public pure {
+    }
+}
+// ----
+// TestCase1: 115:1:-1
+// TestCase2: 106:51:-1
diff --git a/compiler/test/libsolidity/astPropertyTests/simple_properties.sol b/compiler/test/libsolidity/astPropertyTests/simple_properties.sol
new file mode 100644
index 00000000..d7485fbe
--- /dev/null
+++ b/compiler/test/libsolidity/astPropertyTests/simple_properties.sol
@@ -0,0 +1,12 @@
+/// TestContractC: name
+contract C {
+    /// TestStateVarX: stateVariable
+    uint x;
+    /// TestFunctionF: visibility
+    function f() public pure {
+    }
+}
+// ----
+// TestContractC: C
+// TestStateVarX: true
+// TestFunctionF: public
diff --git a/compiler/test/libsolidity/functionDependencyGraphTests/callgraph.sol b/compiler/test/libsolidity/functionDependencyGraphTests/callgraph.sol
new file mode 100644
index 00000000..21f0e7e5
--- /dev/null
+++ b/compiler/test/libsolidity/functionDependencyGraphTests/callgraph.sol
@@ -0,0 +1,60 @@
+// fallback---------->f----------+
+//                    |          |
+//                    |          |
+//                    |          |
+//                    |          |
+//                    v          v
+//                    g          h
+//
+//
+// add
+//
+// unreferenced
+
+pragma experimental solidity;
+
+type uint256 = __builtin("word");
+
+instantiation uint256: + {
+    function add(x, y) -> uint256 {
+        let a = uint256.rep(x);
+        let b = uint256.rep(y);
+        assembly {
+            a := add(a,b)
+        }
+        return uint256.abs(a);
+    }
+}
+
+function unreferenced(x:uint256) -> uint256
+{
+    return x;
+}
+
+function f(x:uint256) -> uint256
+{
+    return g(h(x));
+}
+
+function g(x:uint256) -> uint256
+{
+    return x;
+}
+
+function h(x:uint256) -> uint256
+{
+    return x;
+}
+
+contract C {
+    fallback() external {
+        let a: uint256->uint256 = f;
+    }
+}
+// ----
+// (add) --> {}
+// (unreferenced) --> {}
+// (f) --> {g,h,}
+// (g) --> {}
+// (h) --> {}
+// (fallback) --> {f,}
diff --git a/compiler/test/libsolidity/functionDependencyGraphTests/callgraph_no_leaves.sol b/compiler/test/libsolidity/functionDependencyGraphTests/callgraph_no_leaves.sol
new file mode 100644
index 00000000..5fe1a75f
--- /dev/null
+++ b/compiler/test/libsolidity/functionDependencyGraphTests/callgraph_no_leaves.sol
@@ -0,0 +1,66 @@
+// a<------b
+// |       ^
+// |       |
+// |       |
+// |       |
+// |       |
+// +------>c------->d-------->e------->f
+//                            ^        |
+//                            |        |
+//                            |        |
+//                            |        |
+//                            |        v
+//                            h<-------g
+
+pragma experimental solidity;
+
+function a()
+{
+    c();
+}
+
+function b()
+{
+    a();
+}
+
+function c()
+{
+    b();
+    d();
+}
+
+function d()
+{
+    e();
+}
+
+function e()
+{
+    f();
+}
+
+function f()
+{
+    g();
+}
+
+function g()
+{
+    h();
+}
+
+function h()
+{
+    e();
+}
+
+// ----
+// (a) --> {c,}
+// (b) --> {a,}
+// (c) --> {b,d,}
+// (d) --> {e,}
+// (e) --> {f,}
+// (f) --> {g,}
+// (g) --> {h,}
+// (h) --> {e,}
diff --git a/compiler/test/libsolidity/gasTests/abiv2.sol b/compiler/test/libsolidity/gasTests/abiv2.sol
new file mode 100644
index 00000000..aacb333b
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/abiv2.sol
@@ -0,0 +1,30 @@
+pragma abicoder               v2;
+
+contract C {
+    uint public a;
+    uint[] public b;
+    function f1(uint) public pure returns (uint) { }
+    function f2(uint[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
+    function f3(uint16[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
+    function f4(uint32[] memory, string[12] memory, bytes[2][] memory, address) public returns (uint[] memory, uint16[] memory) {}
+    function f5(address[] memory, string[] memory, bytes memory, address) public returns (uint[] memory, uint16[] memory) {}
+    function f6(uint[30] memory, string[] memory, uint16, address) public returns (uint16[200] memory, uint16[] memory) {}
+    function f7(uint[31] memory, string[20] memory, C, address) public returns (bytes[] memory, uint16[] memory) {}
+    function f8(uint[32] memory, string[] memory, uint32, address) public returns (uint[] memory, uint16[] memory) {}
+}
+// ----
+// creation:
+//   codeDepositCost: 1213200
+//   executionCost: 1259
+//   totalCost: 1214459
+// external:
+//   a(): 2425
+//   b(uint256): infinite
+//   f1(uint256): infinite
+//   f2(uint256[],string[],uint16,address): infinite
+//   f3(uint16[],string[],uint16,address): infinite
+//   f4(uint32[],string[12],bytes[2][],address): infinite
+//   f5(address[],string[],bytes,address): infinite
+//   f6(uint256[30],string[],uint16,address): infinite
+//   f7(uint256[31],string[20],address,address): infinite
+//   f8(uint256[32],string[],uint32,address): infinite
diff --git a/compiler/test/libsolidity/gasTests/abiv2_optimised.sol b/compiler/test/libsolidity/gasTests/abiv2_optimised.sol
new file mode 100644
index 00000000..1ab8803d
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/abiv2_optimised.sol
@@ -0,0 +1,33 @@
+pragma abicoder               v2;
+
+contract C {
+    uint public a;
+    uint[] public b;
+    function f1(uint) public pure returns (uint) { }
+    function f2(uint[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
+    function f3(uint16[] memory, string[] memory, uint16, address) public returns (uint[] memory, uint16[] memory) {}
+    function f4(uint32[] memory, string[12] memory, bytes[2][] memory, address) public returns (uint[] memory, uint16[] memory) {}
+    function f5(address[] memory, string[] memory, bytes memory, address) public returns (uint[] memory, uint16[] memory) {}
+    function f6(uint[30] memory, string[] memory, uint16, address) public returns (uint16[200] memory, uint16[] memory) {}
+    function f7(uint[31] memory, string[20] memory, C, address) public returns (bytes[] memory, uint16[] memory) {}
+    function f8(uint[32] memory, string[] memory, uint32, address) public returns (uint[] memory, uint16[] memory) {}
+}
+// ====
+// optimize: true
+// optimize-yul: true
+// ----
+// creation:
+//   codeDepositCost: 639000
+//   executionCost: 668
+//   totalCost: 639668
+// external:
+//   a(): 2283
+//   b(uint256): 4649
+//   f1(uint256): 304
+//   f2(uint256[],string[],uint16,address): infinite
+//   f3(uint16[],string[],uint16,address): infinite
+//   f4(uint32[],string[12],bytes[2][],address): infinite
+//   f5(address[],string[],bytes,address): infinite
+//   f6(uint256[30],string[],uint16,address): infinite
+//   f7(uint256[31],string[20],address,address): infinite
+//   f8(uint256[32],string[],uint32,address): infinite
diff --git a/compiler/test/libsolidity/gasTests/data_storage.sol b/compiler/test/libsolidity/gasTests/data_storage.sol
new file mode 100644
index 00000000..0d24ef50
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/data_storage.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f() pure public {
+        require(false, "1234567890123456789012345678901");
+        require(false, "12345678901234567890123456789012");
+        require(false, "123456789012345678901234567890123");
+        require(false, "1234567890123456789012345678901234");
+        require(false, "12345678901234567890123456789012345");
+        require(false, "123456789012345678901234567890123456");
+        require(false, "123456789012345678901234567890121234567890123456789012345678901");
+        require(false, "1234567890123456789012345678901212345678901234567890123456789012");
+        require(false, "12345678901234567890123456789012123456789012345678901234567890123");
+    }
+}
+// ----
+// creation:
+//   codeDepositCost: 377800
+//   executionCost: 416
+//   totalCost: 378216
+// external:
+//   f(): 421
diff --git a/compiler/test/libsolidity/gasTests/dispatch_large.sol b/compiler/test/libsolidity/gasTests/dispatch_large.sol
new file mode 100644
index 00000000..e1cce4ac
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_large.sol
@@ -0,0 +1,52 @@
+contract Large {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function f2(uint x) public returns (uint) { b[uint8(msg.data[1])] = x; }
+    function f3(uint x) public returns (uint) { b[uint8(msg.data[2])] = x; }
+    function f4(uint x) public returns (uint) { b[uint8(msg.data[3])] = x; }
+    function f5(uint x) public returns (uint) { b[uint8(msg.data[4])] = x; }
+    function f6(uint x) public returns (uint) { b[uint8(msg.data[5])] = x; }
+    function f7(uint x) public returns (uint) { b[uint8(msg.data[6])] = x; }
+    function f8(uint x) public returns (uint) { b[uint8(msg.data[7])] = x; }
+    function f9(uint x) public returns (uint) { b[uint8(msg.data[8])] = x; }
+    function f0(uint x) public pure returns (uint) { require(x > 10); }
+    function g1(uint x) public payable returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function g2(uint x) public payable returns (uint) { b[uint8(msg.data[1])] = x; }
+    function g3(uint x) public payable returns (uint) { b[uint8(msg.data[2])] = x; }
+    function g4(uint x) public payable returns (uint) { b[uint8(msg.data[3])] = x; }
+    function g5(uint x) public payable returns (uint) { b[uint8(msg.data[4])] = x; }
+    function g6(uint x) public payable returns (uint) { b[uint8(msg.data[5])] = x; }
+    function g7(uint x) public payable returns (uint) { b[uint8(msg.data[6])] = x; }
+    function g8(uint x) public payable returns (uint) { b[uint8(msg.data[7])] = x; }
+    function g9(uint x) public payable returns (uint) { b[uint8(msg.data[8])] = x; }
+    function g0(uint x) public payable returns (uint) { require(x > 10); }
+}
+// ----
+// creation:
+//   codeDepositCost: 618400
+//   executionCost: 649
+//   totalCost: 619049
+// external:
+//   a(): 2470
+//   b(uint256): infinite
+//   f0(uint256): infinite
+//   f1(uint256): infinite
+//   f2(uint256): infinite
+//   f3(uint256): infinite
+//   f4(uint256): infinite
+//   f5(uint256): infinite
+//   f6(uint256): infinite
+//   f7(uint256): infinite
+//   f8(uint256): infinite
+//   f9(uint256): infinite
+//   g0(uint256): infinite
+//   g1(uint256): infinite
+//   g2(uint256): infinite
+//   g3(uint256): infinite
+//   g4(uint256): infinite
+//   g5(uint256): infinite
+//   g6(uint256): infinite
+//   g7(uint256): infinite
+//   g8(uint256): infinite
+//   g9(uint256): infinite
diff --git a/compiler/test/libsolidity/gasTests/dispatch_large_optimised.sol b/compiler/test/libsolidity/gasTests/dispatch_large_optimised.sol
new file mode 100644
index 00000000..83e55c1a
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_large_optimised.sol
@@ -0,0 +1,55 @@
+contract Large {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function f2(uint x) public returns (uint) { b[uint8(msg.data[1])] = x; }
+    function f3(uint x) public returns (uint) { b[uint8(msg.data[2])] = x; }
+    function f4(uint x) public returns (uint) { b[uint8(msg.data[3])] = x; }
+    function f5(uint x) public returns (uint) { b[uint8(msg.data[4])] = x; }
+    function f6(uint x) public returns (uint) { b[uint8(msg.data[5])] = x; }
+    function f7(uint x) public returns (uint) { b[uint8(msg.data[6])] = x; }
+    function f8(uint x) public returns (uint) { b[uint8(msg.data[7])] = x; }
+    function f9(uint x) public returns (uint) { b[uint8(msg.data[8])] = x; }
+    function f0(uint x) public pure returns (uint) { require(x > 10); }
+    function g1(uint x) public payable returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function g2(uint x) public payable returns (uint) { b[uint8(msg.data[1])] = x; }
+    function g3(uint x) public payable returns (uint) { b[uint8(msg.data[2])] = x; }
+    function g4(uint x) public payable returns (uint) { b[uint8(msg.data[3])] = x; }
+    function g5(uint x) public payable returns (uint) { b[uint8(msg.data[4])] = x; }
+    function g6(uint x) public payable returns (uint) { b[uint8(msg.data[5])] = x; }
+    function g7(uint x) public payable returns (uint) { b[uint8(msg.data[6])] = x; }
+    function g8(uint x) public payable returns (uint) { b[uint8(msg.data[7])] = x; }
+    function g9(uint x) public payable returns (uint) { b[uint8(msg.data[8])] = x; }
+    function g0(uint x) public payable returns (uint) { require(x > 10); }
+}
+// ====
+// optimize: true
+// optimize-runs: 2
+// ----
+// creation:
+//   codeDepositCost: 224600
+//   executionCost: 267
+//   totalCost: 224867
+// external:
+//   a(): 2281
+//   b(uint256): 4934
+//   f0(uint256): 363
+//   f1(uint256): 47002
+//   f2(uint256): 24967
+//   f3(uint256): 25055
+//   f4(uint256): 25033
+//   f5(uint256): 25011
+//   f6(uint256): 24923
+//   f7(uint256): 24703
+//   f8(uint256): 24835
+//   f9(uint256): 24857
+//   g0(uint256): 603
+//   g1(uint256): 46714
+//   g2(uint256): 24701
+//   g3(uint256): 24789
+//   g4(uint256): 24767
+//   g5(uint256): 24855
+//   g6(uint256): 24635
+//   g7(uint256): 24745
+//   g8(uint256): 24723
+//   g9(uint256): 24569
diff --git a/compiler/test/libsolidity/gasTests/dispatch_medium.sol b/compiler/test/libsolidity/gasTests/dispatch_medium.sol
new file mode 100644
index 00000000..6bf8f893
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_medium.sol
@@ -0,0 +1,26 @@
+contract Medium {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function f2(uint x) public returns (uint) { b[uint8(msg.data[1])] = x; }
+    function f3(uint x) public returns (uint) { b[uint8(msg.data[2])] = x; }
+    function g7(uint x) public payable returns (uint) { b[uint8(msg.data[6])] = x; }
+    function g8(uint x) public payable returns (uint) { b[uint8(msg.data[7])] = x; }
+    function g9(uint x) public payable returns (uint) { b[uint8(msg.data[8])] = x; }
+    function g0(uint x) public payable returns (uint) { require(x > 10); }
+}
+// ----
+// creation:
+//   codeDepositCost: 259600
+//   executionCost: 298
+//   totalCost: 259898
+// external:
+//   a(): 2447
+//   b(uint256): infinite
+//   f1(uint256): infinite
+//   f2(uint256): infinite
+//   f3(uint256): infinite
+//   g0(uint256): infinite
+//   g7(uint256): infinite
+//   g8(uint256): infinite
+//   g9(uint256): infinite
diff --git a/compiler/test/libsolidity/gasTests/dispatch_medium_optimised.sol b/compiler/test/libsolidity/gasTests/dispatch_medium_optimised.sol
new file mode 100644
index 00000000..e921fcf1
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_medium_optimised.sol
@@ -0,0 +1,29 @@
+contract Medium {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    function f2(uint x) public returns (uint) { b[uint8(msg.data[1])] = x; }
+    function f3(uint x) public returns (uint) { b[uint8(msg.data[2])] = x; }
+    function g7(uint x) public payable returns (uint) { b[uint8(msg.data[6])] = x; }
+    function g8(uint x) public payable returns (uint) { b[uint8(msg.data[7])] = x; }
+    function g9(uint x) public payable returns (uint) { b[uint8(msg.data[8])] = x; }
+    function g0(uint x) public payable returns (uint) { require(x > 10); }
+}
+// ====
+// optimize: true
+// optimize-runs: 2
+// ----
+// creation:
+//   codeDepositCost: 126000
+//   executionCost: 169
+//   totalCost: 126169
+// external:
+//   a(): 2281
+//   b(uint256): 4692
+//   f1(uint256): 46782
+//   f2(uint256): 24725
+//   f3(uint256): 24769
+//   g0(uint256): 361
+//   g7(uint256): 24635
+//   g8(uint256): 24613
+//   g9(uint256): 24569
diff --git a/compiler/test/libsolidity/gasTests/dispatch_small.sol b/compiler/test/libsolidity/gasTests/dispatch_small.sol
new file mode 100644
index 00000000..d2c39158
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_small.sol
@@ -0,0 +1,16 @@
+contract Small {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    fallback () external payable {}
+}
+// ----
+// creation:
+//   codeDepositCost: 103800
+//   executionCost: 151
+//   totalCost: 103951
+// external:
+//   fallback: 128
+//   a(): 2402
+//   b(uint256): infinite
+//   f1(uint256): infinite
diff --git a/compiler/test/libsolidity/gasTests/dispatch_small_optimised.sol b/compiler/test/libsolidity/gasTests/dispatch_small_optimised.sol
new file mode 100644
index 00000000..e20e1d98
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/dispatch_small_optimised.sol
@@ -0,0 +1,19 @@
+contract Small {
+    uint public a;
+    uint[] public b;
+    function f1(uint x) public returns (uint) { a = x; b[uint8(msg.data[0])] = x; }
+    fallback () external payable {}
+}
+// ====
+// optimize: true
+// optimize-runs: 2
+// ----
+// creation:
+//   codeDepositCost: 58200
+//   executionCost: 109
+//   totalCost: 58309
+// external:
+//   fallback: 117
+//   a(): 2259
+//   b(uint256): 4582
+//   f1(uint256): 46716
diff --git a/compiler/test/libsolidity/gasTests/exp.sol b/compiler/test/libsolidity/gasTests/exp.sol
new file mode 100644
index 00000000..6ad4dd3b
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/exp.sol
@@ -0,0 +1,29 @@
+pragma abicoder               v2;
+
+contract C {
+	function exp_neg_one(uint exponent) public returns(int) {
+		unchecked { return (-1)**exponent; }
+	}
+	function exp_two(uint exponent) public returns(uint) {
+		unchecked { return 2**exponent; }
+	}
+	function exp_zero(uint exponent) public returns(uint) {
+		unchecked { return 0**exponent; }
+	}
+	function exp_one(uint exponent) public returns(uint) {
+		unchecked { return 1**exponent; }
+	}
+}
+// ====
+// optimize: false
+// optimize-yul: false
+// ----
+// creation:
+//   codeDepositCost: 107000
+//   executionCost: 151
+//   totalCost: 107151
+// external:
+//   exp_neg_one(uint256): 2250
+//   exp_one(uint256): infinite
+//   exp_two(uint256): infinite
+//   exp_zero(uint256): infinite
diff --git a/compiler/test/libsolidity/gasTests/exp_optimized.sol b/compiler/test/libsolidity/gasTests/exp_optimized.sol
new file mode 100644
index 00000000..982fcd28
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/exp_optimized.sol
@@ -0,0 +1,29 @@
+pragma abicoder               v2;
+
+contract C {
+	function exp_neg_one(uint exponent) public returns(int) {
+		unchecked { return (-1)**exponent; }
+	}
+	function exp_two(uint exponent) public returns(uint) {
+		unchecked { return 2**exponent; }
+	}
+	function exp_zero(uint exponent) public returns(uint) {
+		unchecked { return 0**exponent; }
+	}
+	function exp_one(uint exponent) public returns(uint) {
+		unchecked { return 1**exponent; }
+	}
+}
+// ====
+// optimize: true
+// optimize-yul: true
+// ----
+// creation:
+//   codeDepositCost: 35800
+//   executionCost: 85
+//   totalCost: 35885
+// external:
+//   exp_neg_one(uint256): 1914
+//   exp_one(uint256): 1868
+//   exp_two(uint256): 1846
+//   exp_zero(uint256): 1889
diff --git a/compiler/test/libsolidity/gasTests/storage_costs.sol b/compiler/test/libsolidity/gasTests/storage_costs.sol
new file mode 100644
index 00000000..afb442ed
--- /dev/null
+++ b/compiler/test/libsolidity/gasTests/storage_costs.sol
@@ -0,0 +1,24 @@
+contract C {
+    uint x;
+    function setX(uint y) public {
+        x = y;
+    }
+    function resetX() public {
+        x = 0;
+    }
+    function readX() public view returns(uint) {
+        return x;
+    }
+}
+// ====
+// optimize: true
+// optimize-yul: true
+// ----
+// creation:
+//   codeDepositCost: 25600
+//   executionCost: 73
+//   totalCost: 25673
+// external:
+//   readX(): 2288
+//   resetX(): 5114
+//   setX(uint256): 22309
diff --git a/compiler/test/libsolidity/interface/FileReader.cpp b/compiler/test/libsolidity/interface/FileReader.cpp
new file mode 100644
index 00000000..dbb03c23
--- /dev/null
+++ b/compiler/test/libsolidity/interface/FileReader.cpp
@@ -0,0 +1,541 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for libsolidity/interface/FileReader.h
+
+#include <libsolidity/interface/FileReader.h>
+
+#include <test/Common.h>
+#include <test/FilesystemUtils.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::util;
+using namespace solidity::test;
+
+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
+
+namespace solidity::frontend::test
+{
+
+using SymlinkResolution = FileReader::SymlinkResolution;
+
+BOOST_AUTO_TEST_SUITE(FileReaderTest)
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_absolute_path)
+{
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/.", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/./", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/./.", resolveSymlinks), "/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/", resolveSymlinks), "/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/.", resolveSymlinks), "/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/./a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/./a/", resolveSymlinks), "/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/./a/.", resolveSymlinks), "/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b", resolveSymlinks), "/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b/", resolveSymlinks), "/a/b/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/./b/", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/../a/b/", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b/c/..", resolveSymlinks), "/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b/c/../", resolveSymlinks), "/a/b/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b/c/../../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b/c/../../../", resolveSymlinks), "/");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_relative_path)
+{
+	TemporaryDirectory tempDir({"x/y/z"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir.path() / "x/y/z");
+
+	// NOTE: If path to work dir contains symlinks (often the case on macOS), boost might resolve
+	// them, making the path different from tempDirPath.
+	boost::filesystem::path expectedPrefix = boost::filesystem::current_path().parent_path().parent_path().parent_path();
+	// On Windows tempDir.path() normally contains the drive letter while the normalized path should not.
+	expectedPrefix = "/" / expectedPrefix.relative_path();
+	soltestAssert(expectedPrefix.is_absolute() || expectedPrefix.root_path() == "/", "");
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS(".", resolveSymlinks), expectedPrefix / "x/y/z/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./", resolveSymlinks), expectedPrefix / "x/y/z/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS(".//", resolveSymlinks), expectedPrefix / "x/y/z/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("..", resolveSymlinks), expectedPrefix / "x/y");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../", resolveSymlinks), expectedPrefix / "x/y/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("..//", resolveSymlinks), expectedPrefix / "x/y/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a", resolveSymlinks), expectedPrefix / "x/y/z/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/.", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a", resolveSymlinks), expectedPrefix / "x/y/z/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/.", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/./", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/.//", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/./.", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/././", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/././/", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b", resolveSymlinks), expectedPrefix / "x/y/z/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/", resolveSymlinks), expectedPrefix / "x/y/z/a/b/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../a/b", resolveSymlinks), expectedPrefix / "x/y/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../../a/b", resolveSymlinks), expectedPrefix / "x/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("./a/b", resolveSymlinks), expectedPrefix / "x/y/z/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("././a/b", resolveSymlinks), expectedPrefix / "x/y/z/a/b");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/./b/", resolveSymlinks), expectedPrefix / "x/y/z/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/../a/b/", resolveSymlinks), expectedPrefix / "x/y/z/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/..", resolveSymlinks), expectedPrefix / "x/y/z/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/../", resolveSymlinks), expectedPrefix / "x/y/z/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/..//", resolveSymlinks), expectedPrefix / "x/y/z/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/../..", resolveSymlinks), expectedPrefix / "x/y/z/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/../../", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/b/c/../..//", resolveSymlinks), expectedPrefix / "x/y/z/a/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../../a/.././../p/../q/../a/b", resolveSymlinks), expectedPrefix / "a/b");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_redundant_slashes)
+{
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("///", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("////", resolveSymlinks), "/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("////a/b/", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a//b/", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a////b/", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b//", resolveSymlinks), "/a/b/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/b////", resolveSymlinks), "/a/b/");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_unc_path)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	// On Windows tempDir.path() normally contains the drive letter while the normalized path should not.
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		// UNC paths start with // or \\ followed by a name. They are used for network shares on Windows.
+		// On UNIX systems they are not supported but still treated in a special way.
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("//host/", resolveSymlinks), "//host/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("//host/a/b", resolveSymlinks), "//host/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("//host/a/b/", resolveSymlinks), "//host/a/b/");
+
+#if defined(_WIN32)
+		// On Windows an UNC path can also start with \\ instead of //
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/", resolveSymlinks), "//host/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/a/b", resolveSymlinks), "//host/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/a/b/", resolveSymlinks), "//host/a/b/");
+#else
+		// On UNIX systems it's just a fancy relative path instead
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/", resolveSymlinks), expectedWorkDir / "\\\\host/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/a/b", resolveSymlinks), expectedWorkDir / "\\\\host/a/b");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("\\\\host/a/b/", resolveSymlinks), expectedWorkDir / "\\\\host/a/b/");
+#endif
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_root_name_only)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+
+	// A root **path** consists of a directory name (typically / or \) and the root name (drive
+	// letter (C:), UNC host name (//host), etc.). Either can be empty. Root path as a whole may be
+	// an absolute path but root name on its own is considered relative. For example on Windows
+	// C:\ represents the root directory of drive C: but C: on its own refers to the current working
+	// directory.
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		// UNC paths
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("//", resolveSymlinks), "//" / expectedWorkDir);
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("//host", resolveSymlinks), "//host" / expectedWorkDir);
+
+		// On UNIX systems root name is empty.
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("", resolveSymlinks), expectedWorkDir);
+
+#if defined(_WIN32)
+		boost::filesystem::path driveLetter = boost::filesystem::current_path().root_name();
+		soltestAssert(!driveLetter.empty(), "");
+		soltestAssert(driveLetter.is_relative(), "");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS(driveLetter, resolveSymlinks), expectedWorkDir);
+#endif
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_stripping_root_name)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	soltestAssert(boost::filesystem::current_path().is_absolute(), "");
+#if defined(_WIN32)
+	soltestAssert(!boost::filesystem::current_path().root_name().empty(), "");
+#endif
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		boost::filesystem::path workDir = boost::filesystem::current_path();
+
+		boost::filesystem::path normalizedPath = FileReader::normalizeCLIPathForVFS(
+			workDir,
+			resolveSymlinks
+		);
+		BOOST_CHECK_EQUAL(normalizedPath, "/" / workDir.relative_path());
+		BOOST_TEST(normalizedPath.root_name().empty());
+		BOOST_CHECK_EQUAL(normalizedPath.root_directory(), "/");
+
+#if defined(_WIN32)
+		std::string root = workDir.root_path().string();
+		soltestAssert(root.length() == 3 && root[1] == ':' && root[2] == '\\', "");
+
+		for (auto convert: {boost::to_lower_copy<std::string>, boost::to_upper_copy<std::string>})
+		{
+			boost::filesystem::path workDirWin = convert(root, std::locale()) / workDir.relative_path();
+			normalizedPath = FileReader::normalizeCLIPathForVFS(
+				workDirWin,
+				resolveSymlinks
+			);
+			BOOST_CHECK_EQUAL(normalizedPath, "/" / workDir.relative_path());
+			BOOST_TEST(normalizedPath.root_name().empty());
+			BOOST_CHECK_EQUAL(normalizedPath.root_directory(), "/");
+		}
+#endif
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_path_beyond_root)
+{
+	TemporaryWorkingDirectory tempWorkDir("/");
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../.", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../a/..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../../a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../../a/..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/../../a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("/a/../../b/../..", resolveSymlinks), "/");
+
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../.", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../a/..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../../a", resolveSymlinks), "/a");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../../a/..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("../../a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/../..", resolveSymlinks), "/");
+		BOOST_CHECK_EQUAL(FileReader::normalizeCLIPathForVFS("a/../../b/../..", resolveSymlinks), "/");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_case_sensitivity)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	boost::filesystem::path workDirNoSymlinks = boost::filesystem::weakly_canonical(tempDir);
+	boost::filesystem::path expectedPrefix = "/" / workDirNoSymlinks.relative_path();
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_TEST(FileReader::normalizeCLIPathForVFS(workDirNoSymlinks / "abc", resolveSymlinks) == expectedPrefix / "abc");
+		BOOST_TEST(FileReader::normalizeCLIPathForVFS(workDirNoSymlinks / "abc", resolveSymlinks) != expectedPrefix / "ABC");
+		BOOST_TEST(FileReader::normalizeCLIPathForVFS(workDirNoSymlinks / "ABC", resolveSymlinks) != expectedPrefix / "abc");
+		BOOST_TEST(FileReader::normalizeCLIPathForVFS(workDirNoSymlinks / "ABC", resolveSymlinks) == expectedPrefix / "ABC");
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_path_separators)
+{
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		// Even on Windows we want / as a separator.
+		BOOST_TEST((
+			FileReader::normalizeCLIPathForVFS("/a/b/c", resolveSymlinks).native() ==
+			boost::filesystem::path("/a/b/c").native()
+		));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_should_not_resolve_symlinks_unless_requested)
+{
+	TemporaryDirectory tempDir({"abc/"}, TEST_CASE_NAME);
+	soltestAssert(tempDir.path().is_absolute(), "");
+
+	if (!createSymlinkIfSupportedByFilesystem(tempDir.path() / "abc", tempDir.path() / "sym", true))
+		return;
+
+	boost::filesystem::path expectedRootPath = FileReader::normalizeCLIRootPathForVFS(tempDir);
+	boost::filesystem::path expectedPrefixWithSymlinks = expectedRootPath / tempDir.path().relative_path();
+	boost::filesystem::path expectedPrefixWithoutSymlinks = expectedRootPath / boost::filesystem::weakly_canonical(tempDir).relative_path();
+
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "sym/contract.sol", SymlinkResolution::Disabled),
+		expectedPrefixWithSymlinks / "sym/contract.sol"
+	);
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "abc/contract.sol", SymlinkResolution::Disabled),
+		expectedPrefixWithSymlinks / "abc/contract.sol"
+	);
+
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "sym/contract.sol", SymlinkResolution::Enabled),
+		expectedPrefixWithoutSymlinks / "abc/contract.sol"
+	);
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "abc/contract.sol", SymlinkResolution::Enabled),
+		expectedPrefixWithoutSymlinks / "abc/contract.sol"
+	);
+}
+
+BOOST_AUTO_TEST_CASE(normalizeCLIPathForVFS_should_resolve_symlinks_in_workdir_when_path_is_relative)
+{
+	TemporaryDirectory tempDir({"abc/"}, TEST_CASE_NAME);
+	soltestAssert(tempDir.path().is_absolute(), "");
+
+	if (!createSymlinkIfSupportedByFilesystem(tempDir.path() / "abc", tempDir.path() / "sym", true))
+		return;
+
+	TemporaryWorkingDirectory tempWorkDir(tempDir.path() / "sym");
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::weakly_canonical(boost::filesystem::current_path()).relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+
+	boost::filesystem::path expectedPrefix = "/" / tempDir.path().relative_path();
+	soltestAssert(expectedPrefix.is_absolute() || expectedPrefix.root_path() == "/", "");
+
+	for (SymlinkResolution resolveSymlinks: {SymlinkResolution::Enabled, SymlinkResolution::Disabled})
+	{
+		BOOST_CHECK_EQUAL(
+			FileReader::normalizeCLIPathForVFS("contract.sol", resolveSymlinks),
+			expectedWorkDir / "contract.sol"
+		);
+	}
+
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "sym/contract.sol", SymlinkResolution::Disabled),
+		expectedPrefix / "sym/contract.sol"
+	);
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "abc/contract.sol", SymlinkResolution::Disabled),
+		expectedPrefix / "abc/contract.sol"
+	);
+
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "sym/contract.sol", SymlinkResolution::Enabled),
+		expectedWorkDir / "contract.sol"
+	);
+	BOOST_CHECK_EQUAL(
+		FileReader::normalizeCLIPathForVFS(tempDir.path() / "abc/contract.sol", SymlinkResolution::Enabled),
+		expectedWorkDir / "contract.sol"
+	);
+}
+
+BOOST_AUTO_TEST_CASE(isPathPrefix_file_prefix)
+{
+	BOOST_TEST(FileReader::isPathPrefix("/", "/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/contract.sol", "/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/contract.sol/", "/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/contract.sol/.", "/contract.sol"));
+
+	BOOST_TEST(FileReader::isPathPrefix("/", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc/def/contract.sol", "/a/bc/def/contract.sol"));
+
+	BOOST_TEST(FileReader::isPathPrefix("/", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc", "/a/bc/def/contract.sol"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc/def/contract.sol", "/a/bc/def/contract.sol"));
+
+	BOOST_TEST(!FileReader::isPathPrefix("/contract.sol", "/token.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/contract", "/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/contract.sol", "/contract"));
+	BOOST_TEST(!FileReader::isPathPrefix("/contract.so", "/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/contract.sol", "/contract.so"));
+
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/contract.sol", "/a/b/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/contract.sol", "/a/b/c/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/contract.sol", "/a/b/c/d/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/d/contract.sol", "/a/b/c/contract.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/contract.sol", "/contract.sol"));
+}
+
+BOOST_AUTO_TEST_CASE(isPathPrefix_directory_prefix)
+{
+	BOOST_TEST(FileReader::isPathPrefix("/", "/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/", "/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c", "/"));
+
+	BOOST_TEST(FileReader::isPathPrefix("/", "/a/bc/"));
+	BOOST_TEST(FileReader::isPathPrefix("/a", "/a/bc/"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/", "/a/bc/"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc", "/a/bc/"));
+	BOOST_TEST(FileReader::isPathPrefix("/a/bc/", "/a/bc/"));
+
+	BOOST_TEST(!FileReader::isPathPrefix("/a", "/b/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/", "/b/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/contract.sol", "/a/b/"));
+
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/", "/a/b/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c", "/a/b/"));
+}
+
+BOOST_AUTO_TEST_CASE(isPathPrefix_unc_path)
+{
+	BOOST_TEST(FileReader::isPathPrefix("//host/a/b/", "//host/a/b/"));
+	BOOST_TEST(FileReader::isPathPrefix("//host/a/b", "//host/a/b/"));
+	BOOST_TEST(FileReader::isPathPrefix("//host/a/", "//host/a/b/"));
+	BOOST_TEST(FileReader::isPathPrefix("//host/a", "//host/a/b/"));
+	BOOST_TEST(FileReader::isPathPrefix("//host/", "//host/a/b/"));
+
+	// NOTE: //host and // cannot be passed to isPathPrefix() because they are considered relative.
+
+	BOOST_TEST(!FileReader::isPathPrefix("//host1/", "//host2/"));
+	BOOST_TEST(!FileReader::isPathPrefix("//host1/a/b/", "//host2/a/b/"));
+
+	BOOST_TEST(!FileReader::isPathPrefix("/a/b/c/", "//a/b/c/"));
+	BOOST_TEST(!FileReader::isPathPrefix("//a/b/c/", "/a/b/c/"));
+}
+
+BOOST_AUTO_TEST_CASE(isPathPrefix_case_sensitivity)
+{
+	BOOST_TEST(!FileReader::isPathPrefix("/a.sol", "/A.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/A.sol", "/a.sol"));
+	BOOST_TEST(!FileReader::isPathPrefix("/A/", "/a/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/", "/A/"));
+	BOOST_TEST(!FileReader::isPathPrefix("/a/BC/def/", "/a/bc/def/contract.sol"));
+}
+
+BOOST_AUTO_TEST_CASE(stripPrefixIfPresent_file_prefix)
+{
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/", "/contract.sol"), "contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract.sol", "/contract.sol"), ".");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract.sol/", "/contract.sol"), ".");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract.sol/.", "/contract.sol"), ".");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/", "/a/bc/def/contract.sol"), "a/bc/def/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a", "/a/bc/def/contract.sol"), "bc/def/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/", "/a/bc/def/contract.sol"), "bc/def/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/bc", "/a/bc/def/contract.sol"), "def/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/bc/def/", "/a/bc/def/contract.sol"), "contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/bc/def/contract.sol", "/a/bc/def/contract.sol"), ".");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract.sol", "/token.sol"), "/token.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract", "/contract.sol"), "/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/contract.sol", "/contract"), "/contract");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/b/c/contract.sol", "/a/b/contract.sol"), "/a/b/contract.sol");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/b/contract.sol", "/a/b/c/contract.sol"), "/a/b/c/contract.sol");
+}
+
+BOOST_AUTO_TEST_CASE(stripPrefixIfPresent_directory_prefix)
+{
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/", "/"), ".");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/", "/a/bc/def/"), "a/bc/def/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a", "/a/bc/def/"), "bc/def/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/", "/a/bc/def/"), "bc/def/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/bc", "/a/bc/def/"), "def/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/bc/def/", "/a/bc/def/"), ".");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a", "/b/"), "/b/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/", "/b/"), "/b/");
+
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/b/c/", "/a/b/"), "/a/b/");
+	BOOST_CHECK_EQUAL(FileReader::stripPrefixIfPresent("/a/b/c", "/a/b/"), "/a/b/");
+}
+
+BOOST_AUTO_TEST_CASE(isUNCPath)
+{
+	BOOST_TEST(FileReader::isUNCPath("//"));
+	BOOST_TEST(FileReader::isUNCPath("//root"));
+	BOOST_TEST(FileReader::isUNCPath("//root/"));
+
+#if defined(_WIN32)
+	// On Windows boost sees these as ///, which is equivalent to /
+	BOOST_TEST(!FileReader::isUNCPath("//\\"));
+	BOOST_TEST(!FileReader::isUNCPath("\\\\/"));
+	BOOST_TEST(!FileReader::isUNCPath("\\/\\"));
+
+	BOOST_TEST(FileReader::isUNCPath("\\\\"));
+	BOOST_TEST(FileReader::isUNCPath("\\\\root"));
+	BOOST_TEST(FileReader::isUNCPath("\\\\root/"));
+#else
+	// On UNIX it's actually an UNC path
+	BOOST_TEST(FileReader::isUNCPath("//\\"));
+
+	// On UNIX these are just weird relative directory names consisting only of backslashes.
+	BOOST_TEST(!FileReader::isUNCPath("\\\\/"));
+	BOOST_TEST(!FileReader::isUNCPath("\\/\\"));
+
+	BOOST_TEST(!FileReader::isUNCPath("\\\\"));
+	BOOST_TEST(!FileReader::isUNCPath("\\\\root"));
+	BOOST_TEST(!FileReader::isUNCPath("\\\\root/"));
+#endif
+
+	BOOST_TEST(!FileReader::isUNCPath("\\/"));
+	BOOST_TEST(!FileReader::isUNCPath("/\\"));
+
+	BOOST_TEST(!FileReader::isUNCPath(""));
+	BOOST_TEST(!FileReader::isUNCPath("."));
+	BOOST_TEST(!FileReader::isUNCPath(".."));
+	BOOST_TEST(!FileReader::isUNCPath("/"));
+	BOOST_TEST(!FileReader::isUNCPath("a"));
+	BOOST_TEST(!FileReader::isUNCPath("a/b/c"));
+	BOOST_TEST(!FileReader::isUNCPath("contract.sol"));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/libsolidity/lsp/hover/hover.sol b/compiler/test/libsolidity/lsp/hover/hover.sol
new file mode 100644
index 00000000..154d2326
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/hover/hover.sol
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+/// Documenting another contract here.
+contract AnotherContract {}
+
+/// User being documented.
+contract User
+{
+    /// Some enum value.
+    enum SomeEnum
+    {
+        Red,
+        Blue
+    }
+
+    /// publicVariable being documented.
+    SomeEnum public publicVariable;
+//  ^ @Cursor1
+//  ^^^^^^^^ @Cursor1Range
+
+    // not documented
+    mapping(int => User.SomeEnum) someRemapping;
+//                      ^ @Cursor2
+//                      ^^^^^^^^ @Cursor2Range
+
+    /// Documenting the setContract().
+    function setValue(User.SomeEnum _value) public
+//                    ^ @Cursor3
+//                    ^^^^ @Cursor3Range
+    {
+        publicVariable = _value;
+//      ^ @Cursor4
+//      ^^^^^^^^^^^^^^ @Cursor4Range
+    }
+
+    function createAnotherContract() public returns (AnotherContract)
+    {
+        return new AnotherContract();
+//                 ^ @Cursor5
+//                 ^^^^^^^^^^^^^^^ @Cursor5Range
+    }
+}
+// ----
+// -> textDocument/hover {
+//     "position": @Cursor1
+// }
+// <- {
+//     "contents": {
+//         "kind": "markdown",
+//         "value": "```solidity\ntype(enum User.SomeEnum)\n```\n\nSome enum value.\n\n"
+//     },
+//     "range": {
+//         "end": {
+//             "character": 12,
+//             "line": 17
+//         },
+//         "start": {
+//             "character": 4,
+//             "line": 17
+//         }
+//     }
+// }
+// -> textDocument/hover {
+//     "position": @Cursor2
+// }
+// <- {
+//     "contents": {
+//         "kind": "markdown",
+//         "value": "```solidity\ntype(enum User.SomeEnum)\n```\n\nSome enum value.\n\n"
+//     },
+//     "range": {
+//         "end": {
+//             "character": 32,
+//             "line": 22
+//         },
+//         "start": {
+//             "character": 24,
+//             "line": 22
+//         }
+//     }
+// }
+// -> textDocument/hover {
+//     "position": @Cursor3
+// }
+// <- {
+//     "contents": {
+//         "kind": "markdown",
+//         "value": "```solidity\ntype(contract User)\n```\n\nUser being documented.\n\n"
+//     },
+//     "range": @Cursor3Range
+// }
+// -> textDocument/hover {
+//     "position": @Cursor4
+// }
+// <- {
+//     "contents": {
+//         "kind": "markdown",
+//         "value": "```solidity\nenum User.SomeEnum\n```\n\n"
+//     },
+//     "range": @Cursor4Range
+// }
+// -> textDocument/hover {
+//     "position": @Cursor5
+// }
+// <- {
+//     "contents": {
+//         "kind": "markdown",
+//         "value": "```solidity\ntype(contract AnotherContract)\n```\n\nDocumenting another contract here.\n\n"
+//     },
+//     "range": @Cursor5Range
+// }
diff --git a/compiler/test/libsolidity/lsp/rename/function.sol b/compiler/test/libsolidity/lsp/rename/function.sol
new file mode 100644
index 00000000..852086c2
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/rename/function.sol
@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+contract C
+{
+    function renameMe() public pure returns (int)
+    //       ^^^^^^^^ @FunctionInDefinition
+    //            ^ @CursorInDefinition
+    {
+        return 1;
+    }
+
+    function other() public view
+    {
+        renameMe();
+//      ^^^^^^^^ @FunctionInFunctionSameContract
+//         ^ @CursorInFunctionSameContract
+        this.renameMe();
+     //      ^^^^^^^^ @FunctionInFunctionSameContractExternal
+         //         ^ @CursorInFunctionSameContractExternal
+    }
+}
+
+contract Other
+{
+    C m_contract;
+
+    function other() public view
+    {
+        m_contract.renameMe();
+           //      ^^^^^^^^ @FunctionInFunctionOtherContract
+        //         ^ @CursorInFunctionOtherContract
+    }
+}
+
+function free() pure
+{
+    C local_contract;
+    local_contract.renameMe();
+           //      ^^^^^^^^ @FunctionInFreeFunction
+        //         ^ @CursorInFreeFunction
+}
+// ----
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorInDefinition
+// }
+// <- {
+//     "changes": {
+//         "rename/function.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionOtherContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContractExternal
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorInFunctionOtherContract
+// }
+// <- {
+//     "changes": {
+//         "rename/function.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionOtherContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContractExternal
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorInFunctionSameContractExternal
+// }
+// <- {
+//     "changes": {
+//         "rename/function.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionOtherContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContractExternal
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorInFunctionSameContract
+// }
+// <- {
+//     "changes": {
+//         "rename/function.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionOtherContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContractExternal
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorInFreeFunction
+// }
+// <- {
+//     "changes": {
+//         "rename/function.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionOtherContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContractExternal
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInFunctionSameContract
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FunctionInDefinition
+//             }
+//         ]
+//     }
+// }
diff --git a/compiler/test/libsolidity/lsp/rename/import_directive.sol b/compiler/test/libsolidity/lsp/rename/import_directive.sol
new file mode 100644
index 00000000..70d86f5d
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/rename/import_directive.sol
@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+import "./contract.sol" as externalFile;
+//                         ^^^^^^^^^^^^ @FileAliasInImportDirective
+//                             ^ @CursorOnFileAliasInImportDirective
+import {ToRename as ExternalContract, User} from "./contract.sol";
+//                  ^^^^^^^^^^^^^^^^ @RenamedContractInImportDirective
+//                         ^ @CursorOnRenamedContractInImportDirective
+//      ^^^^^^^^ @OriginalNameInImportDirective
+//      ^ @CursorOnOriginalNameInImportDirective
+//                                    ^^^^ @UserInImportDirective
+//                                    ^ @CursorOnUserInImportDirective
+
+contract C
+{
+    ExternalContract public externalContract;
+//  ^^^^^^^^^^^^^^^^ @RenamedContractInPublicVariable
+//        ^ @CursorOnRenamedContractInPublicVariable
+    externalFile.ToRename public externalFileContract;
+//  ^^^^^^^^^^^^ @FileAliasInPublicVariable
+//  ^ @CursorOnFileAliasInPublicVariable
+//               ^^^^^^^^ @OriginalNameInPublicVariable
+//                      ^ @CursorOnOriginalNameInPublicVariable
+    User public externalUserContract;
+//  ^^^^ @UserInPublicVariable
+//     ^ @CursorOnUserInPublicVariable
+}
+// ----
+// contract:
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnFileAliasInImportDirective
+// }
+// <- {
+//     "changes": {
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FileAliasInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FileAliasInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnRenamedContractInImportDirective
+// }
+// <- {
+//     "changes": {
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @RenamedContractInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @RenamedContractInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnOriginalNameInImportDirective
+// }
+// <- {
+//     "changes": {
+//         "rename/contract.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInParameter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInReturnExpression
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInReturnParameter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInMapping
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInArrayType
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInDefinition
+//             }
+//         ],
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @OriginalNameInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @OriginalNameInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnRenamedContractInPublicVariable
+// }
+// <- {
+//     "changes": {
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @RenamedContractInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @RenamedContractInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnFileAliasInPublicVariable
+// }
+// <- {
+//     "changes": {
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FileAliasInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @FileAliasInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnOriginalNameInPublicVariable
+// }
+// <- {
+//     "changes": {
+//         "rename/contract.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInParameter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInReturnExpression
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInReturnParameter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInMapping
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInArrayType
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @ContractInDefinition
+//             }
+//         ],
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @OriginalNameInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @OriginalNameInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnUserInPublicVariable
+// }
+// <- {
+//     "changes": {
+//         "rename/contract.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserContractInContractTest
+//             }
+//         ],
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserInImportDirective
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnUserInImportDirective
+// }
+// <- {
+//     "changes": {
+//         "rename/contract.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserContractInContractTest
+//             }
+//         ],
+//         "rename/import_directive.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserInPublicVariable
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @UserInImportDirective
+//             }
+//         ]
+//     }
+// }
diff --git a/compiler/test/libsolidity/lsp/rename/variable.sol b/compiler/test/libsolidity/lsp/rename/variable.sol
new file mode 100644
index 00000000..a3c08f32
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/rename/variable.sol
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+contract C
+{
+    int public renameMe;
+    //         ^^^^^^^^ @VariableInDefinition
+    //         ^ @CursorOnVariableDefinition
+
+    function foo() public returns(int)
+    {
+        renameMe = 1;
+//      ^^^^^^^^ @VariableInFunction
+//             ^ @CursorOnVariableInFunction
+        return this.renameMe();
+//                  ^^^^^^^^ @VariableInGetter
+//                     ^ @CursorOnVariableInGetter
+    }
+}
+
+function freeFunction(C _contract) view returns(int)
+{
+    return _contract.renameMe();
+    //               ^^^^^^^^ @VariableInFreeFunction
+    //                 ^ @CursorOnVariableInFreeFunction
+}
+// ----
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnVariableInFunction
+// }
+// <- {
+//     "changes": {
+//         "rename/variable.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInGetter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnVariableDefinition
+// }
+// <- {
+//     "changes": {
+//         "rename/variable.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInGetter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnVariableInGetter
+// }
+// <- {
+//     "changes": {
+//         "rename/variable.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInGetter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInDefinition
+//             }
+//         ]
+//     }
+// }
+// -> textDocument/rename {
+//     "newName": "Renamed",
+//     "position": @CursorOnVariableInFreeFunction
+// }
+// <- {
+//     "changes": {
+//         "rename/variable.sol": [
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFreeFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInGetter
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInFunction
+//             },
+//             {
+//                 "newText": "Renamed",
+//                 "range": @VariableInDefinition
+//             }
+//         ]
+//     }
+// }
diff --git a/compiler/test/libsolidity/lsp/semanticTokens/enums.sol b/compiler/test/libsolidity/lsp/semanticTokens/enums.sol
new file mode 100644
index 00000000..848c08e7
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/semanticTokens/enums.sol
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+enum Weather {
+    Sunny,
+    Cloudy,
+    Rainy
+}
+
+enum Color {
+    Red,
+    Green,
+    Blue
+}
+
+function getColorEnum() pure returns (Color result)
+{
+    result = Color.Red;
+}
+// ----
+// -> textDocument/semanticTokens/full {
+// }
+// <- {
+//     "data": [
+//         1, 0, 24, 8, 0,
+//         2, 5, 7, 2, 0,
+//         1, 4, 5, 3, 0,
+//         1, 4, 6, 3, 0,
+//         1, 4, 5, 3, 0,
+//         3, 5, 5, 2, 0,
+//         1, 4, 3, 3, 0,
+//         1, 4, 5, 3, 0,
+//         1, 4, 4, 3, 0,
+//         3, 9, 12, 5, 0,
+//         0, 29, 5, 2, 0,
+//         0, 6, 6, 19, 0,
+//         2, 4, 6, 2, 0,
+//         0, 9, 5, 2, 0,
+//         0, 6, 3, 3, 0
+//     ]
+// }
diff --git a/compiler/test/libsolidity/lsp/semanticTokens/functions.sol b/compiler/test/libsolidity/lsp/semanticTokens/functions.sol
new file mode 100644
index 00000000..a7a53495
--- /dev/null
+++ b/compiler/test/libsolidity/lsp/semanticTokens/functions.sol
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+library Lib
+{
+    function add(uint a, uint b) public pure returns (uint result)
+    {
+        result = a + b;
+    }
+
+    function warningWithUnused() public pure
+    {
+        uint unused;
+//      ^^^^^^^^^^^ @unusedVariable
+    }
+}
+
+contract Contract
+{
+    function doNothing() pure public returns (bool)
+    {
+        return true;
+    }
+}
+// ----
+// functions: @unusedVariable 2072
+// -> textDocument/semanticTokens/full {
+// }
+// <- {
+//     "data": [
+//         1, 0, 24, 8, 0,
+//         2, 8, 3, 0, 0,
+//         2, 13, 3, 5, 0,
+//         0, 4, 4, 11, 0,
+//         0, 5, 1, 19, 0,
+//         0, 3, 4, 11, 0,
+//         0, 5, 1, 19, 0,
+//         0, 24, 4, 11, 0,
+//         0, 5, 6, 19, 0,
+//         2, 8, 6, 19, 0,
+//         0, 9, 1, 19, 0,
+//         0, 4, 1, 19, 0,
+//         3, 13, 17, 5, 0,
+//         2, 8, 4, 11, 0,
+//         0, 5, 6, 19, 0,
+//         5, 9, 8, 0, 0,
+//         2, 13, 9, 5, 0,
+//         0, 33, 4, 11, 0,
+//         2, 15, 4, 11, 0
+//     ]
+// }
diff --git a/compiler/test/libsolidity/memoryGuardTests/marked_empty.sol b/compiler/test/libsolidity/memoryGuardTests/marked_empty.sol
new file mode 100644
index 00000000..faae617a
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/marked_empty.sol
@@ -0,0 +1,12 @@
+contract C {
+    constructor() {
+        assembly ("memory-safe") {}
+    }
+
+    function f() public {
+        assembly ("memory-safe") {}
+    }
+}
+// ----
+// :C(creation) true
+// :C(runtime) true
diff --git a/compiler/test/libsolidity/memoryGuardTests/marked_with_memory_access.sol b/compiler/test/libsolidity/memoryGuardTests/marked_with_memory_access.sol
new file mode 100644
index 00000000..8ceb0b1a
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/marked_with_memory_access.sol
@@ -0,0 +1,16 @@
+contract C {
+    constructor() {
+        assembly ("memory-safe") {
+            mstore(0, 1)
+        }
+    }
+
+    function store() public {
+        assembly ("memory-safe") {
+            mstore(0, 1)
+        }
+    }
+}
+// ----
+// :C(creation) true
+// :C(runtime) true
diff --git a/compiler/test/libsolidity/memoryGuardTests/unmarked_empty.sol b/compiler/test/libsolidity/memoryGuardTests/unmarked_empty.sol
new file mode 100644
index 00000000..c87e8893
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/unmarked_empty.sol
@@ -0,0 +1,12 @@
+contract C {
+    constructor() {
+        assembly {}
+    }
+
+    function f() public {
+        assembly {}
+    }
+}
+// ----
+// :C(creation) true
+// :C(runtime) true
diff --git a/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy.sol b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy.sol
new file mode 100644
index 00000000..075cfb6f
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy.sol
@@ -0,0 +1,18 @@
+contract C {
+    constructor() {
+        assembly {
+            mcopy(1000, 2000, 1000)
+        }
+    }
+
+    function copy() public {
+        assembly {
+            mcopy(1000, 2000, 1000)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// :C(creation) false
+// :C(runtime) false
diff --git a/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy_zero_size.sol b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy_zero_size.sol
new file mode 100644
index 00000000..5ef77fcc
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mcopy_zero_size.sol
@@ -0,0 +1,18 @@
+contract C {
+    constructor() {
+        assembly {
+            mcopy(1000, 2000, 0)
+        }
+    }
+
+    function copy() public {
+        assembly {
+            mcopy(1000, 2000, 0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// :C(creation) false
+// :C(runtime) false
diff --git a/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mstore.sol b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mstore.sol
new file mode 100644
index 00000000..3cf05a79
--- /dev/null
+++ b/compiler/test/libsolidity/memoryGuardTests/unmarked_with_memory_access_mstore.sol
@@ -0,0 +1,16 @@
+contract C {
+    constructor() {
+        assembly {
+            mstore(0, 1)
+        }
+    }
+
+    function store() public {
+        assembly {
+            mstore(0, 1)
+        }
+    }
+}
+// ----
+// :C(creation) false
+// :C(runtime) false
diff --git a/compiler/test/libsolidity/natspecJSON/custom.sol b/compiler/test/libsolidity/natspecJSON/custom.sol
new file mode 100644
index 00000000..28073c0b
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/custom.sol
@@ -0,0 +1,43 @@
+/// @custom:x one two three
+/// @custom:y line
+/// break
+/// @custom:t one
+/// @custom:t two
+contract A {
+    /// @custom:note statevar
+    uint x;
+    /// @custom:since 2014
+    function g(int x) public pure virtual returns (int, int) { return (1, 2); }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "custom:t": "onetwo",
+//     "custom:x": "one two three",
+//     "custom:y": "line break",
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "custom:since": "2014"
+//         }
+//     },
+//     "stateVariables":
+//     {
+//         "x":
+//         {
+//             "custom:note": "statevar"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/custom_inheritance.sol b/compiler/test/libsolidity/natspecJSON/custom_inheritance.sol
new file mode 100644
index 00000000..c4a1360f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/custom_inheritance.sol
@@ -0,0 +1,43 @@
+contract A {
+    /// @custom:since 2014
+    function g(uint x) public pure virtual {}
+}
+contract B is A {
+    function g(uint x) public pure override {}
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(uint256)":
+//         {
+//             "custom:since": "2014"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_and_user_basic_test.sol b/compiler/test/libsolidity/natspecJSON/dev_and_user_basic_test.sol
new file mode 100644
index 00000000..42252235
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_and_user_basic_test.sol
@@ -0,0 +1,33 @@
+contract test {
+    /// @notice Multiplies `a` by 7
+    /// @dev Multiplies a number by 7
+    function mul(uint a) public returns (uint d) { return a * 7; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256)":
+//         {
+//             "details": "Multiplies a number by 7"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "mul(uint256)":
+//         {
+//             "notice": "Multiplies `a` by 7"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_and_user_no_doc.sol b/compiler/test/libsolidity/natspecJSON/dev_and_user_no_doc.sol
new file mode 100644
index 00000000..db744791
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_and_user_no_doc.sol
@@ -0,0 +1,24 @@
+contract test {
+    function mul(uint a) public returns (uint d) {
+        return a * 7;
+    }
+    function sub(int input) public returns (int d) {
+        return input - 3;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_author_at_function.sol b/compiler/test/libsolidity/natspecJSON/dev_author_at_function.sol
new file mode 100644
index 00000000..10a21f75
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_author_at_function.sol
@@ -0,0 +1,10 @@
+/// @author Lefteris
+/// @title Just a test contract
+contract test {
+    /// @dev Mul function
+    /// @author John Doe
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 6546: (73-119): Documentation tag @author not valid for functions.
diff --git a/compiler/test/libsolidity/natspecJSON/dev_constructor.sol b/compiler/test/libsolidity/natspecJSON/dev_constructor.sol
new file mode 100644
index 00000000..9cb1e05a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_constructor.sol
@@ -0,0 +1,31 @@
+contract test {
+    /// @param a the parameter a is really nice and very useful
+    /// @param second the second parameter is not very useful, it just provides additional confusion
+    constructor(uint a, uint second) { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "constructor":
+//         {
+//             "params":
+//             {
+//                 "a": "the parameter a is really nice and very useful",
+//                 "second": "the second parameter is not very useful, it just provides additional confusion"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_constructor_and_function.sol b/compiler/test/libsolidity/natspecJSON/dev_constructor_and_function.sol
new file mode 100644
index 00000000..0954009f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_constructor_and_function.sol
@@ -0,0 +1,53 @@
+contract test {
+    /// @param a the parameter a is really nice and very useful
+    /// @param second the second parameter is not very useful, it just provides additional confusion
+    constructor(uint a, uint second) { }
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return d The result of the multiplication
+    /// and cookies with nutella
+    function mul(uint a, uint second) public returns(uint d) {
+        return a * 7 + second;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "constructor":
+//         {
+//             "params":
+//             {
+//                 "a": "the parameter a is really nice and very useful",
+//                 "second": "the second parameter is not very useful, it just provides additional confusion"
+//             }
+//         },
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication and cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_constructor_return.sol b/compiler/test/libsolidity/natspecJSON/dev_constructor_return.sol
new file mode 100644
index 00000000..4695806d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_constructor_return.sol
@@ -0,0 +1,10 @@
+contract test {
+    /// @param a the parameter a is really nice and very useful
+    /// @param second the second parameter is not very useful, it just provides additional confusion
+    /// @return return should not work within constructors
+    constructor(uint a, uint second) { }
+}
+
+// ----
+// DocstringParsingError 6546: (20-239): Documentation tag @return not valid for constructor.
+// DocstringParsingError 2604: (20-239): Documentation tag "@return return should not work within constructors" exceeds the number of return parameters.
diff --git a/compiler/test/libsolidity/natspecJSON/dev_contract_doc.sol b/compiler/test/libsolidity/natspecJSON/dev_contract_doc.sol
new file mode 100644
index 00000000..3958a01e
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_contract_doc.sol
@@ -0,0 +1,30 @@
+/// @author Lefteris
+/// @title Just a test contract
+contract test {
+    /// @dev Mul function
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "author": "Lefteris",
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Mul function"
+//         }
+//     },
+//     "title": "Just a test contract",
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_contract_no_doc.sol b/compiler/test/libsolidity/natspecJSON/dev_contract_no_doc.sol
new file mode 100644
index 00000000..a60847d7
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_contract_no_doc.sol
@@ -0,0 +1,26 @@
+contract test {
+    /// @dev Mul function
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Mul function"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_default_inherit.sol b/compiler/test/libsolidity/natspecJSON/dev_default_inherit.sol
new file mode 100644
index 00000000..dd65ddfb
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_default_inherit.sol
@@ -0,0 +1,117 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// Second line.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract Middle is ERC20 {
+    function transfer(address to, uint amount) virtual override external returns (bool)
+    {
+    return false;
+    }
+}
+
+contract Token is Middle {
+    function transfer(address to, uint amount) override external returns (bool)
+    {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_default_inherit_variable.sol b/compiler/test/libsolidity/natspecJSON/dev_default_inherit_variable.sol
new file mode 100644
index 00000000..89d57d01
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_default_inherit_variable.sol
@@ -0,0 +1,66 @@
+contract C {
+    /// @notice Hello world
+    /// @dev test
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract D is C {
+    uint public override x;
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "x":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_desc_after_nl.sol b/compiler/test/libsolidity/natspecJSON/dev_desc_after_nl.sol
new file mode 100644
index 00000000..fd83ff1b
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_desc_after_nl.sol
@@ -0,0 +1,34 @@
+contract test {
+    /// @dev
+    /// Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param second Documentation for the second parameter
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter",
+//                 "second": "Documentation for the second parameter"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_different_return_name.sol b/compiler/test/libsolidity/natspecJSON/dev_different_return_name.sol
new file mode 100644
index 00000000..7d74cc29
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_different_return_name.sol
@@ -0,0 +1,56 @@
+contract A {
+    /// @return y value
+    function g(int x) public pure virtual returns (int y) { return x; }
+}
+
+contract B is A {
+    function g(int x) public pure override returns (int z) { return x; }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "y": "value"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "z": "value"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple.sol b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple.sol
new file mode 100644
index 00000000..2a8ba399
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple.sol
@@ -0,0 +1,59 @@
+contract A {
+    /// @return a value A
+    /// @return b value B
+    function g(int x) public pure virtual returns (int a, int b) { return (1, 2); }
+}
+
+contract B is A {
+    function g(int x) public pure override returns (int z, int y) { return (1, 2); }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "a": "value A",
+//                 "b": "value B"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "y": "value B",
+//                 "z": "value A"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_partly_unnamed.sol b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_partly_unnamed.sol
new file mode 100644
index 00000000..c41336d8
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_partly_unnamed.sol
@@ -0,0 +1,59 @@
+contract A {
+    /// @return value A
+    /// @return b value B
+    function g(int x) public pure virtual returns (int, int b) { return (1, 2); }
+}
+
+contract B is A {
+    function g(int x) public pure override returns (int z, int) { return (1, 2); }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "_0": "value A",
+//                 "b": "value B"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "_1": "value B",
+//                 "z": "value A"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_unnamed.sol b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_unnamed.sol
new file mode 100644
index 00000000..3bf40011
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_different_return_name_multiple_unnamed.sol
@@ -0,0 +1,59 @@
+contract A {
+    /// @return value A
+    /// @return value B
+    function g(int x) public pure virtual returns (int, int) { return (1, 2); }
+}
+
+contract B is A {
+    function g(int x) public pure override returns (int z, int y) { return (1, 2); }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "_0": "value A",
+//                 "_1": "value B"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "y": "value B",
+//                 "z": "value A"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_description.sol b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_description.sol
new file mode 100644
index 00000000..e02437ac
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_description.sol
@@ -0,0 +1,9 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param second
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 9942: (20-156): No description given for param second
diff --git a/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name.sol b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name.sol
new file mode 100644
index 00000000..c8da55d7
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name.sol
@@ -0,0 +1,9 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 3335: (20-149): No param name given
diff --git a/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name_end.sol b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name_end.sol
new file mode 100644
index 00000000..500092e1
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_param_name_end.sol
@@ -0,0 +1,9 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param se
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 9942: (20-152): No description given for param se
diff --git a/compiler/test/libsolidity/natspecJSON/dev_documenting_no_return_param_name.sol b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_return_param_name.sol
new file mode 100644
index 00000000..2a99c78a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_documenting_no_return_param_name.sol
@@ -0,0 +1,10 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param second Documentation for the second parameter
+    /// @return
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 5856: (20-211): Documentation tag "@return " does not contain the name of its return parameter.
diff --git a/compiler/test/libsolidity/natspecJSON/dev_documenting_nonexistent_param.sol b/compiler/test/libsolidity/natspecJSON/dev_documenting_nonexistent_param.sol
new file mode 100644
index 00000000..a2ebc265
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_documenting_nonexistent_param.sol
@@ -0,0 +1,9 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param not_existing Documentation for the second parameter
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 3881: (20-201): Documented parameter "not_existing" not found in the parameter list of the function.
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit.sol
new file mode 100644
index 00000000..a8ddb313
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit.sol
@@ -0,0 +1,98 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 {
+    function transfer(address to, uint amount) virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21, ERC20 {
+    /// @inheritdoc ERC20
+    function transfer(address to, uint amount) override(ERC21, ERC20) external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit2.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit2.sol
new file mode 100644
index 00000000..4c726f55
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit2.sol
@@ -0,0 +1,115 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 is ERC20 {
+    function transfer(address to, uint amount) virtual override external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC20 {
+    /// @inheritdoc ERC20
+    function transfer(address to, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_complex.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_complex.sol
new file mode 100644
index 00000000..38726c77
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_complex.sol
@@ -0,0 +1,122 @@
+==== Source: Interfaces.sol ====
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+interface ERC21 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test2
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+==== Source: Testfile.sol ====
+import "Interfaces.sol" as myInterfaces;
+
+contract Token is myInterfaces.ERC20, myInterfaces.ERC21 {
+    /// @inheritdoc myInterfaces.ERC20
+    function transfer(address too, uint amount)
+        override(myInterfaces.ERC20, myInterfaces.ERC21) external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// Interfaces.sol:ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// Interfaces.sol:ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// Interfaces.sol:ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test2",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// Interfaces.sol:ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// Testfile.sol:Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// Testfile.sol:Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial.sol
new file mode 100644
index 00000000..c69bd412
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial.sol
@@ -0,0 +1,100 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 {
+    function transfer(address to, uint amount) virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21, ERC20 {
+    /// @inheritdoc ERC20
+    /// @dev override dev comment
+    /// @notice override notice
+    function transfer(address to, uint amount) override(ERC21, ERC20) external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial2.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial2.sol
new file mode 100644
index 00000000..6bb49e88
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_partial2.sol
@@ -0,0 +1,117 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 is ERC20 {
+    /// @inheritdoc ERC20
+    /// @dev override dev comment
+    /// @notice override notice
+    function transfer(address to, uint amount) virtual override external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21 {
+    function transfer(address to, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_variable.sol b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_variable.sol
new file mode 100644
index 00000000..b35a9287
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_explicit_inherit_variable.sol
@@ -0,0 +1,87 @@
+contract B {
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract C {
+    /// @notice Hello world
+    /// @dev test
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract D is C, B {
+    /// @inheritdoc C
+    uint public override(C, B) x;
+}
+
+// ----
+// ----
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "x":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_inherit_parameter_mismatch.sol b/compiler/test/libsolidity/natspecJSON/dev_inherit_parameter_mismatch.sol
new file mode 100644
index 00000000..a8ab60bd
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_inherit_parameter_mismatch.sol
@@ -0,0 +1,97 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract Middle is ERC20 {
+    function transfer(address to, uint amount) override virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is Middle {
+    function transfer(address too, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_multiline_comment.sol b/compiler/test/libsolidity/natspecJSON/dev_multiline_comment.sol
new file mode 100644
index 00000000..b86bcff9
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_multiline_comment.sol
@@ -0,0 +1,44 @@
+contract test {
+    /**
+     * @dev Multiplies a number by 7 and adds second parameter
+     * @param a Documentation for the first parameter starts here.
+     * Since it's a really complicated parameter we need 2 lines
+     * @param second Documentation for the second parameter
+     * @return d The result of the multiplication
+     * and cookies with nutella
+     */
+    function mul(uint a, uint second) public returns (uint d) {
+        return a * 7 + second;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication and cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_multiline_return.sol b/compiler/test/libsolidity/natspecJSON/dev_multiline_return.sol
new file mode 100644
index 00000000..cd3c1df9
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_multiline_return.sol
@@ -0,0 +1,42 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return d The result of the multiplication
+    /// and cookies with nutella
+    function mul(uint a, uint second) public returns (uint d) {
+        return a * 7 + second;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication and cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_multiple_functions.sol b/compiler/test/libsolidity/natspecJSON/dev_multiple_functions.sol
new file mode 100644
index 00000000..899fb5e2
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_multiple_functions.sol
@@ -0,0 +1,63 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param second Documentation for the second parameter
+    function mul(uint a, uint second) public returns (uint d) {
+        return a * 7 + second;
+    }
+    /// @dev Divides 2 numbers
+    /// @param input Documentation for the input parameter
+    /// @param div Documentation for the div parameter
+    function divide(uint input, uint div) public returns (uint d) {
+        return input / div;
+    }
+    /// @dev Subtracts 3 from `input`
+    /// @param input Documentation for the input parameter
+    function sub(int input) public returns (int d) {
+        return input - 3;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "divide(uint256,uint256)":
+//         {
+//             "details": "Divides 2 numbers",
+//             "params":
+//             {
+//                 "div": "Documentation for the div parameter",
+//                 "input": "Documentation for the input parameter"
+//             }
+//         },
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter",
+//                 "second": "Documentation for the second parameter"
+//             }
+//         },
+//         "sub(int256)":
+//         {
+//             "details": "Subtracts 3 from `input`",
+//             "params":
+//             {
+//                 "input": "Documentation for the input parameter"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_multiple_params.sol b/compiler/test/libsolidity/natspecJSON/dev_multiple_params.sol
new file mode 100644
index 00000000..424f368d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_multiple_params.sol
@@ -0,0 +1,33 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter
+    /// @param second Documentation for the second parameter
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter",
+//                 "second": "Documentation for the second parameter"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_multiple_params_mixed_whitespace.sol b/compiler/test/libsolidity/natspecJSON/dev_multiple_params_mixed_whitespace.sol
new file mode 100644
index 00000000..61f45aa6
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_multiple_params_mixed_whitespace.sol
@@ -0,0 +1,33 @@
+contract test {
+  /// @dev	 Multiplies a number by 7 and adds second parameter
+  /// @param 	 a Documentation for the first parameter
+  /// @param	 second			 Documentation for the second parameter
+  function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter",
+//                 "second": "Documentation for the second parameter"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_mutiline_param_description.sol b/compiler/test/libsolidity/natspecJSON/dev_mutiline_param_description.sol
new file mode 100644
index 00000000..9bdfd050
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_mutiline_param_description.sol
@@ -0,0 +1,34 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return.sol b/compiler/test/libsolidity/natspecJSON/dev_return.sol
new file mode 100644
index 00000000..c9789704
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return.sol
@@ -0,0 +1,39 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return d The result of the multiplication
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_desc_after_nl.sol b/compiler/test/libsolidity/natspecJSON/dev_return_desc_after_nl.sol
new file mode 100644
index 00000000..b6ae9f2f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_desc_after_nl.sol
@@ -0,0 +1,42 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return
+    /// d The result of the multiplication
+    function mul(uint a, uint second) public returns (uint d) {
+        return a * 7 + second;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple.sol b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple.sol
new file mode 100644
index 00000000..0c93dfdd
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple.sol
@@ -0,0 +1,44 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return d The result of the multiplication
+    /// @return f And cookies with nutella
+    function mul(uint a, uint second) public returns (uint d, uint f) {
+        uint mul = a * 7;
+        return (mul, second);
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication",
+//                 "f": "And cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed.sol b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed.sol
new file mode 100644
index 00000000..1d93b4ab
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed.sol
@@ -0,0 +1,44 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return The result of the multiplication
+    /// @return And cookies with nutella
+    function mul(uint a, uint second) public returns (uint, uint) {
+        uint mul = a * 7;
+        return (mul, second);
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "_0": "The result of the multiplication",
+//                 "_1": "And cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed.sol b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed.sol
new file mode 100644
index 00000000..6147aace
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed.sol
@@ -0,0 +1,44 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return The result of the multiplication
+    /// @return _cookies And cookies with nutella
+    function mul(uint a, uint second) public returns (uint, uint _cookies) {
+        uint mul = a * 7;
+        return (mul, second);
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "_0": "The result of the multiplication",
+//                 "_cookies": "And cookies with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed_2.sol b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed_2.sol
new file mode 100644
index 00000000..824671ee
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_desc_multiple_unamed_mixed_2.sol
@@ -0,0 +1,47 @@
+contract test {
+    /// @dev Multiplies a number by 7 and adds second parameter
+    /// @param a Documentation for the first parameter starts here.
+    /// Since it's a really complicated parameter we need 2 lines
+    /// @param second Documentation for the second parameter
+    /// @return _cookies And cookies with nutella
+    /// @return The result of the multiplication
+    /// @return _milk And milk with nutella
+    function mul(uint a, uint second) public returns (uint _cookies, uint, uint _milk) {
+        uint mul = a * 7;
+        uint milk = 4;
+        return (mul, second, milk);
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "details": "Multiplies a number by 7 and adds second parameter",
+//             "params":
+//             {
+//                 "a": "Documentation for the first parameter starts here. Since it's a really complicated parameter we need 2 lines",
+//                 "second": "Documentation for the second parameter"
+//             },
+//             "returns":
+//             {
+//                 "_1": "The result of the multiplication",
+//                 "_cookies": "And cookies with nutella",
+//                 "_milk": "And milk with nutella"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_name_no_description.sol b/compiler/test/libsolidity/natspecJSON/dev_return_name_no_description.sol
new file mode 100644
index 00000000..1e65a235
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_name_no_description.sol
@@ -0,0 +1,56 @@
+contract A {
+    /// @return a
+    function g(int x) public pure virtual returns (int a) { return 2; }
+}
+
+contract B is A {
+    function g(int x) public pure override returns (int b) { return 2; }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "a": "a"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "g(int256)":
+//         {
+//             "returns":
+//             {
+//                 "b": "a"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_return_no_params.sol b/compiler/test/libsolidity/natspecJSON/dev_return_no_params.sol
new file mode 100644
index 00000000..37442f10
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_return_no_params.sol
@@ -0,0 +1,29 @@
+contract test {
+    /// @return d The result of the multiplication
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "mul(uint256,uint256)":
+//         {
+//             "returns":
+//             {
+//                 "d": "The result of the multiplication"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override.sol b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override.sol
new file mode 100644
index 00000000..019e1a33
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override.sol
@@ -0,0 +1,65 @@
+interface IThing {
+    /// @return x a number
+    /// @return y another number
+    function value() external view returns (uint128 x, uint128 y);
+}
+
+contract Thing is IThing {
+    struct Value {
+        uint128 x;
+        uint128 y;
+    }
+
+    Value public override value;
+}
+
+// ----
+// ----
+// :IThing devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "value()":
+//         {
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :IThing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Thing devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "value":
+//         {
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Thing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_different_return_parameter_names.sol b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_different_return_parameter_names.sol
new file mode 100644
index 00000000..0acfa70f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_different_return_parameter_names.sol
@@ -0,0 +1,65 @@
+interface IThing {
+    /// @return x a number
+    /// @return y another number
+    function value() external view returns (uint128 x, uint128 y);
+}
+
+contract Thing is IThing {
+    struct Value {
+        uint128 a;
+        uint128 b;
+    }
+
+    Value public override value;
+}
+
+// ----
+// ----
+// :IThing devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "value()":
+//         {
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :IThing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Thing devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "value":
+//         {
+//             "returns":
+//             {
+//                 "a": "a number",
+//                 "b": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Thing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_no_return_name.sol b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_no_return_name.sol
new file mode 100644
index 00000000..06810957
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_struct_getter_override_no_return_name.sol
@@ -0,0 +1,62 @@
+interface IThing {
+    ///@return
+    function value(uint) external returns (uint128,uint128);
+}
+
+contract Thing is IThing {
+    struct Value {
+        uint128 x;
+        uint128 A;
+    }
+    mapping(uint=>Value) public override value;
+}
+
+// ----
+// ----
+// :IThing devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "value(uint256)":
+//         {
+//             "returns":
+//             {
+//                 "_0": ""
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :IThing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Thing devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "value":
+//         {
+//             "return": "x ",
+//             "returns":
+//             {
+//                 "x": ""
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Thing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/dev_title_at_function_error.sol b/compiler/test/libsolidity/natspecJSON/dev_title_at_function_error.sol
new file mode 100644
index 00000000..2b18e807
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/dev_title_at_function_error.sol
@@ -0,0 +1,10 @@
+/// @author Lefteris
+/// @title Just a test contract
+contract test {
+    /// @dev Mul function
+    /// @title I really should not be here
+    function mul(uint a, uint second) public returns (uint d) { return a * 7 + second; }
+}
+
+// ----
+// DocstringParsingError 6546: (73-137): Documentation tag @title not valid for functions.
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_double_empty.sol b/compiler/test/libsolidity/natspecJSON/docstring_double_empty.sol
new file mode 100644
index 00000000..16222d0a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_double_empty.sol
@@ -0,0 +1,21 @@
+contract C {
+  ///
+  ///
+  function vote(uint id) public {
+  }
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_enum.sol b/compiler/test/libsolidity/natspecJSON/docstring_enum.sol
new file mode 100644
index 00000000..d5ace6b1
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_enum.sol
@@ -0,0 +1,25 @@
+contract C {
+    /// @title example of title
+    /// @author example of author
+    /// @notice example of notice
+    /// @dev example of dev
+    enum Color {
+        Red,
+        Green
+    }
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_named_return_parameter.sol b/compiler/test/libsolidity/natspecJSON/docstring_named_return_parameter.sol
new file mode 100644
index 00000000..01e0368d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_named_return_parameter.sol
@@ -0,0 +1,28 @@
+abstract contract C {
+    /// @return value The value returned by this function.
+    function vote() public virtual returns (uint value);
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "vote()":
+//         {
+//             "returns":
+//             {
+//                 "value": "The value returned by this function."
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_parameter.sol b/compiler/test/libsolidity/natspecJSON/docstring_parameter.sol
new file mode 100644
index 00000000..deacbbca
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_parameter.sol
@@ -0,0 +1,26 @@
+contract C {
+    /**
+     * @dev a function
+     * @param _from 5 from address
+     * @param _5to   : to address
+     * @param value: token transfer amount
+     * @param value? token transfer amount
+     */
+    function f(address _from, address _5to, uint256 value) internal {
+    }
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_private_state_variable.sol b/compiler/test/libsolidity/natspecJSON/docstring_private_state_variable.sol
new file mode 100644
index 00000000..2ea1747e
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_private_state_variable.sol
@@ -0,0 +1,27 @@
+contract C {
+    /// @notice example of notice
+    /// @dev example of dev
+    uint private state;
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "state":
+//         {
+//             "details": "example of dev"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_state_variable.sol b/compiler/test/libsolidity/natspecJSON/docstring_state_variable.sol
new file mode 100644
index 00000000..5627c206
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_state_variable.sol
@@ -0,0 +1,33 @@
+contract C {
+    /// @notice example of notice
+    /// @dev example of dev
+    uint public state;
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "state":
+//         {
+//             "details": "example of dev"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "state()":
+//         {
+//             "notice": "example of notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_struct.sol b/compiler/test/libsolidity/natspecJSON/docstring_struct.sol
new file mode 100644
index 00000000..91e5802d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_struct.sol
@@ -0,0 +1,26 @@
+contract C {
+    /// @title example of title
+    /// @author example of author
+    /// @notice example of notice
+    /// @dev example of dev
+    struct Example {
+        string text;
+        bool valid;
+        uint256 value;
+    }
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/docstring_variable.sol b/compiler/test/libsolidity/natspecJSON/docstring_variable.sol
new file mode 100644
index 00000000..66a143ff
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/docstring_variable.sol
@@ -0,0 +1,27 @@
+contract C {
+    function f() public pure returns (uint) {
+        /// @title example of title
+        /// @author example of author
+        /// @notice example of notice
+        /// @dev example of dev
+        /// @param example of param
+        /// @return example of return
+        uint state = 42;
+        return state;
+    }
+}
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract.sol b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract.sol
new file mode 100644
index 00000000..66977513
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract.sol
@@ -0,0 +1,69 @@
+contract X {
+    /// @notice Userdoc for event E.
+    /// @dev Devdoc for event E.
+    event E();
+}
+
+contract C {
+    function g() public {
+        emit X.E();
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for event E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for event E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :X devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for event E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :X userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for event E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_no_inheritance.sol b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_no_inheritance.sol
new file mode 100644
index 00000000..c8909139
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_no_inheritance.sol
@@ -0,0 +1,59 @@
+// Tests that emitting an event from contract C in contract D does not inherit natspec from C.E
+
+contract C {
+    /// @notice C.E event
+    /// @dev C.E event
+    event E();
+}
+
+contract D {
+    event E();
+
+    function test() public {
+        emit C.E();
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "C.E event"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "C.E event"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_with_same_signature.sol b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_with_same_signature.sol
new file mode 100644
index 00000000..6030c27d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_event_from_foreign_contract_with_same_signature.sol
@@ -0,0 +1,74 @@
+contract C {
+    /// @notice C.E event
+    /// @dev C.E event
+    event E(uint256 value);
+}
+
+contract D {
+    /// @notice D.E event
+    /// @dev D.E event
+    event E(uint256 value);
+
+    function test() public {
+        emit C.E(1);
+        emit E(2);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "E(uint256)":
+//         {
+//             "details": "C.E event"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "E(uint256)":
+//         {
+//             "notice": "C.E event"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "events":
+//     {
+//         "E(uint256)":
+//         {
+//             "details": "D.E event"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "events":
+//     {
+//         "E(uint256)":
+//         {
+//             "notice": "D.E event"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_file_level_event.sol b/compiler/test/libsolidity/natspecJSON/emit_file_level_event.sol
new file mode 100644
index 00000000..42c028ec
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_file_level_event.sol
@@ -0,0 +1,39 @@
+/// @notice Userdoc for file-level event E.
+/// @dev Devdoc for file-level E.
+event E();
+
+contract C {
+    function f() public {
+        emit E();
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for file-level E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for file-level event E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_file_level_event_inheritance.sol b/compiler/test/libsolidity/natspecJSON/emit_file_level_event_inheritance.sol
new file mode 100644
index 00000000..f8660a27
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_file_level_event_inheritance.sol
@@ -0,0 +1,69 @@
+/// @notice Userdoc for file-level event E.
+/// @dev Devdoc for file-level E.
+event E();
+
+contract C {
+    function f() public {
+        emit E();
+    }
+}
+
+contract D is C {}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for file-level E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for file-level event E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for file-level E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for file-level event E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_file_level_event_with_same_signature_as_foreign_event.sol b/compiler/test/libsolidity/natspecJSON/emit_file_level_event_with_same_signature_as_foreign_event.sol
new file mode 100644
index 00000000..0e084434
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_file_level_event_with_same_signature_as_foreign_event.sol
@@ -0,0 +1,60 @@
+/// @notice Userdoc for file-level event E.
+/// @dev Devdoc for file-level E.
+event E();
+
+contract F {
+    /// @notice Userdoc for event F.E.
+    /// @dev Devdoc for event F.E.
+    event E();
+}
+
+contract C {
+    function f() public {
+        emit E();
+        emit F.E();
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :F devdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "details": "Devdoc for event F.E."
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :F userdoc
+// {
+//     "events":
+//     {
+//         "E()":
+//         {
+//             "notice": "Userdoc for event F.E."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries.sol
new file mode 100644
index 00000000..46c8cadf
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries.sol
@@ -0,0 +1,122 @@
+library L1 {
+    /// @notice This event is defined in Library L1
+    /// @dev This should not appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+}
+library L2 {
+    /// @notice This event is defined in Library L2
+    /// @dev This should not appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+}
+library L3 {
+    /// @notice This event is defined in Library L3
+    /// @dev This should not appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+}
+contract C {
+    function f() public {
+        emit L1.SameSignatureEvent(0);
+        emit L2.SameSignatureEvent(1);
+        emit L3.SameSignatureEvent(2);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L1 devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L1 userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Library L1"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L2 devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L2 userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Library L2"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L3 devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L3 userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Library L3"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries_missing_natspec.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries_missing_natspec.sol
new file mode 100644
index 00000000..ba51b10c
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_different_libraries_missing_natspec.sol
@@ -0,0 +1,90 @@
+library L1 {
+    event SameSignatureEvent(uint16);
+}
+library L2 {
+    /// @notice This event is defined in library L2
+    /// @dev This should not appear in Contract C devdoc
+    event SameSignatureEvent(uint16);
+}
+library L3 {
+    event SameSignatureEvent(uint16);
+}
+contract C {
+    function f() public {
+        emit L1.SameSignatureEvent(0);
+        emit L2.SameSignatureEvent(1);
+        emit L3.SameSignatureEvent(2);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L1 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L1 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L2 devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C devdoc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L2 userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in library L2"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L3 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L3 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract.sol
new file mode 100644
index 00000000..9b198afd
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract.sol
@@ -0,0 +1,104 @@
+library L {
+    /// @notice This event is defined in Library L
+    /// @dev This should not appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+    /// @notice This event is defined in Library L
+    /// @dev This should appear in Contract C dev doc
+    event LibraryEvent(uint32);
+}
+contract C {
+    /// @notice This event is defined in Contract C
+    /// @dev This should appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+    /// @notice This event is defined in Contract C
+    /// @dev This should appear in contract C dev doc
+    event ContractEvent(uint32);
+    function f() public {
+    emit L.SameSignatureEvent(0);
+    emit SameSignatureEvent(1);
+    emit L.LibraryEvent(2);
+    emit ContractEvent(3);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "ContractEvent(uint32)":
+//         {
+//             "details": "This should appear in contract C dev doc"
+//         },
+//         "LibraryEvent(uint32)":
+//         {
+//             "details": "This should appear in Contract C dev doc"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "ContractEvent(uint32)":
+//         {
+//             "notice": "This event is defined in Contract C"
+//         },
+//         "LibraryEvent(uint32)":
+//         {
+//             "notice": "This event is defined in Library L"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Contract C"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L devdoc
+// {
+//     "events":
+//     {
+//         "LibraryEvent(uint32)":
+//         {
+//             "details": "This should appear in Contract C dev doc"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L userdoc
+// {
+//     "events":
+//     {
+//         "LibraryEvent(uint32)":
+//         {
+//             "notice": "This event is defined in Library L"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Library L"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract_missing_natspec.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract_missing_natspec.sol
new file mode 100644
index 00000000..9bc2f57f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_contract_missing_natspec.sol
@@ -0,0 +1,89 @@
+library L {
+    /// @notice This event is defined in library L
+    /// @dev This should not appear in contract C devdoc
+    event SameSignatureEvent(uint16);
+    /// @notice This event is defined in library L
+    /// @dev This should appear in contract C devdoc
+    event LibraryEvent(uint32);
+}
+contract C {
+    event SameSignatureEvent(uint16);
+    /// @notice This event is defined in contract C
+    event ContractEvent(uint32);
+    function f() public {
+        emit L.SameSignatureEvent(0);
+        emit SameSignatureEvent(1);
+        emit L.LibraryEvent(2);
+        emit ContractEvent(3);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "LibraryEvent(uint32)":
+//         {
+//             "details": "This should appear in contract C devdoc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "ContractEvent(uint32)":
+//         {
+//             "notice": "This event is defined in contract C"
+//         },
+//         "LibraryEvent(uint32)":
+//         {
+//             "notice": "This event is defined in library L"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L devdoc
+// {
+//     "events":
+//     {
+//         "LibraryEvent(uint32)":
+//         {
+//             "details": "This should appear in contract C devdoc"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in contract C devdoc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L userdoc
+// {
+//     "events":
+//     {
+//         "LibraryEvent(uint32)":
+//         {
+//             "notice": "This event is defined in library L"
+//         },
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in library L"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited.sol
new file mode 100644
index 00000000..ecc7ee62
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited.sol
@@ -0,0 +1,102 @@
+contract D {
+    /// @notice This event is defined in contract D
+    /// @dev This should appear in Contract C dev doc
+    event SameSignatureEvent(uint16);
+}
+library L {
+    /// @notice This event is defined in Library L
+    /// @dev This should not appear in Contract C
+    event SameSignatureEvent(uint16);
+}
+contract C is D {
+    function f() public {
+        emit L.SameSignatureEvent(0);
+        emit D.SameSignatureEvent(1);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in contract D"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should appear in Contract C dev doc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in contract D"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in Contract C"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in Library L"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited_missing_natspec.sol b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited_missing_natspec.sol
new file mode 100644
index 00000000..a3a6286c
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/emit_same_signature_event_library_inherited_missing_natspec.sol
@@ -0,0 +1,72 @@
+contract D {
+    event SameSignatureEvent(uint16);
+}
+library L {
+    /// @notice This event is defined in library L
+    /// @dev This should not appear in contract C devdoc
+    event SameSignatureEvent(uint16);
+}
+contract C is D {
+    function f() public {
+        emit L.SameSignatureEvent(0);
+        emit D.SameSignatureEvent(1);
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L devdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "details": "This should not appear in contract C devdoc"
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :L userdoc
+// {
+//     "events":
+//     {
+//         "SameSignatureEvent(uint16)":
+//         {
+//             "notice": "This event is defined in library L"
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/empty_comment.sol b/compiler/test/libsolidity/natspecJSON/empty_comment.sol
new file mode 100644
index 00000000..4310c26d
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/empty_comment.sol
@@ -0,0 +1,19 @@
+//
+contract test
+{}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/enum_no_docs.sol b/compiler/test/libsolidity/natspecJSON/enum_no_docs.sol
new file mode 100644
index 00000000..021f7c6b
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/enum_no_docs.sol
@@ -0,0 +1,26 @@
+contract C {
+    /// @title example of title
+    /// @author example of author
+    /// @notice example of notice
+    /// @dev example of dev
+    enum Color {
+        Red,
+        Green
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/error.sol b/compiler/test/libsolidity/natspecJSON/error.sol
new file mode 100644
index 00000000..c82412fe
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/error.sol
@@ -0,0 +1,46 @@
+contract test {
+    /// Something failed.
+    /// @dev an error.
+    /// @param a first parameter
+    /// @param b second parameter
+    error E(uint a, uint b);
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "details": "an error.",
+//                 "params":
+//                 {
+//                     "a": "first parameter",
+//                     "b": "second parameter"
+//                 }
+//             }
+//         ]
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "notice": "Something failed."
+//             }
+//         ]
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/error_multiple.sol b/compiler/test/libsolidity/natspecJSON/error_multiple.sol
new file mode 100644
index 00000000..205e79a9
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/error_multiple.sol
@@ -0,0 +1,107 @@
+contract A {
+    /// Something failed.
+    /// @dev an error.
+    /// @param x first parameter
+    /// @param y second parameter
+    error E(uint x, uint y);
+}
+contract test {
+    /// X Something failed.
+    /// @dev X an error.
+    /// @param a X first parameter
+    /// @param b X second parameter
+    error E(uint a, uint b);
+    function f(bool a) public pure {
+        if (a)
+            revert E(1, 2);
+        else
+            revert A.E(5, 6);
+    }
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "details": "an error.",
+//                 "params":
+//                 {
+//                     "x": "first parameter",
+//                     "y": "second parameter"
+//                 }
+//             }
+//         ]
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "notice": "Something failed."
+//             }
+//         ]
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test devdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "details": "an error.",
+//                 "params":
+//                 {
+//                     "x": "first parameter",
+//                     "y": "second parameter"
+//                 }
+//             },
+//             {
+//                 "details": "X an error.",
+//                 "params":
+//                 {
+//                     "a": "X first parameter",
+//                     "b": "X second parameter"
+//                 }
+//             }
+//         ]
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "errors":
+//     {
+//         "E(uint256,uint256)":
+//         [
+//             {
+//                 "notice": "Something failed."
+//             },
+//             {
+//                 "notice": "X Something failed."
+//             }
+//         ]
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/event.sol b/compiler/test/libsolidity/natspecJSON/event.sol
new file mode 100644
index 00000000..9887b021
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/event.sol
@@ -0,0 +1,44 @@
+contract ERC20 {
+    /// @notice This event is emitted when a transfer occurs.
+    /// @param from The source account.
+    /// @param to The destination account.
+    /// @param amount The amount.
+    /// @dev A test case!
+    event Transfer(address indexed from, address indexed to, uint amount);
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/event_inheritance.sol b/compiler/test/libsolidity/natspecJSON/event_inheritance.sol
new file mode 100644
index 00000000..7912bd1b
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/event_inheritance.sol
@@ -0,0 +1,116 @@
+contract ERC20 {
+    /// @notice This event is emitted when a transfer occurs.
+    /// @param from The source account.
+    /// @param to The destination account.
+    /// @param amount The amount.
+    /// @dev A test case!
+    event Transfer(address indexed from, address indexed to, uint amount);
+}
+contract A is ERC20 {
+}
+contract B is A {
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC20 devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/event_inheritance_interface.sol b/compiler/test/libsolidity/natspecJSON/event_inheritance_interface.sol
new file mode 100644
index 00000000..8b4137fc
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/event_inheritance_interface.sol
@@ -0,0 +1,116 @@
+interface ERC20 {
+    /// @notice This event is emitted when a transfer occurs.
+    /// @param from The source account.
+    /// @param to The destination account.
+    /// @param amount The amount.
+    /// @dev A test case!
+    event Transfer(address indexed from, address indexed to, uint amount);
+}
+contract A is ERC20 {
+}
+contract B is A {
+}
+
+// ----
+// ----
+// :A devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :A userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC20 devdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "details": "A test case!",
+//             "params":
+//             {
+//                 "amount": "The amount.",
+//                 "from": "The source account.",
+//                 "to": "The destination account."
+//             }
+//         }
+//     },
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "events":
+//     {
+//         "Transfer(address,address,uint256)":
+//         {
+//             "notice": "This event is emitted when a transfer occurs."
+//         }
+//     },
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_function.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_function.sol
new file mode 100644
index 00000000..71db9907
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_function.sol
@@ -0,0 +1,6 @@
+contract C {
+    /// @author author
+    function iHaveAuthor() public pure {}
+}
+// ----
+// DocstringParsingError 6546: (17-35): Documentation tag @author not valid for functions.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_title_state_variable.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_title_state_variable.sol
new file mode 100644
index 00000000..e861d31c
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_author_title_state_variable.sol
@@ -0,0 +1,8 @@
+contract C {
+    /// @title title
+    /// @author author
+    uint private state;
+}
+// ----
+// DocstringParsingError 6546: (17-56): Documentation tag @author not valid for non-public state variables.
+// DocstringParsingError 6546: (17-56): Documentation tag @title not valid for non-public state variables.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_description.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_description.sol
new file mode 100644
index 00000000..e77e42c4
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_description.sol
@@ -0,0 +1,6 @@
+contract C {
+    /// @param id
+    function vote(uint id) public {}
+}
+// ----
+// DocstringParsingError 9942: (17-30): No description given for param id
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_tag.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_tag.sol
new file mode 100644
index 00000000..56c3d59a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_empty_tag.sol
@@ -0,0 +1,6 @@
+abstract contract C {
+    /// @param
+    function vote(uint id) public {}
+}
+// ----
+// DocstringParsingError 3335: (26-36): No param name given
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return.sol
new file mode 100644
index 00000000..2517ff38
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return.sol
@@ -0,0 +1,10 @@
+contract C {
+	///@return
+	modifier m22 virtual { _; }
+}
+
+contract D is C {
+	modifier m22 override { _; }
+}
+// ----
+// DocstringParsingError 6546: (14-24): Documentation tag @return not valid for modifiers.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return2.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return2.sol
new file mode 100644
index 00000000..5b81a466
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inherit_modifier_no_return2.sol
@@ -0,0 +1,12 @@
+contract A {
+	/// @return a
+	function g(int x) public virtual { return 2; }
+}
+
+contract B is A {
+	function g(int x) public pure override returns (int b) { return 2; }
+}
+// ----
+// DocstringParsingError 2604: (14-27): Documentation tag "@return a" exceeds the number of return parameters.
+// TypeError 4822: (98-166): Overriding function return types differ.
+// TypeError 8863: (64-72): Different number of arguments in return statement than in returns declaration.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc.sol
new file mode 100644
index 00000000..678872d7
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc.sol
@@ -0,0 +1,7 @@
+contract C {
+    /// @inheritdoc X
+    function f() internal {
+    }
+}
+// ----
+// DocstringParsingError 9397: (17-34): Documentation tag @inheritdoc references inexistent contract "X".
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc2.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc2.sol
new file mode 100644
index 00000000..4d97ff93
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc2.sol
@@ -0,0 +1,10 @@
+contract D {
+}
+
+contract C is D {
+    /// @inheritdoc D
+    function f() internal {
+    }
+}
+// ----
+// DocstringParsingError 4682: (38-55): Documentation tag @inheritdoc references contract "D", but the contract does not contain a function that is overridden by this function.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc3.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc3.sol
new file mode 100644
index 00000000..d00e1e7e
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc3.sol
@@ -0,0 +1,11 @@
+contract D {
+    struct S { uint a; }
+}
+
+contract C is D {
+    /// @inheritdoc D.S
+    function f() internal {
+    }
+}
+// ----
+// DocstringParsingError 1430: (63-82): Documentation tag @inheritdoc reference "D.S" is not a contract.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_emptys.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_emptys.sol
new file mode 100644
index 00000000..d2c41cd2
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_emptys.sol
@@ -0,0 +1,19 @@
+contract C {
+    /// @inheritdoc
+    function f() internal {
+    }
+    /// @inheritdoc .
+    function f() internal {
+    }
+    /// @inheritdoc C..f
+    function f() internal {
+    }
+    /// @inheritdoc C.
+    function f() internal {
+    }
+}
+// ----
+// DocstringParsingError 1933: (17-32): Expected contract name following documentation tag @inheritdoc.
+// DocstringParsingError 5967: (71-88): Documentation tag @inheritdoc reference "." is malformed.
+// DocstringParsingError 5967: (127-147): Documentation tag @inheritdoc reference "C..f" is malformed.
+// DocstringParsingError 5967: (186-204): Documentation tag @inheritdoc reference "C." is malformed.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_twice.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_twice.sol
new file mode 100644
index 00000000..d59dea29
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_twice.sol
@@ -0,0 +1,9 @@
+contract B {}
+
+contract C {
+    /// @inheritdoc B
+    /// @inheritdoc B
+    function f() internal {}
+}
+// ----
+// DocstringParsingError 5142: (32-71): Documentation tag @inheritdoc can only be given once.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_wrong_type.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_wrong_type.sol
new file mode 100644
index 00000000..510f6622
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_inheritdoc_wrong_type.sol
@@ -0,0 +1,8 @@
+contract C {
+    struct S { uint a; }
+    /// @inheritdoc S
+    function f() internal {
+    }
+}
+// ----
+// DocstringParsingError 1430: (42-59): Documentation tag @inheritdoc reference "S" is not a contract.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_named_return_param_mismatch.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_named_return_param_mismatch.sol
new file mode 100644
index 00000000..6e9ef2e9
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_named_return_param_mismatch.sol
@@ -0,0 +1,7 @@
+abstract contract C {
+    /// @param id Some identifier
+    /// @return No value returned
+    function vote(uint id) public virtual returns (uint value);
+}
+// ----
+// DocstringParsingError 5856: (26-89): Documentation tag "@return No value returned" does not contain the name of its return parameter.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_non_public_state_variable_with_return.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_non_public_state_variable_with_return.sol
new file mode 100644
index 00000000..da2d75fe
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_non_public_state_variable_with_return.sol
@@ -0,0 +1,6 @@
+contract test {
+  /// @return returns something
+  uint private state;
+}
+// ----
+// DocstringParsingError 6546: (18-47): Documentation tag @return not valid for non-public state variables.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_parameter.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_parameter.sol
new file mode 100644
index 00000000..9ea55334
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_parameter.sol
@@ -0,0 +1,11 @@
+contract C {
+    /**
+     * @param 5value a value parameter
+     * @param _ a value parameter
+     */
+    function f(uint256 _5value, uint256 _value, uint256 value) internal {
+    }
+}
+// ----
+// DocstringParsingError 3881: (17-101): Documented parameter "" not found in the parameter list of the function.
+// DocstringParsingError 3881: (17-101): Documented parameter "_" not found in the parameter list of the function.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_return_size_mismatch.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_return_size_mismatch.sol
new file mode 100644
index 00000000..e060a543
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_return_size_mismatch.sol
@@ -0,0 +1,11 @@
+abstract contract C {
+    /// @param id Some identifier
+    /// @return No value returned
+    function vote(uint id) public virtual returns (uint value);
+
+    /// @return No value returned
+    function unvote(uint id) public virtual returns (uint value);
+}
+// ----
+// DocstringParsingError 5856: (26-89): Documentation tag "@return No value returned" does not contain the name of its return parameter.
+// DocstringParsingError 5856: (159-188): Documentation tag "@return No value returned" does not contain the name of its return parameter.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_state_variable_too_many_return_tags.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_state_variable_too_many_return_tags.sol
new file mode 100644
index 00000000..bccedd5a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_state_variable_too_many_return_tags.sol
@@ -0,0 +1,9 @@
+contract test {
+  /// @notice example of notice
+  /// @dev example of dev
+  /// @return returns something
+  /// @return returns something
+  uint public state;
+}
+// ----
+// DocstringParsingError 2604: (18-137): Documentation tag "@return returns something" exceeds the number of return parameters.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/docstring_too_many_return_tags.sol b/compiler/test/libsolidity/natspecJSON/invalid/docstring_too_many_return_tags.sol
new file mode 100644
index 00000000..11131603
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/docstring_too_many_return_tags.sol
@@ -0,0 +1,8 @@
+abstract contract C {
+    /// @param id Some identifier
+    /// @return value Some value
+	/// @return value2 Some value 2
+    function vote(uint id) public virtual returns (uint value);
+}
+// ----
+// DocstringParsingError 2604: (26-121): Documentation tag "@return value2 Some value 2" exceeds the number of return parameters.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/inherit_doc_events.sol b/compiler/test/libsolidity/natspecJSON/invalid/inherit_doc_events.sol
new file mode 100644
index 00000000..e7fb1a82
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/inherit_doc_events.sol
@@ -0,0 +1,17 @@
+contract ERC20 {
+	/// @notice This event is emitted when a transfer occurs.
+	/// @param from The source account.
+	/// @param to The destination account.
+	/// @param amount The amount.
+	/// @dev A test case!
+	event Transfer(address indexed from, address indexed to, uint amount);
+}
+
+contract A is ERC20 {
+	/// @inheritdoc ERC20
+	event Transfer();
+}
+
+
+// ----
+// DocstringParsingError 6546: (305-326): Documentation tag @inheritdoc not valid for events.
diff --git a/compiler/test/libsolidity/natspecJSON/invalid/invalid_tag.sol b/compiler/test/libsolidity/natspecJSON/invalid/invalid_tag.sol
new file mode 100644
index 00000000..741dc440
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/invalid/invalid_tag.sol
@@ -0,0 +1,19 @@
+/// @a&b test
+contract C {
+	/// @custom:x^y test2
+	function f() public pure {}
+	/// @custom:
+	function g() public pure {}
+	/// @custom:abcDEF
+	function h() public pure {}
+	/// @custom:abc-def
+	function i() public pure {}
+	/// @custom
+	function j() public pure {}
+}
+// ----
+// DocstringParsingError 6546: (0-14): Documentation tag @a&b not valid for contracts.
+// DocstringParsingError 2968: (28-49): Invalid character in custom tag @custom:x^y. Only lowercase letters and "-" are permitted.
+// DocstringParsingError 6564: (80-92): Custom documentation tag must contain a chosen name, i.e. @custom:mytag.
+// DocstringParsingError 2968: (123-141): Invalid character in custom tag @custom:abcDEF. Only lowercase letters and "-" are permitted.
+// DocstringParsingError 6564: (222-233): Custom documentation tag must contain a chosen name, i.e. @custom:mytag.
diff --git a/compiler/test/libsolidity/natspecJSON/multiline_notice_without_tag.sol b/compiler/test/libsolidity/natspecJSON/multiline_notice_without_tag.sol
new file mode 100644
index 00000000..4f055b2f
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/multiline_notice_without_tag.sol
@@ -0,0 +1,27 @@
+contract test {
+    /// I do something awesome
+    /// which requires two lines to explain
+    function mul(uint a) public returns (uint d) { return a * 7; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "mul(uint256)":
+//         {
+//             "notice": "I do something awesome which requires two lines to explain"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/notice_without_tag.sol b/compiler/test/libsolidity/natspecJSON/notice_without_tag.sol
new file mode 100644
index 00000000..d5629933
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/notice_without_tag.sol
@@ -0,0 +1,26 @@
+contract test {
+    /// I do something awesome
+    function mul(uint a) public returns (uint d) { return a * 7; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "mul(uint256)":
+//         {
+//             "notice": "I do something awesome"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/private_state_variable.sol b/compiler/test/libsolidity/natspecJSON/private_state_variable.sol
new file mode 100644
index 00000000..7d7707a8
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/private_state_variable.sol
@@ -0,0 +1,27 @@
+contract test {
+    /// @dev example of dev
+    uint private state;
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "state":
+//         {
+//             "details": "example of dev"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/public_state_variable.sol b/compiler/test/libsolidity/natspecJSON/public_state_variable.sol
new file mode 100644
index 00000000..5fda30ce
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/public_state_variable.sol
@@ -0,0 +1,40 @@
+contract test {
+    /// @notice example of notice
+    /// @dev example of dev
+    /// @return returns state
+    uint public state;
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "state":
+//         {
+//             "details": "example of dev",
+//             "return": "returns state",
+//             "returns":
+//             {
+//                 "_0": "returns state"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "state()":
+//         {
+//             "notice": "example of notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/public_state_variable_struct.sol b/compiler/test/libsolidity/natspecJSON/public_state_variable_struct.sol
new file mode 100644
index 00000000..43824724
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/public_state_variable_struct.sol
@@ -0,0 +1,44 @@
+contract Bank {
+    struct Coin {
+        string observeGraphicURL;
+        string reverseGraphicURL;
+    }
+
+    /// @notice Get the n-th coin I own
+    /// @return observeGraphicURL Front pic
+    /// @return reverseGraphicURL Back pic
+    Coin[] public coinStack;
+}
+
+// ----
+// ----
+// :Bank devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "coinStack":
+//         {
+//             "returns":
+//             {
+//                 "observeGraphicURL": "Front pic",
+//                 "reverseGraphicURL": "Back pic"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Bank userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "coinStack(uint256)":
+//         {
+//             "notice": "Get the n-th coin I own"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/public_state_variable_struct_repeated.sol b/compiler/test/libsolidity/natspecJSON/public_state_variable_struct_repeated.sol
new file mode 100644
index 00000000..78a6f9ee
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/public_state_variable_struct_repeated.sol
@@ -0,0 +1,14 @@
+contract Bank {
+    struct Coin {
+        string obverseGraphicURL;
+        string reverseGraphicURL;
+    }
+
+    /// @notice Get the n-th coin I own
+    /// @return obverseGraphicURL Front pic
+    /// @return obverseGraphicURL Front pic
+    Coin[] public coinStack;
+}
+
+// ----
+// DocstringParsingError 5856: (113-236): Documentation tag "@return obverseGraphicURL Front pic" does not contain the name of its return parameter.
diff --git a/compiler/test/libsolidity/natspecJSON/return_param_amount_differs.sol b/compiler/test/libsolidity/natspecJSON/return_param_amount_differs.sol
new file mode 100644
index 00000000..2d18ce8a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/return_param_amount_differs.sol
@@ -0,0 +1,64 @@
+interface IThing {
+    /// @return x a number
+    /// @return y another number
+    function value() external view returns (uint128 x, uint128 y);
+}
+
+contract Thing is IThing {
+    struct Value {
+        uint128 x;
+        uint128 y;
+    }
+
+    Value public override value;
+}
+// ----
+// ----
+// :IThing devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "value()":
+//         {
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :IThing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Thing devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "value":
+//         {
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Thing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/return_param_amount_differs2.sol b/compiler/test/libsolidity/natspecJSON/return_param_amount_differs2.sol
new file mode 100644
index 00000000..e10802c1
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/return_param_amount_differs2.sol
@@ -0,0 +1,73 @@
+interface IThing {
+    /// @param v value to search for
+    /// @return x a number
+    /// @return y another number
+    function value(uint256 v) external view returns (uint128 x, uint128 y);
+}
+
+contract Thing is IThing {
+    struct Value {
+        uint128 x;
+        uint128 y;
+    }
+
+    mapping(uint256=>Value) public override value;
+}
+// ----
+// ----
+// :IThing devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "value(uint256)":
+//         {
+//             "params":
+//             {
+//                 "v": "value to search for"
+//             },
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :IThing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Thing devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "value":
+//         {
+//             "params":
+//             {
+//                 "v": "value to search for"
+//             },
+//             "returns":
+//             {
+//                 "x": "a number",
+//                 "y": "another number"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Thing userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/slash3_slash3.sol b/compiler/test/libsolidity/natspecJSON/slash3_slash3.sol
new file mode 100644
index 00000000..fc8e47f9
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/slash3_slash3.sol
@@ -0,0 +1,27 @@
+contract test {
+    /// @notice lorem
+    /// ipsum
+    function f() public { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "f()":
+//         {
+//             "notice": "lorem ipsum"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/slash3_slash4.sol b/compiler/test/libsolidity/natspecJSON/slash3_slash4.sol
new file mode 100644
index 00000000..c428f5e1
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/slash3_slash4.sol
@@ -0,0 +1,27 @@
+contract test {
+    /// @notice lorem
+    //// ipsum
+    function f() public { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "f()":
+//         {
+//             "notice": "lorem"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/slash4.sol b/compiler/test/libsolidity/natspecJSON/slash4.sol
new file mode 100644
index 00000000..74997524
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/slash4.sol
@@ -0,0 +1,20 @@
+contract test {
+    //// @notice lorem ipsum
+    function f() public { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/star3.sol b/compiler/test/libsolidity/natspecJSON/star3.sol
new file mode 100644
index 00000000..24e742f8
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/star3.sol
@@ -0,0 +1,22 @@
+contract test {
+    /***
+     * @notice lorem ipsum
+     */
+    function f() public { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/struct_no_docs.sol b/compiler/test/libsolidity/natspecJSON/struct_no_docs.sol
new file mode 100644
index 00000000..e29a4b8e
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/struct_no_docs.sol
@@ -0,0 +1,27 @@
+contract C {
+    /// @title example of title
+    /// @author example of author
+    /// @notice example of notice
+    /// @dev example of dev
+    struct Example {
+        string text;
+        bool valid;
+        uint256 value;
+    }
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/unused_file_level_event.sol b/compiler/test/libsolidity/natspecJSON/unused_file_level_event.sol
new file mode 100644
index 00000000..4a621f38
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/unused_file_level_event.sol
@@ -0,0 +1,21 @@
+/// @notice Userdoc for file-level event E.
+/// @dev Devdoc for file-level E.
+event E();
+
+contract C {}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_basic_test.sol b/compiler/test/libsolidity/natspecJSON/user_basic_test.sol
new file mode 100644
index 00000000..0ec21750
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_basic_test.sol
@@ -0,0 +1,26 @@
+contract test {
+    /// @notice Multiplies `a` by 7
+    function mul(uint a) public returns(uint d) { return a * 7; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "mul(uint256)":
+//         {
+//             "notice": "Multiplies `a` by 7"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_constructor.sol b/compiler/test/libsolidity/natspecJSON/user_constructor.sol
new file mode 100644
index 00000000..0dedd30a
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_constructor.sol
@@ -0,0 +1,26 @@
+contract test {
+    /// @notice this is a really nice constructor
+    constructor(uint a, uint second) { }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "constructor":
+//         {
+//             "notice": "this is a really nice constructor"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_constructor_and_function.sol b/compiler/test/libsolidity/natspecJSON/user_constructor_and_function.sol
new file mode 100644
index 00000000..5e8cfd04
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_constructor_and_function.sol
@@ -0,0 +1,32 @@
+contract test {
+    /// @notice this is a really nice constructor
+    constructor(uint a, uint second) { }
+    /// another multiplier
+    function mul(uint a, uint second) public returns(uint d) { return a * 7 + second; }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "constructor":
+//         {
+//             "notice": "this is a really nice constructor"
+//         },
+//         "mul(uint256,uint256)":
+//         {
+//             "notice": "another multiplier"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_default_inherit.sol b/compiler/test/libsolidity/natspecJSON/user_default_inherit.sol
new file mode 100644
index 00000000..b4f97cfa
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_default_inherit.sol
@@ -0,0 +1,117 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// Second line.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract Middle is ERC20 {
+    function transfer(address to, uint amount) virtual override external returns (bool)
+    {
+        return false;
+    }
+}
+
+contract Token is Middle {
+    function transfer(address to, uint amount) override external returns (bool)
+    {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``. Second line."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_default_inherit_variable.sol b/compiler/test/libsolidity/natspecJSON/user_default_inherit_variable.sol
new file mode 100644
index 00000000..89d57d01
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_default_inherit_variable.sol
@@ -0,0 +1,66 @@
+contract C {
+    /// @notice Hello world
+    /// @dev test
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract D is C {
+    uint public override x;
+}
+
+// ----
+// ----
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "x":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_empty_contract.sol b/compiler/test/libsolidity/natspecJSON/user_empty_contract.sol
new file mode 100644
index 00000000..09f17860
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_empty_contract.sol
@@ -0,0 +1,17 @@
+contract test { }
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_empty_natspec_test.sol b/compiler/test/libsolidity/natspecJSON/user_empty_natspec_test.sol
new file mode 100644
index 00000000..aa19fac3
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_empty_natspec_test.sol
@@ -0,0 +1,22 @@
+contract test {
+    ///
+    ///
+    function f() public {
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_explicit_inherit.sol b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit.sol
new file mode 100644
index 00000000..a8ddb313
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit.sol
@@ -0,0 +1,98 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 {
+    function transfer(address to, uint amount) virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21, ERC20 {
+    /// @inheritdoc ERC20
+    function transfer(address to, uint amount) override(ERC21, ERC20) external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_explicit_inherit2.sol b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit2.sol
new file mode 100644
index 00000000..4c726f55
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit2.sol
@@ -0,0 +1,115 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 is ERC20 {
+    function transfer(address to, uint amount) virtual override external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC20 {
+    /// @inheritdoc ERC20
+    function transfer(address to, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial.sol b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial.sol
new file mode 100644
index 00000000..c69bd412
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial.sol
@@ -0,0 +1,100 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 {
+    function transfer(address to, uint amount) virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21, ERC20 {
+    /// @inheritdoc ERC20
+    /// @dev override dev comment
+    /// @notice override notice
+    function transfer(address to, uint amount) override(ERC21, ERC20) external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial2.sol b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial2.sol
new file mode 100644
index 00000000..6bb49e88
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_partial2.sol
@@ -0,0 +1,117 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract ERC21 is ERC20 {
+    /// @inheritdoc ERC20
+    /// @dev override dev comment
+    /// @notice override notice
+    function transfer(address to, uint amount) virtual override external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is ERC21 {
+    function transfer(address to, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC21 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "override dev comment",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "override notice"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_variable.sol b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_variable.sol
new file mode 100644
index 00000000..b35a9287
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_explicit_inherit_variable.sol
@@ -0,0 +1,87 @@
+contract B {
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract C {
+    /// @notice Hello world
+    /// @dev test
+    function x() virtual external returns (uint) {
+        return 1;
+    }
+}
+
+contract D is C, B {
+    /// @inheritdoc C
+    uint public override(C, B) x;
+}
+
+// ----
+// ----
+// :B devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :B userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :C devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :C userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "stateVariables":
+//     {
+//         "x":
+//         {
+//             "details": "test"
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :D userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "x()":
+//         {
+//             "notice": "Hello world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_inherit_parameter_mismatch.sol b/compiler/test/libsolidity/natspecJSON/user_inherit_parameter_mismatch.sol
new file mode 100644
index 00000000..a8ab60bd
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_inherit_parameter_mismatch.sol
@@ -0,0 +1,97 @@
+interface ERC20 {
+    /// Transfer ``amount`` from ``msg.sender`` to ``to``.
+    /// @dev test
+    /// @param to address to transfer to
+    /// @param amount amount to transfer
+    function transfer(address to, uint amount) external returns (bool);
+}
+
+contract Middle is ERC20 {
+    function transfer(address to, uint amount) override virtual external returns (bool) {
+        return false;
+    }
+}
+
+contract Token is Middle {
+    function transfer(address too, uint amount) override external returns (bool) {
+        return false;
+    }
+}
+
+// ----
+// ----
+// :ERC20 devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :ERC20 userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle devdoc
+// {
+//     "kind": "dev",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "details": "test",
+//             "params":
+//             {
+//                 "amount": "amount to transfer",
+//                 "to": "address to transfer to"
+//             }
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Middle userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "transfer(address,uint256)":
+//         {
+//             "notice": "Transfer ``amount`` from ``msg.sender`` to ``to``."
+//         }
+//     },
+//     "version": 1
+// }
+//
+// :Token devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :Token userdoc
+// {
+//     "kind": "user",
+//     "methods": {},
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_multiline_comment.sol b/compiler/test/libsolidity/natspecJSON/user_multiline_comment.sol
new file mode 100644
index 00000000..5407c7fe
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_multiline_comment.sol
@@ -0,0 +1,29 @@
+contract test {
+    /// @notice Multiplies `a` by 7
+    /// and then adds `b`
+    function mul_and_add(uint a, uint256 b) public returns (uint256 d) {
+        return (a * 7) + b;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "mul_and_add(uint256,uint256)":
+//         {
+//             "notice": "Multiplies `a` by 7 and then adds `b`"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_multiline_empty_lines.sol b/compiler/test/libsolidity/natspecJSON/user_multiline_empty_lines.sol
new file mode 100644
index 00000000..12bc050e
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_multiline_empty_lines.sol
@@ -0,0 +1,31 @@
+contract test {
+    /**
+     *
+     *
+     * @notice hello world
+     */
+    function f() public {
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "f()":
+//         {
+//             "notice": "hello world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_multiple_functions.sol b/compiler/test/libsolidity/natspecJSON/user_multiple_functions.sol
new file mode 100644
index 00000000..3c6759bd
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_multiple_functions.sol
@@ -0,0 +1,46 @@
+contract test {
+    /// @notice Multiplies `a` by 7 and then adds `b`
+    function mul_and_add(uint a, uint256 b) public returns (uint256 d) {
+        return (a * 7) + b;
+    }
+
+    /// @notice Divides `input` by `div`
+    function divide(uint input, uint div) public returns (uint d) {
+        return input / div;
+    }
+
+    /// @notice Subtracts 3 from `input`
+    function sub(int input) public returns (int d) {
+        return input - 3;
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "divide(uint256,uint256)":
+//         {
+//             "notice": "Divides `input` by `div`"
+//         },
+//         "mul_and_add(uint256,uint256)":
+//         {
+//             "notice": "Multiplies `a` by 7 and then adds `b`"
+//         },
+//         "sub(int256)":
+//         {
+//             "notice": "Subtracts 3 from `input`"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/natspecJSON/user_newline_break.sol b/compiler/test/libsolidity/natspecJSON/user_newline_break.sol
new file mode 100644
index 00000000..7284c880
--- /dev/null
+++ b/compiler/test/libsolidity/natspecJSON/user_newline_break.sol
@@ -0,0 +1,30 @@
+contract test {
+    ///
+    /// @notice hello
+
+    /// @notice world
+    function f() public {
+    }
+}
+
+// ----
+// ----
+// :test devdoc
+// {
+//     "kind": "dev",
+//     "methods": {},
+//     "version": 1
+// }
+//
+// :test userdoc
+// {
+//     "kind": "user",
+//     "methods":
+//     {
+//         "f()":
+//         {
+//             "notice": "world"
+//         }
+//     },
+//     "version": 1
+// }
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_dynamic_array.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_dynamic_array.sol
new file mode 100644
index 00000000..4d6b9207
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_dynamic_array.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(bytes calldata data) external pure returns (uint256[] memory) {
+        return abi.decode(data, (uint256[]));
+    }
+}
+// ----
+// f(bytes): 0x20, 0xc0, 0x20, 0x4, 0x3, 0x4, 0x5, 0x6 -> 0x20, 0x4, 0x3, 0x4, 0x5, 0x6
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array.sol
new file mode 100644
index 00000000..fd0a59ab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(bytes calldata data)
+        external
+        pure
+        returns (uint256[2][3] memory)
+    {
+        return abi.decode(data, (uint256[2][3]));
+    }
+}
+// ----
+// f(bytes): 0x20, 0xc0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 -> 1, 2, 3, 4, 5, 6
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol
new file mode 100644
index 00000000..e228099c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_static_array_v2.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(bytes calldata data)
+        external
+        pure
+        returns (uint256[2][3] memory)
+    {
+        return abi.decode(data, (uint256[2][3]));
+    }
+}
+// ----
+// f(bytes): 0x20, 0xc0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 -> 1, 2, 3, 4, 5, 6
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_trivial.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_trivial.sol
new file mode 100644
index 00000000..c1b91815
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_trivial.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(bytes memory data) public pure returns (uint256) {
+        return abi.decode(data, (uint256));
+    }
+}
+// ----
+// f(bytes): 0x20, 0x20, 0x21 -> 33
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol
new file mode 100644
index 00000000..782971c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2.sol
@@ -0,0 +1,21 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256[] b;
+    }
+
+    function f() public pure returns (S memory) {
+        S memory s;
+        s.a = 8;
+        s.b = new uint256[](3);
+        s.b[0] = 9;
+        s.b[1] = 10;
+        s.b[2] = 11;
+        return abi.decode(abi.encode(s), (S));
+    }
+}
+// ----
+// f() -> 0x20, 0x8, 0x40, 0x3, 0x9, 0xa, 0xb
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol
new file mode 100644
index 00000000..8bbb77b9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_calldata.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256[] b;
+    }
+
+    function f(bytes calldata data) external pure returns (S memory) {
+        return abi.decode(data, (S));
+    }
+}
+// ----
+// f(bytes): 0x20, 0xe0, 0x20, 0x21, 0x40, 0x3, 0xa, 0xb, 0xc -> 0x20, 0x21, 0x40, 0x3, 0xa, 0xb, 0xc
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol
new file mode 100644
index 00000000..b4ef43c4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_decode_v2_storage.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+
+contract C {
+    bytes data;
+    struct S {
+        uint256 a;
+        uint256[] b;
+    }
+
+    function f() public returns (S memory) {
+        S memory s;
+        s.a = 8;
+        s.b = new uint256[](3);
+        s.b[0] = 9;
+        s.b[1] = 10;
+        s.b[2] = 11;
+        data = abi.encode(s);
+        return abi.decode(data, (S));
+    }
+}
+// ----
+// f() -> 0x20, 0x8, 0x40, 0x3, 0x9, 0xa, 0xb
+// gas irOptimized: 203149
+// gas legacy: 206263
+// gas legacyOptimized: 203156
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode.sol
new file mode 100644
index 00000000..1e654d28
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode.sol
@@ -0,0 +1,35 @@
+contract C {
+    function f0() public returns (bytes memory) {
+        return abi.encode();
+    }
+
+    function f1() public returns (bytes memory) {
+        return abi.encode(1, 2);
+    }
+
+    function f2() public returns (bytes memory) {
+        string memory x = "abc";
+        return abi.encode(1, x, 2);
+    }
+
+    function f3() public returns (bytes memory r) {
+        // test that memory is properly allocated
+        string memory x = "abc";
+        r = abi.encode(1, x, 2);
+        bytes memory y = "def";
+        require(y[0] == "d");
+        y[0] = "e";
+        require(y[0] == "e");
+    }
+
+    function f4() public returns (bytes memory) {
+        bytes4 x = "abcd";
+        return abi.encode(bytes2(x));
+    }
+}
+// ----
+// f0() -> 0x20, 0x0
+// f1() -> 0x20, 0x40, 0x1, 0x2
+// f2() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc"
+// f3() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc"
+// f4() -> 0x20, 0x20, "ab"
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_call.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_call.sol
new file mode 100644
index 00000000..e34d46b7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_call.sol
@@ -0,0 +1,25 @@
+contract C {
+    bool x;
+
+    function c(uint256 a, uint256[] memory b) public {
+        require(a == 5);
+        require(b.length == 2);
+        require(b[0] == 6);
+        require(b[1] == 7);
+        x = true;
+    }
+
+    function f() public returns (bool) {
+        uint256 a = 5;
+        uint256[] memory b = new uint256[](2);
+        b[0] = 6;
+        b[1] = 7;
+        (bool success, ) = address(this).call(
+            abi.encodeWithSignature("c(uint256,uint256[])", a, b)
+        );
+        require(success);
+        return x;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_calldata_slice.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_calldata_slice.sol
new file mode 100644
index 00000000..f548c50b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_calldata_slice.sol
@@ -0,0 +1,68 @@
+contract C {
+	function enc_packed_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(data[start:end]);
+	}
+	function enc_packed_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(bytes(data[start:end]));
+	}
+
+	function enc_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(data[start:end]);
+	}
+	function enc_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(bytes(data[start:end]));
+	}
+
+	function enc_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(x[start:end]);
+	}
+	function enc_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(x[start:end]);
+	}
+
+	function enc_packed_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(x[start:end]);
+	}
+	function enc_packed_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(x[start:end]);
+	}
+
+	function compare(bytes memory x, bytes memory y) internal {
+		assert(x.length == y.length);
+		for (uint i = 0; i < x.length; ++i)
+			assert(x[i] == y[i]);
+	}
+
+	function test_bytes() public {
+		bytes memory test = new bytes(3);
+		test[0] = 0x41; test[1] = 0x42; test[2] = 0x42;
+		for (uint i = 0; i < test.length; i++)
+			for (uint j = i; j <= test.length; j++)
+			{
+				compare(this.enc_packed_bytes(test, i, j), this.enc_packed_bytes_reference(test, i, j));
+				compare(this.enc_bytes(test, i, j), this.enc_bytes_reference(test, i, j));
+			}
+	}
+
+	function test_uint256() public {
+		uint256[] memory test = new uint256[](3);
+		test[0] = 0x41; test[1] = 0x42; test[2] = 0x42;
+		for (uint i = 0; i < test.length; i++)
+			for (uint j = i; j <= test.length; j++)
+			{
+				compare(this.enc_packed_uint256(test, i, j), this.enc_packed_uint256_reference(test, i, j));
+				compare(this.enc_uint256(test, i, j), this.enc_uint256_reference(test, i, j));
+			}
+	}
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// test_bytes() ->
+// gas irOptimized: 321332
+// gas legacy: 319111
+// gas legacyOptimized: 269317
+// test_uint256() ->
+// gas irOptimized: 447646
+// gas legacy: 433627
+// gas legacyOptimized: 365410
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_decode_simple.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_decode_simple.sol
new file mode 100644
index 00000000..627f0b0c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_decode_simple.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (uint256, bytes memory) {
+        bytes memory arg = "abcdefg";
+        return abi.decode(abi.encode(uint256(33), arg), (uint256, bytes));
+    }
+}
+// ----
+// f() -> 0x21, 0x40, 0x7, "abcdefg"
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_empty_string.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_empty_string.sol
new file mode 100644
index 00000000..601fb3cb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_empty_string.sol
@@ -0,0 +1,34 @@
+pragma abicoder v1;
+contract C {
+    function f1() public returns (bytes memory) {
+        return abi.encode("");
+    }
+    function f2(string calldata msg) public returns (bytes memory) {
+        return abi.encode(msg);
+    }
+    function g1() public returns (bytes memory) {
+        return abi.encodePacked("");
+    }
+    function g2(string calldata msg) public returns (bytes memory) {
+        return abi.encodePacked(msg);
+    }
+    function h1() public returns (bytes memory) {
+        return abi.encodeWithSelector(0x00000001, "");
+    }
+    function h2(string calldata msg) public returns (bytes memory) {
+        return abi.encodeWithSelector(0x00000001, msg);
+    }
+}
+// ====
+// ABIEncoderV1Only: true
+// compileViaYul: false
+// ----
+// f1() -> 0x20, 0x40, 0x20, 0
+// f2(string): 0x20, 0 -> 0x20, 0x40, 0x20, 0
+// f2(string): 0x20, 0, 0 -> 0x20, 0x40, 0x20, 0
+// g1() -> 32, 0
+// g2(string): 0x20, 0 -> 0x20, 0
+// g2(string): 0x20, 0, 0 -> 0x20, 0
+// h1() -> 0x20, 0x44, 26959946667150639794667015087019630673637144422540572481103610249216, 862718293348820473429344482784628181556388621521298319395315527974912, 0
+// h2(string): 0x20, 0 -> 0x20, 0x44, 26959946667150639794667015087019630673637144422540572481103610249216, 862718293348820473429344482784628181556388621521298319395315527974912, 0
+// h2(string): 0x20, 0, 0 -> 0x20, 0x44, 26959946667150639794667015087019630673637144422540572481103610249216, 862718293348820473429344482784628181556388621521298319395315527974912, 0
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_rational.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_rational.sol
new file mode 100644
index 00000000..44cf1ab5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/abi_encode_rational.sol
@@ -0,0 +1,8 @@
+// Tests that rational numbers (even negative ones) are encoded properly.
+contract C {
+    function f() public pure returns (bytes memory) {
+        return abi.encode(1, -2);
+    }
+}
+// ----
+// f() -> 0x20, 0x40, 0x1, -2
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/calldata_arrays_too_large.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/calldata_arrays_too_large.sol
new file mode 100644
index 00000000..49bee94e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/calldata_arrays_too_large.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(uint a, uint[] calldata b, uint c) external pure returns (uint) {
+        return 7;
+    }
+}
+// ----
+// f(uint256,uint256[],uint256): 6, 0x60, 9, 0x8000000000000000000000000000000000000000000000000000000000000002, 1, 2 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/decode_slice.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/decode_slice.sol
new file mode 100644
index 00000000..35cb1507
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/decode_slice.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f(uint256 a, uint256 b) external returns (uint256 c, uint256 d, uint256 e, uint256 f) {
+        (c, d) = abi.decode(msg.data[4:], (uint256, uint256));
+        e = abi.decode(msg.data[4 : 4 + 32], (uint256));
+        f = abi.decode(msg.data[4 + 32 : 4 + 32 + 32], (uint256));
+    }
+}
+// ----
+// f(uint256,uint256): 42, 23 -> 42, 23, 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/dynamic_memory_copy.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/dynamic_memory_copy.sol
new file mode 100644
index 00000000..ef2b07cb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/dynamic_memory_copy.sol
@@ -0,0 +1,26 @@
+contract C {
+    function test(bytes memory buf) public view returns (bool same, bool inplaceDecoded) {
+        (uint256[] memory arr1, uint256[] memory arr2) = abi.decode(buf, (uint256[],uint256[]));
+        assembly {
+            // Check whether arr1 and arr2 end up at the same memory location.
+            // This used to be the case, if both tail pointers in buf pointed to the
+            // same memory region, i.e. this used to be false in the first two, but true
+            // in the last three calls below. The desired behaviour is to always get distinct
+            // memory regions, i.e. this should be false.
+            same := eq(arr1, arr2)
+            // Check whether (given the particular tail pointer of 0x40 for arr1 in the calls below)
+            // arr1 points to the part of buf containing the encoding of arr1.
+            // The position of the encoding of arr1 in buf is at offset 0x20 (length) + 0x40 (tail pointer)
+            // of buf.
+            // This used to be the case for all the test calls below, whereas now arr1 is always copied
+            // from buf to a new memory area. Should always be false.
+            inplaceDecoded := eq(arr1, add(buf, 0x60))
+        }
+    }
+}
+// ----
+// test(bytes): 0x20, 0x80, 0x40, 0x60, 0, 0 -> false, false
+// test(bytes): 0x20, 0xC0, 0x40, 0x80, 1, 0x42, 1, 0x42 -> false, false
+// test(bytes): 0x20, 0x80, 0x40, 0x40, 1, 0x42 -> false, false
+// test(bytes): 0x20, 0x60, 0x40, 0x40, 0 -> false, false
+// test(bytes): 0x20, 0x80, 0x40, 0x40, 1, 0x42 -> false, false
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/memory_dynamic_array_and_calldata_bytes.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/memory_dynamic_array_and_calldata_bytes.sol
new file mode 100644
index 00000000..f828ab41
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/memory_dynamic_array_and_calldata_bytes.sol
@@ -0,0 +1,16 @@
+pragma abicoder v1;
+
+contract C {
+    function f(uint256[] memory a, bytes calldata b) public returns (bytes memory) {
+        return abi.encode(a, b);
+    }
+
+    function g(uint256[] memory a, bytes calldata b) external returns (bytes memory) {
+        return f(a, b);
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// f(uint256[],bytes): 0x40, 0x80, 1, 0xFF, 6, "123456" -> 0x20, 0xc0, 0x40, 0x80, 1, 0xff, 6, "123456"
+// g(uint256[],bytes): 0x40, 0x80, 1, 0xffff, 8, "12345678" -> 0x20, 0xc0, 0x40, 0x80, 1, 0xffff, 8, "12345678"
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV1/struct/struct_storage_ptr.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV1/struct/struct_storage_ptr.sol
new file mode 100644
index 00000000..efffab86
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV1/struct/struct_storage_ptr.sol
@@ -0,0 +1,29 @@
+library L {
+	struct S { uint x; uint y; }
+	function f(uint[] storage r, S storage s) public returns (uint, uint, uint, uint) {
+		r[2] = 8;
+		s.x = 7;
+		return (r[0], r[1], s.x, s.y);
+	}
+}
+contract C {
+	uint8 x = 3;
+	L.S s;
+	uint[] r;
+	function f() public returns (uint, uint, uint, uint, uint, uint) {
+		r = new uint[](6);
+		r[0] = 1;
+		r[1] = 2;
+		r[2] = 3;
+		s.x = 11;
+		s.y = 12;
+		(uint a, uint b, uint c, uint d) = L.f(r, s);
+		return (r[2], s.x, a, b, c, d);
+	}
+}
+// ----
+// library: L
+// f() -> 8, 7, 1, 2, 7, 12
+// gas irOptimized: 166475
+// gas legacy: 169283
+// gas legacyOptimized: 167248
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol
new file mode 100644
index 00000000..686164de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_calldata_slice.sol
@@ -0,0 +1,69 @@
+pragma abicoder               v2;
+contract C {
+	function enc_packed_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(data[start:end]);
+	}
+	function enc_packed_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(bytes(data[start:end]));
+	}
+
+	function enc_bytes(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(data[start:end]);
+	}
+	function enc_bytes_reference(bytes calldata data, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(bytes(data[start:end]));
+	}
+
+	function enc_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(x[start:end]);
+	}
+	function enc_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encode(x[start:end]);
+	}
+
+	function enc_packed_uint256(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(x[start:end]);
+	}
+	function enc_packed_uint256_reference(uint256[] calldata x, uint256 start, uint256 end) external returns (bytes memory) {
+		return abi.encodePacked(x[start:end]);
+	}
+
+	function compare(bytes memory x, bytes memory y) internal {
+		assert(x.length == y.length);
+		for (uint i = 0; i < x.length; ++i)
+			assert(x[i] == y[i]);
+	}
+
+	function test_bytes() public {
+		bytes memory test = new bytes(3);
+		test[0] = 0x41; test[1] = 0x42; test[2] = 0x42;
+		for (uint i = 0; i < test.length; i++)
+			for (uint j = i; j <= test.length; j++)
+			{
+				compare(this.enc_packed_bytes(test, i, j), this.enc_packed_bytes_reference(test, i, j));
+				compare(this.enc_bytes(test, i, j), this.enc_bytes_reference(test, i, j));
+			}
+	}
+
+	function test_uint256() public {
+		uint256[] memory test = new uint256[](3);
+		test[0] = 0x41; test[1] = 0x42; test[2] = 0x42;
+		for (uint i = 0; i < test.length; i++)
+			for (uint j = i; j <= test.length; j++)
+			{
+				compare(this.enc_packed_uint256(test, i, j), this.enc_packed_uint256_reference(test, i, j));
+				compare(this.enc_uint256(test, i, j), this.enc_uint256_reference(test, i, j));
+			}
+	}
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// test_bytes() ->
+// gas irOptimized: 321332
+// gas legacy: 319111
+// gas legacyOptimized: 269317
+// test_uint256() ->
+// gas irOptimized: 447646
+// gas legacy: 433627
+// gas legacyOptimized: 365410
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol
new file mode 100644
index 00000000..849c24a9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_empty_string_v2.sol
@@ -0,0 +1,12 @@
+// Tests that this will not end up using a "bytes0" type
+// (which would assert)
+pragma abicoder               v2;
+
+
+contract C {
+    function f() public pure returns (bytes memory, bytes memory) {
+        return (abi.encode(""), abi.encodePacked(""));
+    }
+}
+// ----
+// f() -> 0x40, 0xa0, 0x40, 0x20, 0x0, 0x0
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol
new file mode 100644
index 00000000..edd319d4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_rational_v2.sol
@@ -0,0 +1,11 @@
+// Tests that rational numbers (even negative ones) are encoded properly.
+pragma abicoder               v2;
+
+
+contract C {
+    function f() public pure returns (bytes memory) {
+        return abi.encode(1, -2);
+    }
+}
+// ----
+// f() -> 0x20, 0x40, 0x1, -2
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol
new file mode 100644
index 00000000..5e50d5e9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2.sol
@@ -0,0 +1,55 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256[] b;
+    }
+
+    function f0() public pure returns (bytes memory) {
+        return abi.encode();
+    }
+
+    function f1() public pure returns (bytes memory) {
+        return abi.encode(1, 2);
+    }
+
+    function f2() public pure returns (bytes memory) {
+        string memory x = "abc";
+        return abi.encode(1, x, 2);
+    }
+
+    function f3() public pure returns (bytes memory r) {
+        // test that memory is properly allocated
+        string memory x = "abc";
+        r = abi.encode(1, x, 2);
+        bytes memory y = "def";
+        require(y[0] == "d");
+        y[0] = "e";
+        require(y[0] == "e");
+    }
+
+    S s;
+
+    function f4() public returns (bytes memory r) {
+        string memory x = "abc";
+        s.a = 7;
+        s.b.push(2);
+        s.b.push(3);
+        r = abi.encode(1, x, s, 2);
+        bytes memory y = "def";
+        require(y[0] == "d");
+        y[0] = "e";
+        require(y[0] == "e");
+    }
+}
+// ----
+// f0() -> 0x20, 0x0
+// f1() -> 0x20, 0x40, 0x1, 0x2
+// f2() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc"
+// f3() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc"
+// f4() -> 0x20, 0x160, 0x1, 0x80, 0xc0, 0x2, 0x3, "abc", 0x7, 0x40, 0x2, 0x2, 0x3
+// gas irOptimized: 112630
+// gas legacy: 114794
+// gas legacyOptimized: 112572
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol
new file mode 100644
index 00000000..55f7991d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_function_inherited_in_v1_contract.sol
@@ -0,0 +1,35 @@
+==== Source: A ====
+pragma abicoder v2;
+
+struct Data {
+    uint a;
+    uint[2] b;
+    uint c;
+}
+
+contract A {
+    function get() public view returns (Data memory) {
+        return Data(5, [uint(66), 77], 8);
+    }
+}
+
+contract B {
+    function foo(A _a) public returns (uint) {
+        return _a.get().b[1];
+    }
+}
+==== Source: B ====
+pragma abicoder v1;
+
+import "A";
+
+contract C is B {
+    function test() public returns (uint) {
+        return foo(new A());
+    }
+}
+// ----
+// test() -> 77
+// gas irOptimized: 110348
+// gas legacy: 151866
+// gas legacyOptimized: 110373
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol
new file mode 100644
index 00000000..7de26301
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/abi_encode_v2_in_modifier_used_in_v1_contract.sol
@@ -0,0 +1,42 @@
+==== Source: A ====
+pragma abicoder v2;
+
+struct Data {
+    uint value;
+}
+
+contract A {
+    function get() public view returns (Data memory) {
+        return Data(5);
+    }
+}
+
+contract B {
+    uint x = 10;
+    uint y = 10;
+
+    modifier updateStorage() {
+        A a = new A();
+        x = a.get().value;
+        _;
+        y = a.get().value;
+    }
+}
+==== Source: B ====
+pragma abicoder v1;
+
+import "A";
+
+contract C is B {
+    function test()
+        public
+        updateStorage
+        returns (uint, uint)
+    {
+        return (x, y);
+    }
+}
+// ----
+// test() -> 5, 10
+// gas irOptimized: 87337
+// gas legacy: 102651
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol
new file mode 100644
index 00000000..e4712570
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/bool_out_of_bounds.sol
@@ -0,0 +1,10 @@
+pragma abicoder               v2;
+
+contract C {
+	function f(bool b) public pure returns (bool) { return b; }
+}
+// ----
+// f(bool): true -> true
+// f(bool): false -> false
+// f(bool): 0x000000 -> false
+// f(bool): 0xffffff -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol
new file mode 100644
index 00000000..22aad674
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array.sol
@@ -0,0 +1,25 @@
+pragma abicoder               v2;
+
+contract C {
+    function g(uint256[] calldata) external pure returns (bytes memory) {
+        return msg.data;
+    }
+    function f(uint256[][1] calldata s) external view returns (bool) {
+        bytes memory a = this.g(s[0]);
+        uint256[] memory m = s[0];
+        bytes memory b = this.g(m);
+        assert(a.length == b.length);
+        for (uint i = 0; i < a.length; i++)
+            assert(a[i] == b[i]);
+        return true;
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// f(uint256[][1]): 32, 32, 0 -> true
+// f(uint256[][1]): 32, 32, 1, 42 -> true
+// f(uint256[][1]): 32, 32, 8, 421, 422, 423, 424, 425, 426, 427, 428 -> true
+// gas irOptimized: 120043
+// gas legacy: 101568
+// gas legacyOptimized: 119092
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol
new file mode 100644
index 00000000..2d809570
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_array_dynamic_static_short_decode.sol
@@ -0,0 +1,11 @@
+pragma abicoder               v2;
+contract C {
+    function f(uint256[][2][] calldata x) external returns (uint256) {
+        x[0]; // trigger bounds checks
+        return 23;
+    }
+}
+// ----
+// f(uint256[][2][]): 0x20, 0x01, 0x20, 0x40, 0x60, 0x00, 0x00 -> 23 # this is the common encoding for x.length == 1 && x[0][0].length == 0 && x[0][1].length == 0 #
+// f(uint256[][2][]): 0x20, 0x01, 0x20, 0x00, 0x00 -> 23 # exotic, but still valid encoding #
+// f(uint256[][2][]): 0x20, 0x01, 0x20, 0x00 -> FAILURE # invalid (too short) encoding, but no failure due to this PR #
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_dynamic_array_to_memory.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_dynamic_array_to_memory.sol
new file mode 100644
index 00000000..1fca188a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_dynamic_array_to_memory.sol
@@ -0,0 +1,24 @@
+pragma abicoder v2;
+
+contract C {
+    function f(uint[][] calldata a) public returns (uint[][] memory) {
+        return a;
+    }
+
+    function g(uint[][][] calldata a) public returns (uint[][][] memory) {
+        return a;
+    }
+
+    function h(uint[2][][] calldata a) public returns (uint[2][][] memory) {
+        return a;
+    }
+}
+// ----
+// f(uint256[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8 -> 0x20, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8
+// f(uint256[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8, 9 -> 0x20, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8
+// f(uint256[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8 -> FAILURE
+// g(uint256[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8 -> 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0xa0, 2, 5, 6, 2, 7, 8
+// g(uint256[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0xa0, 2, 5, 6, 2, 7 -> FAILURE
+// h(uint256[2][][]): 0x20, 2, 0x40, 0x60, 0, 2, 5, 6, 7, 8 -> 0x20, 2, 0x40, 0x60, 0, 2, 5, 6, 7, 8
+// h(uint256[2][][]): 0x20, 2, 0x40, 0x60, 0, 2, 5, 6, 7, 8, 9 -> 0x20, 2, 0x40, 0x60, 0, 2, 5, 6, 7, 8
+// h(uint256[2][][]): 0x20, 2, 0x40, 0x60, 0, 2, 5, 6, 7 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_dynamic_arrays.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_dynamic_arrays.sol
new file mode 100644
index 00000000..a9233609
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_dynamic_arrays.sol
@@ -0,0 +1,40 @@
+pragma abicoder v2;
+
+contract C {
+    uint[] s;
+    uint[2] n;
+
+    function f_memory(uint[] calldata a, uint[2] calldata b) public returns (uint[] memory, uint[2] memory) {
+        return (a, b);
+    }
+
+    function f_encode(uint[] calldata a, uint[2] calldata b) public returns (bytes memory) {
+        return abi.encode(a, b);
+    }
+
+    function f_which(uint[] calldata a, uint[2] calldata b, uint which) public returns (bytes memory) {
+        return abi.encode(a[which], b[1]);
+    }
+
+    function f_storage(uint[] calldata a, uint[2] calldata b ) public returns (bytes memory) {
+        s = a;
+        n = b;
+        return abi.encode(s);
+    }
+}
+// ----
+// f_memory(uint256[],uint256[2]): 0x20, 1, 2 -> 0x60, 0x01, 0x02, 1, 2
+// f_memory(uint256[],uint256[2]): 0x40, 1, 2, 5, 6 -> 0x60, 1, 2, 2, 5, 6
+// f_memory(uint256[],uint256[2]): 0x40, 1, 2, 5 -> FAILURE
+// f_encode(uint256[],uint256[2]): 0x20, 1, 2 -> 0x20, 0xa0, 0x60, 1, 2, 1, 2
+// f_encode(uint256[],uint256[2]): 0x40, 1, 2, 5, 6 -> 0x20, 0xc0, 0x60, 1, 2, 2, 5, 6
+// f_encode(uint256[],uint256[2]): 0x40, 1, 2, 5 -> FAILURE
+// f_which(uint256[],uint256[2],uint256): 0x40, 1, 2, 1, 5 -> 0x20, 0x40, 5, 2
+// f_which(uint256[],uint256[2],uint256): 0x40, 1, 2, 1, 5, 6 -> 0x20, 0x40, 5, 2
+// f_which(uint256[],uint256[2],uint256): 0x40, 1, 2, 1 -> FAILURE
+// f_storage(uint256[],uint256[2]): 0x20, 1, 2 -> 0x20, 0x60, 0x20, 1, 2
+// gas irOptimized: 111642
+// gas legacy: 112944
+// gas legacyOptimized: 112092
+// f_storage(uint256[],uint256[2]): 0x40, 1, 2, 5, 6 -> 0x20, 0x80, 0x20, 2, 5, 6
+// f_storage(uint256[],uint256[2]): 0x40, 1, 2, 5 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_nested_dynamic_arrays.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_nested_dynamic_arrays.sol
new file mode 100644
index 00000000..d5a3266f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_overlapped_nested_dynamic_arrays.sol
@@ -0,0 +1,34 @@
+pragma abicoder v2;
+
+contract C {
+    uint[] s;
+    uint[2] n;
+
+    function f_memory(uint[][] calldata a) public returns (uint[][] memory) {
+        return a;
+    }
+
+    function f_encode(uint[][] calldata a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function f_which(uint[][] calldata a, uint which) public returns (uint[] memory) {
+        return a[which];
+    }
+}
+// ----
+// f_memory(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 1, 2 -> 0x20, 2, 0x40, 0xa0, 2, 1, 2, 2, 1, 2
+// f_memory(uint256[][]): 0x20, 2, 0x40, 0x60, 2, 1, 2 -> 0x20, 2, 0x40, 0xa0, 2, 1, 2, 1, 2
+// f_memory(uint256[][]): 0x20, 2, 0, 0x60, 2, 1, 2 -> 0x20, 2, 0x40, 0x60, 0, 1, 2
+// f_memory(uint256[][]): 0x20, 2, 0, 0x60, 2, 2, 2 -> FAILURE
+// f_encode(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 1, 2 -> 0x20, 0x0140, 0x20, 2, 0x40, 0xa0, 2, 1, 2, 2, 1, 2
+// f_encode(uint256[][]): 0x20, 2, 0x40, 0x60, 2, 1, 2 -> 0x20, 0x0120, 0x20, 2, 0x40, 0xa0, 2, 1, 2, 1, 2
+// f_encode(uint256[][]): 0x20, 2, 0, 0x60, 2, 1, 2 -> 0x20, 0xe0, 0x20, 2, 0x40, 0x60, 0, 1, 2
+// f_encode(uint256[][]): 0x20, 2, 0, 0x60, 2, 2, 2 -> FAILURE
+// f_which(uint256[][],uint256): 0x40, 0, 2, 0x40, 0x40, 2, 1, 2 -> 0x20, 2, 1, 2
+// f_which(uint256[][],uint256): 0x40, 1, 2, 0x40, 0x40, 2, 1, 2 -> 0x20, 2, 1, 2
+// f_which(uint256[][],uint256): 0x40, 0, 2, 0x40, 0x60, 2, 1, 2 -> 0x20, 2, 1, 2
+// f_which(uint256[][],uint256): 0x40, 1, 2, 0x40, 0x60, 2, 1, 2 -> 0x20, 1, 2
+// f_which(uint256[][],uint256): 0x40, 0, 2, 0, 0x60, 2, 1, 2 -> 0x20, 0
+// f_which(uint256[][],uint256): 0x40, 1, 2, 0, 0x60, 2, 1, 2 -> 0x20, 1, 2
+// f_which(uint256[][],uint256): 0x40, 1, 2, 0, 0x60, 2, 2, 2 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_array_reencode.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_array_reencode.sol
new file mode 100644
index 00000000..347710a3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_struct_array_reencode.sol
@@ -0,0 +1,53 @@
+pragma abicoder v2;
+
+contract C {
+    struct D { uint[] x; }
+    struct S { uint x; }
+
+    function f(D calldata a) public returns (bytes memory){
+        return abi.encode(a);
+    }
+
+    function g(D[2] calldata a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function h(D[][] calldata a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function i(D[2][] calldata a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function j(S[] memory a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function k(S[2] memory a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function l(S[][] memory a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+}
+// ----
+// f((uint256[])): 0x20, 0x20, 0 -> 0x20, 0x60, 0x20, 0x20, 0
+// f((uint256[])): 0x20, 0x20, 1 -> FAILURE
+// f((uint256[])): 0x20, 0x20, 2 -> FAILURE
+// f((uint256[])): 0x20, 0x20, 3 -> FAILURE
+// g((uint256[])[2]): 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3 -> 0x20, 0x0140, 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3
+// g((uint256[])[2]): 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1 -> FAILURE
+// h((uint256[])[][]): 0x20, 0x02, 0x40, 0x0180, 2, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3, 1, 0x20, 0x20, 1, 1 -> 0x20, 0x0260, 0x20, 2, 0x40, 0x0180, 2, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3, 1, 0x20, 0x20, 1, 1
+// h((uint256[])[][]): 0x20, 0x02, 0x40, 0x0180, 2, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3, 1, 0x20, 0x20, 1 -> FAILURE
+// i((uint256[])[2][]): 0x20, 1, 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3 -> 0x20, 0x0180, 0x20, 1, 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1, 3
+// i((uint256[])[2][]): 0x20, 1, 0x20, 0x40, 0xc0, 0x20, 2, 1, 2, 0x20, 1 -> FAILURE
+// j((uint256)[]): 0x20, 2, 1, 2 -> 0x20, 0x80, 0x20, 2, 1, 2
+// j((uint256)[]): 0x20, 2, 1 -> FAILURE
+// k((uint256)[2]): 1, 2 -> 0x20, 0x40, 1, 2
+// k((uint256)[2]): 1 -> FAILURE
+// l((uint256)[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8, 9 -> 0x20, 0x0160, 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8, 9
+// l((uint256)[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8, 9, 10 -> 0x20, 0x0160, 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8, 9
+// l((uint256)[][]): 0x20, 2, 0x40, 0xa0, 2, 5, 6, 3, 7, 8 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_three_dimensional_dynamic_array_index_access.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_three_dimensional_dynamic_array_index_access.sol
new file mode 100644
index 00000000..745bebe7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_three_dimensional_dynamic_array_index_access.sol
@@ -0,0 +1,40 @@
+pragma abicoder v2;
+
+contract C {
+    struct S { uint[] a; }
+
+    function f(uint[][] calldata s, uint i, uint j) public pure returns (bytes memory) {
+        return abi.encode(s[i][j]);
+    }
+
+    function g(uint[][][] calldata s, uint i, uint j, uint k) public pure returns (bytes memory) {
+        return abi.encode(s[i][j][k]);
+    }
+
+    function h(uint[][][1] calldata s, uint i) public pure returns (bytes memory) {
+        return abi.encode(s[0][i]);
+    }
+
+    function k(S[][] calldata s, uint i, uint j) public pure returns (bytes memory) {
+        return abi.encode(s[i][j].a);
+    }
+
+    function l(S[2][2] calldata s, uint i, uint j) public pure returns (bytes memory) {
+        return abi.encode(s[i][j].a);
+    }
+}
+// ====
+// revertStrings: debug
+// ----
+// f(uint256[][],uint256,uint256): 0x60, 0, 0, 2, 0x40, 0x80, 1, 7, 1, 8 -> 0x20, 0x20, 7
+// f(uint256[][],uint256,uint256): 0x60, 1, 0, 2, 0x40, 0x80, 1, 7, 1, 8 -> 0x20, 0x20, 8
+// g(uint256[][][],uint256,uint256,uint256): 0x80, 0, 0, 0, 2, 0x40, 0xc0, 1, 0x20, 1, 4, 2, 0x40, 0xa0, 2, 5, 6, 1, 7 -> 0x20, 0x20, 4
+// g(uint256[][][],uint256,uint256,uint256): 0x80, 1, 0, 1, 2, 0x40, 0xc0, 1, 0x20, 1, 4, 2, 0x40, 0xa0, 2, 5, 6, 1, 7 -> 0x20, 0x20, 6
+// g(uint256[][][],uint256,uint256,uint256): 0x80, 1, 0, 2, 2, 0x40, 0xc0, 1, 0x20, 1, 4, 2, 0x40, 0xa0, 2, 5, 6, 1, 7 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[][][],uint256,uint256,uint256): 0x80, 2, 0, 1, 2, 0x40, 0xc0, 1, 0x20, 1, 4, 2, 0x40, 0xa0, 2, 5, 6, 1, 7 -> FAILURE, hex"4e487b71", 0x32
+// h(uint256[][][1],uint256): 0x40, 1, 0x20, 2, 0x40, 0xA0, 2, 5, 6, 3, 7, 8, 9 -> 0x20, 0xa0, 0x20, 3, 7, 8, 9
+// h(uint256[][][1],uint256): 0x40, 2, 0x20, 2, 0x40, 0xA0, 2, 5, 6, 3, 7, 8, 9 -> FAILURE, hex"4e487b71", 0x32
+// k((uint256[])[][],uint256,uint256): 0x60, 0, 0, 2, 0x40, 0xe0, 1, 0x20, 0x20, 1, 6, 2, 0x40, 0xa0, 0x20, 1, 7, 0x20, 2, 8, 9 -> 0x20, 0x60, 0x20, 1, 6
+// k((uint256[])[][],uint256,uint256): 0x60, 0, 1, 2, 0x40, 0xe0, 1, 0x20, 0x20, 1, 6, 2, 0x40, 0xa0, 0x20, 1, 7, 0x20, 2, 8, 9 -> FAILURE, hex"4e487b71", 0x32
+// l((uint256[])[2][2],uint256,uint256): 0x60, 1, 1, 0x40, 0x0140, 0x40, 0xa0, 0x20, 1, 5, 0x20, 1, 6, 0x40, 0xa0, 0x20, 1, 7, 0x20, 2, 8, 9 -> 0x20, 0x80, 0x20, 2, 8, 9
+// l((uint256[])[2][2],uint256,uint256): 0x60, 1, 2, 0x40, 0x0140, 0x40, 0xa0, 0x20, 1, 5, 0x20, 1, 6, 0x40, 0xa0, 0x20, 1, 7, 0x20, 2, 8, 9 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_with_garbage.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_with_garbage.sol
new file mode 100644
index 00000000..58f68b8c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/calldata_with_garbage.sol
@@ -0,0 +1,66 @@
+pragma abicoder v2;
+
+contract C {
+    uint[] aTmp;
+    uint[2] bTmp;
+
+    function f_memory(uint[] calldata a) public returns (uint[] memory) {
+        return a;
+    }
+
+    function f_encode(uint[] calldata a) public returns (bytes memory) {
+        return abi.encode(a);
+    }
+
+    function f_storage(uint[] calldata a) public returns (bytes memory) {
+        aTmp = a;
+        return abi.encode(aTmp);
+    }
+
+    function f_index(uint[] calldata a, uint which) public returns (uint) {
+        return a[which];
+    }
+
+    function g_memory(uint[] calldata a, uint[2] calldata b) public returns (uint[] memory, uint[2] memory) {
+        return (a, b);
+    }
+
+    function g_encode(uint[] calldata a, uint[2] calldata b) public returns (bytes memory) {
+        return abi.encode(a, b);
+    }
+
+    function g_storage(uint[] calldata a, uint[2] calldata b) public returns (bytes memory) {
+        aTmp = a;
+        bTmp = b;
+        return abi.encode(aTmp, bTmp);
+    }
+
+    function g_index(uint[] calldata a, uint[2] calldata b, uint which) public returns (uint, uint) {
+        return (a[which], b[0]);
+    }
+}
+// ----
+// f_memory(uint256[]): 0x80, 9, 9, 9, 0 -> 0x20, 0
+// f_memory(uint256[]): 0x80, 9, 9, 9, 1, 7 -> 0x20, 1, 7
+// f_memory(uint256[]): 0x80, 9, 9, 9, 2, 7 -> FAILURE
+// f_encode(uint256[]): 0x80, 9, 9, 9, 0 -> 0x20, 0x40, 0x20, 0
+// f_encode(uint256[]): 0x80, 9, 9, 9, 1, 7 -> 0x20, 0x60, 0x20, 1, 7
+// f_encode(uint256[]): 0x80, 9, 9, 9, 2, 7 -> FAILURE
+// f_storage(uint256[]): 0x80, 9, 9, 9, 0 -> 0x20, 0x40, 0x20, 0
+// f_storage(uint256[]): 0x80, 9, 9, 9, 1, 7 -> 0x20, 0x60, 0x20, 1, 7
+// f_storage(uint256[]): 0x80, 9, 9, 9, 2, 7 -> FAILURE
+// f_index(uint256[],uint256): 0xa0, 0, 9, 9, 9, 2, 7, 8 -> 7
+// f_index(uint256[],uint256): 0xa0, 1, 9, 9, 9, 2, 7, 8 -> 8
+// f_index(uint256[],uint256): 0xa0, 2, 9, 9, 9, 2, 7, 8 -> FAILURE, hex"4e487b71", 0x32
+// g_memory(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 0 -> 0x60, 1, 2, 0
+// g_memory(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 1, 7 -> 0x60, 1, 2, 1, 7
+// g_memory(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 2, 7 -> FAILURE
+// g_encode(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 0 -> 0x20, 0x80, 0x60, 1, 2, 0
+// g_encode(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 1, 7 -> 0x20, 0xa0, 0x60, 1, 2, 1, 7
+// g_encode(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 2, 7 -> FAILURE
+// g_storage(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 0 -> 0x20, 0x80, 0x60, 1, 2, 0
+// g_storage(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 1, 7 -> 0x20, 0xa0, 0x60, 1, 2, 1, 7
+// g_storage(uint256[],uint256[2]): 0xc0, 1, 2, 9, 9, 9, 2, 7 -> FAILURE
+// g_index(uint256[],uint256[2],uint256): 0xe0, 1, 2, 0, 9, 9, 9, 2, 7, 8 -> 7, 1
+// g_index(uint256[],uint256[2],uint256): 0xe0, 1, 2, 1, 9, 9, 9, 2, 7, 8 -> 8, 1
+// g_index(uint256[],uint256[2],uint256): 0xe0, 1, 2, 1, 9, 9, 9, 2, 7 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol
new file mode 100644
index 00000000..4286f8f0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/cleanup/cleanup.sol
@@ -0,0 +1,16 @@
+pragma abicoder               v2;
+
+contract C {
+    function f(uint16 a, int16 b, address c, bytes3 d, bool e)
+            public pure returns (uint v, uint w, uint x, uint y, uint z) {
+        assembly { v := a  w := b x := c y := d z := e}
+    }
+}
+// ----
+// f(uint16,int16,address,bytes3,bool): 1, 2, 3, "a", true -> 1, 2, 3, "a", true
+// f(uint16,int16,address,bytes3,bool): 0xffffff, 0x1ffff, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "abcd", 1 -> FAILURE
+// f(uint16,int16,address,bytes3,bool): 0xffffff, 0, 0, "bcd", 1 -> FAILURE
+// f(uint16,int16,address,bytes3,bool): 0, 0x1ffff, 0, "ab", 1 -> FAILURE
+// f(uint16,int16,address,bytes3,bool): 0, 0, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "ad", 1 -> FAILURE
+// f(uint16,int16,address,bytes3,bool): 0, 0, 0, "abcd", 1 -> FAILURE
+// f(uint16,int16,address,bytes3,bool): 0, 0, 0, "abc", 2 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/enums.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/enums.sol
new file mode 100644
index 00000000..1e323472
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/enums.sol
@@ -0,0 +1,13 @@
+pragma abicoder               v2;
+
+contract C {
+    enum E { A, B }
+    function f(E e) public pure returns (uint x) {
+        assembly { x := e }
+    }
+}
+// ----
+// f(uint8): 0 -> 0
+// f(uint8): 1 -> 1
+// f(uint8): 2 -> FAILURE
+// f(uint8): 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_bytes.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_bytes.sol
new file mode 100644
index 00000000..3fe54eff
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_bytes.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint256[] memory a, bytes calldata b) public returns (bytes memory) {
+        return abi.encode(a, b);
+    }
+
+    function g(uint256[] memory a, bytes calldata b) external returns (bytes memory) {
+        return f(a, b);
+    }
+}
+// ----
+// f(uint256[],bytes): 0x40, 0x80, 1, 0xFF, 6, "123456" -> 0x20, 0xc0, 0x40, 0x80, 1, 0xff, 6, "123456"
+// g(uint256[],bytes): 0x40, 0x80, 1, 0xffff, 8, "12345678" -> 0x20, 0xc0, 0x40, 0x80, 1, 0xffff, 8, "12345678"
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_static_array.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_static_array.sol
new file mode 100644
index 00000000..a734103f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/memory_dynamic_array_and_calldata_static_array.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f(uint256[] memory a, uint256[1] calldata b) public returns (bytes memory) {
+        return abi.encode(a, b);
+    }
+
+    function g(uint256[] memory a, uint256[1] calldata b) external returns (bytes memory) {
+        return f(a, b);
+    }
+
+    function h(uint256[] memory a, uint256[1] calldata b) external returns (uint256[] memory, uint256[1] calldata) {
+        return (a, b);
+    }
+}
+// ----
+// f(uint256[],uint256[1]): 0x40, 0xff, 1, 0xffff -> 0x20, 0x80, 0x40, 0xff, 1, 0xffff
+// g(uint256[],uint256[1]): 0x40, 0xff, 1, 0xffff -> 0x20, 0x80, 0x40, 0xff, 1, 0xffff
+// h(uint256[],uint256[1]): 0x40, 0xff, 1, 0xffff -> 0x40, 0xff, 1, 0xffff
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol
new file mode 100644
index 00000000..33075675
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/storage_array_encoding.sol
@@ -0,0 +1,27 @@
+pragma abicoder               v2;
+
+// tests encoding from storage arrays
+
+contract C {
+    uint256[2][] tmp_h;
+    function h(uint256[2][] calldata s) external returns (bytes memory) {
+        tmp_h = s;
+        return abi.encode(tmp_h);
+    }
+    uint256[2][2] tmp_i;
+    function i(uint256[2][2] calldata s) external returns (bytes memory) {
+        tmp_i = s;
+        return abi.encode(tmp_i);
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// h(uint256[2][]): 0x20, 3, 123, 124, 223, 224, 323, 324 -> 32, 256, 0x20, 3, 123, 124, 223, 224, 323, 324
+// gas irOptimized: 180720
+// gas legacy: 184830
+// gas legacyOptimized: 181493
+// i(uint256[2][2]): 123, 124, 223, 224 -> 32, 128, 123, 124, 223, 224
+// gas irOptimized: 112425
+// gas legacy: 115398
+// gas legacyOptimized: 112982
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol
new file mode 100644
index 00000000..ce6550d3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_short.sol
@@ -0,0 +1,11 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S { int a; uint b; bytes16 c; }
+    function f(S memory s) public pure returns (S memory q) {
+        q = s;
+    }
+}
+// ----
+// f((int256,uint256,bytes16)): 0xff010, 0xff0002, "abcd" -> 0xff010, 0xff0002, "abcd"
+// f((int256,uint256,bytes16)): 0xff010, 0xff0002, 0x1111222233334444555566667777888800000000000000000000000000000000 -> 0xff010, 0xff0002, left(0x11112222333344445555666677778888)
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol
new file mode 100644
index 00000000..cf631b8a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_simple.sol
@@ -0,0 +1,13 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S { uint a; uint8 b; uint8 c; bytes2 d; }
+    function f(S memory s) public pure returns (uint a, uint b, uint c, uint d) {
+        a = s.a;
+        b = s.b;
+        c = s.c;
+        d = uint16(s.d);
+    }
+}
+// ----
+// f((uint256,uint8,uint8,bytes2)): 1, 2, 3, "ab" -> 1, 2, 3, 0x6162
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol
new file mode 100644
index 00000000..57e218f7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/struct_validation.sol
@@ -0,0 +1,17 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S { int16 a; uint8 b; bytes2 c; }
+	function f(S memory s) public pure returns (uint a, uint b, uint c) {
+		assembly {
+			a := mload(s)
+			b := mload(add(s, 0x20))
+			c := mload(add(s, 0x40))
+		}
+	}
+}
+// ----
+// f((int16,uint8,bytes2)): 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, 0xff, "ab" -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, 0xff, "ab"
+// f((int16,uint8,bytes2)): 0xff010, 0xff, "ab" -> FAILURE
+// f((int16,uint8,bytes2)): 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, 0xff0002, "ab" -> FAILURE
+// f((int16,uint8,bytes2)): 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, 0xff, "abcd" -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol
new file mode 100644
index 00000000..8a22b037
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiEncoderV2/struct/validation_function_type_inside_struct.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S { function () external x; }
+    function f(S memory) public pure returns (uint r) { r = 1; }
+    function g(S calldata) external pure returns (uint r) { r = 2; }
+    function h(S calldata s) external pure returns (uint r) { s.x; r = 3; }
+}
+// ----
+// f((function)): "01234567890123456789abcd" -> 1
+// f((function)): "01234567890123456789abcdX" -> FAILURE
+// g((function)): "01234567890123456789abcd" -> 2
+// g((function)): "01234567890123456789abcdX" -> 2
+// h((function)): "01234567890123456789abcd" -> 3
+// h((function)): "01234567890123456789abcdX" -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_calldata.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_calldata.sol
new file mode 100644
index 00000000..6b6e55e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_calldata.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(bytes calldata data)
+        external
+        pure
+        returns (uint256, bytes memory r)
+    {
+        return abi.decode(data, (uint256, bytes));
+    }
+}
+// ----
+// f(bytes): 0x20, 0x80, 0x21, 0x40, 0x7, "abcdefg" -> 0x21, 0x40, 0x7, "abcdefg"
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple.sol
new file mode 100644
index 00000000..9ae6602f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(bytes memory data) public pure returns (uint256, bytes memory) {
+        return abi.decode(data, (uint256, bytes));
+    }
+}
+// ----
+// f(bytes): 0x20, 0x80, 0x21, 0x40, 0x7, "abcdefg" -> 0x21, 0x40, 0x7, "abcdefg"
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple_storage.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple_storage.sol
new file mode 100644
index 00000000..c06d2b24
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_decode_simple_storage.sol
@@ -0,0 +1,13 @@
+contract C {
+    bytes data;
+
+    function f(bytes memory _data) public returns (uint256, bytes memory) {
+        data = _data;
+        return abi.decode(data, (uint256, bytes));
+    }
+}
+// ----
+// f(bytes): 0x20, 0x80, 0x21, 0x40, 0x7, "abcdefg" -> 0x21, 0x40, 0x7, "abcdefg"
+// gas irOptimized: 135661
+// gas legacy: 137278
+// gas legacyOptimized: 136048
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call.sol
new file mode 100644
index 00000000..1edede78
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call.sol
@@ -0,0 +1,48 @@
+pragma abicoder v2;
+contract C {
+	type UnsignedNumber is uint256;
+	enum Enum { First, Second, Third }
+
+	struct Struct {
+		UnsignedNumber[] dynamicArray;
+		uint256 justAnInt;
+		string name;
+		bytes someBytes;
+		Enum theEnum;
+	}
+
+	function callMeMaybe(Struct calldata _data, int256 _intVal, string memory _nameVal) external pure {
+		assert(_data.dynamicArray.length == 3);
+		assert(UnsignedNumber.unwrap(_data.dynamicArray[0]) == 0);
+		assert(UnsignedNumber.unwrap(_data.dynamicArray[1]) == 1);
+		assert(UnsignedNumber.unwrap(_data.dynamicArray[2]) == 2);
+		assert(_data.justAnInt == 6);
+		assert(keccak256(bytes(_data.name)) == keccak256("StructName"));
+		assert(keccak256(_data.someBytes) == keccak256(bytes("1234")));
+		assert(_data.theEnum == Enum.Second);
+		assert(_intVal == 5);
+		assert(keccak256(bytes(_nameVal)) == keccak256("TestName"));
+	}
+
+	function callExternal() public returns (bool) {
+		Struct memory structToSend;
+		structToSend.dynamicArray = new UnsignedNumber[](3);
+		structToSend.dynamicArray[0] = UnsignedNumber.wrap(0);
+		structToSend.dynamicArray[1] = UnsignedNumber.wrap(1);
+		structToSend.dynamicArray[2] = UnsignedNumber.wrap(2);
+		structToSend.justAnInt = 6;
+		structToSend.name = "StructName";
+		structToSend.someBytes = bytes("1234");
+		structToSend.theEnum = Enum.Second;
+
+		(bool success,) = address(this).call(abi.encodeCall(this.callMeMaybe, (
+			structToSend,
+			5,
+			"TestName"
+		)));
+
+		return success;
+	}
+}
+// ----
+// callExternal() -> true
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_declaration.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_declaration.sol
new file mode 100644
index 00000000..752298fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_declaration.sol
@@ -0,0 +1,52 @@
+pragma abicoder v2;
+
+contract X {
+    // no "returns" on purpose
+    function a(uint) public pure {}
+    function b(uint) external pure {}
+}
+
+contract Base {
+    function a(uint x) external pure returns (uint) { return x + 1; }
+}
+
+contract C is Base {
+	function test() public view returns (uint r) {
+        bool success;
+        bytes memory result;
+        (success, result) = address(this).staticcall(abi.encodeCall(X.a, 1));
+        require(success && result.length == 32);
+        r += abi.decode(result, (uint));
+        require(r == 2);
+
+        (success, result) = address(this).staticcall(abi.encodeCall(X.b, 10));
+        require(success && result.length == 32);
+        r += abi.decode(result, (uint));
+        require(r == 13);
+
+        (success, result) = address(this).staticcall(abi.encodeCall(Base.a, 100));
+        require(success && result.length == 32);
+        r += abi.decode(result, (uint));
+        require(r == 114);
+
+        (success, result) = address(this).staticcall(abi.encodeCall(this.a, 1000));
+        require(success && result.length == 32);
+        r += abi.decode(result, (uint));
+        require(r == 1115);
+
+        (success, result) = address(this).staticcall(abi.encodeCall(C.b, 10000));
+        require(success && result.length == 32);
+        r += abi.decode(result, (uint));
+        require(r == 11116);
+
+        return r;
+	}
+    function b(uint x) external view returns (uint) {
+        return this.a(x);
+    }
+
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// test() -> 11116
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_memory.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_memory.sol
new file mode 100644
index 00000000..5f67174c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_call_memory.sol
@@ -0,0 +1,25 @@
+pragma abicoder v2;
+
+contract D {
+	function something() external pure {}
+}
+
+contract C {
+	function something() external pure {}
+	function test() external returns (bytes4) {
+		function() external[2] memory x;
+		x[0] = this.something;
+		x[1] = (new D()).something;
+		function() external f = x[1];
+		bytes memory a = abi.encodeCall(x[0], ());
+		bytes memory b = abi.encodeCall(x[1], ());
+		bytes memory c = abi.encodeCall(f, ());
+		assert(a.length == 4 && b.length == 4 && c.length == 4);
+		assert(bytes4(a) == bytes4(b));
+		assert(bytes4(a) == bytes4(c));
+		assert(bytes4(a) == f.selector);
+		return bytes4(a);
+	}
+}
+// ----
+// test() -> 0xa7a0d53700000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selector.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selector.sol
new file mode 100644
index 00000000..f72de437
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selector.sol
@@ -0,0 +1,22 @@
+pragma abicoder v1;
+contract C {
+	function f0() public pure returns (bytes memory) {
+		return abi.encodeWithSelector(0x12345678);
+	}
+	function f1() public pure returns (bytes memory) {
+		return abi.encodeWithSelector(0x12345678, "abc");
+	}
+	function f2() public pure returns (bytes memory) {
+		bytes4 x = 0x12345678;
+		return abi.encodeWithSelector(x, "abc");
+	}
+	function f3() public pure returns (bytes memory) {
+		bytes4 x = 0x12345678;
+		return abi.encodeWithSelector(x, type(uint).max);
+	}
+}
+// ----
+// f0() -> 0x20, 4, 8234104107246695022420661102507966550300666591269321702959126607540084801536
+// f1() -> 0x20, 0x64, 8234104107246695022420661102507966550300666591269321702959126607540084801536, 862718293348820473429344482784628181556388621521298319395315527974912, 91135606241822717681769169345594720818313984248279388438121731325952, 0
+// f2() -> 0x20, 0x64, 8234104107246695022420661102507966550300666591269321702959126607540084801536, 862718293348820473429344482784628181556388621521298319395315527974912, 91135606241822717681769169345594720818313984248279388438121731325952, 0
+// f3() -> 0x20, 0x24, 0x12345678ffffffffffffffffffffffffffffffffffffffffffffffffffffffff, -26959946667150639794667015087019630673637144422540572481103610249216
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selectorv2.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selectorv2.sol
new file mode 100644
index 00000000..b23e2dd2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/abi_encode_with_selectorv2.sol
@@ -0,0 +1,32 @@
+pragma abicoder v2;
+contract C {
+	function f0() public pure returns (bytes memory) {
+		return abi.encodeWithSelector(0x12345678);
+	}
+	function f1() public pure returns (bytes memory) {
+		return abi.encodeWithSelector(0x12345678, "abc");
+	}
+	function f2() public pure returns (bytes memory) {
+		bytes4 x = 0x12345678;
+		return abi.encodeWithSelector(x, "abc");
+	}
+	function f3() public pure returns (bytes memory) {
+		bytes4 x = 0x12345678;
+		return abi.encodeWithSelector(x, type(uint).max);
+	}
+	struct S { uint a; string b; uint16 c; }
+	function f4() public pure returns (bytes memory) {
+		bytes4 x = 0x12345678;
+		S memory s;
+		s.a = 0x1234567;
+		s.b = "Lorem ipsum dolor sit ethereum........";
+		s.c = 0x1234;
+		return abi.encodeWithSelector(x, type(uint).max, s, uint(3));
+	}
+}
+// ----
+// f0() -> 0x20, 4, 8234104107246695022420661102507966550300666591269321702959126607540084801536
+// f1() -> 0x20, 0x64, 8234104107246695022420661102507966550300666591269321702959126607540084801536, 862718293348820473429344482784628181556388621521298319395315527974912, 91135606241822717681769169345594720818313984248279388438121731325952, 0
+// f2() -> 0x20, 0x64, 8234104107246695022420661102507966550300666591269321702959126607540084801536, 862718293348820473429344482784628181556388621521298319395315527974912, 91135606241822717681769169345594720818313984248279388438121731325952, 0
+// f3() -> 0x20, 0x24, 0x12345678ffffffffffffffffffffffffffffffffffffffffffffffffffffffff, -26959946667150639794667015087019630673637144422540572481103610249216
+// f4() -> 0x20, 292, 0x12345678ffffffffffffffffffffffffffffffffffffffffffffffffffffffff, -26959946667150639794667015087019630673637144422540572481103610249216, 2588154880046461420288033448353884544669165864563894958185946583924736, 80879840001451919384001045261058892020911433267621717443310830747648, 514631493222945105325971421573240365883976325135760395164659172419450175488, 2588154880046461420288033448353884544669165864563894958185946583924736, 125633351468921981443148290305511478939149093009039067761942823761346560, 0x264c6f72656d20697073756d20646f6c6f722073697420657468657265, 53113508339655873314659021564971517366334151400493876485713881232784043802624, 0
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding.sol
new file mode 100644
index 00000000..02937ace
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding.sol
@@ -0,0 +1,27 @@
+pragma abicoder v2;
+contract Test {
+	struct MemoryUint {
+		uint field;
+	}
+	function test() public pure returns (uint) {
+		uint[] memory before = new uint[](1); // at offset 0x80
+		// Two problems here: The first offset is zero, the second offset is missing.
+		bytes memory corrupt = abi.encode(uint(32), // offset to "tuple"
+										  uint(0)); // bogus first element
+		/*
+		  At this point the free pointer is 0x80 + 64 (size of before) + 32 (length field of corrupt) + 64 (two encoded words)
+
+		  Now let's put random junk into memory immediately after the bogus first element. Our goal is to overflow the read pointer to point to before.
+		  The value read out at this point will be added to beginning of the encoded tuple, AKA corrupt + 64. We need then to write x where:
+		  x + 0x80 + 64 (before) + 32 (length of corrupt) + 32 (first word of corrupt) = 0x80 (mod 2^256)
+		  that is MAX_UINT - 128
+		*/
+		MemoryUint memory afterCorrupt;
+		afterCorrupt.field = uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80);
+		before[0] = 123456;
+		uint[][2] memory decoded = abi.decode(corrupt, (uint[][2]));
+		return decoded[1][0];
+	}
+}
+// ----
+// test() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_2.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_2.sol
new file mode 100644
index 00000000..0a874914
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_2.sol
@@ -0,0 +1,28 @@
+pragma abicoder v2;
+contract Test {
+	struct MemoryTuple {
+		uint field1;
+		uint field2;
+	}
+	function withinArray() public pure returns (uint) {
+		uint[] memory before = new uint[](1);
+		bytes memory corrupt = abi.encode(uint(32),
+										  uint(2));
+		MemoryTuple memory afterCorrupt;
+		before[0] = 123456;
+		/*
+		  As above, but in this case we are adding to:
+		  0x80 + 64 (before) + 32 (length of corrupt) + 32 (offset) + 32 (field pointer)
+		  giving MAX_UINT - 96
+		*/
+		afterCorrupt.field1 = uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60);
+		afterCorrupt.field2 = uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60);
+		uint[][] memory decoded = abi.decode(corrupt, (uint[][]));
+		/*
+		  Will return 123456 * 2, AKA before has been copied twice
+		 */
+		return decoded[0][0] + decoded[1][0];
+	}
+}
+// ----
+// withinArray() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_3.sol b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_3.sol
new file mode 100644
index 00000000..a20e9ae4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/abiencodedecode/offset_overflow_in_array_decoding_3.sol
@@ -0,0 +1,21 @@
+pragma abicoder v2;
+contract Test {
+	struct MemoryUint {
+		uint field;
+	}
+	function test() public pure returns (uint) {
+		uint[] memory before = new uint[](1); // at offset 0x80
+		bytes memory corrupt = abi.encode(
+            uint(32),
+            uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80),
+            uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80)
+        );
+		MemoryUint memory afterCorrupt;
+		afterCorrupt.field = uint(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80);
+		before[0] = 123456;
+		uint[][2] memory decoded = abi.decode(corrupt, (uint[][2]));
+		return decoded[1][0];
+	}
+}
+// ----
+// test() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/accessor/accessor_for_const_state_variable.sol b/compiler/test/libsolidity/semanticTests/accessor/accessor_for_const_state_variable.sol
new file mode 100644
index 00000000..b8def588
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/accessor/accessor_for_const_state_variable.sol
@@ -0,0 +1,5 @@
+contract Lotto {
+    uint256 public constant ticketPrice = 555;
+}
+// ----
+// ticketPrice() -> 555
diff --git a/compiler/test/libsolidity/semanticTests/accessor/accessor_for_state_variable.sol b/compiler/test/libsolidity/semanticTests/accessor/accessor_for_state_variable.sol
new file mode 100644
index 00000000..51cb8e5e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/accessor/accessor_for_state_variable.sol
@@ -0,0 +1,5 @@
+contract Lotto {
+    uint256 public ticketPrice = 500;
+}
+// ----
+// ticketPrice() -> 500
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod.sol b/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod.sol
new file mode 100644
index 00000000..e6f703bd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod.sol
@@ -0,0 +1,11 @@
+contract C {
+    function test() public returns (uint256) {
+        // Note that this only works because computation on literals is done using
+        // unbounded integers.
+        if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) return 1;
+        if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) return 2;
+        return 0;
+    }
+}
+// ----
+// test() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod_zero.sol b/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod_zero.sol
new file mode 100644
index 00000000..cd32ceff
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/addmod_mulmod_zero.sol
@@ -0,0 +1,23 @@
+contract C {
+    function f(uint256 d) public pure returns (uint256) {
+        addmod(1, 2, d);
+        return 2;
+    }
+
+    function g(uint256 d) public pure returns (uint256) {
+        mulmod(1, 2, d);
+        return 2;
+    }
+
+    function h() public pure returns (uint256) {
+        mulmod(0, 1, 2);
+        mulmod(1, 0, 2);
+        addmod(0, 1, 2);
+        addmod(1, 0, 2);
+        return 2;
+    }
+}
+// ----
+// f(uint256): 0 -> FAILURE, hex"4e487b71", 0x12
+// g(uint256): 0 -> FAILURE, hex"4e487b71", 0x12
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/block_inside_unchecked.sol b/compiler/test/libsolidity/semanticTests/arithmetics/block_inside_unchecked.sol
new file mode 100644
index 00000000..7a8504d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/block_inside_unchecked.sol
@@ -0,0 +1,11 @@
+contract C {
+  function f() public returns (uint y) {
+    unchecked{{
+        uint max = type(uint).max;
+        uint x = max + 1;
+        y = x;
+    }}
+  }
+}
+// ----
+// f() -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/check_var_init.sol b/compiler/test/libsolidity/semanticTests/arithmetics/check_var_init.sol
new file mode 100644
index 00000000..6cc02bd9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/check_var_init.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint public x = msg.value - 10;
+    constructor() payable {}
+}
+
+contract D {
+    function f() public {
+        unchecked {
+            new C();
+        }
+    }
+    function g() public payable returns (uint) {
+        return (new C{value: 11}()).x();
+    }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x11
+// g(), 100 wei -> 1
+// gas legacy: 100388
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/checked_called_by_unchecked.sol b/compiler/test/libsolidity/semanticTests/arithmetics/checked_called_by_unchecked.sol
new file mode 100644
index 00000000..420a52cd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/checked_called_by_unchecked.sol
@@ -0,0 +1,12 @@
+contract C {
+    function add(uint16 a, uint16 b) public returns (uint16) {
+        return a + b;
+    }
+
+    function f(uint16 a, uint16 b, uint16 c) public returns (uint16) {
+        unchecked { return add(a, b) + c; }
+    }
+}
+// ----
+// f(uint16,uint16,uint16): 0xe000, 0xe500, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(uint16,uint16,uint16): 0xe000, 0x1000, 0x1000 -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/checked_modifier_called_by_unchecked.sol b/compiler/test/libsolidity/semanticTests/arithmetics/checked_modifier_called_by_unchecked.sol
new file mode 100644
index 00000000..42658f83
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/checked_modifier_called_by_unchecked.sol
@@ -0,0 +1,13 @@
+contract C {
+    modifier add(uint16 a, uint16 b) {
+        unchecked { a + b; }
+        _;
+    }
+
+    function f(uint16 a, uint16 b, uint16 c) public add(a, b) returns (uint16) {
+        return b + c;
+    }
+}
+// ----
+// f(uint16,uint16,uint16): 0xe000, 0xe500, 2 -> 58626
+// f(uint16,uint16,uint16): 0x1000, 0xe500, 0xe000 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/divisiod_by_zero.sol b/compiler/test/libsolidity/semanticTests/arithmetics/divisiod_by_zero.sol
new file mode 100644
index 00000000..517c4966
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/divisiod_by_zero.sol
@@ -0,0 +1,14 @@
+contract C {
+    function div(uint256 a, uint256 b) public returns (uint256) {
+        return a / b;
+    }
+
+    function mod(uint256 a, uint256 b) public returns (uint256) {
+        return a % b;
+    }
+}
+// ----
+// div(uint256,uint256): 7, 2 -> 3
+// div(uint256,uint256): 7, 0 -> FAILURE, hex"4e487b71", 0x12 # throws #
+// mod(uint256,uint256): 7, 2 -> 1
+// mod(uint256,uint256): 7, 0 -> FAILURE, hex"4e487b71", 0x12 # throws #
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/exp_associativity.sol b/compiler/test/libsolidity/semanticTests/arithmetics/exp_associativity.sol
new file mode 100644
index 00000000..0ec9f2c7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/exp_associativity.sol
@@ -0,0 +1,38 @@
+contract C {
+    // (2**3)**4 = 4096
+    // 2**(3**4) = 2417851639229258349412352
+    function test_hardcode1(uint a, uint b, uint c) public returns (uint256) {
+        return a**b**c;
+    }
+
+    // (3**2)**2)**2 = 6561
+    // 3**(2**(2**2) = 43046721
+    function test_hardcode2(uint a, uint b, uint c, uint d) public returns (uint256) {
+        return a**b**c**d;
+    }
+
+    function test_invariant(uint a, uint b, uint c) public returns (bool) {
+        return a**b**c == a**(b**c);
+    }
+
+    function test_literal_mix(uint a, uint b) public returns (bool) {
+        return
+            (a**2**b == a**(2**b)) &&
+            (2**a**b == 2**(a**b)) &&
+            (a**b**2 == a**(b**2));
+    }
+
+    function test_other_operators(uint a, uint b) public returns (bool) {
+        return
+            (a**b/25 == (a**b)/25) &&
+            (a**b*3**b == (a**b)*(3**b)) &&
+            (b**a**a/b**a**b == (b**(a**a))/(b**(a**b)));
+     }
+}
+// ----
+// test_hardcode1(uint256,uint256,uint256): 2, 3, 4 -> 2417851639229258349412352
+// test_hardcode2(uint256,uint256,uint256,uint256): 3, 2, 2, 2 -> 43046721
+// test_invariant(uint256,uint256,uint256): 2, 3, 4 -> true
+// test_invariant(uint256,uint256,uint256): 3, 4, 2 -> true
+// test_literal_mix(uint256,uint256): 2, 3 -> true
+// test_other_operators(uint256,uint256): 2, 4 -> true
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/signed_mod.sol b/compiler/test/libsolidity/semanticTests/arithmetics/signed_mod.sol
new file mode 100644
index 00000000..30625620
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/signed_mod.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f(int a, int b) public pure returns (int) {
+        return a % b;
+    }
+    function g(bool _check) public pure returns (int) {
+        int x = type(int).min;
+        if (_check) {
+            return x / -1;
+        } else {
+            unchecked { return x / -1; }
+        }
+    }
+}
+// ----
+// f(int256,int256): 7, 5 -> 2
+// f(int256,int256): 7, -5 -> 2
+// f(int256,int256): -7, 5 -> -2
+// f(int256,int256): -7, 5 -> -2
+// f(int256,int256): -5, -5 -> 0
+// g(bool): true -> FAILURE, hex"4e487b71", 0x11
+// g(bool): false -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_called_by_checked.sol b/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_called_by_checked.sol
new file mode 100644
index 00000000..14050627
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_called_by_checked.sol
@@ -0,0 +1,15 @@
+contract C {
+    function add(uint16 a, uint16 b) public returns (uint16) {
+        unchecked {
+            return a + b;
+        }
+    }
+
+    function f(uint16 a) public returns (uint16) {
+        return add(a, 0x100) + 0x100;
+    }
+}
+// ----
+// f(uint16): 7 -> 0x0207
+// f(uint16): 0xffff -> 511
+// f(uint16): 0xfeff -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_div_by_zero.sol b/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_div_by_zero.sol
new file mode 100644
index 00000000..ae91ea27
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/arithmetics/unchecked_div_by_zero.sol
@@ -0,0 +1,20 @@
+contract C {
+    function div(uint256 a, uint256 b) public returns (uint256) {
+        // Does not disable div by zero check
+        unchecked {
+            return a / b;
+        }
+    }
+
+    function mod(uint256 a, uint256 b) public returns (uint256) {
+        // Does not disable div by zero check
+        unchecked {
+            return a % b;
+        }
+    }
+}
+// ----
+// div(uint256,uint256): 7, 2 -> 3
+// div(uint256,uint256): 7, 0 -> FAILURE, hex"4e487b71", 0x12 # throws #
+// mod(uint256,uint256): 7, 2 -> 1
+// mod(uint256,uint256): 7, 0 -> FAILURE, hex"4e487b71", 0x12 # throws #
diff --git a/compiler/test/libsolidity/semanticTests/array/array_2d_assignment.sol b/compiler/test/libsolidity/semanticTests/array/array_2d_assignment.sol
new file mode 100644
index 00000000..9a4093c3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_2d_assignment.sol
@@ -0,0 +1,12 @@
+contract C {
+	function f(uint n) public pure returns (uint) {
+		uint[][] memory a = new uint[][](2);
+		for (uint i = 0; i < 2; ++i)
+			a[i] = new uint[](3);
+		a[1][1] = n;
+		uint[] memory b = a[1];
+		return b[1];
+	}
+}
+// ----
+// f(uint256): 42 -> 42
diff --git a/compiler/test/libsolidity/semanticTests/array/array_2d_new.sol b/compiler/test/libsolidity/semanticTests/array/array_2d_new.sol
new file mode 100644
index 00000000..13c0ac20
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_2d_new.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(uint n) public pure returns (uint) {
+		uint[][] memory a = new uint[][](2);
+		for (uint i = 0; i < 2; ++i)
+			a[i] = new uint[](3);
+		return a[0][0] = n;
+	}
+}
+// ----
+// f(uint256): 42 -> 42
diff --git a/compiler/test/libsolidity/semanticTests/array/array_3d_assignment.sol b/compiler/test/libsolidity/semanticTests/array/array_3d_assignment.sol
new file mode 100644
index 00000000..f987a17d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_3d_assignment.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(uint n) public pure returns (uint) {
+		uint[][][] memory a = new uint[][][](2);
+		for (uint i = 0; i < 2; ++i)
+		{
+			a[i] = new uint[][](3);
+			for (uint j = 0; j < 3; ++j)
+				a[i][j] = new uint[](4);
+		}
+		a[1][1][1] = n;
+		uint[][] memory b = a[1];
+		uint[] memory c = b[1];
+		return c[1];
+	}
+}
+// ----
+// f(uint256): 42 -> 42
diff --git a/compiler/test/libsolidity/semanticTests/array/array_3d_new.sol b/compiler/test/libsolidity/semanticTests/array/array_3d_new.sol
new file mode 100644
index 00000000..b4bb4e62
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_3d_new.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(uint n) public pure returns (uint) {
+		uint[][][] memory a = new uint[][][](2);
+		for (uint i = 0; i < 2; ++i)
+		{
+			a[i] = new uint[][](3);
+			for (uint j = 0; j < 3; ++j)
+				a[i][j] = new uint[](4);
+		}
+		return a[1][1][1] = n;
+	}
+}
+// ----
+// f(uint256): 42 -> 42
diff --git a/compiler/test/libsolidity/semanticTests/array/array_function_pointers.sol b/compiler/test/libsolidity/semanticTests/array/array_function_pointers.sol
new file mode 100644
index 00000000..5d4707ec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_function_pointers.sol
@@ -0,0 +1,27 @@
+contract C {
+	function f(uint n, uint m) public {
+		function() internal returns (uint)[] memory arr = new function() internal returns (uint)[](n);
+		arr[m]();
+	}
+	function f2(uint n, uint m, uint a, uint b) public {
+		function() internal returns (uint)[][] memory arr = new function() internal returns (uint)[][](n);
+		for (uint i = 0; i < n; ++i)
+			arr[i] = new function() internal returns (uint)[](m);
+		arr[a][b]();
+	}
+	function g(uint n, uint m) public {
+		function() external returns (uint)[] memory arr = new function() external returns (uint)[](n);
+		arr[m]();
+	}
+	function g2(uint n, uint m, uint a, uint b) public {
+		function() external returns (uint)[][] memory arr = new function() external returns (uint)[][](n);
+		for (uint i = 0; i < n; ++i)
+			arr[i] = new function() external returns (uint)[](m);
+		arr[a][b]();
+	}
+}
+// ----
+// f(uint256,uint256): 1823621, 12323 -> FAILURE # Out of gas #
+// f2(uint256,uint256,uint256,uint256): 18723921, 1823621, 123, 12323 -> FAILURE # Out of gas #
+// g(uint256,uint256): 1823621, 12323 -> FAILURE # Out of gas #
+// g2(uint256,uint256,uint256,uint256): 18723921, 1823621, 123, 12323 -> FAILURE # Out of gas #
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_2d_zeroed_memory_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_2d_zeroed_memory_index_access.sol
new file mode 100644
index 00000000..683eca90
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_2d_zeroed_memory_index_access.sol
@@ -0,0 +1,22 @@
+contract C {
+	uint test1;
+	uint test2;
+	uint test3;
+	uint test4;
+	uint test5;
+	uint test6;
+	uint test7;
+	mapping (string => uint) map;
+	function set(string memory s, uint n, uint m, uint a, uint b) public returns (uint) {
+		map[s] = 0;
+		uint[][] memory x = new uint[][](n);
+		for (uint i = 0; i < n; ++i)
+			x[i] = new uint[](m);
+		return x[a][b];
+	}
+}
+// ----
+// set(string,uint256,uint256,uint256,uint256): 0xa0, 2, 4, 0, 0, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256,uint256,uint256): 0xa0, 2, 4, 1, 3, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256,uint256,uint256): 0xa0, 2, 4, 3, 3, 32, "01234567890123456789012345678901" -> FAILURE, hex"4e487b71", 0x32
+// set(string,uint256,uint256,uint256,uint256): 0xa0, 2, 4, 1, 5, 32, "01234567890123456789012345678901" -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_array_static.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_array_static.sol
new file mode 100644
index 00000000..6113cfee
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_array_static.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint test1;
+	uint test2;
+	uint test3;
+	uint test4;
+	uint test5;
+	uint test6;
+	uint test7;
+	mapping (string => uint) map;
+	function set(string memory s, uint n, uint m) public returns (uint) {
+		map[s] = 0;
+		uint[4][] memory x = new uint[4][](n);
+		return x[m][0];
+	}
+}
+// ----
+// set(string,uint256,uint256): 0x60, 2, 0, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256): 0x60, 2, 1, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256): 0x60, 2, 2, 32, "01234567890123456789012345678901" -> FAILURE, hex"4e487b71", 0x32
+// set(string,uint256,uint256): 0x60, 200, 199, 32, "01234567890123456789012345678901" -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_return_param_zeroed_memory_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_return_param_zeroed_memory_index_access.sol
new file mode 100644
index 00000000..13af18a5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_return_param_zeroed_memory_index_access.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint test1;
+	uint test2;
+	uint test3;
+	uint test4;
+	uint test5;
+	uint test6;
+	uint test7;
+	mapping (string => uint) map;
+	function set(string memory s) public returns (uint[3] memory x, uint[2] memory y, uint[] memory z, uint t) {
+		map[s] = 0;
+	}
+}
+// ----
+// set(string): 0x20, 32, "01234567890123456789012345678901" -> 0, 0, 0, 0, 0, 0xe0, 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_zeroed_memory_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_zeroed_memory_index_access.sol
new file mode 100644
index 00000000..eddf0e72
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_static_zeroed_memory_index_access.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint test1;
+	uint test2;
+	uint test3;
+	uint test4;
+	uint test5;
+	uint test6;
+	uint test7;
+	mapping (string => uint) map;
+	function set(string memory s) public returns (uint) {
+		map[s] = 0;
+		uint[3] memory x;
+		return x[2];
+	}
+}
+// ----
+// set(string): 0x20, 32, "01234567890123456789012345678901" -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_zeroed_memory_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_zeroed_memory_index_access.sol
new file mode 100644
index 00000000..5eeaad7d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_allocation/array_zeroed_memory_index_access.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint test1;
+	uint test2;
+	uint test3;
+	uint test4;
+	uint test5;
+	uint test6;
+	uint test7;
+	mapping (string => uint) map;
+	function set(string memory s, uint n, uint a) public returns (uint) {
+		map[s] = 0;
+		uint[] memory x = new uint[](n);
+		return x[a];
+	}
+}
+// ----
+// set(string,uint256,uint256): 0x60, 5, 0, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256): 0x60, 5, 1, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256): 0x60, 5, 4, 32, "01234567890123456789012345678901" -> 0
+// set(string,uint256,uint256): 0x60, 5, 5, 32, "01234567890123456789012345678901" -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_as_parameter.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_as_parameter.sol
new file mode 100644
index 00000000..151fe089
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_as_parameter.sol
@@ -0,0 +1,24 @@
+contract C {
+	function test(uint256 len, uint idx) public returns (uint256)
+	{
+		uint[] memory array = new uint[](len);
+		uint result = receiver(array, idx);
+
+		for (uint256 i = 0; i < array.length; i++)
+			require(array[i] == i + 1);
+
+		return result;
+	}
+	function receiver(uint[] memory array, uint idx) public returns (uint256)
+	{
+		for (uint256 i = 0; i < array.length; i++)
+			array[i] = i + 1;
+
+		return array[idx];
+	}
+}
+// ----
+// test(uint256,uint256): 0, 0 -> FAILURE, hex"4e487b71", 0x32
+// test(uint256,uint256): 1, 0 -> 1
+// test(uint256,uint256): 10, 5 -> 6
+// test(uint256,uint256): 10, 50 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_create.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_create.sol
new file mode 100644
index 00000000..91e72bc9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_create.sol
@@ -0,0 +1,11 @@
+contract C {
+	function create(uint256 len) public returns (uint256)
+	{
+		uint[] memory array = new uint[](len);
+		return array.length;
+	}
+}
+// ----
+// create(uint256): 0 -> 0
+// create(uint256): 7 -> 7
+// create(uint256): 10 -> 10
diff --git a/compiler/test/libsolidity/semanticTests/array/array_memory_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_memory_index_access.sol
new file mode 100644
index 00000000..d313e7ac
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_memory_index_access.sol
@@ -0,0 +1,36 @@
+contract C {
+	function index(uint256 len) public returns (bool)
+	{
+		uint[] memory array = new uint[](len);
+
+		for (uint256 i = 0; i < len; i++)
+			array[i] = i + 1;
+
+		for (uint256 i = 0; i < len; i++)
+			require(array[i] == i + 1, "Unexpected value in array!");
+
+		return array.length == len;
+	}
+	function accessIndex(uint256 len, int256 idx) public returns (uint256)
+	{
+		uint[] memory array = new uint[](len);
+
+		for (uint256 i = 0; i < len; i++)
+			array[i] = i + 1;
+
+		return array[uint256(idx)];
+	}
+}
+// ----
+// index(uint256): 0 -> true
+// index(uint256): 10 -> true
+// index(uint256): 20 -> true
+// index(uint256): 0xFF -> true
+// gas irOptimized: 108291
+// gas legacy: 181523
+// gas legacyOptimized: 117443
+// accessIndex(uint256,int256): 10, 1 -> 2
+// accessIndex(uint256,int256): 10, 0 -> 1
+// accessIndex(uint256,int256): 10, 11 -> FAILURE, hex"4e487b71", 0x32
+// accessIndex(uint256,int256): 10, 10 -> FAILURE, hex"4e487b71", 0x32
+// accessIndex(uint256,int256): 10, -1 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_push_return_reference.sol b/compiler/test/libsolidity/semanticTests/array/array_push_return_reference.sol
new file mode 100644
index 00000000..a7e5454b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_push_return_reference.sol
@@ -0,0 +1,23 @@
+contract C {
+    uint[] storageArray;
+    function test(uint256 v) public {
+        storageArray.push() = v;
+    }
+    function getLength() public view returns (uint256) {
+        return storageArray.length;
+    }
+    function fetch(uint256 a) public view returns (uint256) {
+        return storageArray[a];
+    }
+}
+// ----
+// getLength() -> 0
+// test(uint256): 42 ->
+// getLength() -> 1
+// fetch(uint256): 0 -> 42
+// fetch(uint256): 1 -> FAILURE, hex"4e487b71", 0x32
+// test(uint256): 23 ->
+// getLength() -> 2
+// fetch(uint256): 0 -> 42
+// fetch(uint256): 1 -> 23
+// fetch(uint256): 2 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_push_with_arg.sol b/compiler/test/libsolidity/semanticTests/array/array_push_with_arg.sol
new file mode 100644
index 00000000..b143c199
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_push_with_arg.sol
@@ -0,0 +1,23 @@
+contract C {
+    uint[] storageArray;
+    function test(uint256 v) public {
+        storageArray.push(v);
+    }
+    function getLength() public view returns (uint256) {
+        return storageArray.length;
+    }
+    function fetch(uint256 a) public view returns (uint256) {
+        return storageArray[a];
+    }
+}
+// ----
+// getLength() -> 0
+// test(uint256): 42 ->
+// getLength() -> 1
+// fetch(uint256): 0 -> 42
+// fetch(uint256): 1 -> FAILURE, hex"4e487b71", 0x32
+// test(uint256): 23 ->
+// getLength() -> 2
+// fetch(uint256): 0 -> 42
+// fetch(uint256): 1 -> 23
+// fetch(uint256): 2 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_index_access.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_index_access.sol
new file mode 100644
index 00000000..2589e470
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_index_access.sol
@@ -0,0 +1,53 @@
+contract C {
+    uint[] storageArray;
+    function test_indices(uint256 len) public
+    {
+        while (storageArray.length < len)
+            storageArray.push();
+        while (storageArray.length > len)
+            storageArray.pop();
+        for (uint i = 0; i < len; i++)
+            storageArray[i] = i + 1;
+
+        for (uint i = 0; i < len; i++)
+            require(storageArray[i] == i + 1);
+    }
+}
+// ----
+// test_indices(uint256): 1 ->
+// test_indices(uint256): 129 ->
+// gas irOptimized: 3003025
+// gas legacy: 3038654
+// gas legacyOptimized: 2995964
+// test_indices(uint256): 5 ->
+// gas irOptimized: 576296
+// gas legacy: 573810
+// gas legacyOptimized: 571847
+// test_indices(uint256): 10 ->
+// gas irOptimized: 157009
+// gas legacy: 160108
+// gas legacyOptimized: 156996
+// test_indices(uint256): 15 ->
+// gas irOptimized: 171409
+// gas legacy: 175973
+// gas legacyOptimized: 171596
+// test_indices(uint256): 0xFF ->
+// gas irOptimized: 5645329
+// gas legacy: 5715748
+// gas legacyOptimized: 5632556
+// test_indices(uint256): 1000 ->
+// gas irOptimized: 18068701
+// gas legacy: 18347810
+// gas legacyOptimized: 18037248
+// test_indices(uint256): 129 ->
+// gas irOptimized: 4136840
+// gas legacy: 4140113
+// gas legacyOptimized: 4108272
+// test_indices(uint256): 128 ->
+// gas irOptimized: 395769
+// gas legacy: 433498
+// gas legacyOptimized: 400909
+// test_indices(uint256): 1 ->
+// gas irOptimized: 580232
+// gas legacy: 576715
+// gas legacyOptimized: 575542
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_index_boundary_test.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_index_boundary_test.sol
new file mode 100644
index 00000000..c77aad0a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_index_boundary_test.sol
@@ -0,0 +1,27 @@
+contract C {
+    uint[] storageArray;
+    function test_boundary_check(uint256 len, uint256 access) public returns (uint256)
+    {
+        while(storageArray.length < len)
+            storageArray.push();
+        while(storageArray.length > len)
+            storageArray.pop();
+        return storageArray[access];
+    }
+}
+// ----
+// test_boundary_check(uint256,uint256): 10, 11 -> FAILURE, hex"4e487b71", 0x32
+// test_boundary_check(uint256,uint256): 10, 9 -> 0
+// test_boundary_check(uint256,uint256): 1, 9 -> FAILURE, hex"4e487b71", 0x32
+// test_boundary_check(uint256,uint256): 1, 1 -> FAILURE, hex"4e487b71", 0x32
+// test_boundary_check(uint256,uint256): 10, 10 -> FAILURE, hex"4e487b71", 0x32
+// test_boundary_check(uint256,uint256): 256, 256 -> FAILURE, hex"4e487b71", 0x32
+// gas irOptimized: 137913
+// gas legacy: 133633
+// gas legacyOptimized: 114354
+// test_boundary_check(uint256,uint256): 256, 255 -> 0
+// gas irOptimized: 140048
+// gas legacy: 135949
+// gas legacyOptimized: 116533
+// test_boundary_check(uint256,uint256): 256, 0xFFFF -> FAILURE, hex"4e487b71", 0x32
+// test_boundary_check(uint256,uint256): 256, 2 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_index_zeroed_test.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_index_zeroed_test.sol
new file mode 100644
index 00000000..59335865
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_index_zeroed_test.sol
@@ -0,0 +1,69 @@
+contract C {
+    uint[] storageArray;
+    function test_zeroed_indicies(uint256 len) public
+    {
+        while(storageArray.length < len)
+            storageArray.push();
+        while(storageArray.length > len)
+            storageArray.pop();
+
+        for (uint i = 0; i < len; i++)
+            storageArray[i] = i + 1;
+
+        if (len > 3)
+        {
+            while(storageArray.length > 0)
+                storageArray.pop();
+            while(storageArray.length < 3)
+                storageArray.push();
+
+            for (uint i = 3; i < len; i++)
+            {
+                assembly {
+                    mstore(0, storageArray.slot)
+                    let pos := add(keccak256(0, 0x20), i)
+
+                    if iszero(eq(sload(pos), 0)) {
+                        revert(0, 0)
+                    }
+                }
+            }
+
+        }
+
+        while(storageArray.length > 0)
+            storageArray.pop();
+        while(storageArray.length < len)
+            storageArray.push();
+
+        for (uint i = 0; i < len; i++)
+        {
+            require(storageArray[i] == 0);
+
+            uint256 val = storageArray[i];
+            uint256 check;
+
+            assembly { check := iszero(val) }
+
+            require(check == 1);
+        }
+    }
+}
+// ----
+// test_zeroed_indicies(uint256): 1 ->
+// test_zeroed_indicies(uint256): 5 ->
+// gas irOptimized: 131315
+// gas legacy: 131671
+// gas legacyOptimized: 129994
+// test_zeroed_indicies(uint256): 10 ->
+// gas irOptimized: 224578
+// gas legacy: 225237
+// gas legacyOptimized: 222359
+// test_zeroed_indicies(uint256): 15 ->
+// gas irOptimized: 321962
+// gas legacy: 322937
+// gas legacyOptimized: 318919
+// test_zeroed_indicies(uint256): 0xFF ->
+// gas irOptimized: 5080806
+// gas legacy: 5093941
+// gas legacyOptimized: 5020727
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_length_access.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_length_access.sol
new file mode 100644
index 00000000..0669a320
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_length_access.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint[] storageArray;
+    function set_get_length(uint256 len) public returns (uint256) {
+        while(storageArray.length < len)
+            storageArray.push();
+        return storageArray.length;
+    }
+}
+// ----
+// set_get_length(uint256): 0 -> 0
+// set_get_length(uint256): 1 -> 1
+// set_get_length(uint256): 10 -> 10
+// set_get_length(uint256): 20 -> 20
+// set_get_length(uint256): 0xFF -> 0xFF
+// gas irOptimized: 96690
+// gas legacy: 128571
+// gas legacyOptimized: 110143
+// set_get_length(uint256): 0xFFF -> 0xFFF
+// gas irOptimized: 1209119
+// gas legacy: 1689548
+// gas legacyOptimized: 1393535
+// set_get_length(uint256): 0xFFFFF -> FAILURE # Out-of-gas #
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_pop_zero_length.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_pop_zero_length.sol
new file mode 100644
index 00000000..ed946e19
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_pop_zero_length.sol
@@ -0,0 +1,10 @@
+contract C {
+    uint[] storageArray;
+    function popEmpty() public {
+        storageArray.pop();
+    }
+}
+// ====
+// EVMVersion: >=petersburg
+// ----
+// popEmpty() -> FAILURE, hex"4e487b71", 0x31
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty.sol
new file mode 100644
index 00000000..80376b42
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty.sol
@@ -0,0 +1,25 @@
+contract C {
+    uint256[] storageArray;
+    function pushEmpty(uint256 len) public {
+        while(storageArray.length < len)
+            storageArray.push();
+
+        for (uint i = 0; i < len; i++)
+            require(storageArray[i] == 0);
+    }
+}
+// ====
+// EVMVersion: >=petersburg
+// ----
+// pushEmpty(uint256): 128
+// gas irOptimized: 401024
+// gas legacy: 400640
+// gas legacyOptimized: 388804
+// pushEmpty(uint256): 256
+// gas irOptimized: 683700
+// gas legacy: 685108
+// gas legacyOptimized: 671480
+// pushEmpty(uint256): 38869 -> FAILURE # out-of-gas #
+// gas irOptimized: 100000000
+// gas legacy: 100000000
+// gas legacyOptimized: 100000000
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol
new file mode 100644
index 00000000..4b5b407e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol
@@ -0,0 +1,33 @@
+contract C {
+    address[] addressArray;
+    function set_get_length(uint256 len) public returns (uint256)
+    {
+        while(addressArray.length < len)
+            addressArray.push();
+        while(addressArray.length > len)
+            addressArray.pop();
+        return addressArray.length;
+    }
+}
+// ====
+// EVMVersion: >=petersburg
+// ----
+// set_get_length(uint256): 0 -> 0
+// set_get_length(uint256): 1 -> 1
+// set_get_length(uint256): 10 -> 10
+// set_get_length(uint256): 20 -> 20
+// set_get_length(uint256): 0 -> 0
+// gas irOptimized: 77628
+// gas legacy: 77730
+// gas legacyOptimized: 77162
+// set_get_length(uint256): 0xFF -> 0xFF
+// gas irOptimized: 158881
+// gas legacy: 696850
+// gas legacyOptimized: 134488
+// set_get_length(uint256): 0xFFF -> 0xFFF
+// gas irOptimized: 1762213
+// gas legacy: 9857362
+// gas legacyOptimized: 1393660
+// set_get_length(uint256): 0xFFFFF -> FAILURE # Out-of-gas #
+// gas irOptimized: 100000000
+// gas legacyOptimized: 100000000
diff --git a/compiler/test/libsolidity/semanticTests/array/array_storage_push_pop.sol b/compiler/test/libsolidity/semanticTests/array/array_storage_push_pop.sol
new file mode 100644
index 00000000..5befbe22
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/array_storage_push_pop.sol
@@ -0,0 +1,27 @@
+contract C {
+    uint[] storageArray;
+    function set_get_length(uint256 len) public returns (uint256) {
+        while(storageArray.length < len)
+            storageArray.push();
+        while(storageArray.length > 0)
+            storageArray.pop();
+        return storageArray.length;
+    }
+}
+// ----
+// set_get_length(uint256): 0 -> 0
+// set_get_length(uint256): 1 -> 0
+// set_get_length(uint256): 10 -> 0
+// set_get_length(uint256): 20 -> 0
+// gas irOptimized: 106222
+// gas legacy: 105722
+// gas legacyOptimized: 103508
+// set_get_length(uint256): 0xFF -> 0
+// gas irOptimized: 815997
+// gas legacy: 808020
+// gas legacyOptimized: 784467
+// set_get_length(uint256): 0xFFF -> 0
+// gas irOptimized: 12746889
+// gas legacy: 12612192
+// gas legacyOptimized: 12239199
+// set_get_length(uint256): 0xFFFF -> FAILURE # Out-of-gas #
diff --git a/compiler/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol
new file mode 100644
index 00000000..95280054
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol
@@ -0,0 +1,21 @@
+contract Test {
+    uint24[3][] public data;
+
+    function set(uint24[3][] memory _data) public returns (uint256) {
+        data = _data;
+        return data.length;
+    }
+
+    function get() public returns (uint24[3][] memory) {
+        return data;
+    }
+}
+// ----
+// set(uint24[3][]): 0x20, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12 -> 0x06
+// gas irOptimized: 186557
+// gas legacy: 211054
+// gas legacyOptimized: 206042
+// data(uint256,uint256): 0x02, 0x02 -> 0x09
+// data(uint256,uint256): 0x05, 0x01 -> 0x11
+// data(uint256,uint256): 0x06, 0x00 -> FAILURE
+// get() -> 0x20, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12
diff --git a/compiler/test/libsolidity/semanticTests/array/byte_array_storage_layout.sol b/compiler/test/libsolidity/semanticTests/array/byte_array_storage_layout.sol
new file mode 100644
index 00000000..942c7337
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/byte_array_storage_layout.sol
@@ -0,0 +1,55 @@
+contract c {
+    bytes data;
+    function test_short() public returns (uint256 r) {
+        assembly {
+            sstore(data.slot, 0)
+        }
+        for (uint8 i = 0; i < 15; i++) {
+            data.push(bytes1(i));
+        }
+        assembly {
+            r := sload(data.slot)
+        }
+    }
+
+    function test_long() public returns (uint256 r) {
+        assembly {
+            sstore(data.slot, 0)
+        }
+        for (uint8 i = 0; i < 33; i++) {
+            data.push(bytes1(i));
+        }
+        assembly {
+            r := sload(data.slot)
+        }
+    }
+
+    function test_pop() public returns (uint256 r) {
+        assembly {
+            sstore(data.slot, 0)
+        }
+        for (uint8 i = 0; i < 32; i++) {
+            data.push(bytes1(i));
+        }
+        data.pop();
+        data.pop();
+        assembly {
+            r := sload(data.slot)
+        }
+    }
+}
+// ----
+// storageEmpty -> 1
+// test_short() -> 1780731860627700044960722568376587075150542249149356309979516913770823710
+// gas legacy: 59838
+// gas legacyOptimized: 58606
+// storageEmpty -> 0
+// test_long() -> 67
+// gas irOptimized: 89148
+// gas legacy: 101601
+// gas legacyOptimized: 100477
+// storageEmpty -> 0
+// test_pop() -> 1780731860627700044960722568376592200742329637303199754547598369979433020
+// gas legacy: 61930
+// gas legacyOptimized: 59404
+// storageEmpty -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol b/compiler/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol
new file mode 100644
index 00000000..3e0f0222
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol
@@ -0,0 +1,22 @@
+// Tests transition between short and long encoding both ways
+contract c {
+    bytes data;
+
+    function test() public returns (uint256) {
+        for (uint8 i = 0; i < 33; i++) {
+            data.push(bytes1(i));
+        }
+        for (uint8 i = 0; i < data.length; i++)
+            if (data[i] != bytes1(i)) return i;
+        data.pop();
+        data.pop();
+        for (uint8 i = 0; i < data.length; i++)
+            if (data[i] != bytes1(i)) return i;
+        return 0;
+    }
+}
+// ----
+// test() -> 0
+// gas irOptimized: 123560
+// gas legacy: 147098
+// gas legacyOptimized: 144200
diff --git a/compiler/test/libsolidity/semanticTests/array/bytes_length_member.sol b/compiler/test/libsolidity/semanticTests/array/bytes_length_member.sol
new file mode 100644
index 00000000..0a3c58b3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/bytes_length_member.sol
@@ -0,0 +1,19 @@
+contract c {
+    function set() public returns (bool) {
+        data = msg.data;
+        return true;
+    }
+
+    function getLength() public returns (uint256) {
+        return data.length;
+    }
+
+    bytes data;
+}
+// ----
+// getLength() -> 0
+// set(): 1, 2 -> true
+// gas irOptimized: 110393
+// gas legacy: 110952
+// gas legacyOptimized: 110576
+// getLength() -> 68
diff --git a/compiler/test/libsolidity/semanticTests/array/calldata_array.sol b/compiler/test/libsolidity/semanticTests/array/calldata_array.sol
new file mode 100644
index 00000000..c524d06e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/calldata_array.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(uint256[2] calldata s)
+        external
+        pure
+        returns (uint256 a, uint256 b)
+    {
+        a = s[0];
+        b = s[1];
+    }
+}
+// ----
+// f(uint256[2]): 42, 23 -> 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/array/calldata_array_as_argument_internal_function.sol b/compiler/test/libsolidity/semanticTests/array/calldata_array_as_argument_internal_function.sol
new file mode 100644
index 00000000..d21c40ca
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/calldata_array_as_argument_internal_function.sol
@@ -0,0 +1,17 @@
+pragma abicoder v2;
+contract Test {
+    function f(uint256[] calldata c) internal returns (uint a, uint b) {
+        return (c.length, c[0]);
+    }
+
+    function g(uint256[] calldata c) external returns (uint a, uint b) {
+        return f(c);
+    }
+
+    function h(uint256[] calldata c, uint start, uint end) external returns (uint a, uint b) {
+        return f(c[start: end]);
+    }
+}
+// ----
+// g(uint256[]): 0x20, 4, 1, 2, 3, 4 -> 4, 1
+// h(uint256[],uint256,uint256): 0x60, 1, 3, 4, 1, 2, 3, 4 -> 2, 2
diff --git a/compiler/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol b/compiler/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol
new file mode 100644
index 00000000..dc1d1c31
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/calldata_array_dynamic_invalid.sol
@@ -0,0 +1,20 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(uint256[][] calldata a) external returns (uint256) {
+        return 42;
+    }
+
+    function g(uint256[][] calldata a) external returns (uint256) {
+        a[0];
+        return 42;
+    }
+}
+// ----
+// f(uint256[][]): 0x20, 0x0 -> 42 # valid access stub #
+// f(uint256[][]): 0x20, 0x1 -> FAILURE # invalid on argument decoding #
+// f(uint256[][]): 0x20, 0x1, 0x20 -> 42 # invalid on outer access #
+// g(uint256[][]): 0x20, 0x1, 0x20 -> FAILURE
+// f(uint256[][]): 0x20, 0x1, 0x20, 0x2, 0x42 -> 42 # invalid on inner access #
+// g(uint256[][]): 0x20, 0x1, 0x20, 0x2, 0x42 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol b/compiler/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol
new file mode 100644
index 00000000..006bf252
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/calldata_array_of_struct.sol
@@ -0,0 +1,23 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f(S[] calldata s)
+        external
+        pure
+        returns (uint256 l, uint256 a, uint256 b, uint256 c, uint256 d)
+    {
+        l = s.length;
+        a = s[0].a;
+        b = s[0].b;
+        c = s[1].a;
+        d = s[1].b;
+    }
+}
+// ----
+// f((uint256,uint256)[]): 0x20, 0x2, 0x1, 0x2, 0x3, 0x4 -> 2, 1, 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/array/calldata_slice_access.sol b/compiler/test/libsolidity/semanticTests/array/calldata_slice_access.sol
new file mode 100644
index 00000000..76af2214
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/calldata_slice_access.sol
@@ -0,0 +1,44 @@
+contract C {
+    function f(uint256[] calldata x, uint256 start, uint256 end) external pure {
+        x[start:end];
+    }
+    function g(uint256[] calldata x, uint256 start, uint256 end, uint256 index) external pure returns (uint256, uint256, uint256) {
+        return (x[start:end][index], x[start:][0:end-start][index], x[:end][start:][index]);
+    }
+}
+// ----
+// f(uint256[],uint256,uint256): 0x80, 0, 0, 0, 1, 42 ->
+// f(uint256[],uint256,uint256): 0x80, 0, 1, 0, 1, 42 ->
+// f(uint256[],uint256,uint256): 0x80, 0, 2, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 1, 0, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 1, 1, 0, 1, 42 ->
+// f(uint256[],uint256,uint256): 0x80, 1, 2, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 2, 0, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 2, 1, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 2, 2, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 0, 2, 1, 0, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, 1, 2, 0, 2, 42, 23 ->
+// f(uint256[],uint256,uint256): 0x80, 1, 3, 0, 2, 42, 23 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, -1, 0, 0, 1, 42 -> FAILURE
+// f(uint256[],uint256,uint256): 0x80, -1, -1, 0, 1, 42 -> FAILURE
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 0, 1, 42 -> 42, 42, 42
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 1, 1, 42 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 0, 0, 1, 42 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 1, 0, 1, 42 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 5, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4201, 0x4201, 0x4201
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 5, 4, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4205, 0x4205, 0x4205
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 5, 5, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 5, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4202, 0x4202, 0x4202
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 5, 3, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4205, 0x4205, 0x4205
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 5, 4, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 4, 5, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4205, 0x4205, 0x4205
+// g(uint256[],uint256,uint256,uint256): 0x80, 4, 5, 1, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 5, 5, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4201, 0x4201, 0x4201
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 1, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4201, 0x4201, 0x4201
+// g(uint256[],uint256,uint256,uint256): 0x80, 0, 1, 1, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 2, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4202, 0x4202, 0x4202
+// g(uint256[],uint256,uint256,uint256): 0x80, 1, 2, 1, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
+// g(uint256[],uint256,uint256,uint256): 0x80, 4, 5, 0, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> 0x4205, 0x4205, 0x4205
+// g(uint256[],uint256,uint256,uint256): 0x80, 4, 5, 1, 5, 0x4201, 0x4202, 0x4203, 0x4204, 0x4205 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_argument_list.sol b/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_argument_list.sol
new file mode 100644
index 00000000..7041ff85
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_argument_list.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bytes memory) {
+        return bytes.concat();
+    }
+}
+// ----
+// f() -> 0x20, 0
diff --git a/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_strings.sol b/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_strings.sol
new file mode 100644
index 00000000..10d31162
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/concat/bytes_concat_empty_strings.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f() public returns (bytes memory) {
+        bytes memory b = "";
+        return bytes.concat(
+            bytes.concat(b),
+            bytes.concat(b, b),
+            bytes.concat("", b),
+            bytes.concat(b, "")
+        );
+    }
+
+    function g() public returns (bytes memory) {
+        return bytes.concat("", "abc", hex"", "abc", unicode"");
+    }
+
+    function h() public returns (bytes memory) {
+        bytes memory b = "";
+        return bytes.concat(b, "abc", b, "abc", b);
+    }
+}
+// ----
+// f() -> 0x20, 0
+// g() -> 0x20, 6, "abcabc"
+// h() -> 0x20, 6, "abcabc"
diff --git a/compiler/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol b/compiler/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol
new file mode 100644
index 00000000..ca65f070
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol
@@ -0,0 +1,16 @@
+contract C {
+    uint256 constant LEN = 3;
+    uint256[LEN] public a;
+
+    constructor(uint256[LEN] memory _a) {
+        a = _a;
+    }
+}
+// ----
+// constructor(): 1, 2, 3 ->
+// gas irOptimized: 139656
+// gas legacy: 180517
+// gas legacyOptimized: 150462
+// a(uint256): 0 -> 1
+// a(uint256): 1 -> 2
+// a(uint256): 2 -> 3
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_calldata_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_calldata_storage.sol
new file mode 100644
index 00000000..80ecd3e1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_calldata_storage.sol
@@ -0,0 +1,26 @@
+contract c {
+    uint[9] m_data;
+    uint[] m_data_dyn;
+    uint8[][] m_byte_data;
+    function store(uint[9] calldata a, uint8[3][] calldata b) external returns (uint8) {
+        m_data = a;
+        m_data_dyn = a;
+        m_byte_data = b;
+        return b[3][1]; // note that access and declaration are reversed to each other
+    }
+    function retrieve() public returns (uint a, uint b, uint c, uint d, uint e, uint f, uint g) {
+        a = m_data.length;
+        b = m_data[7];
+        c = m_data_dyn.length;
+        d = m_data_dyn[7];
+        e = m_byte_data.length;
+        f = m_byte_data[3].length;
+        g = m_byte_data[3][1];
+    }
+}
+// ----
+// store(uint256[9],uint8[3][]): 21, 22, 23, 24, 25, 26, 27, 28, 29, 0x140, 4, 1, 2, 3, 11, 12, 13, 21, 22, 23, 31, 32, 33 -> 32
+// gas irOptimized: 648315
+// gas legacy: 694356
+// gas legacyOptimized: 693864
+// retrieve() -> 9, 28, 9, 28, 4, 3, 32
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol
new file mode 100644
index 00000000..600f00a9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol
@@ -0,0 +1,51 @@
+// Issue 9832: Test to see if cleanup is performed properly after array copying
+contract C {
+    uint40[] x;
+    function f() public returns(bool) {
+
+        x.push(42); x.push(42); x.push(42); x.push(42);
+        x.push(42); x.push(42); x.push(42); x.push(42);
+        x.push(42); x.push(42); x.push(42); x.push(42);
+        x.push(42); x.push(42); x.push(42); x.push(42);
+        x.push(42); x.push(42); x.push(42); x.push(42);
+
+        uint40[] memory y = new uint40[](1);
+        y[0] = 23;
+        x = y;
+
+        assembly { sstore(x.slot, 20) }
+
+        assert(x[0] == 23);
+        assert(x[1] == 0);
+        assert(x[2] == 0);
+        assert(x[3] == 0);
+
+        assert(x[4] == 0);
+        assert(x[5] == 0);
+        assert(x[6] == 0);
+        assert(x[7] == 0);
+
+        assert(x[8] == 0);
+        assert(x[9] == 0);
+        assert(x[10] == 0);
+        assert(x[11] == 0);
+
+        assert(x[12] == 0);
+        assert(x[13] == 0);
+        assert(x[14] == 0);
+        assert(x[15] == 0);
+
+        assert(x[16] == 0);
+        assert(x[17] == 0);
+        assert(x[18] == 0);
+        assert(x[19] == 0);
+
+        return true;
+
+    }
+}
+// ----
+// f() -> true
+// gas irOptimized: 117264
+// gas legacy: 124660
+// gas legacyOptimized: 122801
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage.sol
new file mode 100644
index 00000000..0bdcda1d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage.sol
@@ -0,0 +1,18 @@
+contract C {
+    uint256[] x;
+    function f() public returns(uint256) {
+        x.push(42); x.push(42); x.push(42); x.push(42);
+        uint256[] memory y = new uint256[](1);
+        y[0] = 23;
+        x = y;
+        assembly { sstore(x.slot, 4) }
+        assert(x[1] == 0);
+        assert(x[2] == 0);
+        return x[3];
+    }
+}
+// ----
+// f() -> 0
+// gas irOptimized: 107453
+// gas legacy: 108218
+// gas legacyOptimized: 107625
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol
new file mode 100644
index 00000000..6e81269d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol
@@ -0,0 +1,23 @@
+contract c {
+    bytes8[] data1; // 4 per slot
+    bytes10[] data2; // 3 per slot
+
+    function test()
+        public
+        returns (bytes10 a, bytes10 b, bytes10 c, bytes10 d, bytes10 e)
+    {
+        data1 = new bytes8[](9);
+        for (uint256 i = 0; i < data1.length; ++i) data1[i] = bytes8(uint64(i));
+        data2 = data1;
+        a = data2[1];
+        b = data2[2];
+        c = data2[3];
+        d = data2[4];
+        e = data2[5];
+    }
+}
+// ----
+// test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x05000000000000000000000000000000000000000000000000
+// gas irOptimized: 207889
+// gas legacy: 220707
+// gas legacyOptimized: 220098
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_including_array.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_including_array.sol
new file mode 100644
index 00000000..385f2ecf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_including_array.sol
@@ -0,0 +1,46 @@
+contract c {
+    uint[3][90][] large;
+    uint[3][3][] small;
+    function test() public returns (uint r) {
+        for (uint i = 0; i < 7; i++) {
+            large.push();
+            small.push();
+        }
+        large[3][2][0] = 2;
+        large[1] = large[3];
+        small[3][2][0] = 2;
+        small[1] = small[2];
+        r = ((
+            small[3][2][0] * 0x100 |
+            small[1][2][0]) * 0x100 |
+            large[3][2][0]) * 0x100 |
+            large[1][2][0];
+        delete small;
+        delete large;
+
+    }
+    function clear() public returns (uint, uint) {
+        for (uint i = 0; i < 7; i++) {
+            large.push();
+            small.push();
+        }
+        small[3][2][0] = 0;
+        large[3][2][0] = 0;
+        while (small.length > 0)
+            small.pop();
+        while (large.length > 0)
+            large.pop();
+        return (small.length, large.length);
+    }
+}
+// ----
+// test() -> 0x02000202
+// gas irOptimized: 4547793
+// gas legacy: 4475396
+// gas legacyOptimized: 4447665
+// storageEmpty -> 1
+// clear() -> 0, 0
+// gas irOptimized: 4474777
+// gas legacy: 4407188
+// gas legacyOptimized: 4381336
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_nested_array.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_nested_array.sol
new file mode 100644
index 00000000..737e4b32
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_nested_array.sol
@@ -0,0 +1,17 @@
+contract c {
+    uint256[4][] a;
+    uint256[10][] b;
+    uint256[][] c;
+
+    function test(uint256[2][] calldata d) external returns (uint256) {
+        a = d;
+        b = a;
+        c = b;
+        return c[1][1] | c[1][2] | c[1][3] | c[1][4];
+    }
+}
+// ----
+// test(uint256[2][]): 32, 3, 7, 8, 9, 10, 11, 12 -> 10
+// gas irOptimized: 689656
+// gas legacy: 686178
+// gas legacyOptimized: 685628
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_abi_signed.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_abi_signed.sol
new file mode 100644
index 00000000..335afd0a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_abi_signed.sol
@@ -0,0 +1,19 @@
+// NOTE: This does not really test copying from storage to ABI directly,
+// because it will always copy to memory first.
+contract c {
+    int16[] x;
+
+    function test() public returns (int16[] memory) {
+        x.push(int16(-1));
+        x.push(int16(-1));
+        x.push(int16(8));
+        x.push(int16(-16));
+        x.push(int16(-2));
+        x.push(int16(6));
+        x.push(int16(8));
+        x.push(int16(-1));
+        return x;
+    }
+}
+// ----
+// test() -> 0x20, 0x8, -1, -1, 8, -16, -2, 6, 8, -1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol
new file mode 100644
index 00000000..d477dc6c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol
@@ -0,0 +1,22 @@
+contract c {
+    uint64[] data1;
+    uint256[] data2;
+
+    function test() public returns (uint256 x, uint256 y) {
+        data2.push(11);
+        data1.push(0);
+        data1.push(1);
+        data1.push(2);
+        data1.push(3);
+        data1.push(4);
+        data2 = data1;
+        assert(data1[0] == data2[0]);
+        x = data2.length;
+        y = data2[4];
+    }
+}
+// ----
+// test() -> 5, 4
+// gas irOptimized: 205044
+// gas legacy: 213863
+// gas legacyOptimized: 212902
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol
new file mode 100644
index 00000000..05711958
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol
@@ -0,0 +1,26 @@
+contract c {
+    uint48[5][2] data1;
+    uint120[6][3] data2;
+
+    function test() public returns (uint256 x, uint120 y) {
+        data2[0][0] = 11;
+        data2[1][0] = 22;
+        data2[2][0] = 33;
+
+        data1[0][0] = 0;
+        data1[0][1] = 1;
+        data1[0][2] = 2;
+        data1[0][3] = 3;
+        data1[0][4] = 4;
+        data1[1][0] = 3;
+        data2 = data1;
+        assert(data1[0][1] == data2[0][1]);
+        x = data2.length;
+        y = data2[0][4];
+    }
+}
+// ----
+// test() -> 3, 4
+// gas irOptimized: 169565
+// gas legacy: 175424
+// gas legacyOptimized: 172535
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol
new file mode 100644
index 00000000..99dd1ca9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol
@@ -0,0 +1,25 @@
+
+contract c {
+    uint[] data1;
+    uint[] data2;
+    function setData1(uint length, uint index, uint value) public {
+        data1 = new uint[](length);
+        if (index < length)
+            data1[index] = value;
+    }
+    function copyStorageStorage() public { data2 = data1; }
+    function getData2(uint index) public returns (uint len, uint val) {
+        len = data2.length; if (index < len) val = data2[index];
+    }
+}
+// ----
+// setData1(uint256,uint256,uint256): 10, 5, 4 ->
+// copyStorageStorage() ->
+// gas irOptimized: 111348
+// gas legacy: 109272
+// gas legacyOptimized: 109262
+// getData2(uint256): 5 -> 10, 4
+// setData1(uint256,uint256,uint256): 0, 0, 0 ->
+// copyStorageStorage() ->
+// getData2(uint256): 0 -> 0, 0
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dynamic_dynamic.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dynamic_dynamic.sol
new file mode 100644
index 00000000..30173409
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dynamic_dynamic.sol
@@ -0,0 +1,22 @@
+contract c {
+    uint256[] data1;
+    uint256[] data2;
+
+    function test() public returns (uint256 x, uint256 y) {
+        data2.push(11);
+        data1.push(0);
+        data1.push(1);
+        data1.push(2);
+        data1.push(3);
+        data1.push(4);
+        data2 = data1;
+        assert(data1[0] == data2[0]);
+        x = data2.length;
+        y = data2[4];
+    }
+}
+// ----
+// test() -> 5, 4
+// gas irOptimized: 252929
+// gas legacy: 250892
+// gas legacyOptimized: 250046
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_dynamic.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_dynamic.sol
new file mode 100644
index 00000000..971469de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_dynamic.sol
@@ -0,0 +1,16 @@
+contract c {
+    uint256[9] data1;
+    uint256[] data2;
+
+    function test() public returns (uint256 x, uint256 y) {
+        data1[8] = 4;
+        data2 = data1;
+        x = data2.length;
+        y = data2[8];
+    }
+}
+// ----
+// test() -> 9, 4
+// gas irOptimized: 123135
+// gas legacy: 123567
+// gas legacyOptimized: 123202
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol
new file mode 100644
index 00000000..2fccff77
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol
@@ -0,0 +1,15 @@
+contract C {
+    bytes1[2] data1;
+    bytes2[2] data2;
+    function test() public returns (bytes2, bytes2) {
+        uint i;
+        for (i = 0; i < data1.length; ++i)
+            data1[i] = bytes1(uint8(1 + i));
+        data2 = data1;
+        return (data2[0], data2[1]);
+    }
+}
+// ----
+// test() -> left(0x01), left(0x02)
+// gas legacy: 90001
+// gas legacyOptimized: 89085
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_static.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_static.sol
new file mode 100644
index 00000000..0d613e5e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_static.sol
@@ -0,0 +1,19 @@
+contract c {
+    uint256[40] data1;
+    uint256[20] data2;
+
+    function test() public returns (uint256 x, uint256 y) {
+        data1[30] = 4;
+        data1[2] = 7;
+        data1[3] = 9;
+        data2[3] = 8;
+        data1 = data2;
+        x = data1[3];
+        y = data1[30]; // should be cleared
+    }
+}
+// ----
+// test() -> 8, 0
+// gas irOptimized: 196259
+// gas legacy: 194843
+// gas legacyOptimized: 194281
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol
new file mode 100644
index 00000000..cfb62339
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol
@@ -0,0 +1,23 @@
+contract c {
+    struct Data { uint x; uint y; }
+    Data[] data1;
+    Data[] data2;
+    function test() public returns (uint x, uint y) {
+        while (data1.length < 9)
+            data1.push();
+        data1[8].x = 4;
+        data1[8].y = 5;
+        data2 = data1;
+        x = data2[8].x;
+        y = data2[8].y;
+        while (data1.length > 0)
+            data1.pop();
+        data2 = data1;
+    }
+}
+// ----
+// test() -> 4, 5
+// gas irOptimized: 190694
+// gas legacy: 190852
+// gas legacyOptimized: 189658
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_to_memory_nested.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_to_memory_nested.sol
new file mode 100644
index 00000000..6bd31ca5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_storage_to_memory_nested.sol
@@ -0,0 +1,20 @@
+pragma abicoder v2;
+contract C {
+    uint[][] a;
+
+    function f() public returns (uint[][] memory) {
+        a.push();
+        a.push();
+        a[0].push(0);
+        a[0].push(1);
+        a[1].push(2);
+        a[1].push(3);
+        uint[][] memory m = a;
+        return m;
+    }
+}
+// ----
+// f() -> 0x20, 2, 0x40, 0xa0, 2, 0, 1, 2, 2, 3
+// gas irOptimized: 161624
+// gas legacy: 162203
+// gas legacyOptimized: 159934
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol
new file mode 100644
index 00000000..10a48a18
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol
@@ -0,0 +1,22 @@
+contract c {
+    bytes1[10] data1;
+    bytes2[32] data2;
+    function test() public returns (uint check, uint res1, uint res2) {
+        uint i;
+        for (i = 0; i < data2.length; ++i)
+            data2[i] = 0xffff;
+        check = uint(uint16(data2[31])) * 0x10000 | uint(uint16(data2[14]));
+        for (i = 0; i < data1.length; ++i)
+            data1[i] = bytes1(uint8(1 + i));
+        data2 = data1;
+        for (i = 0; i < 16; ++i)
+            res1 |= uint(uint16(data2[i])) * 0x10000**i;
+        for (i = 0; i < 16; ++i)
+            res2 |= uint(uint16(data2[16 + i])) * 0x10000**i;
+    }
+}
+// ----
+// test() -> 0xffffffff, 0x0000000000000000000000000a00090008000700060005000400030002000100, 0x0000000000000000000000000000000000000000000000000000000000000000
+// gas irOptimized: 100980
+// gas legacy: 158142
+// gas legacyOptimized: 141096
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol
new file mode 100644
index 00000000..0a2bcffc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol
@@ -0,0 +1,24 @@
+// since the copy always copies whole slots, we have to make sure that the source size maxes
+// out a whole slot and at the same time there are still elements left in the target at that point
+contract c {
+    bytes8[4] data1; // fits into one slot
+    bytes10[6] data2; // 4 elements need two slots
+
+    function test() public returns (bytes10 r1, bytes10 r2, bytes10 r3) {
+        data1[0] = bytes8(uint64(1));
+        data1[1] = bytes8(uint64(2));
+        data1[2] = bytes8(uint64(3));
+        data1[3] = bytes8(uint64(4));
+        for (uint256 i = 0; i < data2.length; ++i)
+            data2[i] = bytes10(uint80(0xffff00 | (1 + i)));
+        data2 = data1;
+        r1 = data2[3];
+        r2 = data2[4];
+        r3 = data2[5];
+    }
+}
+// ----
+// test() -> 0x04000000000000000000000000000000000000000000000000, 0x0, 0x0
+// gas irOptimized: 93858
+// gas legacy: 97451
+// gas legacyOptimized: 94200
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol
new file mode 100644
index 00000000..a839e3bb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol
@@ -0,0 +1,23 @@
+contract c {
+    bytes8[9] data1; // 4 per slot
+    bytes17[10] data2; // 1 per slot, no offset counter
+
+    function test()
+        public
+        returns (bytes17 a, bytes17 b, bytes17 c, bytes17 d, bytes17 e)
+    {
+        for (uint256 i = 0; i < data1.length; ++i) data1[i] = bytes8(uint64(i));
+        data2[8] = data2[9] = bytes8(uint64(2));
+        data2 = data1;
+        a = data2[1];
+        b = data2[2];
+        c = data2[3];
+        d = data2[4];
+        e = data2[9];
+    }
+}
+// ----
+// test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x0
+// gas irOptimized: 273372
+// gas legacy: 282604
+// gas legacyOptimized: 281510
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol
new file mode 100644
index 00000000..f9e1cbd2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol
@@ -0,0 +1,23 @@
+contract c {
+    bytes9[7] data1; // 3 per slot
+    bytes32[10] data2; // 1 per slot
+
+    function test()
+        public
+        returns (bytes32 a, bytes32 b, bytes32 c, bytes32 d, bytes32 e)
+    {
+        for (uint256 i = 0; i < data1.length; ++i) data1[i] = bytes8(uint64(i));
+        data2[8] = data2[9] = bytes8(uint64(2));
+        data2 = data1;
+        a = data2[1];
+        b = data2[2];
+        c = data2[3];
+        d = data2[4];
+        e = data2[9];
+    }
+}
+// ----
+// test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x00
+// gas irOptimized: 233118
+// gas legacy: 235697
+// gas legacyOptimized: 235193
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol
new file mode 100644
index 00000000..b1e8659b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol
@@ -0,0 +1,60 @@
+pragma abicoder v2;
+
+contract C {
+    mapping (uint => uint8[][]) m;
+
+    uint8[][] s;
+
+    constructor() {
+        s = new uint8[][](2);
+
+        s[0] = new uint8[](2);
+        s[0][0] = 10;
+        s[0][1] = 11;
+
+        s[1] = new uint8[](3);
+        s[1][0] = 12;
+        s[1][1] = 13;
+        s[1][2] = 14;
+    }
+
+    function from_storage() public returns (uint8[][] memory) {
+        m[0] = new uint8[][](2);
+        m[0][0] = s[0];
+        m[0][1] = s[1];
+        return m[0];
+    }
+
+
+    function from_storage_ptr() public returns (uint8[][] memory) {
+        uint8[][] storage sPtr = s;
+        m[0] = new uint8[][](2);
+        m[0][0] = sPtr[0];
+        m[0][1] = sPtr[1];
+        return m[0];
+    }
+
+
+    function from_memory() public returns (uint8[][] memory) {
+        uint8[][] memory a = s;
+        m[0] = new uint8[][](2);
+        m[0][0] = a[0];
+        m[0][1] = a[1];
+        return m[0];
+    }
+
+    function from_calldata(uint8[][] calldata _a) public returns (uint8[][] memory) {
+        m[0] = new uint8[][](2);
+        m[0][0] = _a[0];
+        m[0][1] = _a[1];
+        return m[0];
+    }
+}
+// ----
+// from_storage() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// gas irOptimized: 150004
+// gas legacy: 150745
+// gas legacyOptimized: 148678
+// from_storage_ptr() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// from_memory() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// from_calldata(uint8[][]): 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol
new file mode 100644
index 00000000..919e8329
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_calldata_to_storage.sol
@@ -0,0 +1,47 @@
+pragma abicoder               v2;
+
+contract c {
+    uint256[][] a1;
+    uint256[][2] a2;
+    uint256[2][] a3;
+    uint256[2][2] a4;
+
+    function test1(uint256[][] calldata c) external returns (uint256, uint256) {
+        a1 = c;
+        assert(a1[0][0] == c[0][0]);
+        assert(a1[0][1] == c[0][1]);
+        return (a1.length, a1[0][0] + a1[1][1]);
+    }
+
+    function test2(uint256[][2] calldata c) external returns (uint256, uint256) {
+        a2 = c;
+        assert(a2[0][0] == c[0][0]);
+        assert(a2[0][1] == c[0][1]);
+        return (a2[0].length, a2[0][0] + a2[1][1]);
+    }
+
+    function test3(uint256[2][] calldata c) external returns (uint256, uint256) {
+        a3 = c;
+        assert(a3[0][0] == c[0][0]);
+        assert(a3[0][1] == c[0][1]);
+        return (a3.length, a3[0][0] + a3[1][1]);
+    }
+
+    function test4(uint256[2][2] calldata c) external returns (uint256) {
+        a4 = c;
+        assert(a4[0][0] == c[0][0]);
+        assert(a4[0][1] == c[0][1]);
+        return (a4[0][0] + a4[1][1]);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 23, 42 -> 2, 65
+// gas irOptimized: 180716
+// test2(uint256[][2]): 0x20, 0x40, 0x40, 2, 23, 42 -> 2, 65
+// gas irOptimized: 157544
+// test3(uint256[2][]): 0x20, 2, 23, 42, 23, 42 -> 2, 65
+// gas irOptimized: 134634
+// test4(uint256[2][2]): 23, 42, 23, 42 -> 65
+// gas irOptimized: 111252
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_nested_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_memory_to_storage.sol
new file mode 100644
index 00000000..eb4b1bbb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_memory_to_storage.sol
@@ -0,0 +1,49 @@
+contract Test {
+    uint128[13] unused;
+    uint256[][] a;
+    uint256[4][] b;
+    uint256[2][3] c;
+
+    function test() external returns (uint256) {
+        uint256[][] memory m = new uint256[][](2);
+        m[0] = new uint256[](3);
+        m[0][0] = 7; m[0][1] = 8; m[0][2] = 9;
+        m[1] = new uint256[](4);
+        m[1][1] = 7; m[1][2] = 8; m[1][3] = 9;
+        a = m;
+        return a[0][0] + a[0][1] + a[1][3];
+    }
+
+    function test1() external returns (uint256) {
+        uint256[2][] memory m = new uint256[2][](1);
+        m[0][0] = 1; m[0][1] = 2;
+        b = m;
+        return b[0][0] + b[0][1];
+    }
+
+    function test2() external returns (uint256) {
+        uint256[2][2] memory m;
+        m[0][0] = 1; m[1][1] = 2; m[0][1] = 3;
+        c = m;
+        return c[0][0] + c[1][1] + c[0][1];
+    }
+
+    function test3() external returns (uint256) {
+        uint256[2][3] memory m;
+        m[0][0] = 7; m[1][0] = 8; m[2][0] = 9;
+        m[0][1] = 7; m[1][1] = 8; m[2][1] = 9;
+        a = m;
+        return a[0][0] + a[1][0] + a[2][1];
+    }
+}
+// ----
+// test() -> 24
+// gas irOptimized: 226666
+// gas legacy: 227084
+// gas legacyOptimized: 226529
+// test1() -> 3
+// test2() -> 6
+// test3() -> 24
+// gas irOptimized: 141225
+// gas legacy: 142238
+// gas legacyOptimized: 141365
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_nested_storage_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_storage_to_memory.sol
new file mode 100644
index 00000000..ebaada76
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_nested_storage_to_memory.sol
@@ -0,0 +1,44 @@
+pragma abicoder v2;
+
+contract C {
+    uint256[][] a1;
+    uint256[][2] a2;
+    uint256[2][] a3;
+    uint256[2][2] a4;
+
+    constructor() {
+        a1 = new uint256[][](2);
+        a1[0] = [1, 2];
+        a1[1] = [3, 4, 5];
+
+        a2[0] = [6, 7, 8];
+        a2[1] = [9];
+
+        a3.push([1, 2]);
+        a3.push([3, 4]);
+        a3.push([5, 6]);
+
+        a4 = [[10, 11], [12, 13]];
+    }
+
+    function test1() external returns (uint256[][] memory) {
+        return a1;
+    }
+
+    function test2() external returns (uint256[][2] memory) {
+        return a2;
+    }
+
+    function test3() external returns (uint256[2][] memory) {
+        return a3;
+    }
+
+    function test4() external returns (uint256[2][2] memory) {
+        return a4;
+    }
+}
+// ----
+// test1() -> 0x20, 2, 0x40, 0xa0, 2, 1, 2, 3, 3, 4, 5
+// test2() -> 0x20, 0x40, 0xc0, 3, 6, 7, 8, 1, 9
+// test3() -> 0x20, 3, 1, 2, 3, 4, 5, 6
+// test4() -> 10, 11, 12, 13
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol
new file mode 100644
index 00000000..01329504
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol
@@ -0,0 +1,51 @@
+contract C {
+    function testFunction1() public {}
+    function testFunction2() public {}
+    function testFunction3() public {}
+
+
+    function() external [] externalArray0;
+    function() external [] externalArray1;
+
+    function() internal [] internalArray0;
+    function() internal [] internalArray1;
+
+    constructor() {
+        externalArray0 = new function() external[] (3);
+        externalArray1 = [
+            this.testFunction1,
+            this.testFunction2,
+            this.testFunction3
+        ];
+
+        internalArray0 = new function() internal[] (3);
+        internalArray1 = [
+            testFunction1,
+            testFunction2,
+            testFunction3
+        ];
+    }
+
+    function copyExternalStorageArrayOfFunctionType() external returns (bool) {
+        assert(keccak256(abi.encode(externalArray0)) != keccak256(abi.encode(externalArray1)));
+        externalArray0 = externalArray1;
+        return keccak256(abi.encode(externalArray0)) == keccak256(abi.encode(externalArray1));
+    }
+
+    function copyInternalArrayOfFunctionType() external returns (bool) {
+        internalArray0 = internalArray1;
+        assert(internalArray0.length == 3);
+
+        return
+            internalArray0.length == internalArray1.length &&
+            internalArray0[0] == internalArray1[0] &&
+            internalArray0[1] == internalArray1[1] &&
+            internalArray0[2] == internalArray1[2];
+    }
+}
+// ----
+// copyExternalStorageArrayOfFunctionType() -> true
+// gas irOptimized: 104592
+// gas legacy: 108554
+// gas legacyOptimized: 102413
+// copyInternalArrayOfFunctionType() -> true
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol
new file mode 100644
index 00000000..50756d0b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol
@@ -0,0 +1,55 @@
+contract C {
+    function testFunction1() public {}
+    function testFunction2() public view {}
+    function testFunction3() public pure {}
+
+
+    function() external [] externalArray0;
+    function() external [] externalArray1;
+
+    function() internal [] internalArray0;
+    function() internal [] internalArray1;
+
+    constructor() {
+        externalArray0 = new function() external[] (3);
+        externalArray1 = [
+            this.testFunction1,
+            this.testFunction2,
+            this.testFunction3
+        ];
+
+        internalArray0 = new function() internal[] (3);
+        internalArray1 = [
+            testFunction1,
+            testFunction2,
+            testFunction3
+        ];
+    }
+
+
+    function copyExternalStorageArraysOfFunctionType() external returns (bool)
+    {
+        assert(keccak256(abi.encodePacked(externalArray0)) != keccak256(abi.encodePacked(externalArray1)));
+        externalArray0 = externalArray1;
+        return keccak256(abi.encodePacked(externalArray0)) == keccak256(abi.encodePacked(externalArray1));
+    }
+
+    function copyInternalArrayOfFunctionType() external returns (bool)
+    {
+        internalArray0 = internalArray1;
+        assert(internalArray0.length == 3);
+
+        return
+            internalArray0.length == internalArray1.length &&
+            internalArray0[0] == internalArray1[0] &&
+            internalArray0[1] == internalArray1[1] &&
+            internalArray0[2] == internalArray1[2];
+    }
+}
+// ----
+// copyExternalStorageArraysOfFunctionType() -> true
+// gas irOptimized: 104265
+// gas legacy: 108295
+// gas legacyOptimized: 102146
+// copyInternalArrayOfFunctionType() -> true
+// gas legacy: 104178
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol
new file mode 100644
index 00000000..546a6e49
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol
@@ -0,0 +1,20 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint128 a;
+        uint64 b;
+        uint128 c;
+    }
+    uint128[137] unused;
+    S[] s;
+    function f(S[] calldata c) public returns (uint128, uint64, uint128) {
+        s = c;
+        return (s[2].a, s[1].b, s[0].c);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f((uint128,uint64,uint128)[]): 0x20, 3, 0, 0, 12, 0, 11, 0, 10, 0, 0 -> 10, 11, 12
+// gas irOptimized: 119704
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol
new file mode 100644
index 00000000..38e26e48
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol
@@ -0,0 +1,22 @@
+contract C {
+    struct S {
+        uint128 a;
+        uint64 b;
+        uint128 c;
+    }
+    uint128[137] unused;
+    S[] s;
+    function f() public returns (uint128, uint64, uint128) {
+        S[] memory m = new S[](3);
+        m[2].a = 10;
+        m[1].b = 11;
+        m[0].c = 12;
+        s = m;
+        return (s[2].a, s[1].b, s[0].c);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 10, 11, 12
+// gas irOptimized: 118362
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol
new file mode 100644
index 00000000..c6e6c587
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint256[] a;
+    }
+
+    S[] s;
+
+    function f(S[] calldata c) external returns (uint256, uint256) {
+        s = c;
+        assert(s.length == c.length);
+        for (uint i = 0; i < s.length; i++) {
+            assert(s[i].a.length == c[i].a.length);
+            for (uint j = 0; j < s[i].a.length; j++) {
+                assert(s[i].a[j] == c[i].a[j]);
+            }
+        }
+        return (s[1].a.length, s[1].a[0]);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f((uint256[])[]): 0x20, 3, 0x60, 0x60, 0x60, 0x20, 3, 1, 2, 3 -> 3, 1
+// gas irOptimized: 326771
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol
new file mode 100644
index 00000000..510e7c9a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol
@@ -0,0 +1,29 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint136 p;
+        uint128[3] b;
+        uint128[] c;
+    }
+
+    S[] s;
+
+    function f() external returns (uint256, uint256, uint128, uint128) {
+        S[] memory m = new S[](3);
+        m[1] = S(0, [uint128(1), 2, 3], new uint128[](3));
+        m[1].c[0] = 1;
+        m[1].c[1] = 2;
+        m[1].c[2] = 3;
+        s = m;
+        assert(s.length == m.length);
+        assert(s[1].b[1] == m[1].b[1]);
+        assert(s[1].c[0] == m[1].c[0]);
+        return (s[1].b.length, s[1].c.length, s[1].b[2], s[1].c[0]);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 3, 3, 3, 1
+// gas irOptimized: 181890
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol
new file mode 100644
index 00000000..5c44ef16
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint8[33] a;
+    uint32[9] b;
+    uint120[3] c;
+
+    function f() public returns (uint8, uint32, uint120) {
+        a[32] = 1; a[31] = 2; a[30] = 3;
+        b[0] = 1; b[1] = 2; b[2] = 3;
+        c[2] = 3; c[1] = 1;
+        return (a[32], b[1], c[2]);
+    }
+}
+// ----
+// f() -> 1, 2, 3
+// gas irOptimized: 131915
+// gas legacy: 134606
+// gas legacyOptimized: 131938
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol b/compiler/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol
new file mode 100644
index 00000000..50ea19a1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol
@@ -0,0 +1,44 @@
+pragma abicoder v2;
+
+contract C {
+    mapping (uint => uint8[][]) m;
+
+    uint8[][] s;
+
+    constructor() {
+        s = new uint8[][](2);
+
+        s[0] = new uint8[](2);
+        s[0][0] = 10;
+        s[0][1] = 11;
+
+        s[1] = new uint8[](3);
+        s[1][0] = 12;
+        s[1][1] = 13;
+        s[1][2] = 14;
+    }
+
+    function from_storage() public returns (uint8[][] memory) {
+        m[0] = s;
+        return m[0];
+    }
+
+    function from_storage_ptr() public returns (uint8[][] memory) {
+        uint8[][] storage sPtr = s;
+        m[0] = sPtr;
+        return m[0];
+    }
+
+    function from_memory() public returns (uint8[][] memory) {
+        uint8[][] memory a = s;
+        m[0] = a;
+        return m[0];
+    }
+}
+// ----
+// from_storage() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// gas irOptimized: 147871
+// gas legacy: 148896
+// gas legacyOptimized: 146901
+// from_storage_ptr() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// from_memory() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol
new file mode 100644
index 00000000..0deb396d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol
@@ -0,0 +1,19 @@
+contract Test {
+    uint24[] public data;
+    function set(uint24[] memory _data) public returns (uint) {
+        data = _data;
+        return data.length;
+    }
+    function get() public returns (uint24[] memory) {
+        return data;
+    }
+}
+// ----
+// set(uint24[]): 0x20, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 -> 18
+// gas irOptimized: 99616
+// gas legacy: 103509
+// gas legacyOptimized: 101390
+// data(uint256): 7 -> 8
+// data(uint256): 15 -> 16
+// data(uint256): 18 -> FAILURE
+// get() -> 0x20, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/bytes_inside_mappings.sol b/compiler/test/libsolidity/semanticTests/array/copying/bytes_inside_mappings.sol
new file mode 100644
index 00000000..19e5ddeb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/bytes_inside_mappings.sol
@@ -0,0 +1,21 @@
+contract c {
+    function set(uint key) public returns (bool) { data[key] = msg.data; return true; }
+    function copy(uint from, uint to) public returns (bool) { data[to] = data[from]; return true; }
+    mapping(uint => bytes) data;
+}
+// ----
+// set(uint256): 1, 2 -> true
+// gas irOptimized: 110558
+// gas legacy: 111312
+// gas legacyOptimized: 110741
+// set(uint256): 2, 2, 3, 4, 5 -> true
+// gas irOptimized: 177509
+// gas legacy: 178314
+// gas legacyOptimized: 177716
+// storageEmpty -> 0
+// copy(uint256,uint256): 1, 2 -> true
+// storageEmpty -> 0
+// copy(uint256,uint256): 99, 1 -> true
+// storageEmpty -> 0
+// copy(uint256,uint256): 99, 2 -> true
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/bytes_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/bytes_memory_to_storage.sol
new file mode 100644
index 00000000..d1202e27
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/bytes_memory_to_storage.sol
@@ -0,0 +1,10 @@
+contract C {
+  bytes s;
+  function f() external returns (bytes1) {
+    bytes memory data = "abcd";
+    s = data;
+    return s[0];
+  }
+}
+// ----
+// f() -> "a"
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_memory.sol
new file mode 100644
index 00000000..84e11c13
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_memory.sol
@@ -0,0 +1,9 @@
+contract C {
+  bytes s = "abcd";
+  function f() external returns (bytes1) {
+    bytes memory data = s;
+    return data[0];
+  }
+}
+// ----
+// f() -> "a"
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol
new file mode 100644
index 00000000..38dbe52b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol
@@ -0,0 +1,41 @@
+contract c {
+    bytes a;
+    bytes b;
+    function f(uint len) public returns (bytes memory) {
+        bytes memory x = new bytes(len);
+        for (uint i = 0; i < len; i++)
+            x[i] = bytes1(uint8(i));
+        a = x;
+        for (uint i = 0; i < len; i++)
+            assert(a[i] == x[i]);
+        b = a;
+        for (uint i = 0; i < len; i++)
+            assert(b[i] == x[i]);
+        return b;
+    }
+}
+// ----
+// f(uint256): 0 -> 0x20, 0x00
+// f(uint256): 31 -> 0x20, 0x1f, 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e00
+// gas irOptimized: 104476
+// gas legacy: 112974
+// gas legacyOptimized: 112717
+// f(uint256): 32 -> 0x20, 0x20, 1780731860627700044960722568376592200742329637303199754547598369979440671
+// gas irOptimized: 118962
+// gas legacy: 129034
+// gas legacyOptimized: 128952
+// f(uint256): 33 -> 0x20, 33, 1780731860627700044960722568376592200742329637303199754547598369979440671, 0x2000000000000000000000000000000000000000000000000000000000000000
+// gas irOptimized: 125419
+// gas legacy: 136234
+// gas legacyOptimized: 135643
+// f(uint256): 63 -> 0x20, 0x3f, 1780731860627700044960722568376592200742329637303199754547598369979440671, 14532552714582660066924456880521368950258152170031413196862950297402215316992
+// gas irOptimized: 129529
+// gas legacy: 148834
+// gas legacyOptimized: 148873
+// f(uint256): 12 -> 0x20, 0x0c, 0x0102030405060708090a0b0000000000000000000000000000000000000000
+// gas legacy: 59345
+// gas legacyOptimized: 57279
+// f(uint256): 129 -> 0x20, 0x81, 1780731860627700044960722568376592200742329637303199754547598369979440671, 0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f, 29063324697304692433803953038474361308315562010425523193971352996434451193439, 0x606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f, -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// gas irOptimized: 421911
+// gas legacy: 459355
+// gas legacyOptimized: 461066
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_1d_array_into_2d_memory_array_element.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_1d_array_into_2d_memory_array_element.sol
new file mode 100644
index 00000000..e78d5bdd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_1d_array_into_2d_memory_array_element.sol
@@ -0,0 +1,37 @@
+// Example from https://github.com/ethereum/solidity/issues/12558
+pragma abicoder v2;
+contract C {
+    function f(uint[] calldata a) external returns (uint[][] memory) {
+        uint[][] memory m = new uint[][](2);
+        m[0] = a;
+
+        return m;
+    }
+}
+contract Test {
+    C immutable c = new C();
+
+    function test() external returns (bool) {
+        uint[] memory arr = new uint[](4);
+
+        arr[0] = 13;
+        arr[1] = 14;
+        arr[2] = 15;
+        arr[3] = 16;
+
+        uint[][] memory ret = c.f(arr);
+        assert(ret.length == 2);
+        assert(ret[0].length == 4);
+        assert(ret[0][0] == 13);
+        assert(ret[0][1] == 14);
+        assert(ret[0][2] == 15);
+        assert(ret[0][3] == 16);
+        assert(ret[1].length == 0);
+
+        return true;
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol
new file mode 100644
index 00000000..706232d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+contract C {
+  uint256[] s;
+  function f(uint256[] calldata data) external returns (uint) {
+    s = data;
+    return s[0];
+  }
+}
+// ----
+// f(uint256[]): 0x20, 0x03, 0x1, 0x2, 0x3 -> 0x1
+// gas irOptimized: 110968
+// gas legacy: 111551
+// gas legacyOptimized: 111339
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol
new file mode 100644
index 00000000..fcf4aca2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_of_struct_to_memory.sol
@@ -0,0 +1,24 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f(S[] calldata s)
+        external
+        pure
+        returns (uint256 l, uint256 a, uint256 b, uint256 c, uint256 d)
+    {
+        S[] memory m = s;
+        l = m.length;
+        a = m[0].a;
+        b = m[0].b;
+        c = m[1].a;
+        d = m[1].b;
+    }
+}
+// ----
+// f((uint256,uint256)[]): 0x20, 0x2, 0x1, 0x2, 0x3, 0x4 -> 2, 1, 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_static_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_static_to_memory.sol
new file mode 100644
index 00000000..ace6550b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_static_to_memory.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint256[2] calldata c) public returns (uint256, uint256) {
+        uint256[2] memory m1 = c;
+        return (m1[0], m1[1]);
+    }
+}
+// ----
+// f(uint256[2]): 43, 57 -> 43, 57
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol
new file mode 100644
index 00000000..e6bf7671
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol
@@ -0,0 +1,17 @@
+pragma abicoder v2;
+
+contract C {
+    mapping (uint => uint8[][]) m;
+
+    uint8[][] s;
+
+    function from_calldata(uint8[][] calldata _a) public returns (uint8[][] memory) {
+        m[0] = _a;
+        return m[0];
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// from_calldata(uint8[][]): 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14
+// gas irOptimized: 139683
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_bytes_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_bytes_to_storage.sol
new file mode 100644
index 00000000..2409893e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_bytes_to_storage.sol
@@ -0,0 +1,9 @@
+contract C {
+  bytes s;
+  function f(bytes calldata data) external returns (bytes1) {
+    s = data;
+    return s[0];
+  }
+}
+// ----
+// f(bytes): 0x20, 0x08, "abcdefgh" -> "a"
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol
new file mode 100644
index 00000000..db6625c8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/calldata_dynamic_array_to_memory.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(uint256[][] calldata a)
+        external
+        returns (uint256, uint256[] memory)
+    {
+        uint256[] memory m = a[0];
+        return (a.length, m);
+    }
+}
+// ----
+// f(uint256[][]): 0x20, 0x1, 0x20, 0x2, 0x17, 0x2a -> 0x1, 0x40, 0x2, 0x17, 0x2a
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/cleanup_during_multi_element_per_slot_copy.sol b/compiler/test/libsolidity/semanticTests/array/copying/cleanup_during_multi_element_per_slot_copy.sol
new file mode 100644
index 00000000..d2361dac
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/cleanup_during_multi_element_per_slot_copy.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint32[] s;
+    constructor()
+    {
+        s.push();
+        s.push();
+    }
+    function f() external returns (uint)
+    {
+        (s[1], s) = (4, [0]);
+        s = [0];
+        s.push();
+        return s[1];
+        // used to return 4 via IR.
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 226349
+// gas legacy: 215757
+// gas legacyOptimized: 181760
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol
new file mode 100644
index 00000000..5482f615
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol
@@ -0,0 +1,46 @@
+pragma abicoder               v2;
+struct S {
+    uint16 x;
+    bytes a;
+    uint16 y;
+    bytes b;
+}
+contract C {
+    uint padding;
+    S data;
+
+    function f() public returns (bytes memory, bytes memory) {
+        S memory x;
+        x.x = 7;
+        x.b = "1234567890123456789012345678901 1234567890123456789012345678901 123456789";
+        x.a = "abcdef";
+        x.y = 9;
+        data = x;
+        return (data.a, data.b);
+    }
+    function g() public returns (bytes memory, bytes memory) {
+        S memory x;
+        x.x = 7;
+        x.b = "12345678923456789";
+        x.a = "1234567890123456789012345678901 1234567890123456789012345678901 123456789";
+        x.y = 9;
+        data = x;
+        return (data.a, data.b);
+    }
+    function h() public returns (bytes memory, bytes memory) {
+        S memory x;
+        data = x;
+        return (data.a, data.b);
+    }
+}
+// ----
+// f() -> 0x40, 0x80, 6, 0x6162636465660000000000000000000000000000000000000000000000000000, 0x49, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738390000000000000000000000000000000000000000000000
+// gas irOptimized: 179750
+// gas legacy: 181001
+// gas legacyOptimized: 180018
+// g() -> 0x40, 0xc0, 0x49, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738390000000000000000000000000000000000000000000000, 0x11, 0x3132333435363738393233343536373839000000000000000000000000000000
+// gas irOptimized: 106679
+// gas legacy: 109720
+// gas legacyOptimized: 106932
+// h() -> 0x40, 0x60, 0x00, 0x00
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol
new file mode 100644
index 00000000..d4599cdb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copy_byte_array_to_storage.sol
@@ -0,0 +1,51 @@
+function dataslot() pure returns (bytes32) {
+    return keccak256(abi.encode(1));
+}
+
+function readDataSlot(uint offset) view returns (bytes32 r) {
+    bytes32 s = dataslot();
+    assembly { r := sload(add(s, offset)) }
+}
+
+function readDataSlot() view returns (bytes32) {
+    return readDataSlot(0);
+}
+
+function readHead() view returns (bytes32 r) {
+    assembly { r := sload(1) }
+}
+
+contract C {
+    uint padding;
+    bytes data;
+
+    function f() public returns (uint) {
+        bytes32 zero;
+        if (!(readDataSlot() == zero)) return 1;
+        data = "abc";
+        if (!(readDataSlot() == zero)) return 2;
+        data = "1234567890123456789012345678901234567890123456789012345678901234567890";
+        if (!(readDataSlot() != zero)) return 3;
+        if (!(readDataSlot(1) != zero)) return 4;
+        if (!(readDataSlot(2) != zero)) return 5;
+        if (!(readDataSlot(3) == zero)) return 6;
+        if (!(readDataSlot(4) == zero)) return 7;
+        data = "abc";
+        if (!(readDataSlot() == zero)) return 8;
+        if (!(readDataSlot(1) == zero)) return 9;
+        if (!(readDataSlot(2) == zero)) return 10;
+        if (!(readDataSlot(3) == zero)) return 11;
+        data = "1234567890123456789012345678901234567890123456789012345678901234567890";
+        data = "123456789012345678901234567890123456";
+        if (!(readDataSlot() != zero)) return 12;
+        if (!(readDataSlot(1) != zero)) return 13;
+        if (!(readDataSlot(2) == zero)) return 14;
+        if (!(readDataSlot(3) == zero)) return 15;
+        return 0xff;
+    }
+}
+// ----
+// f() -> 0xff
+// gas irOptimized: 143412
+// gas legacy: 153395
+// gas legacyOptimized: 146720
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol b/compiler/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol
new file mode 100644
index 00000000..fb217790
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol
@@ -0,0 +1,20 @@
+contract C {
+    function() internal returns (uint)[] x;
+    function() internal returns (uint)[] y;
+
+    function test() public returns (uint256) {
+        x = new function() internal returns (uint)[](10);
+        x[9] = a;
+        y = x;
+        return y[9]();
+    }
+
+    function a() public returns (uint256) {
+        return 7;
+    }
+}
+// ----
+// test() -> 7
+// gas irOptimized: 122455
+// gas legacy: 205176
+// gas legacyOptimized: 204971
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copy_internal_function_array_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/copy_internal_function_array_to_storage.sol
new file mode 100644
index 00000000..95ba9d8e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copy_internal_function_array_to_storage.sol
@@ -0,0 +1,23 @@
+contract C {
+    function() internal returns (uint)[20] x;
+    int256 mutex;
+
+    function one() public returns (uint256) {
+        function() internal returns (uint)[20] memory xmem;
+        x = xmem;
+        return 3;
+    }
+
+    function two() public returns (uint256) {
+        if (mutex > 0) return 7;
+        mutex = 1;
+        // If this test fails, it might re-execute this function.
+        x[0]();
+        return 2;
+    }
+}
+// ----
+// one() -> 3
+// gas legacy: 140253
+// gas legacyOptimized: 140093
+// two() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copy_removes_bytes_data.sol b/compiler/test/libsolidity/semanticTests/array/copying/copy_removes_bytes_data.sol
new file mode 100644
index 00000000..85c396fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copy_removes_bytes_data.sol
@@ -0,0 +1,15 @@
+
+contract c {
+    function set() public returns (bool) { data1 = msg.data; return true; }
+    function reset() public returns (bool) { data1 = data2; return true; }
+    bytes data1;
+    bytes data2;
+}
+// ----
+// set(): 1, 2, 3, 4, 5 -> true
+// gas irOptimized: 177376
+// gas legacy: 177954
+// gas legacyOptimized: 177550
+// storageEmpty -> 0
+// reset() -> true
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol b/compiler/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol
new file mode 100644
index 00000000..58b5dd04
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol
@@ -0,0 +1,30 @@
+contract receiver {
+    uint public received;
+    function recv(uint x) public { received += x + 1; }
+    fallback() external { received = 0x80; }
+}
+contract sender {
+    constructor() { rec = new receiver(); }
+    fallback() external { savedData1 = savedData2 = msg.data; }
+    function forward(bool selector) public returns (bool) {
+        if (selector) { address(rec).call(savedData1); delete savedData1; }
+        else { address(rec).call(savedData2); delete savedData2; }
+        return true;
+    }
+    function val() public returns (uint) { return rec.received(); }
+    receiver rec;
+    bytes savedData1;
+    bytes savedData2;
+}
+// ----
+// (): 7 ->
+// gas irOptimized: 110831
+// gas legacy: 111388
+// gas legacyOptimized: 111065
+// val() -> 0
+// forward(bool): true -> true
+// val() -> 0x80
+// forward(bool): false -> true
+// val() -> 0x80
+// forward(bool): true -> true
+// val() -> 0x80
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/dirty_memory_bytes_to_storage_copy_ir.sol b/compiler/test/libsolidity/semanticTests/array/copying/dirty_memory_bytes_to_storage_copy_ir.sol
new file mode 100644
index 00000000..3704e368
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/dirty_memory_bytes_to_storage_copy_ir.sol
@@ -0,0 +1,18 @@
+contract C {
+    bytes x;
+    function f() public returns (uint r) {
+        bytes memory m = "tmp";
+        assembly {
+            mstore(m, 8)
+            mstore(add(m, 32), "deadbeef15dead")
+        }
+        x = m;
+        assembly {
+            r := sload(x.slot)
+        }
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 0x6465616462656566000000000000000000000000000000000000000000000010
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol
new file mode 100644
index 00000000..ea5625f2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol
@@ -0,0 +1,38 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[] a;
+        uint8[2] b;
+    }
+
+    S[][][] s1;
+    S[][1][] s2;
+    S[1][][1] s3;
+
+    function test1(S[][][] calldata _a) public returns (S[][] memory){
+        s1.push();
+        s1[0] = _a[0];
+        return s1[0];
+    }
+
+    function test2(S[][1][] calldata _a) public returns (S[][1] memory) {
+        s2.push();
+        s2[0] = _a[0];
+        return s2[0];
+    }
+
+    function test3(S[1][][2] calldata _a) public returns (S[1][] memory) {
+        s3[0] = _a[1];
+        return s3[0];
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1((uint8[],uint8[2])[][][]): 0x20, 1, 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29
+// gas irOptimized: 327874
+// test2((uint8[],uint8[2])[][1][]): 0x20, 2, 0x40, 0x0160, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13, 0x20, 1, 0x20, 0x60, 31, 37, 2, 23, 29 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 140879
+// test3((uint8[],uint8[2])[1][][2]): 0x20, 0x40, 0x60, 0, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 188535
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol
new file mode 100644
index 00000000..96f24f77
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol
@@ -0,0 +1,38 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[] a;
+        uint8[2] b;
+    }
+
+    S[][][] s1;
+    S[][1][] s2;
+    S[1][][1] s3;
+
+    function test1(S[][][] memory _a) public returns (S[][] memory){
+        s1.push();
+        s1[0] = _a[0];
+        return s1[0];
+    }
+
+    function test2(S[][1][] memory _a) public returns (S[][1] memory) {
+        s2.push();
+        s2[0] = _a[0];
+        return s2[0];
+    }
+
+    function test3(S[1][][2] memory _a) public returns (S[1][] memory) {
+        s3[0] = _a[1];
+        return s3[0];
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1((uint8[],uint8[2])[][][]): 0x20, 1, 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29
+// gas irOptimized: 332660
+// test2((uint8[],uint8[2])[][1][]): 0x20, 2, 0x40, 0x0160, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13, 0x20, 1, 0x20, 0x60, 31, 37, 2, 23, 29 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 145150
+// test3((uint8[],uint8[2])[1][][2]): 0x20, 0x40, 0x60, 0, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 192598
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol
new file mode 100644
index 00000000..275a0fca
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol
@@ -0,0 +1,56 @@
+contract C {
+	string log;
+	function() external[] fs;
+	function() external[] gs;
+
+	function a() external {
+		log = string.concat(log, "[a called]");
+	}
+	function b() external {
+		log = string.concat(log, "[b called]");
+	}
+
+	function f(function() external[] calldata x) external {
+		fs = x;
+	}
+	function g(function() external[] memory x) public {
+		fs = x;
+	}
+	function test() external returns (string memory) {
+		log = "";
+		function() external[] memory x = new function() external[](2);
+		x[0] = this.a;
+		x[1] = this.b;
+		this.f(x);
+		fs[0]();
+		fs[1]();
+		return log;
+	}
+	function test2() external returns (string memory) {
+		log = "";
+		function() external[] memory x = new function() external[](2);
+		x[0] = this.b;
+		x[1] = this.a;
+		g(x);
+		fs[0]();
+		fs[1]();
+		return log;
+	}
+	function test3() external returns (string memory) {
+		log = "";
+		gs = fs;
+		gs[0]();
+		gs[1]();
+		return log;
+	}
+}
+// ----
+// test() -> 0x20, 0x14, "[a called][b called]"
+// gas irOptimized: 116645
+// gas legacy: 118936
+// gas legacyOptimized: 116975
+// test2() -> 0x20, 0x14, "[b called][a called]"
+// test3() -> 0x20, 0x14, "[b called][a called]"
+// gas irOptimized: 103246
+// gas legacy: 102745
+// gas legacyOptimized: 101669
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol
new file mode 100644
index 00000000..79882a74
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol
@@ -0,0 +1,23 @@
+pragma abicoder v2;
+
+contract C {
+    bytes[] s;
+    function f() external returns (uint256) {
+        bytes[] memory m = new bytes[](3);
+        m[0] = "ab"; m[1] = "cde"; m[2] = "fghij";
+        s = m;
+        assert(s.length == m.length);
+        for (uint i = 0; i < s.length; ++i) {
+            assert(s[i].length == m[i].length);
+            for (uint j = 0; j < s[i].length; ++j) {
+                 assert(s[i][j] == m[i][j]);
+            }
+        }
+        return s.length;
+    }
+}
+// ----
+// f() -> 3
+// gas irOptimized: 127422
+// gas legacy: 129050
+// gas legacyOptimized: 128222
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_memory.sol
new file mode 100644
index 00000000..e3843537
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_memory.sol
@@ -0,0 +1,40 @@
+pragma abicoder v2;
+
+contract C {
+    function test1(uint8[][][] calldata _a) public returns (uint8[][] memory) {
+        return _a[1];
+    }
+
+    function test2(uint8[][1][] calldata _a) public returns (uint8[][1] memory) {
+        return _a[0];
+    }
+
+    function test3(uint8[2][][2] calldata _a) public returns (uint8[2][] memory) {
+        return _a[0];
+    }
+
+    function test4(uint16[][] calldata _a) public returns (uint16[][] memory) {
+        uint16[][][] memory tmp = new uint16[][][](2);
+        tmp[1] = _a;
+        return tmp[1];
+    }
+
+    function test5(uint32[][2] calldata _a) public returns (uint32[][2] memory) {
+        uint32[][2][] memory tmp = new uint32[][2][](1);
+        tmp[0] = _a;
+        return tmp[0];
+    }
+
+    function test6(uint32[2][] calldata _a) public returns (uint32[2][] memory) {
+        uint32[2][][] memory tmp = new uint32[2][][](1);
+        tmp[0] = _a;
+        return tmp[0];
+    }
+}
+// ----
+// test1(uint8[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// test2(uint8[][1][]): 0x20, 2, 0x40, 0xe0, 0x20, 3, 12, 13, 14, 0x20, 3, 15, 16, 17 -> 0x20, 0x20, 3, 12, 13, 14
+// test3(uint8[2][][2]): 0x20, 0x40, 0xa0, 1, 7, 7, 2, 8, 8, 0x09, 9 -> 0x20, 1, 7, 7
+// test4(uint16[][]): 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// test5(uint32[][2]): 0x20, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 0x40, 0x80, 1, 7, 2, 8, 9
+// test6(uint32[2][]): 0x20, 2, 5, 6, 7, 8 -> 0x20, 2, 5, 6, 7, 8
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_storage.sol
new file mode 100644
index 00000000..5040a72c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_calldata_to_storage.sol
@@ -0,0 +1,29 @@
+contract C {
+    uint8[2][2] a;
+    uint8[2][2][2] a2;
+
+    function test(uint8[2][2][2] calldata _a) public {
+        a = _a[0];
+        require(a[0][0] == 1);
+        require(a[0][1] == 2);
+        require(a[1][0] == 3);
+        require(a[1][1] == 4);
+    }
+
+    function test2(uint8[2][2] calldata _a) public {
+        a2[0] = _a;
+        require(a2[0][0][0] == 1);
+        require(a2[0][0][1] == 2);
+        require(a2[0][1][0] == 3);
+        require(a2[0][1][1] == 4);
+        require(a2[1][0][0] == 0);
+        require(a2[1][0][1] == 0);
+        require(a2[1][1][0] == 0);
+        require(a2[1][1][1] == 0);
+    }
+}
+// ----
+// test(uint8[2][2][2]): 1, 2, 3, 4, 5, 6, 7, 8
+// test2(uint8[2][2]): 1, 2, 3, 4
+// gas irOptimized: 119939
+// gas legacyOptimized: 120228
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_memory.sol
new file mode 100644
index 00000000..3058df84
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_memory.sol
@@ -0,0 +1,40 @@
+pragma abicoder v2;
+
+contract C {
+    function test1(uint8[][][] memory _a) public returns (uint8[][] memory) {
+        return _a[1];
+    }
+
+    function test2(uint8[][1][] memory _a) public returns (uint8[][1] memory) {
+        return _a[0];
+    }
+
+    function test3(uint8[2][][2] memory _a) public returns (uint8[2][] memory) {
+        return _a[0];
+    }
+
+    function test4(uint16[][] memory _a) public returns (uint16[][] memory) {
+        uint16[][][] memory tmp = new uint16[][][](2);
+        tmp[1] = _a;
+        return tmp[1];
+    }
+
+    function test5(uint32[][2] memory _a) public returns (uint32[][2] memory) {
+        uint32[][2][] memory tmp = new uint32[][2][](1);
+        tmp[0] = _a;
+        return tmp[0];
+    }
+
+    function test6(uint32[2][] memory _a) public returns (uint32[2][] memory) {
+        uint32[2][][] memory tmp = new uint32[2][][](1);
+        tmp[0] = _a;
+        return tmp[0];
+    }
+}
+// ----
+// test1(uint8[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// test2(uint8[][1][]): 0x20, 2, 0x40, 0xe0, 0x20, 3, 12, 13, 14, 0x20, 3, 15, 16, 17 -> 0x20, 0x20, 3, 12, 13, 14
+// test3(uint8[2][][2]): 0x20, 0x40, 0xa0, 1, 7, 7, 2, 8, 8, 0x09, 9 -> 0x20, 1, 7, 7
+// test4(uint16[][]): 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// test5(uint32[][2]): 0x20, 0x40, 0x80, 1, 7, 2, 8, 9 -> 0x20, 0x40, 0x80, 1, 7, 2, 8, 9
+// test6(uint32[2][]): 0x20, 2, 5, 6, 7, 8 -> 0x20, 2, 5, 6, 7, 8
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_storage.sol
new file mode 100644
index 00000000..2f4b4ca7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_memory_to_storage.sol
@@ -0,0 +1,29 @@
+contract C {
+    uint8[2][2] a1;
+    uint8[2][2][2] a2;
+
+    function test(uint8[2][2][2] memory _a) public {
+        a1 = _a[0];
+        require(a1[0][0] == 1);
+        require(a1[0][1] == 2);
+        require(a1[1][0] == 3);
+        require(a1[1][1] == 4);
+    }
+
+    function test2(uint8[2][2] memory _a) public {
+        a2[0] = _a;
+        require(a2[0][0][0] == 1);
+        require(a2[0][0][1] == 2);
+        require(a2[0][1][0] == 3);
+        require(a2[0][1][1] == 4);
+        require(a2[1][0][0] == 0);
+        require(a2[1][0][1] == 0);
+        require(a2[1][1][0] == 0);
+        require(a2[1][1][1] == 0);
+    }
+}
+// ----
+// test(uint8[2][2][2]): 1, 2, 3, 4, 5, 6, 7, 8
+// test2(uint8[2][2]): 1, 2, 3, 4
+// gas irOptimized: 119939
+// gas legacyOptimized: 120228
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_memory.sol
new file mode 100644
index 00000000..e30ca769
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_memory.sol
@@ -0,0 +1,70 @@
+pragma abicoder v2;
+
+contract C {
+    uint8[][][] a1 = new uint8[][][](2);
+    uint8[][][2] a2;
+    uint8[][2][] a3 = new uint8[][2][](1);
+    uint8[2][][] a4 = new uint8[2][][](2);
+
+    constructor() {
+        a1[1] = new uint8[][](2);
+        a1[1][0] = [3, 4];
+        a1[1][1] = [5, 6];
+
+        a2[0] = new uint8[][](2);
+        a2[0][0] = [6, 7];
+        a2[0][1] = [8, 9];
+        a2[1] = new uint8[][](2);
+        a2[1][0] = [10, 11];
+
+        a3[0][0] = [3, 4];
+        a3[0][1] = [5, 6];
+
+        a4[0] = new uint8[2][](1);
+        a4[0][0] = [17, 23];
+        a4[1] = new uint8[2][](1);
+        a4[1][0] = [19, 31];
+    }
+
+    function test1() public returns (uint8[][] memory) {
+        return a1[1];
+    }
+
+    function test2() public returns (uint8[][] memory) {
+        return a2[0];
+    }
+
+    function test3() public returns (uint8[][2] memory) {
+        return a3[0];
+    }
+
+    function test4() public returns (uint8[2][] memory) {
+        return a4[1];
+    }
+
+    function test5() public returns (uint8[][][] memory) {
+        uint8[][][] memory tmp = new uint8[][][](3);
+        tmp[1] = a1[1];
+        return tmp;
+    }
+
+    function test6() public returns (uint8[][2][] memory) {
+        uint8[][2][] memory tmp = new uint8[][2][](2);
+        tmp[0] = a3[0];
+        return tmp;
+    }
+
+    function test7() public returns (uint8[2][][] memory) {
+        uint8[2][][] memory tmp = new uint8[2][][](1);
+        tmp[0] = a4[0];
+        return tmp;
+    }
+}
+// ----
+// test1() -> 0x20, 2, 0x40, 0xa0, 2, 3, 4, 2, 5, 6
+// test2() -> 0x20, 2, 0x40, 0xa0, 2, 6, 7, 2, 8, 9
+// test3() -> 0x20, 0x40, 0xa0, 2, 3, 4, 2, 5, 6
+// test4() -> 0x20, 1, 19, 31
+// test5() -> 0x20, 3, 0x60, 0x80, 0x01a0, 0, 2, 0x40, 0xa0, 2, 3, 4, 2, 5, 6, 0
+// test6() -> 0x20, 2, 0x40, 0x0140, 0x40, 0xa0, 2, 3, 4, 2, 5, 6, 0x40, 0x60, 0, 0
+// test7() -> 0x20, 1, 0x20, 1, 17, 23
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_storage.sol
new file mode 100644
index 00000000..f85b8eb9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_element_storage_to_storage.sol
@@ -0,0 +1,84 @@
+pragma abicoder v2;
+
+contract C {
+    uint8[][][] src1 = new uint8[][][](2);
+    uint8[][][2] src2;
+    uint8[][2][] src3 = new uint8[][2][](1);
+    uint8[2][][] src4 = new uint8[2][][](2);
+
+    uint8[][] dst1;
+    uint8[][] dst2;
+    uint8[][2] dst3;
+    uint8[][] dst4;
+
+    constructor() {
+        src1[1] = new uint8[][](2);
+        src1[1][0] = [3, 4];
+        src1[1][1] = [5, 6];
+
+        src2[0] = new uint8[][](2);
+        src2[0][0] = [6, 7];
+        src2[0][1] = [8, 9];
+        src2[1] = new uint8[][](2);
+        src2[1][0] = [10, 11];
+
+        src3[0][0] = [3, 4];
+        src3[0][1] = [5, 6];
+
+        src4[0] = new uint8[2][](1);
+        src4[0][0] = [17, 23];
+        src4[1] = new uint8[2][](1);
+        src4[1][0] = [19, 31];
+    }
+
+    function test1() public {
+        dst1 = src1[1];
+
+        require(dst1.length == 2);
+        require(dst1[0][0] == src1[1][0][0]);
+        require(dst1[0][1] == src1[1][0][1]);
+        require(dst1[1][0] == src1[1][1][0]);
+        require(dst1[1][1] == src1[1][1][1]);
+    }
+
+    function test2() public {
+        dst2 = src2[0];
+
+        require(dst2.length == 2);
+        require(dst2[0][0] == src2[1][0][0]);
+        require(dst2[0][1] == src2[1][0][1]);
+        require(dst2[1][0] == src2[1][1][0]);
+        require(dst2[1][1] == src2[1][1][1]);
+    }
+
+    function test3() public {
+        dst3 = src3[0];
+        require(dst3[0][0] == src3[0][0][0]);
+        require(dst3[0][1] == src3[0][0][1]);
+        require(dst3[1][0] == src3[0][1][0]);
+        require(dst3[1][1] == src3[0][1][1]);
+    }
+
+    function test4() public {
+        dst4 = src4[1];
+        require(dst4.length == 2);
+        require(dst4[0][0] == src4[0][0][0]);
+        require(dst4[0][1] == src4[0][0][1]);
+        require(dst4[1][0] == src4[0][1][0]);
+        require(dst4[1][1] == src4[0][1][1]);
+    }
+}
+// ----
+// test1() ->
+// gas irOptimized: 150468
+// gas legacy: 150949
+// gas legacyOptimized: 150906
+// test2() -> FAILURE
+// gas irOptimized: 150378
+// gas legacy: 150673
+// gas legacyOptimized: 150576
+// test3() ->
+// gas irOptimized: 123762
+// gas legacy: 125333
+// gas legacyOptimized: 125127
+// test4() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_memory.sol
new file mode 100644
index 00000000..3d424a7c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_memory.sol
@@ -0,0 +1,24 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8 x;
+        uint8 y;
+    }
+
+    function test1(S[1][2] calldata a) public returns (S[1][2] memory) {
+        return a;
+    }
+
+    function test2(S[1][] calldata a) public returns (S[1][] memory) {
+        return a;
+    }
+
+    function test3(S[][2] calldata a) public returns (S[][2] memory) {
+        return a;
+    }
+}
+// ----
+// test1((uint8,uint8)[1][2]): 1, 2, 3, 4 -> 1, 2, 3, 4
+// test2((uint8,uint8)[1][]): 0x20, 3, 7, 11, 13, 17, 19, 23 -> 0x20, 3, 7, 11, 13, 17, 19, 23
+// test3((uint8,uint8)[][2]): 0x20, 0x40, 0xa0, 1, 3, 7, 2, 11, 13, 17, 19 -> 0x20, 0x40, 0xa0, 1, 3, 7, 2, 11, 13, 17, 19
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol
new file mode 100644
index 00000000..844a8630
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol
@@ -0,0 +1,36 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[] a;
+        uint8[2] b;
+    }
+
+    S[][] s1;
+    S[][1] s2;
+    S[1][] s3;
+
+    function test1(S[][] calldata _a) public returns (S[][] memory){
+        s1 = _a;
+        return s1;
+    }
+
+    function test2(S[][1] calldata _a) public returns (S[][1] memory) {
+        s2 = _a;
+        return s2;
+    }
+
+    function test3(S[1][] calldata _a) public returns (S[1][] memory) {
+        s3 = _a;
+        return s3;
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1((uint8[],uint8[2])[][]): 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29
+// gas irOptimized: 304747
+// test2((uint8[],uint8[2])[][1]): 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 116464
+// test3((uint8[],uint8[2])[1][]): 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 188024
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_memory.sol
new file mode 100644
index 00000000..6c8da98d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_memory.sol
@@ -0,0 +1,24 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8 x;
+        uint8 y;
+    }
+
+    function test1(S[1][2] memory a) public returns (S[1][2] memory r) {
+        r = a;
+    }
+
+    function test2(S[1][] memory a) public returns (S[1][] memory r) {
+        r = a;
+    }
+
+    function test3(S[][2] memory a) public returns (S[][2] memory r) {
+        r = a;
+    }
+}
+// ----
+// test1((uint8,uint8)[1][2]): 1, 2, 3, 4 -> 1, 2, 3, 4
+// test2((uint8,uint8)[1][]): 0x20, 3, 7, 11, 13, 17, 19, 23 -> 0x20, 3, 7, 11, 13, 17, 19, 23
+// test3((uint8,uint8)[][2]): 0x20, 0x40, 0xa0, 1, 3, 7, 2, 11, 13, 17, 19 -> 0x20, 0x40, 0xa0, 1, 3, 7, 2, 11, 13, 17, 19
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol
new file mode 100644
index 00000000..209a6ee6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol
@@ -0,0 +1,36 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[] a;
+        uint8[2] b;
+    }
+
+    S[][] s1;
+    S[][1] s2;
+    S[1][] s3;
+
+    function test1(S[][] memory _a) public returns (S[][] memory){
+        s1 = _a;
+        return s1;
+    }
+
+    function test2(S[][1] memory _a) public returns (S[][1] memory) {
+        s2 = _a;
+        return s2;
+    }
+
+    function test3(S[1][] memory _a) public returns (S[1][] memory) {
+        s3 = _a;
+        return s3;
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1((uint8[],uint8[2])[][]): 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29
+// gas irOptimized: 309074
+// test2((uint8[],uint8[2])[][1]): 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 118256
+// test3((uint8[],uint8[2])[1][]): 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13
+// gas irOptimized: 190993
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_storage_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_storage_to_storage.sol
new file mode 100644
index 00000000..c356e029
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_storage_to_storage.sol
@@ -0,0 +1,69 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8 x;
+        uint8 y;
+    }
+
+    S[][] src1;
+    S[][1] src2;
+    S[1][] src3;
+
+    S[][] dst1;
+    S[][1] dst2;
+    S[1][] dst3;
+
+    constructor() {
+        src1 = new S[][](1);
+        src1[0].push(S({x: 3, y: 7}));
+        src1[0].push(S({x: 11, y: 13}));
+
+        src2[0].push(S({x: 3, y: 7}));
+        src2[0].push(S({x: 11, y: 13}));
+        src2[0].push(S({x: 17, y: 19}));
+
+        src3.push([S({x: 3, y: 7})]);
+        src3.push([S({x: 11, y: 13})]);
+    }
+
+    function test1() public {
+        dst1 = src1;
+
+        require(dst1.length == 1);
+        require(dst1[0][0].x == src1[0][0].x);
+        require(dst1[0][0].y == src1[0][0].y);
+        require(dst1[0][1].x == src1[0][1].x);
+        require(dst1[0][1].y == src1[0][1].y);
+    }
+
+    function test2() public {
+        dst2 = src2;
+
+        require(dst2[0].length == 3);
+        require(dst2[0][0].x == src2[0][0].x);
+        require(dst2[0][0].y == src2[0][0].y);
+        require(dst2[0][1].x == src2[0][1].x);
+        require(dst2[0][1].y == src2[0][1].y);
+        require(dst2[0][2].x == src2[0][2].x);
+        require(dst2[0][2].y == src2[0][2].y);
+    }
+
+    function test3() public {
+        dst3 = src3;
+
+        require(dst3.length == 2);
+        require(dst3[0][0].x == src3[0][0].x);
+        require(dst3[0][0].y == src3[0][0].y);
+        require(dst3[1][0].x == src3[1][0].x);
+        require(dst3[1][0].y == src3[1][0].y);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1()
+// gas irOptimized: 123202
+// test2()
+// gas irOptimized: 123027
+// test3()
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_with_nested_array_from_storage_to_memory.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_with_nested_array_from_storage_to_memory.sol
new file mode 100644
index 00000000..3a5e44a5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_with_nested_array_from_storage_to_memory.sol
@@ -0,0 +1,44 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[] a;
+        uint8[2] b;
+    }
+
+    uint8[] a1;
+    uint8[] a2;
+    uint8[] a3;
+
+    S[][] s1;
+    S[1][1] s2;
+
+    constructor() {
+        a1.push(23);
+        a1.push(29);
+        a2.push(31);
+
+        s1 = new S[][](2);
+        s1[0] = new S[](2);
+        s1[0][0] = S({a: a1, b: [7, 11]});
+        s1[0][1] = S({a: a2, b: [17, 19]});
+
+        s1[1] = new S[](1);
+        s1[1][0] = S({a: a3, b: [37, 41]});
+
+        s2[0][0] = S({a: a3, b: [43, 47]});
+    }
+
+    function test1() public returns (S[] memory) {
+        return s1[0];
+    }
+
+    function test2() public returns (S[1] memory) {
+        return s2[0];
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test1() -> 0x20, 2, 0x40, 0x0100, 0x60, 7, 11, 2, 23, 29, 0x60, 17, 19, 1, 31
+// test2() -> 0x20, 0x20, 0x60, 43, 47, 0
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol
new file mode 100644
index 00000000..dfb7c27a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol
@@ -0,0 +1,36 @@
+pragma abicoder v2;
+
+contract C {
+    uint8[][] a;
+    uint8[][][] a2;
+
+    function test(uint8[][][] calldata _a) public {
+        a = _a[1];
+        require(a.length == 2);
+        require(a[0].length == 1);
+        require(a[0][0] == 7);
+        require(a[1].length == 2);
+        require(a[1][0] == 8);
+        require(a[1][1] == 9);
+    }
+
+    function test2(uint8[][] calldata _a) public {
+        a2 = new uint8[][][](2);
+        a2[0] = _a;
+        require(a2[0].length == 2);
+	require(a2[0][0].length == 1);
+	require(a2[0][0][0] == 7);
+	require(a2[0][1].length == 2);
+	require(a2[0][1][0] == 8);
+	require(a2[0][1][1] == 9);
+	require(a2[1].length == 0);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test(uint8[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// gas irOptimized: 138040
+// test2(uint8[][]): 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9
+// gas irOptimized: 164246
+// gas legacyOptimized: 120228
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol
new file mode 100644
index 00000000..9a2fbb4d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint72[5][] a;
+
+    function f() public returns (uint72, uint72, uint72, uint72, uint72, uint72, uint72) {
+        for (uint i = 0; i < 4; i++)
+            a.push();
+        a[0][0] = 1;
+        a[0][3] = 2;
+        a[1][1] = 3;
+        a[1][4] = 4;
+        a[2][0] = 5;
+        a[3][2] = 6;
+        a[3][3] = 7;
+        uint72[5][] memory m = a;
+        return (m[0][0], m[0][3], m[1][1], m[1][4], m[2][0], m[3][2], m[3][3]);
+    }
+}
+// ----
+// f() -> 1, 2, 3, 4, 5, 6, 7
+// gas irOptimized: 205783
+// gas legacy: 211765
+// gas legacyOptimized: 211181
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol
new file mode 100644
index 00000000..211477c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_bytes.sol
@@ -0,0 +1,16 @@
+pragma abicoder               v2;
+contract C {
+    bytes[] a;
+
+    function f() public returns (bytes[] memory) {
+        a.push("abc");
+        a.push("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ");
+        bytes[] memory m = a;
+        return m;
+    }
+}
+// ----
+// f() -> 0x20, 0x02, 0x40, 0x80, 3, 0x6162630000000000000000000000000000000000000000000000000000000000, 0x99, 44048183304486788312148433451363384677562265908331949128489393215789685032262, 32241931068525137014058842823026578386641954854143559838526554899205067598957, 49951309422467613961193228765530489307475214998374779756599339590522149884499, 0x54555658595a6162636465666768696a6b6c6d6e6f707172737475767778797a, 0x4142434445464748494a4b4c4d4e4f5051525354555658595a00000000000000
+// gas irOptimized: 202731
+// gas legacy: 204798
+// gas legacyOptimized: 203357
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol
new file mode 100644
index 00000000..3606d7d6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol
@@ -0,0 +1,23 @@
+contract C {
+    uint72[5][] a;
+
+    function f() public returns (uint72, uint72, uint72, uint72, uint72, uint72, uint72) {
+        for (uint i = 0; i < 4; i++)
+            a.push();
+        a[0][0] = 1;
+        a[0][3] = 2;
+        a[1][1] = 3;
+        a[1][4] = 4;
+        a[2][0] = 5;
+        a[3][2] = 6;
+        a[3][3] = 7;
+        uint72[5][] storage a_ = a;
+        uint72[5][] memory m = a_;
+        return (m[0][0], m[0][3], m[1][1], m[1][4], m[2][0], m[3][2], m[3][3]);
+    }
+}
+// ----
+// f() -> 1, 2, 3, 4, 5, 6, 7
+// gas irOptimized: 205783
+// gas legacy: 211770
+// gas legacyOptimized: 211186
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol
new file mode 100644
index 00000000..cfbf5c87
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol
@@ -0,0 +1,29 @@
+contract C {
+    struct T { uint8 x; uint8 y; uint[] z; }
+    T[3][] a;
+
+    function f() public returns (uint8, uint8, uint, uint8, uint8, uint) {
+        a.push();
+        a.push();
+        a[0][1].x = 11;
+        a[0][1].y = 12;
+        a[0][1].z.push(1);
+        a[0][1].z.push(2);
+        a[0][1].z.push(3);
+        a[1][2].x = 21;
+        a[1][2].y = 22;
+        a[1][2].z.push(4);
+        a[1][2].z.push(5);
+        a[1][2].z.push(6);
+        T[3][] memory m = a;
+        return (
+            m[0][1].x, m[0][1].y, m[0][1].z[0],
+            m[1][2].x, m[1][2].y, m[1][2].z[0]
+        );
+    }
+}
+// ----
+// f() -> 11, 0x0c, 1, 0x15, 22, 4
+// gas irOptimized: 291047
+// gas legacy: 293407
+// gas legacyOptimized: 290218
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed.sol
new file mode 100644
index 00000000..f49b4923
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed.sol
@@ -0,0 +1,13 @@
+contract C {
+    uint8[33] a;
+
+    function f() public returns (uint8, uint8, uint8) {
+        a[0] = 2;
+        a[16] = 3;
+        a[32] = 4;
+        uint8[33] memory m = a;
+        return (m[0], m[16], m[32]);
+    }
+}
+// ----
+// f() -> 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed_dyn.sol b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed_dyn.sol
new file mode 100644
index 00000000..3ba5604a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/copying/storage_memory_packed_dyn.sol
@@ -0,0 +1,18 @@
+contract C {
+    uint8[] a;
+
+    function f() public returns (uint8, uint8, uint8) {
+        for (uint i = 0; i < 33; i++)
+            a.push(7);
+        a[0] = 2;
+        a[16] = 3;
+        a[32] = 4;
+        uint8[] memory m = a;
+        return (m[0], m[16], m[32]);
+    }
+}
+// ----
+// f() -> 2, 3, 4
+// gas irOptimized: 109108
+// gas legacy: 122235
+// gas legacyOptimized: 118411
diff --git a/compiler/test/libsolidity/semanticTests/array/create_dynamic_array_with_zero_length.sol b/compiler/test/libsolidity/semanticTests/array/create_dynamic_array_with_zero_length.sol
new file mode 100644
index 00000000..9d2dbd8c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/create_dynamic_array_with_zero_length.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public returns (uint256) {
+        uint256[][] memory a = new uint256[][](0);
+        return 7;
+    }
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/array/create_memory_array.sol b/compiler/test/libsolidity/semanticTests/array/create_memory_array.sol
new file mode 100644
index 00000000..d507f080
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/create_memory_array.sol
@@ -0,0 +1,23 @@
+contract C {
+    struct S {
+        uint256[2] a;
+        bytes b;
+    }
+
+    function f() public returns (bytes1, uint256, uint256, bytes1) {
+        bytes memory x = new bytes(200);
+        x[199] = "A";
+        uint256[2][] memory y = new uint256[2][](300);
+        y[203][1] = 8;
+        S[] memory z = new S[](180);
+        z[170].a[1] = 4;
+        z[170].b = new bytes(102);
+        z[170].b[99] = "B";
+        return (x[199], y[203][1], z[170].a[1], z[170].b[99]);
+    }
+}
+// ----
+// f() -> "A", 8, 4, "B"
+// gas irOptimized: 125822
+// gas legacy: 121382
+// gas legacyOptimized: 115488
diff --git a/compiler/test/libsolidity/semanticTests/array/create_memory_array_too_large.sol b/compiler/test/libsolidity/semanticTests/array/create_memory_array_too_large.sol
new file mode 100644
index 00000000..1d886a8c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/create_memory_array_too_large.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f() public returns (uint256) {
+        uint256 l = 2**256 / 32;
+        // This used to work without causing an error.
+        uint256[] memory x = new uint256[](l);
+        uint256[] memory y = new uint256[](1);
+        x[1] = 42;
+        // This used to overwrite the value written above.
+        y[0] = 23;
+        return x[1];
+    }
+    function g() public returns (uint256) {
+        uint256 l = 2**256 / 2 + 1;
+        // This used to work without causing an error.
+        uint16[] memory x = new uint16[](l);
+        uint16[] memory y = new uint16[](1);
+        x[2] = 42;
+        // This used to overwrite the value written above.
+        y[0] = 23;
+        return x[2];
+    }}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x41
+// g() -> FAILURE, hex"4e487b71", 0x41
diff --git a/compiler/test/libsolidity/semanticTests/array/create_multiple_dynamic_arrays.sol b/compiler/test/libsolidity/semanticTests/array/create_multiple_dynamic_arrays.sol
new file mode 100644
index 00000000..2396e317
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/create_multiple_dynamic_arrays.sol
@@ -0,0 +1,33 @@
+contract C {
+    function f() public returns (uint256) {
+        uint256[][] memory x = new uint256[][](42);
+        assert(x[0].length == 0);
+        x[0] = new uint256[](1);
+        x[0][0] = 1;
+        assert(x[4].length == 0);
+        x[4] = new uint256[](1);
+        x[4][0] = 2;
+        assert(x[10].length == 0);
+        x[10] = new uint256[](1);
+        x[10][0] = 44;
+        uint256[][] memory y = new uint256[][](24);
+        assert(y[0].length == 0);
+        y[0] = new uint256[](1);
+        y[0][0] = 1;
+        assert(y[4].length == 0);
+        y[4] = new uint256[](1);
+        y[4][0] = 2;
+        assert(y[10].length == 0);
+        y[10] = new uint256[](1);
+        y[10][0] = 88;
+        if (
+            (x[0][0] == y[0][0]) &&
+            (x[4][0] == y[4][0]) &&
+            (x[10][0] == 44) &&
+            (y[10][0] == 88)
+        ) return 7;
+        return 0;
+    }
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol b/compiler/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol
new file mode 100644
index 00000000..fffea685
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol
@@ -0,0 +1,21 @@
+contract c {
+    bytes data;
+
+    function test1() external returns (bool) {
+        data = new bytes(100);
+        for (uint256 i = 0; i < data.length; i++) data[i] = bytes1(uint8(i));
+        delete data[94];
+        delete data[96];
+        delete data[98];
+        return
+            data[94] == 0 &&
+            uint8(data[95]) == 95 &&
+            data[96] == 0 &&
+            uint8(data[97]) == 97;
+    }
+}
+// ----
+// test1() -> true
+// gas irOptimized: 204782
+// gas legacy: 242256
+// gas legacyOptimized: 241192
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/delete_bytes_array.sol b/compiler/test/libsolidity/semanticTests/array/delete/delete_bytes_array.sol
new file mode 100644
index 00000000..b735d182
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/delete_bytes_array.sol
@@ -0,0 +1,34 @@
+contract C {
+    bytes data;
+
+    function f() public returns (uint ret) {
+        data.push("a");
+        data.push("b");
+        delete data;
+        assembly {
+            ret := sload(data.slot)
+        }
+    }
+
+    function g() public returns (uint ret) {
+        assembly {
+            sstore(data.slot, 67)
+        }
+        data.push("a");
+        data.push("b");
+        assert(data.length == 35);
+        delete data;
+        assert(data.length == 0);
+
+        uint size = 999;
+        assembly {
+            size := sload(data.slot)
+            mstore(0, data.slot)
+            ret := sload(keccak256(0, 32))
+        }
+        assert(size == 0);
+    }
+}
+// ----
+// f() -> 0
+// g() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/delete_memory_array.sol b/compiler/test/libsolidity/semanticTests/array/delete/delete_memory_array.sol
new file mode 100644
index 00000000..53a66af3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/delete_memory_array.sol
@@ -0,0 +1,14 @@
+contract C {
+
+    function len() public returns (uint ret) {
+        uint[] memory data = new uint[](2);
+        data[0] = 234;
+        data[1] = 123;
+        delete data;
+        assembly {
+            ret := mload(data)
+        }
+    }
+}
+// ----
+// len() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/delete_on_array_of_structs.sol b/compiler/test/libsolidity/semanticTests/array/delete/delete_on_array_of_structs.sol
new file mode 100644
index 00000000..2c1421ee
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/delete_on_array_of_structs.sol
@@ -0,0 +1,19 @@
+// Test for a bug where we did not increment the counter properly while deleting a dynamic array.
+contract C {
+    struct S {
+        uint256 x;
+        uint256[] y;
+    }
+    S[] data;
+
+    function f() public returns (bool) {
+        S storage s1 = data.push();
+        s1.x = 2**200;
+        S storage s2 = data.push();
+        s2.x = 2**200;
+        delete data;
+        return true;
+    }
+}
+// ----
+// f() -> true # This code interprets x as an array length and thus will go out of gas. neither of the two should throw due to out-of-bounds access #
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array.sol b/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array.sol
new file mode 100644
index 00000000..41364566
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array.sol
@@ -0,0 +1,37 @@
+contract C {
+    uint[] data;
+
+    function len() public returns (uint ret) {
+        data.push(234);
+        data.push(123);
+        delete data;
+        assembly {
+            ret := sload(data.slot)
+        }
+    }
+
+    function val() public returns (uint ret) {
+        assembly {
+            sstore(0, 2)
+            mstore(0, 0)
+            sstore(keccak256(0, 32), 234)
+            sstore(add(keccak256(0, 32), 1), 123)
+        }
+
+        assert(data[0] == 234);
+        assert(data[1] == 123);
+
+        delete data;
+
+        uint size = 999;
+
+        assembly {
+            size := sload(0)
+            mstore(0, 0)
+            ret := sload(keccak256(0, 32))
+        }
+    }
+}
+// ----
+// len() -> 0
+// val() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol b/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol
new file mode 100644
index 00000000..9665201c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint120[] data;
+
+    function f() public returns (uint120, uint120, uint120) {
+        data.push(123);
+        data.push(234);
+        data.push(345);
+        delete data;
+        assembly {
+            sstore(data.slot, 3)
+        }
+        return (data[0], data[1], data[2]);
+    }
+}
+// ----
+// f() -> 0, 0, 0
+// gas irOptimized: 90992
+// gas legacy: 111037
+// gas legacyOptimized: 109633
diff --git a/compiler/test/libsolidity/semanticTests/array/dynamic_array_cleanup.sol b/compiler/test/libsolidity/semanticTests/array/dynamic_array_cleanup.sol
new file mode 100644
index 00000000..eb950d18
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/dynamic_array_cleanup.sol
@@ -0,0 +1,27 @@
+contract c {
+    uint[20] spacer;
+    uint[] dynamic;
+    function fill() public {
+        for (uint i = 0; i < 21; ++i)
+            dynamic.push(i + 1);
+    }
+    function halfClear() public {
+        while (dynamic.length > 5)
+            dynamic.pop();
+    }
+    function fullClear() public { delete dynamic; }
+}
+// ----
+// storageEmpty -> 1
+// fill() ->
+// gas irOptimized: 519017
+// gas legacy: 518936
+// gas legacyOptimized: 515555
+// storageEmpty -> 0
+// halfClear() ->
+// gas irOptimized: 113961
+// gas legacy: 113257
+// gas legacyOptimized: 113120
+// storageEmpty -> 0
+// fullClear() ->
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/dynamic_arrays_in_storage.sol b/compiler/test/libsolidity/semanticTests/array/dynamic_arrays_in_storage.sol
new file mode 100644
index 00000000..2f6769a2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/dynamic_arrays_in_storage.sol
@@ -0,0 +1,55 @@
+contract c {
+    struct Data {
+        uint256 x;
+        uint256 y;
+    }
+    Data[] data;
+    uint256[] ids;
+
+    function setIDStatic(uint256 id) public {
+        ids[2] = id;
+    }
+
+    function setID(uint256 index, uint256 id) public {
+        ids[index] = id;
+    }
+
+    function setData(uint256 index, uint256 x, uint256 y) public {
+        data[index].x = x;
+        data[index].y = y;
+    }
+
+    function getID(uint256 index) public returns (uint256) {
+        return ids[index];
+    }
+
+    function getData(uint256 index) public returns (uint256 x, uint256 y) {
+        x = data[index].x;
+        y = data[index].y;
+    }
+
+    function getLengths() public returns (uint256 l1, uint256 l2) {
+        l1 = data.length;
+        l2 = ids.length;
+    }
+
+    function setLengths(uint256 l1, uint256 l2) public {
+        while (data.length < l1) data.push();
+        while (ids.length < l2) ids.push();
+    }
+}
+// ----
+// getLengths() -> 0, 0
+// setLengths(uint256,uint256): 48, 49 ->
+// gas irOptimized: 110797
+// gas legacy: 108273
+// gas legacyOptimized: 100269
+// getLengths() -> 48, 49
+// setIDStatic(uint256): 11 ->
+// getID(uint256): 2 -> 11
+// setID(uint256,uint256): 7, 8 ->
+// getID(uint256): 7 -> 8
+// setData(uint256,uint256,uint256): 7, 8, 9 ->
+// setData(uint256,uint256,uint256): 8, 10, 11 ->
+// getData(uint256): 7 -> 8, 9
+// getData(uint256): 8 -> 10, 11
diff --git a/compiler/test/libsolidity/semanticTests/array/dynamic_multi_array_cleanup.sol b/compiler/test/libsolidity/semanticTests/array/dynamic_multi_array_cleanup.sol
new file mode 100644
index 00000000..7621d05b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/dynamic_multi_array_cleanup.sol
@@ -0,0 +1,24 @@
+contract c {
+    struct s { uint[][] d; }
+    s[] data;
+    function fill() public returns (uint) {
+        while (data.length < 3)
+            data.push();
+        while (data[2].d.length < 4)
+            data[2].d.push();
+        while (data[2].d[3].length < 5)
+            data[2].d[3].push();
+        data[2].d[3][4] = 8;
+        return data[2].d[3][4];
+    }
+    function clear() public { delete data; }
+}
+// ----
+// storageEmpty -> 1
+// fill() -> 8
+// gas irOptimized: 122742
+// gas legacy: 121602
+// gas legacyOptimized: 120589
+// storageEmpty -> 0
+// clear() ->
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/dynamic_out_of_bounds_array_access.sol b/compiler/test/libsolidity/semanticTests/array/dynamic_out_of_bounds_array_access.sol
new file mode 100644
index 00000000..5cf35ef3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/dynamic_out_of_bounds_array_access.sol
@@ -0,0 +1,31 @@
+contract c {
+    uint256[] data;
+
+    function enlarge(uint256 amount) public returns (uint256) {
+        while (data.length < amount) data.push();
+        return data.length;
+    }
+
+    function set(uint256 index, uint256 value) public returns (bool) {
+        data[index] = value;
+        return true;
+    }
+
+    function get(uint256 index) public returns (uint256) {
+        return data[index];
+    }
+
+    function length() public returns (uint256) {
+        return data.length;
+    }
+}
+// ----
+// length() -> 0
+// get(uint256): 3 -> FAILURE, hex"4e487b71", 0x32
+// enlarge(uint256): 4 -> 4
+// length() -> 4
+// set(uint256,uint256): 3, 4 -> true
+// get(uint256): 3 -> 4
+// length() -> 4
+// set(uint256,uint256): 4, 8 -> FAILURE, hex"4e487b71", 0x32
+// length() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/array/external_array_args.sol b/compiler/test/libsolidity/semanticTests/array/external_array_args.sol
new file mode 100644
index 00000000..da6664f9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/external_array_args.sol
@@ -0,0 +1,10 @@
+contract c {
+    function test(uint[8] calldata a, uint[] calldata b, uint[5] calldata c, uint a_index, uint b_index, uint c_index)
+            external returns (uint av, uint bv, uint cv) {
+        av = a[a_index];
+        bv = b[b_index];
+        cv = c[c_index];
+    }
+}
+// ----
+// test(uint256[8],uint256[],uint256[5],uint256,uint256,uint256): 1, 2, 3, 4, 5, 6, 7, 8, 0x220, 21, 22, 23, 24, 25, 0, 1, 2, 3, 11, 12, 13 -> 1, 12, 23
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_array_cleanup.sol b/compiler/test/libsolidity/semanticTests/array/fixed_array_cleanup.sol
new file mode 100644
index 00000000..b4d9a30e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_array_cleanup.sol
@@ -0,0 +1,21 @@
+contract c {
+    uint spacer1;
+    uint spacer2;
+    uint[20] data;
+    function fill() public {
+        for (uint i = 0; i < data.length; ++i) data[i] = i+1;
+    }
+    function clear() public { delete data; }
+}
+// ----
+// storageEmpty -> 1
+// fill() ->
+// gas irOptimized: 464834
+// gas legacy: 468818
+// gas legacyOptimized: 466238
+// storageEmpty -> 0
+// clear() ->
+// gas irOptimized: 122148
+// gas legacy: 122440
+// gas legacyOptimized: 122259
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol
new file mode 100644
index 00000000..dd909857
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol
@@ -0,0 +1,23 @@
+contract A {
+    function f(uint16 input) public pure returns (uint16[5] memory arr) {
+        arr[0] = input;
+        arr[1] = ++input;
+        arr[2] = ++input;
+        arr[3] = ++input;
+        arr[4] = ++input;
+    }
+}
+
+
+contract B {
+    function f() public returns (uint16[5] memory res, uint16[5] memory res2) {
+        A a = new A();
+        res = a.f(2);
+        res2 = a.f(1000);
+    }
+}
+// ----
+// f() -> 2, 3, 4, 5, 6, 1000, 1001, 1002, 1003, 1004
+// gas irOptimized: 114404
+// gas legacy: 230001
+// gas legacyOptimized: 130637
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol
new file mode 100644
index 00000000..ac11d779
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol
@@ -0,0 +1,16 @@
+contract Creator {
+    uint256 public r;
+    address public ch;
+
+    constructor(address[3] memory s, uint256 x) {
+        r = x;
+        ch = s[2];
+    }
+}
+// ----
+// constructor(): 1, 2, 3, 4 ->
+// gas irOptimized: 126363
+// gas legacy: 174186
+// gas legacyOptimized: 128709
+// r() -> 4
+// ch() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_storage.sol b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_storage.sol
new file mode 100644
index 00000000..b65a3d25
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_arrays_in_storage.sol
@@ -0,0 +1,45 @@
+contract c {
+    struct Data {
+        uint256 x;
+        uint256 y;
+    }
+    Data[2**10] data;
+    uint256[2**10 + 3] ids;
+
+    function setIDStatic(uint256 id) public {
+        ids[2] = id;
+    }
+
+    function setID(uint256 index, uint256 id) public {
+        ids[index] = id;
+    }
+
+    function setData(uint256 index, uint256 x, uint256 y) public {
+        data[index].x = x;
+        data[index].y = y;
+    }
+
+    function getID(uint256 index) public returns (uint256) {
+        return ids[index];
+    }
+
+    function getData(uint256 index) public returns (uint256 x, uint256 y) {
+        x = data[index].x;
+        y = data[index].y;
+    }
+
+    function getLengths() public returns (uint256 l1, uint256 l2) {
+        l1 = data.length;
+        l2 = ids.length;
+    }
+}
+// ----
+// setIDStatic(uint256): 0xb ->
+// getID(uint256): 0x2 -> 0xb
+// setID(uint256,uint256): 0x7, 0x8 ->
+// getID(uint256): 0x7 -> 0x8
+// setData(uint256,uint256,uint256): 0x7, 0x8, 0x9 ->
+// setData(uint256,uint256,uint256): 0x8, 0xa, 0xb ->
+// getData(uint256): 0x7 -> 0x8, 0x9
+// getData(uint256): 0x8 -> 0xa, 0xb
+// getLengths() -> 0x400, 0x403
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_bytes_length_access.sol b/compiler/test/libsolidity/semanticTests/array/fixed_bytes_length_access.sol
new file mode 100644
index 00000000..d641cd83
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_bytes_length_access.sol
@@ -0,0 +1,9 @@
+contract C {
+    bytes1 a;
+
+    function f(bytes32 x) public returns (uint256, uint256, uint256) {
+        return (x.length, bytes16(uint128(2)).length, a.length + 7);
+    }
+}
+// ----
+// f(bytes32): "789" -> 32, 16, 8
diff --git a/compiler/test/libsolidity/semanticTests/array/fixed_out_of_bounds_array_access.sol b/compiler/test/libsolidity/semanticTests/array/fixed_out_of_bounds_array_access.sol
new file mode 100644
index 00000000..1b3b6408
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/fixed_out_of_bounds_array_access.sol
@@ -0,0 +1,25 @@
+contract c {
+    uint256[4] data;
+
+    function set(uint256 index, uint256 value) public returns (bool) {
+        data[index] = value;
+        return true;
+    }
+
+    function get(uint256 index) public returns (uint256) {
+        return data[index];
+    }
+
+    function length() public returns (uint256) {
+        return data.length;
+    }
+}
+// ----
+// length() -> 4
+// set(uint256,uint256): 3, 4 -> true
+// set(uint256,uint256): 4, 5 -> FAILURE, hex"4e487b71", 0x32
+// set(uint256,uint256): 400, 5 -> FAILURE, hex"4e487b71", 0x32
+// get(uint256): 3 -> 4
+// get(uint256): 4 -> FAILURE, hex"4e487b71", 0x32
+// get(uint256): 400 -> FAILURE, hex"4e487b71", 0x32
+// length() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/array/function_array_cross_calls.sol b/compiler/test/libsolidity/semanticTests/array/function_array_cross_calls.sol
new file mode 100644
index 00000000..773e904c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/function_array_cross_calls.sol
@@ -0,0 +1,47 @@
+contract D {
+    function f(function() external returns (function() external returns (uint))[] memory x)
+        public returns (function() external returns (uint)[3] memory r) {
+        r[0] = x[0]();
+        r[1] = x[1]();
+        r[2] = x[2]();
+    }
+}
+
+
+contract C {
+    function test() public returns (uint256, uint256, uint256) {
+        function() external returns (function() external returns (uint))[] memory x =
+            new function() external returns (function() external returns (uint))[](10);
+        for (uint256 i = 0; i < x.length; i++) x[i] = this.h;
+        x[0] = this.htwo;
+        function() external returns (uint)[3] memory y = (new D()).f(x);
+        return (y[0](), y[1](), y[2]());
+    }
+
+    function e() public returns (uint256) {
+        return 5;
+    }
+
+    function f() public returns (uint256) {
+        return 6;
+    }
+
+    function g() public returns (uint256) {
+        return 7;
+    }
+
+    uint256 counter;
+
+    function h() public returns (function() external returns (uint)) {
+        return counter++ == 0 ? this.f : this.g;
+    }
+
+    function htwo() public returns (function() external returns (uint)) {
+        return this.e;
+    }
+}
+// ----
+// test() -> 5, 6, 7
+// gas irOptimized: 255728
+// gas legacy: 440376
+// gas legacyOptimized: 278651
diff --git a/compiler/test/libsolidity/semanticTests/array/function_memory_array.sol b/compiler/test/libsolidity/semanticTests/array/function_memory_array.sol
new file mode 100644
index 00000000..bdd23c67
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/function_memory_array.sol
@@ -0,0 +1,39 @@
+contract C {
+    function a(uint256 x) public returns (uint256) {
+        return x + 1;
+    }
+
+    function b(uint256 x) public returns (uint256) {
+        return x + 2;
+    }
+
+    function c(uint256 x) public returns (uint256) {
+        return x + 3;
+    }
+
+    function d(uint256 x) public returns (uint256) {
+        return x + 5;
+    }
+
+    function e(uint256 x) public returns (uint256) {
+        return x + 8;
+    }
+
+    function test(uint256 x, uint256 i) public returns (uint256) {
+        function(uint) internal returns (uint)[] memory arr =
+            new function(uint) internal returns (uint)[](10);
+        arr[0] = a;
+        arr[1] = b;
+        arr[2] = c;
+        arr[3] = d;
+        arr[4] = e;
+        return arr[i](x);
+    }
+}
+// ----
+// test(uint256,uint256): 10, 0 -> 11
+// test(uint256,uint256): 10, 1 -> 12
+// test(uint256,uint256): 10, 2 -> 13
+// test(uint256,uint256): 10, 3 -> 15
+// test(uint256,uint256): 10, 4 -> 18
+// test(uint256,uint256): 10, 5 -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/array/indexAccess/index_access.sol b/compiler/test/libsolidity/semanticTests/array/indexAccess/index_access.sol
new file mode 100644
index 00000000..c618ae8e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/indexAccess/index_access.sol
@@ -0,0 +1,18 @@
+contract C {
+    function to_little_endian_64(uint64 value) public pure returns (bytes memory ret) {
+        ret = new bytes(8);
+        bytes8 bytesValue = bytes8(value);
+        // Byteswapping during copying to bytes.
+        ret[0] = bytesValue[7];
+        ret[1] = bytesValue[6];
+        ret[2] = bytesValue[5];
+        ret[3] = bytesValue[4];
+        ret[4] = bytesValue[3];
+        ret[5] = bytesValue[2];
+        ret[6] = bytesValue[1];
+        ret[7] = bytesValue[0];
+    }
+}
+// ----
+// to_little_endian_64(uint64): 0 -> 0x20, 8, 0x00
+// to_little_endian_64(uint64): 0x0102030405060708 -> 0x20, 8, 0x0807060504030201000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_ints.sol b/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_ints.sol
new file mode 100644
index 00000000..0525f6f2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_ints.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (uint256) {
+        return ([1, 2, 3, 4][2]);
+    }
+}
+// ----
+// f() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_strings.sol b/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_strings.sol
new file mode 100644
index 00000000..bf6c0b0e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/indexAccess/inline_array_index_access_strings.sol
@@ -0,0 +1,14 @@
+contract C {
+    string public tester;
+
+    function f() public returns (string memory) {
+        return (["abc", "def", "g"][0]);
+    }
+
+    function test() public {
+        tester = f();
+    }
+}
+// ----
+// test() ->
+// tester() -> 0x20, 0x3, "abc"
diff --git a/compiler/test/libsolidity/semanticTests/array/indexAccess/memory_arrays_index_access_write.sol b/compiler/test/libsolidity/semanticTests/array/indexAccess/memory_arrays_index_access_write.sol
new file mode 100644
index 00000000..7a8a1867
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/indexAccess/memory_arrays_index_access_write.sol
@@ -0,0 +1,14 @@
+contract Test {
+    function set(uint24[3][4] memory x) public {
+        x[2][2] = 1;
+        x[3][2] = 7;
+    }
+
+    function f() public returns (uint24[3][4] memory) {
+        uint24[3][4] memory data;
+        set(data);
+        return data;
+    }
+}
+// ----
+// f() -> 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07
diff --git a/compiler/test/libsolidity/semanticTests/array/inline_array_return.sol b/compiler/test/libsolidity/semanticTests/array/inline_array_return.sol
new file mode 100644
index 00000000..25302dcb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/inline_array_return.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint8[] tester;
+
+    function f() public returns (uint8[5] memory) {
+        return ([1, 2, 3, 4, 5]);
+    }
+
+    function test() public returns (uint8, uint8, uint8, uint8, uint8) {
+        tester = f();
+        return (tester[0], tester[1], tester[2], tester[3], tester[4]);
+    }
+}
+// ----
+// f() -> 1, 2, 3, 4, 5
diff --git a/compiler/test/libsolidity/semanticTests/array/inline_array_singleton.sol b/compiler/test/libsolidity/semanticTests/array/inline_array_singleton.sol
new file mode 100644
index 00000000..b14ade6e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/inline_array_singleton.sol
@@ -0,0 +1,8 @@
+// This caused a failure since the type was not converted to its mobile type.
+contract C {
+    function f() public returns (uint256) {
+        return [4][0];
+    }
+}
+// ----
+// f() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_ints.sol b/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_ints.sol
new file mode 100644
index 00000000..e145d281
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_ints.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public returns (uint256 x, uint256 y) {
+        x = 3;
+        y = 6;
+        uint256[2] memory z = [x, y];
+        return (z[0], z[1]);
+    }
+}
+// ----
+// f() -> 3, 6
diff --git a/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_strings.sol b/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_strings.sol
new file mode 100644
index 00000000..7dfe6e64
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/inline_array_storage_to_memory_conversion_strings.sol
@@ -0,0 +1,11 @@
+contract C {
+    string s = "doh";
+
+    function f() public returns (string memory, string memory) {
+        string memory t = "ray";
+        string[3] memory x = [s, t, "mi"];
+        return (x[1], x[2]);
+    }
+}
+// ----
+// f() -> 0x40, 0x80, 0x3, "ray", 0x2, "mi"
diff --git a/compiler/test/libsolidity/semanticTests/array/inline_array_strings_from_document.sol b/compiler/test/libsolidity/semanticTests/array/inline_array_strings_from_document.sol
new file mode 100644
index 00000000..9cb16349
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/inline_array_strings_from_document.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(uint256 i) public returns (string memory) {
+        string[4] memory x = ["This", "is", "an", "array"];
+        return (x[i]);
+    }
+}
+// ----
+// f(uint256): 0 -> 0x20, 0x4, "This"
+// f(uint256): 1 -> 0x20, 0x2, "is"
+// f(uint256): 2 -> 0x20, 0x2, "an"
+// f(uint256): 3 -> 0x20, 0x5, "array"
diff --git a/compiler/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol b/compiler/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol
new file mode 100644
index 00000000..ddf67aa9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol
@@ -0,0 +1,95 @@
+contract C {
+    bytes public x = "abc";
+    bytes public y;
+    function invalidateXShort() public {
+        assembly { sstore(x.slot, 64) }
+        delete y;
+    }
+    function invalidateXLong() public {
+        assembly { sstore(x.slot, 5) }
+        delete y;
+    }
+    function abiEncode() public view returns (bytes memory) { return x; }
+    function abiEncodePacked() public view returns (bytes memory) { return abi.encodePacked(x); }
+    function copyToMemory() public view returns (bytes memory m) { m = x; }
+    function indexAccess() public view returns (bytes1) { return x[0]; }
+    function assignTo() public { x = "def"; }
+    function assignToLong() public { x = "1234567890123456789012345678901234567"; }
+    function copyToStorage() public { y = x; }
+    function copyFromStorageShort() public { y = "abc"; x = y; }
+    function copyFromStorageLong() public { y = "1234567890123456789012345678901234567"; x = y; }
+    function arrayPop() public { x.pop(); }
+    function arrayPush() public { x.push("t"); }
+    function arrayPushEmpty() public { x.push(); }
+    function del() public { delete x; }
+}
+// ----
+// x() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000
+// abiEncode() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000
+// abiEncodePacked() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000
+// copyToMemory() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000
+// indexAccess() -> 0x6100000000000000000000000000000000000000000000000000000000000000
+// arrayPushEmpty()
+// arrayPush()
+// x() -> 0x20, 5, 0x6162630074000000000000000000000000000000000000000000000000000000
+// arrayPop()
+// assignToLong()
+// x() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000
+// assignTo()
+// x() -> 0x20, 3, 0x6465660000000000000000000000000000000000000000000000000000000000
+// copyFromStorageShort()
+// x() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000
+// copyFromStorageLong()
+// gas irOptimized: 121106
+// gas legacy: 121904
+// gas legacyOptimized: 121398
+// x() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000
+// copyToStorage()
+// x() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000
+// y() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000
+// del()
+// x() -> 0x20, 0x00
+// invalidateXLong()
+// x() -> FAILURE, hex"4e487b71", 0x22
+// abiEncode() -> FAILURE, hex"4e487b71", 0x22
+// abiEncodePacked() -> FAILURE, hex"4e487b71", 0x22
+// copyToMemory() -> FAILURE, hex"4e487b71", 0x22
+// indexAccess() -> FAILURE, hex"4e487b71", 0x22
+// arrayPushEmpty() -> FAILURE, hex"4e487b71", 0x22
+// arrayPush() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// arrayPop() -> FAILURE, hex"4e487b71", 0x22
+// assignToLong() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// assignTo() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyFromStorageShort() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyFromStorageLong() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyToStorage() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// y() -> 0x20, 0x00
+// del() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// invalidateXShort()
+// x() -> FAILURE, hex"4e487b71", 0x22
+// abiEncode() -> FAILURE, hex"4e487b71", 0x22
+// abiEncodePacked() -> FAILURE, hex"4e487b71", 0x22
+// copyToMemory() -> FAILURE, hex"4e487b71", 0x22
+// indexAccess() -> FAILURE, hex"4e487b71", 0x22
+// arrayPushEmpty() -> FAILURE, hex"4e487b71", 0x22
+// arrayPush() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// arrayPop() -> FAILURE, hex"4e487b71", 0x22
+// assignToLong() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// assignTo() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyFromStorageShort() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyFromStorageLong() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// copyToStorage() -> FAILURE, hex"4e487b71", 0x22
+// x() -> FAILURE, hex"4e487b71", 0x22
+// y() -> 0x20, 0x00
diff --git a/compiler/test/libsolidity/semanticTests/array/memory.sol b/compiler/test/libsolidity/semanticTests/array/memory.sol
new file mode 100644
index 00000000..88c18d49
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/memory.sol
@@ -0,0 +1,14 @@
+pragma solidity >= 0.6.0;
+
+contract C {
+    function h(uint[4] memory n) public pure returns (uint) {
+        return n[0] + n[1] + n[2] + n[3];
+    }
+
+    function i(uint[4] memory n) public view returns (uint) {
+        return this.h(n) * 2;
+    }
+}
+// ----
+// h(uint256[4]): 1, 2, 3, 4 -> 10
+// i(uint256[4]): 1, 2, 3, 4 -> 20
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/array_pop_array_transition.sol b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_array_transition.sol
new file mode 100644
index 00000000..a08d27ac
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_array_transition.sol
@@ -0,0 +1,29 @@
+contract c {
+    uint256 a;
+    uint256 b;
+    uint256 c;
+    uint16[] inner = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    uint16[][] data;
+    function test() public returns (uint x, uint y, uint z) {
+        for (uint i = 1; i <= 48; i++)
+            data.push(inner);
+        for (uint j = 1; j <= 10; j++)
+            data.pop();
+        x = data[data.length - 1][0];
+        for (uint k = 1; k <= 10; k++)
+            data.pop();
+        y = data[data.length - 1][1];
+        for (uint l = 1; l <= 10; l++)
+            data.pop();
+        z = data[data.length - 1][2];
+        for (uint m = 1; m <= 18; m++)
+            data.pop();
+        delete inner;
+    }
+}
+// ----
+// test() -> 1, 2, 3
+// gas irOptimized: 1827730
+// gas legacy: 1822466
+// gas legacyOptimized: 1813404
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/array_pop_empty_exception.sol b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_empty_exception.sol
new file mode 100644
index 00000000..6130130d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_empty_exception.sol
@@ -0,0 +1,10 @@
+contract c {
+    uint256[] data;
+
+    function test() public returns (bool) {
+        data.pop();
+        return true;
+    }
+}
+// ----
+// test() -> FAILURE, hex"4e487b71", 0x31
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/array_pop_isolated.sol b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_isolated.sol
new file mode 100644
index 00000000..43d7c3a9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_isolated.sol
@@ -0,0 +1,12 @@
+// This tests that the compiler knows the correct size of the function on the stack.
+contract c {
+    uint256[] data;
+
+    function test() public returns (uint256 x) {
+        x = 2;
+        data.pop;
+        x = 3;
+    }
+}
+// ----
+// test() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint16_transition.sol b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint16_transition.sol
new file mode 100644
index 00000000..1b69ab33
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint16_transition.sol
@@ -0,0 +1,24 @@
+contract c {
+    uint16[] data;
+    function test() public returns (uint16 x, uint16 y, uint16 z) {
+        for (uint i = 1; i <= 48; i++)
+            data.push(uint16(i));
+        for (uint j = 1; j <= 10; j++)
+            data.pop();
+        x = data[data.length - 1];
+        for (uint k = 1; k <= 10; k++)
+            data.pop();
+        y = data[data.length - 1];
+        for (uint l = 1; l <= 10; l++)
+            data.pop();
+        z = data[data.length - 1];
+        for (uint m = 1; m <= 18; m++)
+            data.pop();
+    }
+}
+// ----
+// test() -> 38, 28, 18
+// gas irOptimized: 148538
+// gas legacy: 151184
+// gas legacyOptimized: 142418
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint24_transition.sol b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint24_transition.sol
new file mode 100644
index 00000000..d2e5995c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/array_pop_uint24_transition.sol
@@ -0,0 +1,24 @@
+contract c {
+    uint256 a;
+    uint256 b;
+    uint256 c;
+    uint24[] data;
+    function test() public returns (uint24 x, uint24 y) {
+        for (uint i = 1; i <= 30; i++)
+            data.push(uint24(i));
+        for (uint j = 1; j <= 10; j++)
+            data.pop();
+        x = data[data.length - 1];
+        for (uint k = 1; k <= 10; k++)
+            data.pop();
+        y = data[data.length - 1];
+        for (uint l = 1; l <= 10; l++)
+            data.pop();
+    }
+}
+// ----
+// test() -> 20, 10
+// gas irOptimized: 126068
+// gas legacy: 127216
+// gas legacyOptimized: 122224
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop.sol
new file mode 100644
index 00000000..8f015218
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop.sol
@@ -0,0 +1,16 @@
+contract c {
+    bytes data;
+
+    function test() public returns (uint256 x, uint256 y, uint256 l) {
+        data.push(0x07);
+        data.push(0x03);
+        x = data.length;
+        data.pop();
+        data.pop();
+        data.push(0x02);
+        y = data.length;
+        l = data.length;
+    }
+}
+// ----
+// test() -> 2, 1, 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_copy_long.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_copy_long.sol
new file mode 100644
index 00000000..c64d93c1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_copy_long.sol
@@ -0,0 +1,14 @@
+contract c {
+    bytes data;
+
+    function test() public returns (bytes memory) {
+        for (uint256 i = 0; i < 33; i++) data.push(0x03);
+        for (uint256 j = 0; j < 4; j++) data.pop();
+        return data;
+    }
+}
+// ----
+// test() -> 0x20, 29, 0x0303030303030303030303030303030303030303030303030303030303000000
+// gas irOptimized: 109310
+// gas legacy: 101220
+// gas legacyOptimized: 123422
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_empty_exception.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_empty_exception.sol
new file mode 100644
index 00000000..d860275e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_empty_exception.sol
@@ -0,0 +1,13 @@
+contract c {
+    uint256 a;
+    uint256 b;
+    uint256 c;
+    bytes data;
+
+    function test() public returns (bool) {
+        data.pop();
+        return true;
+    }
+}
+// ----
+// test() -> FAILURE, hex"4e487b71", 0x31
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_isolated.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_isolated.sol
new file mode 100644
index 00000000..f7422171
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_isolated.sol
@@ -0,0 +1,12 @@
+// This tests that the compiler knows the correct size of the function on the stack.
+contract c {
+    bytes data;
+
+    function test() public returns (uint256 x) {
+        x = 2;
+        data.pop;
+        x = 3;
+    }
+}
+// ----
+// test() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol
new file mode 100644
index 00000000..a3ba9d4d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol
@@ -0,0 +1,22 @@
+contract c {
+    uint256 a;
+    uint256 b;
+    uint256 c;
+    bytes data;
+    function test() public returns (bool) {
+        for (uint8 i = 0; i <= 40; i++)
+            data.push(bytes1(i+1));
+        for (int8 j = 40; j >= 0; j--) {
+            require(data[uint8(j)] == bytes1(uint8(j+1)));
+            require(data.length == uint8(j+1));
+            data.pop();
+        }
+        return true;
+    }
+}
+// ----
+// test() -> true
+// gas irOptimized: 140154
+// gas legacy: 178397
+// gas legacyOptimized: 163832
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol
new file mode 100644
index 00000000..a014e761
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty_garbage_ref.sol
@@ -0,0 +1,21 @@
+contract c {
+    uint256 a;
+    uint256 b;
+    bytes data;
+    function test() public {
+        for (uint8 i = 0; i <= 40; i++)
+            data.push(0x03);
+        for (uint8 j = 0; j <= 40; j++) {
+            assembly {
+                mstore(0, "garbage")
+            }
+            data.pop();
+        }
+    }
+}
+// ----
+// test() ->
+// gas irOptimized: 113782
+// gas legacy: 131245
+// gas legacyOptimized: 126668
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_masking_long.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_masking_long.sol
new file mode 100644
index 00000000..5b1a6183
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_masking_long.sol
@@ -0,0 +1,14 @@
+contract c {
+    bytes data;
+
+    function test() public returns (bytes memory) {
+        for (uint256 i = 0; i < 34; i++) data.push(0x03);
+        data.pop();
+        return data;
+    }
+}
+// ----
+// test() -> 0x20, 33, 0x303030303030303030303030303030303030303030303030303030303030303, 0x0300000000000000000000000000000000000000000000000000000000000000
+// gas irOptimized: 107343
+// gas legacy: 121408
+// gas legacyOptimized: 120534
diff --git a/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_storage_empty.sol b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_storage_empty.sol
new file mode 100644
index 00000000..a89f8a2a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/pop/byte_array_pop_storage_empty.sol
@@ -0,0 +1,14 @@
+contract c {
+    bytes data;
+    function test() public {
+        data.push(0x07);
+        data.push(0x05);
+        data.push(0x03);
+        data.pop();
+        data.pop();
+        data.pop();
+    }
+}
+// ----
+// test() ->
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/push/array_push.sol b/compiler/test/libsolidity/semanticTests/array/push/array_push.sol
new file mode 100644
index 00000000..3e7ceb5a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/array_push.sol
@@ -0,0 +1,21 @@
+contract c {
+    uint256[] data;
+
+    function test()
+        public
+        returns (uint256 x, uint256 y, uint256 z, uint256 l)
+    {
+        data.push(5);
+        x = data[0];
+        data.push(4);
+        y = data[1];
+        data.push(3);
+        l = data.length;
+        z = data[2];
+    }
+}
+// ----
+// test() -> 5, 4, 3, 3
+// gas irOptimized: 111363
+// gas legacy: 111807
+// gas legacyOptimized: 111122
diff --git a/compiler/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol b/compiler/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol
new file mode 100644
index 00000000..a010a993
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint8 b = 23;
+    uint120[][] s;
+    uint8 a = 17;
+    function f(uint120[] calldata c) public returns(uint120) {
+        s.push(c);
+        assert(s.length == 1);
+        assert(s[0].length == c.length);
+        assert(s[0].length > 0);
+        return s[0][0];
+    }
+}
+// ----
+// f(uint120[]): 0x20, 3, 1, 2, 3 -> 1
+// gas irOptimized: 112812
+// gas legacy: 113659
+// gas legacyOptimized: 113482
diff --git a/compiler/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol b/compiler/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol
new file mode 100644
index 00000000..e7a3bdbd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol
@@ -0,0 +1,18 @@
+contract c {
+    uint80[] x;
+
+    function test() public returns (uint80, uint80, uint80, uint80) {
+        x.push(1);
+        x.push(2);
+        x.push(3);
+        x.push(4);
+        x.push(5);
+        x.pop();
+        return (x[0], x[1], x[2], x[3]);
+    }
+}
+// ----
+// test() -> 1, 2, 3, 4
+// gas irOptimized: 93017
+// gas legacy: 92798
+// gas legacyOptimized: 92062
diff --git a/compiler/test/libsolidity/semanticTests/array/push/array_push_struct.sol b/compiler/test/libsolidity/semanticTests/array/push/array_push_struct.sol
new file mode 100644
index 00000000..06c5db88
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/array_push_struct.sol
@@ -0,0 +1,25 @@
+contract c {
+    struct S {
+        uint16 a;
+        uint16 b;
+        uint16[3] c;
+        uint16[] d;
+    }
+    S[] data;
+
+    function test() public returns (uint16, uint16, uint16, uint16) {
+        S memory s;
+        s.a = 2;
+        s.b = 3;
+        s.c[2] = 4;
+        s.d = new uint16[](4);
+        s.d[2] = 5;
+        data.push(s);
+        return (data[0].a, data[0].b, data[0].c[2], data[0].d[2]);
+    }
+}
+// ----
+// test() -> 2, 3, 4, 5
+// gas irOptimized: 135103
+// gas legacy: 147443
+// gas legacyOptimized: 146434
diff --git a/compiler/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol b/compiler/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol
new file mode 100644
index 00000000..4a33f816
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol
@@ -0,0 +1,21 @@
+pragma abicoder v2;
+
+contract c {
+    struct S {
+        uint16 a;
+        uint16 b;
+        uint16[3] c;
+        uint16[] d;
+    }
+    S[] data;
+
+    function test(S calldata c) public returns (uint16, uint16, uint16, uint16) {
+        data.push(c);
+        return (data[0].a, data[0].b, data[0].c[2], data[0].d[2]);
+    }
+}
+// ----
+// test((uint16,uint16,uint16[3],uint16[])): 0x20, 2, 3, 0, 0, 4, 0xC0, 4, 0, 0, 5, 0, 0 -> 2, 3, 4, 5
+// gas irOptimized: 137061
+// gas legacy: 142423
+// gas legacyOptimized: 137991
diff --git a/compiler/test/libsolidity/semanticTests/array/push/byte_array_push.sol b/compiler/test/libsolidity/semanticTests/array/push/byte_array_push.sol
new file mode 100644
index 00000000..2e0288d2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/byte_array_push.sol
@@ -0,0 +1,17 @@
+contract c {
+    bytes data;
+
+    function test() public returns (bool x) {
+        data.push(0x05);
+        if (data.length != 1) return true;
+        if (data[0] != 0x05) return true;
+        data.push(0x04);
+        if (data[1] != 0x04) return true;
+        data.push(0x03);
+        uint256 l = data.length;
+        if (data[2] != 0x03) return true;
+        if (l != 0x03) return true;
+    }
+}
+// ----
+// test() -> false
diff --git a/compiler/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol b/compiler/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol
new file mode 100644
index 00000000..5f1fe0fa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol
@@ -0,0 +1,20 @@
+// Tests transition between short and long encoding
+contract c {
+    bytes data;
+
+    function test() public returns (uint256) {
+        for (uint8 i = 1; i < 40; i++) {
+            data.push(bytes1(i));
+            if (data.length != i) return 0x1000 + i;
+            if (data[data.length - 1] != bytes1(i)) return i;
+        }
+        for (uint8 i = 1; i < 40; i++)
+            if (data[i - 1] != bytes1(i)) return 0x1000000 + i;
+        return 0;
+    }
+}
+// ----
+// test() -> 0
+// gas irOptimized: 167700
+// gas legacy: 206219
+// gas legacyOptimized: 197297
diff --git a/compiler/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol b/compiler/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol
new file mode 100644
index 00000000..30ed4792
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol
@@ -0,0 +1,18 @@
+pragma abicoder               v2;
+contract C {
+    bytes[] a;
+
+    function f() public {
+        a.push("abc");
+        a.push("abcdefghabcdefghabcdefghabcdefgh");
+        a.push("abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh");
+        assert(a[0][0] == "a");
+        assert(a[1][31] == "h");
+        assert(a[2][32] == "a");
+    }
+}
+// ----
+// f() ->
+// gas irOptimized: 179112
+// gas legacy: 181014
+// gas legacyOptimized: 180422
diff --git a/compiler/test/libsolidity/semanticTests/array/push/push_no_args_2d.sol b/compiler/test/libsolidity/semanticTests/array/push/push_no_args_2d.sol
new file mode 100644
index 00000000..6901e32b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/push_no_args_2d.sol
@@ -0,0 +1,45 @@
+contract C {
+	uint[][] array2d;
+
+	function l() public returns (uint) {
+		return array2d.length;
+	}
+
+	function ll(uint index) public returns (uint) {
+		return array2d[index].length;
+	}
+
+	function a(uint i, uint j) public returns (uint) {
+		return array2d[i][j];
+	}
+
+	function f(uint index, uint value) public {
+		uint[] storage pointer = array2d.push();
+		for (uint i = 0; i <= index; ++i)
+			pointer.push();
+		pointer[index] = value;
+	}
+
+	function lv(uint value) public {
+		array2d.push().push() = value;
+	}
+}
+// ----
+// l() -> 0
+// f(uint256,uint256): 42, 64 ->
+// gas irOptimized: 112266
+// gas legacy: 107920
+// gas legacyOptimized: 101897
+// l() -> 1
+// ll(uint256): 0 -> 43
+// a(uint256,uint256): 0, 42 -> 64
+// f(uint256,uint256): 84, 128 ->
+// gas irOptimized: 118686
+// gas legacy: 109972
+// gas legacyOptimized: 96331
+// l() -> 2
+// ll(uint256): 1 -> 85
+// a(uint256,uint256): 0, 42 -> 64
+// a(uint256,uint256): 1, 84 -> 128
+// lv(uint256): 512 ->
+// a(uint256,uint256): 2, 0 -> 512
diff --git a/compiler/test/libsolidity/semanticTests/array/push/push_no_args_bytes.sol b/compiler/test/libsolidity/semanticTests/array/push/push_no_args_bytes.sol
new file mode 100644
index 00000000..b19ebcc7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/push/push_no_args_bytes.sol
@@ -0,0 +1,31 @@
+contract C {
+	bytes array;
+
+	function f() public {
+		array.push();
+	}
+
+	function g(uint x) public {
+		for (uint i = 0; i < x; ++i)
+			array.push() = bytes1(uint8(i));
+	}
+
+	function l() public returns (uint) {
+		return array.length;
+	}
+
+	function a(uint index) public view returns (bytes1) {
+		return array[index];
+	}
+}
+// ----
+// l() -> 0
+// g(uint256): 70 ->
+// gas irOptimized: 180849
+// gas legacy: 175185
+// gas legacyOptimized: 175005
+// l() -> 70
+// a(uint256): 69 -> left(69)
+// f() ->
+// l() -> 71
+// a(uint256): 70 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/array/reusing_memory.sol b/compiler/test/libsolidity/semanticTests/array/reusing_memory.sol
new file mode 100644
index 00000000..92b0c06b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/reusing_memory.sol
@@ -0,0 +1,29 @@
+// Invoke some features that use memory and test that they do not interfere with each other.
+contract Helper {
+    uint256 public flag;
+
+    constructor(uint256 x) {
+        flag = x;
+    }
+}
+
+
+contract Main {
+    mapping(uint256 => uint256) map;
+
+    function f(uint256 x) public returns (uint256) {
+        map[x] = x;
+        return
+            (new Helper(uint256(keccak256(abi.encodePacked(this.g(map[x]))))))
+                .flag();
+    }
+
+    function g(uint256 a) public returns (uint256) {
+        return map[a];
+    }
+}
+// ----
+// f(uint256): 0x34 -> 0x46bddb1178e94d7f2892ff5f366840eb658911794f2c3a44c450aa2c505186c1
+// gas irOptimized: 111924
+// gas legacy: 125162
+// gas legacyOptimized: 113012
diff --git a/compiler/test/libsolidity/semanticTests/array/short_fixed_array_cleanup.sol b/compiler/test/libsolidity/semanticTests/array/short_fixed_array_cleanup.sol
new file mode 100644
index 00000000..8288e1e8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/short_fixed_array_cleanup.sol
@@ -0,0 +1,15 @@
+contract c {
+    uint spacer1;
+    uint spacer2;
+    uint[3] data;
+    function fill() public {
+        for (uint i = 0; i < data.length; ++i) data[i] = i+1;
+    }
+    function clear() public { delete data; }
+}
+// ----
+// storageEmpty -> 1
+// fill() ->
+// storageEmpty -> 0
+// clear() ->
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/array/slices/array_calldata_assignment.sol b/compiler/test/libsolidity/semanticTests/array/slices/array_calldata_assignment.sol
new file mode 100644
index 00000000..c9c489a8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/slices/array_calldata_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint256[] calldata x, uint256[] calldata y, uint256 i) external returns (uint256) {
+        x = y;
+        return x[i];
+    }
+}
+// ----
+// f(uint256[],uint256[],uint256): 0x60, 0xA0, 1, 1, 0, 2, 1, 2 -> 2
diff --git a/compiler/test/libsolidity/semanticTests/array/storage_array_ref.sol b/compiler/test/libsolidity/semanticTests/array/storage_array_ref.sol
new file mode 100644
index 00000000..37292ae8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/storage_array_ref.sol
@@ -0,0 +1,57 @@
+contract BinarySearch {
+    /// Finds the position of _value in the sorted list _data.
+    /// Note that "internal" is important here, because storage references only work for internal or private functions
+    function find(uint256[] storage _data, uint256 _value)
+        internal
+        returns (uint256 o_position)
+    {
+        return find(_data, 0, _data.length, _value);
+    }
+
+    function find(
+        uint256[] storage _data,
+        uint256 _begin,
+        uint256 _len,
+        uint256 _value
+    ) private returns (uint256 o_position) {
+        if (_len == 0 || (_len == 1 && _data[_begin] != _value))
+            return type(uint256).max; // failure
+        uint256 halfLen = _len / 2;
+        uint256 v = _data[_begin + halfLen];
+        if (_value < v) return find(_data, _begin, halfLen, _value);
+        else if (_value > v)
+            return find(_data, _begin + halfLen + 1, halfLen - 1, _value);
+        else return _begin + halfLen;
+    }
+}
+
+
+contract Store is BinarySearch {
+    uint256[] data;
+
+    function add(uint256 v) public {
+        data.push(0);
+        data[data.length - 1] = v;
+    }
+
+    function find(uint256 v) public returns (uint256) {
+        return find(data, v);
+    }
+}
+// ----
+// find(uint256): 7 -> -1
+// add(uint256): 7 ->
+// find(uint256): 7 -> 0
+// add(uint256): 11 ->
+// add(uint256): 17 ->
+// add(uint256): 27 ->
+// add(uint256): 31 ->
+// add(uint256): 32 ->
+// add(uint256): 66 ->
+// add(uint256): 177 ->
+// find(uint256): 7 -> 0
+// find(uint256): 27 -> 3
+// find(uint256): 32 -> 5
+// find(uint256): 176 -> -1
+// find(uint256): 0 -> -1
+// find(uint256): 400 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/array/string_allocation_bug.sol b/compiler/test/libsolidity/semanticTests/array/string_allocation_bug.sol
new file mode 100644
index 00000000..d6dadb78
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/string_allocation_bug.sol
@@ -0,0 +1,20 @@
+contract Sample {
+    struct s {
+        uint16 x;
+        uint16 y;
+        string a;
+        string b;
+    }
+    s[2] public p;
+
+    constructor() {
+        s memory m;
+        m.x = 0xbbbb;
+        m.y = 0xcccc;
+        m.a = "hello";
+        m.b = "world";
+        p[0] = m;
+    }
+}
+// ----
+// p(uint256): 0x0 -> 0xbbbb, 0xcccc, 0x80, 0xc0, 0x05, "hello", 0x05, "world"
diff --git a/compiler/test/libsolidity/semanticTests/array/strings_in_struct.sol b/compiler/test/libsolidity/semanticTests/array/strings_in_struct.sol
new file mode 100644
index 00000000..bacf8dec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/array/strings_in_struct.sol
@@ -0,0 +1,35 @@
+contract buggystruct {
+    Buggy public bug;
+
+    struct Buggy {
+        uint256 first;
+        uint256 second;
+        uint256 third;
+        string last;
+    }
+
+    constructor() {
+        bug = Buggy(10, 20, 30, "asdfghjkl");
+    }
+
+    function getFirst() public returns (uint256) {
+        return bug.first;
+    }
+
+    function getSecond() public returns (uint256) {
+        return bug.second;
+    }
+
+    function getThird() public returns (uint256) {
+        return bug.third;
+    }
+
+    function getLast() public returns (string memory) {
+        return bug.last;
+    }
+}
+// ----
+// getFirst() -> 0x0a
+// getSecond() -> 0x14
+// getThird() -> 0x1e
+// getLast() -> 0x20, 0x09, "asdfghjkl"
diff --git a/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_break.sol b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_break.sol
new file mode 100644
index 00000000..d74db942
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_break.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public returns (uint i) {
+        assembly {
+            for {} lt(i, 10) { i := add(i, 1) }
+            {
+                if eq(i, 6) { break }
+                i := add(i, 1)
+            }
+        }
+    }
+}
+// ----
+// f() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_continue.sol b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_continue.sol
new file mode 100644
index 00000000..f25a3c06
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_continue.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public returns (uint k) {
+        assembly {
+            for {let i := 0} lt(i, 10) { i := add(i, 1) }
+            {
+                if eq(mod(i, 2), 0) { continue }
+                k := add(k, 1)
+            }
+        }
+    }
+}
+// ----
+// f() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_nested.sol b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_nested.sol
new file mode 100644
index 00000000..3a13e9f0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/asmForLoop/for_loop_nested.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(uint x) public returns (uint i) {
+        assembly {
+            for {} lt(i, 10) { i := add(i, 1) }
+            {
+                if eq(x, 0) { i := 2 break }
+                for {} lt(x, 3) { i := 17 x := 9 } {
+                    if eq(x, 1) { continue }
+                    if eq(x, 2) { break }
+                }
+                if eq(x, 4) { i := 90 }
+            }
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 2
+// f(uint256): 1 -> 18
+// f(uint256): 2 -> 10
+// f(uint256): 4 -> 91
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/assignment_to_const_var_involving_keccak.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/assignment_to_const_var_involving_keccak.sol
new file mode 100644
index 00000000..2fc479d0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/assignment_to_const_var_involving_keccak.sol
@@ -0,0 +1,9 @@
+contract C {
+    bytes32 constant x = keccak256("abc");
+
+    function f() public returns (bytes32) {
+        return x;
+    }
+}
+// ----
+// f() -> 0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash.sol
new file mode 100644
index 00000000..445a011b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public view returns(bytes32) {
+        return blobhash(0);
+    }
+    function g() public view returns(bytes32) {
+        return blobhash(1);
+    }
+    function h() public view returns(bytes32) {
+        // NOTE: blobhash(2) should return 0 since EVMHost has only two blob hashes injected in the block the transaction is being executed.
+        return blobhash(2);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x0100000000000000000000000000000000000000000000000000000000000001
+// g() -> 0x0100000000000000000000000000000000000000000000000000000000000002
+// h() -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash_shadow_resolution.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash_shadow_resolution.sol
new file mode 100644
index 00000000..6a141cb9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/blobhash_shadow_resolution.sol
@@ -0,0 +1,12 @@
+contract C {
+    function blobhash(uint256 index) public pure returns(bytes32) {
+        return bytes32(index);
+    }
+    function f() public pure returns(bytes32) {
+        return blobhash(3);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x03
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash.sol
new file mode 100644
index 00000000..008a0467
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() public returns(bytes32) {
+        return blockhash(1);
+    }
+    function g() public returns(bytes32) {
+        return blockhash(2);
+    }
+    function h() public returns(bytes32) {
+        return blockhash(3);
+    }
+}
+// ----
+// f() -> 0x3737373737373737373737373737373737373737373737373737373737373738
+// g() -> 0x3737373737373737373737373737373737373737373737373737373737373739
+// h() -> 0x373737373737373737373737373737373737373737373737373737373737373a
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash_shadow_resolution.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash_shadow_resolution.sol
new file mode 100644
index 00000000..0b532da0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/blockhash_shadow_resolution.sol
@@ -0,0 +1,6 @@
+contract C {
+    function blockhash(uint256 blockNumber) public returns(bytes32) { bytes32 x; return x; }
+    function f() public returns(bytes32) { return blockhash(3); }
+}
+// ----
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/function_types_sig.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/function_types_sig.sol
new file mode 100644
index 00000000..2e771032
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/function_types_sig.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint256 public x;
+
+    function f() public pure returns (bytes4) {
+        return this.f.selector;
+    }
+
+    function g() public returns (bytes4) {
+        function () pure external returns (bytes4) fun = this.f;
+        return fun.selector;
+    }
+
+    function h() public returns (bytes4) {
+        function () pure external returns (bytes4) fun = this.f;
+        return fun.selector;
+    }
+
+    function i() public pure returns (bytes4) {
+        return this.x.selector;
+    }
+}
+// ----
+// f() -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// g() -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// h() -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// i() -> 0x0c55699c00000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256.sol
new file mode 100644
index 00000000..e01a5695
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f(int256 input) public returns (bytes32 sha256hash) {
+        return keccak256(abi.encodePacked(bytes32(uint256(input))));
+    }
+}
+// ----
+// f(int256): 4 -> 0x8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b
+// f(int256): 5 -> 0x036b6384b5eca791c62761152d0c79bb0604c104a5fb6f4eb0703f3154bb3db0
+// f(int256): -1 -> 0xa9c584056064687e149968cbab758a3376d22aedc6a55823d1b3ecbee81b8fb9
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_empty.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_empty.sol
new file mode 100644
index 00000000..f75c569e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_empty.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bytes32) {
+        return keccak256("");
+    }
+}
+// ----
+// f() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed.sol
new file mode 100644
index 00000000..cad49dae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(int256 _input) public returns (bytes32 hash) {
+        uint24 b = 65536;
+        uint c = 256;
+        bytes32 input = bytes32(uint256(_input));
+        return keccak256(abi.encodePacked(uint8(8), input, b, input, c));
+    }
+}
+// ----
+// f(int256): 4 -> 0xd270285b9966fefc715561efcd09d5b6a8deb15596f7c53cb4a1bb73aa55ac3a
+// f(int256): 5 -> 0xf2f92566c5653600c1e527a7073e5d881576d12bb51887c0b8f3e1f81865b03d
+// f(int256): -1 -> 0xbc78b45e0db67af5af72e4ab62757c67aefa7388cdf0c4e74f8b5fe9dd5d9d13
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol
new file mode 100644
index 00000000..ea6d7818
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint120[3] x;
+    function f() public returns (bytes32 hash1, bytes32 hash2, bytes32 hash3) {
+        uint120[] memory y = new uint120[](3);
+        x[0] = y[0] = uint120(type(uint).max - 1);
+        x[1] = y[1] = uint120(type(uint).max - 2);
+        x[2] = y[2] = uint120(type(uint).max - 3);
+        hash1 = keccak256(abi.encodePacked(x));
+        hash2 = keccak256(abi.encodePacked(y));
+        hash3 = keccak256(abi.encodePacked(this.f));
+    }
+}
+// ----
+// f() -> 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0x0e9229fb1d2cd02cee4b6c9f25497777014a8766e3479666d1c619066d2887ec
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_with_bytes.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_with_bytes.sol
new file mode 100644
index 00000000..1904e814
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/keccak256_with_bytes.sol
@@ -0,0 +1,12 @@
+contract c {
+    bytes data;
+
+    function foo() public returns (bool) {
+        data.push("f");
+        data.push("o");
+        data.push("o");
+        return keccak256(data) == keccak256("foo");
+    }
+}
+// ----
+// foo() -> true
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig.sol
new file mode 100644
index 00000000..f28658fe
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig.sol
@@ -0,0 +1,7 @@
+contract test {
+    function foo(uint256 a) public returns (bytes4 value) {
+        return msg.sig;
+    }
+}
+// ----
+// foo(uint256): 0x0 -> 0x2fbebd3800000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig_after_internal_call_is_same.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig_after_internal_call_is_same.sol
new file mode 100644
index 00000000..7ff53efa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/msg_sig_after_internal_call_is_same.sol
@@ -0,0 +1,11 @@
+contract test {
+    function boo() public returns (bytes4 value) {
+        return msg.sig;
+    }
+
+    function foo(uint256 a) public returns (bytes4 value) {
+        return boo();
+    }
+}
+// ----
+// foo(uint256): 0x0 -> 0x2fbebd3800000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160.sol
new file mode 100644
index 00000000..e070a65f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f(int256 input) public returns (bytes32 sha256hash) {
+        return ripemd160(abi.encodePacked(bytes32(uint256(input))));
+    }
+}
+// ----
+// f(int256): 4 -> 0x1b0f3c404d12075c68c938f9f60ebea4f74941a0000000000000000000000000
+// f(int256): 5 -> 0xee54aa84fc32d8fed5a5fe160442ae84626829d9000000000000000000000000
+// f(int256): -1 -> 0x1cf4e77f5966e13e109703cd8a0df7ceda7f3dc3000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_empty.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_empty.sol
new file mode 100644
index 00000000..330fafc4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_empty.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bytes20) {
+        return ripemd160("");
+    }
+}
+// ----
+// f() -> 0x9c1185a5c5e9fc54612808977ee8f548b2258d31000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_packed.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_packed.sol
new file mode 100644
index 00000000..733bd420
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/ripemd160_packed.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(int256 _input) public returns (bytes32 hash) {
+        uint24 b = 65536;
+        uint c = 256;
+        bytes32 input = bytes32(uint256(_input));
+        return ripemd160(abi.encodePacked(uint8(8), input, b, input, c));
+    }
+}
+// ----
+// f(int256): 4 -> 0xf93175303eba2a7b372174fc9330237f5ad202fc000000000000000000000000
+// f(int256): 5 -> 0x04f4fc112e2bfbe0d38f896a46629e08e2fcfad5000000000000000000000000
+// f(int256): -1 -> 0xc0a2e4b1f3ff766a9a0089e7a410391730872495000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256.sol
new file mode 100644
index 00000000..4060a7fa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f(int256 input) public returns (bytes32 sha256hash) {
+        return sha256(abi.encodePacked(bytes32(uint256(input))));
+    }
+}
+// ----
+// f(int256): 4 -> 0xe38990d0c7fc009880a9c07c23842e886c6bbdc964ce6bdd5817ad357335ee6f
+// f(int256): 5 -> 0x96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47
+// f(int256): -1 -> 0xaf9613760f72635fbdb44a5a0a63c39f12af30f950a6ee5c971be188e89c4051
diff --git a/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256_packed.sol b/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256_packed.sol
new file mode 100644
index 00000000..19959c44
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/builtinFunctions/sha256_packed.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(int256 _input) public returns (bytes32 hash) {
+        uint24 b = 65536;
+        uint c = 256;
+        bytes32 input = bytes32(uint256(_input));
+        return sha256(abi.encodePacked(uint8(8), input, b, input, c));
+    }
+}
+// ----
+// f(int256): 4 -> 0x804e0d7003cfd70fc925dc103174d9f898ebb142ecc2a286da1abd22ac2ce3ac
+// f(int256): 5 -> 0xe94921945f9068726c529a290a954f412bcac53184bb41224208a31edbf63cf0
+// f(int256): -1 -> 0xf14def4d07cd185ddd8b10a81b2238326196a38867e6e6adbcc956dc913488c7
diff --git a/compiler/test/libsolidity/semanticTests/byte_array_to_storage_cleanup.sol b/compiler/test/libsolidity/semanticTests/byte_array_to_storage_cleanup.sol
new file mode 100644
index 00000000..dc77f0df
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/byte_array_to_storage_cleanup.sol
@@ -0,0 +1,37 @@
+contract C {
+    event ev(uint[], uint);
+    bytes public s;
+    function h() external returns (bytes memory) {
+        uint[] memory x = new uint[](2);
+        emit ev(x, 0x21);
+        bytes memory m = new bytes(63);
+        s = m;
+        s.push();
+        return s;
+    }
+    function g() external returns (bytes memory) {
+        bytes memory m = new bytes(63);
+        assembly {
+            mstore8(add(m, add(32, 63)), 0x42)
+        }
+        s = m;
+        s.push();
+        return s;
+    }
+    function f(bytes calldata c) external returns (bytes memory) {
+        s = c;
+        s.push();
+        return s;
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// constructor() ->
+// gas irOptimized: 443406
+// gas legacy: 711299
+// gas legacyOptimized: 482382
+// h() -> 0x20, 0x40, 0x00, 0
+// ~ emit ev(uint256[],uint256): 0x40, 0x21, 0x02, 0x00, 0x00
+// g() -> 0x20, 0x40, 0, 0x00
+// f(bytes): 0x20, 33, 0, -1 -> 0x20, 0x22, 0, 0xff00000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/c99_scoping_activation.sol b/compiler/test/libsolidity/semanticTests/c99_scoping_activation.sol
new file mode 100644
index 00000000..6edf9db4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/c99_scoping_activation.sol
@@ -0,0 +1,41 @@
+contract test {
+    function f() pure public returns (uint) {
+        uint x = 7;
+        {
+            x = 3; // This should still assign to the outer variable
+            uint x;
+            x = 4; // This should assign to the new one
+        }
+        return x;
+    }
+    function g() pure public returns (uint x) {
+        x = 7;
+        {
+            x = 3;
+            uint x;
+            return x; // This returns the new variable, i.e. 0
+        }
+    }
+    function h() pure public returns (uint x, uint a, uint b) {
+        x = 7;
+        {
+            x = 3;
+            a = x; // This should read from the outer
+            uint x = 4;
+            b = x;
+        }
+    }
+    function i() pure public returns (uint x, uint a) {
+        x = 7;
+        {
+            x = 3;
+            uint x = x; // This should read from the outer and assign to the inner
+            a = x;
+        }
+    }
+}
+// ----
+// f() -> 3
+// g() -> 0
+// h() -> 3, 3, 4
+// i() -> 3, 3
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_array_access.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_access.sol
new file mode 100644
index 00000000..6dedc2a7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_access.sol
@@ -0,0 +1,18 @@
+pragma abicoder               v2;
+contract C {
+    function f(uint256[] calldata x, uint256 i) external returns (uint256) {
+        return x[i];
+    }
+    function f(uint256[][] calldata x, uint256 i, uint256 j) external returns (uint256) {
+        return x[i][j];
+    }
+}
+// ----
+// f(uint256[],uint256): 0x40, 0, 0 -> FAILURE, hex"4e487b71", 0x32
+// f(uint256[],uint256): 0x40, 0, 1, 23 -> 23
+// f(uint256[],uint256): 0x40, 1, 1, 23 -> FAILURE, hex"4e487b71", 0x32
+// f(uint256[],uint256): 0x40, 0, 2, 23, 42 -> 23
+// f(uint256[],uint256): 0x40, 1, 2, 23, 42 -> 42
+// f(uint256[],uint256): 0x40, 2, 2, 23, 42 -> FAILURE, hex"4e487b71", 0x32
+// f(uint256[][],uint256,uint256): 0x60, 0, 0 -> FAILURE
+// f(uint256[][],uint256,uint256): 0x60, 0, 0, 1, 0x20, 1, 23 -> 23
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_array_index_range_access.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_index_range_access.sol
new file mode 100644
index 00000000..634e3569
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_index_range_access.sol
@@ -0,0 +1,43 @@
+pragma abicoder               v2;
+contract C {
+    function f(uint256[] calldata x, uint256 s, uint256 e) external returns (uint256) {
+        return uint256[](x[s:e]).length;
+    }
+    function f(uint256[] calldata x, uint256 s, uint256 e, uint256 ss, uint256 ee) external returns (uint256) {
+        return uint256[](x[s:e][ss:ee]).length;
+    }
+    function f_s_only(uint256[] calldata x, uint256 s) external returns (uint256) {
+        return uint256[](x[s:]).length;
+    }
+    function f_e_only(uint256[] calldata x, uint256 e) external returns (uint256) {
+        return uint256[](x[:e]).length;
+    }
+    function g(uint256[] calldata x, uint256 s, uint256 e, uint256 idx) external returns (uint256) {
+        return uint256[](x[s:e])[idx];
+    }
+    function gg(uint256[] calldata x, uint256 s, uint256 e, uint256 idx) external returns (uint256) {
+        return x[s:e][idx];
+    }
+    function gg_s_only(uint256[] calldata x, uint256 s, uint256 idx) external returns (uint256) {
+        return x[s:][idx];
+    }
+    function gg_e_only(uint256[] calldata x, uint256 e, uint256 idx) external returns (uint256) {
+        return x[:e][idx];
+    }
+}
+// ----
+// f(uint256[],uint256,uint256): 0x60, 2, 4, 5, 1, 2, 3, 4, 5 -> 2
+// f(uint256[],uint256,uint256): 0x60, 2, 6, 5, 1, 2, 3, 4, 5 -> FAILURE
+// f(uint256[],uint256,uint256): 0x60, 3, 3, 5, 1, 2, 3, 4, 5 -> 0
+// f(uint256[],uint256,uint256): 0x60, 4, 3, 5, 1, 2, 3, 4, 5 -> FAILURE
+// f(uint256[],uint256,uint256): 0x60, 0, 3, 5, 1, 2, 3, 4, 5 -> 3
+// f(uint256[],uint256,uint256,uint256,uint256): 0xA0, 1, 3, 1, 2, 5, 1, 2, 3, 4, 5 -> 1
+// f(uint256[],uint256,uint256,uint256,uint256): 0xA0, 1, 3, 1, 4, 5, 1, 2, 3, 4, 5 -> FAILURE
+// f_s_only(uint256[],uint256): 0x40, 2, 5, 1, 2, 3, 4, 5 -> 3
+// f_s_only(uint256[],uint256): 0x40, 6, 5, 1, 2, 3, 4, 5 -> FAILURE
+// f_e_only(uint256[],uint256): 0x40, 3, 5, 1, 2, 3, 4, 5 -> 3
+// f_e_only(uint256[],uint256): 0x40, 6, 5, 1, 2, 3, 4, 5 -> FAILURE
+// g(uint256[],uint256,uint256,uint256): 0x80, 2, 4, 1, 5, 1, 2, 3, 4, 5 -> 4
+// g(uint256[],uint256,uint256,uint256): 0x80, 2, 4, 3, 5, 1, 2, 3, 4, 5 -> FAILURE, hex"4e487b71", 0x32
+// gg(uint256[],uint256,uint256,uint256): 0x80, 2, 4, 1, 5, 1, 2, 3, 4, 5 -> 4
+// gg(uint256[],uint256,uint256,uint256): 0x80, 2, 4, 3, 5, 1, 2, 3, 4, 5 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_array_length.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_length.sol
new file mode 100644
index 00000000..779d261a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_length.sol
@@ -0,0 +1,32 @@
+pragma abicoder               v2;
+contract C {
+    function f(uint256[] calldata x) external returns (uint256) {
+        return x.length;
+    }
+    function f(uint256[][] calldata x) external returns (uint256 l1, uint256 l2, uint256 l3) {
+        l1 = x.length;
+        if (l1 > 0) l2 = x[0].length;
+        if (l1 > 1) l3 = x[1].length;
+    }
+    function f(uint256[2] calldata x) external returns (uint256) {
+        return x.length;
+    }
+}
+// ----
+// f(uint256[]): 0x20, 0 -> 0
+// f(uint256[]): 0x20, 1, 23 -> 1
+// f(uint256[]): 0x20, 2, 23, 42 -> 2
+// f(uint256[]): 0x20, 3, 23, 42, 17 -> 3
+// f(uint256[2]): 23, 42 -> 2
+// f(uint256[][]): 0x20, 0 -> 0, 0, 0
+// f(uint256[][]): 0x20, 1, 0x20, 0 -> 1, 0, 0
+// f(uint256[][]): 0x20, 1, 0x00 -> 1, 0, 0
+// f(uint256[][]): 0x20, 1, 0x20, 1, 23 -> 1, 1, 0
+// f(uint256[][]): 0x20, 1, 0x20, 2, 23, 42 -> 1, 2, 0
+// f(uint256[][]): 0x20, 1, 0x40, 0, 2, 23, 42 -> 1, 2, 0
+// f(uint256[][]): 0x20, 1, -32 -> 1, 1, 0
+// f(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 23, 42 -> 2, 2, 2
+// f(uint256[][]): 0x20, 2, 0x40, 0xa0, 2, 23, 42, 0 -> 2, 2, 0
+// f(uint256[][]): 0x20, 2, 0xA0, 0x40, 2, 23, 42, 0 -> 2, 0, 2
+// f(uint256[][]): 0x20, 2, 0x40, 0xA0, 2, 23, 42, 1, 17 -> 2, 2, 1
+// f(uint256[][]): 0x20, 2, 0x40, 0xA0, 2, 23, 42, 2, 17, 13 -> 2, 2, 2
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_array_three_dimensional.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_three_dimensional.sol
new file mode 100644
index 00000000..42c360be
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_array_three_dimensional.sol
@@ -0,0 +1,18 @@
+pragma abicoder               v2;
+
+contract C {
+	function f(uint256[][2][] calldata x, uint256 i, uint256 j, uint256 k) external returns (uint256 a, uint256 b, uint256 c, uint256 d) {
+		a = x.length;
+		b = x[i].length;
+		c = x[i][j].length;
+		d = x[i][j][k];
+    }
+}
+// ----
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 0, 0, 1, 0x20, 0x40, 0x80, 1, 42, 1, 23 -> 1, 2, 1, 42
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 1, 0, 1, 0x20, 0x40, 0x80, 1, 42, 1, 23 -> 1, 2, 1, 23
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 1, 0, 1, 0x20, 0x40, 0x80, 1, 42, 2, 23, 17 -> 1, 2, 2, 23
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 1, 1, 1, 0x20, 0x40, 0x80, 1, 42, 2, 23, 17 -> 1, 2, 2, 17
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 1, 0, 0, 1, 0x20, 0x40, 0x80, 1, 42, 1, 23 -> FAILURE, hex"4e487b71", 0x32
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 2, 0, 1, 0x20, 0x40, 0x80, 1, 42, 1, 23 -> FAILURE, hex"4e487b71", 0x32
+// f(uint256[][2][],uint256,uint256,uint256): 0x80, 0, 2, 0, 1, 0x20, 0x40, 0x80, 1, 42, 1, 23 -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_bytes.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_bytes.sol
new file mode 100644
index 00000000..1b6e7379
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_bytes.sol
@@ -0,0 +1,17 @@
+pragma abicoder v2;
+
+library L {
+    function reverse(bytes calldata _b) internal pure returns (bytes1, bytes1) {
+        return (_b[1], _b[0]);
+    }
+}
+
+contract C {
+    using L for bytes;
+
+    function test(uint, bytes calldata _b, uint) external pure returns (bytes1, bytes1) {
+        return _b.reverse();
+    }
+}
+// ----
+// test(uint256,bytes,uint256): 7, 0x60, 4, 2, "ab" -> "b", "a"
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_dynamic_array_or_slice.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_dynamic_array_or_slice.sol
new file mode 100644
index 00000000..5803ef6e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_dynamic_array_or_slice.sol
@@ -0,0 +1,22 @@
+pragma abicoder v2;
+
+library L {
+    function reverse(uint[] calldata _a) internal pure returns (uint, uint) {
+        return (_a[1], _a[0]);
+    }
+}
+
+contract C {
+    using L for *;
+
+    function testArray(uint, uint[] calldata _a, uint) external pure returns (uint, uint) {
+        return _a.reverse();
+    }
+
+    function testSlice(uint, uint[] calldata _a, uint) external pure returns (uint, uint) {
+        return _a[:].reverse();
+    }
+}
+// ----
+// testArray(uint256,uint256[],uint256): 7, 0x60, 4, 2, 66, 77 -> 77, 66
+// testSlice(uint256,uint256[],uint256): 7, 0x60, 4, 2, 66, 77 -> 77, 66
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_static_array.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_static_array.sol
new file mode 100644
index 00000000..a5158dad
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_static_array.sol
@@ -0,0 +1,17 @@
+pragma abicoder v2;
+
+library L {
+    function reverse(uint[2] calldata _a) internal pure returns (uint, uint) {
+        return (_a[1], _a[0]);
+    }
+}
+
+contract C {
+    using L for uint[2];
+
+    function test(uint, uint[2] calldata _a, uint) external pure returns (uint, uint) {
+        return _a.reverse();
+    }
+}
+// ----
+// test(uint256,uint256[2],uint256): 7, 66, 77, 4 -> 77, 66
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_struct.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_struct.sol
new file mode 100644
index 00000000..ee442047
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_attached_to_struct.sol
@@ -0,0 +1,22 @@
+pragma abicoder v2;
+
+struct S {
+    uint x;
+    uint y;
+}
+
+library L {
+    function reverse(S calldata _s) internal pure returns (uint, uint) {
+        return (_s.y, _s.x);
+    }
+}
+
+contract C {
+    using L for S;
+
+    function test(uint, S calldata _s, uint) external pure returns (uint, uint) {
+        return _s.reverse();
+    }
+}
+// ----
+// test(uint256,(uint256,uint256),uint256): 7, 66, 77, 4 -> 77, 66
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_bytes_array_bounds.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_bytes_array_bounds.sol
new file mode 100644
index 00000000..eb19897c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_bytes_array_bounds.sol
@@ -0,0 +1,10 @@
+pragma abicoder               v2;
+contract C {
+    function f(bytes[] calldata a, uint256 i) external returns (uint) {
+        return uint8(a[0][i]);
+    }
+}
+// ----
+// f(bytes[],uint256): 0x40, 0, 1, 0x20, 2, hex"6162" -> 0x61
+// f(bytes[],uint256): 0x40, 1, 1, 0x20, 2, hex"6162" -> 0x62
+// f(bytes[],uint256): 0x40, 2, 1, 0x20, 2, hex"6162" -> FAILURE, hex"4e487b71", 0x32
diff --git a/compiler/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol b/compiler/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol
new file mode 100644
index 00000000..45b323b3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/calldata_struct_cleaning.sol
@@ -0,0 +1,22 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint8 a;
+        bytes1 b;
+    }
+
+    function f(S calldata s) external pure returns (uint256 a, bytes32 b) {
+        uint8 tmp1 = s.a;
+        bytes1 tmp2 = s.b;
+        assembly {
+            a := tmp1
+            b := tmp2
+        }
+    }
+}
+// ----
+// f((uint8,bytes1)): 0x12, hex"3400000000000000000000000000000000000000000000000000000000000000" -> 0x12, hex"3400000000000000000000000000000000000000000000000000000000000000" # double check that the valid case goes through #
+// f((uint8,bytes1)): 0x1234, hex"5678000000000000000000000000000000000000000000000000000000000000" -> FAILURE
+// f((uint8,bytes1)): 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/calldata/copy_from_calldata_removes_bytes_data.sol b/compiler/test/libsolidity/semanticTests/calldata/copy_from_calldata_removes_bytes_data.sol
new file mode 100644
index 00000000..aedf5ada
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/calldata/copy_from_calldata_removes_bytes_data.sol
@@ -0,0 +1,17 @@
+contract c {
+    function set() public returns (bool) { data = msg.data; return true; }
+    function checkIfDataIsEmpty() public returns (bool) { return data.length == 0; }
+    function sendMessage() public returns (bool, bytes memory) { bytes memory emptyData; return address(this).call(emptyData);}
+    fallback() external { data = msg.data; }
+    bytes data;
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// (): 1, 2, 3, 4, 5 ->
+// gas irOptimized: 155130
+// gas legacy: 155473
+// gas legacyOptimized: 155295
+// checkIfDataIsEmpty() -> false
+// sendMessage() -> true, 0x40, 0
+// checkIfDataIsEmpty() -> true
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol b/compiler/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol
new file mode 100644
index 00000000..003cdb0e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/bool_conversion_v2.sol
@@ -0,0 +1,24 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(bool _b) public returns (uint256) {
+        if (_b) return 1;
+        else return 0;
+    }
+
+    function g(bool _in) public returns (bool _out) {
+        _out = _in;
+    }
+}
+// ----
+// f(bool): 0x0 -> 0x0
+// f(bool): 0x1 -> 0x1
+// f(bool): 0x2 -> FAILURE
+// f(bool): 0x3 -> FAILURE
+// f(bool): 0xff -> FAILURE
+// g(bool): 0x0 -> 0x0
+// g(bool): 0x1 -> 0x1
+// g(bool): 0x2 -> FAILURE
+// g(bool): 0x3 -> FAILURE
+// g(bool): 0xff -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_shortening.sol b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_shortening.sol
new file mode 100644
index 00000000..8718cb2e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_shortening.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f() public pure returns (address r) {
+        bytes21 x = 0x1122334455667788990011223344556677889900ff;
+        bytes20 y;
+        assembly {
+            y := x
+        }
+        address z = address(y);
+        assembly {
+            r := z
+        }
+        require(z == 0x1122334455667788990011223344556677889900);
+    }
+
+    function g() public pure returns (address payable r) {
+        bytes21 x = 0x1122334455667788990011223344556677889900ff;
+        bytes20 y;
+        assembly {
+            y := x
+        }
+        address payable z = payable(address(y));
+        assembly {
+            r := z
+        }
+        require(z == 0x1122334455667788990011223344556677889900);
+    }
+}
+// ----
+// f() -> 0x1122334455667788990011223344556677889900
+// g() -> 0x1122334455667788990011223344556677889900
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol
new file mode 100644
index 00000000..73db35c3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_address_types_v2.sol
@@ -0,0 +1,18 @@
+pragma abicoder               v2;
+
+
+// Checks that address types are properly cleaned before they are compared.
+contract C {
+    function f(address a) public returns (uint256) {
+        if (a != 0x1234567890123456789012345678901234567890) return 1;
+        return 0;
+    }
+
+    function g(address payable a) public returns (uint256) {
+        if (a != 0x1234567890123456789012345678901234567890) return 1;
+        return 0;
+    }
+}
+// ----
+// f(address): 0xffff1234567890123456789012345678901234567890 -> FAILURE # We input longer data on purpose.#
+// g(address): 0xffff1234567890123456789012345678901234567890 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_shortening_newCodeGen.sol b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_shortening_newCodeGen.sol
new file mode 100644
index 00000000..b26ba564
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_shortening_newCodeGen.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure returns (bytes32 r) {
+        bytes4 x = 0xffffffff;
+        bytes2 y = bytes2(x);
+        assembly {
+            r := y
+        }
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 0xffff000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol
new file mode 100644
index 00000000..8a95f10c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_bytes_types_v2.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+// Checks that bytesXX types are properly cleaned before they are compared.
+contract C {
+    function f(bytes2 a, uint16 x) public returns (uint256) {
+        if (a != "ab") return 1;
+        if (x != 0x0102) return 2;
+        if (bytes3(uint24(x)) != 0x000102) return 3;
+        return 0;
+    }
+}
+// ----
+// f(bytes2,uint16): "abc", 0x40102 -> FAILURE # We input longer data on purpose. #
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/cleanup_in_compound_assign.sol b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_in_compound_assign.sol
new file mode 100644
index 00000000..e0e62971
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/cleanup_in_compound_assign.sol
@@ -0,0 +1,12 @@
+contract C {
+    function test() public returns (uint256, uint256) {
+        uint32 a = 0xffffffff;
+        uint16 x = uint16(a);
+        uint16 y = x;
+        x /= 0x100;
+        y = y / 0x100;
+        return (x, y);
+    }
+}
+// ----
+// test() -> 0xff, 0xff
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup.sol b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup.sol
new file mode 100644
index 00000000..746f21ef
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public pure returns (uint x) {
+        unchecked {
+            uint8 y = uint8(2)**uint8(8);
+            return 0**y;
+        }
+    }
+}
+// ----
+// f() -> 0x1
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_direct.sol b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_direct.sol
new file mode 100644
index 00000000..62f927b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_direct.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (uint8 x) {
+        unchecked {
+            return uint8(0)**uint8(uint8(2)**uint8(8));
+        }
+    }
+}
+// ----
+// f() -> 0x1
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_nonzero_base.sol b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_nonzero_base.sol
new file mode 100644
index 00000000..de55afa9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_nonzero_base.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public pure returns (uint8 x) {
+        unchecked {
+			uint16 x = 0x166;
+            return uint8(x)**uint8(uint8(2)**uint8(8));
+        }
+    }
+}
+// ----
+// f() -> 0x1
diff --git a/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_smaller_base.sol b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_smaller_base.sol
new file mode 100644
index 00000000..7b81d0a1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/cleanup/exp_cleanup_smaller_base.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure returns (uint16 x) {
+        // tests that ``e`` is not converted to uint8
+        // right before the exp
+        uint16 e = 0x100;
+        uint8 b = 0x2;
+        unchecked {
+            return b**e;
+        }
+    }
+}
+// ----
+// f() -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/constantEvaluator/negative_fractional_mod.sol b/compiler/test/libsolidity/semanticTests/constantEvaluator/negative_fractional_mod.sol
new file mode 100644
index 00000000..4426f0c0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constantEvaluator/negative_fractional_mod.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (int, int) {
+        int x = int((-(-5.2 % 3)) * 5);
+        int t = 5;
+        return (x, (-(-t % 3)) * 5);
+    }
+}
+// ----
+// f() -> 11, 10
diff --git a/compiler/test/libsolidity/semanticTests/constantEvaluator/rounding.sol b/compiler/test/libsolidity/semanticTests/constantEvaluator/rounding.sol
new file mode 100644
index 00000000..837e87dc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constantEvaluator/rounding.sol
@@ -0,0 +1,13 @@
+contract C {
+    int constant a = 7;
+    int constant b = 3;
+    int constant c = a / b;
+    int constant d = (-a) / b;
+    function f() public pure returns (uint, int, uint, int) {
+        uint[c] memory x;
+        uint[-d] memory y;
+        return (x.length, c, y.length, -d);
+    }
+}
+// ----
+// f() -> 2, 2, 2, 2
diff --git a/compiler/test/libsolidity/semanticTests/constants/asm_address_constant_regression.sol b/compiler/test/libsolidity/semanticTests/constants/asm_address_constant_regression.sol
new file mode 100644
index 00000000..ae405d8f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/asm_address_constant_regression.sol
@@ -0,0 +1,11 @@
+// Test for regression of https://github.com/ethereum/solidity/issues/8406
+
+contract C {
+  address constant e = 0x1212121212121212121212121000002134593163;
+
+  function f() public returns (bytes1 z) {
+    assembly { z := e }
+  }
+}
+// ----
+// f() -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/constants/asm_constant_file_level.sol b/compiler/test/libsolidity/semanticTests/constants/asm_constant_file_level.sol
new file mode 100644
index 00000000..4f907646
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/asm_constant_file_level.sol
@@ -0,0 +1,9 @@
+address constant e = 0x1212121212121212121212121000002134593163;
+
+contract C {
+  function f() public returns (address z) {
+    assembly { z := e }
+  }
+}
+// ----
+// f() -> 0x1212121212121212121212121000002134593163
diff --git a/compiler/test/libsolidity/semanticTests/constants/constant_string.sol b/compiler/test/libsolidity/semanticTests/constants/constant_string.sol
new file mode 100644
index 00000000..3b53102b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/constant_string.sol
@@ -0,0 +1,21 @@
+contract C {
+    bytes constant a = "\x03\x01\x02";
+    bytes constant b = hex"030102";
+    string constant c = "hello";
+
+    function f() public returns (bytes memory) {
+        return a;
+    }
+
+    function g() public returns (bytes memory) {
+        return b;
+    }
+
+    function h() public returns (bytes memory) {
+        return bytes(c);
+    }
+}
+// ----
+// f() -> 0x20, 3, "\x03\x01\x02"
+// g() -> 0x20, 3, "\x03\x01\x02"
+// h() -> 0x20, 5, "hello"
diff --git a/compiler/test/libsolidity/semanticTests/constants/constant_string_at_file_level.sol b/compiler/test/libsolidity/semanticTests/constants/constant_string_at_file_level.sol
new file mode 100644
index 00000000..0ff332c4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/constant_string_at_file_level.sol
@@ -0,0 +1,30 @@
+bytes constant a = "\x03\x01\x02";
+bytes constant b = hex"030102";
+string constant c = "hello";
+uint256 constant x = 56;
+enum ActionChoices {GoLeft, GoRight, GoStraight, Sit}
+ActionChoices constant choices = ActionChoices.GoRight;
+bytes32 constant st = "abc\x00\xff__";
+
+contract C {
+    function f() public returns (bytes memory) {
+        return a;
+    }
+
+    function g() public returns (bytes memory) {
+        return b;
+    }
+
+    function h() public returns (bytes memory) {
+        return bytes(c);
+    }
+
+    function i() public returns (uint, ActionChoices, bytes32) {
+        return (x, choices, st);
+    }
+}
+// ----
+// f() -> 0x20, 3, "\x03\x01\x02"
+// g() -> 0x20, 3, "\x03\x01\x02"
+// h() -> 0x20, 5, "hello"
+// i() -> 0x38, 1, 0x61626300ff5f5f00000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/constants/constant_variables.sol b/compiler/test/libsolidity/semanticTests/constants/constant_variables.sol
new file mode 100644
index 00000000..2ecd6e76
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/constant_variables.sol
@@ -0,0 +1,8 @@
+contract Foo {
+    uint256 constant x = 56;
+    enum ActionChoices {GoLeft, GoRight, GoStraight, Sit}
+    ActionChoices constant choices = ActionChoices.GoLeft;
+    bytes32 constant st = "abc\x00\xff__";
+}
+// ----
+// constructor() ->
diff --git a/compiler/test/libsolidity/semanticTests/constants/constants_at_file_level_referencing.sol b/compiler/test/libsolidity/semanticTests/constants/constants_at_file_level_referencing.sol
new file mode 100644
index 00000000..764ffc24
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/constants_at_file_level_referencing.sol
@@ -0,0 +1,38 @@
+==== Source: s1.sol ====
+
+
+bytes constant a = b;
+bytes constant b = hex"030102";
+
+function fre() pure returns (bytes memory) {
+    return a;
+}
+
+==== Source: s2.sol ====
+
+import "s1.sol";
+
+uint256 constant c = uint8(a[0]) + 2;
+
+contract C {
+    function f() public returns (bytes memory) {
+        return a;
+    }
+
+    function g() public returns (bytes memory) {
+        return b;
+    }
+
+    function h() public returns (uint) {
+        return c;
+    }
+
+    function i() public returns (bytes memory) {
+        return fre();
+    }
+}
+// ----
+// f() -> 0x20, 3, "\x03\x01\x02"
+// g() -> 0x20, 3, "\x03\x01\x02"
+// h() -> 5
+// i() -> 0x20, 3, "\x03\x01\x02"
diff --git a/compiler/test/libsolidity/semanticTests/constants/consteval_array_length.sol b/compiler/test/libsolidity/semanticTests/constants/consteval_array_length.sol
new file mode 100644
index 00000000..91e92983
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/consteval_array_length.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint constant a = 12;
+    uint constant b = 10;
+
+    function f() public pure returns (uint, uint) {
+        uint[(a / b) * b] memory x;
+        return (x.length, (a / b) * b);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// constructor() ->
+// f() -> 0x0a, 0x0a
diff --git a/compiler/test/libsolidity/semanticTests/constants/function_unreferenced.sol b/compiler/test/libsolidity/semanticTests/constants/function_unreferenced.sol
new file mode 100644
index 00000000..d7578fec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/function_unreferenced.sol
@@ -0,0 +1,9 @@
+contract B {
+    function g() public {}
+}
+contract C is B {
+    bytes4 constant s2 = B.g.selector;
+    function f() external pure returns (bytes4) { return s2; }
+}
+// ----
+// f() -> 0xe2179b8e00000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/constants/same_constants_different_files.sol b/compiler/test/libsolidity/semanticTests/constants/same_constants_different_files.sol
new file mode 100644
index 00000000..3a819bef
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/same_constants_different_files.sol
@@ -0,0 +1,23 @@
+==== Source: s1.sol ====
+
+
+uint constant a = 89;
+
+function fre() pure returns (uint) {
+    return a;
+}
+
+==== Source: s2.sol ====
+
+import {a as b, fre} from "s1.sol";
+import "s1.sol" as M;
+
+uint256 constant a = 13;
+
+contract C {
+    function f() public returns (uint, uint, uint, uint) {
+        return (a, fre(), M.a, b);
+    }
+}
+// ----
+// f() -> 0x0d, 0x59, 0x59, 0x59
diff --git a/compiler/test/libsolidity/semanticTests/constants/simple_constant_variables_test.sol b/compiler/test/libsolidity/semanticTests/constants/simple_constant_variables_test.sol
new file mode 100644
index 00000000..ed0e919f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constants/simple_constant_variables_test.sol
@@ -0,0 +1,9 @@
+contract Foo {
+    function getX() public returns (uint256 r) {
+        return x;
+    }
+
+    uint256 constant x = 56;
+}
+// ----
+// getX() -> 56
diff --git a/compiler/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol b/compiler/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol
new file mode 100644
index 00000000..3d9c1ffe
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol
@@ -0,0 +1,29 @@
+contract Base {
+    uint public m_x;
+    address[] m_s;
+    constructor(uint x, address[] memory s) {
+        m_x = x;
+        m_s = s;
+    }
+    function part(uint i) public returns (address) {
+        return m_s[i];
+    }
+}
+contract Main is Base {
+    constructor(address[] memory s, uint x) Base(x, f(s)) {}
+    function f(address[] memory s) public returns (address[] memory) {
+        return s;
+    }
+}
+contract Creator {
+    function f(uint x, address[] memory s) public returns (uint r, address ch) {
+        Main c = new Main(s, x);
+        r = c.m_x();
+        ch = c.part(x);
+    }
+}
+// ----
+// f(uint256,address[]): 7, 0x40, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 -> 7, 8
+// gas irOptimized: 424526
+// gas legacy: 581443
+// gas legacyOptimized: 444599
diff --git a/compiler/test/libsolidity/semanticTests/constructor/base_constructor_arguments.sol b/compiler/test/libsolidity/semanticTests/constructor/base_constructor_arguments.sol
new file mode 100644
index 00000000..55daf6d3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/base_constructor_arguments.sol
@@ -0,0 +1,23 @@
+contract BaseBase {
+    uint256 m_a;
+
+    constructor(uint256 a) {
+        m_a = a;
+    }
+}
+
+
+contract Base is BaseBase(7) {
+    constructor() {
+        m_a *= m_a;
+    }
+}
+
+
+contract Derived is Base {
+    function getA() public returns (uint256 r) {
+        return m_a;
+    }
+}
+// ----
+// getA() -> 49
diff --git a/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol b/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol
new file mode 100644
index 00000000..067a64e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol
@@ -0,0 +1,29 @@
+contract Base {
+    uint public m_x;
+    bytes m_s;
+    constructor(uint x, bytes memory s) {
+        m_x = x;
+        m_s = s;
+    }
+    function part(uint i) public returns (bytes1) {
+        return m_s[i];
+    }
+}
+contract Main is Base {
+    constructor(bytes memory s, uint x) Base(x, f(s)) {}
+    function f(bytes memory s) public returns (bytes memory) {
+        return s;
+    }
+}
+contract Creator {
+    function f(uint x, bytes memory s) public returns (uint r, bytes1 ch) {
+        Main c = new Main(s, x);
+        r = c.m_x();
+        ch = c.part(x);
+    }
+}
+// ----
+// f(uint256,bytes): 7, 0x40, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz" -> 7, "h"
+// gas irOptimized: 275102
+// gas legacy: 418462
+// gas legacyOptimized: 291960
diff --git a/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol b/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol
new file mode 100644
index 00000000..0665cb80
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol
@@ -0,0 +1,15 @@
+contract Test {
+    uint public m_x;
+    bytes public m_s;
+    constructor(uint x, bytes memory s) {
+        m_x = x;
+        m_s = s;
+    }
+}
+// ----
+// constructor(): 7, 0x40, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz" ->
+// gas irOptimized: 269225
+// gas legacy: 311324
+// gas legacyOptimized: 258604
+// m_x() -> 7
+// m_s() -> 0x20, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz"
diff --git a/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol b/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol
new file mode 100644
index 00000000..3037aaa3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol
@@ -0,0 +1,24 @@
+contract Main {
+    bytes3 name;
+    bool flag;
+
+    constructor(bytes3 x, bool f) {
+        name = x;
+        flag = f;
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return name;
+    }
+
+    function getFlag() public returns (bool ret) {
+        return flag;
+    }
+}
+// ----
+// constructor(): "abc", true
+// gas irOptimized: 104394
+// gas legacy: 143300
+// gas legacyOptimized: 102961
+// getFlag() -> true
+// getName() -> "abc"
diff --git a/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_internal.sol b/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_internal.sol
new file mode 100644
index 00000000..bf3f0c0c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/constructor_arguments_internal.sol
@@ -0,0 +1,37 @@
+contract Helper {
+    bytes3 name;
+    bool flag;
+
+    constructor(bytes3 x, bool f) {
+        name = x;
+        flag = f;
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return name;
+    }
+
+    function getFlag() public returns (bool ret) {
+        return flag;
+    }
+}
+
+
+contract Main {
+    Helper h;
+
+    constructor() {
+        h = new Helper("abc", true);
+    }
+
+    function getFlag() public returns (bool ret) {
+        return h.getFlag();
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return h.getName();
+    }
+}
+// ----
+// getFlag() -> true
+// getName() -> "abc"
diff --git a/compiler/test/libsolidity/semanticTests/constructor/constructor_function_complex.sol b/compiler/test/libsolidity/semanticTests/constructor/constructor_function_complex.sol
new file mode 100644
index 00000000..4117b84b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/constructor_function_complex.sol
@@ -0,0 +1,20 @@
+contract D {
+    uint public x;
+    constructor(function() external pure returns (uint) g) {
+        x = g();
+    }
+}
+
+contract C {
+    function f() public returns (uint r) {
+        D d = new D(this.sixteen);
+        r = d.x();
+    }
+
+    function sixteen() public pure returns (uint) {
+        return 16;
+    }
+}
+// ----
+// f() -> 16
+// gas legacy: 102082
diff --git a/compiler/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol b/compiler/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol
new file mode 100644
index 00000000..22acd1cc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol
@@ -0,0 +1,18 @@
+contract C {
+    uint256 public a;
+    uint256[3] public b;
+
+    constructor(uint256 _a, uint256[3] memory _b) {
+        a = _a;
+        b = _b;
+    }
+}
+// ----
+// constructor(): 1, 2, 3, 4 ->
+// gas irOptimized: 171015
+// gas legacy: 218378
+// gas legacyOptimized: 176211
+// a() -> 1
+// b(uint256): 0 -> 2
+// b(uint256): 1 -> 3
+// b(uint256): 2 -> 4
diff --git a/compiler/test/libsolidity/semanticTests/constructor/evm_exceptions_in_constructor_call_fail.sol b/compiler/test/libsolidity/semanticTests/constructor/evm_exceptions_in_constructor_call_fail.sol
new file mode 100644
index 00000000..43d1fdab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/evm_exceptions_in_constructor_call_fail.sol
@@ -0,0 +1,18 @@
+contract A {
+    constructor() {
+        address(this).call("123");
+    }
+}
+
+
+contract B {
+    uint256 public test = 1;
+
+    function testIt() public {
+        A a = new A();
+        ++test;
+    }
+}
+// ----
+// testIt() ->
+// test() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/constructor/function_usage_in_constructor_arguments.sol b/compiler/test/libsolidity/semanticTests/constructor/function_usage_in_constructor_arguments.sol
new file mode 100644
index 00000000..c04f0391
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/function_usage_in_constructor_arguments.sol
@@ -0,0 +1,23 @@
+contract BaseBase {
+    uint256 m_a;
+
+    constructor(uint256 a) {
+        m_a = a;
+    }
+
+    function g() public returns (uint256 r) {
+        return 2;
+    }
+}
+
+
+contract Base is BaseBase(BaseBase.g()) {}
+
+
+contract Derived is Base {
+    function getA() public returns (uint256 r) {
+        return m_a;
+    }
+}
+// ----
+// getA() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor.sol
new file mode 100644
index 00000000..b968a07a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor.sol
@@ -0,0 +1,18 @@
+contract Test {
+    bytes3 name;
+    bool flag;
+
+    constructor() {
+        setName("abc");
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return name;
+    }
+
+    function setName(bytes3 _name) private {
+        name = _name;
+    }
+}
+// ----
+// getName() -> "abc"
diff --git a/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor_through_dispatch.sol b/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor_through_dispatch.sol
new file mode 100644
index 00000000..0a1250a8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/functions_called_by_constructor_through_dispatch.sol
@@ -0,0 +1,28 @@
+contract Test {
+    bytes6 name;
+
+    constructor() {
+        function (bytes6 _name) internal setter = setName;
+        setter("abcdef");
+
+        applyShift(leftByteShift, 3);
+    }
+
+    function getName() public returns (bytes6 ret) {
+        return name;
+    }
+
+    function setName(bytes6 _name) private {
+        name = _name;
+    }
+
+    function leftByteShift(bytes6 _value, uint _shift) public returns (bytes6) {
+        return _value << _shift * 8;
+    }
+
+    function applyShift(function (bytes6 _value, uint _shift) internal returns (bytes6) _shiftOperator, uint _bytes) internal {
+        name = _shiftOperator(name, _bytes);
+    }
+}
+// ----
+// getName() -> "def\x00\x00\x00"
diff --git a/compiler/test/libsolidity/semanticTests/constructor/inline_member_init_inheritence_without_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/inline_member_init_inheritence_without_constructor.sol
new file mode 100644
index 00000000..320349cd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/inline_member_init_inheritence_without_constructor.sol
@@ -0,0 +1,19 @@
+contract Base {
+    uint256 m_base = 5;
+
+    function getBMember() public returns (uint256 i) {
+        return m_base;
+    }
+}
+
+
+contract Derived is Base {
+    uint256 m_derived = 6;
+
+    function getDMember() public returns (uint256 i) {
+        return m_derived;
+    }
+}
+// ----
+// getBMember() -> 5
+// getDMember() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol b/compiler/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol
new file mode 100644
index 00000000..eec01005
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol
@@ -0,0 +1,22 @@
+contract A1 {}
+contract B1 is A1 { constructor() payable {} }
+
+contract A2 { constructor() {} }
+contract B2 is A2 { constructor() payable {} }
+
+contract B3 { constructor() payable {} }
+
+contract C {
+	function f() public payable returns (bool) {
+		// Make sure none of these revert.
+		new B1{value: 10}();
+		new B2{value: 10}();
+		new B3{value: 10}();
+		return true;
+	}
+}
+// ----
+// f(), 2000 ether -> true
+// gas irOptimized: 119441
+// gas legacy: 122621
+// gas legacyOptimized: 122490
diff --git a/compiler/test/libsolidity/semanticTests/constructor/payable_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/payable_constructor.sol
new file mode 100644
index 00000000..09fe0a1c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/payable_constructor.sol
@@ -0,0 +1,5 @@
+contract C {
+    constructor() payable {}
+}
+// ----
+// constructor(), 27 wei ->
diff --git a/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor.sol
new file mode 100644
index 00000000..dee3af35
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor.sol
@@ -0,0 +1,20 @@
+contract C {
+    uint256 public result_in_constructor;
+    function(uint256) returns (uint256) internal x;
+
+    constructor() {
+        x = double;
+        result_in_constructor = use(2);
+    }
+
+    function double(uint256 _arg) public returns (uint256 _ret) {
+        _ret = _arg * 2;
+    }
+
+    function use(uint256 _arg) public returns (uint256) {
+        return x(_arg);
+    }
+}
+// ----
+// use(uint256): 3 -> 6
+// result_in_constructor() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor_packed.sol b/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor_packed.sol
new file mode 100644
index 00000000..07b12ad9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/store_function_in_constructor_packed.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint16 public result_in_constructor;
+    function(uint16) returns (uint16) internal x;
+    uint16 public other = 0x1fff;
+
+    constructor() {
+        x = doubleInv;
+        result_in_constructor = use(2);
+    }
+
+    function doubleInv(uint16 _arg) public returns (uint16 _ret) {
+        _ret = ~(_arg * 2);
+    }
+
+    function use(uint16 _arg) public returns (uint16) {
+        return x(_arg);
+    }
+}
+// ----
+// use(uint16): 3 -> 0xfff9
+// result_in_constructor() -> 0xfffb
+// other() -> 0x1fff
diff --git a/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_function_in_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_function_in_constructor.sol
new file mode 100644
index 00000000..cc9d8ca6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_function_in_constructor.sol
@@ -0,0 +1,17 @@
+contract C {
+    function() returns (uint256) internal x;
+
+    constructor() {
+        x = unused;
+    }
+
+    function unused() internal returns (uint256) {
+        return 7;
+    }
+
+    function t() public returns (uint256) {
+        return x();
+    }
+}
+// ----
+// t() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_library_function_in_constructor.sol b/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_library_function_in_constructor.sol
new file mode 100644
index 00000000..5845e9b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor/store_internal_unused_library_function_in_constructor.sol
@@ -0,0 +1,20 @@
+library L {
+    function x() internal returns (uint256) {
+        return 7;
+    }
+}
+
+
+contract C {
+    function() returns (uint256) internal x;
+
+    constructor() {
+        x = L.x;
+    }
+
+    function t() public returns (uint256) {
+        return x();
+    }
+}
+// ----
+// t() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order.sol b/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order.sol
new file mode 100644
index 00000000..20cd8760
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order.sol
@@ -0,0 +1,18 @@
+contract A {
+    uint x;
+    constructor() {
+        x = 42;
+    }
+    function f() public returns(uint256) {
+        return x;
+    }
+}
+contract B is A {
+    uint public y = f();
+}
+// ====
+// compileViaYul: true
+// ----
+// constructor() ->
+// gas irOptimized: 119640
+// y() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order_2.sol b/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order_2.sol
new file mode 100644
index 00000000..820c56a4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor_inheritance_init_order_2.sol
@@ -0,0 +1,15 @@
+contract A {
+    uint x = 42;
+    function f() public returns(uint256) {
+        return x;
+    }
+}
+contract B is A {
+    uint public y = f();
+}
+// ----
+// constructor() ->
+// gas irOptimized: 119640
+// gas legacy: 133594
+// gas legacyOptimized: 115341
+// y() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/constructor_with_params.sol b/compiler/test/libsolidity/semanticTests/constructor_with_params.sol
new file mode 100644
index 00000000..1916f692
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor_with_params.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint public i;
+    uint public k;
+
+    constructor(uint newI, uint newK) {
+        i = newI;
+        k = newK;
+    }
+}
+// ----
+// constructor(): 2, 0 ->
+// gas irOptimized: 101390
+// gas legacy: 115678
+// i() -> 2
+// k() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/constructor_with_params_diamond_inheritance.sol b/compiler/test/libsolidity/semanticTests/constructor_with_params_diamond_inheritance.sol
new file mode 100644
index 00000000..b2f66e45
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor_with_params_diamond_inheritance.sol
@@ -0,0 +1,29 @@
+contract A {
+    uint public i;
+    uint public k;
+
+    constructor(uint newI, uint newK) {
+        i = newI;
+        k = newK;
+    }
+}
+abstract contract B is A {
+    uint public j;
+    constructor(uint newJ) {
+        j = newJ;
+    }
+}
+contract C is A {
+    constructor(uint newI, uint newK) A(newI, newK) {}
+}
+contract D is B, C {
+    constructor(uint newI, uint newK) B(newI) C(newI, newK + 1) {}
+}
+// ----
+// constructor(): 2, 0 ->
+// gas irOptimized: 151966
+// gas legacy: 168623
+// gas legacyOptimized: 144577
+// i() -> 2
+// j() -> 2
+// k() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/constructor_with_params_inheritance.sol b/compiler/test/libsolidity/semanticTests/constructor_with_params_inheritance.sol
new file mode 100644
index 00000000..f5b20d98
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/constructor_with_params_inheritance.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint public i;
+    uint public k;
+
+    constructor(uint newI, uint newK) {
+        i = newI;
+        k = newK;
+    }
+}
+contract D is C {
+    constructor(uint newI, uint newK) C(newI, newK + 1) {}
+}
+// ----
+// constructor(): 2, 0 ->
+// gas irOptimized: 121805
+// gas legacy: 137193
+// gas legacyOptimized: 118548
+// i() -> 2
+// k() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol
new file mode 100644
index 00000000..64b80422
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol
@@ -0,0 +1,40 @@
+function longdata(S memory) pure returns (bytes memory) {
+    return
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+        "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+}
+
+struct S {
+    uint x;
+}
+
+using { longdata } for S;
+
+contract C {
+    bytes data;
+    constructor() {
+        S memory x;
+        data = x.longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol
new file mode 100644
index 00000000..93110919
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol
@@ -0,0 +1,34 @@
+library L {
+    function longdata() pure internal returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+contract C {
+    bytes data;
+    constructor() {
+        data = L.longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function L.longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function_deployed.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function_deployed.sol
new file mode 100644
index 00000000..30f403af
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/library_function_deployed.sol
@@ -0,0 +1,31 @@
+library L {
+    function longdata() pure internal returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C {
+    bytes data;
+    function () pure returns (bytes memory) f;
+    constructor() {
+        data = L.longdata();
+        f = L.longdata;
+    }
+    function test() public view returns (bool) {
+        return keccak256(data) == keccak256(f());
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol
new file mode 100644
index 00000000..018d4105
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol
@@ -0,0 +1,36 @@
+==== Source: mod.sol ====
+function longdata() pure returns (bytes memory) {
+    return
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+        "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+}
+==== Source: main.sol ====
+import "mod.sol" as M;
+
+contract C {
+    bytes data;
+    constructor() {
+        data = M.longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function_deployed.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function_deployed.sol
new file mode 100644
index 00000000..f29355e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/module_function_deployed.sol
@@ -0,0 +1,32 @@
+==== Source: mod.sol ====
+function longdata() pure returns (bytes memory) {
+    return
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+        "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+}
+==== Source: main.sol ====
+import "mod.sol" as M;
+
+contract C {
+    bytes data;
+    function () pure returns (bytes memory) f;
+    constructor() {
+        data = M.longdata();
+        f = M.longdata;
+    }
+    function test() public view returns (bool) {
+        return keccak256(data) == keccak256(f());
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol
new file mode 100644
index 00000000..0f9b023b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol
@@ -0,0 +1,35 @@
+abstract contract S {
+    function longdata() internal pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C is S {
+    bytes data;
+    constructor() {
+        data = S.longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function_deployed.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function_deployed.sol
new file mode 100644
index 00000000..a7c8d6cf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function_deployed.sol
@@ -0,0 +1,31 @@
+abstract contract S {
+    function longdata() internal pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C is S {
+    bytes data;
+    function () pure returns (bytes memory) f;
+    constructor() {
+        data = S.longdata();
+        f = S.longdata;
+    }
+    function test() public view returns (bool) {
+        return keccak256(data) == keccak256(f());
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol
new file mode 100644
index 00000000..b6ae85b8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol
@@ -0,0 +1,41 @@
+contract A {
+    function longdata() pure external returns (bytes memory) {
+        return
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+        "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+        "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+        "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+        "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+        "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C {
+    constructor() {
+    }
+
+    function a() external returns (bytes memory) {
+        return type(A).creationCode;
+    }
+
+    function b() external returns (A) {
+        return new A();
+    }
+
+    function test() public view returns (bool) {
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return type(A).creationCode.length < x &&
+            x < 2 * type(A).creationCode.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol
new file mode 100644
index 00000000..9accc54a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol
@@ -0,0 +1,35 @@
+abstract contract S {
+    function longdata() internal pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C is S {
+    bytes data;
+    constructor() {
+        data = super.longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function_deployed.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function_deployed.sol
new file mode 100644
index 00000000..9588007b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/super_function_deployed.sol
@@ -0,0 +1,31 @@
+abstract contract S {
+    function longdata() internal pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+    }
+}
+
+contract C is S {
+    bytes data;
+    function () pure returns (bytes memory) f;
+    constructor() {
+        data = super.longdata();
+        f = super.longdata;
+    }
+    function test() public view returns (bool) {
+        return keccak256(data) == keccak256(f());
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol
new file mode 100644
index 00000000..866fe9df
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol
@@ -0,0 +1,39 @@
+abstract contract S {
+    function longdata() internal virtual pure returns (bytes memory);
+}
+
+abstract contract X is S {
+    function longdata() internal override pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+        }
+}
+
+contract C is X {
+    bytes data;
+    constructor() {
+        data = longdata();
+    }
+    function test() public view returns (bool) {
+        // Tests that the function longdata is not
+        // included in the runtime code.
+        uint x;
+        assembly {
+            x := codesize()
+        }
+        return x < data.length;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function_deployed.sol b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function_deployed.sol
new file mode 100644
index 00000000..bcc95b9f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function_deployed.sol
@@ -0,0 +1,35 @@
+abstract contract S {
+    function longdata() internal virtual pure returns (bytes memory);
+}
+
+abstract contract X is S {
+    function longdata() internal override pure returns (bytes memory) {
+        return
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            " .RPOKIDAS,.CKUMT.,ORKAD ,NOKIDHA .CGKIAD OVHAMS CUAOGT DAKN OIT"
+            "xasopca.pngaibngidak.jbtnudak.cAP.BRRSMCPJAGPD KIAJDOMHUKR,SCPID"
+            "M,SEYBDXCNTKIMNJGO;DUIAQBQUEHAKMPGIDSAJCOUKANJBCUEBKNA.GIAKMV.TI"
+            "AJMO<KXBANJCPGUD ABKCJIDHA NKIMAJU,EKAMHSO;PYCAKUM,L.UCA MR;KITA"
+            "apibakrpidbacnidkacjadtnpdkylca.,jda,r.kuadc,jdlkjd',c'dj, ncg d"
+            "anosumantkudkc,djntudkantuadnc,ui,c.ud,.nujdncud,j.rsch'pkl.'pih";
+        }
+}
+
+contract C is X {
+    bytes data;
+    function () pure returns (bytes memory) f;
+    constructor() {
+        data = super.longdata();
+        f = super.longdata;
+    }
+    function test() public view returns (bool) {
+        return keccak256(data) == keccak256(f());
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/dirty_calldata_bytes.sol b/compiler/test/libsolidity/semanticTests/dirty_calldata_bytes.sol
new file mode 100644
index 00000000..5876b1f7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/dirty_calldata_bytes.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(bytes calldata b) public returns (bool correct) {
+        bytes1 a = b[3];
+        uint r;
+        assembly {
+            r := a
+        }
+        correct = r == (0x64 << 248);
+    }
+}
+// ----
+// f(bytes): 0x20, 0x04, "dead" -> true
diff --git a/compiler/test/libsolidity/semanticTests/emit_three_identical_events.sol b/compiler/test/libsolidity/semanticTests/emit_three_identical_events.sol
new file mode 100644
index 00000000..dec367e1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/emit_three_identical_events.sol
@@ -0,0 +1,14 @@
+contract C {
+    event Terminated();
+
+    function terminate() external {
+        emit Terminated();
+        emit Terminated();
+        emit Terminated();
+    }
+}
+// ----
+// terminate() ->
+// ~ emit Terminated()
+// ~ emit Terminated()
+// ~ emit Terminated()
\ No newline at end of file
diff --git a/compiler/test/libsolidity/semanticTests/emit_two_identical_events.sol b/compiler/test/libsolidity/semanticTests/emit_two_identical_events.sol
new file mode 100644
index 00000000..85cdceaf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/emit_two_identical_events.sol
@@ -0,0 +1,12 @@
+contract C {
+    event Terminated();
+
+    function terminate() external {
+        emit Terminated();
+        emit Terminated();
+    }
+}
+// ----
+// terminate() ->
+// ~ emit Terminated()
+// ~ emit Terminated()
\ No newline at end of file
diff --git a/compiler/test/libsolidity/semanticTests/empty_contract.sol b/compiler/test/libsolidity/semanticTests/empty_contract.sol
new file mode 100644
index 00000000..7c1ae284
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/empty_contract.sol
@@ -0,0 +1,6 @@
+contract test {
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// i_am_not_there() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/empty_for_loop.sol b/compiler/test/libsolidity/semanticTests/empty_for_loop.sol
new file mode 100644
index 00000000..450134b6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/empty_for_loop.sol
@@ -0,0 +1,11 @@
+contract test {
+    function f() public returns(uint ret) {
+        ret = 1;
+        for (;;) {
+            ret += 1;
+            if (ret >= 10) break;
+        }
+    }
+}
+// ----
+// f() -> 10
diff --git a/compiler/test/libsolidity/semanticTests/enums/constructing_enums_from_ints.sol b/compiler/test/libsolidity/semanticTests/enums/constructing_enums_from_ints.sol
new file mode 100644
index 00000000..beabc514
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/constructing_enums_from_ints.sol
@@ -0,0 +1,9 @@
+contract c {
+    enum Truth {False, True}
+
+    function test() public returns (uint256) {
+        return uint256(Truth(uint8(0x1)));
+    }
+}
+// ----
+// test() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow.sol b/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow.sol
new file mode 100644
index 00000000..b952524b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow.sol
@@ -0,0 +1,31 @@
+contract test {
+    enum ActionChoices {GoLeft, GoRight, GoStraight}
+
+    constructor() {}
+
+    function getChoiceExp(uint256 x) public returns (uint256 d) {
+        choice = ActionChoices(x);
+        d = uint256(choice);
+    }
+
+    function getChoiceFromSigned(int256 x) public returns (uint256 d) {
+        choice = ActionChoices(x);
+        d = uint256(choice);
+    }
+
+    function getChoiceFromMax() public returns (uint256 d) {
+        choice = ActionChoices(type(uint).max);
+        d = uint256(choice);
+    }
+
+    ActionChoices choice;
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// getChoiceExp(uint256): 2 -> 2
+// getChoiceExp(uint256): 3 -> FAILURE, hex"4e487b71", 0x21 # These should throw #
+// getChoiceFromSigned(int256): -1 -> FAILURE, hex"4e487b71", 0x21
+// getChoiceFromMax() -> FAILURE, hex"4e487b71", 0x21
+// getChoiceExp(uint256): 2 -> 2 # These should work #
+// getChoiceExp(uint256): 0 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow_homestead.sol b/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow_homestead.sol
new file mode 100644
index 00000000..60a1d64d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/enum_explicit_overflow_homestead.sol
@@ -0,0 +1,30 @@
+contract test {
+    enum ActionChoices {GoLeft, GoRight, GoStraight}
+
+    constructor() {}
+
+    function getChoiceExp(uint256 x) public returns (uint256 d) {
+        choice = ActionChoices(x);
+        d = uint256(choice);
+    }
+
+    function getChoiceFromSigned(int256 x) public returns (uint256 d) {
+        choice = ActionChoices(x);
+        d = uint256(choice);
+    }
+
+    function getChoiceFromMax() public returns (uint256 d) {
+        choice = ActionChoices(type(uint256).max);
+        d = uint256(choice);
+    }
+
+    ActionChoices choice;
+}
+// ====
+// EVMVersion: <byzantium
+// ----
+// getChoiceExp(uint256): 3 -> FAILURE # These should throw #
+// getChoiceFromSigned(int256): -1 -> FAILURE
+// getChoiceFromMax() -> FAILURE
+// getChoiceExp(uint256): 2 -> 2 # These should work #
+// getChoiceExp(uint256): 0 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/enums/enum_referencing.sol b/compiler/test/libsolidity/semanticTests/enums/enum_referencing.sol
new file mode 100644
index 00000000..c58f6e83
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/enum_referencing.sol
@@ -0,0 +1,38 @@
+interface I {
+    enum Direction { A, B, Left, Right }
+}
+library L {
+    enum Direction { Left, Right }
+    function f() public pure returns (Direction) {
+        return Direction.Right;
+    }
+    function g() public pure returns (I.Direction) {
+        return I.Direction.Right;
+    }
+}
+contract C is I {
+    function f() public pure returns (Direction) {
+        return Direction.Right;
+    }
+    function g() public pure returns (I.Direction) {
+        return I.Direction.Right;
+    }
+    function h() public pure returns (L.Direction) {
+        return L.Direction.Right;
+    }
+    function x() public pure returns (L.Direction) {
+        return L.f();
+    }
+    function y() public pure returns (I.Direction) {
+        return L.g();
+    }
+}
+// ----
+// library: L
+// f() -> 3
+// g() -> 3
+// f() -> 3
+// g() -> 3
+// h() -> 1
+// x() -> 1
+// y() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/enums/minmax.sol b/compiler/test/libsolidity/semanticTests/enums/minmax.sol
new file mode 100644
index 00000000..a447f643
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/minmax.sol
@@ -0,0 +1,9 @@
+contract test {
+	enum MinMax { A, B, C, D }
+
+	function min() public returns(uint) { return uint(type(MinMax).min); }
+	function max() public returns(uint) { return uint(type(MinMax).max); }
+}
+// ----
+// min() -> 0
+// max() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/enums/using_contract_enums_with_explicit_contract_name.sol b/compiler/test/libsolidity/semanticTests/enums/using_contract_enums_with_explicit_contract_name.sol
new file mode 100644
index 00000000..a3bce93a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/using_contract_enums_with_explicit_contract_name.sol
@@ -0,0 +1,9 @@
+contract test {
+    enum Choice {A, B, C}
+
+    function answer() public returns (test.Choice _ret) {
+        _ret = test.Choice.B;
+    }
+}
+// ----
+// answer() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/enums/using_enums.sol b/compiler/test/libsolidity/semanticTests/enums/using_enums.sol
new file mode 100644
index 00000000..b4d0ce8e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/using_enums.sol
@@ -0,0 +1,15 @@
+contract test {
+    enum ActionChoices {GoLeft, GoRight, GoStraight, Sit}
+
+    constructor() {
+        choices = ActionChoices.GoStraight;
+    }
+
+    function getChoice() public returns (uint256 d) {
+        d = uint256(choices);
+    }
+
+    ActionChoices choices;
+}
+// ----
+// getChoice() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum.sol b/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum.sol
new file mode 100644
index 00000000..9741568b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum.sol
@@ -0,0 +1,12 @@
+contract base {
+    enum Choice {A, B, C}
+}
+
+
+contract test is base {
+    function answer() public returns (Choice _ret) {
+        _ret = Choice.B;
+    }
+}
+// ----
+// answer() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum_excplicitly.sol b/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum_excplicitly.sol
new file mode 100644
index 00000000..eb1d63a2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/enums/using_inherited_enum_excplicitly.sol
@@ -0,0 +1,12 @@
+contract base {
+    enum Choice {A, B, C}
+}
+
+
+contract test is base {
+    function answer() public returns (base.Choice _ret) {
+        _ret = base.Choice.B;
+    }
+}
+// ----
+// answer() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/errors/named_error_args.sol b/compiler/test/libsolidity/semanticTests/errors/named_error_args.sol
new file mode 100644
index 00000000..04697f52
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/named_error_args.sol
@@ -0,0 +1,8 @@
+error E(uint a, uint b);
+contract C {
+    function f() public pure {
+        revert E({b: 7, a: 2});
+    }
+}
+// ----
+// f() -> FAILURE, hex"85208890", hex"0000000000000000000000000000000000000000000000000000000000000002", hex"0000000000000000000000000000000000000000000000000000000000000007"
diff --git a/compiler/test/libsolidity/semanticTests/errors/named_parameters_shadowing_types.sol b/compiler/test/libsolidity/semanticTests/errors/named_parameters_shadowing_types.sol
new file mode 100644
index 00000000..2f2b7c67
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/named_parameters_shadowing_types.sol
@@ -0,0 +1,23 @@
+pragma abicoder v2;
+
+contract C {
+    enum EnumType {A, B, C}
+
+    struct StructType {
+        uint x;
+    }
+
+    error E1(StructType StructType);
+    error E2(EnumType StructType, StructType EnumType);
+
+    function f() public {
+        revert E1({StructType: StructType(42)});
+    }
+
+    function g() public {
+        revert E2({EnumType: StructType(42), StructType: EnumType.B});
+    }
+}
+// ----
+// f() -> FAILURE, hex"33a54193", hex"000000000000000000000000000000000000000000000000000000000000002a"
+// g() -> FAILURE, hex"374b9387", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"000000000000000000000000000000000000000000000000000000000000002a"
diff --git a/compiler/test/libsolidity/semanticTests/errors/panic_via_import.sol b/compiler/test/libsolidity/semanticTests/errors/panic_via_import.sol
new file mode 100644
index 00000000..94a6a7aa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/panic_via_import.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+error E(uint);
+==== Source: s2.sol ====
+import { E as Panic } from "s1.sol";
+contract C {
+    error E(uint);
+    function a() public pure {
+        revert Panic(1);
+    }
+    function b() public pure {
+        revert E(1);
+    }
+}
+// ----
+// a() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// b() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000001"
diff --git a/compiler/test/libsolidity/semanticTests/errors/simple.sol b/compiler/test/libsolidity/semanticTests/errors/simple.sol
new file mode 100644
index 00000000..809b10c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/simple.sol
@@ -0,0 +1,8 @@
+error E(uint a, uint b);
+contract C {
+    function f() public pure {
+        revert E(2, 7);
+    }
+}
+// ----
+// f() -> FAILURE, hex"85208890", 2, 7
diff --git a/compiler/test/libsolidity/semanticTests/errors/using_structs.sol b/compiler/test/libsolidity/semanticTests/errors/using_structs.sol
new file mode 100644
index 00000000..e04e4b1c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/using_structs.sol
@@ -0,0 +1,18 @@
+pragma abicoder v2;
+struct S { uint a; string b; }
+error E(uint a, S s, uint b);
+contract C {
+    S s;
+    function f(bool c) public {
+        if (c) {
+            s.a = 9;
+            s.b = "abc";
+            revert E(2, s, 7);
+        } else {
+            revert E({b: 7, a: 2, s: S({b: "abc", a: 9})});
+        }
+    }
+}
+// ----
+// f(bool): true -> FAILURE, hex"e96e07f0", hex"0000000000000000000000000000000000000000000000000000000000000002", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000007", hex"0000000000000000000000000000000000000000000000000000000000000009", hex"0000000000000000000000000000000000000000000000000000000000000040", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"6162630000000000000000000000000000000000000000000000000000000000"
+// f(bool): false -> FAILURE, hex"e96e07f0", hex"0000000000000000000000000000000000000000000000000000000000000002", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"0000000000000000000000000000000000000000000000000000000000000007", hex"0000000000000000000000000000000000000000000000000000000000000009", hex"0000000000000000000000000000000000000000000000000000000000000040", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"6162630000000000000000000000000000000000000000000000000000000000"
diff --git a/compiler/test/libsolidity/semanticTests/errors/via_contract_type.sol b/compiler/test/libsolidity/semanticTests/errors/via_contract_type.sol
new file mode 100644
index 00000000..09f60e65
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/via_contract_type.sol
@@ -0,0 +1,16 @@
+contract A {
+  error E(uint);
+}
+contract X {
+  error E(string);
+}
+contract B is A {
+  function f() public pure { revert E(1); }
+  function g() public pure  { revert A.E(1); }
+  function h() public pure { revert X.E("abc"); }
+
+}
+// ----
+// f() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// g() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// h() -> FAILURE, hex"3e9992c9", hex"0000000000000000000000000000000000000000000000000000000000000020", hex"0000000000000000000000000000000000000000000000000000000000000003", hex"6162630000000000000000000000000000000000000000000000000000000000"
diff --git a/compiler/test/libsolidity/semanticTests/errors/via_import.sol b/compiler/test/libsolidity/semanticTests/errors/via_import.sol
new file mode 100644
index 00000000..eb54e5b4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/via_import.sol
@@ -0,0 +1,23 @@
+==== Source: s1.sol ====
+error E(uint);
+==== Source: s2.sol ====
+import "s1.sol" as S;
+==== Source: s3.sol ====
+import "s1.sol" as S;
+import "s2.sol" as T;
+import "s1.sol";
+contract C {
+  function x() public pure {
+    revert E(1);
+  }
+  function y() public pure {
+    revert S.E(2);
+  }
+  function z() public pure {
+    revert T.S.E(3);
+  }
+}
+// ----
+// x() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// y() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000002"
+// z() -> FAILURE, hex"002ff067", hex"0000000000000000000000000000000000000000000000000000000000000003"
diff --git a/compiler/test/libsolidity/semanticTests/errors/weird_name.sol b/compiler/test/libsolidity/semanticTests/errors/weird_name.sol
new file mode 100644
index 00000000..2466d6e2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/errors/weird_name.sol
@@ -0,0 +1,8 @@
+error error(uint a);
+contract C {
+    function f() public pure {
+        revert error(2);
+    }
+}
+// ----
+// f() -> FAILURE, hex"b48fb6cf", hex"0000000000000000000000000000000000000000000000000000000000000002"
diff --git a/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage.sol b/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage.sol
new file mode 100644
index 00000000..fec281c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage.sol
@@ -0,0 +1,18 @@
+contract C {
+    event E(uint[]);
+    uint[] arr;
+    function createEvent(uint x) public {
+        while (arr.length < 3)
+            arr.push();
+        arr[0] = x;
+        arr[1] = x + 1;
+        arr[2] = x + 2;
+        emit E(arr);
+    }
+}
+// ----
+// createEvent(uint256): 42 ->
+// ~ emit E(uint256[]): 0x20, 0x03, 0x2a, 0x2b, 0x2c
+// gas irOptimized: 113485
+// gas legacy: 116314
+// gas legacyOptimized: 114407
diff --git a/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage_v2.sol b/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage_v2.sol
new file mode 100644
index 00000000..2b5a7114
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_dynamic_array_storage_v2.sol
@@ -0,0 +1,19 @@
+pragma abicoder v2;
+contract C {
+    event E(uint[]);
+    uint[] arr;
+    function createEvent(uint x) public {
+        while (arr.length < 3)
+            arr.push();
+        arr[0] = x;
+        arr[1] = x + 1;
+        arr[2] = x + 2;
+        emit E(arr);
+    }
+}
+// ----
+// createEvent(uint256): 42 ->
+// ~ emit E(uint256[]): 0x20, 0x03, 0x2a, 0x2b, 0x2c
+// gas irOptimized: 113485
+// gas legacy: 116314
+// gas legacyOptimized: 114407
diff --git a/compiler/test/libsolidity/semanticTests/events/event_dynamic_nested_array_storage_v2.sol b/compiler/test/libsolidity/semanticTests/events/event_dynamic_nested_array_storage_v2.sol
new file mode 100644
index 00000000..d6cfb68b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_dynamic_nested_array_storage_v2.sol
@@ -0,0 +1,20 @@
+pragma abicoder v2;
+contract C {
+    event E(uint[][]);
+    uint[][] arr;
+    function createEvent(uint x) public {
+        arr.push(new uint[](2));
+        arr.push(new uint[](2));
+        arr[0][0] = x;
+        arr[0][1] = x + 1;
+        arr[1][0] = x + 2;
+        arr[1][1] = x + 3;
+        emit E(arr);
+    }
+}
+// ----
+// createEvent(uint256): 42 ->
+// ~ emit E(uint256[][]): 0x20, 0x02, 0x40, 0xa0, 0x02, 0x2a, 0x2b, 0x02, 0x2c, 0x2d
+// gas irOptimized: 185033
+// gas legacy: 187495
+// gas legacyOptimized: 184525
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_file_level.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_file_level.sol
new file mode 100644
index 00000000..b698bb80
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_file_level.sol
@@ -0,0 +1,10 @@
+event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
+
+contract ClientReceipt {
+    function deposit(bytes32 _id) public payable {
+        emit Deposit(msg.sender, _id, msg.value);
+    }
+}
+// ----
+// deposit(bytes32), 18 wei: 0x1234 ->
+// ~ emit Deposit(address,bytes32,uint256): #0x1212121212121212121212121212120000000012, #0x1234, 0x12
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract.sol
new file mode 100644
index 00000000..fcd7b6f4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract.sol
@@ -0,0 +1,13 @@
+contract C {
+    event E();
+}
+
+contract D {
+    function test() public {
+        emit C.E();
+    }
+}
+
+// ----
+// test() ->
+// ~ emit E()
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract_same_name.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract_same_name.sol
new file mode 100644
index 00000000..05c03c20
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_from_a_foreign_contract_same_name.sol
@@ -0,0 +1,17 @@
+contract C {
+    event E(uint256 value);
+}
+
+contract D {
+    event E(uint256 value);
+
+    function test() public {
+        emit C.E(1);
+        emit E(2);
+    }
+}
+
+// ----
+// test() ->
+// ~ emit E(uint256): 0x01
+// ~ emit E(uint256): 0x02
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol
new file mode 100644
index 00000000..f8b5141b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol
@@ -0,0 +1,22 @@
+contract D {
+    event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
+    function deposit(bytes32 _id) public payable {
+        emit Deposit(msg.sender, _id, msg.value);
+    }
+}
+contract C {
+    D d;
+    constructor() {
+        d = new D();
+    }
+    function deposit(bytes32 _id) public payable {
+        d.deposit(_id);
+    }
+}
+// ----
+// constructor() ->
+// gas irOptimized: 165386
+// gas legacy: 244800
+// gas legacyOptimized: 171615
+// deposit(bytes32), 18 wei: 0x1234 ->
+// ~ emit Deposit(address,bytes32,uint256) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: #0xc06afe3a8444fc0004668591e8306bfb9968e79e, #0x1234, 0x00
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_interface_event_via_library.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_interface_event_via_library.sol
new file mode 100644
index 00000000..9e24287a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_interface_event_via_library.sol
@@ -0,0 +1,19 @@
+interface I {
+    event E();
+}
+
+library L {
+    function f() internal {
+        emit I.E();
+    }
+}
+
+contract C {
+    function g() public {
+        L.f();
+    }
+}
+
+// ----
+// g() ->
+// ~ emit E()
diff --git a/compiler/test/libsolidity/semanticTests/events/event_emit_via_interface.sol b/compiler/test/libsolidity/semanticTests/events/event_emit_via_interface.sol
new file mode 100644
index 00000000..7268e9ac
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_emit_via_interface.sol
@@ -0,0 +1,13 @@
+interface I {
+    event Event(address indexed _from, uint256 _value);
+}
+
+contract C {
+    function emitEvent(uint256 _value) public {
+        emit I.Event(msg.sender, _value);
+    }
+}
+
+// ----
+// emitEvent(uint256): 100 ->
+// ~ emit Event(address,uint256): #0x1212121212121212121212121212120000000012, 0x64
diff --git a/compiler/test/libsolidity/semanticTests/events/event_indexed_function.sol b/compiler/test/libsolidity/semanticTests/events/event_indexed_function.sol
new file mode 100644
index 00000000..ea757415
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_indexed_function.sol
@@ -0,0 +1,9 @@
+contract C {
+    event Test(function() external indexed);
+    function f() public {
+        emit Test(this.f);
+    }
+}
+// ----
+// f() ->
+// ~ emit Test(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79e26121ff00000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/events/event_indexed_function2.sol b/compiler/test/libsolidity/semanticTests/events/event_indexed_function2.sol
new file mode 100644
index 00000000..d4c47e86
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_indexed_function2.sol
@@ -0,0 +1,15 @@
+contract C {
+    event TestA(function() external indexed);
+    event TestB(function(uint256) external indexed);
+    function f1() public {
+        emit TestA(this.f1);
+    }
+    function f2(uint256 a) public {
+        emit TestB(this.f2);
+    }
+}
+// ----
+// f1() ->
+// ~ emit TestA(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79ec27fc3050000000000000000
+// f2(uint256): 1 ->
+// ~ emit TestB(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79ebf3724af0000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/events/event_indexed_string.sol b/compiler/test/libsolidity/semanticTests/events/event_indexed_string.sol
new file mode 100644
index 00000000..73961906
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_indexed_string.sol
@@ -0,0 +1,22 @@
+contract C {
+    string x;
+    uint[4] y;
+    event E(string indexed r, uint[4] indexed t);
+    function deposit() public {
+        for (uint i = 0; i < 90; i++)
+            bytes(x).push(0);
+        for (uint8 i = 0; i < 90; i++)
+            bytes(x)[i] = bytes1(i);
+        y[0] = 4;
+        y[1] = 5;
+        y[2] = 6;
+        y[3] = 7;
+        emit E(x, y);
+    }
+}
+// ----
+// deposit() ->
+// ~ emit E(string,uint256[4]): #0xa7fb06bb999a5eb9aff9e0779953f4e1e4ce58044936c2f51c7fb879b85c08bd, #0xe755d8cc1a8cde16a2a31160dcd8017ac32d7e2f13215b29a23cdae40a78aa81
+// gas irOptimized: 328856
+// gas legacy: 365828
+// gas legacyOptimized: 362251
diff --git a/compiler/test/libsolidity/semanticTests/events/event_selector.sol b/compiler/test/libsolidity/semanticTests/events/event_selector.sol
new file mode 100644
index 00000000..b42ba490
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_selector.sol
@@ -0,0 +1,58 @@
+library L {
+    event E();
+}
+
+library S {
+    event E(uint);
+}
+
+library T {
+    event E();
+}
+
+interface I {
+    event E();
+}
+
+contract B {
+    event E();
+}
+
+contract D {
+    event F();
+}
+
+contract C is D {
+    function test1() external pure returns (bytes32, bytes32, bytes32, bytes32) {
+        assert(L.E.selector == T.E.selector);
+        assert(I.E.selector == L.E.selector);
+        assert(T.E.selector == I.E.selector);
+        assert(B.E.selector == T.E.selector);
+
+        assert(L.E.selector != S.E.selector);
+        assert(T.E.selector != S.E.selector);
+        assert(I.E.selector != S.E.selector);
+        assert(B.E.selector != S.E.selector);
+
+        return (L.E.selector, S.E.selector, I.E.selector, B.E.selector);
+    }
+
+    bytes32 s1 = L.E.selector;
+    bytes32 s2 = S.E.selector;
+    bytes32 s3 = T.E.selector;
+    bytes32 s4 = I.E.selector;
+    bytes32 s5 = B.E.selector;
+    function test2() external returns (bytes32, bytes32, bytes32, bytes32, bytes32) {
+        return (s1, s2, s3, s4, s5);
+    }
+
+    function test3() external returns (bytes32) {
+        return (F.selector);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// test1() -> 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x2ff0672f372fbe844b353429d4510ea5e43683af134c54f75f789ff57bc0c0, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028
+// test2() -> 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x2ff0672f372fbe844b353429d4510ea5e43683af134c54f75f789ff57bc0c0, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028
+// test3() -> 0x28811f5935c16a099486acb976b3a6b4942950a1425a74e9eb3e9b7f7135e12a
diff --git a/compiler/test/libsolidity/semanticTests/events/event_selector_file_level.sol b/compiler/test/libsolidity/semanticTests/events/event_selector_file_level.sol
new file mode 100644
index 00000000..8c5b6c95
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_selector_file_level.sol
@@ -0,0 +1,15 @@
+event E();
+
+library L {
+    event E();
+}
+
+contract C {
+    function main() external pure returns (bytes32, bytes32) {
+        assert(E.selector == L.E.selector);
+
+        return (E.selector, L.E.selector);
+    }
+}
+// ----
+// main() -> 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028
diff --git a/compiler/test/libsolidity/semanticTests/events/event_shadowing_file_level.sol b/compiler/test/libsolidity/semanticTests/events/event_shadowing_file_level.sol
new file mode 100644
index 00000000..01c7d85a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/event_shadowing_file_level.sol
@@ -0,0 +1,38 @@
+event E();
+
+library L1 {
+    event E(string);
+}
+
+library L2 {
+    event E();
+}
+
+library K {
+    function main() internal pure returns (bytes32, bytes32, bytes32) {
+        // Here E is the global event.
+        assert(E.selector != L1.E.selector);
+        assert(E.selector == L2.E.selector);
+
+        return (E.selector, L1.E.selector, L2.E.selector);
+    }
+}
+
+contract C {
+    event E(string);
+
+    function main() external pure returns (bytes32, bytes32, bytes32) {
+        // Here E is the local event.
+        assert(E.selector == L1.E.selector);
+        assert(E.selector != L2.E.selector);
+
+        return (E.selector, L1.E.selector, L2.E.selector);
+    }
+
+    function k_main() external pure returns (bytes32, bytes32, bytes32) {
+        return K.main();
+    }
+}
+// ----
+// main() -> 0x3e9992c940c54ea252d3a34557cc3d3014281525c43d694f89d5f3dfd820b07d, 0x3e9992c940c54ea252d3a34557cc3d3014281525c43d694f89d5f3dfd820b07d, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028
+// k_main() -> 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028, 0x3e9992c940c54ea252d3a34557cc3d3014281525c43d694f89d5f3dfd820b07d, 0x92bbf6e823a631f3c8e09b1c8df90f378fb56f7fbc9701827e1ff8aad7f6a028
diff --git a/compiler/test/libsolidity/semanticTests/events/events_with_same_name_file_level.sol b/compiler/test/libsolidity/semanticTests/events/events_with_same_name_file_level.sol
new file mode 100644
index 00000000..222e0b0c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/events/events_with_same_name_file_level.sol
@@ -0,0 +1,32 @@
+event Deposit();
+event Deposit(address _addr);
+event Deposit(address _addr, uint _amount);
+event Deposit(address _addr, bool _flag);
+
+contract ClientReceipt {
+    function deposit() public returns (uint) {
+        emit Deposit();
+        return 1;
+    }
+    function deposit(address _addr) public returns (uint) {
+        emit Deposit(_addr);
+        return 2;
+    }
+    function deposit(address _addr, uint _amount) public returns (uint) {
+        emit Deposit(_addr, _amount);
+        return 3;
+    }
+    function deposit(address _addr, bool _flag) public returns (uint) {
+        emit Deposit(_addr, _flag);
+        return 4;
+    }
+}
+// ----
+// deposit() -> 1
+// ~ emit Deposit()
+// deposit(address): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988 -> 2
+// ~ emit Deposit(address): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988
+// deposit(address,uint256): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988, 100 -> 3
+// ~ emit Deposit(address,uint256): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988, 0x64
+// deposit(address,bool): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988, false -> 4
+// ~ emit Deposit(address,bool): 0x5082a85c489be6aa0f2e6693bf09cc1bbd35e988, false
diff --git a/compiler/test/libsolidity/semanticTests/experimental/stub.sol b/compiler/test/libsolidity/semanticTests/experimental/stub.sol
new file mode 100644
index 00000000..6e7a750f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/experimental/stub.sol
@@ -0,0 +1,97 @@
+pragma experimental solidity;
+
+type word = __builtin("word");
+type bool = __builtin("bool");
+type integer = __builtin("integer");
+
+type uint256 = word;
+
+instantiation uint256: + {
+    function add(x, y) -> uint256 {
+        let a = uint256.rep(x);
+        let b = uint256.rep(y);
+        assembly {
+            a := add(a,b)
+        }
+        return uint256.abs(a);
+    }
+}
+
+
+instantiation uint256: * {
+    function mul(x, y) -> uint256 {
+        let a = uint256.rep(x);
+        let b = uint256.rep(y);
+        assembly {
+            a := mul(a,b)
+        }
+        return uint256.abs(a);
+    }
+}
+instantiation word: * {
+    function mul(x, y) -> word {
+        let z: word;
+        assembly {
+            z := mul(x,y)
+        }
+        return z;
+    }
+}
+
+instantiation word: Integer {
+    function fromInteger(x:integer) -> word {
+        //x + x;
+    }
+}
+
+instantiation word: == {
+    function eq(x, y) -> bool {
+        assembly {
+            x := eq(x, y)
+        }
+    }
+}
+
+
+function f(x:uint256->uint256,y:uint256) -> uint256
+{
+    return x(y);
+}
+
+function g(x:uint256) -> uint256
+{
+    return x;
+}
+
+contract C {
+    fallback() external {
+        let arg;
+        assembly {
+            arg := calldataload(0)
+        }
+        let x : word;
+        if (bool.abs(arg)) {
+            assembly {
+                x := 0x10
+            }
+        }
+        let w = uint256.abs(x);
+//        w = f(g, w);
+        w = w * w + w;
+        let y : word;
+        let z : (uint256,uint256);
+        assembly { y := 2 }
+        y = uint256.rep(w) * y;
+        assembly {
+            mstore(0, y)
+            return(0, 32)
+        }
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ====
+// compileViaYul: true
+// ----
+// (): 0 -> 0
+// (): 1 -> 544
diff --git a/compiler/test/libsolidity/semanticTests/experimental/type_class.sol b/compiler/test/libsolidity/semanticTests/experimental/type_class.sol
new file mode 100644
index 00000000..69fa568d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/experimental/type_class.sol
@@ -0,0 +1,67 @@
+pragma experimental solidity;
+
+type word = __builtin("word");
+type bool = __builtin("bool");
+
+type Cat = word;
+type Dog = word;
+
+class Self: Animal {
+    function new() -> Self;
+    function alive(self: Self) -> bool;
+}
+
+instantiation Cat: Animal {
+    function new() -> Cat {
+        let c;
+        return c;
+    }
+
+    function alive(self: Cat) -> bool {
+        // TODO: Boolean literals or operators not implemented.
+        let w;
+        assembly {
+            w := 1
+        }
+        return bool.abs(w);
+    }
+}
+
+instantiation Dog: Animal {
+    function new() -> Dog {
+        let d: Dog;
+        return d;
+    }
+
+    function alive(self: Dog) -> bool {
+        let b: bool;
+        return b;
+    }
+}
+
+contract C {
+    fallback() external {
+        let boolResult1: bool;
+        let boolResult2: bool;
+
+        let c: Cat = Animal.new();
+        boolResult1 = Animal.alive(c);
+
+        let d: Dog = Animal.new();
+        boolResult2 = Animal.alive(d);
+
+        let wordResult1 = bool.rep(boolResult1);
+        let wordResult2 = bool.rep(boolResult2);
+        assembly {
+            mstore(0, wordResult1)
+            mstore(32, wordResult2)
+            return(0, 64)
+        }
+    }
+}
+
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// () -> 1, 0
diff --git a/compiler/test/libsolidity/semanticTests/exponentiation/literal_base.sol b/compiler/test/libsolidity/semanticTests/exponentiation/literal_base.sol
new file mode 100644
index 00000000..3dcba494
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/exponentiation/literal_base.sol
@@ -0,0 +1,18 @@
+contract test {
+    function f(uint x) public pure returns (uint, int) {
+        unchecked {
+            uint a = 2 ** x;
+            int b = -2 ** x;
+            return (a, b);
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 1, 1
+// f(uint256): 1 -> 2, -2
+// f(uint256): 2 -> 4, 4
+// f(uint256): 13 -> 0x2000, -8192
+// f(uint256): 113 -> 0x020000000000000000000000000000, -10384593717069655257060992658440192
+// f(uint256): 114 -> 0x040000000000000000000000000000, 20769187434139310514121985316880384
+// f(uint256): 1113 -> 0x00, 0
+// f(uint256): 1114 -> 0x00, 0
diff --git a/compiler/test/libsolidity/semanticTests/exponentiation/signed_base.sol b/compiler/test/libsolidity/semanticTests/exponentiation/signed_base.sol
new file mode 100644
index 00000000..f58c0812
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/exponentiation/signed_base.sol
@@ -0,0 +1,14 @@
+contract test {
+    function f() public pure returns (int, int) {
+        int32 x = -3;
+        uint8 y1;
+        uint8 y2;
+        assembly {
+            y1 := 0x102
+            y2 := 0x103
+        }
+        return (x**y1, x**y2);
+    }
+}
+// ----
+// f() -> 9, -27
diff --git a/compiler/test/libsolidity/semanticTests/exponentiation/small_exp.sol b/compiler/test/libsolidity/semanticTests/exponentiation/small_exp.sol
new file mode 100644
index 00000000..a26675fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/exponentiation/small_exp.sol
@@ -0,0 +1,14 @@
+contract test {
+    function f() public pure returns (uint r) {
+        uint32 x;
+        uint8 y;
+        assembly {
+            x := 0xfffffffffe
+            y := 0x102
+        }
+        unchecked { r = x**y; }
+        return r;
+    }
+}
+// ----
+// f() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/expressions/bit_operators.sol b/compiler/test/libsolidity/semanticTests/expressions/bit_operators.sol
new file mode 100644
index 00000000..35887059
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/bit_operators.sol
@@ -0,0 +1,17 @@
+contract test {
+    uint8 x;
+    uint v;
+    function f() public returns (uint x, uint y, uint z) {
+        uint16 a;
+        uint32 b;
+        assembly {
+            a := 0x0f0f0f0f0f
+            b := 0xff0fff0fff
+        }
+        x = a & b;
+        y = a | b;
+        z = a ^ b;
+    }
+}
+// ----
+// f() -> 3855, 268374015, 268370160
diff --git a/compiler/test/libsolidity/semanticTests/expressions/bytes_comparison.sol b/compiler/test/libsolidity/semanticTests/expressions/bytes_comparison.sol
new file mode 100644
index 00000000..b1220c51
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/bytes_comparison.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f() public returns (bool) {
+        bytes2 a = "a";
+        bytes2 x = "aa";
+        bytes2 b = "b";
+        return a < x && x < b;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_different_types.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_different_types.sol
new file mode 100644
index 00000000..df07364b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_different_types.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f(bool cond) public returns (uint) {
+        uint8 x = 0xcd;
+        uint16 y = 0xabab;
+        return cond ? x : y;
+    }
+}
+// ----
+// f(bool): true -> 0xcd
+// f(bool): false -> 0xabab
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_false_literal.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_false_literal.sol
new file mode 100644
index 00000000..3915c7b8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_false_literal.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public returns(uint d) {
+        return false ? 5 : 10;
+    }
+}
+// ----
+// f() -> 10
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_functions.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_functions.sol
new file mode 100644
index 00000000..bff9122b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_functions.sol
@@ -0,0 +1,12 @@
+contract test {
+    function x() public returns (uint) { return 1; }
+    function y() public returns (uint) { return 2; }
+
+    function f(bool cond) public returns (uint) {
+        function () returns (uint) z = cond ? x : y;
+        return z();
+    }
+}
+// ----
+// f(bool): true -> 1
+// f(bool): false -> 2
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_multiple.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_multiple.sol
new file mode 100644
index 00000000..2a9d6de8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_multiple.sol
@@ -0,0 +1,13 @@
+contract test {
+    function f(uint x) public returns(uint d) {
+        return x > 100 ?
+                    x > 1000 ? 1000 : 100
+                    :
+                    x > 50 ? 50 : 10;
+    }
+}
+// ----
+// f(uint256): 1001 -> 1000
+// f(uint256): 500 -> 100
+// f(uint256): 80 -> 50
+// f(uint256): 40 -> 10
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_storage_memory_1.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_storage_memory_1.sol
new file mode 100644
index 00000000..3434cca0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_storage_memory_1.sol
@@ -0,0 +1,27 @@
+contract test {
+    bytes2[2] data1;
+    function f(bool cond) public returns (uint) {
+        bytes2[2] memory x;
+        x[0] = "aa";
+        bytes2[2] memory y;
+        y[0] = "bb";
+
+        data1 = cond ? x : y;
+
+        uint ret = 0;
+        if (data1[0] == "aa")
+        {
+            ret = 1;
+        }
+
+        if (data1[0] == "bb")
+        {
+            ret = 2;
+        }
+
+        return ret;
+    }
+}
+// ----
+// f(bool): true -> 1
+// f(bool): false -> 2
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_true_literal.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_true_literal.sol
new file mode 100644
index 00000000..06247f0d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_true_literal.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public returns(uint d) {
+        return true ? 5 : 10;
+    }
+}
+// ----
+// f() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_tuples.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_tuples.sol
new file mode 100644
index 00000000..d27d06ba
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_tuples.sol
@@ -0,0 +1,8 @@
+contract test {
+    function f(bool cond) public returns (uint, uint) {
+        return cond ? (1, 2) : (3, 4);
+    }
+}
+// ----
+// f(bool): true -> 1, 2
+// f(bool): false -> 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_with_return_values.sol b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_with_return_values.sol
new file mode 100644
index 00000000..bbaf051b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/conditional_expression_with_return_values.sol
@@ -0,0 +1,8 @@
+contract test {
+    function f(bool cond, uint v) public returns (uint a, uint b) {
+        cond ? a = v : b = v;
+    }
+}
+// ----
+// f(bool,uint256): true, 20 -> 20, 0
+// f(bool,uint256): false, 20 -> 0, 20
diff --git a/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const.sol b/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const.sol
new file mode 100644
index 00000000..e2a7ccc7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const.sol
@@ -0,0 +1,5 @@
+contract test {
+    function f() public returns(uint d) { return 2 ** 3; }
+}
+// ----
+// f() -> 8
diff --git a/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const_signed.sol b/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const_signed.sol
new file mode 100644
index 00000000..b2dd001b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/exp_operator_const_signed.sol
@@ -0,0 +1,5 @@
+contract test {
+    function f() public returns(int d) { return (-2) ** 3; }
+}
+// ----
+// f() -> -8
diff --git a/compiler/test/libsolidity/semanticTests/expressions/exp_zero_literal.sol b/compiler/test/libsolidity/semanticTests/expressions/exp_zero_literal.sol
new file mode 100644
index 00000000..f7e5c6ab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/exp_zero_literal.sol
@@ -0,0 +1,5 @@
+contract test {
+    function f() public returns(uint d) { return 0 ** 0; }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/expressions/inc_dec_operators.sol b/compiler/test/libsolidity/semanticTests/expressions/inc_dec_operators.sol
new file mode 100644
index 00000000..c6957ee9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/inc_dec_operators.sol
@@ -0,0 +1,15 @@
+contract test {
+    uint8 x;
+    uint v;
+    function f() public returns (uint r) {
+        uint a = 6;
+        r = a;
+        r += (a++) * 0x10;
+        r += (++a) * 0x100;
+        v = 3;
+        r += (v++) * 0x1000;
+        r += (++v) * 0x10000;
+    }
+}
+// ----
+// f() -> 0x053866
diff --git a/compiler/test/libsolidity/semanticTests/expressions/module_from_ternary_expression.sol b/compiler/test/libsolidity/semanticTests/expressions/module_from_ternary_expression.sol
new file mode 100644
index 00000000..937d06c1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/module_from_ternary_expression.sol
@@ -0,0 +1,15 @@
+==== Source: A ====
+contract D {
+}
+==== Source: B ====
+import "A" as M;
+
+contract C {
+    function f() public pure returns (bool) {
+        bool flag;
+        ((flag = true) ? M : M).D;
+        return flag;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/expressions/tuple_from_ternary_expression.sol b/compiler/test/libsolidity/semanticTests/expressions/tuple_from_ternary_expression.sol
new file mode 100644
index 00000000..c8a2ced2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/tuple_from_ternary_expression.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (bool){
+        bool flag;
+        ((flag = true) ? (1, 2, 3) : (3, 2, 1));
+        return flag;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/expressions/uncalled_address_transfer_send.sol b/compiler/test/libsolidity/semanticTests/expressions/uncalled_address_transfer_send.sol
new file mode 100644
index 00000000..af408b3f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/expressions/uncalled_address_transfer_send.sol
@@ -0,0 +1,10 @@
+contract TransferTest {
+	fallback() external payable {
+		// This used to cause an ICE
+		payable(this).transfer;
+	}
+
+	function f() pure public {}
+}
+// ----
+// f() ->
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol b/compiler/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol
new file mode 100644
index 00000000..f9f53275
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol
@@ -0,0 +1,118 @@
+//sol FixedFeeRegistrar
+// Simple global registrar with fixed-fee reservations.
+// @authors:
+//   Gav Wood <g@ethdev.com>
+
+pragma solidity >=0.4.0 <0.9.0;
+
+abstract contract Registrar {
+	event Changed(string indexed name);
+
+	function owner(string memory _name) public virtual view returns (address o_owner);
+	function addr(string memory _name) public virtual view returns (address o_address);
+	function subRegistrar(string memory _name) virtual public view returns (address o_subRegistrar);
+	function content(string memory _name) public virtual view returns (bytes32 o_content);
+}
+
+contract FixedFeeRegistrar is Registrar {
+	struct Record {
+		address addr;
+		address subRegistrar;
+		bytes32 content;
+		address owner;
+	}
+
+	modifier onlyrecordowner(string memory _name) { if (m_record(_name).owner == msg.sender) _; }
+
+	function reserve(string memory _name) public payable {
+		Record storage rec = m_record(_name);
+		if (rec.owner == 0x0000000000000000000000000000000000000000 && msg.value >= c_fee) {
+			rec.owner = msg.sender;
+			emit Changed(_name);
+		}
+	}
+	function disown(string memory _name, address payable _refund) onlyrecordowner(_name) public {
+		delete m_recordData[uint(keccak256(bytes(_name))) / 8];
+		if (!_refund.send(c_fee))
+			revert();
+		emit Changed(_name);
+	}
+	function transfer(string memory _name, address _newOwner) onlyrecordowner(_name) public {
+		m_record(_name).owner = _newOwner;
+		emit Changed(_name);
+	}
+	function setAddr(string memory _name, address _a) onlyrecordowner(_name) public {
+		m_record(_name).addr = _a;
+		emit Changed(_name);
+	}
+	function setSubRegistrar(string memory _name, address _registrar) onlyrecordowner(_name) public {
+		m_record(_name).subRegistrar = _registrar;
+		emit Changed(_name);
+	}
+	function setContent(string memory _name, bytes32 _content) onlyrecordowner(_name) public {
+		m_record(_name).content = _content;
+		emit Changed(_name);
+	}
+
+	function record(string memory _name) public view returns (address o_addr, address o_subRegistrar, bytes32 o_content, address o_owner) {
+		Record storage rec = m_record(_name);
+		o_addr = rec.addr;
+		o_subRegistrar = rec.subRegistrar;
+		o_content = rec.content;
+		o_owner = rec.owner;
+	}
+	function addr(string memory _name) public override view returns (address) { return m_record(_name).addr; }
+	function subRegistrar(string memory _name) public override view returns (address) { return m_record(_name).subRegistrar; }
+	function content(string memory _name) public override view returns (bytes32) { return m_record(_name).content; }
+	function owner(string memory _name) public override view returns (address) { return m_record(_name).owner; }
+
+	Record[2**253] m_recordData;
+	function m_record(string memory _name) view internal returns (Record storage o_record) {
+		return m_recordData[uint(keccak256(bytes(_name))) / 8];
+	}
+	uint constant c_fee = 69 ether;
+}
+// ----
+// constructor()
+// gas irOptimized: 384610
+// gas legacy: 913421
+// gas legacyOptimized: 476928
+// reserve(string), 69 ether: 0x20, 3, "abc" ->
+// ~ emit Changed(string): #0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
+// gas irOptimized: 45967
+// gas legacy: 46842
+// gas legacyOptimized: 46091
+// owner(string): 0x20, 3, "abc" -> 0x1212121212121212121212121212120000000012
+// reserve(string), 70 ether: 0x20, 3, "def" ->
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// owner(string): 0x20, 3, "def" -> 0x1212121212121212121212121212120000000012
+// reserve(string), 68 ether: 0x20, 3, "ghi" ->
+// owner(string): 0x20, 3, "ghi" -> 0
+// account: 1 -> 0x1212121212121212121212121212120000001012
+// reserve(string), 69 ether: 0x20, 3, "abc" ->
+// owner(string): 0x20, 3, "abc" -> 0x1212121212121212121212121212120000000012
+// account: 0 -> 0x1212121212121212121212121212120000000012
+// setContent(string,bytes32): 0x40, 0, 3, "abc" ->
+// ~ emit Changed(string): #0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
+// transfer(string,address): 0x40, 555, 3, "abc" ->
+// ~ emit Changed(string): #0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
+// owner(string): 0x20, 3, "abc" -> 555
+// content(string): 0x20, 3, "abc" -> 0x00
+// setContent(string,bytes32): 0x40, 333, 3, "def" ->
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// setAddr(string,address): 0x40, 124, 3, "def" ->
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// setSubRegistrar(string,address): 0x40, 125, 3, "def" ->
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// content(string): 0x20, 3, "def" -> 333
+// addr(string): 0x20, 3, "def" -> 124
+// subRegistrar(string): 0x20, 3, "def" -> 125
+// balance: 0x124 -> 0
+// disown(string,address): 0x40, 0x124, 3, "def" ->
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// balance: 0x124 -> 0
+// ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c
+// owner(string): 0x20, 3, "def" -> 0
+// content(string): 0x20, 3, "def" -> 0
+// addr(string): 0x20, 3, "def" -> 0
+// subRegistrar(string): 0x20, 3, "def" -> 0
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/_prbmath/PRBMathCommon.sol b/compiler/test/libsolidity/semanticTests/externalContracts/_prbmath/PRBMathCommon.sol
new file mode 100644
index 00000000..a3b49f8d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/_prbmath/PRBMathCommon.sol
@@ -0,0 +1,361 @@
+// SPDX-License-Identifier: WTFPL
+pragma solidity >=0.8.0;
+
+/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
+/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
+// representation. When it does not, it is annotated in the function's NatSpec documentation.
+library PRBMathCommon {
+    /// @dev How many trailing decimals can be represented.
+    uint256 internal constant SCALE = 1e18;
+
+    /// @dev Largest power of two divisor of SCALE.
+    uint256 internal constant SCALE_LPOTD = 262144;
+
+    /// @dev SCALE inverted mod 2^256.
+    uint256 internal constant SCALE_INVERSE = 78156646155174841979727994598816262306175212592076161876661508869554232690281;
+
+    /// @notice Calculates the binary exponent of x using the binary fraction method.
+    /// @dev Uses 128.128-bit fixed-point numbers, which is the most efficient way.
+    /// See https://ethereum.stackexchange.com/a/96594/24693.
+    /// @param x The exponent as an unsigned 128.128-bit fixed-point number.
+    /// @return result The result as an unsigned 60x18 decimal fixed-point number.
+    function exp2(uint256 x) internal pure returns (uint256 result) {
+        unchecked {
+            // Start from 0.5 in the 128.128-bit fixed-point format.
+            result = 0x80000000000000000000000000000000;
+
+            // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows
+            // because the initial result is 2^127 and all magic factors are less than 2^129.
+            if (x & 0x80000000000000000000000000000000 > 0) result = (result * 0x16A09E667F3BCC908B2FB1366EA957D3E) >> 128;
+            if (x & 0x40000000000000000000000000000000 > 0) result = (result * 0x1306FE0A31B7152DE8D5A46305C85EDED) >> 128;
+            if (x & 0x20000000000000000000000000000000 > 0) result = (result * 0x1172B83C7D517ADCDF7C8C50EB14A7920) >> 128;
+            if (x & 0x10000000000000000000000000000000 > 0) result = (result * 0x10B5586CF9890F6298B92B71842A98364) >> 128;
+            if (x & 0x8000000000000000000000000000000 > 0) result = (result * 0x1059B0D31585743AE7C548EB68CA417FE) >> 128;
+            if (x & 0x4000000000000000000000000000000 > 0) result = (result * 0x102C9A3E778060EE6F7CACA4F7A29BDE9) >> 128;
+            if (x & 0x2000000000000000000000000000000 > 0) result = (result * 0x10163DA9FB33356D84A66AE336DCDFA40) >> 128;
+            if (x & 0x1000000000000000000000000000000 > 0) result = (result * 0x100B1AFA5ABCBED6129AB13EC11DC9544) >> 128;
+            if (x & 0x800000000000000000000000000000 > 0) result = (result * 0x10058C86DA1C09EA1FF19D294CF2F679C) >> 128;
+            if (x & 0x400000000000000000000000000000 > 0) result = (result * 0x1002C605E2E8CEC506D21BFC89A23A011) >> 128;
+            if (x & 0x200000000000000000000000000000 > 0) result = (result * 0x100162F3904051FA128BCA9C55C31E5E0) >> 128;
+            if (x & 0x100000000000000000000000000000 > 0) result = (result * 0x1000B175EFFDC76BA38E31671CA939726) >> 128;
+            if (x & 0x80000000000000000000000000000 > 0) result = (result * 0x100058BA01FB9F96D6CACD4B180917C3E) >> 128;
+            if (x & 0x40000000000000000000000000000 > 0) result = (result * 0x10002C5CC37DA9491D0985C348C68E7B4) >> 128;
+            if (x & 0x20000000000000000000000000000 > 0) result = (result * 0x1000162E525EE054754457D5995292027) >> 128;
+            if (x & 0x10000000000000000000000000000 > 0) result = (result * 0x10000B17255775C040618BF4A4ADE83FD) >> 128;
+            if (x & 0x8000000000000000000000000000 > 0) result = (result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAC) >> 128;
+            if (x & 0x4000000000000000000000000000 > 0) result = (result * 0x100002C5C89D5EC6CA4D7C8ACC017B7CA) >> 128;
+            if (x & 0x2000000000000000000000000000 > 0) result = (result * 0x10000162E43F4F831060E02D839A9D16D) >> 128;
+            if (x & 0x1000000000000000000000000000 > 0) result = (result * 0x100000B1721BCFC99D9F890EA06911763) >> 128;
+            if (x & 0x800000000000000000000000000 > 0) result = (result * 0x10000058B90CF1E6D97F9CA14DBCC1629) >> 128;
+            if (x & 0x400000000000000000000000000 > 0) result = (result * 0x1000002C5C863B73F016468F6BAC5CA2C) >> 128;
+            if (x & 0x200000000000000000000000000 > 0) result = (result * 0x100000162E430E5A18F6119E3C02282A6) >> 128;
+            if (x & 0x100000000000000000000000000 > 0) result = (result * 0x1000000B1721835514B86E6D96EFD1BFF) >> 128;
+            if (x & 0x80000000000000000000000000 > 0) result = (result * 0x100000058B90C0B48C6BE5DF846C5B2F0) >> 128;
+            if (x & 0x40000000000000000000000000 > 0) result = (result * 0x10000002C5C8601CC6B9E94213C72737B) >> 128;
+            if (x & 0x20000000000000000000000000 > 0) result = (result * 0x1000000162E42FFF037DF38AA2B219F07) >> 128;
+            if (x & 0x10000000000000000000000000 > 0) result = (result * 0x10000000B17217FBA9C739AA5819F44FA) >> 128;
+            if (x & 0x8000000000000000000000000 > 0) result = (result * 0x1000000058B90BFCDEE5ACD3C1CEDC824) >> 128;
+            if (x & 0x4000000000000000000000000 > 0) result = (result * 0x100000002C5C85FE31F35A6A30DA1BE51) >> 128;
+            if (x & 0x2000000000000000000000000 > 0) result = (result * 0x10000000162E42FF0999CE3541B9FFFD0) >> 128;
+            if (x & 0x1000000000000000000000000 > 0) result = (result * 0x100000000B17217F80F4EF5AADDA45554) >> 128;
+            if (x & 0x800000000000000000000000 > 0) result = (result * 0x10000000058B90BFBF8479BD5A81B51AE) >> 128;
+            if (x & 0x400000000000000000000000 > 0) result = (result * 0x1000000002C5C85FDF84BD62AE30A74CD) >> 128;
+            if (x & 0x200000000000000000000000 > 0) result = (result * 0x100000000162E42FEFB2FED257559BDAA) >> 128;
+            if (x & 0x100000000000000000000000 > 0) result = (result * 0x1000000000B17217F7D5A7716BBA4A9AF) >> 128;
+            if (x & 0x80000000000000000000000 > 0) result = (result * 0x100000000058B90BFBE9DDBAC5E109CCF) >> 128;
+            if (x & 0x40000000000000000000000 > 0) result = (result * 0x10000000002C5C85FDF4B15DE6F17EB0E) >> 128;
+            if (x & 0x20000000000000000000000 > 0) result = (result * 0x1000000000162E42FEFA494F1478FDE05) >> 128;
+            if (x & 0x10000000000000000000000 > 0) result = (result * 0x10000000000B17217F7D20CF927C8E94D) >> 128;
+            if (x & 0x8000000000000000000000 > 0) result = (result * 0x1000000000058B90BFBE8F71CB4E4B33E) >> 128;
+            if (x & 0x4000000000000000000000 > 0) result = (result * 0x100000000002C5C85FDF477B662B26946) >> 128;
+            if (x & 0x2000000000000000000000 > 0) result = (result * 0x10000000000162E42FEFA3AE53369388D) >> 128;
+            if (x & 0x1000000000000000000000 > 0) result = (result * 0x100000000000B17217F7D1D351A389D41) >> 128;
+            if (x & 0x800000000000000000000 > 0) result = (result * 0x10000000000058B90BFBE8E8B2D3D4EDF) >> 128;
+            if (x & 0x400000000000000000000 > 0) result = (result * 0x1000000000002C5C85FDF4741BEA6E77F) >> 128;
+            if (x & 0x200000000000000000000 > 0) result = (result * 0x100000000000162E42FEFA39FE95583C3) >> 128;
+            if (x & 0x100000000000000000000 > 0) result = (result * 0x1000000000000B17217F7D1CFB72B45E3) >> 128;
+            if (x & 0x80000000000000000000 > 0) result = (result * 0x100000000000058B90BFBE8E7CC35C3F2) >> 128;
+            if (x & 0x40000000000000000000 > 0) result = (result * 0x10000000000002C5C85FDF473E242EA39) >> 128;
+            if (x & 0x20000000000000000000 > 0) result = (result * 0x1000000000000162E42FEFA39F02B772C) >> 128;
+            if (x & 0x10000000000000000000 > 0) result = (result * 0x10000000000000B17217F7D1CF7D83C1A) >> 128;
+            if (x & 0x8000000000000000000 > 0) result = (result * 0x1000000000000058B90BFBE8E7BDCBE2E) >> 128;
+            if (x & 0x4000000000000000000 > 0) result = (result * 0x100000000000002C5C85FDF473DEA871F) >> 128;
+            if (x & 0x2000000000000000000 > 0) result = (result * 0x10000000000000162E42FEFA39EF44D92) >> 128;
+            if (x & 0x1000000000000000000 > 0) result = (result * 0x100000000000000B17217F7D1CF79E949) >> 128;
+            if (x & 0x800000000000000000 > 0) result = (result * 0x10000000000000058B90BFBE8E7BCE545) >> 128;
+            if (x & 0x400000000000000000 > 0) result = (result * 0x1000000000000002C5C85FDF473DE6ECA) >> 128;
+            if (x & 0x200000000000000000 > 0) result = (result * 0x100000000000000162E42FEFA39EF366F) >> 128;
+            if (x & 0x100000000000000000 > 0) result = (result * 0x1000000000000000B17217F7D1CF79AFA) >> 128;
+            if (x & 0x80000000000000000 > 0) result = (result * 0x100000000000000058B90BFBE8E7BCD6E) >> 128;
+            if (x & 0x40000000000000000 > 0) result = (result * 0x10000000000000002C5C85FDF473DE6B3) >> 128;
+            if (x & 0x20000000000000000 > 0) result = (result * 0x1000000000000000162E42FEFA39EF359) >> 128;
+            if (x & 0x10000000000000000 > 0) result = (result * 0x10000000000000000B17217F7D1CF79AC) >> 128;
+
+            // We do two things at the same time below:
+            //
+            //     1. Multiply the result by 2^n + 1, where 2^n is the integer part and 1 is an extra bit to account
+            //        for the fact that we initially set the result to 0.5 We implement this by subtracting from 127
+            //        instead of 128.
+            //     2. Convert the result to the unsigned 60.18-decimal fixed-point format.
+            //
+            // This works because result * SCALE * 2^ip / 2^127 = result * SCALE / 2^(127 - ip), where ip is the integer
+            // part and SCALE / 2^128 is what converts the result to our unsigned fixed-point format.
+            result *= SCALE;
+            result >>= (127 - (x >> 128));
+        }
+    }
+
+    /// @notice Finds the zero-based index of the first one in the binary representation of x.
+    /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
+    /// @param x The uint256 number for which to find the index of the most significant bit.
+    /// @return msb The index of the most significant bit as an uint256.
+    function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
+        if (x >= 2**128) {
+            x >>= 128;
+            msb += 128;
+        }
+        if (x >= 2**64) {
+            x >>= 64;
+            msb += 64;
+        }
+        if (x >= 2**32) {
+            x >>= 32;
+            msb += 32;
+        }
+        if (x >= 2**16) {
+            x >>= 16;
+            msb += 16;
+        }
+        if (x >= 2**8) {
+            x >>= 8;
+            msb += 8;
+        }
+        if (x >= 2**4) {
+            x >>= 4;
+            msb += 4;
+        }
+        if (x >= 2**2) {
+            x >>= 2;
+            msb += 2;
+        }
+        if (x >= 2**1) {
+            // No need to shift x any more.
+            msb += 1;
+        }
+    }
+
+    /// @notice Calculates floor(x*y÷denominator) with full precision.
+    ///
+    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
+    ///
+    /// Requirements:
+    /// - The denominator cannot be zero.
+    /// - The result must fit within uint256.
+    ///
+    /// Caveats:
+    /// - This function does not work with fixed-point numbers.
+    ///
+    /// @param x The multiplicand as an uint256.
+    /// @param y The multiplier as an uint256.
+    /// @param denominator The divisor as an uint256.
+    /// @return result The result as an uint256.
+    function mulDiv(
+        uint256 x,
+        uint256 y,
+        uint256 denominator
+    ) internal pure returns (uint256 result) {
+        // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2**256 and mod 2**256 - 1, then use
+        // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+        // variables such that product = prod1 * 2**256 + prod0.
+        uint256 prod0; // Least significant 256 bits of the product
+        uint256 prod1; // Most significant 256 bits of the product
+        assembly {
+            let mm := mulmod(x, y, not(0))
+            prod0 := mul(x, y)
+            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+        }
+
+        // Handle non-overflow cases, 256 by 256 division
+        if (prod1 == 0) {
+            require(denominator > 0);
+            assembly {
+                result := div(prod0, denominator)
+            }
+            return result;
+        }
+
+        // Make sure the result is less than 2**256. Also prevents denominator == 0.
+        require(denominator > prod1);
+
+        ///////////////////////////////////////////////
+        // 512 by 256 division.
+        ///////////////////////////////////////////////
+
+        // Make division exact by subtracting the remainder from [prod1 prod0].
+        uint256 remainder;
+        assembly {
+            // Compute remainder using mulmod.
+            remainder := mulmod(x, y, denominator)
+
+            // Subtract 256 bit number from 512 bit number
+            prod1 := sub(prod1, gt(remainder, prod0))
+            prod0 := sub(prod0, remainder)
+        }
+
+        // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+        // See https://cs.stackexchange.com/q/138556/92363.
+        unchecked {
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 lpotdod = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by lpotdod.
+                denominator := div(denominator, lpotdod)
+
+                // Divide [prod1 prod0] by lpotdod.
+                prod0 := div(prod0, lpotdod)
+
+                // Flip lpotdod such that it is 2**256 / lpotdod. If lpotdod is zero, then it becomes one.
+                lpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * lpotdod;
+
+            // Invert denominator mod 2**256. Now that denominator is an odd number, it has an inverse modulo 2**256 such
+            // that denominator * inv = 1 mod 2**256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2**4
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Now use Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2**8
+            inverse *= 2 - denominator * inverse; // inverse mod 2**16
+            inverse *= 2 - denominator * inverse; // inverse mod 2**32
+            inverse *= 2 - denominator * inverse; // inverse mod 2**64
+            inverse *= 2 - denominator * inverse; // inverse mod 2**128
+            inverse *= 2 - denominator * inverse; // inverse mod 2**256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2**256. Since the precoditions guarantee that the outcome is
+            // less than 2**256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    /// @notice Calculates floor(x*y÷1e18) with full precision.
+    ///
+    /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the
+    /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of
+    /// being rounded to 1e-18.  See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.
+    ///
+    /// Requirements:
+    /// - The result must fit within uint256.
+    ///
+    /// Caveats:
+    /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMathCommon.mulDiv" to understand how this works.
+    /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:
+    ///     1. x * y = type(uint256).max * SCALE
+    ///     2. (x * y) % SCALE >= SCALE / 2
+    ///
+    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
+    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
+    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
+    function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
+        uint256 prod0;
+        uint256 prod1;
+        assembly {
+            let mm := mulmod(x, y, not(0))
+            prod0 := mul(x, y)
+            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+        }
+
+        uint256 remainder;
+        uint256 roundUpUnit;
+        assembly {
+            remainder := mulmod(x, y, SCALE)
+            roundUpUnit := gt(remainder, 499999999999999999)
+        }
+
+        if (prod1 == 0) {
+            unchecked {
+                result = (prod0 / SCALE) + roundUpUnit;
+                return result;
+            }
+        }
+
+        require(SCALE > prod1);
+
+        assembly {
+            result := add(
+                mul(
+                    or(
+                        div(sub(prod0, remainder), SCALE_LPOTD),
+                        mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
+                    ),
+                    SCALE_INVERSE
+                ),
+                roundUpUnit
+            )
+        }
+    }
+
+    /// @notice Calculates the square root of x, rounding down.
+    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
+    ///
+    /// Caveats:
+    /// - This function does not work with fixed-point numbers.
+    ///
+    /// @param x The uint256 number for which to calculate the square root.
+    /// @return result The result as an uint256.
+    function sqrt(uint256 x) internal pure returns (uint256 result) {
+        if (x == 0) {
+            return 0;
+        }
+
+        // Calculate the square root of the perfect square of a power of two that is the closest to x.
+        uint256 xAux = uint256(x);
+        result = 1;
+        if (xAux >= 0x100000000000000000000000000000000) {
+            xAux >>= 128;
+            result <<= 64;
+        }
+        if (xAux >= 0x10000000000000000) {
+            xAux >>= 64;
+            result <<= 32;
+        }
+        if (xAux >= 0x100000000) {
+            xAux >>= 32;
+            result <<= 16;
+        }
+        if (xAux >= 0x10000) {
+            xAux >>= 16;
+            result <<= 8;
+        }
+        if (xAux >= 0x100) {
+            xAux >>= 8;
+            result <<= 4;
+        }
+        if (xAux >= 0x10) {
+            xAux >>= 4;
+            result <<= 2;
+        }
+        if (xAux >= 0x8) {
+            result <<= 1;
+        }
+
+        // The operations can never overflow because the result is max 2^127 when it enters this block.
+        unchecked {
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1;
+            result = (result + x / result) >> 1; // Seven iterations should be enough
+            uint256 roundedDownResult = x / result;
+            return result >= roundedDownResult ? roundedDownResult : result;
+        }
+    }
+}
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/base64.sol b/compiler/test/libsolidity/semanticTests/externalContracts/base64.sol
new file mode 100644
index 00000000..646601e6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/base64.sol
@@ -0,0 +1,60 @@
+==== ExternalSource: _base64/base64_inline_asm.sol ====
+==== ExternalSource: _base64/base64_no_inline_asm.sol ====
+==== Source: base64.sol ====
+
+import "_base64/base64_inline_asm.sol";
+import "_base64/base64_no_inline_asm.sol";
+
+contract test {
+    function encode_inline_asm(bytes memory data) external pure returns (string memory) {
+      return InlineAsmBase64.encode(data);
+    }
+
+    function encode_no_asm(bytes memory data) external pure returns (string memory) {
+      return NoAsmBase64.encode(data);
+    }
+
+    function encode_inline_asm_large() external {
+      for (uint i = 0; i < 1000; i++) {
+        InlineAsmBase64.encode("foo");
+      }
+    }
+
+    function encode_no_asm_large() external {
+      for (uint i = 0; i < 1000; i++) {
+        NoAsmBase64.encode("foo");
+      }
+    }
+}
+// Test cases derived from Base64 specification: RFC4648
+// https://datatracker.ietf.org/doc/html/rfc4648#section-10
+//
+// ====
+// EVMVersion: >=constantinople
+// ----
+// constructor()
+// gas irOptimized: 405832
+// gas legacy: 735054
+// gas legacyOptimized: 522722
+// encode_inline_asm(bytes): 0x20, 0 -> 0x20, 0
+// encode_inline_asm(bytes): 0x20, 1, "f" -> 0x20, 4, "Zg=="
+// encode_inline_asm(bytes): 0x20, 2, "fo" -> 0x20, 4, "Zm8="
+// encode_inline_asm(bytes): 0x20, 3, "foo" -> 0x20, 4, "Zm9v"
+// encode_inline_asm(bytes): 0x20, 4, "foob" -> 0x20, 8, "Zm9vYg=="
+// encode_inline_asm(bytes): 0x20, 5, "fooba" -> 0x20, 8, "Zm9vYmE="
+// encode_inline_asm(bytes): 0x20, 6, "foobar" -> 0x20, 8, "Zm9vYmFy"
+// encode_no_asm(bytes): 0x20, 0 -> 0x20, 0
+// encode_no_asm(bytes): 0x20, 1, "f" -> 0x20, 4, "Zg=="
+// encode_no_asm(bytes): 0x20, 2, "fo" -> 0x20, 4, "Zm8="
+// encode_no_asm(bytes): 0x20, 3, "foo" -> 0x20, 4, "Zm9v"
+// encode_no_asm(bytes): 0x20, 4, "foob" -> 0x20, 8, "Zm9vYg=="
+// encode_no_asm(bytes): 0x20, 5, "fooba" -> 0x20, 8, "Zm9vYmE="
+// encode_no_asm(bytes): 0x20, 6, "foobar" -> 0x20, 8, "Zm9vYmFy"
+// encode_inline_asm_large()
+// gas irOptimized: 1322025
+// gas legacy: 1554031
+// gas legacyOptimized: 1132031
+// encode_no_asm_large()
+// gas irOptimized: 3206081
+// gas legacy: 4587075
+// gas legacyOptimized: 2823075
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol b/compiler/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol
new file mode 100644
index 00000000..4f3342de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol
@@ -0,0 +1,210 @@
+// ┏━━━┓━┏┓━┏┓━━┏━━━┓━━┏━━━┓━━━━┏━━━┓━━━━━━━━━━━━━━━━━━━┏┓━━━━━┏━━━┓━━━━━━━━━┏┓━━━━━━━━━━━━━━┏┓━
+// ┃┏━━┛┏┛┗┓┃┃━━┃┏━┓┃━━┃┏━┓┃━━━━┗┓┏┓┃━━━━━━━━━━━━━━━━━━┏┛┗┓━━━━┃┏━┓┃━━━━━━━━┏┛┗┓━━━━━━━━━━━━┏┛┗┓
+// ┃┗━━┓┗┓┏┛┃┗━┓┗┛┏┛┃━━┃┃━┃┃━━━━━┃┃┃┃┏━━┓┏━━┓┏━━┓┏━━┓┏┓┗┓┏┛━━━━┃┃━┗┛┏━━┓┏━┓━┗┓┏┛┏━┓┏━━┓━┏━━┓┗┓┏┛
+// ┃┏━━┛━┃┃━┃┏┓┃┏━┛┏┛━━┃┃━┃┃━━━━━┃┃┃┃┃┏┓┃┃┏┓┃┃┏┓┃┃━━┫┣┫━┃┃━━━━━┃┃━┏┓┃┏┓┃┃┏┓┓━┃┃━┃┏┛┗━┓┃━┃┏━┛━┃┃━
+// ┃┗━━┓━┃┗┓┃┃┃┃┃┃┗━┓┏┓┃┗━┛┃━━━━┏┛┗┛┃┃┃━┫┃┗┛┃┃┗┛┃┣━━┃┃┃━┃┗┓━━━━┃┗━┛┃┃┗┛┃┃┃┃┃━┃┗┓┃┃━┃┗┛┗┓┃┗━┓━┃┗┓
+// ┗━━━┛━┗━┛┗┛┗┛┗━━━┛┗┛┗━━━┛━━━━┗━━━┛┗━━┛┃┏━┛┗━━┛┗━━┛┗┛━┗━┛━━━━┗━━━┛┗━━┛┗┛┗┛━┗━┛┗┛━┗━━━┛┗━━┛━┗━┛
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┗┛━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+// SPDX-License-Identifier: CC0-1.0
+
+// This interface is designed to be compatible with the Vyper version.
+/// @notice This is the Ethereum 2.0 deposit contract interface.
+/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
+interface IDepositContract {
+    /// @notice A processed deposit event.
+    event DepositEvent(
+        bytes pubkey,
+        bytes withdrawal_credentials,
+        bytes amount,
+        bytes signature,
+        bytes index
+    );
+
+    /// @notice Submit a Phase 0 DepositData object.
+    /// @param pubkey A BLS12-381 public key.
+    /// @param withdrawal_credentials Commitment to a public key for withdrawals.
+    /// @param signature A BLS12-381 signature.
+    /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
+    /// Used as a protection against malformed input.
+    function deposit(
+        bytes calldata pubkey,
+        bytes calldata withdrawal_credentials,
+        bytes calldata signature,
+        bytes32 deposit_data_root
+    ) external payable;
+
+    /// @notice Query the current deposit root hash.
+    /// @return The deposit root hash.
+    function get_deposit_root() external view returns (bytes32);
+
+    /// @notice Query the current deposit count.
+    /// @return The deposit count encoded as a little endian 64-bit number.
+    function get_deposit_count() external view returns (bytes memory);
+}
+
+// Based on official specification in https://eips.ethereum.org/EIPS/eip-165
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceId The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceId` and
+    ///  `interfaceId` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool);
+}
+
+// This is a rewrite of the Vyper Eth2.0 deposit contract in Solidity.
+// It tries to stay as close as possible to the original source code.
+/// @notice This is the Ethereum 2.0 deposit contract interface.
+/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
+contract DepositContract is IDepositContract, ERC165 {
+    uint constant DEPOSIT_CONTRACT_TREE_DEPTH = 32;
+    // NOTE: this also ensures `deposit_count` will fit into 64-bits
+    uint constant MAX_DEPOSIT_COUNT = 2**DEPOSIT_CONTRACT_TREE_DEPTH - 1;
+
+    bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] branch;
+    uint256 deposit_count;
+
+    bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] zero_hashes;
+
+    constructor() public {
+        // Compute hashes in empty sparse Merkle tree
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH - 1; height++)
+            zero_hashes[height + 1] = sha256(abi.encodePacked(zero_hashes[height], zero_hashes[height]));
+    }
+
+    function get_deposit_root() override external view returns (bytes32) {
+        bytes32 node;
+        uint size = deposit_count;
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
+            if ((size & 1) == 1)
+                node = sha256(abi.encodePacked(branch[height], node));
+            else
+                node = sha256(abi.encodePacked(node, zero_hashes[height]));
+            size /= 2;
+        }
+        return sha256(abi.encodePacked(
+            node,
+            to_little_endian_64(uint64(deposit_count)),
+            bytes24(0)
+        ));
+    }
+
+    function get_deposit_count() override external view returns (bytes memory) {
+        return to_little_endian_64(uint64(deposit_count));
+    }
+
+    function deposit(
+        bytes calldata pubkey,
+        bytes calldata withdrawal_credentials,
+        bytes calldata signature,
+        bytes32 deposit_data_root
+    ) override external payable {
+        // Extended ABI length checks since dynamic types are used.
+        require(pubkey.length == 48, "DepositContract: invalid pubkey length");
+        require(withdrawal_credentials.length == 32, "DepositContract: invalid withdrawal_credentials length");
+        require(signature.length == 96, "DepositContract: invalid signature length");
+
+        // Check deposit amount
+        require(msg.value >= 1 ether, "DepositContract: deposit value too low");
+        require(msg.value % 1 gwei == 0, "DepositContract: deposit value not multiple of gwei");
+        uint deposit_amount = msg.value / 1 gwei;
+        require(deposit_amount <= type(uint64).max, "DepositContract: deposit value too high");
+
+        // Emit `DepositEvent` log
+        bytes memory amount = to_little_endian_64(uint64(deposit_amount));
+        emit DepositEvent(
+            pubkey,
+            withdrawal_credentials,
+            amount,
+            signature,
+            to_little_endian_64(uint64(deposit_count))
+        );
+
+        // Compute deposit data root (`DepositData` hash tree root)
+        bytes32 pubkey_root = sha256(abi.encodePacked(pubkey, bytes16(0)));
+        bytes32 signature_root = sha256(abi.encodePacked(
+            sha256(abi.encodePacked(signature[:64])),
+            sha256(abi.encodePacked(signature[64:], bytes32(0)))
+        ));
+        bytes32 node = sha256(abi.encodePacked(
+            sha256(abi.encodePacked(pubkey_root, withdrawal_credentials)),
+            sha256(abi.encodePacked(amount, bytes24(0), signature_root))
+        ));
+
+        // Verify computed and expected deposit data roots match
+        require(node == deposit_data_root, "DepositContract: reconstructed DepositData does not match supplied deposit_data_root");
+
+        // Avoid overflowing the Merkle tree (and prevent edge case in computing `branch`)
+        require(deposit_count < MAX_DEPOSIT_COUNT, "DepositContract: merkle tree full");
+
+        // Add deposit data root to Merkle tree (update a single `branch` node)
+        deposit_count += 1;
+        uint size = deposit_count;
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
+            if ((size & 1) == 1) {
+                branch[height] = node;
+                return;
+            }
+            node = sha256(abi.encodePacked(branch[height], node));
+            size /= 2;
+        }
+        // As the loop should always end prematurely with the `return` statement,
+        // this code should be unreachable. We assert `false` just to be safe.
+        assert(false);
+    }
+
+    function supportsInterface(bytes4 interfaceId) override external pure returns (bool) {
+        return interfaceId == type(ERC165).interfaceId || interfaceId == type(IDepositContract).interfaceId;
+    }
+
+    function to_little_endian_64(uint64 value) internal pure returns (bytes memory ret) {
+        ret = new bytes(8);
+        bytes8 bytesValue = bytes8(value);
+        // Byteswapping during copying to bytes.
+        ret[0] = bytesValue[7];
+        ret[1] = bytesValue[6];
+        ret[2] = bytesValue[5];
+        ret[3] = bytesValue[4];
+        ret[4] = bytesValue[3];
+        ret[5] = bytesValue[2];
+        ret[6] = bytesValue[1];
+        ret[7] = bytesValue[0];
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 1386886
+// gas legacy: 2369061
+// gas legacyOptimized: 1740144
+// supportsInterface(bytes4): 0x0 -> 0
+// supportsInterface(bytes4): 0xffffffff00000000000000000000000000000000000000000000000000000000 -> false # defined to be false by ERC-165 #
+// supportsInterface(bytes4): 0x01ffc9a700000000000000000000000000000000000000000000000000000000 -> true # ERC-165 id #
+// supportsInterface(bytes4): 0x8564090700000000000000000000000000000000000000000000000000000000 -> true # the deposit interface id #
+// get_deposit_root() -> 0xd70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e
+// gas irOptimized: 115231
+// gas legacy: 148205
+// gas legacyOptimized: 122303
+// get_deposit_count() -> 0x20, 8, 0 # TODO: check balance and logs after each deposit #
+// deposit(bytes,bytes,bytes,bytes32), 32 ether: 0 -> FAILURE # Empty input #
+// get_deposit_root() -> 0xd70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e
+// gas irOptimized: 115231
+// gas legacy: 148205
+// gas legacyOptimized: 122303
+// get_deposit_count() -> 0x20, 8, 0
+// deposit(bytes,bytes,bytes,bytes32), 1 ether: 0x80, 0xe0, 0x120, 0xaa4a8d0b7d9077248630f1a4701ae9764e42271d7f22b7838778411857fd349e, 0x30, 0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f73292, 0x67a8811c397529dac52ae1342ba58c9500000000000000000000000000000000, 0x20, 0x00f50428677c60f997aadeab24aabf7fceaef491c96a52b463ae91f95611cf71, 0x60, 0xa29d01cc8c6296a8150e515b5995390ef841dc18948aa3e79be6d7c1851b4cbb, 0x5d6ff49fa70b9c782399506a22a85193151b9b691245cebafd2063012443c132, 0x4b6c36debaedefb7b2d71b0503ffdc00150aaffd42e63358238ec888901738b8 -> # txhash: 0x7085c586686d666e8bb6e9477a0f0b09565b2060a11f1c4209d3a52295033832 #
+// ~ emit DepositEvent(bytes,bytes,bytes,bytes,bytes): 0xa0, 0x0100, 0x0140, 0x0180, 0x0200, 0x30, 0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f73292, 0x67a8811c397529dac52ae1342ba58c9500000000000000000000000000000000, 0x20, 0xf50428677c60f997aadeab24aabf7fceaef491c96a52b463ae91f95611cf71, 0x08, 0xca9a3b00000000000000000000000000000000000000000000000000000000, 0x60, 0xa29d01cc8c6296a8150e515b5995390ef841dc18948aa3e79be6d7c1851b4cbb, 0x5d6ff49fa70b9c782399506a22a85193151b9b691245cebafd2063012443c132, 0x4b6c36debaedefb7b2d71b0503ffdc00150aaffd42e63358238ec888901738b8, 0x08, 0x00
+// get_deposit_root() -> 0x2089653123d9c721215120b6db6738ba273bbc5228ac093b1f983badcdc8a438
+// gas irOptimized: 115216
+// gas legacy: 148214
+// gas legacyOptimized: 122315
+// get_deposit_count() -> 0x20, 8, 0x0100000000000000000000000000000000000000000000000000000000000000
+// deposit(bytes,bytes,bytes,bytes32), 32 ether: 0x80, 0xe0, 0x120, 0xdbd986dc85ceb382708cf90a3500f500f0a393c5ece76963ac3ed72eccd2c301, 0x30, 0xb2ce0f79f90e7b3a113ca5783c65756f96c4b4673c2b5c1eb4efc22280259441, 0x06d601211e8866dc5b50dc48a244dd7c00000000000000000000000000000000, 0x20, 0x00344b6c73f71b11c56aba0d01b7d8ad83559f209d0a4101a515f6ad54c89771, 0x60, 0x945caaf82d18e78c033927d51f452ebcd76524497b91d7a11219cb3db6a1d369, 0x7595fc095ce489e46b2ef129591f2f6d079be4faaf345a02c5eb133c072e7c56, 0x0c6c3617eee66b4b878165c502357d49485326bc6b31bc96873f308c8f19c09d -> # txhash: 0x404d8e109822ce448e68f45216c12cb051b784d068fbe98317ab8e50c58304ac #
+// ~ emit DepositEvent(bytes,bytes,bytes,bytes,bytes): 0xa0, 0x0100, 0x0140, 0x0180, 0x0200, 0x30, 0xb2ce0f79f90e7b3a113ca5783c65756f96c4b4673c2b5c1eb4efc22280259441, 0x06d601211e8866dc5b50dc48a244dd7c00000000000000000000000000000000, 0x20, 0x344b6c73f71b11c56aba0d01b7d8ad83559f209d0a4101a515f6ad54c89771, 0x08, 0x40597307000000000000000000000000000000000000000000000000000000, 0x60, 0x945caaf82d18e78c033927d51f452ebcd76524497b91d7a11219cb3db6a1d369, 0x7595fc095ce489e46b2ef129591f2f6d079be4faaf345a02c5eb133c072e7c56, 0x0c6c3617eee66b4b878165c502357d49485326bc6b31bc96873f308c8f19c09d, 0x08, 0x0100000000000000000000000000000000000000000000000000000000000000
+// get_deposit_root() -> 0x40255975859377d912c53aa853245ebd939bdd2b33a28e084babdcc1ed8238ee
+// gas irOptimized: 115216
+// gas legacy: 148214
+// gas legacyOptimized: 122315
+// get_deposit_count() -> 0x20, 8, 0x0200000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol b/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol
new file mode 100644
index 00000000..3311a8dc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol
@@ -0,0 +1,93 @@
+==== ExternalSource: _prbmath/PRBMathCommon.sol ====
+==== ExternalSource: _prbmath/PRBMathSD59x18.sol ====
+==== Source: prbmath.sol ====
+import "_prbmath/PRBMathSD59x18.sol";
+
+contract test {
+    using PRBMathSD59x18 for int256;
+
+    function div(int256 x, int256 y) external pure returns (int256 ret) {
+        ret = x.div(y);
+    }
+    function exp(int256 x) external pure returns (int256 ret) {
+        ret = x.exp();
+    }
+    function exp2(int256 x) external pure returns (int256 ret) {
+        ret = x.exp2();
+    }
+    function gm(int256 x, int256 y) external pure returns (int256 ret) {
+        ret = x.gm(y);
+    }
+    function log10(int256 x) external pure returns (int256 ret) {
+        ret = x.log10();
+    }
+    function log2(int256 x) external pure returns (int256 ret) {
+        ret = x.log2();
+    }
+    function mul(int256 x, int256 y) external pure returns (int256 ret) {
+        ret = x.mul(y);
+    }
+    function pow(int256 x, uint256 y) external pure returns (int256 ret) {
+        ret = x.pow(y);
+    }
+    function sqrt(int256 x) external pure returns (int256 ret) {
+        ret = x.sqrt();
+    }
+    function benchmark(int256 x) external pure returns (int256 ret, int256 z1, int256 z2) {
+        int256 y = x.mul(3).ceil();
+        int256 z = y.div(x);
+        for (uint i = 0; i < 10; i++)
+            z = z.sqrt();
+        ret = z;
+
+        // Check precision
+        z1 = z.ceil();
+        z2 = z.sqrt().pow(2).ceil();
+        assert(z1 == z2);
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 1841740
+// gas legacy: 2414091
+// gas legacyOptimized: 1847616
+// div(int256,int256): 3141592653589793238, 88714123 -> 35412542528203691288251815328
+// gas irOptimized: 22137
+// gas legacy: 22767
+// gas legacyOptimized: 22282
+// exp(int256): 3141592653589793238 -> 23140692632779268978
+// gas irOptimized: 24545
+// gas legacy: 25203
+// gas legacyOptimized: 24357
+// exp2(int256): 3141592653589793238 -> 8824977827076287620
+// gas irOptimized: 24257
+// gas legacy: 24864
+// gas legacyOptimized: 24110
+// gm(int256,int256): 3141592653589793238, 88714123 -> 16694419339601
+// gas irOptimized: 22970
+// gas legacy: 23228
+// gas legacyOptimized: 22683
+// log10(int256): 3141592653589793238 -> 4971498726941338506
+// gas irOptimized: 30609
+// gas legacy: 32934
+// gas legacyOptimized: 30323
+// log2(int256): 3141592653589793238 -> 1651496129472318782
+// gas irOptimized: 28819
+// gas legacy: 31067
+// gas legacyOptimized: 28426
+// mul(int256,int256): 3141592653589793238, 88714123 -> 278703637
+// gas irOptimized: 22225
+// gas legacy: 22807
+// gas legacyOptimized: 22295
+// pow(int256,uint256): 3141592653589793238, 5 -> 306019684785281453040
+// gas irOptimized: 22635
+// gas legacy: 23508
+// gas legacyOptimized: 22921
+// sqrt(int256): 3141592653589793238 -> 1772453850905516027
+// gas irOptimized: 22650
+// gas legacy: 22802
+// gas legacyOptimized: 22422
+// benchmark(int256): 3141592653589793238 -> 998882724338592125, 1000000000000000000, 1000000000000000000
+// gas irOptimized: 36630
+// gas legacy: 36673
+// gas legacyOptimized: 34729
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_unsigned.sol b/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_unsigned.sol
new file mode 100644
index 00000000..fb1d1a43
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/prbmath_unsigned.sol
@@ -0,0 +1,93 @@
+==== ExternalSource: _prbmath/PRBMathCommon.sol ====
+==== ExternalSource: _prbmath/PRBMathUD60x18.sol ====
+==== Source: prbmath.sol ====
+import "_prbmath/PRBMathUD60x18.sol";
+
+contract test {
+    using PRBMathUD60x18 for uint256;
+
+    function div(uint256 x, uint256 y) external pure returns (uint256 ret) {
+        ret = x.div(y);
+    }
+    function exp(uint256 x) external pure returns (uint256 ret) {
+        ret = x.exp();
+    }
+    function exp2(uint256 x) external pure returns (uint256 ret) {
+        ret = x.exp2();
+    }
+    function gm(uint256 x, uint256 y) external pure returns (uint256 ret) {
+        ret = x.gm(y);
+    }
+    function log10(uint256 x) external pure returns (uint256 ret) {
+        ret = x.log10();
+    }
+    function log2(uint256 x) external pure returns (uint256 ret) {
+        ret = x.log2();
+    }
+    function mul(uint256 x, uint256 y) external pure returns (uint256 ret) {
+        ret = x.mul(y);
+    }
+    function pow(uint256 x, uint256 y) external pure returns (uint256 ret) {
+        ret = x.pow(y);
+    }
+    function sqrt(uint256 x) external pure returns (uint256 ret) {
+        ret = x.sqrt();
+    }
+    function benchmark(uint256 x) external pure returns (uint256 ret, uint256 z1, uint256 z2) {
+        uint256 y = x.mul(3).ceil();
+        uint256 z = y.div(x);
+        for (uint i = 0; i < 10; i++)
+            z = z.sqrt();
+        ret = z;
+
+        // Check precision
+        z1 = z.ceil();
+        z2 = z.sqrt().pow(2).ceil();
+        assert(z1 == z2);
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 1716327
+// gas legacy: 2193550
+// gas legacyOptimized: 1725061
+// div(uint256,uint256): 3141592653589793238, 88714123 -> 35412542528203691288251815328
+// gas irOptimized: 22004
+// gas legacy: 22497
+// gas legacyOptimized: 22010
+// exp(uint256): 3141592653589793238 -> 23140692632779268978
+// gas irOptimized: 24444
+// gas legacy: 25104
+// gas legacyOptimized: 24258
+// exp2(uint256): 3141592653589793238 -> 8824977827076287620
+// gas irOptimized: 24198
+// gas legacy: 24814
+// gas legacyOptimized: 24062
+// gm(uint256,uint256): 3141592653589793238, 88714123 -> 16694419339601
+// gas irOptimized: 22950
+// gas legacy: 23269
+// gas legacyOptimized: 22724
+// log10(uint256): 3141592653589793238 -> 0x44fe4fc084a52b8a
+// gas irOptimized: 30269
+// gas legacy: 32898
+// gas legacyOptimized: 29925
+// log2(uint256): 3141592653589793238 -> 1651496129472318782
+// gas irOptimized: 28235
+// gas legacy: 30986
+// gas legacyOptimized: 28001
+// mul(uint256,uint256): 3141592653589793238, 88714123 -> 278703637
+// gas irOptimized: 22048
+// gas legacy: 22604
+// gas legacyOptimized: 22090
+// pow(uint256,uint256): 3141592653589793238, 5 -> 306019684785281453040
+// gas irOptimized: 22406
+// gas legacy: 23245
+// gas legacyOptimized: 22646
+// sqrt(uint256): 3141592653589793238 -> 1772453850905516027
+// gas irOptimized: 22672
+// gas legacy: 22820
+// gas legacyOptimized: 22440
+// benchmark(uint256): 3141592653589793238 -> 998882724338592125, 1000000000000000000, 1000000000000000000
+// gas irOptimized: 35603
+// gas legacy: 35385
+// gas legacyOptimized: 33449
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol b/compiler/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol
new file mode 100644
index 00000000..3f555405
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol
@@ -0,0 +1,42 @@
+==== ExternalSource: _prbmath/PRBMathCommon.sol ====
+==== ExternalSource: _prbmath/PRBMathSD59x18.sol ====
+==== Source: ramanujan_pi.sol ====
+import "_prbmath/PRBMathSD59x18.sol";
+
+// The goal of this test file is to implement Ramanujan's pi approximation using various libraries.
+
+function factorial(uint n) pure returns (uint ret) {
+    ret = 1;
+    for (; n > 1; --n)
+        ret *= n;
+}
+
+contract test {
+    using PRBMathSD59x18 for int256;
+
+    function prb_scale(uint n) internal pure returns (int256 ret) {
+        // Scale to SD59x18
+        ret = int256(n * 10e17);
+    }
+
+    // This dumb implementation of Ramanujan series calculates 1/pi
+    function prb_pi() external pure returns (int256 ret) {
+        uint n = 6; // More than 6 iterations results in failure
+        for (uint k = 0; k < n; k++) {
+            int256 a = prb_scale(factorial(4 * k)).div(prb_scale(factorial(k)).pow(4));
+            int256 b = (prb_scale(25390).mul(prb_scale(k)) + prb_scale(1103)).div(prb_scale(396).pow(4 * k));
+            ret += a.mul(b);
+        }
+        ret = ret.mul(prb_scale(2).sqrt().mul(prb_scale(2)).div(prb_scale(99).pow(2)));
+        ret = prb_scale(1).div(ret);
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 407507
+// gas legacy: 615090
+// gas legacyOptimized: 451871
+// prb_pi() -> 3141592656369545286
+// gas irOptimized: 57478
+// gas legacy: 100947
+// gas legacyOptimized: 75735
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/snark.sol b/compiler/test/libsolidity/semanticTests/externalContracts/snark.sol
new file mode 100644
index 00000000..d3492a5c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/snark.sol
@@ -0,0 +1,304 @@
+library Pairing {
+	struct G1Point {
+		uint X;
+		uint Y;
+	}
+	// Encoding of field elements is: X[0] * z + X[1]
+	struct G2Point {
+		uint[2] X;
+		uint[2] Y;
+	}
+
+	/// @return the generator of G1
+	function P1() internal returns (G1Point memory) {
+		return G1Point(1, 2);
+	}
+
+	/// @return the generator of G2
+	function P2() internal returns (G2Point memory) {
+		return G2Point(
+			[11559732032986387107991004021392285783925812861821192530917403151452391805634,
+			 10857046999023057135944570762232829481370756359578518086990519993285655852781],
+			[4082367875863433681332203403145435568316851327593401208105741076214120093531,
+			 8495653923123431417604973247489272438418190587263600148770280649306958101930]
+		);
+	}
+
+	/// @return the negation of p, i.e. p.add(p.negate()) should be zero.
+	function negate(G1Point memory p) internal returns (G1Point memory) {
+		// The prime q in the base field F_q for G1
+		uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+		if (p.X == 0 && p.Y == 0)
+			return G1Point(0, 0);
+		return G1Point(p.X, q - (p.Y % q));
+	}
+
+	/// @return r the sum of two points of G1
+	function add(G1Point memory p1, G1Point memory p2) internal returns (G1Point memory r) {
+		uint[4] memory input;
+		input[0] = p1.X;
+		input[1] = p1.Y;
+		input[2] = p2.X;
+		input[3] = p2.Y;
+		bool success;
+		assembly {
+			success := call(sub(gas(), 2000), 6, 0, input, 0xc0, r, 0x60)
+			// Use "invalid" to make gas estimation work
+			switch success case 0 { invalid() }
+		}
+		require(success);
+	}
+
+	/// @return r the product of a point on G1 and a scalar, i.e.
+	/// p == p.mul(1) and p.add(p) == p.mul(2) for all points p.
+	function mul(G1Point memory p, uint s) internal returns (G1Point memory r) {
+		uint[3] memory input;
+		input[0] = p.X;
+		input[1] = p.Y;
+		input[2] = s;
+		bool success;
+		assembly {
+			success := call(sub(gas(), 2000), 7, 0, input, 0x80, r, 0x60)
+			// Use "invalid" to make gas estimation work
+			switch success case 0 { invalid() }
+		}
+		require(success);
+	}
+
+	/// @return the result of computing the pairing check
+	/// e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
+	/// For example pairing([P1(), P1().negate()], [P2(), P2()]) should
+	/// return true.
+	function pairing(G1Point[] memory p1, G2Point[] memory p2) internal returns (bool) {
+		require(p1.length == p2.length);
+		uint elements = p1.length;
+		uint inputSize = p1.length * 6;
+		uint[] memory input = new uint[](inputSize);
+		for (uint i = 0; i < elements; i++)
+		{
+			input[i * 6 + 0] = p1[i].X;
+			input[i * 6 + 1] = p1[i].Y;
+			input[i * 6 + 2] = p2[i].X[0];
+			input[i * 6 + 3] = p2[i].X[1];
+			input[i * 6 + 4] = p2[i].Y[0];
+			input[i * 6 + 5] = p2[i].Y[1];
+		}
+		uint[1] memory out;
+		bool success;
+		assembly {
+			success := call(sub(gas(), 2000), 8, 0, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
+			// Use "invalid" to make gas estimation work
+			switch success case 0 { invalid() }
+		}
+		require(success);
+		return out[0] != 0;
+	}
+	function pairingProd2(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2) internal returns (bool) {
+		G1Point[] memory p1 = new G1Point[](2);
+		G2Point[] memory p2 = new G2Point[](2);
+		p1[0] = a1;
+		p1[1] = b1;
+		p2[0] = a2;
+		p2[1] = b2;
+		return pairing(p1, p2);
+	}
+	function pairingProd3(
+		G1Point memory a1, G2Point memory a2,
+		G1Point memory b1, G2Point memory b2,
+		G1Point memory c1, G2Point memory c2
+	) internal returns (bool) {
+		G1Point[] memory p1 = new G1Point[](3);
+		G2Point[] memory p2 = new G2Point[](3);
+		p1[0] = a1;
+		p1[1] = b1;
+		p1[2] = c1;
+		p2[0] = a2;
+		p2[1] = b2;
+		p2[2] = c2;
+		return pairing(p1, p2);
+	}
+	function pairingProd4(
+		G1Point memory a1, G2Point memory a2,
+		G1Point memory b1, G2Point memory b2,
+		G1Point memory c1, G2Point memory c2,
+			G1Point memory d1, G2Point memory d2
+	) internal returns (bool) {
+		G1Point[] memory p1 = new G1Point[](4);
+		G2Point[] memory p2 = new G2Point[](4);
+		p1[0] = a1;
+		p1[1] = b1;
+		p1[2] = c1;
+		p1[3] = d1;
+		p2[0] = a2;
+		p2[1] = b2;
+		p2[2] = c2;
+		p2[3] = d2;
+		return pairing(p1, p2);
+	}
+}
+
+contract Test {
+	using Pairing for *;
+	struct VerifyingKey {
+		Pairing.G2Point A;
+		Pairing.G1Point B;
+		Pairing.G2Point C;
+		Pairing.G2Point gamma;
+		Pairing.G1Point gammaBeta1;
+		Pairing.G2Point gammaBeta2;
+		Pairing.G2Point Z;
+		Pairing.G1Point[] IC;
+	}
+	struct Proof {
+		Pairing.G1Point A;
+		Pairing.G1Point A_p;
+		Pairing.G2Point B;
+		Pairing.G1Point B_p;
+		Pairing.G1Point C;
+		Pairing.G1Point C_p;
+		Pairing.G1Point K;
+		Pairing.G1Point H;
+	}
+	function f() public returns (bool) {
+		Pairing.G1Point memory p1;
+		Pairing.G1Point memory p2;
+		p1.X = 1; p1.Y = 2;
+		p2.X = 1; p2.Y = 2;
+		Pairing.G1Point memory explicit_sum = Pairing.add(p1, p2);
+		Pairing.G1Point memory scalar_prod = Pairing.mul(p1, 2);
+		return (explicit_sum.X == scalar_prod.X &&
+			explicit_sum.Y == scalar_prod.Y);
+	}
+	function g() public returns (bool) {
+		Pairing.G1Point memory x = Pairing.add(Pairing.P1(), Pairing.negate(Pairing.P1()));
+		// should be zero
+		return (x.X == 0 && x.Y == 0);
+	}
+	function testMul() public returns (bool) {
+		Pairing.G1Point memory p;
+		// @TODO The points here are reported to be not well-formed
+		p.X = 14125296762497065001182820090155008161146766663259912659363835465243039841726;
+		p.Y = 16229134936871442251132173501211935676986397196799085184804749187146857848057;
+		p = Pairing.mul(p, 13986731495506593864492662381614386532349950841221768152838255933892789078521);
+		return
+			p.X == 18256332256630856740336504687838346961237861778318632856900758565550522381207 &&
+			p.Y == 6976682127058094634733239494758371323697222088503263230319702770853579280803;
+	}
+	function pair() public returns (bool) {
+		Pairing.G2Point memory fiveTimesP2 = Pairing.G2Point(
+			[4540444681147253467785307942530223364530218361853237193970751657229138047649, 20954117799226682825035885491234530437475518021362091509513177301640194298072],
+			[11631839690097995216017572651900167465857396346217730511548857041925508482915, 21508930868448350162258892668132814424284302804699005394342512102884055673846]
+		);
+		// The prime p in the base field F_p for G1
+		uint p = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+		Pairing.G1Point[] memory g1points = new Pairing.G1Point[](2);
+		Pairing.G2Point[] memory g2points = new Pairing.G2Point[](2);
+		// check e(5 P1, P2)e(-P1, 5 P2) == 1
+		g1points[0] = Pairing.P1().mul(5);
+		g1points[1] = Pairing.P1().negate();
+		g2points[0] = Pairing.P2();
+		g2points[1] = fiveTimesP2;
+		if (!Pairing.pairing(g1points, g2points))
+			return false;
+		// check e(P1, P2)e(-P1, P2) == 1
+		g1points[0] = Pairing.P1();
+		g1points[1] = Pairing.P1();
+		g1points[1].Y = p - g1points[1].Y;
+		g2points[0] = Pairing.P2();
+		g2points[1] = Pairing.P2();
+		if (!Pairing.pairing(g1points, g2points))
+			return false;
+		return true;
+	}
+	function verifyingKey() internal returns (VerifyingKey memory vk) {
+		vk.A = Pairing.G2Point([0x209dd15ebff5d46c4bd888e51a93cf99a7329636c63514396b4a452003a35bf7, 0x04bf11ca01483bfa8b34b43561848d28905960114c8ac04049af4b6315a41678], [0x2bb8324af6cfc93537a2ad1a445cfd0ca2a71acd7ac41fadbf933c2a51be344d, 0x120a2a4cf30c1bf9845f20c6fe39e07ea2cce61f0c9bb048165fe5e4de877550]);
+		vk.B = Pairing.G1Point(0x2eca0c7238bf16e83e7a1e6c5d49540685ff51380f309842a98561558019fc02, 0x03d3260361bb8451de5ff5ecd17f010ff22f5c31cdf184e9020b06fa5997db84);
+		vk.C = Pairing.G2Point([0x2e89718ad33c8bed92e210e81d1853435399a271913a6520736a4729cf0d51eb, 0x01a9e2ffa2e92599b68e44de5bcf354fa2642bd4f26b259daa6f7ce3ed57aeb3], [0x14a9a87b789a58af499b314e13c3d65bede56c07ea2d418d6874857b70763713, 0x178fb49a2d6cd347dc58973ff49613a20757d0fcc22079f9abd10c3baee24590]);
+		vk.gamma = Pairing.G2Point([0x25f83c8b6ab9de74e7da488ef02645c5a16a6652c3c71a15dc37fe3a5dcb7cb1, 0x22acdedd6308e3bb230d226d16a105295f523a8a02bfc5e8bd2da135ac4c245d], [0x065bbad92e7c4e31bf3757f1fe7362a63fbfee50e7dc68da116e67d600d9bf68, 0x06d302580dc0661002994e7cd3a7f224e7ddc27802777486bf80f40e4ca3cfdb]);
+		vk.gammaBeta1 = Pairing.G1Point(0x15794ab061441e51d01e94640b7e3084a07e02c78cf3103c542bc5b298669f21, 0x14db745c6780e9df549864cec19c2daf4531f6ec0c89cc1c7436cc4d8d300c6d);
+		vk.gammaBeta2 = Pairing.G2Point([0x1f39e4e4afc4bc74790a4a028aff2c3d2538731fb755edefd8cb48d6ea589b5e, 0x283f150794b6736f670d6a1033f9b46c6f5204f50813eb85c8dc4b59db1c5d39], [0x140d97ee4d2b36d99bc49974d18ecca3e7ad51011956051b464d9e27d46cc25e, 0x0764bb98575bd466d32db7b15f582b2d5c452b36aa394b789366e5e3ca5aabd4]);
+		vk.Z = Pairing.G2Point([0x217cee0a9ad79a4493b5253e2e4e3a39fc2df38419f230d341f60cb064a0ac29, 0x0a3d76f140db8418ba512272381446eb73958670f00cf46f1d9e64cba057b53c], [0x26f64a8ec70387a13e41430ed3ee4a7db2059cc5fc13c067194bcc0cb49a9855, 0x2fd72bd9edb657346127da132e5b82ab908f5816c826acb499e22f2412d1a2d7]);
+		vk.IC = new Pairing.G1Point[](10);
+		vk.IC[0] = Pairing.G1Point(0x0aee46a7ea6e80a3675026dfa84019deee2a2dedb1bbe11d7fe124cb3efb4b5a, 0x044747b6e9176e13ede3a4dfd0d33ccca6321b9acd23bf3683a60adc0366ebaf);
+		vk.IC[1] = Pairing.G1Point(0x1e39e9f0f91fa7ff8047ffd90de08785777fe61c0e3434e728fce4cf35047ddc, 0x2e0b64d75ebfa86d7f8f8e08abbe2e7ae6e0a1c0b34d028f19fa56e9450527cb);
+		vk.IC[2] = Pairing.G1Point(0x1c36e713d4d54e3a9644dffca1fc524be4868f66572516025a61ca542539d43f, 0x042dcc4525b82dfb242b09cb21909d5c22643dcdbe98c4d082cc2877e96b24db);
+		vk.IC[3] = Pairing.G1Point(0x17d5d09b4146424bff7e6fb01487c477bbfcd0cdbbc92d5d6457aae0b6717cc5, 0x02b5636903efbf46db9235bbe74045d21c138897fda32e079040db1a16c1a7a1);
+		vk.IC[4] = Pairing.G1Point(0x0f103f14a584d4203c27c26155b2c955f8dfa816980b24ba824e1972d6486a5d, 0x0c4165133b9f5be17c804203af781bcf168da7386620479f9b885ecbcd27b17b);
+		vk.IC[5] = Pairing.G1Point(0x232063b584fb76c8d07995bee3a38fa7565405f3549c6a918ddaa90ab971e7f8, 0x2ac9b135a81d96425c92d02296322ad56ffb16299633233e4880f95aafa7fda7);
+		vk.IC[6] = Pairing.G1Point(0x09b54f111d3b2d1b2fe1ae9669b3db3d7bf93b70f00647e65c849275de6dc7fe, 0x18b2e77c63a3e400d6d1f1fbc6e1a1167bbca603d34d03edea231eb0ab7b14b4);
+		vk.IC[7] = Pairing.G1Point(0x0c54b42137b67cc268cbb53ac62b00ecead23984092b494a88befe58445a244a, 0x18e3723d37fae9262d58b548a0575f59d9c3266db7afb4d5739555837f6b8b3e);
+		vk.IC[8] = Pairing.G1Point(0x0a6de0e2240aa253f46ce0da883b61976e3588146e01c9d8976548c145fe6e4a, 0x04fbaa3a4aed4bb77f30ebb07a3ec1c7d77a7f2edd75636babfeff97b1ea686e);
+		vk.IC[9] = Pairing.G1Point(0x111e2e2a5f8828f80ddad08f9f74db56dac1cc16c1cb278036f79a84cf7a116f, 0x1d7d62e192b219b9808faa906c5ced871788f6339e8d91b83ac1343e20a16b30);
+	}
+	function verify(uint[] memory input, Proof memory proof) internal returns (uint) {
+		VerifyingKey memory vk = verifyingKey();
+		require(input.length + 1 == vk.IC.length);
+		// Compute the linear combination vk_x
+		Pairing.G1Point memory vk_x = Pairing.G1Point(0, 0);
+		for (uint i = 0; i < input.length; i++)
+			vk_x = Pairing.add(vk_x, Pairing.mul(vk.IC[i + 1], input[i]));
+		vk_x = Pairing.add(vk_x, vk.IC[0]);
+		if (!Pairing.pairingProd2(proof.A, vk.A, Pairing.negate(proof.A_p), Pairing.P2())) return 1;
+		if (!Pairing.pairingProd2(vk.B, proof.B, Pairing.negate(proof.B_p), Pairing.P2())) return 2;
+		if (!Pairing.pairingProd2(proof.C, vk.C, Pairing.negate(proof.C_p), Pairing.P2())) return 3;
+		if (!Pairing.pairingProd3(
+			proof.K, vk.gamma,
+			Pairing.negate(Pairing.add(vk_x, Pairing.add(proof.A, proof.C))), vk.gammaBeta2,
+			Pairing.negate(vk.gammaBeta1), proof.B
+		)) return 4;
+		if (!Pairing.pairingProd3(
+			Pairing.add(vk_x, proof.A), proof.B,
+			Pairing.negate(proof.H), vk.Z,
+			Pairing.negate(proof.C), Pairing.P2()
+		)) return 5;
+		return 0;
+	}
+	event Verified(string);
+	function verifyTx() public returns (bool) {
+		uint[] memory input = new uint[](9);
+		Proof memory proof;
+		proof.A = Pairing.G1Point(12873740738727497448187997291915224677121726020054032516825496230827252793177, 21804419174137094775122804775419507726154084057848719988004616848382402162497);
+		proof.A_p = Pairing.G1Point(7742452358972543465462254569134860944739929848367563713587808717088650354556, 7324522103398787664095385319014038380128814213034709026832529060148225837366);
+		proof.B = Pairing.G2Point(
+			[8176651290984905087450403379100573157708110416512446269839297438960217797614, 15588556568726919713003060429893850972163943674590384915350025440408631945055],
+			[15347511022514187557142999444367533883366476794364262773195059233657571533367, 4265071979090628150845437155927259896060451682253086069461962693761322642015]);
+		proof.B_p = Pairing.G1Point(2979746655438963305714517285593753729335852012083057917022078236006592638393, 6470627481646078059765266161088786576504622012540639992486470834383274712950);
+		proof.C = Pairing.G1Point(6851077925310461602867742977619883934042581405263014789956638244065803308498, 10336382210592135525880811046708757754106524561907815205241508542912494488506);
+		proof.C_p = Pairing.G1Point(12491625890066296859584468664467427202390981822868257437245835716136010795448, 13818492518017455361318553880921248537817650587494176379915981090396574171686);
+		proof.H = Pairing.G1Point(12091046215835229523641173286701717671667447745509192321596954139357866668225, 14446807589950902476683545679847436767890904443411534435294953056557941441758);
+		proof.K = Pairing.G1Point(21341087976609916409401737322664290631992568431163400450267978471171152600502, 2942165230690572858696920423896381470344658299915828986338281196715687693170);
+		input[0] = 13986731495506593864492662381614386532349950841221768152838255933892789078521;
+		input[1] = 622860516154313070522697309645122400675542217310916019527100517240519630053;
+		input[2] = 11094488463398718754251685950409355128550342438297986977413505294941943071569;
+		input[3] = 6627643779954497813586310325594578844876646808666478625705401786271515864467;
+		input[4] = 2957286918163151606545409668133310005545945782087581890025685458369200827463;
+		input[5] = 1384290496819542862903939282897996566903332587607290986044945365745128311081;
+		input[6] = 5613571677741714971687805233468747950848449704454346829971683826953541367271;
+		input[7] = 9643208548031422463313148630985736896287522941726746581856185889848792022807;
+		input[8] = 18066496933330839731877828156604;
+		if (verify(input, proof) == 0) {
+			emit Verified("Successfully verified.");
+			return true;
+		} else {
+			return false;
+		}
+	}
+}
+/// Disabled because the point seems to be not well-formed, we need to find another example.
+/// testMul() -> true
+//
+// ====
+// EVMVersion: >=constantinople
+// ----
+// library: Pairing
+// f() -> true
+// g() -> true
+// pair() -> true
+// gas irOptimized: 269697
+// gas legacy: 275206
+// gas legacyOptimized: 266925
+// verifyTx() -> true
+// ~ emit Verified(string): 0x20, 0x16, "Successfully verified."
+// gas irOptimized: 782210
+// gas legacy: 801868
+// gas legacyOptimized: 770942
diff --git a/compiler/test/libsolidity/semanticTests/externalContracts/strings.sol b/compiler/test/libsolidity/semanticTests/externalContracts/strings.sol
new file mode 100644
index 00000000..18d6db37
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/externalContracts/strings.sol
@@ -0,0 +1,74 @@
+==== ExternalSource: _stringutils/stringutils.sol ====
+==== Source: strings.sol ====
+pragma abicoder v2;
+import "_stringutils/stringutils.sol";
+
+contract test {
+    using strings for bytes32;
+    using strings for string;
+    using strings for strings.slice;
+
+    function toSlice(string memory a) external pure returns (strings.slice memory) {
+        return a.toSlice();
+    }
+
+    function roundtrip(string memory a) external pure returns (string memory) {
+        return a.toSlice().toString();
+    }
+
+    function utf8len(string memory a) external pure returns (uint) {
+        return a.toSlice().len();
+    }
+
+    function multiconcat(string memory a, uint count) public pure returns (string memory) {
+        strings.slice memory s = a.toSlice();
+        for (uint i = 0; i < count; i++) {
+            s = s.concat(s).toSlice();
+        }
+        return s.toString();
+    }
+
+    function benchmark(string memory text, bytes32 seed) external pure returns (uint) {
+        // Grow text.
+        text = multiconcat(text, 10);
+
+        strings.slice memory a = text.toSlice();
+        strings.slice memory b = seed.toSliceB32();
+
+        // Some heavy computation.
+        bool c = b.equals(a) || b.startsWith(a);
+
+        // Join as a list.
+        strings.slice memory delim = c ? string(",").toSlice() : string(";").toSlice();
+        strings.slice[] memory parts = new strings.slice[](2);
+        parts[0] = a;
+        parts[1] = b;
+        string memory d = delim.join(parts);
+        return d.toSlice().len();
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 630224
+// gas legacy: 1061957
+// gas legacyOptimized: 718937
+// toSlice(string): 0x20, 11, "hello world" -> 11, 0xa0
+// gas irOptimized: 22660
+// gas legacy: 23190
+// gas legacyOptimized: 22508
+// roundtrip(string): 0x20, 11, "hello world" -> 0x20, 11, "hello world"
+// gas irOptimized: 23408
+// gas legacy: 23820
+// gas legacyOptimized: 23123
+// utf8len(string): 0x20, 16, "\xf0\x9f\x98\x83\xf0\x9f\x98\x83\xf0\x9f\x98\x83\xf0\x9f\x98\x83" -> 4 # Input: "😃😃😃😃" #
+// gas irOptimized: 24026
+// gas legacy: 25716
+// gas legacyOptimized: 24115
+// multiconcat(string,uint256): 0x40, 3, 11, "hello world" -> 0x20, 0x58, 0x68656c6c6f20776f726c6468656c6c6f20776f726c6468656c6c6f20776f726c, 0x6468656c6c6f20776f726c6468656c6c6f20776f726c6468656c6c6f20776f72, 49027192869463622675296414541903001712009715982962058146354235762728281047040 # concatenating 3 times #
+// gas irOptimized: 28440
+// gas legacy: 31621
+// gas legacyOptimized: 27914
+// benchmark(string,bytes32): 0x40, 0x0842021, 8, "solidity" -> 0x2020
+// gas irOptimized: 1980944
+// gas legacy: 4233999
+// gas legacyOptimized: 2318684
diff --git a/compiler/test/libsolidity/semanticTests/fallback/call_forward_bytes.sol b/compiler/test/libsolidity/semanticTests/fallback/call_forward_bytes.sol
new file mode 100644
index 00000000..7bf3aee3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/fallback/call_forward_bytes.sol
@@ -0,0 +1,25 @@
+contract receiver {
+    uint256 public received;
+    function recv(uint256 x) public { received += x + 1; }
+    fallback() external { received = 0x80; }
+}
+contract sender {
+    constructor() { rec = new receiver();}
+    fallback() external { savedData = msg.data; }
+    function forward() public returns (bool) { address(rec).call(savedData); return true; }
+    function clear() public returns (bool) { delete savedData; return true; }
+    function val() public returns (uint) { return rec.received(); }
+    receiver rec;
+    bytes savedData;
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// recv(uint256): 7 ->
+// val() -> 0
+// forward() -> true
+// val() -> 8
+// clear() -> true
+// val() -> 8
+// forward() -> true
+// val() -> 0x80
diff --git a/compiler/test/libsolidity/semanticTests/fallback/falback_return.sol b/compiler/test/libsolidity/semanticTests/fallback/falback_return.sol
new file mode 100644
index 00000000..d59bb9d4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/fallback/falback_return.sol
@@ -0,0 +1,16 @@
+contract A {
+    uint public x;
+    fallback () external {
+        if (x == 2) return;
+        x++;
+    }
+}
+// ----
+// ()
+// x() -> 1
+// ()
+// x() -> 2
+// ()
+// x() -> 2
+// ()
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/fallback/fallback_or_receive.sol b/compiler/test/libsolidity/semanticTests/fallback/fallback_or_receive.sol
new file mode 100644
index 00000000..9b5319ae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/fallback/fallback_or_receive.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint x;
+    uint y;
+    fallback () payable external { ++x; }
+    receive () payable external { ++y; }
+    function f() external returns (uint, uint) { return (x, y); }
+}
+// ----
+// f() -> 0, 0
+// () ->
+// f() -> 0, 1
+// (), 1 ether ->
+// f() -> 0, 2
+// (): 1 ->
+// f() -> 1, 2
+// (), 1 ether: 1 ->
+// f() -> 2, 2
diff --git a/compiler/test/libsolidity/semanticTests/fallback/inherited.sol b/compiler/test/libsolidity/semanticTests/fallback/inherited.sol
new file mode 100644
index 00000000..55c63944
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/fallback/inherited.sol
@@ -0,0 +1,10 @@
+contract A {
+    uint data;
+    fallback() external { data = 1; }
+    function getData() public returns (uint r) { return data; }
+}
+contract B is A {}
+// ----
+// getData() -> 0
+// (): 42 ->
+// getData() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/fallback/short_data_calls_fallback.sol b/compiler/test/libsolidity/semanticTests/fallback/short_data_calls_fallback.sol
new file mode 100644
index 00000000..dd97f4c0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/fallback/short_data_calls_fallback.sol
@@ -0,0 +1,17 @@
+contract A {
+    uint public x;
+    // Signature is d88e0b00
+    function fow() public { x = 3; }
+    fallback () external { x = 2; }
+}
+// ----
+// (): hex"d88e0b"
+// x() -> 2
+// (): hex"d88e0b00"
+// x() -> 3
+// (): hex"d88e"
+// x() -> 2
+// (): hex"d88e0b00"
+// x() -> 3
+// (): hex"d8"
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/easy.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/easy.sol
new file mode 100644
index 00000000..f73f1012
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/easy.sol
@@ -0,0 +1,11 @@
+function add(uint a, uint b) pure returns (uint) {
+  return a + b;
+}
+
+contract C {
+  function f(uint x) public pure returns (uint) {
+    return add(x, 2);
+  }
+}
+// ----
+// f(uint256): 7 -> 9
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/free_namesake_contract_function.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/free_namesake_contract_function.sol
new file mode 100644
index 00000000..cf414028
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/free_namesake_contract_function.sol
@@ -0,0 +1,8 @@
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function f() public pure returns (uint) {
+    return f();
+  }
+}
+// ----
+// f() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/import.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/import.sol
new file mode 100644
index 00000000..edd44de4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/import.sol
@@ -0,0 +1,18 @@
+==== Source: A ====
+struct S { uint x; }
+function set(S storage a, uint v) { a.x = v; }
+
+==== Source: B ====
+import "A";
+import "A" as A;
+contract C {
+  A.S data;
+  function f(uint v) public returns (uint one, uint two) {
+    A.set(data, v);
+    one = data.x;
+    set(data, v + 1);
+    two = data.x;
+  }
+}
+// ----
+// f(uint256): 7 -> 7, 8
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/new_operator.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/new_operator.sol
new file mode 100644
index 00000000..dd44a1b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/new_operator.sol
@@ -0,0 +1,16 @@
+contract C {
+  uint public x = 2;
+}
+
+function test() returns (uint) {
+  return (new C()).x();
+}
+
+contract D {
+  function f() public returns (uint) {
+    return test();
+  }
+}
+// ----
+// f() -> 2
+// gas legacy: 100211
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/overloads.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/overloads.sol
new file mode 100644
index 00000000..6a2da653
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/overloads.sol
@@ -0,0 +1,14 @@
+function f(uint) returns (uint) {
+    return 2;
+}
+function f(string memory) returns (uint) {
+    return 3;
+}
+
+contract C {
+  function g() public returns (uint, uint) {
+      return (f(2), f("abc"));
+  }
+}
+// ----
+// g() -> 2, 3
diff --git a/compiler/test/libsolidity/semanticTests/freeFunctions/recursion.sol b/compiler/test/libsolidity/semanticTests/freeFunctions/recursion.sol
new file mode 100644
index 00000000..894a60f3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/freeFunctions/recursion.sol
@@ -0,0 +1,21 @@
+function exp(uint base, uint exponent) pure returns (uint power) {
+    if (exponent == 0)
+        return 1;
+    power = exp(base, exponent / 2);
+    power *= power;
+    if (exponent & 1 == 1)
+        power *= base;
+}
+
+contract C {
+  function g(uint base, uint exponent) public pure returns (uint) {
+      return exp(base, exponent);
+  }
+}
+// ----
+// g(uint256,uint256): 0, 0 -> 1
+// g(uint256,uint256): 0, 1 -> 0x00
+// g(uint256,uint256): 1, 0 -> 1
+// g(uint256,uint256): 2, 3 -> 8
+// g(uint256,uint256): 3, 10 -> 59049
+// g(uint256,uint256): 2, 255 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/array_multiple_local_vars.sol b/compiler/test/libsolidity/semanticTests/functionCall/array_multiple_local_vars.sol
new file mode 100644
index 00000000..4dbfe91f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/array_multiple_local_vars.sol
@@ -0,0 +1,28 @@
+contract test {
+    function f(uint256[] calldata seq) external pure returns (uint256) {
+        uint i = 0;
+        uint sum = 0;
+        while (i < seq.length)
+        {
+            uint idx = i;
+            if (idx >= 10) break;
+            uint x = seq[idx];
+            if (x >= 1000) {
+                uint n = i + 1;
+                i = n;
+                continue;
+            }
+            else {
+                uint y = sum + x;
+                sum = y;
+            }
+            if (sum >= 500) return sum;
+            i++;
+        }
+        return sum;
+    }
+}
+// ----
+// f(uint256[]): 32, 3, 1000, 1, 2 -> 3
+// f(uint256[]): 32, 3, 100, 500, 300 -> 600
+// f(uint256[]): 32, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 111 -> 55
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_function.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_function.sol
new file mode 100644
index 00000000..023133a4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_function.sol
@@ -0,0 +1,13 @@
+library L {
+    function g(function() internal returns (uint) _t) internal returns (uint) { return _t(); }
+}
+contract C {
+    using L for *;
+    function f() public returns (uint) {
+        return t.g();
+    }
+    function t() public pure returns (uint)  { return 7; }
+}
+// ----
+// library: L
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_storage_variable.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_storage_variable.sol
new file mode 100644
index 00000000..5a599c8a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_storage_variable.sol
@@ -0,0 +1,13 @@
+library D { struct s { uint a; } function mul(s storage self, uint x) public returns (uint) { return self.a *= x; } }
+contract C {
+    using D for D.s;
+    D.s public x;
+    function f(uint a) public returns (uint) {
+        x.a = 6;
+        return (x.mul)({x: a});
+    }
+}
+// ----
+// library: D
+// f(uint256): 7 -> 0x2a
+// x() -> 0x2a
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_string.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_string.sol
new file mode 100644
index 00000000..d2d23fb6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_attached_library_function_on_string.sol
@@ -0,0 +1,17 @@
+library D { function length(string memory self) public returns (uint) { return bytes(self).length; } }
+contract C {
+    using D for string;
+    string x;
+    function f() public returns (uint) {
+        x = "abc";
+        return x.length();
+    }
+    function g() public returns (uint) {
+        string memory s = "abc";
+        return s.length();
+    }
+}
+// ----
+// library: D
+// f() -> 3
+// g() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_function.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_function.sol
new file mode 100644
index 00000000..a00628ea
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_function.sol
@@ -0,0 +1,25 @@
+contract test {
+    function f0() public returns (uint) {
+        return 2;
+    }
+
+    function f1() internal returns (function() internal returns (uint)) {
+        return f0;
+    }
+
+    function f2() internal returns (function() internal returns (function () internal returns (uint))) {
+        return f1;
+    }
+
+    function f3() internal returns (function() internal returns (function () internal returns (function () internal returns (uint)))) {
+        return f2;
+    }
+
+    function f() public returns (uint) {
+        function() internal returns(function() internal returns(function() internal returns(function() internal returns(uint)))) x;
+        x = f3;
+        return x()()()();
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_nothing_via_pointer.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_nothing_via_pointer.sol
new file mode 100644
index 00000000..b43c453d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_function_returning_nothing_via_pointer.sol
@@ -0,0 +1,16 @@
+contract test {
+    bool public flag = false;
+
+    function f0() public {
+        flag = true;
+    }
+
+    function f() public returns (bool) {
+        function() internal x = f0;
+        x();
+        return flag;
+    }
+}
+// ----
+// f() -> true
+// flag() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_internal_function_via_expression.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_internal_function_via_expression.sol
new file mode 100644
index 00000000..0b880bfd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_internal_function_via_expression.sol
@@ -0,0 +1,22 @@
+contract C {
+    function foo() internal returns (uint) {
+        return 42;
+    }
+
+    function get_ptr(function() internal returns (uint) ptr) internal returns(function() internal returns (uint)) {
+        return ptr;
+    }
+
+    function associated() public returns (uint) {
+        // This expression directly references function definition
+        return (foo)();
+    }
+
+    function unassociated() public returns (uint) {
+        // This expression is not associated with a specific function definition
+        return (get_ptr(foo))();
+    }
+}
+// ----
+// associated() -> 42
+// unassociated() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/call_options_overload.sol b/compiler/test/libsolidity/semanticTests/functionCall/call_options_overload.sol
new file mode 100644
index 00000000..b9eb6ca4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/call_options_overload.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f(uint x) external payable returns (uint) { return 1; }
+    function f(uint x, uint y) external payable returns (uint) { return 2; }
+    function call() public payable returns (uint v, uint x, uint y, uint z) {
+        v = this.f{value: 10}(2);
+        x = this.f{gas: 10000}(2, 3);
+        y = this.f{gas: 10000, value: 10}(2, 3);
+        z = this.f{value: 10, gas: 10000}(2, 3);
+    }
+    function bal() external returns (uint) { return address(this).balance; }
+    receive() external payable {}
+}
+// ----
+// (), 1 ether
+// call() -> 1, 2, 2, 2
+// bal() -> 1000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol b/compiler/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol
new file mode 100644
index 00000000..22961838
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/calling_nonexisting_contract_throws.sol
@@ -0,0 +1,27 @@
+abstract contract D {
+    function g() public virtual;
+}
+
+
+contract C {
+    D d = D(address(0x1212));
+
+    function f() public returns (uint256) {
+        d.g();
+        return 7;
+    }
+
+    function g() public returns (uint256) {
+        d.g{gas: 200}();
+        return 7;
+    }
+
+    function h() public returns (uint256) {
+        address(d).call(""); // this does not throw (low-level)
+        return 7;
+    }
+}
+// ----
+// f() -> FAILURE
+// g() -> FAILURE
+// h() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/calling_other_functions.sol b/compiler/test/libsolidity/semanticTests/functionCall/calling_other_functions.sol
new file mode 100644
index 00000000..9b008f12
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/calling_other_functions.sol
@@ -0,0 +1,20 @@
+contract collatz {
+    function run(uint x) public returns(uint y) {
+        while ((y = x) > 1) {
+            if (x % 2 == 0) x = evenStep(x);
+            else x = oddStep(x);
+        }
+    }
+    function evenStep(uint x) public returns(uint y) {
+        return x / 2;
+    }
+    function oddStep(uint x) public returns(uint y) {
+        return 3 * x + 1;
+    }
+}
+// ----
+// run(uint256): 0 -> 0
+// run(uint256): 1 -> 1
+// run(uint256): 2 -> 1
+// run(uint256): 8 -> 1
+// run(uint256): 127 -> 1
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function.sol b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function.sol
new file mode 100644
index 00000000..701b1f51
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function.sol
@@ -0,0 +1,16 @@
+contract C {
+    function intern() public returns (uint256) {
+        function (uint) internal returns (uint) x;
+        x(2);
+        return 7;
+    }
+
+    function extern() public returns (uint256) {
+        function (uint) external returns (uint) x;
+        x(2);
+        return 7;
+    }
+}
+// ----
+// intern() -> FAILURE, hex"4e487b71", 0x51 # This should throw exceptions #
+// extern() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_in_detail.sol b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_in_detail.sol
new file mode 100644
index 00000000..aa455afc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_in_detail.sol
@@ -0,0 +1,19 @@
+contract C {
+    function() returns (uint256) internal x;
+    int256 mutex;
+
+    function t() public returns (uint256) {
+        if (mutex > 0) {
+            assembly {
+                mstore(0, 7)
+                return(0, 0x20)
+            }
+        }
+        mutex = 1;
+        // Avoid re-executing this function if we jump somewhere.
+        x();
+        return 2;
+    }
+}
+// ----
+// t() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_through_array.sol b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_through_array.sol
new file mode 100644
index 00000000..d83fab85
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/calling_uninitialized_function_through_array.sol
@@ -0,0 +1,19 @@
+contract C {
+    int256 mutex;
+
+    function t() public returns (uint256) {
+        if (mutex > 0) {
+            assembly {
+                mstore(0, 7)
+                return(0, 0x20)
+            }
+        }
+        mutex = 1;
+        // Avoid re-executing this function if we jump somewhere.
+        function() internal returns (uint)[200] memory x;
+        x[0]();
+        return 2;
+    }
+}
+// ----
+// t() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/conditional_with_arguments.sol b/compiler/test/libsolidity/semanticTests/functionCall/conditional_with_arguments.sol
new file mode 100644
index 00000000..f5996d32
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/conditional_with_arguments.sol
@@ -0,0 +1,10 @@
+contract C {
+    function g(int x, int y) public pure returns (int) { return x - y; }
+    function h(int y, int x) public pure returns (int) { return y - x; }
+
+    function f() public pure returns (int) {
+        return (false ? g : h)(2, 1);
+    }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_no_args.sol b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_no_args.sol
new file mode 100644
index 00000000..b6a33fb7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_no_args.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint public i;
+    constructor() {
+        i = 2;
+    }
+}
+contract D {
+    function f() public returns (uint r) {
+        return new C().i();
+    }
+}
+// ----
+// f() -> 2
+// gas legacy: 100185
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol
new file mode 100644
index 00000000..39592f4a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol
@@ -0,0 +1,21 @@
+contract C {
+    uint public i;
+    constructor(uint newI) {
+        i = newI;
+    }
+}
+contract D {
+    C c;
+    constructor(uint v) {
+        c = new C(v);
+    }
+    function f() public returns (uint r) {
+        return c.i();
+    }
+}
+// ----
+// constructor(): 2 ->
+// gas irOptimized: 192703
+// gas legacy: 241234
+// gas legacyOptimized: 192961
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol
new file mode 100644
index 00000000..3850a0be
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol
@@ -0,0 +1,23 @@
+contract C {
+    uint public i;
+    constructor(uint newI) {
+        i = newI;
+    }
+}
+contract D {
+    C c;
+    constructor(uint v) {
+        c = new C{salt: "abc"}(v);
+    }
+    function f() public returns (uint r) {
+        return c.i();
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// constructor(): 2 ->
+// gas irOptimized: 192866
+// gas legacy: 241606
+// gas legacyOptimized: 193193
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/disordered_named_args.sol b/compiler/test/libsolidity/semanticTests/functionCall/disordered_named_args.sol
new file mode 100644
index 00000000..f15d2201
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/disordered_named_args.sol
@@ -0,0 +1,6 @@
+contract test {
+    function a(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+    function b() public returns (uint r) { r = a({c: 3, a: 1, b: 2}); }
+}
+// ----
+// b() -> 123
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call.sol
new file mode 100644
index 00000000..9189d5cc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call.sol
@@ -0,0 +1,14 @@
+pragma solidity >= 0.6.0;
+
+contract C {
+    function g(uint n) external pure returns (uint) {
+        return n + 1;
+    }
+
+    function f(uint n) public view returns (uint) {
+        return this.g(2 * n);
+    }
+}
+// ----
+// g(uint256): 4 -> 5
+// f(uint256): 2 -> 5
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol
new file mode 100644
index 00000000..6f7f020f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call_at_construction_time.sol
@@ -0,0 +1,24 @@
+// This tests skipping the extcodesize check.
+
+contract T {
+    constructor() { this.f(); }
+    function f() external {}
+}
+contract U {
+    constructor() { this.f(); }
+    function f() external returns (uint) {}
+}
+
+contract C {
+    function f(uint c) external returns (uint) {
+        if (c == 0) new T();
+        else if (c == 1) new U();
+        return 1 + c;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// f(uint256): 0 -> FAILURE
+// f(uint256): 1 -> FAILURE
+// f(uint256): 2 -> 3
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call_dynamic_returndata.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call_dynamic_returndata.sol
new file mode 100644
index 00000000..80ca6cc4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call_dynamic_returndata.sol
@@ -0,0 +1,22 @@
+pragma solidity >= 0.6.0;
+
+contract C {
+    function d(uint n) external pure returns (uint[] memory) {
+        uint[] memory data = new uint[](n);
+        for (uint i = 0; i < data.length; ++i)
+            data[i] = i;
+        return data;
+    }
+
+    function dt(uint n) public view returns (uint) {
+        uint[] memory data = this.d(n);
+        uint sum = 0;
+        for (uint i = 0; i < data.length; ++i)
+            sum += data[i];
+        return sum;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// dt(uint256): 4 -> 6
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol
new file mode 100644
index 00000000..a1c74cf8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol
@@ -0,0 +1,34 @@
+// This tests skipping the extcodesize check.
+
+interface I {
+    function a() external pure;
+    function b() external;
+    function c() external payable;
+    function x() external returns (uint);
+    function y() external returns (string memory);
+}
+contract C {
+    I i = I(address(0xcafecafe));
+    constructor() payable {}
+    function f(uint c) external returns (uint) {
+        if (c == 0) i.a();
+        else if (c == 1) i.b();
+        else if (c == 2) i.c();
+        else if (c == 3) i.c{value: 1}();
+        else if (c == 4) i.x();
+        else if (c == 5) i.y();
+        return 1 + c;
+    }
+}
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 262355
+// gas legacy: 441442
+// gas legacyOptimized: 292862
+// f(uint256): 0 -> FAILURE
+// f(uint256): 1 -> FAILURE
+// f(uint256): 2 -> FAILURE
+// f(uint256): 3 -> FAILURE
+// f(uint256): 4 -> FAILURE
+// f(uint256): 5 -> FAILURE
+// f(uint256): 6 -> 7
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol
new file mode 100644
index 00000000..96f097ce
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol
@@ -0,0 +1,37 @@
+// This tests skipping the extcodesize check.
+
+interface I {
+    function a() external pure;
+    function b() external;
+    function c() external payable;
+    function x() external returns (uint);
+    function y() external returns (string memory);
+}
+contract C {
+    I i = I(address(0xcafecafe));
+    constructor() payable {}
+    function f(uint c) external returns (uint) {
+        if (c == 0) i.a();
+        else if (c == 1) i.b();
+        else if (c == 2) i.c();
+        else if (c == 3) i.c{value: 1}();
+        else if (c == 4) i.x();
+        else if (c == 5) i.y();
+        return 1 + c;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// revertStrings: debug
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 390464
+// gas legacy: 809985
+// gas legacyOptimized: 498331
+// f(uint256): 0 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 1 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 2 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 3 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 4 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 5 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code"
+// f(uint256): 6 -> 7
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_call_value.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_call_value.sol
new file mode 100644
index 00000000..9639c111
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_call_value.sol
@@ -0,0 +1,14 @@
+pragma solidity >= 0.6.0;
+
+contract C {
+    function g(uint n) external payable returns (uint, uint) {
+        return (msg.value * 1000, n);
+    }
+
+    function f(uint n) public payable returns (uint, uint) {
+        return this.g{value: 10}(n);
+    }
+}
+// ----
+// g(uint256), 1 ether: 4 -> 1000000000000000000000, 4
+// f(uint256), 11 ether: 2 -> 10000, 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_function.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_function.sol
new file mode 100644
index 00000000..284bad09
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_function.sol
@@ -0,0 +1,15 @@
+contract c {
+    function f(uint256 a) public returns (uint256) {
+        return a;
+    }
+
+    function test(uint256 a, uint256 b)
+        external
+        returns (uint256 r_a, uint256 r_b)
+    {
+        r_a = f(a + 7);
+        r_b = b;
+    }
+}
+// ----
+// test(uint256,uint256): 2, 3 -> 9, 3
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/external_public_override.sol b/compiler/test/libsolidity/semanticTests/functionCall/external_public_override.sol
new file mode 100644
index 00000000..8e34a5b2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/external_public_override.sol
@@ -0,0 +1,19 @@
+contract A {
+    function f() external virtual returns (uint256) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() public override returns (uint256) {
+        return 2;
+    }
+
+    function g() public returns (uint256) {
+        return f();
+    }
+}
+// ----
+// f() -> 2
+// g() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/failed_create.sol b/compiler/test/libsolidity/semanticTests/functionCall/failed_create.sol
new file mode 100644
index 00000000..091e5a77
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/failed_create.sol
@@ -0,0 +1,33 @@
+contract D { constructor() payable {} }
+contract C {
+	uint public x;
+	constructor() payable {}
+	function f(uint amount) public returns (D) {
+		x++;
+		return (new D){value: amount}();
+	}
+	function stack(uint depth) public payable returns (address) {
+		if (depth > 0)
+			return this.stack(depth - 1);
+		else
+			return address(f(0));
+	}
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// constructor(), 20 wei
+// gas irOptimized: 166148
+// gas legacy: 285547
+// gas legacyOptimized: 168515
+// f(uint256): 20 -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a
+// x() -> 1
+// f(uint256): 20 -> FAILURE
+// x() -> 1
+// stack(uint256): 1023 -> FAILURE
+// gas irOptimized: 252410
+// gas legacy: 477722
+// gas legacyOptimized: 299567
+// x() -> 1
+// stack(uint256): 10 -> 0x87948bd7ebbe13a00bfd930c93e4828ab18e3908
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/file_level_call_via_module.sol b/compiler/test/libsolidity/semanticTests/functionCall/file_level_call_via_module.sol
new file mode 100644
index 00000000..7013a635
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/file_level_call_via_module.sol
@@ -0,0 +1,13 @@
+==== Source: a.sol ====
+function f(uint) pure returns (uint) { return 7; }
+function f(bytes memory x) pure returns (uint) { return x.length; }
+==== Source: b.sol ====
+import "a.sol" as M;
+contract C {
+    function f() public pure returns (uint, uint) {
+        return (M.f(2), M.f("abc"));
+
+    }
+}
+// ----
+// f() -> 7, 3
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol b/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol
new file mode 100644
index 00000000..79a829aa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol
@@ -0,0 +1,46 @@
+contract helper {
+    bool flag;
+
+    function getBalance() public payable returns (uint256 myBalance) {
+        return address(this).balance;
+    }
+
+    function setFlag() public {
+        flag = true;
+    }
+
+    function getFlag() public returns (bool fl) {
+        return flag;
+    }
+}
+
+
+contract test {
+    helper h;
+
+    constructor() payable {
+        h = new helper();
+    }
+
+    function sendAmount(uint256 amount) public payable returns (uint256 bal) {
+        return h.getBalance{value: amount}();
+    }
+
+    function outOfGas() public returns (bool ret) {
+        h.setFlag{gas: 2}(); // should fail due to OOG
+        return true;
+    }
+
+    function checkState() public returns (bool flagAfter, uint256 myBal) {
+        flagAfter = h.getFlag();
+        myBal = address(this).balance;
+    }
+}
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 252642
+// gas legacy: 391588
+// gas legacyOptimized: 268089
+// sendAmount(uint256): 5 -> 5
+// outOfGas() -> FAILURE # call to helper should not succeed but amount should be transferred anyway #
+// checkState() -> false, 15
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol b/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol
new file mode 100644
index 00000000..71b6ebb2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/gas_and_value_brace_syntax.sol
@@ -0,0 +1,45 @@
+contract helper {
+    bool flag;
+
+    function getBalance() payable public returns(uint256 myBalance) {
+        return address(this).balance;
+    }
+
+    function setFlag() public {
+        flag = true;
+    }
+
+    function getFlag() public returns(bool fl) {
+        return flag;
+    }
+}
+contract test {
+    helper h;
+    constructor() payable {
+        h = new helper();
+    }
+
+    function sendAmount(uint amount) public payable returns(uint256 bal) {
+        return h.getBalance{value: amount}();
+    }
+
+    function outOfGas() public returns(bool ret) {
+        h.setFlag {
+            gas: 2
+        }(); // should fail due to OOG
+        return true;
+    }
+
+    function checkState() public returns(bool flagAfter, uint myBal) {
+        flagAfter = h.getFlag();
+        myBal = address(this).balance;
+    }
+}
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 252642
+// gas legacy: 391588
+// gas legacyOptimized: 268089
+// sendAmount(uint256): 5 -> 5
+// outOfGas() -> FAILURE # call to helper should not succeed but amount should be transferred anyway #
+// checkState() -> false, 15
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_base_overload.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_base_overload.sol
new file mode 100644
index 00000000..adf1200e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_base_overload.sol
@@ -0,0 +1,50 @@
+contract BaseBase {
+	uint public x;
+	uint public y;
+	function init(uint a, uint b) public virtual {
+		x = b;
+		y = a;
+	}
+	function init(uint a) public virtual {
+		x = a + 1;
+	}
+}
+
+contract Base is BaseBase {
+	function init(uint a, uint b) public override {
+		x = a;
+		y = b;
+	}
+	function init(uint a) public override {
+		x = a;
+	}
+}
+
+contract Child is Base {
+	function cInit(uint c) public {
+		Base.init(c);
+	}
+	function cInit(uint c, uint d) public {
+		Base.init(c, d);
+	}
+	function bInit(uint c) public {
+		BaseBase.init(c);
+	}
+	function bInit(uint c, uint d) public {
+		BaseBase.init(c, d);
+	}
+}
+// ----
+// x() -> 0
+// y() -> 0
+// cInit(uint256): 2 ->
+// x() -> 2
+// y() -> 0
+// cInit(uint256,uint256): 3, 3 ->
+// x() -> 3
+// y() -> 3
+// bInit(uint256): 4 ->
+// x() -> 5
+// bInit(uint256,uint256): 9, 10 ->
+// x() -> 10
+// y() -> 9
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_overload.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_overload.sol
new file mode 100644
index 00000000..924431ec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/base_overload.sol
@@ -0,0 +1,29 @@
+contract Base {
+	uint public x;
+	uint public y;
+	function init(uint a, uint b) public {
+		x = a;
+		y = b;
+	}
+	function init(uint a) public {
+		x = a;
+	}
+}
+
+contract Child is Base {
+	function cInit(uint c) public {
+		Base.init(c);
+	}
+	function cInit(uint c, uint d) public {
+		Base.init(c, d);
+	}
+}
+// ----
+// x() -> 0
+// y() -> 0
+// cInit(uint256): 2 ->
+// x() -> 2
+// y() -> 0
+// cInit(uint256,uint256): 3, 3 ->
+// x() -> 3
+// y() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base.sol
new file mode 100644
index 00000000..8f0e93dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base.sol
@@ -0,0 +1,13 @@
+contract Base {
+	function f(uint n) public returns (uint) {
+		return 2 * n;
+	}
+}
+
+contract Child is Base {
+	function g(uint n) public returns (uint) {
+		return f(n);
+	}
+}
+// ----
+// g(uint256): 4 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base.sol
new file mode 100644
index 00000000..8578a670
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base.sol
@@ -0,0 +1,27 @@
+contract BaseBase {
+	function f(uint n) public virtual returns (uint) {
+		return 2 * n;
+	}
+	function s(uint n) public returns (uint) {
+		return 4 * n;
+	}
+}
+
+contract Base is BaseBase {
+	function f(uint n) public virtual override returns (uint) {
+		return 3 * n;
+	}
+}
+
+contract Child is Base {
+	function g(uint n) public returns (uint) {
+		return f(n);
+	}
+
+	function h(uint n) public returns (uint) {
+		return s(n);
+	}
+}
+// ----
+// g(uint256): 4 -> 12
+// h(uint256): 4 -> 16
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base_explicit.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base_explicit.sol
new file mode 100644
index 00000000..f327b3f2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_base_explicit.sol
@@ -0,0 +1,30 @@
+contract BaseBase {
+	function f(uint n) public virtual returns (uint) {
+		return 2 * n;
+	}
+
+	function s(uint n) public returns (uint) {
+		return 4 * n;
+	}
+}
+
+contract Base is BaseBase {
+	function f(uint n) public virtual override returns (uint) {
+		return 3 * n;
+	}
+}
+
+contract Child is Base {
+	function g(uint n) public returns (uint) {
+		// calling base-bse function of a virtual overridden function.
+		return BaseBase.f(n);
+	}
+
+	function k(uint n) public returns (uint) {
+		// Calling base-base function of a non-virtual function.
+		return BaseBase.s(n);
+	}
+}
+// ----
+// g(uint256): 4 -> 8
+// k(uint256): 4 -> 16
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_explicit.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_explicit.sol
new file mode 100644
index 00000000..0a0cf465
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_base_explicit.sol
@@ -0,0 +1,13 @@
+contract Base {
+	function f(uint n) public returns (uint) {
+		return 2 * n;
+	}
+}
+
+contract Child is Base {
+	function g(uint n) public returns (uint) {
+		return Base.f(n);
+	}
+}
+// ----
+// g(uint256): 4 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_unimplemented_base.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_unimplemented_base.sol
new file mode 100644
index 00000000..21ab22e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/call_unimplemented_base.sol
@@ -0,0 +1,18 @@
+abstract contract I
+{
+    function a() internal view virtual returns(uint256);
+}
+abstract contract J is I
+{
+    function a() internal view virtual override returns(uint256);
+}
+abstract contract V is J
+{
+    function b() public view returns(uint256) { return a(); }
+}
+contract C is V
+{
+    function a() internal view override returns (uint256) { return 42; }
+}
+// ----
+// b() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_abstract_contract.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_abstract_contract.sol
new file mode 100644
index 00000000..20774d69
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_abstract_contract.sol
@@ -0,0 +1,19 @@
+contract A {
+    function f() public virtual returns (uint) {
+        return 42;
+    }
+}
+
+abstract contract I {
+    function f() external virtual returns (uint);
+}
+
+contract B is A, I {
+    function f() override(A, I) public returns (uint) {
+        // I.f() is before A.f() in the C3 linearized order
+        // but it has no implementation.
+        return super.f();
+    }
+}
+// ----
+// f() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_interface.sol b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_interface.sol
new file mode 100644
index 00000000..f5f05613
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/inheritance/super_skip_unimplemented_in_interface.sol
@@ -0,0 +1,19 @@
+contract A {
+    function f() public virtual returns (uint) {
+        return 42;
+    }
+}
+
+interface I {
+    function f() external returns (uint);
+}
+
+contract B is A, I {
+    function f() override(A, I) public returns (uint) {
+        // I.f() is before A.f() in the C3 linearized order
+        // but it has no implementation.
+        return super.f();
+    }
+}
+// ----
+// f() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/mapping_array_internal_argument.sol b/compiler/test/libsolidity/semanticTests/functionCall/mapping_array_internal_argument.sol
new file mode 100644
index 00000000..28c1822d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/mapping_array_internal_argument.sol
@@ -0,0 +1,26 @@
+contract test {
+    mapping(uint8 => uint8)[2] a;
+    mapping(uint8 => uint8)[2] b;
+    function set_internal(mapping(uint8 => uint8)[2] storage m, uint8 key, uint8 value1, uint8 value2) internal returns (uint8, uint8) {
+        uint8 oldValue1 = m[0][key];
+        uint8 oldValue2 = m[1][key];
+        m[0][key] = value1;
+        m[1][key] = value2;
+        return (oldValue1, oldValue2);
+    }
+    function set(uint8 key, uint8 value_a1, uint8 value_a2, uint8 value_b1, uint8 value_b2) public returns (uint8 old_a1, uint8 old_a2, uint8 old_b1, uint8 old_b2) {
+        (old_a1, old_a2) = set_internal(a, key, value_a1, value_a2);
+        (old_b1, old_b2) = set_internal(b, key, value_b1, value_b2);
+    }
+    function get(uint8 key) public returns (uint8, uint8, uint8, uint8) {
+        return (a[0][key], a[1][key], b[0][key], b[1][key]);
+    }
+}
+// ----
+// set(uint8,uint8,uint8,uint8,uint8): 1, 21, 22, 42, 43 -> 0, 0, 0, 0
+// gas irOptimized: 111628
+// gas legacy: 113748
+// gas legacyOptimized: 111772
+// get(uint8): 1 -> 21, 22, 42, 43
+// set(uint8,uint8,uint8,uint8,uint8): 1, 10, 30, 11, 31 -> 21, 22, 42, 43
+// get(uint8): 1 -> 10, 30, 11, 31
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/member_accessors.sol b/compiler/test/libsolidity/semanticTests/functionCall/member_accessors.sol
new file mode 100644
index 00000000..ae5eab6d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/member_accessors.sol
@@ -0,0 +1,22 @@
+contract test {
+    uint256 public data;
+    bytes6 public name;
+    bytes32 public a_hash;
+    address public an_address;
+    constructor() {
+        data = 8;
+        name = "Celina";
+        a_hash = keccak256("\x7b");
+        an_address = address(0x1337);
+        super_secret_data = 42;
+    }
+    uint256 super_secret_data;
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// data() -> 8
+// name() -> "Celina"
+// a_hash() -> 0xa91eddf639b0b768929589c1a9fd21dcb0107199bdd82e55c5348018a1572f52
+// an_address() -> 0x1337
+// super_secret_data() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/multiple_functions.sol b/compiler/test/libsolidity/semanticTests/functionCall/multiple_functions.sol
new file mode 100644
index 00000000..3c60a13f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/multiple_functions.sol
@@ -0,0 +1,14 @@
+contract test {
+    function a() public returns(uint n) { return 0; }
+    function b() public returns(uint n) { return 1; }
+    function c() public returns(uint n) { return 2; }
+    function f() public returns(uint n) { return 3; }
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// a() -> 0
+// b() -> 1
+// c() -> 2
+// f() -> 3
+// i_am_not_there() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/multiple_return_values.sol b/compiler/test/libsolidity/semanticTests/functionCall/multiple_return_values.sol
new file mode 100644
index 00000000..cb2a8a0c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/multiple_return_values.sol
@@ -0,0 +1,7 @@
+contract test {
+    function run(bool x1, uint x2) public returns(uint y1, bool y2, uint y3) {
+        y1 = x2; y2 = x1;
+    }
+}
+// ----
+// run(bool,uint256): true, 0xcd -> 0xcd, true, 0
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/named_args.sol b/compiler/test/libsolidity/semanticTests/functionCall/named_args.sol
new file mode 100644
index 00000000..706f6d94
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/named_args.sol
@@ -0,0 +1,8 @@
+contract test {
+    function a(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; }
+    function b() public returns (uint r) { r = a({a: 1, b: 2, c: 3}); }
+    function c() public returns (uint r) { r = a({b: 2, c: 3, a: 1}); }
+}
+// ----
+// b() -> 123
+// c() -> 123
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/named_args_overload.sol b/compiler/test/libsolidity/semanticTests/functionCall/named_args_overload.sol
new file mode 100644
index 00000000..65f34d8f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/named_args_overload.sol
@@ -0,0 +1,35 @@
+contract C {
+    function f() public returns (uint) {
+        return 0;
+    }
+    function f(uint a) public returns (uint) {
+        return a;
+    }
+    function f(uint a, uint b) public returns (uint) {
+        return a+b;
+    }
+    function f(uint a, uint b, uint c) public returns (uint) {
+        return a+b+c;
+    }
+    function call(uint num) public returns (uint256) {
+        if (num == 0)
+            return f();
+        if (num == 1)
+            return f({a: 1});
+        if (num == 2)
+            return f({b: 1, a: 2});
+        if (num == 3)
+            return f({c: 1, a: 2, b: 3});
+        if (num == 4)
+            return f({b: 5, c: 1, a: 2});
+
+        return 500;
+    }
+}
+// ----
+// call(uint256): 0 -> 0
+// call(uint256): 1 -> 1
+// call(uint256): 2 -> 3
+// call(uint256): 3 -> 6
+// call(uint256): 4 -> 8
+// call(uint256): 5 -> 500
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol b/compiler/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol
new file mode 100644
index 00000000..18a19979
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol
@@ -0,0 +1,21 @@
+// Sending zero ether to a contract should still invoke the receive ether function
+// (it previously did not because the gas stipend was not provided by the EVM)
+contract Receiver {
+    receive() external payable {}
+}
+
+
+contract Main {
+    constructor() payable {}
+
+    function s() public returns (bool) {
+        Receiver r = new Receiver();
+        return payable(r).send(0);
+    }
+}
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 100264
+// gas legacy: 113411
+// gas legacyOptimized: 100361
+// s() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/transaction_status.sol b/compiler/test/libsolidity/semanticTests/functionCall/transaction_status.sol
new file mode 100644
index 00000000..caa538de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/transaction_status.sol
@@ -0,0 +1,9 @@
+contract test {
+	function f() public { }
+	function g() public { revert(); }
+	function h() public { assert(false); }
+}
+// ----
+// f() ->
+// g() -> FAILURE
+// h() -> FAILURE, hex"4e487b71", 0x01
diff --git a/compiler/test/libsolidity/semanticTests/functionCall/value_test.sol b/compiler/test/libsolidity/semanticTests/functionCall/value_test.sol
new file mode 100644
index 00000000..a6fea6a5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionCall/value_test.sol
@@ -0,0 +1,8 @@
+contract C {
+	function f() public payable returns (uint) {
+		return msg.value;
+	}
+}
+// ----
+// f(), 1 ether -> 1000000000000000000
+// f(), 1 wei -> 1
diff --git a/compiler/test/libsolidity/semanticTests/functionSelector/function_selector_via_contract_name.sol b/compiler/test/libsolidity/semanticTests/functionSelector/function_selector_via_contract_name.sol
new file mode 100644
index 00000000..0a9e6d3f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionSelector/function_selector_via_contract_name.sol
@@ -0,0 +1,20 @@
+contract A {
+    function f() external {}
+    function g(uint256) external {}
+}
+contract B {
+    function f() external returns (uint256) {}
+    function g(uint256) external returns (uint256) {}
+}
+contract C {
+    function test1() external returns(bytes4, bytes4, bytes4, bytes4) {
+        return (A.f.selector, A.g.selector, B.f.selector, B.g.selector);
+    }
+    function test2() external returns(bytes4, bytes4, bytes4, bytes4) {
+        A a; B b;
+        return (a.f.selector, a.g.selector, b.f.selector, b.g.selector);
+    }
+}
+// ----
+// test1() -> left(0x26121ff0), left(0xe420264a), left(0x26121ff0), left(0xe420264a)
+// test2() -> left(0x26121ff0), left(0xe420264a), left(0x26121ff0), left(0xe420264a)
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/address_member.sol b/compiler/test/libsolidity/semanticTests/functionTypes/address_member.sol
new file mode 100644
index 00000000..a5f56f3d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/address_member.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public view returns (address a1, address a2) {
+        a1 = this.f.address;
+        this.f.address;
+        [this.f.address][0];
+        a2 = [this.f.address][0];
+    }
+}
+// ----
+// f() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e, 0xc06afe3a8444fc0004668591e8306bfb9968e79e
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_ir.sol b/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_ir.sol
new file mode 100644
index 00000000..a083ee1d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_ir.sol
@@ -0,0 +1,27 @@
+contract Other {
+    function addTwo(uint256 x) public returns (uint256) {
+        return x + 2;
+    }
+}
+contract C {
+    function (function (uint) external returns (uint)) internal returns (uint) ev;
+    function (uint) external returns (uint) x;
+
+    function store(function(uint) external returns (uint) y) public {
+         x = y;
+    }
+
+    function eval(function(uint) external returns (uint) y) public returns (uint) {
+        return y(7);
+    }
+
+    function t() public returns (uint256) {
+        this.store((new Other()).addTwo);
+        // This call panics
+        return ev(x);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// t() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_legacy.sol b/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_legacy.sol
new file mode 100644
index 00000000..feca44e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/call_to_zero_initialized_function_type_legacy.sol
@@ -0,0 +1,27 @@
+contract Other {
+    function addTwo(uint256 x) public returns (uint256) {
+        return x + 2;
+    }
+}
+contract C {
+    function (function (uint) external returns (uint)) internal returns (uint) ev;
+    function (uint) external returns (uint) x;
+
+    function store(function(uint) external returns (uint) y) public {
+         x = y;
+    }
+
+    function eval(function(uint) external returns (uint) y) public returns (uint) {
+        return y(7);
+    }
+
+    function t() public returns (uint256) {
+        this.store((new Other()).addTwo);
+        // This call panics
+        return ev(x);
+    }
+}
+// ====
+// compileViaYul: false
+// ----
+// t() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/duplicated_function_definition_with_same_id_in_internal_dispatcher.sol b/compiler/test/libsolidity/semanticTests/functionTypes/duplicated_function_definition_with_same_id_in_internal_dispatcher.sol
new file mode 100644
index 00000000..c15007c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/duplicated_function_definition_with_same_id_in_internal_dispatcher.sol
@@ -0,0 +1,9 @@
+contract C {
+    function a() internal {}
+    function f() public {
+        function() ptr1 = a;
+        function() ptr2 = a;
+    }
+}
+// ----
+// f()
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol b/compiler/test/libsolidity/semanticTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol
new file mode 100644
index 00000000..069d257f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol
@@ -0,0 +1,10 @@
+contract C {
+    function g(string calldata) external returns (bool) { return true; }
+
+    function main() external returns (bool) {
+        function (string memory) external returns (bool) ptr = this.g;
+        return ptr("testString");
+    }
+}
+// ----
+// main() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_stack.sol b/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_stack.sol
new file mode 100644
index 00000000..67a4434d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_stack.sol
@@ -0,0 +1,13 @@
+contract C {
+    function a() public returns (uint256) {
+        return 7;
+    }
+
+    function test() public returns (uint256) {
+        function() returns (uint256) y = a;
+        delete y;
+        y();
+    }
+}
+// ----
+// test() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_storage.sol b/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_storage.sol
new file mode 100644
index 00000000..a147b4e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/function_delete_storage.sol
@@ -0,0 +1,26 @@
+contract C {
+    function a() public returns (uint256) {
+        return 7;
+    }
+
+    function() returns (uint256) internal y;
+
+    function set() public returns (uint256) {
+        y = a;
+        return y();
+    }
+
+    function d() public returns (uint256) {
+        delete y;
+        return 1;
+    }
+
+    function ca() public returns (uint256) {
+        return y();
+    }
+}
+// ----
+// set() -> 7
+// ca() -> 7
+// d() -> 1
+// ca() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol b/compiler/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol
new file mode 100644
index 00000000..d5e105e5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/function_external_delete_storage.sol
@@ -0,0 +1,37 @@
+contract C {
+    function() external public x;
+    uint public y = 0;
+
+    function increment() public {
+        ++y;
+    }
+
+    function set() external {
+        x = this.increment;
+    }
+
+    function incrementIndirectly() public {
+        x();
+    }
+
+    function deleteFunction() public {
+        // used to lead to an ICE during IR
+        delete x;
+    }
+}
+// ----
+// x() -> 0
+// y() -> 0
+// increment() ->
+// y() -> 1
+// set() ->
+// x() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79ed09de08a0000000000000000
+// increment() ->
+// y() -> 2
+// incrementIndirectly() ->
+// y() -> 3
+// deleteFunction() ->
+// increment() ->
+// y() -> 4
+// incrementIndirectly() -> FAILURE
+// y() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/function_type_library_internal.sol b/compiler/test/libsolidity/semanticTests/functionTypes/function_type_library_internal.sol
new file mode 100644
index 00000000..587daac9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/function_type_library_internal.sol
@@ -0,0 +1,25 @@
+library Utils {
+    function reduce(
+        uint256[] memory array,
+        function(uint, uint) internal returns (uint) f,
+        uint256 init
+    ) internal returns (uint256) {
+        for (uint256 i = 0; i < array.length; i++) {
+            init = f(array[i], init);
+        }
+        return init;
+    }
+
+    function sum(uint256 a, uint256 b) internal returns (uint256) {
+        return a + b;
+    }
+}
+
+
+contract C {
+    function f(uint256[] memory x) public returns (uint256) {
+        return Utils.reduce(x, Utils.sum, 0);
+    }
+}
+// ----
+// f(uint256[]): 0x20, 0x3, 0x1, 0x7, 0x3 -> 11
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/mapping_of_functions.sol b/compiler/test/libsolidity/semanticTests/functionTypes/mapping_of_functions.sol
new file mode 100644
index 00000000..f9cd863b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/mapping_of_functions.sol
@@ -0,0 +1,33 @@
+contract Flow {
+    bool public success;
+
+    mapping(address => function() internal) stages;
+
+    function stage0() internal {
+        stages[msg.sender] = stage1;
+    }
+
+    function stage1() internal {
+        stages[msg.sender] = stage2;
+    }
+
+    function stage2() internal {
+        success = true;
+    }
+
+    constructor() {
+        stages[msg.sender] = stage0;
+    }
+
+    function f() public returns (uint256) {
+        stages[msg.sender]();
+        return 7;
+    }
+}
+// ----
+// success() -> false
+// f() -> 7
+// f() -> 7
+// success() -> false
+// f() -> 7
+// success() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_externally.sol b/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_externally.sol
new file mode 100644
index 00000000..3f14eb59
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_externally.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(uint256 x) public returns (uint256) {
+        return this.eval(this.g, x);
+    }
+
+    function f2(uint256 x) public returns (uint256) {
+        return eval(this.g, x);
+    }
+
+    function eval(function(uint) external returns (uint) x, uint a) public returns (uint) {
+        return x(a);
+    }
+
+    function g(uint256 x) public returns (uint256) {
+        return x + 1;
+    }
+}
+// ----
+// f(uint256): 7 -> 8
+// f2(uint256): 7 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_internally.sol b/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_internally.sol
new file mode 100644
index 00000000..0acbcc58
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/pass_function_types_internally.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint256 x) public returns (uint256) {
+        return eval(g, x);
+    }
+
+    function eval(function(uint) internal returns (uint) x, uint a) internal returns (uint) {
+        return x(a);
+    }
+
+    function g(uint256 x) public pure returns (uint256) {
+        return x + 1;
+    }
+}
+// ----
+// f(uint256): 7 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime.sol b/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime.sol
new file mode 100644
index 00000000..84f6fad1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime.sol
@@ -0,0 +1,18 @@
+contract C {
+    uint256 public initial;
+
+    constructor() {
+        initial = double(2);
+    }
+
+    function double(uint256 _arg) public returns (uint256 _ret) {
+        _ret = _arg * 2;
+    }
+
+    function runtime(uint256 _arg) public returns (uint256) {
+        return double(_arg);
+    }
+}
+// ----
+// runtime(uint256): 3 -> 6
+// initial() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime_equality_check.sol b/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime_equality_check.sol
new file mode 100644
index 00000000..b5b24954
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/same_function_in_construction_and_runtime_equality_check.sol
@@ -0,0 +1,17 @@
+contract C {
+    function(uint256) returns (uint256) internal x;
+
+    constructor() {
+        x = double;
+    }
+
+    function test() public returns (bool) {
+        return x == double;
+    }
+
+    function double(uint256 _arg) public returns (uint256 _ret) {
+        _ret = _arg * 2;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_1.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_1.sol
new file mode 100644
index 00000000..397655da
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_1.sol
@@ -0,0 +1,14 @@
+contract B {
+    function ext() external {}
+    function pub() public {}
+}
+
+contract C is B {
+    function test() public returns (bytes4, bytes4, bytes4, bytes4) {
+        return (B.ext.selector, B.pub.selector, this.ext.selector, pub.selector);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test() -> 0xcf9f23b500000000000000000000000000000000000000000000000000000000, 0x7defb41000000000000000000000000000000000000000000000000000000000, 0xcf9f23b500000000000000000000000000000000000000000000000000000000, 0x7defb41000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_2.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_2.sol
new file mode 100644
index 00000000..248e4467
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_2.sol
@@ -0,0 +1,14 @@
+contract B {
+    function ext() external {}
+    function pub() public {}
+}
+
+contract D {
+    function test() public returns (bytes4, bytes4) {
+        return (B.ext.selector, B.pub.selector);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// test() -> 0xcf9f23b500000000000000000000000000000000000000000000000000000000, 0x7defb41000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_assignment_expression.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_assignment_expression.sol
new file mode 100644
index 00000000..896dbeb9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_assignment_expression.sol
@@ -0,0 +1,10 @@
+contract C {
+    bool public z;
+    function f() public {
+        ((z = true) ? this.f : this.f).selector;
+    }
+}
+
+// ----
+// f()
+// z() -> true
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_expression_side_effect.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_expression_side_effect.sol
new file mode 100644
index 00000000..cdb7b98d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_expression_side_effect.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint x;
+	function f() public returns (uint256) {
+		h().f.selector;
+		return x;
+	}
+	function h() public returns (C) {
+		x = 42;
+		return this;
+	}
+}
+// ----
+// f() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary.sol
new file mode 100644
index 00000000..567b7c14
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f() public {}
+	function g() public {}
+	function h(bool c) public returns (bytes4) {
+		return (c ? this.f : this.g).selector;
+	}
+}
+// ----
+// h(bool): true -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// h(bool): false -> 0xe2179b8e00000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary_function_pointer_from_function_call.sol b/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary_function_pointer_from_function_call.sol
new file mode 100644
index 00000000..83415f72
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/selector_ternary_function_pointer_from_function_call.sol
@@ -0,0 +1,19 @@
+contract A {
+    function f() public {}
+	function g() public {}
+}
+
+contract C {
+    A a = new A();
+
+    function getContract() public view returns (A) {
+        return a;
+    }
+
+    function test(bool b) public view returns (bytes4) {
+        return (b ? getContract().f : getContract().g).selector;
+    }
+}
+// ----
+// test(bool): true -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// test(bool): false -> 0xe2179b8e00000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/store_function.sol b/compiler/test/libsolidity/semanticTests/functionTypes/store_function.sol
new file mode 100644
index 00000000..132a6c95
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/store_function.sol
@@ -0,0 +1,30 @@
+contract Other {
+    function addTwo(uint256 x) public returns (uint256) {
+        return x + 2;
+    }
+}
+
+
+contract C {
+    function (function (uint) external returns (uint)) internal returns (uint) ev;
+    function (uint) external returns (uint) x;
+
+    function store(function(uint) external returns (uint) y) public {
+        x = y;
+    }
+
+    function eval(function(uint) external returns (uint) y) public returns (uint) {
+        return y(7);
+    }
+
+    function t() public returns (uint256) {
+        ev = eval;
+        this.store((new Other()).addTwo);
+        return ev(x);
+    }
+}
+// ----
+// t() -> 9
+// gas irOptimized: 99064
+// gas legacy: 149095
+// gas legacyOptimized: 106188
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_external_function.sol b/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_external_function.sol
new file mode 100644
index 00000000..3de9cfa8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_external_function.sol
@@ -0,0 +1,31 @@
+struct S {
+    uint16 a;
+    function() external returns (uint) x;
+    uint16 b;
+}
+contract Flow {
+    S[2] t;
+
+    function X() public pure returns (uint) {
+        return 1;
+    }
+
+    function Y() public pure returns (uint) {
+        return 2;
+    }
+
+    constructor() {
+        t[0].a = 0xff07;
+        t[0].b = 0xff07;
+        t[1].x = this.Y;
+        t[1].a = 0xff07;
+        t[1].b = 0xff07;
+        t[0].x = this.X;
+    }
+
+    function f() public returns (uint, uint) {
+        return (t[0].x(), t[1].x());
+    }
+}
+// ----
+// f() -> 1, 2
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_functions.sol b/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_functions.sol
new file mode 100644
index 00000000..fae91862
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/struct_with_functions.sol
@@ -0,0 +1,31 @@
+struct S {
+    uint16 a;
+    function() returns (uint) x;
+    uint16 b;
+}
+contract Flow {
+    S[2] t;
+
+    function X() internal pure returns (uint) {
+        return 1;
+    }
+
+    function Y() internal pure returns (uint) {
+        return 2;
+    }
+
+    constructor() {
+        t[0].a = 0xff07;
+        t[0].b = 0xff07;
+        t[1].x = Y;
+        t[1].a = 0xff07;
+        t[1].b = 0xff07;
+        t[0].x = X;
+    }
+
+    function f() public returns (uint, uint) {
+        return (t[0].x(), t[1].x());
+    }
+}
+// ----
+// f() -> 1, 2
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_internal_function.sol b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_internal_function.sol
new file mode 100644
index 00000000..f7dc8904
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_internal_function.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() internal pure returns(uint256) { return 1;}
+    function g() internal pure returns(uint256) { return 2; }
+    function test(bool b) public returns(uint256) {
+        return (b ? C.f : C.g)();
+    }
+}
+// ----
+// test(bool): true -> 1
+// test(bool): false -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_library_internal_function.sol b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_library_internal_function.sol
new file mode 100644
index 00000000..a29a678d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_library_internal_function.sol
@@ -0,0 +1,13 @@
+library L {
+    function f() internal pure returns(uint256){ return 1; }
+}
+
+contract C {
+    function g() internal pure returns(uint256) { return 2; }
+    function test(bool b) public returns(uint256) {
+        return (b ? L.f : C.g)();
+    }
+}
+// ----
+// test(bool): true -> 1
+// test(bool): false -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_public_function.sol b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_public_function.sol
new file mode 100644
index 00000000..6d52017a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/ternary_contract_public_function.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public pure returns(uint256) { return 1; }
+    function g() public pure returns(uint256) { return 2; }
+    function test(bool b) public returns(uint256) {
+        return (b ? C.f : C.g)();
+    }
+}
+// ----
+// test(bool): true -> 1
+// test(bool): false -> 2
diff --git a/compiler/test/libsolidity/semanticTests/functionTypes/uninitialized_internal_storage_function_call.sol b/compiler/test/libsolidity/semanticTests/functionTypes/uninitialized_internal_storage_function_call.sol
new file mode 100644
index 00000000..b55de087
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/functionTypes/uninitialized_internal_storage_function_call.sol
@@ -0,0 +1,10 @@
+contract Test {
+    function() internal x;
+
+    function f() public returns (uint256 r) {
+        x();
+        return 2;
+    }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/getters/bytes.sol b/compiler/test/libsolidity/semanticTests/getters/bytes.sol
new file mode 100644
index 00000000..c22403c7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/getters/bytes.sol
@@ -0,0 +1,8 @@
+contract C {
+    bytes public b;
+    constructor() {
+        b = "abc";
+    }
+}
+// ----
+// b() -> 0x20, 0x03, 0x6162630000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/getters/mapping_with_names.sol b/compiler/test/libsolidity/semanticTests/getters/mapping_with_names.sol
new file mode 100644
index 00000000..290a8880
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/getters/mapping_with_names.sol
@@ -0,0 +1,9 @@
+contract C {
+    mapping(uint a => mapping(uint b => uint c)) public x;
+    constructor() {
+        x[1][2] = 3;
+    }
+}
+// ----
+// x(uint256,uint256): 1, 2 -> 3
+// x(uint256,uint256): 0, 0 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/getters/string_and_bytes.sol b/compiler/test/libsolidity/semanticTests/getters/string_and_bytes.sol
new file mode 100644
index 00000000..f9cf7316
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/getters/string_and_bytes.sol
@@ -0,0 +1,16 @@
+contract C {
+    string public a;
+    string public b;
+    bytes public c;
+    string public d = "abcd";
+    constructor() {
+        a = "hello world";
+        b = hex"41424344";
+        c = hex"ff077fff";
+    }
+}
+// ----
+// a() -> 0x20, 11, "hello world"
+// b() -> 0x20, 4, "ABCD"
+// c() -> 0x20, 4, -439061522557375173052089223601630338202760422010735733633791622124826263552
+// d() -> 0x20, 4, "abcd"
diff --git a/compiler/test/libsolidity/semanticTests/getters/value_types.sol b/compiler/test/libsolidity/semanticTests/getters/value_types.sol
new file mode 100644
index 00000000..a8a8759e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/getters/value_types.sol
@@ -0,0 +1,32 @@
+contract C {
+    uint8 public a;
+    uint16 public b;
+    uint128 public c;
+    uint public d;
+    bytes1 public e;
+    bytes20 public f;
+    bytes32 public g;
+    bool public h;
+    address public i;
+    constructor() {
+        a = 3;
+        b = 4;
+        c = 5;
+        d = 6;
+        e = bytes1(uint8(0x7f));
+        f = bytes20(uint160(0x6465616462656566313564656164000000000010));
+        g = bytes32(uint256(0x6465616462656566313564656164000000000000000000000000000000000010));
+        h = true;
+        i = address(type(uint160).max / 3);
+    }
+}
+// ----
+// a() -> 3
+// b() -> 4
+// c() -> 5
+// d() -> 6
+// e() -> 0x7f00000000000000000000000000000000000000000000000000000000000000
+// f() -> 0x6465616462656566313564656164000000000010000000000000000000000000
+// g() -> 0x6465616462656566313564656164000000000000000000000000000000000010
+// h() -> true
+// i() -> 0x5555555555555555555555555555555555555555
diff --git a/compiler/test/libsolidity/semanticTests/immutable/delete.sol b/compiler/test/libsolidity/semanticTests/immutable/delete.sol
new file mode 100644
index 00000000..76e219a7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/delete.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint8 immutable public a;
+    uint8 immutable public b = 0x42;
+    uint public c;
+
+    constructor() {
+        delete a;
+        delete b;
+        c = b * 2 + a;
+    }
+}
+// ----
+// a() -> 0
+// b() -> 0
+// c() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/immutable/increment_decrement.sol b/compiler/test/libsolidity/semanticTests/immutable/increment_decrement.sol
new file mode 100644
index 00000000..14304513
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/increment_decrement.sol
@@ -0,0 +1,18 @@
+contract C {
+    int immutable x = 1;
+    int immutable y = 3;
+
+    constructor() {
+        x--;
+        --x;
+        y++;
+        ++y;
+        --y;
+    }
+
+    function f() public view returns (int, int) {
+        return (x, y);
+    }
+}
+// ----
+// f() -> -1, 4
diff --git a/compiler/test/libsolidity/semanticTests/immutable/multi_creation.sol b/compiler/test/libsolidity/semanticTests/immutable/multi_creation.sol
new file mode 100644
index 00000000..145c32ad
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/multi_creation.sol
@@ -0,0 +1,34 @@
+contract A {
+	uint immutable a;
+	constructor() {
+		a = 7;
+	}
+	function f() public view returns (uint) { return a; }
+}
+contract B {
+	uint immutable a;
+	constructor() {
+		a = 5;
+	}
+	function f() public view returns (uint) { return a; }
+}
+contract C {
+	uint immutable a;
+	uint public x;
+	uint public y;
+	constructor() {
+		a = 3;
+		x = (new A()).f();
+		y = (new B()).f();
+	}
+	function f() public returns (uint256, uint, uint) {
+		return (a, (new A()).f(), (new B()).f());
+	}
+}
+// ----
+// f() -> 3, 7, 5
+// gas irOptimized: 124021
+// gas legacy: 148528
+// gas legacyOptimized: 123971
+// x() -> 7
+// y() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/immutable/multiple_initializations.sol b/compiler/test/libsolidity/semanticTests/immutable/multiple_initializations.sol
new file mode 100644
index 00000000..b72f05b1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/multiple_initializations.sol
@@ -0,0 +1,27 @@
+contract A {
+    uint immutable x = x + 1;
+    uint immutable y = x += 2;
+
+    constructor(uint) m(x += 16) m(x += 32) {
+        x += 64;
+        x += 128;
+    }
+
+    modifier m(uint) {
+        _;
+    }
+
+    function get() public returns (uint) {
+        return x;
+    }
+}
+
+contract B is A(A.x += 8) {
+    constructor(uint) {}
+}
+
+contract C is B {
+    constructor() B(x += 4) {}
+}
+// ----
+// get() -> 0xff
diff --git a/compiler/test/libsolidity/semanticTests/immutable/uninitialized.sol b/compiler/test/libsolidity/semanticTests/immutable/uninitialized.sol
new file mode 100644
index 00000000..f6d59ce7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/uninitialized.sol
@@ -0,0 +1,11 @@
+contract C {
+    uint immutable u;
+    bool immutable b;
+    address immutable a;
+
+    function get() public returns (uint, bool, address) {
+        return (u, b, a);
+    }
+}
+// ----
+// get() -> 0, false, 0x0
diff --git a/compiler/test/libsolidity/semanticTests/immutable/use_scratch.sol b/compiler/test/libsolidity/semanticTests/immutable/use_scratch.sol
new file mode 100644
index 00000000..0a5ccf72
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/immutable/use_scratch.sol
@@ -0,0 +1,22 @@
+contract C {
+	uint256 immutable x;
+	uint256 immutable y;
+	mapping(uint => uint) public m;
+	constructor(uint _a) {
+		x = 42;
+		y = 23;
+		m[_a] = 7;
+		new uint[](4);
+
+	}
+	function f() public view returns (uint256, uint256) {
+		return (x+x,y);
+	}
+}
+// ----
+// constructor(): 3 ->
+// gas irOptimized: 123542
+// gas legacy: 197645
+// gas legacyOptimized: 137678
+// f() -> 84, 23
+// m(uint256): 3 -> 7
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/access_base_storage.sol b/compiler/test/libsolidity/semanticTests/inheritance/access_base_storage.sol
new file mode 100644
index 00000000..034e7c1d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/access_base_storage.sol
@@ -0,0 +1,27 @@
+contract Base {
+    uint256 dataBase;
+
+    function getViaBase() public returns (uint256 i) {
+        return dataBase;
+    }
+}
+
+
+contract Derived is Base {
+    uint256 dataDerived;
+
+    function setData(uint256 base, uint256 derived) public returns (bool r) {
+        dataBase = base;
+        dataDerived = derived;
+        return true;
+    }
+
+    function getViaDerived() public returns (uint256 base, uint256 derived) {
+        base = dataBase;
+        derived = dataDerived;
+    }
+}
+// ----
+// setData(uint256,uint256): 1, 2 -> true
+// getViaBase() -> 1
+// getViaDerived() -> 1, 2
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol b/compiler/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol
new file mode 100644
index 00000000..c65d1abe
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol
@@ -0,0 +1,27 @@
+contract C {
+    function balance() public returns (uint256) {
+        return 1;
+    }
+
+    function transfer(uint256 amount) public returns (uint256) {
+        return amount;
+    }
+}
+
+
+contract D {
+    function f() public returns (uint256) {
+        return (new C()).balance();
+    }
+
+    function g() public returns (uint256) {
+        return (new C()).transfer(5);
+    }
+}
+// ----
+// f() -> 1
+// gas irOptimized: 77051
+// gas legacy: 112280
+// g() -> 5
+// gas irOptimized: 77106
+// gas legacy: 112816
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/base_access_to_function_type_variables.sol b/compiler/test/libsolidity/semanticTests/inheritance/base_access_to_function_type_variables.sol
new file mode 100644
index 00000000..9cff3c72
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/base_access_to_function_type_variables.sol
@@ -0,0 +1,20 @@
+contract C {
+    function() returns (uint256) internal x;
+
+    function set() public {
+        C.x = g;
+    }
+
+    function g() public pure returns (uint256) {
+        return 2;
+    }
+
+    function h() public returns (uint256) {
+        return C.x();
+    }
+}
+// ----
+// g() -> 2
+// h() -> FAILURE, hex"4e487b71", 0x51
+// set() ->
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_direct.sol b/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_direct.sol
new file mode 100644
index 00000000..02e20c49
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_direct.sol
@@ -0,0 +1,18 @@
+contract B {
+    function f() public returns (uint256) {
+        return 10;
+    }
+}
+
+
+contract C is B {
+    function f(uint256 i) public returns (uint256) {
+        return 2 * i;
+    }
+
+    function g() public returns (uint256) {
+        return f(1);
+    }
+}
+// ----
+// g() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_indirect.sol b/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_indirect.sol
new file mode 100644
index 00000000..5976fee6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/derived_overload_base_function_indirect.sol
@@ -0,0 +1,26 @@
+contract A {
+    function f(uint256 a) public returns (uint256) {
+        return 2 * a;
+    }
+}
+
+
+contract B {
+    function f() public returns (uint256) {
+        return 10;
+    }
+}
+
+
+contract C is A, B {
+    function g() public returns (uint256) {
+        return f();
+    }
+
+    function h() public returns (uint256) {
+        return f(1);
+    }
+}
+// ----
+// g() -> 10
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/explicit_base_class.sol b/compiler/test/libsolidity/semanticTests/inheritance/explicit_base_class.sol
new file mode 100644
index 00000000..78f1f186
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/explicit_base_class.sol
@@ -0,0 +1,26 @@
+contract BaseBase {
+    function g() public virtual returns (uint256 r) {
+        return 1;
+    }
+}
+
+
+contract Base is BaseBase {
+    function g() public virtual override returns (uint256 r) {
+        return 2;
+    }
+}
+
+
+contract Derived is Base {
+    function f() public returns (uint256 r) {
+        return BaseBase.g();
+    }
+
+    function g() public override returns (uint256 r) {
+        return 3;
+    }
+}
+// ----
+// g() -> 3
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_constant_state_var.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_constant_state_var.sol
new file mode 100644
index 00000000..70674a6c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_constant_state_var.sol
@@ -0,0 +1,12 @@
+contract A {
+    uint256 constant x = 7;
+}
+
+
+contract B is A {
+    function f() public returns (uint256) {
+        return A.x;
+    }
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_function.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function.sol
new file mode 100644
index 00000000..fb3f8ee8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function.sol
@@ -0,0 +1,18 @@
+contract A {
+    function f() internal virtual returns (uint256) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() internal override returns (uint256) {
+        return 2;
+    }
+
+    function g() public returns (uint256) {
+        return A.f();
+    }
+}
+// ----
+// g() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol
new file mode 100644
index 00000000..3114c80f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol
@@ -0,0 +1,26 @@
+interface I {
+    function f(uint256[] calldata a) external returns (uint256);
+}
+
+
+contract A is I {
+    function f(uint256[] calldata a) external override returns (uint256) {
+        return 42;
+    }
+}
+
+
+contract B {
+    function f(uint256[] memory a) public returns (uint256) {
+        return a[1];
+    }
+
+    function g() public returns (uint256) {
+        I i = I(new A());
+        return i.f(new uint256[](2));
+    }
+}
+// ----
+// g() -> 42
+// gas irOptimized: 80813
+// gas legacy: 122471
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol
new file mode 100644
index 00000000..74bf42ec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol
@@ -0,0 +1,27 @@
+interface I {
+    function f(uint256[] calldata a) external returns (uint256);
+}
+
+
+contract A is I {
+    function f(uint256[] memory a) public override returns (uint256) {
+        return 42;
+    }
+}
+
+
+contract B {
+    function f(uint256[] memory a) public returns (uint256) {
+        return a[1];
+    }
+
+    function g() public returns (uint256) {
+        I i = I(new A());
+        return i.f(new uint256[](2));
+    }
+}
+// ----
+// g() -> 42
+// gas irOptimized: 100282
+// gas legacy: 180440
+// gas legacyOptimized: 112596
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_from_a_library.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_from_a_library.sol
new file mode 100644
index 00000000..1b1092cb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_from_a_library.sol
@@ -0,0 +1,18 @@
+library A {
+    function f() internal returns (uint256) {
+        return 1;
+    }
+}
+
+
+contract B {
+    function f() internal returns (uint256) {
+        return 2;
+    }
+
+    function g() public returns (uint256) {
+        return A.f();
+    }
+}
+// ----
+// g() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_through_dispatch.sol b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_through_dispatch.sol
new file mode 100644
index 00000000..39683079
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/inherited_function_through_dispatch.sol
@@ -0,0 +1,19 @@
+contract A {
+    function f() internal virtual returns (uint256) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() internal override returns (uint256) {
+        return 2;
+    }
+
+    function g() public returns (uint256) {
+        function() internal returns (uint256) ptr = A.f;
+        return ptr();
+    }
+}
+// ----
+// g() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol b/compiler/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol
new file mode 100644
index 00000000..33392e8d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/member_notation_ctor.sol
@@ -0,0 +1,24 @@
+==== Source: A ====
+contract C {
+	int private x;
+	constructor (int p) public { x = p; }
+	function getX() public returns (int) { return x; }
+}
+==== Source: B ====
+import "A" as M;
+
+contract D is M.C {
+	constructor (int p) M.C(p) public {}
+}
+
+contract A {
+	function g(int p) public returns (int) {
+		D d = new D(p);
+		return d.getX();
+	}
+}
+// ----
+// g(int256): -1 -> -1
+// gas legacy: 102086
+// g(int256): 10 -> 10
+// gas legacy: 101714
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_first.sol b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_first.sol
new file mode 100644
index 00000000..d31dba48
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_first.sol
@@ -0,0 +1,15 @@
+contract test {
+    function f(uint256 k) public returns (uint256 d) {
+        return k;
+    }
+
+    function f(uint256 a, uint256 b) public returns (uint256 d) {
+        return a + b;
+    }
+
+    function g() public returns (uint256 d) {
+        return f(3);
+    }
+}
+// ----
+// g() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_second.sol b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_second.sol
new file mode 100644
index 00000000..c1f816c1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_resolve_to_second.sol
@@ -0,0 +1,15 @@
+contract test {
+    function f(uint256 a, uint256 b) public returns (uint256 d) {
+        return a + b;
+    }
+
+    function f(uint256 k) public returns (uint256 d) {
+        return k;
+    }
+
+    function g() public returns (uint256 d) {
+        return f(3, 7);
+    }
+}
+// ----
+// g() -> 10
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_with_if_else.sol b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_with_if_else.sol
new file mode 100644
index 00000000..c0ff8fd5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/overloaded_function_call_with_if_else.sol
@@ -0,0 +1,17 @@
+contract test {
+    function f(uint256 a, uint256 b) public returns (uint256 d) {
+        return a + b;
+    }
+
+    function f(uint256 k) public returns (uint256 d) {
+        return k;
+    }
+
+    function g(bool flag) public returns (uint256 d) {
+        if (flag) return f(3);
+        else return f(3, 7);
+    }
+}
+// ----
+// g(bool): true -> 3
+// g(bool): false -> 10
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor.sol b/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor.sol
new file mode 100644
index 00000000..7e0aa51d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor.sol
@@ -0,0 +1,34 @@
+contract A {
+    function f() public virtual returns (uint256 r) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() public virtual override returns (uint256 r) {
+        return super.f() | 2;
+    }
+}
+
+
+contract C is A {
+    function f() public virtual override returns (uint256 r) {
+        return super.f() | 4;
+    }
+}
+
+
+contract D is B, C {
+    uint256 data;
+
+    constructor() {
+        data = super.f() | 8;
+    }
+
+    function f() public override (B, C) returns (uint256 r) {
+        return data;
+    }
+}
+// ----
+// f() -> 15
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor_assignment.sol b/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor_assignment.sol
new file mode 100644
index 00000000..6b06a784
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/super_in_constructor_assignment.sol
@@ -0,0 +1,37 @@
+contract A {
+    function f() public virtual returns (uint256 r) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() public virtual override returns (uint256 r) {
+        function() internal returns (uint) x = super.f;
+        return x() | 2;
+    }
+}
+
+
+contract C is A {
+    function f() public virtual override returns (uint256 r) {
+        function() internal returns (uint) x = super.f;
+        return x() | 4;
+    }
+}
+
+
+contract D is B, C {
+    uint256 data;
+
+    constructor() {
+        function() internal returns (uint) x = super.f;
+        data = x() | 8;
+    }
+
+    function f() public override (B, C) returns (uint256 r) {
+        return data;
+    }
+}
+// ----
+// f() -> 15
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/super_overload.sol b/compiler/test/libsolidity/semanticTests/inheritance/super_overload.sol
new file mode 100644
index 00000000..7b0b1448
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/super_overload.sol
@@ -0,0 +1,26 @@
+contract A {
+    function f(uint256 a) public returns (uint256) {
+        return 2 * a;
+    }
+}
+
+
+contract B {
+    function f(bool b) public returns (uint256) {
+        return 10;
+    }
+}
+
+
+contract C is A, B {
+    function g() public returns (uint256) {
+        return super.f(true);
+    }
+
+    function h() public returns (uint256) {
+        return super.f(1);
+    }
+}
+// ----
+// g() -> 10
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol b/compiler/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol
new file mode 100644
index 00000000..d8fd8766
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol
@@ -0,0 +1,47 @@
+contract Helper {
+    bytes3 name;
+    bool flag;
+
+    constructor(bytes3 x, bool f) payable {
+        name = x;
+        flag = f;
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return name;
+    }
+
+    function getFlag() public returns (bool ret) {
+        return flag;
+    }
+}
+
+
+contract Main {
+    Helper h;
+
+    constructor() payable {
+        h = (new Helper){value: 10}("abc", true);
+    }
+
+    function getFlag() public returns (bool ret) {
+        return h.getFlag();
+    }
+
+    function getName() public returns (bytes3 ret) {
+        return h.getName();
+    }
+
+    function getBalances() public returns (uint256 me, uint256 them) {
+        me = address(this).balance;
+        them = address(h).balance;
+    }
+}
+// ----
+// constructor(), 22 wei ->
+// gas irOptimized: 261888
+// gas legacy: 392786
+// gas legacyOptimized: 261633
+// getFlag() -> true
+// getName() -> "abc"
+// getBalances() -> 12, 10
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/blobbasefee_shanghai_function.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobbasefee_shanghai_function.sol
new file mode 100644
index 00000000..d0645713
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobbasefee_shanghai_function.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            let blobbasefee := 999
+            ret := blobbasefee
+        }
+    }
+    function g() public pure returns (uint ret) {
+        assembly {
+            function blobbasefee() -> r {
+                r := 1000
+            }
+            ret := blobbasefee()
+        }
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
+// f() -> 999
+// g() -> 1000
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash.sol
new file mode 100644
index 00000000..3beac1d2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (bytes32 ret) {
+        assembly {
+            ret := blobhash(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x0100000000000000000000000000000000000000000000000000000000000001
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_index_exceeding_blob_count.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_index_exceeding_blob_count.sol
new file mode 100644
index 00000000..7063978c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_index_exceeding_blob_count.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public view returns (bytes32 ret) {
+        assembly {
+            // EIP-4844 specifies that if `index < len(tx.blob_versioned_hashes)`, `blobhash(index)` should return 0.
+            // Thus, as we injected only two blob hashes in the transaction context in EVMHost,
+            // the return value of the function below MUST be zero.
+            ret := blobhash(2)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_pre_cancun.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_pre_cancun.sol
new file mode 100644
index 00000000..8972958e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/blobhash_pre_cancun.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public pure returns (uint ret) {
+        assembly {
+            let blobhash := 1
+            ret := blobhash
+        }
+    }
+    function g() public pure returns (uint ret) {
+        assembly {
+            function blobhash() -> r {
+                r := 1000
+            }
+            ret := blobhash()
+        }
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
+// f() -> 1
+// g() -> 1000
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_array_read.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_array_read.sol
new file mode 100644
index 00000000..572e9def
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_array_read.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(uint[2][] calldata x) public returns (uint o, uint l, uint s) {
+        assembly { l := x.length o := x.offset }
+        uint[2] calldata t = x[1];
+        // statically-sized arrays only use one slot, so we read directly.
+        assembly { s := t }
+    }
+}
+// ----
+// f(uint256[2][]): 0x20, 2, 1, 2, 3, 4 -> 0x44, 2, 0x84
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_length_read.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_length_read.sol
new file mode 100644
index 00000000..d3574806
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_length_read.sol
@@ -0,0 +1,16 @@
+contract C {
+    function lenBytesRead(bytes calldata x) public returns (uint l) {
+        assembly { l := x.length }
+    }
+
+    function lenStringRead(string calldata x) public returns (uint l) {
+        assembly { l := x.length }
+    }
+}
+// ----
+// lenBytesRead(bytes): 0x20, 4, "abcd" -> 4
+// lenBytesRead(bytes): 0x20, 0, "abcd" -> 0x00
+// lenBytesRead(bytes): 0x20, 0x21, "abcd", "ef" -> 33
+// lenStringRead(string): 0x20, 4, "abcd" -> 4
+// lenStringRead(string): 0x20, 0, "abcd" -> 0x00
+// lenStringRead(string): 0x20, 0x21, "abcd", "ef" -> 33
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read.sol
new file mode 100644
index 00000000..0b10748c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f(bytes calldata x) public returns (uint r) {
+        assembly { r := x.offset }
+    }
+
+    function f(uint, bytes calldata x, uint) public returns (uint r, uint v) {
+        assembly {
+            r := x.offset
+            v := x.length
+        }
+    }
+}
+// ----
+// f(bytes): 0x20, 0, 0 -> 0x44
+// f(bytes): 0x22, 0, 0, 0 -> 0x46
+// f(uint256,bytes,uint256): 7, 0x60, 8, 2, 0 -> 0x84, 2
+// f(uint256,bytes,uint256): 0, 0, 0 -> 0x24, 0x00
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read_write.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read_write.sol
new file mode 100644
index 00000000..bcba7169
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read_write.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint, bytes calldata x, uint) public returns (uint r, uint v) {
+        assembly {
+            x.offset := 8
+            x.length := 20
+        }
+        assembly {
+            r := x.offset
+            v := x.length
+        }
+    }
+}
+// ----
+// f(uint256,bytes,uint256): 7, 0x60, 8, 2, 0 -> 8, 0x14
+// f(uint256,bytes,uint256): 0, 0, 0 -> 8, 0x14
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access.sol
new file mode 100644
index 00000000..82badaca
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access.sol
@@ -0,0 +1,18 @@
+contract C {
+    uint constant a = 2;
+    bytes2 constant b = 0xabcd;
+    bytes3 constant c = "abc";
+    bool constant d = true;
+    address constant e = 0x1212121212121212121212121212121212121212;
+    function f() public pure returns (uint w, bytes2 x, bytes3 y, bool z, address t) {
+        assembly {
+            w := a
+            x := b
+            y := c
+            z := d
+            t := e
+        }
+    }
+}
+// ----
+// f() -> 2, left(0xabcd), left(0x616263), true, 0x1212121212121212121212121212121212121212
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access_referencing.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access_referencing.sol
new file mode 100644
index 00000000..d12a979c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/constant_access_referencing.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint constant a = 2;
+    uint constant aa = a;
+    uint constant aaa = aa;
+    bytes2 constant b = 0xabcd;
+    bytes2 constant bb = b;
+    bytes3 constant c = "abc";
+    bytes3 constant cc = c;
+    bytes3 constant ccc = cc;
+    bytes3 constant cccc = ccc;
+    bool constant d = true;
+    bool constant dd = d;
+    address constant e = 0x1212121212121212121212121212121212121212;
+    address constant ee = e;
+    function f() public pure returns (uint w, bytes2 x, bytes3 y, bool z, address t) {
+        assembly {
+            w := aaa
+            x := bb
+            y := cccc
+            z := dd
+            t := ee
+        }
+    }
+}
+// ----
+// f() -> 2, left(0xabcd), left(0x616263), true, 0x1212121212121212121212121212121212121212
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/difficulty.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/difficulty.sol
new file mode 100644
index 00000000..ef531f78
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/difficulty.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            ret := difficulty()
+        }
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// f() -> 200000000
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol
new file mode 100644
index 00000000..ae891df5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/external_function_pointer_address.sol
@@ -0,0 +1,17 @@
+contract C {
+	function testFunction() external {}
+
+	function testYul() public returns (address adr) {
+		function() external fp = this.testFunction;
+
+		assembly {
+			adr := fp.address
+		}
+	}
+	function testSol() public returns (address) {
+		return this.testFunction.address;
+	}
+}
+// ----
+// testYul() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
+// testSol() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_embedded_function_call.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_embedded_function_call.sol
new file mode 100644
index 00000000..c925823d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_embedded_function_call.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f() public {
+        assembly {
+            let d:= 0x10
+
+            function asmfun(a, b, c) -> x, y, z {
+                x := g(a)
+                function g(r) -> s {
+                    s := mul(r, r)
+                }
+                y := g(b)
+                z := 7
+            }
+            let a1, b1, c1 := asmfun(1, 2, 3)
+            mstore(0x00, a1)
+            mstore(0x20, b1)
+            mstore(0x40, c1)
+            mstore(0x60, d)
+            return (0, 0x80)
+        }
+    }
+}
+// ----
+// f() -> 0x1, 0x4, 0x7, 0x10
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for.sol
new file mode 100644
index 00000000..848e9016
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for.sol
@@ -0,0 +1,23 @@
+contract C {
+    function f(uint256 a) public returns (uint256 b) {
+        assembly {
+            function fac(n) -> nf {
+                nf := 1
+                for {
+                    let i := n
+                } gt(i, 0) {
+                    i := sub(i, 1)
+                } {
+                    nf := mul(nf, i)
+                }
+            }
+            b := fac(a)
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 1
+// f(uint256): 1 -> 1
+// f(uint256): 2 -> 2
+// f(uint256): 3 -> 6
+// f(uint256): 4 -> 24
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for2.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for2.sol
new file mode 100644
index 00000000..2d817951
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_for2.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint256 st;
+
+    function f(uint256 a) public returns (uint256 b, uint256 c, uint256 d) {
+        st = 0;
+        assembly {
+            function sideeffect(r) -> x {
+                sstore(0, add(sload(0), r))
+                x := 1
+            }
+            for {
+                let i := a
+            } eq(i, sideeffect(2)) {
+                d := add(d, 3)
+            } {
+                b := i
+                i := 0
+            }
+        }
+        c = st;
+    }
+}
+// ----
+// f(uint256): 0 -> 0, 2, 0
+// f(uint256): 1 -> 1, 4, 3
+// f(uint256): 2 -> 0, 2, 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call.sol
new file mode 100644
index 00000000..de198dff
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public {
+        assembly {
+            function asmfun(a, b, c) -> x, y, z {
+                x := a
+                y := b
+                z := 7
+            }
+            let a1, b1, c1 := asmfun(1, 2, 3)
+            mstore(0x00, a1)
+            mstore(0x20, b1)
+            mstore(0x40, c1)
+            return (0, 0x60)
+        }
+    }
+}
+// ----
+// f() -> 1, 2, 7
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call2.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call2.sol
new file mode 100644
index 00000000..d21084aa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call2.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public {
+        assembly {
+            let d := 0x10
+
+            function asmfun(a, b, c) -> x, y, z {
+                x := a
+                y := b
+                z := 7
+            }
+            let a1, b1, c1 := asmfun(1, 2, 3)
+            mstore(0x00, a1)
+            mstore(0x20, b1)
+            mstore(0x40, c1)
+            mstore(0x60, d)
+            return (0, 0x80)
+        }
+    }
+}
+// ----
+// f() -> 0x1, 0x2, 0x7, 0x10
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call_assignment.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call_assignment.sol
new file mode 100644
index 00000000..e2e07823
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_function_call_assignment.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f() public {
+        assembly {
+            let a1, b1, c1
+
+            function asmfun(a, b, c) -> x, y, z {
+                x := a
+                y := b
+                z := 7
+            }
+            a1, b1, c1 := asmfun(1, 2, 3)
+            mstore(0x00, a1)
+            mstore(0x20, b1)
+            mstore(0x40, c1)
+            return (0, 0x60)
+        }
+    }
+}
+// ----
+// f() -> 1, 2, 7
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_if.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_if.sol
new file mode 100644
index 00000000..ebe50f51
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_if.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(uint256 a) public returns (uint256 b) {
+        assembly {
+            if gt(a, 1) {
+                b := 2
+            }
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 0
+// f(uint256): 1 -> 0
+// f(uint256): 2 -> 2
+// f(uint256): 3 -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_in_modifiers.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_in_modifiers.sol
new file mode 100644
index 00000000..e050d2b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_in_modifiers.sol
@@ -0,0 +1,32 @@
+contract C {
+    modifier m {
+        uint256 a = 1;
+        assembly {
+            a := 2
+        }
+        if (a != 2) revert();
+        _;
+    }
+
+    function f() public m returns (bool) {
+        return true;
+    }
+
+    modifier n {
+        uint256 a = 1;
+        assembly {
+            a := 2
+        }
+        if (a != 2)
+            _;
+        revert();
+    }
+
+    function g() public n returns (bool) {
+        // This statement should never execute.
+        return true;
+    }
+}
+// ----
+// f() -> true
+// g() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_memory_access.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_memory_access.sol
new file mode 100644
index 00000000..1f6a50d6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_memory_access.sol
@@ -0,0 +1,12 @@
+contract C {
+    function test() public returns (bytes memory) {
+        bytes memory x = new bytes(5);
+        for (uint256 i = 0; i < x.length; ++i) x[i] = bytes1(uint8(i + 1));
+        assembly {
+            mstore(add(x, 32), "12345678901234567890123456789012")
+        }
+        return x;
+    }
+}
+// ----
+// test() -> 0x20, 0x5, "12345"
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_read_and_write_stack.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_read_and_write_stack.sol
new file mode 100644
index 00000000..ae4b94ed
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_read_and_write_stack.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public returns (uint256 r) {
+        for (uint256 x = 0; x < 10; ++x)
+            assembly {
+                r := add(r, x)
+            }
+    }
+}
+// ----
+// f() -> 45
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_recursion.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_recursion.sol
new file mode 100644
index 00000000..a5095131
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_recursion.sol
@@ -0,0 +1,25 @@
+contract C {
+    function f(uint256 a) public returns (uint256 b) {
+        assembly {
+            function fac(n) -> nf {
+                switch n
+                    case 0 {
+                        nf := 1
+                    }
+                    case 1 {
+                        nf := 1
+                    }
+                    default {
+                        nf := mul(n, fac(sub(n, 1)))
+                    }
+            }
+            b := fac(a)
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 1
+// f(uint256): 1 -> 1
+// f(uint256): 2 -> 2
+// f(uint256): 3 -> 6
+// f(uint256): 4 -> 24
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access.sol
new file mode 100644
index 00000000..254bc747
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access.sol
@@ -0,0 +1,21 @@
+contract C {
+    uint16 x;
+    uint16 public y;
+    uint256 public z;
+
+    function f() public returns (bool) {
+        uint256 off1;
+        uint256 off2;
+        assembly {
+            sstore(z.slot, 7)
+            off1 := z.offset
+            off2 := y.offset
+        }
+        assert(off1 == 0);
+        assert(off2 == 2);
+        return true;
+    }
+}
+// ----
+// f() -> true
+// z() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_inside_function.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_inside_function.sol
new file mode 100644
index 00000000..80cd7e11
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_inside_function.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint16 x;
+    uint16 public y;
+    uint256 public z;
+
+    function f() public returns (bool) {
+        uint256 off1;
+        uint256 off2;
+        assembly {
+            function f() -> o1 {
+                sstore(z.slot, 7)
+                o1 := y.offset
+            }
+            off2 := f()
+        }
+        assert(off2 == 2);
+        return true;
+    }
+}
+// ----
+// f() -> true
+// z() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_local_var.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_local_var.sol
new file mode 100644
index 00000000..c7728068
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_local_var.sol
@@ -0,0 +1,16 @@
+contract C {
+    uint256[] public a;
+
+    function f() public returns (uint256) {
+        uint256[] storage x = a;
+        uint256 off;
+        assembly {
+            sstore(x.slot, 7)
+            off := x.offset
+        }
+        assert(off == 0);
+        return a.length;
+    }
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_via_pointer.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_via_pointer.sol
new file mode 100644
index 00000000..6c382ef9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_storage_access_via_pointer.sol
@@ -0,0 +1,24 @@
+contract C {
+    struct Data {
+        uint256 contents;
+    }
+    uint256 public separator;
+    Data public a;
+    uint256 public separator2;
+
+    function f() public returns (bool) {
+        Data storage x = a;
+        uint256 off;
+        assembly {
+            sstore(x.slot, 7)
+            off := x.offset
+        }
+        assert(off == 0);
+        return true;
+    }
+}
+// ----
+// f() -> true
+// a() -> 7
+// separator() -> 0
+// separator2() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_switch.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_switch.sol
new file mode 100644
index 00000000..615d6959
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_switch.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f(uint256 a) public returns (uint256 b) {
+        assembly {
+            switch a
+                case 1 {
+                    b := 8
+                }
+                case 2 {
+                    b := 9
+                }
+                default {
+                    b := 2
+                }
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 2
+// f(uint256): 1 -> 8
+// f(uint256): 2 -> 9
+// f(uint256): 3 -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_write_to_stack.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_write_to_stack.sol
new file mode 100644
index 00000000..ed20bfe2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inline_assembly_write_to_stack.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public returns (uint256 r, bytes32 r2) {
+        assembly {
+            r := 7
+            r2 := "abcdef"
+        }
+    }
+}
+// ----
+// f() -> 7, "abcdef"
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/inlineasm_empty_let.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/inlineasm_empty_let.sol
new file mode 100644
index 00000000..17e14e8a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/inlineasm_empty_let.sol
@@ -0,0 +1,12 @@
+contract C {
+	function f() public pure returns (uint a, uint b) {
+		assembly {
+			let x
+			let y, z
+			a := x
+			b := z
+		}
+	}
+}
+// ----
+// f() -> 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/keccak256_assembly.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/keccak256_assembly.sol
new file mode 100644
index 00000000..253af989
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/keccak256_assembly.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (bytes32 ret) {
+        assembly {
+            ret := keccak256(0, 0)
+        }
+    }
+}
+// ----
+// f() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/leave.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/leave.sol
new file mode 100644
index 00000000..40add273
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/leave.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public pure returns (uint w) {
+        assembly {
+            function f() -> t {
+                t := 2
+                leave
+                t := 9
+            }
+            w := f()
+        }
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy.sol
new file mode 100644
index 00000000..e98409f3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(bytes memory src) public pure returns (bytes memory dst) {
+        assembly {
+            mcopy(add(dst, 0x1f), add(src, 0x1f), 0x01) // Copy over src length byte to dst
+            mcopy(add(dst, 0x20), add(src, 0x00), 0x08) // Copy 8 zero bytes to dst
+            mcopy(add(dst, 0x28), add(src, 0x28), 0x10) // Copy 16 bytes from the middle of src to dst
+            mcopy(add(dst, 0x38), add(src, 0x00), 0x08) // Copy 8 zero bytes to dst
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f(bytes): 0x20, 0x20, 0xffeeddccbbaa9988776655443322110000112233445566778899aabbccddeeff -> 0x20, 0x20, 0x0000000000000000776655443322110000112233445566770000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_as_identifier_pre_cancun.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_as_identifier_pre_cancun.sol
new file mode 100644
index 00000000..4f50d1dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_as_identifier_pre_cancun.sol
@@ -0,0 +1,22 @@
+contract C {
+    function f() public pure returns (uint result) {
+        assembly {
+            let mcopy := 1
+            result := mcopy
+        }
+    }
+
+    function g() public pure returns (uint result) {
+        assembly {
+            function mcopy() -> r {
+                r := 1000
+            }
+            result := mcopy()
+        }
+    }
+}
+// ====
+// EVMVersion: <cancun
+// ----
+// f() -> 1
+// g() -> 1000
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_empty.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_empty.sol
new file mode 100644
index 00000000..e34e443b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_empty.sol
@@ -0,0 +1,18 @@
+contract C {
+    function mcopy_zero(bytes memory pattern) public pure returns (bytes memory out) {
+        out = pattern;
+
+        // This should have no effect on output
+        assembly {
+            mcopy(add(out, 0x20), add(out, 0x30), 0)
+            mcopy(add(out, 0x30), add(out, 0x30), 0)
+            mcopy(add(out, 0x40), add(out, 0x30), 0)
+
+            mcopy(add(out, 0x21), 0, 0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// mcopy_zero(bytes): 0x20, 0x20, 0xffeeddccbbaa9988776655443322110000112233445566778899aabbccddeeff -> 0x20, 0x20, 0xffeeddccbbaa9988776655443322110000112233445566778899aabbccddeeff
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_overlap.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_overlap.sol
new file mode 100644
index 00000000..95f517da
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/mcopy_overlap.sol
@@ -0,0 +1,39 @@
+function copy(uint dstOffset, uint srcOffset, uint length) pure returns (bytes memory out) {
+    out =
+        hex"2222222222222222333333333333333344444444444444445555555555555555"
+        hex"6666666666666666777777777777777788888888888888889999999999999999"
+        hex"aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd";
+    assembly {
+        mcopy(add(add(out, 0x20), dstOffset), add(add(out, 0x20), srcOffset), length)
+    }
+}
+
+contract C {
+    function mcopy_to_right_overlap() public pure returns (bytes memory) {
+        return copy(0x20, 0x10, 0x30);
+    }
+
+    function mcopy_to_left_overlap() public pure returns (bytes memory) {
+        return copy(0x10, 0x20, 0x30);
+    }
+
+    function mcopy_in_place() public pure returns (bytes memory) {
+        return copy(0x10, 0x10, 0x40);
+    }
+
+    function mcopy_to_right_no_overlap() public pure returns (bytes memory) {
+        return copy(0x30, 0x10, 0x20);
+    }
+
+    function mcopy_to_left_no_overlap() public pure returns (bytes memory) {
+        return copy(0x10, 0x30, 0x20);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// mcopy_to_right_overlap()    -> 0x20, 0x60, 0x2222222222222222333333333333333344444444444444445555555555555555, 0x4444444444444444555555555555555566666666666666667777777777777777, 0x88888888888888889999999999999999ccccccccccccccccdddddddddddddddd
+// mcopy_to_left_overlap()     -> 0x20, 0x60, 0x2222222222222222333333333333333366666666666666667777777777777777, 0x88888888888888889999999999999999aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb, 0xaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd
+// mcopy_in_place()            -> 0x20, 0x60, 0x2222222222222222333333333333333344444444444444445555555555555555, 0x6666666666666666777777777777777788888888888888889999999999999999, 0xaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd
+// mcopy_to_right_no_overlap() -> 0x20, 0x60, 0x2222222222222222333333333333333344444444444444445555555555555555, 0x6666666666666666777777777777777744444444444444445555555555555555, 0x66666666666666667777777777777777ccccccccccccccccdddddddddddddddd
+// mcopy_to_left_no_overlap()  -> 0x20, 0x60, 0x2222222222222222333333333333333388888888888888889999999999999999, 0xaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb88888888888888889999999999999999, 0xaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/prevrandao.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/prevrandao.sol
new file mode 100644
index 00000000..8a71c8f4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/prevrandao.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            ret := prevrandao()
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// f() -> 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/shadowing_local_function_opcode.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/shadowing_local_function_opcode.sol
new file mode 100644
index 00000000..d7e585e3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/shadowing_local_function_opcode.sol
@@ -0,0 +1,11 @@
+contract C {
+    function add(uint, uint) public pure returns (uint) { return 7; }
+    function g() public pure returns (uint x, uint y) {
+        x = add(1, 2);
+        assembly {
+            y := add(1, 2)
+        }
+    }
+}
+// ----
+// g() -> 7, 3
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/slot_access_via_mapping_pointer.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/slot_access_via_mapping_pointer.sol
new file mode 100644
index 00000000..e080985e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/slot_access_via_mapping_pointer.sol
@@ -0,0 +1,31 @@
+contract C {
+    mapping(uint => uint) private m0;
+    mapping(uint => uint) private m1;
+    mapping(uint => uint) private m2;
+
+    function f(uint i) public returns (uint slot, uint offset) {
+        mapping(uint => uint) storage m0Ptr = m0;
+        mapping(uint => uint) storage m1Ptr = m1;
+        mapping(uint => uint) storage m2Ptr = m2;
+
+        assembly {
+            switch i
+            case 1 {
+                slot := m1Ptr.slot
+                offset := m1Ptr.offset
+            }
+            case 2 {
+                slot := m2Ptr.slot
+                offset := m2Ptr.offset
+            }
+            default {
+                slot := m0Ptr.slot
+                offset := m0Ptr.offset
+            }
+        }
+    }
+}
+// ----
+// f(uint256): 0 -> 0, 0
+// f(uint256): 1 -> 1, 0
+// f(uint256): 2 -> 2, 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/tload_tstore_not_reserved_before_cancun.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/tload_tstore_not_reserved_before_cancun.sol
new file mode 100644
index 00000000..930c531e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/tload_tstore_not_reserved_before_cancun.sol
@@ -0,0 +1,25 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            let tload := sload(0)
+            let tstore := add(tload, 1)
+            ret := tstore
+        }
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            function tstore() -> a {
+                a := 2
+            }
+            function tload() -> b {
+                b := 3
+            }
+            ret := add(tstore(), tload())
+        }
+    }
+}
+// ====
+// EVMVersion: <cancun
+// ----
+// f() -> 1
+// g() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_creation.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_creation.sol
new file mode 100644
index 00000000..5a97dc84
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_creation.sol
@@ -0,0 +1,14 @@
+contract C {
+    constructor() {
+        uint x;
+        assembly {
+            tstore(0, 42)
+            x := tload(0)
+        }
+        assert(x == 42);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor() ->
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol
new file mode 100644
index 00000000..f3fe0384
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_low_level_calls.sol
@@ -0,0 +1,70 @@
+contract D {
+    function addOne() external {
+        assembly {
+            let x := tload(0)
+            tstore(0, add(x, 1))
+        }
+    }
+    function get() external returns (uint x) {
+        assembly {
+            x := tload(0)
+        }
+    }
+}
+
+contract C {
+    function set(uint x) external {
+        assembly {
+            tstore(0, x)
+        }
+    }
+
+    function get() external view returns (uint x) {
+        assembly {
+            x := tload(0)
+        }
+    }
+
+    function testDelegateCall() external returns (bool) {
+        this.set(5);
+        D d = new D();
+        // Caller contract is the owner of the transient storage
+        (bool success, ) = address(d).delegatecall(abi.encodeCall(d.addOne, ()));
+        require(success);
+        require(this.get() == 6);
+        return true;
+    }
+
+    function testCall() external returns (bool) {
+        this.set(5);
+        D d = new D();
+        // Callee/Target contract is the owner of the transient storage
+        (bool success, ) = address(d).call(abi.encodeCall(d.addOne, ()));
+        require(success);
+        require(d.get() == 1);
+        return true;
+    }
+
+    function tloadAllowedStaticCall() external returns (bool) {
+        this.set(5);
+        D d = new D();
+        (bool success, bytes memory result) = address(d).staticcall(abi.encodeCall(d.get, ()));
+        require(success);
+        require(abi.decode(result, (uint)) == 0);
+        return true;
+    }
+
+    function tstoreNotAllowedStaticCall() external returns (bool) {
+        D d = new D();
+        (bool success, ) = address(d).staticcall(abi.encodeCall(d.addOne, ()));
+        require(!success);
+        return true;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// testDelegateCall() -> true
+// testCall() -> true
+// tloadAllowedStaticCall() -> true
+// tstoreNotAllowedStaticCall() -> true
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_calls_different_transactions.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_calls_different_transactions.sol
new file mode 100644
index 00000000..c8228655
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_calls_different_transactions.sol
@@ -0,0 +1,24 @@
+contract C {
+    function get(uint256 addr) external view returns (uint256 x) {
+        assembly {
+            x := tload(addr)
+        }
+    }
+    function set(uint256 addr, uint256 x) external {
+        assembly {
+            tstore(addr, x)
+        }
+    }
+    function test() public {
+        assert(this.get(0) == 0 && this.get(42) == 0);
+        this.set(0, 21);
+        assert(this.get(0) == 21 && this.get(42) == 0);
+        this.set(42, 131);
+        assert(this.get(0) == 21 && this.get(42) == 131);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// test() ->
+// test() ->
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_transactions.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_transactions.sol
new file mode 100644
index 00000000..931f34de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_multiple_transactions.sol
@@ -0,0 +1,38 @@
+contract C {
+    function set(uint value) private {
+        assembly {
+            tstore(0, value)
+        }
+    }
+
+    function get() private view returns (uint value) {
+        assembly {
+            value := tload(0)
+        }
+    }
+
+    function f() external {
+        assembly {
+            tstore(0, 42)
+        }
+    }
+
+    function g() external view returns(uint r) {
+        assembly {
+            r := tload(0)
+        }
+    }
+
+    function h() external returns (uint x) {
+        set(99);
+        x = get();
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// g() -> 0
+// f() ->
+// g() -> 0
+// h() -> 0x63
+// g() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_reset_between_creation_runtime.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_reset_between_creation_runtime.sol
new file mode 100644
index 00000000..e41fcb60
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_reset_between_creation_runtime.sol
@@ -0,0 +1,24 @@
+contract C {
+    constructor() {
+        uint x;
+        assembly {
+            tstore(0, 42)
+            x := tload(0)
+        }
+        assert(x == 42);
+    }
+
+    function f() public returns (uint x) {
+        assembly {
+            x := tload(0)
+            if eq(x, 42) {
+                revert(0, 0)
+            }
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor() ->
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_sanity_checks.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_sanity_checks.sol
new file mode 100644
index 00000000..101c3c10
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_sanity_checks.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f() external {
+        assembly {
+            tstore(0, 21)
+            mstore(0, 42)
+            sstore(0, 42)
+            if iszero(eq(tload(0), 21)) {
+                revert(0, 0)
+            }
+        }
+    }
+    function g() external view returns (uint s, uint m, uint t) {
+        assembly {
+            s := sload(0)
+            m := mload(0)
+            t := tload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() ->
+// g() -> 0x2a, 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol
new file mode 100644
index 00000000..93543542
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol
@@ -0,0 +1,44 @@
+contract C {
+    function set(uint value) external {
+        assembly {
+            tstore(0, value)
+        }
+    }
+
+    function get() external view returns (uint value) {
+        assembly {
+            value := tload(0)
+        }
+    }
+
+    function terminate(address payable a) external {
+        selfdestruct(a);
+    }
+}
+
+contract D {
+    C public c;
+
+    constructor() {
+        c = new C();
+    }
+
+    function destroy() external {
+        c.set(42);
+        c.terminate(payable(address(this)));
+        assert(c.get() == 42);
+    }
+
+    function createAndDestroy() external {
+        c = new C();
+        c.set(42);
+        c.terminate(payable(address(this)));
+        assert(c.get() == 42);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor() ->
+// destroy() ->
+// createAndDestroy() ->
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_simple_reentrancy_lock.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_simple_reentrancy_lock.sol
new file mode 100644
index 00000000..0d05c926
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/transient_storage_simple_reentrancy_lock.sol
@@ -0,0 +1,22 @@
+contract C {
+    modifier nonreentrant {
+        assembly {
+            if tload(0) { revert(0, 0) }
+            tstore(0, 1)
+        }
+        _;
+        assembly {
+            tstore(0, 0)
+        }
+    }
+    function f(bool simulateReentrancy) nonreentrant public {
+        if (simulateReentrancy) {
+            f(false);
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f(bool): false ->
+// f(bool): true -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/truefalse.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/truefalse.sol
new file mode 100644
index 00000000..4183642b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/truefalse.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public returns (uint x, uint y) {
+        assembly {
+            x := true
+            y := false
+        }
+    }
+}
+// ----
+// f() -> 1, 0
diff --git a/compiler/test/libsolidity/semanticTests/inlineAssembly/tstore_hidden_staticcall.sol b/compiler/test/libsolidity/semanticTests/inlineAssembly/tstore_hidden_staticcall.sol
new file mode 100644
index 00000000..bdd9401e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/inlineAssembly/tstore_hidden_staticcall.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f() internal {
+        assembly {
+            tstore(0, 0)
+        }
+    }
+    function g() public view {
+        function() internal ptr = f;
+        function() internal view ptr2;
+        assembly { ptr2 := ptr }
+        ptr2(); // we force calling the non-view function, which should result in a revert during the staticcall
+    }
+    function test() public {
+        this.g(); // an external call to a view function should use static call
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// test() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/integer/basic.sol b/compiler/test/libsolidity/semanticTests/integer/basic.sol
new file mode 100644
index 00000000..cea56cd7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/integer/basic.sol
@@ -0,0 +1,22 @@
+contract C {
+	function basic() public pure returns(bool) {
+		uint uint_min = type(uint).min;
+		require(uint_min == 0);
+
+		uint uint_max = type(uint).max;
+		require(uint_max == 2**256 - 1);
+		require(uint_max == 115792089237316195423570985008687907853269984665640564039457584007913129639935);
+
+		int int_min = type(int).min;
+		require(int_min == -2**255);
+		require(int_min == -57896044618658097711785492504343953926634992332820282019728792003956564819968);
+
+		int int_max = type(int).max;
+		require(int_max == 2**255 -1);
+		require(int_max == 57896044618658097711785492504343953926634992332820282019728792003956564819967);
+
+		return true;
+	}
+}
+// ----
+// basic() -> true
diff --git a/compiler/test/libsolidity/semanticTests/integer/int.sol b/compiler/test/libsolidity/semanticTests/integer/int.sol
new file mode 100644
index 00000000..d3681a0e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/integer/int.sol
@@ -0,0 +1,243 @@
+contract test {
+
+	function intMinA() public pure returns (bool) {
+
+		int8 int8_min = type(int8).min;
+		require(int8_min == -2**7);
+
+		int16 int16_min = type(int16).min;
+		require(int16_min == -2**15);
+
+		int24 int24_min = type(int24).min;
+		require(int24_min == -2**23);
+
+		int32 int32_min = type(int32).min;
+		require(int32_min == -2**31);
+
+		int40 int40_min = type(int40).min;
+		require(int40_min == -2**39);
+
+		int48 int48_min = type(int48).min;
+		require(int48_min == -2**47);
+
+		int56 int56_min = type(int56).min;
+		require(int56_min == -2**55);
+
+		int64 int64_min = type(int64).min;
+		require(int64_min == -2**63);
+
+		return true;
+	}
+
+	function intMinB() public pure returns(bool) {
+
+		int72 int72_min = type(int72).min;
+		require(int72_min == -2**71);
+
+		int80 int80_min = type(int80).min;
+		require(int80_min == -2**79);
+
+		int88 int88_min = type(int88).min;
+		require(int88_min == -2**87);
+
+		int96 int96_min = type(int96).min;
+		require(int96_min == -2**95);
+
+		int104 int104_min = type(int104).min;
+		require(int104_min == -2**103);
+
+		int112 int112_min = type(int112).min;
+		require(int112_min == -2**111);
+
+		int120 int120_min = type(int120).min;
+		require(int120_min == -2**119);
+
+		int128 int128_min = type(int128).min;
+		require(int128_min == -2**127);
+
+		return true;
+	}
+
+	function intMinC() public pure returns (bool) {
+
+		int136 int136_min = type(int136).min;
+		require(int136_min == -2**135);
+
+		int144 int144_min = type(int144).min;
+		require(int144_min == -2**143);
+
+		int152 int152_min = type(int152).min;
+		require(int152_min == -2**151);
+
+		int160 int160_min = type(int160).min;
+		require(int160_min == -2**159);
+
+		int168 int168_min = type(int168).min;
+		require(int168_min == -2**167);
+
+		int176 int176_min = type(int176).min;
+		require(int176_min == -2**175);
+
+		int184 int184_min = type(int184).min;
+		require(int184_min == -2**183);
+
+		int192 int192_min = type(int192).min;
+		require(int192_min == -2**191);
+
+		return true;
+	}
+
+	function intMinD() public pure returns(bool) {
+
+		int200 int200_min = type(int200).min;
+		require(int200_min == -2**199);
+
+		int208 int208_min = type(int208).min;
+		require(int208_min == -2**207);
+
+		int216 int216_min = type(int216).min;
+		require(int216_min == -2**215);
+
+		int224 int224_min = type(int224).min;
+		require(int224_min == -2**223);
+
+		int232 int232_min = type(int232).min;
+		require(int232_min == -2**231);
+
+		int240 int240_min = type(int240).min;
+		require(int240_min == -2**239);
+
+		int248 int248_min = type(int248).min;
+		require(int248_min == -2**247);
+
+		int256 int256_min = type(int256).min;
+		require(int256_min == -2**255);
+
+		return true;
+	}
+
+	function intMaxA() public pure returns (bool) {
+
+		int8 int8_max = type(int8).max;
+		require(int8_max == 2**7-1);
+
+		int16 int16_max = type(int16).max;
+		require(int16_max == 2**15-1);
+
+		int24 int24_max = type(int24).max;
+		require(int24_max == 2**23-1);
+
+		int32 int32_max = type(int32).max;
+		require(int32_max == 2**31-1);
+
+		int40 int40_max = type(int40).max;
+		require(int40_max == 2**39-1);
+
+		int48 int48_max = type(int48).max;
+		require(int48_max == 2**47-1);
+
+		int56 int56_max = type(int56).max;
+		require(int56_max == 2**55-1);
+
+		int64 int64_max = type(int64).max;
+		require(int64_max == 2**63-1);
+
+		return true;
+	}
+
+	function intMaxB() public pure returns(bool) {
+
+		int72 int72_max = type(int72).max;
+		require(int72_max == 2**71-1);
+
+		int80 int80_max = type(int80).max;
+		require(int80_max == 2**79-1);
+
+		int88 int88_max = type(int88).max;
+		require(int88_max == 2**87-1);
+
+		int96 int96_max = type(int96).max;
+		require(int96_max == 2**95-1);
+
+		int104 int104_max = type(int104).max;
+		require(int104_max == 2**103-1);
+
+		int112 int112_max = type(int112).max;
+		require(int112_max == 2**111-1);
+
+		int120 int120_max = type(int120).max;
+		require(int120_max == 2**119-1);
+
+		int128 int128_max = type(int128).max;
+		require(int128_max == 2**127-1);
+
+		return true;
+	}
+
+	function intMaxC() public pure returns (bool) {
+
+		int136 int136_max = type(int136).max;
+		require(int136_max == 2**135-1);
+
+		int144 int144_max = type(int144).max;
+		require(int144_max == 2**143-1);
+
+		int152 int152_max = type(int152).max;
+		require(int152_max == 2**151-1);
+
+		int160 int160_max = type(int160).max;
+		require(int160_max == 2**159-1);
+
+		int168 int168_max = type(int168).max;
+		require(int168_max == 2**167-1);
+
+		int176 int176_max = type(int176).max;
+		require(int176_max == 2**175-1);
+
+		int184 int184_max = type(int184).max;
+		require(int184_max == 2**183-1);
+
+		int192 int192_max = type(int192).max;
+		require(int192_max == 2**191-1);
+
+		return true;
+	}
+
+	function intMaxD() public pure returns(bool) {
+
+		int200 int200_max = type(int200).max;
+		require(int200_max == 2**199-1);
+
+		int208 int208_max = type(int208).max;
+		require(int208_max == 2**207-1);
+
+		int216 int216_max = type(int216).max;
+		require(int216_max == 2**215-1);
+
+		int224 int224_max = type(int224).max;
+		require(int224_max == 2**223-1);
+
+		int232 int232_max = type(int232).max;
+		require(int232_max == 2**231-1);
+
+		int240 int240_max = type(int240).max;
+		require(int240_max == 2**239-1);
+
+		int248 int248_max = type(int248).max;
+		require(int248_max == 2**247-1);
+
+		int256 int256_max = type(int256).max;
+		require(int256_max == 2**255-1);
+
+		return true;
+	}
+}
+// ----
+// intMinA() -> true
+// intMinB() -> true
+// intMinC() -> true
+// intMinD() -> true
+// intMaxA() -> true
+// intMaxB() -> true
+// intMaxC() -> true
+// intMaxD() -> true
diff --git a/compiler/test/libsolidity/semanticTests/integer/many_local_variables.sol b/compiler/test/libsolidity/semanticTests/integer/many_local_variables.sol
new file mode 100644
index 00000000..c43f9269
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/integer/many_local_variables.sol
@@ -0,0 +1,9 @@
+contract test {
+    function run(uint x1, uint x2, uint x3) public returns(uint y) {
+        uint8 a = 0x1; uint8 b = 0x10; uint16 c = 0x100;
+        y = a + b + c + x1 + x2 + x3;
+        y += b + x2;
+    }
+}
+// ----
+// run(uint256,uint256,uint256): 0x1000, 0x10000, 0x100000 -> 0x121121
diff --git a/compiler/test/libsolidity/semanticTests/integer/small_signed_types.sol b/compiler/test/libsolidity/semanticTests/integer/small_signed_types.sol
new file mode 100644
index 00000000..4c0311e5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/integer/small_signed_types.sol
@@ -0,0 +1,7 @@
+contract test {
+    function run() public returns(int256 y) {
+        return -int32(10) * -int64(20);
+    }
+}
+// ----
+// run() -> 200
diff --git a/compiler/test/libsolidity/semanticTests/integer/uint.sol b/compiler/test/libsolidity/semanticTests/integer/uint.sol
new file mode 100644
index 00000000..ccd32fab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/integer/uint.sol
@@ -0,0 +1,242 @@
+contract test {
+
+	function uintMinA() public pure returns(bool) {
+
+		uint8 uint8_min = type(uint8).min;
+		require(uint8_min == 0);
+
+		uint16 uint16_min = type(uint16).min;
+		require(uint16_min == 0);
+
+		uint24 uint24_min = type(uint24).min;
+		require(uint24_min == 0);
+
+		uint32 uint32_min = type(uint32).min;
+		require(uint32_min == 0);
+
+		uint40 uint40_min = type(uint40).min;
+		require(uint40_min == 0);
+
+		uint48 uint48_min = type(uint48).min;
+		require(uint48_min == 0);
+
+		uint56 uint56_min = type(uint56).min;
+		require(uint56_min == 0);
+
+		uint64 uint64_min = type(uint64).min;
+		require(uint64_min == 0);
+
+		return true;
+	}
+
+	function uintMinB() public pure returns(bool) {
+
+		uint72 uint72_min = type(uint72).min;
+		require(uint72_min == 0);
+
+		uint80 uint80_min = type(uint80).min;
+		require(uint80_min == 0);
+
+		uint88 uint88_min = type(uint88).min;
+		require(uint88_min == 0);
+
+		uint96 uint96_min = type(uint96).min;
+		require(uint96_min == 0);
+
+		uint104 uint104_min = type(uint104).min;
+		require(uint104_min == 0);
+
+		uint112 uint112_min = type(uint112).min;
+		require(uint112_min == 0);
+
+		uint120 uint120_min = type(uint120).min;
+		require(uint120_min == 0);
+
+		uint128 uint128_min = type(uint128).min;
+		require(uint128_min == 0);
+
+		return true;
+	}
+
+	function uintMinC() public pure returns(bool) {
+
+		uint136 uint136_min = type(uint136).min;
+		require(uint136_min == 0);
+
+		uint144 uint144_min = type(uint144).min;
+		require(uint144_min == 0);
+
+		uint152 uint152_min = type(uint152).min;
+		require(uint152_min == 0);
+
+		uint160 uint160_min = type(uint160).min;
+		require(uint160_min == 0);
+
+		uint168 uint168_min = type(uint168).min;
+		require(uint168_min == 0);
+
+		uint176 uint176_min = type(uint176).min;
+		require(uint176_min == 0);
+
+		uint184 uint184_min = type(uint184).min;
+		require(uint184_min == 0);
+
+		uint192 uint192_min = type(uint192).min;
+		require(uint192_min == 0);
+
+		return true;
+	}
+
+	function uintMinD() public pure returns(bool) {
+
+		uint200 uint200_min = type(uint200).min;
+		require(uint200_min == 0);
+
+		uint208 uint208_min = type(uint208).min;
+		require(uint208_min == 0);
+
+		uint216 uint216_min = type(uint216).min;
+		require(uint216_min == 0);
+
+		uint224 uint224_min = type(uint224).min;
+		require(uint224_min == 0);
+
+		uint232 uint232_min = type(uint232).min;
+		require(uint232_min == 0);
+
+		uint240 uint240_min = type(uint240).min;
+		require(uint240_min == 0);
+
+		uint248 uint248_min = type(uint248).min;
+		require(uint248_min == 0);
+
+		uint256 uint256_min = type(uint256).min;
+		require(uint256_min == 0);
+
+		return true;
+	}
+
+	function uintMaxA() public pure returns (bool) {
+
+		uint8 uint8_max = type(uint8).max;
+		require(uint8_max == 2**8-1);
+
+		uint16 uint16_max = type(uint16).max;
+		require(uint16_max == 2**16-1);
+
+		uint24 uint24_max = type(uint24).max;
+		require(uint24_max == 2**24-1);
+
+		uint32 uint32_max = type(uint32).max;
+		require(uint32_max == 2**32-1);
+
+		uint40 uint40_max = type(uint40).max;
+		require(uint40_max == 2**40-1);
+
+		uint48 uint48_max = type(uint48).max;
+		require(uint48_max == 2**48-1);
+
+		uint56 uint56_max = type(uint56).max;
+		require(uint56_max == 2**56-1);
+
+		uint64 uint64_max = type(uint64).max;
+		require(uint64_max == 2**64-1);
+
+		return true;
+	}
+
+	function uintMaxB() public pure returns (bool) {
+
+		uint72 uint72_max = type(uint72).max;
+		require(uint72_max == 2**72-1);
+
+		uint80 uint80_max = type(uint80).max;
+		require(uint80_max == 2**80-1);
+
+		uint88 uint88_max = type(uint88).max;
+		require(uint88_max == 2**88-1);
+
+		uint96 uint96_max = type(uint96).max;
+		require(uint96_max == 2**96-1);
+
+		uint104 uint104_max = type(uint104).max;
+		require(uint104_max == 2**104-1);
+
+		uint112 uint112_max = type(uint112).max;
+		require(uint112_max == 2**112-1);
+
+		uint120 uint120_max = type(uint120).max;
+		require(uint120_max == 2**120-1);
+
+		uint128 uint128_max = type(uint128).max;
+		require(uint128_max == 2**128-1);
+
+		return true;
+	}
+
+	function uintMaxC() public pure returns (bool) {
+
+		uint136 uint136_max = type(uint136).max;
+		require(uint136_max == 2**136-1);
+
+		uint144 uint144_max = type(uint144).max;
+		require(uint144_max == 2**144-1);
+
+		uint152 uint152_max = type(uint152).max;
+		require(uint152_max == 2**152-1);
+
+		uint160 uint160_max = type(uint160).max;
+		require(uint160_max == 2**160-1);
+
+		uint168 uint168_max = type(uint168).max;
+		require(uint168_max == 2**168-1);
+
+		uint176 uint176_max = type(uint176).max;
+		require(uint176_max == 2**176-1);
+
+		uint184 uint184_max = type(uint184).max;
+		require(uint184_max == 2**184-1);
+
+		uint192 uint192_max = type(uint192).max;
+		require(uint192_max == 2**192-1);
+
+		return true;
+	}
+
+	function uintMaxD() public pure returns(bool) {
+		uint200 uint200_max = type(uint200).max;
+		require(uint200_max == 2**200-1);
+
+		uint208 uint208_max = type(uint208).max;
+		require(uint208_max == 2**208-1);
+
+		uint216 uint216_max = type(uint216).max;
+		require(uint216_max == 2**216-1);
+
+		uint224 uint224_max = type(uint224).max;
+		require(uint224_max == 2**224-1);
+
+		uint232 uint232_max = type(uint232).max;
+		require(uint232_max == 2**232-1);
+
+		uint240 uint240_max = type(uint240).max;
+		require(uint240_max == 2**240-1);
+
+		uint248 uint248_max = type(uint248).max;
+		require(uint248_max == 2**248-1);
+
+		uint256 uint256_max = type(uint256).max;
+		require(uint256_max == 2**256-1);
+
+		return true;
+	}
+}
+// ----
+// uintMinA() -> true
+// uintMinB() -> true
+// uintMinC() -> true
+// uintMinD() -> true
+// uintMaxA() -> true
+// uintMaxB() -> true
+// uintMaxC() -> true
+// uintMaxD() -> true
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/homer.sol b/compiler/test/libsolidity/semanticTests/interfaceID/homer.sol
new file mode 100644
index 00000000..fbe6293d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/homer.sol
@@ -0,0 +1,35 @@
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+interface Simpson {
+    function is2D() external returns (bool);
+    function skinColor() external returns (string memory);
+}
+
+contract Homer is ERC165, Simpson {
+    function supportsInterface(bytes4 interfaceID) external view override returns (bool) {
+        return
+            interfaceID == this.supportsInterface.selector || // ERC165
+            interfaceID == this.is2D.selector ^ this.skinColor.selector; // Simpson
+    }
+
+    function is2D() external override returns (bool) {
+        return true;
+    }
+
+    function skinColor() external override returns (string memory) {
+        return "yellow";
+    }
+}
+// ----
+// supportsInterface(bytes4): left(0x01ffc9a0) -> false
+// supportsInterface(bytes4): left(0x01ffc9a7) -> true
+// supportsInterface(bytes4): left(0x73b6b492) -> true
+// supportsInterface(bytes4): left(0x70b6b492) -> false
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/homer_interfaceId.sol b/compiler/test/libsolidity/semanticTests/interfaceID/homer_interfaceId.sol
new file mode 100644
index 00000000..c66169cd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/homer_interfaceId.sol
@@ -0,0 +1,35 @@
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+interface Simpson {
+    function is2D() external returns (bool);
+    function skinColor() external returns (string memory);
+}
+
+contract Homer is ERC165, Simpson {
+    function supportsInterface(bytes4 interfaceID) external view override returns (bool) {
+        return
+            interfaceID == type(ERC165).interfaceId ||
+            interfaceID == type(Simpson).interfaceId;
+    }
+
+    function is2D() external override returns (bool) {
+        return true;
+    }
+
+    function skinColor() external override returns (string memory) {
+        return "yellow";
+    }
+}
+// ----
+// supportsInterface(bytes4): left(0x01ffc9a0) -> false
+// supportsInterface(bytes4): left(0x01ffc9a7) -> true
+// supportsInterface(bytes4): left(0x73b6b492) -> true
+// supportsInterface(bytes4): left(0x70b6b492) -> false
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/interfaceId_events.sol b/compiler/test/libsolidity/semanticTests/interfaceID/interfaceId_events.sol
new file mode 100644
index 00000000..9bbf11be
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/interfaceId_events.sol
@@ -0,0 +1,18 @@
+interface HelloWorld {
+    function hello() external pure;
+    function world(int) external pure;
+}
+
+interface HelloWorldWithEvent {
+    event Event();
+    function hello() external pure;
+    function world(int) external pure;
+}
+
+contract Test {
+    bytes4 public hello_world = type(HelloWorld).interfaceId;
+    bytes4 public hello_world_with_event = type(HelloWorldWithEvent).interfaceId;
+}
+// ----
+// hello_world() -> left(0xc6be8b58)
+// hello_world_with_event() -> left(0xc6be8b58)
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/interfaces.sol b/compiler/test/libsolidity/semanticTests/interfaceID/interfaces.sol
new file mode 100644
index 00000000..f66d859e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/interfaces.sol
@@ -0,0 +1,61 @@
+interface HelloWorld {
+    function hello() external pure;
+    function world(int) external pure;
+}
+
+interface HelloWorldDerived is HelloWorld {
+    function other() external pure;
+}
+
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+contract Test {
+    bytes4 public ghello_world_interfaceId = type(HelloWorld).interfaceId;
+    bytes4 public ERC165_interfaceId = type(ERC165).interfaceId;
+
+    function hello() public pure returns (bytes4 data){
+        HelloWorld i;
+        return i.hello.selector;
+    }
+
+    function world() public pure returns (bytes4 data){
+        HelloWorld i;
+        return i.world.selector;
+    }
+
+    function hello_world() public pure returns (bytes4 data){
+        // HelloWorld i;
+        // return i.hello.selector ^ i.world.selector; // = 0xc6be8b58
+        return 0xc6be8b58;
+    }
+
+    function hello_world_interfaceId() public pure returns (bytes4 data){
+        return type(HelloWorld).interfaceId;
+    }
+
+    function other() public pure returns (bytes4 data){
+        HelloWorldDerived i;
+        return i.other.selector;
+    }
+
+    function hello_world_derived_interfaceId() public pure returns (bytes4 data){
+        return type(HelloWorldDerived).interfaceId;
+    }
+}
+// ----
+// hello() -> left(0x19ff1d21)
+// world() -> left(0xdf419679)
+// ERC165_interfaceId() -> left(0x01ffc9a7)
+// hello_world() -> left(0xc6be8b58)
+// hello_world_interfaceId() -> left(0xc6be8b58)
+// ghello_world_interfaceId() -> left(0xc6be8b58)
+// other() -> left(0x85295877)
+// hello_world_derived_interfaceId() -> left(0x85295877)
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/lisa.sol b/compiler/test/libsolidity/semanticTests/interfaceID/lisa.sol
new file mode 100644
index 00000000..722502d8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/lisa.sol
@@ -0,0 +1,46 @@
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+abstract contract ERC165MappingImplementation is ERC165 {
+    /// @dev You must not set element 0xffffffff to true
+    mapping(bytes4 => bool) internal supportedInterfaces;
+
+    constructor() {
+        supportedInterfaces[this.supportsInterface.selector] = true;
+    }
+
+    function supportsInterface(bytes4 interfaceID) external view override returns (bool) {
+        return supportedInterfaces[interfaceID];
+    }
+}
+
+interface Simpson {
+    function is2D() external returns (bool);
+    function skinColor() external returns (string memory);
+}
+
+contract Lisa is ERC165MappingImplementation, Simpson {
+    constructor() {
+        supportedInterfaces[this.is2D.selector ^ this.skinColor.selector] = true;
+    }
+
+    function is2D() external override returns (bool) {
+        return true;
+    }
+
+    function skinColor() external override returns (string memory) {
+        return "yellow";
+    }
+}
+// ----
+// supportsInterface(bytes4): left(0x01ffc9a0) -> false
+// supportsInterface(bytes4): left(0x01ffc9a7) -> true
+// supportsInterface(bytes4): left(0x73b6b492) -> true
+// supportsInterface(bytes4): left(0x70b6b492) -> false
diff --git a/compiler/test/libsolidity/semanticTests/interfaceID/lisa_interfaceId.sol b/compiler/test/libsolidity/semanticTests/interfaceID/lisa_interfaceId.sol
new file mode 100644
index 00000000..457ac885
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interfaceID/lisa_interfaceId.sol
@@ -0,0 +1,46 @@
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+abstract contract ERC165MappingImplementation is ERC165 {
+    /// @dev You must not set element 0xffffffff to true
+    mapping(bytes4 => bool) internal supportedInterfaces;
+
+    constructor() {
+        supportedInterfaces[this.supportsInterface.selector] = true;
+    }
+
+    function supportsInterface(bytes4 interfaceID) external view override returns (bool) {
+        return supportedInterfaces[interfaceID];
+    }
+}
+
+interface Simpson {
+    function is2D() external returns (bool);
+    function skinColor() external returns (string memory);
+}
+
+contract Lisa is ERC165MappingImplementation, Simpson {
+    constructor() {
+        supportedInterfaces[type(Simpson).interfaceId] = true;
+    }
+
+    function is2D() external override returns (bool) {
+        return true;
+    }
+
+    function skinColor() external override returns (string memory) {
+        return "yellow";
+    }
+}
+// ----
+// supportsInterface(bytes4): left(0x01ffc9a0) -> false
+// supportsInterface(bytes4): left(0x01ffc9a7) -> true
+// supportsInterface(bytes4): left(0x73b6b492) -> true
+// supportsInterface(bytes4): left(0x70b6b492) -> false
diff --git a/compiler/test/libsolidity/semanticTests/interface_inheritance_conversions.sol b/compiler/test/libsolidity/semanticTests/interface_inheritance_conversions.sol
new file mode 100644
index 00000000..62e1e4fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/interface_inheritance_conversions.sol
@@ -0,0 +1,43 @@
+interface Parent {
+    function parentFun() external returns (uint256);
+}
+
+interface SubA is Parent {
+    function subAFun() external returns (uint256);
+}
+
+interface SubB is Parent {
+    function subBFun() external returns (uint256);
+}
+
+contract Impl is SubA, SubB {
+    function parentFun() override external returns (uint256) { return 1; }
+    function subAFun() override external returns (uint256) { return 2; }
+    function subBFun() override external returns (uint256) { return 3; }
+}
+
+contract C {
+    function convertParent() public returns (uint256) {
+        Parent p = new Impl();
+        return p.parentFun();
+    }
+
+    function convertSubA() public returns (uint256, uint256) {
+        SubA sa = new Impl();
+        return (sa.parentFun(), sa.subAFun());
+    }
+
+    function convertSubB() public returns (uint256, uint256) {
+        SubB sb = new Impl();
+        return (sb.parentFun(), sb.subBFun());
+    }
+}
+// ----
+// convertParent() -> 1
+// gas irOptimized: 85524
+// convertSubA() -> 1, 2
+// gas irOptimized: 86155
+// gas legacy: 99047
+// convertSubB() -> 1, 3
+// gas irOptimized: 86098
+// gas legacy: 98981
diff --git a/compiler/test/libsolidity/semanticTests/isoltestFormatting.sol b/compiler/test/libsolidity/semanticTests/isoltestFormatting.sol
new file mode 100644
index 00000000..9380dc01
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/isoltestFormatting.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public returns (uint[5] memory) {
+        uint[5] memory a = [4, 11, 0x111, uint(3355443), 2222222222222222222];
+        return a;
+    }
+    function g() public returns (uint[5] memory) {
+        uint[5] memory a = [16, 256, 257, uint(0x333333), 0x1ed6eb565788e38e];
+        return a;
+    }
+}
+// ----
+// f() -> 4, 11, 0x0111, 0x333333, 2222222222222222222
+// g() -> 0x10, 0x0100, 0x0101, 0x333333, 2222222222222222222
diff --git a/compiler/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol b/compiler/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol
new file mode 100644
index 00000000..306bc356
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/isoltestTesting/balance_other_contract.sol
@@ -0,0 +1,27 @@
+contract Other {
+    constructor() payable {
+    }
+    function getAddress() public returns (address) {
+        return address(this);
+    }
+}
+contract ClientReceipt {
+    Other other;
+    constructor() payable {
+        other = new Other{value:500}();
+    }
+    function getAddress() public returns (address) {
+        return other.getAddress();
+    }
+}
+// ----
+// constructor(), 2000 wei ->
+// gas irOptimized: 169915
+// gas legacy: 230038
+// gas legacyOptimized: 173883
+// balance -> 1500
+// gas irOptimized: 191881
+// gas legacy: 235167
+// gas legacyOptimized: 180756
+// getAddress() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a
+// balance: 0x137aa4dfc0911524504fcd4d98501f179bc13b4a -> 500
diff --git a/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_accepting_calldata.sol b/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_accepting_calldata.sol
new file mode 100644
index 00000000..bc9e11de
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_accepting_calldata.sol
@@ -0,0 +1,17 @@
+library D {
+    function f(bytes calldata _x) internal pure returns (bytes1) {
+        return _x[0];
+    }
+    function g(bytes memory _x) internal pure returns (bytes1) {
+        return _x[0];
+    }
+}
+
+contract C {
+    using D for bytes;
+    function f(bytes calldata _x) public pure returns (bytes1, bytes1) {
+        return (_x.f(), _x.g());
+    }
+}
+// ----
+// f(bytes): 0x20, 4, "abcd" -> 0x6100000000000000000000000000000000000000000000000000000000000000, 0x6100000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_returning_calldata.sol b/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_returning_calldata.sol
new file mode 100644
index 00000000..5c32d31e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/attached_internal_library_function_returning_calldata.sol
@@ -0,0 +1,17 @@
+library D {
+    function f(bytes calldata _x) internal pure returns (bytes calldata) {
+        return _x;
+    }
+    function g(bytes calldata _x) internal pure returns (bytes memory) {
+        return _x;
+    }
+}
+
+contract C {
+    using D for bytes;
+    function f(bytes calldata _x) public pure returns (bytes1, bytes1) {
+        return (_x.f()[0], _x.g()[0]);
+    }
+}
+// ----
+// f(bytes): 0x20, 4, "abcd" -> 0x6100000000000000000000000000000000000000000000000000000000000000, 0x6100000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_accepting_calldata.sol.sol b/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_accepting_calldata.sol.sol
new file mode 100644
index 00000000..1c1f0457
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_accepting_calldata.sol.sol
@@ -0,0 +1,20 @@
+library D {
+    function f(bytes calldata _x) public pure returns (bytes1) {
+        return _x[0];
+    }
+    function g(bytes memory _x) public pure returns (bytes1) {
+        return _x[0];
+    }
+}
+
+contract C {
+    using D for bytes;
+    function f(bytes calldata _x) public pure returns (bytes1, bytes1) {
+        return (_x.f(), _x.g());
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// library: D
+// f(bytes): 0x20, 4, "abcd" -> 0x6100000000000000000000000000000000000000000000000000000000000000, 0x6100000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_returning_calldata.sol b/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_returning_calldata.sol
new file mode 100644
index 00000000..c194af88
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/attached_public_library_function_returning_calldata.sol
@@ -0,0 +1,20 @@
+library D {
+    function f(bytes calldata _x) public pure returns (bytes calldata) {
+        return _x;
+    }
+    function g(bytes calldata _x) public pure returns (bytes memory) {
+        return _x;
+    }
+}
+
+contract C {
+    using D for bytes;
+    function f(bytes calldata _x) public pure returns (bytes1, bytes1) {
+        return (_x.f()[0], _x.g()[0]);
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// library: D
+// f(bytes): 0x20, 4, "abcd" -> 0x6100000000000000000000000000000000000000000000000000000000000000, 0x6100000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_call_attached_with_parentheses.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_call_attached_with_parentheses.sol
new file mode 100644
index 00000000..1fa930ac
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_call_attached_with_parentheses.sol
@@ -0,0 +1,24 @@
+library L {
+    struct S {
+        uint256[] data;
+    }
+
+    function f(S memory _s) internal {
+        _s.data[3] += 2;
+    }
+}
+
+
+contract C {
+    using L for L.S;
+
+    function f() public returns (uint256) {
+        L.S memory x;
+        x.data = new uint256[](7);
+        x.data[3] = 8;
+        (x.f)();
+        return x.data[3];
+    }
+}
+// ----
+// f() -> 0x0a
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_call_unattached_with_parentheses.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_call_unattached_with_parentheses.sol
new file mode 100644
index 00000000..5a76dabd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_call_unattached_with_parentheses.sol
@@ -0,0 +1,13 @@
+library L {
+	function f() internal returns (uint) {
+		return 3;
+	}
+}
+
+contract C {
+	function foo() public returns (uint) {
+		return (L.f)();
+	}
+}
+// ----
+// foo() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function.sol
new file mode 100644
index 00000000..24299b6d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function.sol
@@ -0,0 +1,20 @@
+// tests that internal library functions can be called from outside
+// and retain the same memory context (i.e. are pulled into the caller's code)
+// This has to work without linking, because everything will be inlined.
+library L {
+    function f(uint256[] memory _data) internal {
+        _data[3] = 2;
+    }
+}
+
+
+contract C {
+    function f() public returns (uint256) {
+        uint256[] memory x = new uint256[](7);
+        x[3] = 8;
+        L.f(x);
+        return x[3];
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address.sol
new file mode 100644
index 00000000..c5581b79
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address.sol
@@ -0,0 +1,16 @@
+library L {
+    function equals(address a, address b) internal pure returns (bool) {
+        return a == b;
+    }
+}
+
+contract C {
+    using L for address;
+
+    function foo(address a, address b) public returns (bool) {
+        return a.equals(b);
+    }
+}
+// ----
+// foo(address,address): 0x111122223333444455556666777788889999aAaa, 0x111122223333444455556666777788889999aAaa -> true
+// foo(address,address): 0x111122223333444455556666777788889999aAaa, 0x0000000000000000000000000000000000000000 -> false
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address_named_send_transfer.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address_named_send_transfer.sol
new file mode 100644
index 00000000..a4facc02
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_address_named_send_transfer.sol
@@ -0,0 +1,19 @@
+library L {
+    function transfer(address a) internal {}
+    function send(address a) internal {}
+}
+
+contract C {
+    using L for address;
+
+    function useTransfer(address a) public {
+        a.transfer();
+    }
+
+    function useSend(address a) public {
+        a.send();
+    }
+}
+// ----
+// useTransfer(address): 0x111122223333444455556666777788889999aAaa ->
+// useSend(address): 0x111122223333444455556666777788889999aAaa ->
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_array_named_pop_push.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_array_named_pop_push.sol
new file mode 100644
index 00000000..80e0153b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_array_named_pop_push.sol
@@ -0,0 +1,17 @@
+library L {
+    function pop(uint[2] memory a) internal {}
+    function push(uint[2] memory a) internal {}
+}
+
+contract C {
+    using L for uint[2];
+
+    function test() public {
+        uint[2] memory input;
+
+        input.push();
+        input.pop();
+    }
+}
+// ----
+// test() ->
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_bool.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_bool.sol
new file mode 100644
index 00000000..bf49f4e7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_bool.sol
@@ -0,0 +1,18 @@
+library L {
+    function xor(bool a, bool b) internal pure returns (bool) {
+        return a != b;
+    }
+}
+
+contract C {
+    using L for bool;
+
+    function foo(bool a, bool b) public returns (bool) {
+        return a.xor(b);
+    }
+}
+// ----
+// foo(bool,bool): true, true -> false
+// foo(bool,bool): true, false -> true
+// foo(bool,bool): false, true -> true
+// foo(bool,bool): false, false -> false
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_contract.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_contract.sol
new file mode 100644
index 00000000..a4a25f51
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_contract.sol
@@ -0,0 +1,18 @@
+contract E {}
+
+library L {
+    function foo(E e) internal pure returns (uint) {
+        return 42;
+    }
+}
+
+contract C {
+    using L for E;
+
+    function test() public returns (uint) {
+        E e = new E();
+        return e.foo();
+    }
+}
+// ----
+// test() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_dynamic_array.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_dynamic_array.sol
new file mode 100644
index 00000000..f759ea78
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_dynamic_array.sol
@@ -0,0 +1,19 @@
+library L {
+    function at(uint[] memory a, uint i) internal pure returns (uint) {
+        return a[i];
+    }
+}
+
+contract C {
+    using L for uint[];
+
+    function secondItem() public returns (uint) {
+        uint[] memory input = new uint[](2);
+        input[0] = 0x11;
+        input[1] = 0x22;
+
+        return input.at(1);
+    }
+}
+// ----
+// secondItem() -> 0x22
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_enum.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_enum.sol
new file mode 100644
index 00000000..4dd3bad4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_enum.sol
@@ -0,0 +1,19 @@
+library L {
+    enum E { A, B }
+
+    function equals(E a, E b) internal pure returns (bool) {
+        return a == b;
+    }
+}
+
+contract C {
+    using L for L.E;
+
+    function equalsA(uint choice) public returns (bool) {
+        L.E x = L.E.A;
+        return x.equals(L.E(choice));
+    }
+}
+// ----
+// equalsA(uint256): 0 -> true
+// equalsA(uint256): 1 -> false
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_external_function_type.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_external_function_type.sol
new file mode 100644
index 00000000..a2473e7e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_external_function_type.sol
@@ -0,0 +1,20 @@
+library L {
+    // NOTE: External function takes up two stack slots
+    function double(function(uint) external pure returns (uint) f, uint x) internal pure returns (uint) {
+        return f(x) * 2;
+    }
+}
+
+contract C {
+    using L for function(uint) external pure returns (uint);
+
+    function identity(uint x) external pure returns (uint) {
+        return x;
+    }
+
+    function test(uint value) public returns (uint) {
+        return this.identity.double(value);
+    }
+}
+// ----
+// test(uint256): 5 -> 10
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_array.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_array.sol
new file mode 100644
index 00000000..28f621d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_array.sol
@@ -0,0 +1,19 @@
+library L {
+    function at(uint[2] memory a, uint i) internal pure returns (uint) {
+        return a[i];
+    }
+}
+
+contract C {
+    using L for uint[2];
+
+    function secondItem() public returns (uint) {
+        uint[2] memory input;
+        input[0] = 0x11;
+        input[1] = 0x22;
+
+        return input.at(1);
+    }
+}
+// ----
+// secondItem() -> 0x22
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_bytes.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_bytes.sol
new file mode 100644
index 00000000..bf7d0ede
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_fixed_bytes.sol
@@ -0,0 +1,15 @@
+library L {
+    function add(bytes2 a, bytes2 b) internal pure returns (bytes2) {
+        return bytes2(uint16(a) + uint16(b));
+    }
+}
+
+contract C {
+    using L for bytes2;
+
+    function sum(bytes2 a, bytes2 b) public returns (bytes2) {
+        return a.add(b);
+    }
+}
+// ----
+// sum(bytes2,bytes2): left(0x1100), left(0x0022) -> left(0x1122)
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_integer.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_integer.sol
new file mode 100644
index 00000000..5234fb5e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_integer.sol
@@ -0,0 +1,15 @@
+library L {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+}
+
+contract C {
+    using L for uint256;
+
+    function foo(uint256 a, uint256 b) public returns (uint256) {
+        return a.add(b);
+    }
+}
+// ----
+// foo(uint256,uint256): 8, 42 -> 50
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_interface.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_interface.sol
new file mode 100644
index 00000000..13228115
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_interface.sol
@@ -0,0 +1,19 @@
+interface I {}
+contract E is I {}
+
+library L {
+    function foo(I i) internal pure returns (uint) {
+        return 42;
+    }
+}
+
+contract C {
+    using L for I;
+
+    function test() public returns (uint) {
+        E e = new E();
+        return I(e).foo();
+    }
+}
+// ----
+// test() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type.sol
new file mode 100644
index 00000000..4397711c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type.sol
@@ -0,0 +1,19 @@
+library L {
+    function double(function(uint) internal pure returns (uint) f, uint x) internal pure returns (uint) {
+        return f(x) * 2;
+    }
+}
+
+contract C {
+    using L for function(uint) internal pure returns (uint);
+
+    function identity(uint x) internal pure returns (uint) {
+        return x;
+    }
+
+    function test(uint value) public returns (uint) {
+        return identity.double(value);
+    }
+}
+// ----
+// test(uint256): 5 -> 10
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type_named_selector.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type_named_selector.sol
new file mode 100644
index 00000000..4305b6d4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_internal_function_type_named_selector.sol
@@ -0,0 +1,19 @@
+library L {
+    function selector(function(uint) internal pure returns (uint) f, uint x) internal pure returns (uint) {
+        return f(x) * 2;
+    }
+}
+
+contract C {
+    using L for function(uint) internal pure returns (uint);
+
+    function identity(uint x) internal pure returns (uint) {
+        return x;
+    }
+
+    function test(uint value) public returns (uint) {
+        return identity.selector(value);
+    }
+}
+// ----
+// test(uint256): 5 -> 10
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_literal.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_literal.sol
new file mode 100644
index 00000000..da7ee6cc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_literal.sol
@@ -0,0 +1,24 @@
+library L {
+    function double(uint a) internal pure returns (uint) {
+        return a * 2;
+    }
+
+    function double(bytes memory a) internal pure returns (bytes memory) {
+        return bytes.concat(a, a);
+    }
+}
+
+contract C {
+    using L for *;
+
+    function double42() public returns (uint) {
+        return 42.double();
+    }
+
+    function doubleABC() public returns (bytes memory) {
+        return "abc".double();
+    }
+}
+// ----
+// double42() -> 84
+// doubleABC() -> 0x20, 6, "abcabc"
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_mapping.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_mapping.sol
new file mode 100644
index 00000000..d4cee5c9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_mapping.sol
@@ -0,0 +1,20 @@
+library L {
+    function at(mapping(uint => uint) storage a, uint i) internal view returns (uint) {
+        return a[i];
+    }
+}
+
+contract C {
+    using L for mapping(uint => uint);
+
+    mapping(uint => uint) map;
+
+    function mapValue(uint a) public returns (uint) {
+        map[42] = 0x24;
+        map[66] = 0x66;
+
+        return map.at(a);
+    }
+}
+// ----
+// mapValue(uint256): 42 -> 0x24
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_memory.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_memory.sol
new file mode 100644
index 00000000..3ed398f9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_memory.sol
@@ -0,0 +1,16 @@
+library L {
+    function at(string memory a, uint i) internal pure returns (uint8) {
+        return uint8(bytes(a)[i]);
+    }
+}
+
+contract C {
+    using L for string;
+
+    function secondChar() public returns (uint8) {
+        string memory input = "abc";
+        return input.at(1);
+    }
+}
+// ----
+// secondChar() -> 98
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_storage.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_storage.sol
new file mode 100644
index 00000000..b7bc103f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_string_accepting_storage.sol
@@ -0,0 +1,20 @@
+library L {
+    function f(string memory a) internal pure returns (string memory) {
+        return a;
+    }
+    function g(string storage a) internal pure returns (string memory) {
+        return a;
+    }
+}
+
+contract C {
+    using L for string;
+    string s;
+
+    function test(string calldata x) public returns (string memory, string memory) {
+        s = x;
+        return (s.f(), s.g());
+    }
+}
+// ----
+// test(string): 0x20, 3, "def" -> 0x40, 0x80, 3, "def", 3, "def"
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_struct.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_struct.sol
new file mode 100644
index 00000000..e9f95c0a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_attached_to_struct.sol
@@ -0,0 +1,25 @@
+// This has to work without linking, because everything will be inlined.
+library L {
+    struct S {
+        uint256[] data;
+    }
+
+    function f(S memory _s) internal {
+        _s.data[3] = 2;
+    }
+}
+
+
+contract C {
+    using L for L.S;
+
+    function f() public returns (uint256) {
+        L.S memory x;
+        x.data = new uint256[](7);
+        x.data[3] = 8;
+        x.f();
+        return x.data[3];
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_calling_private.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_calling_private.sol
new file mode 100644
index 00000000..5ef12f69
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_calling_private.sol
@@ -0,0 +1,25 @@
+// tests that internal library functions that are called from outside and that
+// themselves call private functions are still able to (i.e. the private function
+// also has to be pulled into the caller's code)
+// This has to work without linking, because everything will be inlined.
+library L {
+    function g(uint256[] memory _data) private {
+        _data[3] = 2;
+    }
+
+    function f(uint256[] memory _data) internal {
+        g(_data);
+    }
+}
+
+
+contract C {
+    function f() public returns (uint256) {
+        uint256[] memory x = new uint256[](7);
+        x[3] = 8;
+        L.f(x);
+        return x[3];
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_return_var_size.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_return_var_size.sol
new file mode 100644
index 00000000..d6e0e926
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_library_function_return_var_size.sol
@@ -0,0 +1,25 @@
+// This has to work without linking, because everything will be inlined.
+library L {
+    struct S {
+        uint256[] data;
+    }
+
+    function f(S memory _s) internal returns (uint256[] memory) {
+        _s.data[3] = 2;
+        return _s.data;
+    }
+}
+
+
+contract C {
+    using L for L.S;
+
+    function f() public returns (uint256) {
+        L.S memory x;
+        x.data = new uint256[](7);
+        x.data[3] = 8;
+        return x.f()[3];
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol b/compiler/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol
new file mode 100644
index 00000000..79d53273
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol
@@ -0,0 +1,27 @@
+library Lib {
+    function find(uint16[] storage _haystack, uint16 _needle) public view returns (uint)
+    {
+        for (uint i = 0; i < _haystack.length; ++i)
+            if (_haystack[i] == _needle)
+                return i;
+        return type(uint).max;
+    }
+}
+contract Test {
+    mapping(string => uint16[]) data;
+    function f() public returns (uint a, uint b)
+    {
+        while (data["abc"].length < 20)
+            data["abc"].push();
+        data["abc"][4] = 9;
+        data["abc"][17] = 3;
+        a = Lib.find(data["abc"], 9);
+        b = Lib.find(data["abc"], 3);
+    }
+}
+// ----
+// library: Lib
+// f() -> 4, 0x11
+// gas irOptimized: 111560
+// gas legacy: 132935
+// gas legacyOptimized: 118023
diff --git a/compiler/test/libsolidity/semanticTests/libraries/library_call_in_homestead.sol b/compiler/test/libsolidity/semanticTests/libraries/library_call_in_homestead.sol
new file mode 100644
index 00000000..44526da6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/library_call_in_homestead.sol
@@ -0,0 +1,13 @@
+library Lib { function m() public returns (address) { return msg.sender; } }
+contract Test {
+    address public sender;
+    function f() public {
+        sender = Lib.m();
+    }
+}
+// ====
+// EVMVersion: >=homestead
+// ----
+// library: Lib
+// f() ->
+// sender() -> 0x1212121212121212121212121212120000000012
diff --git a/compiler/test/libsolidity/semanticTests/libraries/library_enum_as_an_expression.sol b/compiler/test/libsolidity/semanticTests/libraries/library_enum_as_an_expression.sol
new file mode 100644
index 00000000..a385fb29
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/library_enum_as_an_expression.sol
@@ -0,0 +1,13 @@
+library Arst {
+    enum Foo {Things, Stuff}
+}
+
+
+contract Tsra {
+    function f() public returns (uint256) {
+        Arst.Foo;
+        return 1;
+    }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/libraries/library_references_preserve.sol b/compiler/test/libsolidity/semanticTests/libraries/library_references_preserve.sol
new file mode 100644
index 00000000..41c16d2f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/library_references_preserve.sol
@@ -0,0 +1,47 @@
+library L1 {
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+        return a + b + 1;
+    }
+}
+
+library L2 {
+    function add(uint256 a, uint256 b) external pure returns (uint256) {
+        return a + b + 2;
+    }
+}
+
+contract A {
+    uint256 sum;
+    constructor() {
+        sum = L1.add(1, 2);
+    }
+    function getSum() external view returns(uint256) {
+        return sum;
+    }
+}
+
+contract B {
+    uint256 sum;
+    constructor() {
+        sum = L2.add(1, 2);
+    }
+    function getSum() external view returns(uint256) {
+        return sum;
+    }
+}
+
+contract C {
+    A a = new A();
+    B b = new B();
+    function aSum() external view returns(uint256) {
+        return a.getSum();
+    }
+    function bSum() external view returns(uint256) {
+        return b.getSum();
+    }
+}
+// ----
+// library: L1
+// library: L2
+// aSum() -> 4
+// bSum() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/libraries/library_stray_values.sol b/compiler/test/libsolidity/semanticTests/libraries/library_stray_values.sol
new file mode 100644
index 00000000..3acc8557
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/library_stray_values.sol
@@ -0,0 +1,11 @@
+library Lib { function m(uint x, uint y) public returns (uint) { return x * y; } }
+contract Test {
+    function f(uint x) public returns (uint) {
+        Lib;
+        Lib.m;
+        return x + 9;
+    }
+}
+// ----
+// library: Lib
+// f(uint256): 33 -> 0x2a
diff --git a/compiler/test/libsolidity/semanticTests/libraries/library_struct_as_an_expression.sol b/compiler/test/libsolidity/semanticTests/libraries/library_struct_as_an_expression.sol
new file mode 100644
index 00000000..96ee9bcf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/library_struct_as_an_expression.sol
@@ -0,0 +1,16 @@
+library Arst {
+    struct Foo {
+        int256 Things;
+        int256 Stuff;
+    }
+}
+
+
+contract Tsra {
+    function f() public returns (uint256) {
+        Arst.Foo;
+        return 1;
+    }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/libraries/mapping_arguments_in_library.sol b/compiler/test/libsolidity/semanticTests/libraries/mapping_arguments_in_library.sol
new file mode 100644
index 00000000..cfbf7b0c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/mapping_arguments_in_library.sol
@@ -0,0 +1,38 @@
+library Lib {
+    function set(mapping(uint => uint) storage m, uint key, uint value) internal
+    {
+        m[key] = value;
+    }
+    function get(mapping(uint => uint) storage m, uint key) internal view returns (uint)
+    {
+        return m[key];
+    }
+}
+contract Test {
+    mapping(uint => uint) m;
+    function set(uint256 key, uint256 value) public returns (uint)
+    {
+        uint oldValue = Lib.get(m, key);
+        Lib.set(m, key, value);
+        return oldValue;
+    }
+    function get(uint256 key) public view returns (uint) {
+        return Lib.get(m, key);
+    }
+}
+// ----
+// library: Lib
+// set(uint256,uint256): 1, 42 -> 0
+// set(uint256,uint256): 2, 84 -> 0
+// set(uint256,uint256): 21, 7 -> 0
+// get(uint256): 0 -> 0
+// get(uint256): 1 -> 0x2a
+// get(uint256): 2 -> 0x54
+// get(uint256): 21 -> 7
+// set(uint256,uint256): 1, 21 -> 0x2a
+// set(uint256,uint256): 2, 42 -> 0x54
+// set(uint256,uint256): 21, 14 -> 7
+// get(uint256): 0 -> 0
+// get(uint256): 1 -> 0x15
+// get(uint256): 2 -> 0x2a
+// get(uint256): 21 -> 14
diff --git a/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library.sol b/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library.sol
new file mode 100644
index 00000000..da521f6b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library.sol
@@ -0,0 +1,72 @@
+library Lib {
+    function choose_mapping(mapping(uint => uint) storage a, mapping(uint => uint) storage b, bool c) internal pure returns(mapping(uint=>uint) storage)
+    {
+        return c ? a : b;
+    }
+}
+contract Test {
+    mapping(uint => uint) a;
+    mapping(uint => uint) b;
+    function set(bool choice, uint256 key, uint256 value) public returns (uint)
+    {
+        mapping(uint => uint) storage m = Lib.choose_mapping(a, b, choice);
+        uint oldValue = m[key];
+        m[key] = value;
+        return oldValue;
+    }
+    function get(bool choice, uint256 key) public view returns (uint) {
+        return Lib.choose_mapping(a, b, choice)[key];
+    }
+    function get_a(uint256 key) public view returns (uint) {
+        return a[key];
+    }
+    function get_b(uint256 key) public view returns (uint) {
+        return b[key];
+    }
+}
+// ----
+// library: Lib
+// set(bool,uint256,uint256): true, 1, 42 -> 0
+// set(bool,uint256,uint256): true, 2, 84 -> 0
+// set(bool,uint256,uint256): true, 21, 7 -> 0
+// set(bool,uint256,uint256): false, 1, 10 -> 0
+// set(bool,uint256,uint256): false, 2, 11 -> 0
+// set(bool,uint256,uint256): false, 21, 12 -> 0
+// get(bool,uint256): true, 0 -> 0
+// get(bool,uint256): true, 1 -> 0x2a
+// get(bool,uint256): true, 2 -> 0x54
+// get(bool,uint256): true, 21 -> 7
+// get_a(uint256): 0 -> 0
+// get_a(uint256): 1 -> 0x2a
+// get_a(uint256): 2 -> 0x54
+// get_a(uint256): 21 -> 7
+// get(bool,uint256): false, 0 -> 0
+// get(bool,uint256): false, 1 -> 10
+// get(bool,uint256): false, 2 -> 11
+// get(bool,uint256): false, 21 -> 12
+// get_b(uint256): 0 -> 0
+// get_b(uint256): 1 -> 10
+// get_b(uint256): 2 -> 11
+// get_b(uint256): 21 -> 12
+// set(bool,uint256,uint256): true, 1, 21 -> 0x2a
+// set(bool,uint256,uint256): true, 2, 42 -> 0x54
+// set(bool,uint256,uint256): true, 21, 14 -> 7
+// set(bool,uint256,uint256): false, 1, 30 -> 10
+// set(bool,uint256,uint256): false, 2, 31 -> 11
+// set(bool,uint256,uint256): false, 21, 32 -> 12
+// get_a(uint256): 0 -> 0
+// get_a(uint256): 1 -> 0x15
+// get_a(uint256): 2 -> 0x2a
+// get_a(uint256): 21 -> 14
+// get(bool,uint256): true, 0 -> 0
+// get(bool,uint256): true, 1 -> 0x15
+// get(bool,uint256): true, 2 -> 0x2a
+// get(bool,uint256): true, 21 -> 14
+// get_b(uint256): 0 -> 0
+// get_b(uint256): 1 -> 0x1e
+// get_b(uint256): 2 -> 0x1f
+// get_b(uint256): 21 -> 0x20
+// get(bool,uint256): false, 0 -> 0
+// get(bool,uint256): false, 1 -> 0x1e
+// get(bool,uint256): false, 2 -> 0x1f
+// get(bool,uint256): false, 21 -> 0x20
diff --git a/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library_named.sol b/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library_named.sol
new file mode 100644
index 00000000..e5963c1b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/mapping_returns_in_library_named.sol
@@ -0,0 +1,28 @@
+library Lib {
+    function f(mapping(uint => uint) storage a, mapping(uint => uint) storage b) internal returns(mapping(uint=>uint) storage r)
+    {
+        r = a;
+        r[1] = 42;
+        r = b;
+        r[1] = 21;
+    }
+}
+contract Test {
+    mapping(uint => uint) a;
+    mapping(uint => uint) b;
+    function f() public returns (uint, uint, uint, uint, uint, uint)
+    {
+        Lib.f(a, b)[2] = 84;
+        return (a[0], a[1], a[2], b[0], b[1], b[2]);
+    }
+    function g() public returns (uint, uint, uint, uint, uint, uint)
+    {
+        mapping(uint => uint) storage m = Lib.f(a, b);
+        m[2] = 17;
+        return (a[0], a[1], a[2], b[0], b[1], b[2]);
+    }
+}
+// ----
+// library: Lib
+// f() -> 0, 0x2a, 0, 0, 0x15, 0x54
+// g() -> 0, 0x2a, 0, 0, 0x15, 0x11
diff --git a/compiler/test/libsolidity/semanticTests/libraries/payable_function_calls_library.sol b/compiler/test/libsolidity/semanticTests/libraries/payable_function_calls_library.sol
new file mode 100644
index 00000000..178f22b4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/payable_function_calls_library.sol
@@ -0,0 +1,11 @@
+library L {
+    function f() public returns (uint) { return 7; }
+}
+contract C {
+    function f() public payable returns (uint) {
+        return L.f();
+    }
+}
+// ----
+// library: L
+// f(): 27 -> 7
diff --git a/compiler/test/libsolidity/semanticTests/libraries/using_for_by_name.sol b/compiler/test/libsolidity/semanticTests/libraries/using_for_by_name.sol
new file mode 100644
index 00000000..d6c7f313
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/using_for_by_name.sol
@@ -0,0 +1,13 @@
+library D { struct s { uint a; } function mul(s storage self, uint x) public returns (uint) { return self.a *= x; } }
+contract C {
+    using D for D.s;
+    D.s public x;
+    function f(uint a) public returns (uint) {
+        x.a = 6;
+        return x.mul({x: a});
+    }
+}
+// ----
+// library: D
+// f(uint256): 7 -> 0x2a
+// x() -> 0x2a
diff --git a/compiler/test/libsolidity/semanticTests/libraries/using_for_overload.sol b/compiler/test/libsolidity/semanticTests/libraries/using_for_overload.sol
new file mode 100644
index 00000000..5dd67fba
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/using_for_overload.sol
@@ -0,0 +1,17 @@
+library D {
+    struct s { uint a; }
+    function mul(s storage self, uint x) public returns (uint) { return self.a *= x; }
+    function mul(s storage self, bytes32 x) public returns (bytes32) { }
+}
+contract C {
+    using D for D.s;
+    D.s public x;
+    function f(uint a) public returns (uint) {
+        x.a = 6;
+        return x.mul(a);
+    }
+}
+// ----
+// library: D
+// f(uint256): 7 -> 0x2a
+// x() -> 0x2a
diff --git a/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_public.sol b/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_public.sol
new file mode 100644
index 00000000..b3e06c5b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_public.sol
@@ -0,0 +1,24 @@
+library Lib {
+    function set(mapping(uint => uint) storage m, uint key, uint value) public
+    {
+        m[key] = value;
+    }
+}
+contract Test {
+    mapping(uint => uint) m1;
+    mapping(uint => uint) m2;
+    function f() public returns (uint, uint, uint, uint, uint, uint)
+    {
+        Lib.set(m1, 0, 1);
+        Lib.set(m1, 2, 42);
+        Lib.set(m2, 0, 23);
+        Lib.set(m2, 2, 99);
+        return (m1[0], m1[1], m1[2], m2[0], m2[1], m2[2]);
+    }
+}
+// ----
+// library: Lib
+// f() -> 1, 0, 0x2a, 0x17, 0, 0x63
+// gas irOptimized: 119635
+// gas legacy: 124674
+// gas legacyOptimized: 119669
diff --git a/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_return.sol b/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_return.sol
new file mode 100644
index 00000000..e9d85596
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/using_library_mappings_return.sol
@@ -0,0 +1,22 @@
+library Lib {
+    function choose(mapping(uint => mapping(uint => uint)) storage m, uint key) external returns (mapping(uint => uint) storage) {
+        return m[key];
+    }
+}
+contract Test {
+    mapping(uint => mapping(uint => uint)) m;
+    function f() public returns (uint, uint, uint, uint, uint, uint)
+    {
+        Lib.choose(m, 0)[0] = 1;
+        Lib.choose(m, 0)[2] = 42;
+        Lib.choose(m, 1)[0] = 23;
+        Lib.choose(m, 1)[2] = 99;
+        return (m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2]);
+    }
+}
+// ----
+// library: Lib
+// f() -> 1, 0, 0x2a, 0x17, 0, 0x63
+// gas irOptimized: 120194
+// gas legacy: 125109
+// gas legacyOptimized: 120128
diff --git a/compiler/test/libsolidity/semanticTests/libraries/using_library_structs.sol b/compiler/test/libsolidity/semanticTests/libraries/using_library_structs.sol
new file mode 100644
index 00000000..e709a5b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/libraries/using_library_structs.sol
@@ -0,0 +1,24 @@
+library Lib {
+    struct Data { uint a; uint[] b; }
+    function set(Data storage _s) public
+    {
+        _s.a = 7;
+        while (_s.b.length < 20)
+            _s.b.push();
+        _s.b[19] = 8;
+    }
+}
+contract Test {
+    mapping(string => Lib.Data) data;
+    function f() public returns (uint a, uint b)
+    {
+        Lib.set(data["abc"]);
+        a = data["abc"].a;
+        b = data["abc"].b[19];
+    }
+}
+// ----
+// library: Lib
+// f() -> 7, 8
+// gas irOptimized: 101818
+// gas legacy: 101429
diff --git a/compiler/test/libsolidity/semanticTests/literals/denominations.sol b/compiler/test/libsolidity/semanticTests/literals/denominations.sol
new file mode 100644
index 00000000..f423775a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/denominations.sol
@@ -0,0 +1,7 @@
+contract C {
+	uint constant x = 1 ether + 1 gwei + 1 wei;
+
+	function f() public view returns(uint) { return x; }
+}
+// ----
+// f() -> 1000000001000000001
diff --git a/compiler/test/libsolidity/semanticTests/literals/denominations_in_array_sizes.sol b/compiler/test/libsolidity/semanticTests/literals/denominations_in_array_sizes.sol
new file mode 100644
index 00000000..43a09af0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/denominations_in_array_sizes.sol
@@ -0,0 +1,25 @@
+contract C {
+    uint[2 wei] a;
+    uint[2 gwei] b;
+    uint[2 ether] c;
+    uint[2 seconds] d;
+    uint[2 minutes] e;
+    uint[2 hours] f;
+    uint[2 days] g;
+    uint[2 weeks] h;
+
+    function lengths() public returns (uint, uint, uint, uint, uint, uint, uint, uint) {
+        return (
+            a.length,
+            b.length,
+            c.length,
+            d.length,
+            e.length,
+            f.length,
+            g.length,
+            h.length
+        );
+    }
+}
+// ----
+// lengths() -> 2, 2000000000, 2000000000000000000, 2, 120, 7200, 172800, 1209600
diff --git a/compiler/test/libsolidity/semanticTests/literals/escape.sol b/compiler/test/libsolidity/semanticTests/literals/escape.sol
new file mode 100644
index 00000000..96fa9b11
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/escape.sol
@@ -0,0 +1,11 @@
+pragma abicoder v2;
+
+contract C
+{
+	function f() public pure returns (uint, bytes1, bytes1) {
+		bytes memory encoded = abi.encodePacked("\\\\");
+		return (encoded.length, encoded[0], encoded[1]);
+	}
+}
+// ----
+// f() -> 2, 0x5c00000000000000000000000000000000000000000000000000000000000000, 0x5c00000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/literals/ether.sol b/compiler/test/libsolidity/semanticTests/literals/ether.sol
new file mode 100644
index 00000000..16cb7531
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/ether.sol
@@ -0,0 +1,7 @@
+contract C {
+	uint constant x = 1 ether;
+
+	function f() public view returns(uint) { return x; }
+}
+// ----
+// f() -> 1000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/literals/fractional_denominations.sol b/compiler/test/libsolidity/semanticTests/literals/fractional_denominations.sol
new file mode 100644
index 00000000..6bc448f0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/fractional_denominations.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint public g = 1.5 gwei;
+    uint public e = 1.5 ether;
+    uint public m = 1.5 minutes;
+    uint public h = 1.5 hours;
+    uint public d = 1.5 days;
+    uint public w = 1.5 weeks;
+}
+// ----
+// g() -> 1500000000
+// e() -> 1500000000000000000
+// m() -> 90
+// h() -> 5400
+// d() -> 129600
+// w() -> 907200
diff --git a/compiler/test/libsolidity/semanticTests/literals/gwei.sol b/compiler/test/libsolidity/semanticTests/literals/gwei.sol
new file mode 100644
index 00000000..bb8cc6ab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/gwei.sol
@@ -0,0 +1,7 @@
+contract C {
+	uint constant x = 1 gwei;
+
+	function f() public view returns(uint) { return x; }
+}
+// ----
+// f() -> 1000000000
diff --git a/compiler/test/libsolidity/semanticTests/literals/hex_string_with_non_printable_characters.sol b/compiler/test/libsolidity/semanticTests/literals/hex_string_with_non_printable_characters.sol
new file mode 100644
index 00000000..3edd6049
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/hex_string_with_non_printable_characters.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (bytes32 result) {
+        assembly {
+            result := hex"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
+        }
+    }
+}
+// ----
+// f() -> 0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
diff --git a/compiler/test/libsolidity/semanticTests/literals/hex_string_with_underscore.sol b/compiler/test/libsolidity/semanticTests/literals/hex_string_with_underscore.sol
new file mode 100644
index 00000000..db7f70f8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/hex_string_with_underscore.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public pure returns(bytes memory) {
+        return hex"12_34_5678_9A";
+    }
+}
+// ----
+// f() -> 32, 5, left(0x123456789A)
diff --git a/compiler/test/libsolidity/semanticTests/literals/scientific_notation.sol b/compiler/test/libsolidity/semanticTests/literals/scientific_notation.sol
new file mode 100644
index 00000000..5e0d8014
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/scientific_notation.sol
@@ -0,0 +1,32 @@
+contract C {
+    function f() public returns(uint) {
+        return 2e10 wei;
+    }
+
+    function g() public returns(uint) {
+        return 200e-2 wei;
+    }
+
+    function h() public returns(uint) {
+        return 2.5e1;
+    }
+
+    function i() public returns(int) {
+        return -2e10;
+    }
+
+    function j() public returns(int) {
+        return -200e-2;
+    }
+
+    function k() public returns(int) {
+        return -2.5e1;
+    }
+}
+// ----
+// f() -> 20000000000
+// g() -> 2
+// h() -> 25
+// i() -> -20000000000
+// j() -> -2
+// k() -> -25
diff --git a/compiler/test/libsolidity/semanticTests/literals/wei.sol b/compiler/test/libsolidity/semanticTests/literals/wei.sol
new file mode 100644
index 00000000..08bba771
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/literals/wei.sol
@@ -0,0 +1,7 @@
+contract C {
+	uint constant x = 1 wei;
+
+	function f() public view returns(uint) { return x; }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol b/compiler/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol
new file mode 100644
index 00000000..d2ed3575
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/memoryManagement/assembly_access.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public pure {
+        uint[] memory x;
+        uint y;
+        assembly {
+            y := x
+        }
+        // The value of an uninitialized dynamic array is not zero but rather
+        // an address of a location in memory that has the value of zero.
+        assert(y != 0);
+    }
+}
+// ----
+// f() ->
diff --git a/compiler/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol b/compiler/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol
new file mode 100644
index 00000000..5b471e1a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/memoryManagement/struct_allocation.sol
@@ -0,0 +1,22 @@
+contract C {
+    struct S { uint x; uint y; uint z; }
+    function memorySize() internal pure returns (uint s) {
+        assembly { s := mload(0x40) }
+    }
+    function withValue() public pure returns (uint) {
+        S memory x = S(1, 2, 3);
+        uint memorySizeBefore = memorySize();
+        S memory t = x;
+        uint memorySizeAfter = memorySize();
+        return memorySizeAfter - memorySizeBefore;
+    }
+    function withoutValue() public pure returns (uint) {
+        uint memorySizeBefore = memorySize();
+        S memory t;
+        uint memorySizeAfter = memorySize();
+        return memorySizeAfter - memorySizeBefore;
+    }
+}
+// ----
+// withValue() -> 0x00
+// withoutValue() -> 0x60
diff --git a/compiler/test/libsolidity/semanticTests/metaTypes/name_other_contract.sol b/compiler/test/libsolidity/semanticTests/metaTypes/name_other_contract.sol
new file mode 100644
index 00000000..efdaedf5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/metaTypes/name_other_contract.sol
@@ -0,0 +1,28 @@
+abstract contract A {
+    function f() virtual public pure;
+}
+
+interface I {
+    function f() external pure;
+}
+
+contract C {
+    function f() pure public {
+    }
+}
+
+contract Test is C {
+    function c() public pure returns (string memory) {
+        return type(C).name;
+    }
+    function a() public pure returns (string memory) {
+        return type(A).name;
+    }
+    function i() public pure returns (string memory) {
+        return type(I).name;
+    }
+}
+// ----
+// c() -> 0x20, 1, "C"
+// a() -> 0x20, 1, "A"
+// i() -> 0x20, 1, "I"
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/access_through_contract_name.sol b/compiler/test/libsolidity/semanticTests/modifiers/access_through_contract_name.sol
new file mode 100644
index 00000000..4d1538d7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/access_through_contract_name.sol
@@ -0,0 +1,22 @@
+contract A {
+    uint public x = 7;
+    modifier m virtual { x = 2; _; }
+}
+contract C is A {
+    modifier m override { x = 1; _; }
+
+    function f() public A.m returns (uint) {
+        return 9;
+    }
+    function g() public m returns (uint) {
+        return 10;
+    }
+}
+// ----
+// x() -> 7
+// f() -> 9
+// x() -> 2
+// g() -> 0x0a
+// x() -> 1
+// f() -> 9
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/access_through_module_name.sol b/compiler/test/libsolidity/semanticTests/modifiers/access_through_module_name.sol
new file mode 100644
index 00000000..58c60014
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/access_through_module_name.sol
@@ -0,0 +1,25 @@
+==== Source: a ====
+import "a" as M;
+contract C {
+    uint public x;
+    modifier m { x = 1; _; }
+
+    function f() public M.M.C.m returns (uint t, uint r) {
+        t = x;
+        x = 3;
+        r = 9;
+    }
+    function g() public m returns (uint t, uint r) {
+        t = x;
+        x = 4;
+        r = 10;
+    }
+}
+// ----
+// x() -> 0x00
+// f() -> 1, 9
+// x() -> 3
+// g() -> 1, 0x0a
+// x() -> 4
+// f() -> 1, 9
+// x() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/break_in_modifier.sol b/compiler/test/libsolidity/semanticTests/modifiers/break_in_modifier.sol
new file mode 100644
index 00000000..67fc0e6b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/break_in_modifier.sol
@@ -0,0 +1,20 @@
+contract C {
+    uint256 public x;
+    modifier run() {
+        for (uint256 i = 0; i < 10; i++) {
+            _;
+            if (i == 1)
+                break;
+        }
+    }
+
+    function f() public run {
+        uint256 k = x;
+        uint256 t = k + 1;
+        x = t;
+    }
+}
+// ----
+// x() -> 0
+// f() ->
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/continue_in_modifier.sol b/compiler/test/libsolidity/semanticTests/modifiers/continue_in_modifier.sol
new file mode 100644
index 00000000..2879c55e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/continue_in_modifier.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint256 public x;
+    modifier run() {
+        for (uint256 i = 0; i < 10; i++) {
+            if (i % 2 == 1) continue;
+            _;
+        }
+    }
+
+    function f() public run {
+        uint256 k = x;
+        uint256 t = k + 1;
+        x = t;
+    }
+}
+// ----
+// x() -> 0
+// f() ->
+// x() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier.sol
new file mode 100644
index 00000000..e1978ba8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier.sol
@@ -0,0 +1,12 @@
+contract C {
+    function getOne() public payable nonFree returns (uint256 r) {
+        return 1;
+    }
+
+    modifier nonFree {
+        if (msg.value > 0) _;
+    }
+}
+// ----
+// getOne() -> 0
+// getOne(), 1 wei -> 1
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_calling_functions_in_creation_context.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_calling_functions_in_creation_context.sol
new file mode 100644
index 00000000..bae50325
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_calling_functions_in_creation_context.sol
@@ -0,0 +1,48 @@
+contract A {
+    uint256 data;
+
+    constructor() mod1 {
+        f1();
+    }
+
+    function f1() public mod2 {
+        data |= 0x1;
+    }
+
+    function f2() public {
+        data |= 0x20;
+    }
+
+    function f3() public virtual {}
+
+    modifier mod1 virtual {
+        f2();
+        _;
+    }
+    modifier mod2 {
+        f3();
+        if (false) _;
+    }
+
+    function getData() public returns (uint256 r) {
+        return data;
+    }
+}
+
+
+contract C is A {
+    modifier mod1 override {
+        f4();
+        _;
+    }
+
+    function f3() public override {
+        data |= 0x300;
+    }
+
+    function f4() public {
+        data |= 0x4000;
+    }
+}
+// ----
+// getData() -> 0x4300
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_empty.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_empty.sol
new file mode 100644
index 00000000..16cbad1a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_empty.sol
@@ -0,0 +1,16 @@
+abstract contract A {
+    function f() public mod returns (bool r) {
+        return true;
+    }
+
+    modifier mod virtual;
+}
+
+
+contract C is A {
+    modifier mod override {
+        if (false) _;
+    }
+}
+// ----
+// f() -> false
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_for_constructor.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_for_constructor.sol
new file mode 100644
index 00000000..f32a2381
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_for_constructor.sol
@@ -0,0 +1,26 @@
+contract A {
+    uint256 data;
+
+    constructor() mod1 {
+        data |= 2;
+    }
+
+    modifier mod1 virtual {
+        data |= 1;
+        _;
+    }
+
+    function getData() public returns (uint256 r) {
+        return data;
+    }
+}
+
+
+contract C is A {
+    modifier mod1 override {
+        data |= 4;
+        _;
+    }
+}
+// ----
+// getData() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library.sol
new file mode 100644
index 00000000..c50fb5dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library.sol
@@ -0,0 +1,27 @@
+library L {
+    struct S {
+        uint256 v;
+    }
+    modifier mod(S storage s) {
+        s.v++;
+        _;
+    }
+
+    function libFun(S storage s) internal mod(s) {
+        s.v += 0x100;
+    }
+}
+
+
+contract Test {
+    using L for *;
+    L.S s;
+
+    function f() public returns (uint256) {
+        s.libFun();
+        L.libFun(s);
+        return s.v;
+    }
+}
+// ----
+// f() -> 0x202
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library_inheritance.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library_inheritance.sol
new file mode 100644
index 00000000..e87ac7a4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_library_inheritance.sol
@@ -0,0 +1,33 @@
+// Tests that virtual lookup for modifiers in libraries does not consider
+// the current inheritance hierarchy.
+library L {
+    struct S {
+        uint256 v;
+    }
+    modifier mod(S storage s) {
+        s.v++;
+        _;
+    }
+
+    function libFun(S storage s) internal mod(s) {
+        s.v += 0x100;
+    }
+}
+
+
+contract Test {
+    using L for *;
+    L.S s;
+    modifier mod(L.S storage) {
+        revert();
+        _;
+    }
+
+    function f() public returns (uint256) {
+        s.libFun();
+        L.libFun(s);
+        return s.v;
+    }
+}
+// ----
+// f() -> 0x202
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_local_variables.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_local_variables.sol
new file mode 100644
index 00000000..c3b10475
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_local_variables.sol
@@ -0,0 +1,18 @@
+contract C {
+    modifier mod1 {
+        uint8 a = 1;
+        uint8 b = 2;
+        _;
+    }
+    modifier mod2(bool a) {
+        if (a) return;
+        else _;
+    }
+
+    function f(bool a) public mod1 mod2(a) returns (uint256 r) {
+        return 3;
+    }
+}
+// ----
+// f(bool): true -> 0
+// f(bool): false -> 3
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_loop_viair.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_loop_viair.sol
new file mode 100644
index 00000000..81caba76
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_loop_viair.sol
@@ -0,0 +1,14 @@
+contract C {
+    modifier repeat(uint256 count) {
+        uint256 i;
+        for (i = 0; i < count; ++i) _;
+    }
+
+    function f() public repeat(10) returns (uint256 r) {
+        r += 1;
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multi_invocation_viair.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multi_invocation_viair.sol
new file mode 100644
index 00000000..929b006e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multi_invocation_viair.sol
@@ -0,0 +1,15 @@
+contract C {
+    modifier repeat(bool twice) {
+        if (twice) _;
+        _;
+    }
+
+    function f(bool twice) public repeat(twice) returns (uint256 r) {
+        r += 1;
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f(bool): false -> 1
+// f(bool): true -> 1
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times.sol
new file mode 100644
index 00000000..5cda8b6d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint256 public a;
+    modifier mod(uint256 x) {
+        a += x;
+        _;
+    }
+
+    function f(uint256 x) public mod(2) mod(5) mod(x) returns (uint256) {
+        return a;
+    }
+}
+// ----
+// f(uint256): 3 -> 10
+// a() -> 10
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times_local_vars.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times_local_vars.sol
new file mode 100644
index 00000000..780b5a36
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_multiple_times_local_vars.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint256 public a;
+    modifier mod(uint256 x) {
+        uint256 b = x;
+        a += b;
+        _;
+        a -= b;
+        assert(b == x);
+    }
+
+    function f(uint256 x) public mod(2) mod(5) mod(x) returns (uint256) {
+        return a;
+    }
+}
+// ----
+// f(uint256): 3 -> 10
+// a() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_overriding.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_overriding.sol
new file mode 100644
index 00000000..16d6b821
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_modifier_overriding.sol
@@ -0,0 +1,18 @@
+contract A {
+    function f() public mod returns (bool r) {
+        return true;
+    }
+
+    modifier mod virtual {
+        _;
+    }
+}
+
+
+contract C is A {
+    modifier mod override {
+        if (false) _;
+    }
+}
+// ----
+// f() -> false
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter.sol
new file mode 100644
index 00000000..ecc7851b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter.sol
@@ -0,0 +1,8 @@
+// The IR of this contract used to throw
+contract B {
+    function f(uint8 a) mod1(a, true) mod2(r) pure public returns (bytes7 r) { }
+    modifier mod1(uint a, bool b) { if (b) _; }
+    modifier mod2(bytes7 a) { while (a == "1234567") _; }
+}
+// ----
+// f(uint8): 5 -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter_complex.sol b/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter_complex.sol
new file mode 100644
index 00000000..530fadf6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/function_return_parameter_complex.sol
@@ -0,0 +1,36 @@
+// Test to see if the function return parameter, when forwarded to the modifier actually has value
+// zero.
+contract A {
+    uint public x = 0;
+
+    modifier alwaysZeros(uint256 a, uint256 b) {
+        x++;
+        _;
+        require(a == 0, "a is not zero");
+        require(b == 0, "b is not zero");
+    }
+
+    function f() public alwaysZeros(r1, r3) returns(uint r1, uint r2, uint r3) {
+        r1 = 16;
+        r2 = 32;
+        r3 = 64;
+    }
+
+    function shouldFail(uint i1) public alwaysZeros(i1, r + 20) returns (uint r) {
+        r = 0;
+    }
+
+    // The value of x would be 1 before calling this. It gets incremented four times in total during
+    // the modifier calls
+    function g() alwaysZeros(r, r) alwaysZeros(r, r) alwaysZeros(r + r, r - r) alwaysZeros(r * r, r & r) public returns (uint r) {
+        r = x;
+    }
+}
+// ----
+// f() -> 0x10, 0x20, 0x40
+// x() -> 1
+// shouldFail(uint256): 1 -> FAILURE, hex"08c379a0", 0x20, 13, "a is not zero"
+// shouldFail(uint256): 0 -> FAILURE, hex"08c379a0", 0x20, 13, "b is not zero"
+// x() -> 1
+// g() -> 5
+// x() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/modifer_recursive.sol b/compiler/test/libsolidity/semanticTests/modifiers/modifer_recursive.sol
new file mode 100644
index 00000000..a69a26f5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/modifer_recursive.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint public called;
+    modifier mod1 {
+        called++;
+        _;
+    }
+    function f(uint x) public mod1 returns (uint256 r) {
+        return x == 0 ? 2 : f(x - 1)**2;
+    }
+}
+// ----
+// called() -> 0x00
+// f(uint256): 5 -> 0x0100000000
+// called() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/modifier_in_constructor_ice.sol b/compiler/test/libsolidity/semanticTests/modifiers/modifier_in_constructor_ice.sol
new file mode 100644
index 00000000..136743d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/modifier_in_constructor_ice.sol
@@ -0,0 +1,5 @@
+// The IR of this contract used to throw
+contract A { modifier m1{_;} }
+contract B is A { constructor() A() m1{} }
+// ----
+// constructor() ->
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/modifier_init_return.sol b/compiler/test/libsolidity/semanticTests/modifiers/modifier_init_return.sol
new file mode 100644
index 00000000..d4c72e16
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/modifier_init_return.sol
@@ -0,0 +1,12 @@
+contract C {
+    modifier m(bool condition) {
+        if (condition) _;
+    }
+
+    function f(uint x) public m(x >= 10) returns (uint[5] memory r) {
+        r[2] = 3;
+    }
+}
+// ----
+// f(uint256): 9 -> 0x00, 0x00, 0x00, 0x00, 0x00
+// f(uint256): 10 -> 0x00, 0x00, 3, 0x00, 0x00
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/modifiers_in_construction_context.sol b/compiler/test/libsolidity/semanticTests/modifiers/modifiers_in_construction_context.sol
new file mode 100644
index 00000000..30cce5a7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/modifiers_in_construction_context.sol
@@ -0,0 +1,11 @@
+// The IR of this contract used to throw
+contract A {
+  constructor() m1 { }
+  modifier m1 { _; }
+}
+contract B is A {
+  modifier m2 { _; }
+  constructor() A() m1 m2 {  }
+}
+// ----
+// constructor() ->
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/return_does_not_skip_modifier.sol b/compiler/test/libsolidity/semanticTests/modifiers/return_does_not_skip_modifier.sol
new file mode 100644
index 00000000..0d9bbfe3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/return_does_not_skip_modifier.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint256 public x;
+    modifier setsx {
+        _;
+        x = 9;
+    }
+
+    function f() public setsx returns (uint256) {
+        return 2;
+    }
+}
+// ----
+// x() -> 0
+// f() -> 2
+// x() -> 9
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/return_in_modifier.sol b/compiler/test/libsolidity/semanticTests/modifiers/return_in_modifier.sol
new file mode 100644
index 00000000..00e2bb32
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/return_in_modifier.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint256 public x;
+    modifier run() {
+        for (uint256 i = 1; i < 10; i++) {
+            if (i == 5) return;
+            _;
+        }
+    }
+
+    function f() public run {
+        uint256 k = x;
+        uint256 t = k + 1;
+        x = t;
+    }
+}
+// ----
+// x() -> 0
+// f() ->
+// x() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/modifiers/stacked_return_with_modifiers.sol b/compiler/test/libsolidity/semanticTests/modifiers/stacked_return_with_modifiers.sol
new file mode 100644
index 00000000..616a2183
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/modifiers/stacked_return_with_modifiers.sol
@@ -0,0 +1,21 @@
+contract C {
+    uint256 public x;
+    modifier m() {
+        for (uint256 i = 0; i < 10; i++) {
+            _;
+            ++x;
+            return;
+        }
+    }
+
+    function f() public m m m returns (uint) {
+        for (uint256 i = 0; i < 10; i++) {
+            ++x;
+            return 42;
+        }
+    }
+}
+// ----
+// x() -> 0
+// f() -> 42
+// x() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/circular_import.sol b/compiler/test/libsolidity/semanticTests/multiSource/circular_import.sol
new file mode 100644
index 00000000..4c4ba4b2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/circular_import.sol
@@ -0,0 +1,13 @@
+==== Source: s1.sol ====
+import {f as g} from "s2.sol";
+function f() pure returns (uint) { return 1; }
+==== Source: s2.sol ====
+import {f as g} from "s1.sol";
+function f() pure returns (uint) { return 2; }
+contract C {
+  function foo() public pure returns (uint) {
+    return f() - g();
+  }
+}
+// ----
+// foo() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/circular_import_2.sol b/compiler/test/libsolidity/semanticTests/multiSource/circular_import_2.sol
new file mode 100644
index 00000000..63962937
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/circular_import_2.sol
@@ -0,0 +1,14 @@
+==== Source: s1.sol ====
+import {f as g, g as h} from "s2.sol";
+function f() pure returns (uint) { return 1000 + g() - h(); }
+==== Source: s2.sol ====
+import {f as h} from "s1.sol";
+function f() pure returns (uint) { return 2; }
+function g() pure returns (uint) { return 4; }
+contract C {
+  function foo() public pure returns (uint) {
+    return h() - f() - g();
+  }
+}
+// ----
+// foo() -> 992
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport.sol b/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport.sol
new file mode 100644
index 00000000..a866b0f5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+import {f as g, g as h} from "s2.sol";
+function f() pure returns (uint) { return 100 + h() - g(); }
+==== Source: s2.sol ====
+import {f as h} from "s1.sol";
+function f() pure returns (uint) { return 2; }
+function g() pure returns (uint) { return 4; }
+==== Source: s3.sol ====
+import "s1.sol";
+contract C {
+  function foo() public pure returns (uint) {
+    return f() - g() - h();
+  }
+}
+// ----
+// foo() -> 0x60
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport_2.sol b/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport_2.sol
new file mode 100644
index 00000000..3ff3a1a6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/circular_reimport_2.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+import {f as g, g as h} from "s2.sol";
+function f() pure returns (uint) { return 1000 + h() - g(); }
+==== Source: s2.sol ====
+import {f as h} from "s1.sol";
+function f() pure returns (uint) { return 2; }
+function g() pure returns (uint) { return 4; }
+==== Source: s3.sol ====
+import "s2.sol";
+contract C {
+  function foo() public pure returns (uint) {
+    return 10000 + f() - g() - h();
+  }
+}
+// ----
+// foo() -> 0x2324
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_different_interger_types.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_different_interger_types.sol
new file mode 100644
index 00000000..a103ef07
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_different_interger_types.sol
@@ -0,0 +1,12 @@
+==== Source: s1.sol ====
+function f(uint24) pure returns (uint) { return 24; }
+function g(bool) pure returns (bool) { return true; }
+==== Source: s2.sol ====
+import {f as g, g as g} from "s1.sol";
+contract C {
+  function foo() public pure returns (uint, bool) {
+    return (g(2), g(false));
+  }
+}
+// ----
+// foo() -> 24, true
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_base_contract.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_base_contract.sol
new file mode 100644
index 00000000..321e16ae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_base_contract.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure returns (uint) {
+    return f();
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol";
+contract D is C {
+  function h() public pure returns (uint) {
+    return g();
+  }
+}
+// ----
+// h() -> 1337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual.sol
new file mode 100644
index 00000000..f111273d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure virtual returns (uint) {
+    return f() + 1;
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol";
+contract D is C {
+  function g() public pure override returns (uint) {
+    return f();
+  }
+}
+// ----
+// g() -> 1337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_super.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_super.sol
new file mode 100644
index 00000000..ae802d7c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_super.sol
@@ -0,0 +1,16 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure virtual returns (uint) {
+    return f();
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol";
+contract D is C {
+  function g() public pure override returns (uint) {
+    return super.g();
+  }
+}
+// ----
+// g() -> 1337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_transitive.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_transitive.sol
new file mode 100644
index 00000000..71723f0f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_function_resolution_override_virtual_transitive.sol
@@ -0,0 +1,23 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure virtual returns (uint) {
+    return f();
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol";
+contract D is C {
+  function g() public pure virtual override returns (uint) {
+    return super.g() + 1;
+  }
+}
+==== Source: s3.sol ====
+import "s2.sol";
+contract E is D {
+  function g() public pure override returns (uint) {
+    return super.g() + 1;
+  }
+}
+// ----
+// g() -> 1339
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/free_function_transitive_import.sol b/compiler/test/libsolidity/semanticTests/multiSource/free_function_transitive_import.sol
new file mode 100644
index 00000000..dec4c3f2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/free_function_transitive_import.sol
@@ -0,0 +1,24 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure returns (uint) {
+    return f();
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol";
+contract D is C {
+  function h() public pure returns (uint) {
+    return g();
+  }
+}
+==== Source: s3.sol ====
+import "s2.sol";
+import {f as f} from "s2.sol";
+contract E is D {
+  function i() public pure returns (uint) {
+    return f();
+  }
+}
+// ----
+// i() -> 1337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/import.sol b/compiler/test/libsolidity/semanticTests/multiSource/import.sol
new file mode 100644
index 00000000..2a0f43d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/import.sol
@@ -0,0 +1,12 @@
+==== Source: A ====
+contract A {
+	function g(uint256 x) public view returns(uint256) { return x + 1; }
+}
+==== Source: B ====
+import "A";
+contract B is A {
+	function f(uint256 x) public view returns(uint256) { return x; }
+}
+// ----
+// f(uint256): 1337 -> 1337
+// g(uint256): 1337 -> 1338
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias.sol b/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias.sol
new file mode 100644
index 00000000..c5769367
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias.sol
@@ -0,0 +1,17 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+contract C {
+  function g() public pure virtual returns (uint) {
+    return f();
+  }
+}
+==== Source: s2.sol ====
+import "s1.sol" as M;
+function f() pure returns (uint) { return 6; }
+contract D is M.C {
+  function g() public pure override returns (uint) {
+    return super.g() + f() * 10000;
+  }
+}
+// ----
+// g() -> 61337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias_direct_call.sol b/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias_direct_call.sol
new file mode 100644
index 00000000..a5f43f8b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/imported_free_function_via_alias_direct_call.sol
@@ -0,0 +1,12 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+==== Source: s2.sol ====
+import {f as g} from "s1.sol";
+function f() pure returns (uint) { return 6; }
+contract D {
+  function h() public pure returns (uint) {
+    return g() + f() * 10000;
+  }
+}
+// ----
+// h() -> 61337
diff --git a/compiler/test/libsolidity/semanticTests/multiSource/reimport_imported_function.sol b/compiler/test/libsolidity/semanticTests/multiSource/reimport_imported_function.sol
new file mode 100644
index 00000000..02b48214
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/multiSource/reimport_imported_function.sol
@@ -0,0 +1,13 @@
+==== Source: s1.sol ====
+function f() pure returns (uint) { return 1337; }
+==== Source: s2.sol ====
+import {f as g} from "s1.sol";
+==== Source: s3.sol ====
+import {g as h} from "s2.sol";
+contract C {
+  function foo() public pure returns (uint) {
+    return h();
+  }
+}
+// ----
+// foo() -> 1337
diff --git a/compiler/test/libsolidity/semanticTests/operators/compound_assign.sol b/compiler/test/libsolidity/semanticTests/operators/compound_assign.sol
new file mode 100644
index 00000000..ed91f3b6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/compound_assign.sol
@@ -0,0 +1,20 @@
+contract test {
+	uint value1;
+	uint value2;
+	function f(uint x, uint y) public returns (uint w) {
+		uint value3 = y;
+		value1 += x;
+		value3 *= x;
+		value2 *= value3 + value1;
+		return value2 += 7;
+	}
+}
+// ----
+// f(uint256,uint256): 0, 6 -> 7
+// f(uint256,uint256): 1, 3 -> 0x23
+// f(uint256,uint256): 2, 25 -> 0x0746
+// f(uint256,uint256): 3, 69 -> 396613
+// f(uint256,uint256): 4, 84 -> 137228105
+// f(uint256,uint256): 5, 2 -> 0xcc7c5e28
+// f(uint256,uint256): 6, 51 -> 1121839760671
+// f(uint256,uint256): 7, 48 -> 408349672884251
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_bytes_cleanup_viaYul.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_bytes_cleanup_viaYul.sol
new file mode 100644
index 00000000..36b6e8b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_bytes_cleanup_viaYul.sol
@@ -0,0 +1,19 @@
+contract C {
+	function l(uint8 y) public returns (bytes20) {
+		bytes20 x;
+		assembly { x := "12345678901234567890abcde" }
+		// When compiling via IR, `x` is truncated before applying
+		// the operation.
+		return x << y;
+	}
+	function r(uint8 y) public returns (bytes20) {
+		bytes20 x;
+		assembly { x := "12345678901234567890abcde" }
+		return x >> y;
+	}
+}
+// ====
+// compileViaYul: true
+// ----
+// l(uint8): 64 -> 0x3930313233343536373839300000000000000000000000000000000000000000
+// r(uint8): 64 -> 0x313233343536373839303132000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup.sol
new file mode 100644
index 00000000..0adc5ae5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public returns (uint16 x) {
+        unchecked {
+            x = 0xffff;
+            x += 32;
+            x <<= 8;
+            x >>= 16;
+        }
+    }
+}
+// ----
+// f() -> 0x0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup_garbled.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup_garbled.sol
new file mode 100644
index 00000000..452884f2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_cleanup_garbled.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public returns (uint8 x) {
+        assembly {
+            x := 0xffff
+        }
+        x >>= 8;
+    }
+}
+// ----
+// f() -> 0x0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left.sol
new file mode 100644
index 00000000..bc0c9f48
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint256 public a = 0x42 << 8;
+}
+// ----
+// a() -> 0x4200
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left_assignment.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left_assignment.sol
new file mode 100644
index 00000000..3d245e9b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_left_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public returns (uint256 a) {
+        a = 0x42;
+        a <<= 8;
+    }
+}
+// ----
+// f() -> 0x4200
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right.sol
new file mode 100644
index 00000000..64403475
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint256 public a = 0x4200 >> 8;
+}
+// ----
+// a() -> 0x42
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right_assignment.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right_assignment.sol
new file mode 100644
index 00000000..ded331a7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_constant_right_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public returns (uint256 a) {
+        a = 0x4200;
+        a >>= 8;
+    }
+}
+// ----
+// f() -> 0x42
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left.sol
new file mode 100644
index 00000000..47afab5e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint256 a, uint256 b) public returns (uint256) {
+        return a << b;
+    }
+}
+// ----
+// f(uint256,uint256): 0x4266, 0x0 -> 0x4266
+// f(uint256,uint256): 0x4266, 0x8 -> 0x426600
+// f(uint256,uint256): 0x4266, 0x10 -> 0x42660000
+// f(uint256,uint256): 0x4266, 0x11 -> 0x84cc0000
+// f(uint256,uint256): 0x4266, 0xf0 -> 0x4266000000000000000000000000000000000000000000000000000000000000
+// f(uint256,uint256): 0x4266, 0x100 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment.sol
new file mode 100644
index 00000000..afa82c6f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f(uint256 a, uint256 b) public returns (uint256) {
+        a <<= b;
+        return a;
+    }
+}
+// ----
+// f(uint256,uint256): 0x4266, 0x0 -> 0x4266
+// f(uint256,uint256): 0x4266, 0x8 -> 0x426600
+// f(uint256,uint256): 0x4266, 0x10 -> 0x42660000
+// f(uint256,uint256): 0x4266, 0x11 -> 0x84cc0000
+// f(uint256,uint256): 0x4266, 0xf0 -> 0x4266000000000000000000000000000000000000000000000000000000000000
+// f(uint256,uint256): 0x4266, 0x100 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment_different_type.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment_different_type.sol
new file mode 100644
index 00000000..44fd4a92
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_assignment_different_type.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint256 a, uint8 b) public returns (uint256) {
+        a <<= b;
+        return a;
+    }
+}
+// ----
+// f(uint256,uint8): 0x4266, 0x0 -> 0x4266
+// f(uint256,uint8): 0x4266, 0x8 -> 0x426600
+// f(uint256,uint8): 0x4266, 0x10 -> 0x42660000
+// f(uint256,uint8): 0x4266, 0x11 -> 0x84cc0000
+// f(uint256,uint8): 0x4266, 0xf0 -> 0x4266000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_larger_type.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_larger_type.sol
new file mode 100644
index 00000000..3d6d7c7e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_larger_type.sol
@@ -0,0 +1,10 @@
+// This basically tests proper cleanup and conversion. It should not convert x to int8.
+contract C {
+    function f() public returns (int8) {
+        uint8 x = 254;
+        int8 y = 1;
+        return y << x;
+    }
+}
+// ----
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint32.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint32.sol
new file mode 100644
index 00000000..d66e2f4c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint32.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(uint32 a, uint32 b) public returns (uint256) {
+        return a << b;
+    }
+}
+// ----
+// f(uint32,uint32): 0x4266, 0x0 -> 0x4266
+// f(uint32,uint32): 0x4266, 0x8 -> 0x426600
+// f(uint32,uint32): 0x4266, 0x10 -> 0x42660000
+// f(uint32,uint32): 0x4266, 0x11 -> 0x84cc0000
+// f(uint32,uint32): 0x4266, 0x20 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint8.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint8.sol
new file mode 100644
index 00000000..d6d6d77b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_left_uint8.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint8 a, uint8 b) public returns (uint256) {
+        return a << b;
+    }
+}
+// ----
+// f(uint8,uint8): 0x66, 0x0 -> 0x66
+// f(uint8,uint8): 0x66, 0x8 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_left.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_left.sol
new file mode 100644
index 00000000..7671ce19
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_left.sol
@@ -0,0 +1,5 @@
+contract C {
+    int256 public a = -0x42 << 8;
+}
+// ----
+// a() -> -16896
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_right.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_right.sol
new file mode 100644
index 00000000..e9a76d2c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_negative_constant_right.sol
@@ -0,0 +1,5 @@
+contract C {
+    int256 public a = -0x4200 >> 8;
+}
+// ----
+// a() -> -66
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_overflow.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_overflow.sol
new file mode 100644
index 00000000..5b0491b3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_overflow.sol
@@ -0,0 +1,15 @@
+contract C {
+    function leftU(uint8 x, uint8 y) public returns (uint8) {
+        return x << y;
+    }
+
+    function leftS(int8 x, uint8 y) public returns (int8) {
+        return x << y;
+    }
+}
+// ----
+// leftU(uint8,uint8): 255, 8 -> 0
+// leftU(uint8,uint8): 255, 1 -> 254
+// leftU(uint8,uint8): 255, 0 -> 255
+// leftS(int8,uint8): 1, 7 -> -128 # Result is -128 and output is sign-extended, not zero-padded. #
+// leftS(int8,uint8): 1, 6 -> 64
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right.sol
new file mode 100644
index 00000000..4947b21d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(uint256 a, uint256 b) public returns (uint256) {
+        return a >> b;
+    }
+}
+// ----
+// f(uint256,uint256): 0x4266, 0x0 -> 0x4266
+// f(uint256,uint256): 0x4266, 0x8 -> 0x42
+// f(uint256,uint256): 0x4266, 0x10 -> 0
+// f(uint256,uint256): 0x4266, 0x11 -> 0
+// f(uint256,uint256): 57896044618658097711785492504343953926634992332820282019728792003956564819968, 5 -> 1809251394333065553493296640760748560207343510400633813116524750123642650624
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_assignment.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_assignment.sol
new file mode 100644
index 00000000..f9206b09
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_assignment.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(uint256 a, uint256 b) public returns (uint256) {
+        a >>= b;
+        return a;
+    }
+}
+// ----
+// f(uint256,uint256): 0x4266, 0x0 -> 0x4266
+// f(uint256,uint256): 0x4266, 0x8 -> 0x42
+// f(uint256,uint256): 0x4266, 0x10 -> 0
+// f(uint256,uint256): 0x4266, 0x11 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol
new file mode 100644
index 00000000..2b1afb52
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_signed_v2.sol
@@ -0,0 +1,31 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(int8 a, uint8 b) public returns (int256) {
+        assembly {
+            a := 0xfffffff0
+        }
+        // Higher bits should be signextended before the shift
+        return a >> b;
+    }
+
+    function g(int8 a, uint8 b) public returns (int256) {
+        assembly {
+            a := 0xf0
+        }
+        // Higher bits should be signextended before the shift
+        return a >> b;
+    }
+}
+// ----
+// f(int8,uint8): 0x00, 0x03 -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
+// f(int8,uint8): 0x00, 0x04 -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// f(int8,uint8): 0x00, 0xff -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// f(int8,uint8): 0x00, 0x1003 -> FAILURE
+// f(int8,uint8): 0x00, 0x1004 -> FAILURE
+// g(int8,uint8): 0x00, 0x03 -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
+// g(int8,uint8): 0x00, 0x04 -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// g(int8,uint8): 0x00, 0xff -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// g(int8,uint8): 0x00, 0x1003 -> FAILURE
+// g(int8,uint8): 0x00, 0x1004 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol
new file mode 100644
index 00000000..8cf89f4b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_garbled_v2.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(uint8 a, uint8 b) public returns (uint256) {
+        assembly {
+            a := 0xffffffff
+        }
+        // Higher bits should be cleared before the shift
+        return a >> b;
+    }
+}
+// ----
+// f(uint8,uint8): 0x00, 0x04 -> 0x0f
+// f(uint8,uint8): 0x00, 0x1004 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_literal.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_literal.sol
new file mode 100644
index 00000000..e24118af
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_literal.sol
@@ -0,0 +1,62 @@
+contract C {
+    function f1() public pure returns (bool) {
+        return (-4266 >> 0) == -4266;
+    }
+
+    function f2() public pure returns (bool) {
+        return (-4266 >> 1) == -2133;
+    }
+
+    function f3() public pure returns (bool) {
+        return (-4266 >> 4) == -267;
+    }
+
+    function f4() public pure returns (bool) {
+        return (-4266 >> 8) == -17;
+    }
+
+    function f5() public pure returns (bool) {
+        return (-4266 >> 16) == -1;
+    }
+
+    function f6() public pure returns (bool) {
+        return (-4266 >> 17) == -1;
+    }
+
+    function g1() public pure returns (bool) {
+        return (-4267 >> 0) == -4267;
+    }
+
+    function g2() public pure returns (bool) {
+        return (-4267 >> 1) == -2134;
+    }
+
+    function g3() public pure returns (bool) {
+        return (-4267 >> 4) == -267;
+    }
+
+    function g4() public pure returns (bool) {
+        return (-4267 >> 8) == -17;
+    }
+
+    function g5() public pure returns (bool) {
+        return (-4267 >> 16) == -1;
+    }
+
+    function g6() public pure returns (bool) {
+        return (-4267 >> 17) == -1;
+    }
+}
+// ----
+// f1() -> true
+// f2() -> true
+// f3() -> true
+// f4() -> true
+// f5() -> true
+// f6() -> true
+// g1() -> true
+// g2() -> true
+// g3() -> true
+// g4() -> true
+// g5() -> true
+// g6() -> true
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue.sol
new file mode 100644
index 00000000..5dcde06f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f(int256 a, uint256 b) public returns (int256) {
+        return a >> b;
+    }
+}
+// ----
+// f(int256,uint256): -4266, 0 -> -4266
+// f(int256,uint256): -4266, 1 -> -2133
+// f(int256,uint256): -4266, 4 -> -267
+// f(int256,uint256): -4266, 8 -> -17
+// f(int256,uint256): -4266, 16 -> -1
+// f(int256,uint256): -4266, 17 -> -1
+// f(int256,uint256): -4267, 0 -> -4267
+// f(int256,uint256): -4267, 1 -> -2134
+// f(int256,uint256): -4267, 4 -> -267
+// f(int256,uint256): -4267, 8 -> -17
+// f(int256,uint256): -4267, 16 -> -1
+// f(int256,uint256): -4267, 17 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_assignment.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_assignment.sol
new file mode 100644
index 00000000..00ac9662
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_assignment.sol
@@ -0,0 +1,19 @@
+contract C {
+    function f(int256 a, uint256 b) public returns (int256) {
+        a >>= b;
+        return a;
+    }
+}
+// ----
+// f(int256,uint256): -4266, 0 -> -4266
+// f(int256,uint256): -4266, 1 -> -2133
+// f(int256,uint256): -4266, 4 -> -267
+// f(int256,uint256): -4266, 8 -> -17
+// f(int256,uint256): -4266, 16 -> -1
+// f(int256,uint256): -4266, 17 -> -1
+// f(int256,uint256): -4267, 0 -> -4267
+// f(int256,uint256): -4267, 1 -> -2134
+// f(int256,uint256): -4267, 4 -> -267
+// f(int256,uint256): -4267, 8 -> -17
+// f(int256,uint256): -4267, 16 -> -1
+// f(int256,uint256): -4267, 17 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int16.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int16.sol
new file mode 100644
index 00000000..50612a6f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int16.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f(int16 a, uint16 b) public returns (int256) {
+        return a >> b;
+    }
+}
+// ----
+// f(int16,uint16): -4266, 0 -> -4266
+// f(int16,uint16): -4266, 1 -> -2133
+// f(int16,uint16): -4266, 4 -> -267
+// f(int16,uint16): -4266, 8 -> -17
+// f(int16,uint16): -4266, 16 -> -1
+// f(int16,uint16): -4266, 17 -> -1
+// f(int16,uint16): -4267, 0 -> -4267
+// f(int16,uint16): -4267, 1 -> -2134
+// f(int16,uint16): -4267, 4 -> -267
+// f(int16,uint16): -4267, 8 -> -17
+// f(int16,uint16): -4267, 16 -> -1
+// f(int16,uint16): -4267, 17 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int32.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int32.sol
new file mode 100644
index 00000000..024eb325
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int32.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f(int32 a, uint32 b) public returns (int256) {
+        return a >> b;
+    }
+}
+// ----
+// f(int32,uint32): -4266, 0 -> -4266
+// f(int32,uint32): -4266, 1 -> -2133
+// f(int32,uint32): -4266, 4 -> -267
+// f(int32,uint32): -4266, 8 -> -17
+// f(int32,uint32): -4266, 16 -> -1
+// f(int32,uint32): -4266, 17 -> -1
+// f(int32,uint32): -4267, 0 -> -4267
+// f(int32,uint32): -4267, 1 -> -2134
+// f(int32,uint32): -4267, 4 -> -267
+// f(int32,uint32): -4267, 8 -> -17
+// f(int32,uint32): -4267, 16 -> -1
+// f(int32,uint32): -4267, 17 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int8.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int8.sol
new file mode 100644
index 00000000..9cff6c3b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_int8.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f(int8 a, uint8 b) public returns (int256) {
+        return a >> b;
+    }
+}
+// ----
+// f(int8,uint8): -66, 0 -> -66
+// f(int8,uint8): -66, 1 -> -33
+// f(int8,uint8): -66, 4 -> -5
+// f(int8,uint8): -66, 8 -> -1
+// f(int8,uint8): -66, 16 -> -1
+// f(int8,uint8): -66, 17 -> -1
+// f(int8,uint8): -67, 0 -> -67
+// f(int8,uint8): -67, 1 -> -34
+// f(int8,uint8): -67, 4 -> -5
+// f(int8,uint8): -67, 8 -> -1
+// f(int8,uint8): -67, 16 -> -1
+// f(int8,uint8): -67, 17 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol
new file mode 100644
index 00000000..f2c02448
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int16_v2.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(int16 a, uint16 b) public returns (int16) {
+        return a >> b;
+    }
+}
+// ----
+// f(int16,uint16): 0xff99, 0x00 -> FAILURE
+// f(int16,uint16): 0xff99, 0x01 -> FAILURE
+// f(int16,uint16): 0xff99, 0x02 -> FAILURE
+// f(int16,uint16): 0xff99, 0x04 -> FAILURE
+// f(int16,uint16): 0xff99, 0x08 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol
new file mode 100644
index 00000000..9c3090a7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int32_v2.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(int32 a, uint32 b) public returns (int32) {
+        return a >> b;
+    }
+}
+// ----
+// f(int32,uint32): 0xffffff99, 0x00 -> FAILURE
+// f(int32,uint32): 0xffffff99, 0x01 -> FAILURE
+// f(int32,uint32): 0xffffff99, 0x02 -> FAILURE
+// f(int32,uint32): 0xffffff99, 0x04 -> FAILURE
+// f(int32,uint32): 0xffffff99, 0x08 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol
new file mode 100644
index 00000000..8d3cec4e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_negative_lvalue_signextend_int8_v2.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+
+contract C {
+    function f(int8 a, uint8 b) public returns (int8) {
+        return a >> b;
+    }
+}
+// ----
+// f(int8,uint8): 0x99, 0x00 -> FAILURE
+// f(int8,uint8): 0x99, 0x01 -> FAILURE
+// f(int8,uint8): 0x99, 0x02 -> FAILURE
+// f(int8,uint8): 0x99, 0x04 -> FAILURE
+// f(int8,uint8): 0x99, 0x08 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint32.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint32.sol
new file mode 100644
index 00000000..2619ea33
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint32.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(uint32 a, uint32 b) public returns (uint256) {
+        return a >> b;
+    }
+}
+// ----
+// f(uint32,uint32): 0x4266, 0x0 -> 0x4266
+// f(uint32,uint32): 0x4266, 0x8 -> 0x42
+// f(uint32,uint32): 0x4266, 0x10 -> 0
+// f(uint32,uint32): 0x4266, 0x11 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint8.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint8.sol
new file mode 100644
index 00000000..1792d875
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_right_uint8.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint8 a, uint8 b) public returns (uint256) {
+        return a >> b;
+    }
+}
+// ----
+// f(uint8,uint8): 0x66, 0x0 -> 0x66
+// f(uint8,uint8): 0x66, 0x8 -> 0x0
diff --git a/compiler/test/libsolidity/semanticTests/operators/shifts/shift_underflow_negative_rvalue.sol b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_underflow_negative_rvalue.sol
new file mode 100644
index 00000000..6f4f95e9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/shifts/shift_underflow_negative_rvalue.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(int256 a, uint256 b) public returns (int256) {
+        return a << b;
+    }
+
+    function g(int256 a, uint256 b) public returns (int256) {
+        return a >> b;
+    }
+}
+// ----
+// f(int256,uint256): 1, -1 -> 0
+// g(int256,uint256): 1, -1 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_operators.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_operators.sol
new file mode 100644
index 00000000..315356b6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_operators.sol
@@ -0,0 +1,92 @@
+type Int is int8;
+using {
+    bitor as |, bitand as &, bitxor as ^, bitnot as ~,
+    add as +, sub as -, unsub as -, mul as *, div as /, mod as %,
+    eq as ==, noteq as !=, lt as <, gt as >, leq as <=, geq as >=
+} for Int global;
+
+function bitor(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) | Int.unwrap(y)); }
+function bitand(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) & Int.unwrap(y)); }
+function bitxor(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) ^ Int.unwrap(y)); }
+function bitnot(Int x) pure returns (Int) { return Int.wrap(~Int.unwrap(x)); }
+
+function add(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) + Int.unwrap(y)); }
+function sub(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) - Int.unwrap(y)); }
+function unsub(Int x) pure returns (Int) { return Int.wrap(-Int.unwrap(x)); }
+function mul(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) * Int.unwrap(y)); }
+function div(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) / Int.unwrap(y)); }
+function mod(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) % Int.unwrap(y)); }
+
+function eq(Int x, Int y) pure returns (bool) { return Int.unwrap(x) == Int.unwrap(y); }
+function noteq(Int x, Int y) pure returns (bool) { return Int.unwrap(x) != Int.unwrap(y); }
+function lt(Int x, Int y) pure returns (bool) { return Int.unwrap(x) < Int.unwrap(y); }
+function gt(Int x, Int y) pure returns (bool) { return Int.unwrap(x) > Int.unwrap(y); }
+function leq(Int x, Int y) pure returns (bool) { return Int.unwrap(x) <= Int.unwrap(y); }
+function geq(Int x, Int y) pure returns (bool) { return Int.unwrap(x) >= Int.unwrap(y); }
+
+contract C {
+    Int constant ZERO = Int.wrap(0);
+    Int constant ONE = Int.wrap(1);
+    Int constant TWO = Int.wrap(2);
+    Int constant THREE = Int.wrap(3);
+    Int constant SIX = Int.wrap(6);
+
+    function testBitwise() public pure {
+        assert(Int.unwrap(ONE | TWO) == 3);
+        assert(Int.unwrap(ONE | ZERO) == 1);
+
+        assert(Int.unwrap(ONE & THREE) == 1);
+        assert(Int.unwrap(ONE & ONE) == 1);
+
+        assert(Int.unwrap(TWO ^ TWO) == 0);
+        assert(Int.unwrap(TWO ^ ONE) == 3);
+
+        assert(Int.unwrap(~ZERO) == -1);
+        assert(Int.unwrap(~ONE) == -2);
+        assert(Int.unwrap(~TWO) == -3);
+    }
+
+    function testArithmetic() public pure {
+        assert(Int.unwrap(ONE + TWO) == 3);
+        assert(Int.unwrap(ONE + ZERO) == 1);
+
+        assert(Int.unwrap(TWO - ONE) == 1);
+        assert(Int.unwrap(THREE - THREE) == 0);
+
+        assert(Int.unwrap(-TWO) == -2);
+        assert(Int.unwrap(-ZERO) == 0);
+
+        assert(Int.unwrap(ONE * ONE) == 1);
+        assert(Int.unwrap(THREE * TWO) == 6);
+
+        assert(Int.unwrap(SIX / TWO) == 3);
+        assert(Int.unwrap(THREE / TWO) == 1);
+
+        assert(Int.unwrap(SIX % TWO) == 0);
+        assert(Int.unwrap(THREE % TWO) == 1);
+    }
+
+    function testComparison() public pure {
+        assert((ONE == ONE) == true);
+        assert((ONE == TWO) == false);
+
+        assert((ONE != ONE) == false);
+        assert((ONE != TWO) == true);
+
+        assert((ONE < TWO) == true);
+        assert((TWO < ONE) == false);
+
+        assert((ONE <= TWO) == true);
+        assert((TWO <= ONE) == false);
+
+        assert((ONE > TWO) == false);
+        assert((TWO > ONE) == true);
+
+        assert((ONE >= TWO) == false);
+        assert((TWO >= ONE) == true);
+    }
+}
+// ----
+// testBitwise() ->
+// testArithmetic() ->
+// testComparison() ->
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_user_defined_value_types_with_operators.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_user_defined_value_types_with_operators.sol
new file mode 100644
index 00000000..868a5396
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/all_possible_user_defined_value_types_with_operators.sol
@@ -0,0 +1,670 @@
+type Int8 is int8;
+type Int16 is int16;
+type Int24 is int24;
+type Int32 is int32;
+type Int40 is int40;
+type Int48 is int48;
+type Int56 is int56;
+type Int64 is int64;
+type Int72 is int72;
+type Int80 is int80;
+type Int88 is int88;
+type Int96 is int96;
+type Int104 is int104;
+type Int112 is int112;
+type Int120 is int120;
+type Int128 is int128;
+type Int136 is int136;
+type Int144 is int144;
+type Int152 is int152;
+type Int160 is int160;
+type Int168 is int168;
+type Int176 is int176;
+type Int184 is int184;
+type Int192 is int192;
+type Int200 is int200;
+type Int208 is int208;
+type Int216 is int216;
+type Int224 is int224;
+type Int232 is int232;
+type Int240 is int240;
+type Int248 is int248;
+type Int256 is int256;
+type Int is int;
+
+type Uint8 is uint8;
+type Uint16 is uint16;
+type Uint24 is uint24;
+type Uint32 is uint32;
+type Uint40 is uint40;
+type Uint48 is uint48;
+type Uint56 is uint56;
+type Uint64 is uint64;
+type Uint72 is uint72;
+type Uint80 is uint80;
+type Uint88 is uint88;
+type Uint96 is uint96;
+type Uint104 is uint104;
+type Uint112 is uint112;
+type Uint120 is uint120;
+type Uint128 is uint128;
+type Uint136 is uint136;
+type Uint144 is uint144;
+type Uint152 is uint152;
+type Uint160 is uint160;
+type Uint168 is uint168;
+type Uint176 is uint176;
+type Uint184 is uint184;
+type Uint192 is uint192;
+type Uint200 is uint200;
+type Uint208 is uint208;
+type Uint216 is uint216;
+type Uint224 is uint224;
+type Uint232 is uint232;
+type Uint240 is uint240;
+type Uint248 is uint248;
+type Uint256 is uint256;
+type Uint is uint;
+
+type Bytes1 is bytes1;
+type Bytes2 is bytes2;
+type Bytes3 is bytes3;
+type Bytes4 is bytes4;
+type Bytes5 is bytes5;
+type Bytes6 is bytes6;
+type Bytes7 is bytes7;
+type Bytes8 is bytes8;
+type Bytes9 is bytes9;
+type Bytes10 is bytes10;
+type Bytes11 is bytes11;
+type Bytes12 is bytes12;
+type Bytes13 is bytes13;
+type Bytes14 is bytes14;
+type Bytes15 is bytes15;
+type Bytes16 is bytes16;
+type Bytes17 is bytes17;
+type Bytes18 is bytes18;
+type Bytes19 is bytes19;
+type Bytes20 is bytes20;
+type Bytes21 is bytes21;
+type Bytes22 is bytes22;
+type Bytes23 is bytes23;
+type Bytes24 is bytes24;
+type Bytes25 is bytes25;
+type Bytes26 is bytes26;
+type Bytes27 is bytes27;
+type Bytes28 is bytes28;
+type Bytes29 is bytes29;
+type Bytes30 is bytes30;
+type Bytes31 is bytes31;
+type Bytes32 is bytes32;
+
+type Address is address;
+type AddressPayable is address payable;
+
+type Bool is bool;
+
+using {bitorInt8 as |, unsubInt8 as -} for Int8 global;
+using {bitorInt16 as |, unsubInt16 as -} for Int16 global;
+using {bitorInt24 as |, unsubInt24 as -} for Int24 global;
+using {bitorInt32 as |, unsubInt32 as -} for Int32 global;
+using {bitorInt40 as |, unsubInt40 as -} for Int40 global;
+using {bitorInt48 as |, unsubInt48 as -} for Int48 global;
+using {bitorInt56 as |, unsubInt56 as -} for Int56 global;
+using {bitorInt64 as |, unsubInt64 as -} for Int64 global;
+using {bitorInt72 as |, unsubInt72 as -} for Int72 global;
+using {bitorInt80 as |, unsubInt80 as -} for Int80 global;
+using {bitorInt88 as |, unsubInt88 as -} for Int88 global;
+using {bitorInt96 as |, unsubInt96 as -} for Int96 global;
+using {bitorInt104 as |, unsubInt104 as -} for Int104 global;
+using {bitorInt112 as |, unsubInt112 as -} for Int112 global;
+using {bitorInt120 as |, unsubInt120 as -} for Int120 global;
+using {bitorInt128 as |, unsubInt128 as -} for Int128 global;
+using {bitorInt136 as |, unsubInt136 as -} for Int136 global;
+using {bitorInt144 as |, unsubInt144 as -} for Int144 global;
+using {bitorInt152 as |, unsubInt152 as -} for Int152 global;
+using {bitorInt160 as |, unsubInt160 as -} for Int160 global;
+using {bitorInt168 as |, unsubInt168 as -} for Int168 global;
+using {bitorInt176 as |, unsubInt176 as -} for Int176 global;
+using {bitorInt184 as |, unsubInt184 as -} for Int184 global;
+using {bitorInt192 as |, unsubInt192 as -} for Int192 global;
+using {bitorInt200 as |, unsubInt200 as -} for Int200 global;
+using {bitorInt208 as |, unsubInt208 as -} for Int208 global;
+using {bitorInt216 as |, unsubInt216 as -} for Int216 global;
+using {bitorInt224 as |, unsubInt224 as -} for Int224 global;
+using {bitorInt232 as |, unsubInt232 as -} for Int232 global;
+using {bitorInt240 as |, unsubInt240 as -} for Int240 global;
+using {bitorInt248 as |, unsubInt248 as -} for Int248 global;
+using {bitorInt256 as |, unsubInt256 as -} for Int256 global;
+using {bitorInt as |, unsubInt as -} for Int global;
+
+using {bitorUint8 as |, bitnotUint8 as ~} for Uint8 global;
+using {bitorUint16 as |, bitnotUint16 as ~} for Uint16 global;
+using {bitorUint24 as |, bitnotUint24 as ~} for Uint24 global;
+using {bitorUint32 as |, bitnotUint32 as ~} for Uint32 global;
+using {bitorUint40 as |, bitnotUint40 as ~} for Uint40 global;
+using {bitorUint48 as |, bitnotUint48 as ~} for Uint48 global;
+using {bitorUint56 as |, bitnotUint56 as ~} for Uint56 global;
+using {bitorUint64 as |, bitnotUint64 as ~} for Uint64 global;
+using {bitorUint72 as |, bitnotUint72 as ~} for Uint72 global;
+using {bitorUint80 as |, bitnotUint80 as ~} for Uint80 global;
+using {bitorUint88 as |, bitnotUint88 as ~} for Uint88 global;
+using {bitorUint96 as |, bitnotUint96 as ~} for Uint96 global;
+using {bitorUint104 as |, bitnotUint104 as ~} for Uint104 global;
+using {bitorUint112 as |, bitnotUint112 as ~} for Uint112 global;
+using {bitorUint120 as |, bitnotUint120 as ~} for Uint120 global;
+using {bitorUint128 as |, bitnotUint128 as ~} for Uint128 global;
+using {bitorUint136 as |, bitnotUint136 as ~} for Uint136 global;
+using {bitorUint144 as |, bitnotUint144 as ~} for Uint144 global;
+using {bitorUint152 as |, bitnotUint152 as ~} for Uint152 global;
+using {bitorUint160 as |, bitnotUint160 as ~} for Uint160 global;
+using {bitorUint168 as |, bitnotUint168 as ~} for Uint168 global;
+using {bitorUint176 as |, bitnotUint176 as ~} for Uint176 global;
+using {bitorUint184 as |, bitnotUint184 as ~} for Uint184 global;
+using {bitorUint192 as |, bitnotUint192 as ~} for Uint192 global;
+using {bitorUint200 as |, bitnotUint200 as ~} for Uint200 global;
+using {bitorUint208 as |, bitnotUint208 as ~} for Uint208 global;
+using {bitorUint216 as |, bitnotUint216 as ~} for Uint216 global;
+using {bitorUint224 as |, bitnotUint224 as ~} for Uint224 global;
+using {bitorUint232 as |, bitnotUint232 as ~} for Uint232 global;
+using {bitorUint240 as |, bitnotUint240 as ~} for Uint240 global;
+using {bitorUint248 as |, bitnotUint248 as ~} for Uint248 global;
+using {bitorUint256 as |, bitnotUint256 as ~} for Uint256 global;
+using {bitorUint as |, bitnotUint as ~} for Uint global;
+
+using {bitorBytes1 as |, bitnotBytes1 as ~} for Bytes1 global;
+using {bitorBytes2 as |, bitnotBytes2 as ~} for Bytes2 global;
+using {bitorBytes3 as |, bitnotBytes3 as ~} for Bytes3 global;
+using {bitorBytes4 as |, bitnotBytes4 as ~} for Bytes4 global;
+using {bitorBytes5 as |, bitnotBytes5 as ~} for Bytes5 global;
+using {bitorBytes6 as |, bitnotBytes6 as ~} for Bytes6 global;
+using {bitorBytes7 as |, bitnotBytes7 as ~} for Bytes7 global;
+using {bitorBytes8 as |, bitnotBytes8 as ~} for Bytes8 global;
+using {bitorBytes9 as |, bitnotBytes9 as ~} for Bytes9 global;
+using {bitorBytes10 as |, bitnotBytes10 as ~} for Bytes10 global;
+using {bitorBytes11 as |, bitnotBytes11 as ~} for Bytes11 global;
+using {bitorBytes12 as |, bitnotBytes12 as ~} for Bytes12 global;
+using {bitorBytes13 as |, bitnotBytes13 as ~} for Bytes13 global;
+using {bitorBytes14 as |, bitnotBytes14 as ~} for Bytes14 global;
+using {bitorBytes15 as |, bitnotBytes15 as ~} for Bytes15 global;
+using {bitorBytes16 as |, bitnotBytes16 as ~} for Bytes16 global;
+using {bitorBytes17 as |, bitnotBytes17 as ~} for Bytes17 global;
+using {bitorBytes18 as |, bitnotBytes18 as ~} for Bytes18 global;
+using {bitorBytes19 as |, bitnotBytes19 as ~} for Bytes19 global;
+using {bitorBytes20 as |, bitnotBytes20 as ~} for Bytes20 global;
+using {bitorBytes21 as |, bitnotBytes21 as ~} for Bytes21 global;
+using {bitorBytes22 as |, bitnotBytes22 as ~} for Bytes22 global;
+using {bitorBytes23 as |, bitnotBytes23 as ~} for Bytes23 global;
+using {bitorBytes24 as |, bitnotBytes24 as ~} for Bytes24 global;
+using {bitorBytes25 as |, bitnotBytes25 as ~} for Bytes25 global;
+using {bitorBytes26 as |, bitnotBytes26 as ~} for Bytes26 global;
+using {bitorBytes27 as |, bitnotBytes27 as ~} for Bytes27 global;
+using {bitorBytes28 as |, bitnotBytes28 as ~} for Bytes28 global;
+using {bitorBytes29 as |, bitnotBytes29 as ~} for Bytes29 global;
+using {bitorBytes30 as |, bitnotBytes30 as ~} for Bytes30 global;
+using {bitorBytes31 as |, bitnotBytes31 as ~} for Bytes31 global;
+using {bitorBytes32 as |, bitnotBytes32 as ~} for Bytes32 global;
+
+function bitorInt8(Int8 x, Int8 y) pure returns (Int8) { return Int8.wrap(Int8.unwrap(x) | Int8.unwrap(y)); }
+function bitorInt16(Int16 x, Int16 y) pure returns (Int16) { return Int16.wrap(Int16.unwrap(x) | Int16.unwrap(y)); }
+function bitorInt24(Int24 x, Int24 y) pure returns (Int24) { return Int24.wrap(Int24.unwrap(x) | Int24.unwrap(y)); }
+function bitorInt32(Int32 x, Int32 y) pure returns (Int32) { return Int32.wrap(Int32.unwrap(x) | Int32.unwrap(y)); }
+function bitorInt40(Int40 x, Int40 y) pure returns (Int40) { return Int40.wrap(Int40.unwrap(x) | Int40.unwrap(y)); }
+function bitorInt48(Int48 x, Int48 y) pure returns (Int48) { return Int48.wrap(Int48.unwrap(x) | Int48.unwrap(y)); }
+function bitorInt56(Int56 x, Int56 y) pure returns (Int56) { return Int56.wrap(Int56.unwrap(x) | Int56.unwrap(y)); }
+function bitorInt64(Int64 x, Int64 y) pure returns (Int64) { return Int64.wrap(Int64.unwrap(x) | Int64.unwrap(y)); }
+function bitorInt72(Int72 x, Int72 y) pure returns (Int72) { return Int72.wrap(Int72.unwrap(x) | Int72.unwrap(y)); }
+function bitorInt80(Int80 x, Int80 y) pure returns (Int80) { return Int80.wrap(Int80.unwrap(x) | Int80.unwrap(y)); }
+function bitorInt88(Int88 x, Int88 y) pure returns (Int88) { return Int88.wrap(Int88.unwrap(x) | Int88.unwrap(y)); }
+function bitorInt96(Int96 x, Int96 y) pure returns (Int96) { return Int96.wrap(Int96.unwrap(x) | Int96.unwrap(y)); }
+function bitorInt104(Int104 x, Int104 y) pure returns (Int104) { return Int104.wrap(Int104.unwrap(x) | Int104.unwrap(y)); }
+function bitorInt112(Int112 x, Int112 y) pure returns (Int112) { return Int112.wrap(Int112.unwrap(x) | Int112.unwrap(y)); }
+function bitorInt120(Int120 x, Int120 y) pure returns (Int120) { return Int120.wrap(Int120.unwrap(x) | Int120.unwrap(y)); }
+function bitorInt128(Int128 x, Int128 y) pure returns (Int128) { return Int128.wrap(Int128.unwrap(x) | Int128.unwrap(y)); }
+function bitorInt136(Int136 x, Int136 y) pure returns (Int136) { return Int136.wrap(Int136.unwrap(x) | Int136.unwrap(y)); }
+function bitorInt144(Int144 x, Int144 y) pure returns (Int144) { return Int144.wrap(Int144.unwrap(x) | Int144.unwrap(y)); }
+function bitorInt152(Int152 x, Int152 y) pure returns (Int152) { return Int152.wrap(Int152.unwrap(x) | Int152.unwrap(y)); }
+function bitorInt160(Int160 x, Int160 y) pure returns (Int160) { return Int160.wrap(Int160.unwrap(x) | Int160.unwrap(y)); }
+function bitorInt168(Int168 x, Int168 y) pure returns (Int168) { return Int168.wrap(Int168.unwrap(x) | Int168.unwrap(y)); }
+function bitorInt176(Int176 x, Int176 y) pure returns (Int176) { return Int176.wrap(Int176.unwrap(x) | Int176.unwrap(y)); }
+function bitorInt184(Int184 x, Int184 y) pure returns (Int184) { return Int184.wrap(Int184.unwrap(x) | Int184.unwrap(y)); }
+function bitorInt192(Int192 x, Int192 y) pure returns (Int192) { return Int192.wrap(Int192.unwrap(x) | Int192.unwrap(y)); }
+function bitorInt200(Int200 x, Int200 y) pure returns (Int200) { return Int200.wrap(Int200.unwrap(x) | Int200.unwrap(y)); }
+function bitorInt208(Int208 x, Int208 y) pure returns (Int208) { return Int208.wrap(Int208.unwrap(x) | Int208.unwrap(y)); }
+function bitorInt216(Int216 x, Int216 y) pure returns (Int216) { return Int216.wrap(Int216.unwrap(x) | Int216.unwrap(y)); }
+function bitorInt224(Int224 x, Int224 y) pure returns (Int224) { return Int224.wrap(Int224.unwrap(x) | Int224.unwrap(y)); }
+function bitorInt232(Int232 x, Int232 y) pure returns (Int232) { return Int232.wrap(Int232.unwrap(x) | Int232.unwrap(y)); }
+function bitorInt240(Int240 x, Int240 y) pure returns (Int240) { return Int240.wrap(Int240.unwrap(x) | Int240.unwrap(y)); }
+function bitorInt248(Int248 x, Int248 y) pure returns (Int248) { return Int248.wrap(Int248.unwrap(x) | Int248.unwrap(y)); }
+function bitorInt256(Int256 x, Int256 y) pure returns (Int256) { return Int256.wrap(Int256.unwrap(x) | Int256.unwrap(y)); }
+function bitorInt(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) | Int.unwrap(y)); }
+
+function unsubInt8(Int8 x) pure returns (Int8) { return Int8.wrap(-Int8.unwrap(x)); }
+function unsubInt16(Int16 x) pure returns (Int16) { return Int16.wrap(-Int16.unwrap(x)); }
+function unsubInt24(Int24 x) pure returns (Int24) { return Int24.wrap(-Int24.unwrap(x)); }
+function unsubInt32(Int32 x) pure returns (Int32) { return Int32.wrap(-Int32.unwrap(x)); }
+function unsubInt40(Int40 x) pure returns (Int40) { return Int40.wrap(-Int40.unwrap(x)); }
+function unsubInt48(Int48 x) pure returns (Int48) { return Int48.wrap(-Int48.unwrap(x)); }
+function unsubInt56(Int56 x) pure returns (Int56) { return Int56.wrap(-Int56.unwrap(x)); }
+function unsubInt64(Int64 x) pure returns (Int64) { return Int64.wrap(-Int64.unwrap(x)); }
+function unsubInt72(Int72 x) pure returns (Int72) { return Int72.wrap(-Int72.unwrap(x)); }
+function unsubInt80(Int80 x) pure returns (Int80) { return Int80.wrap(-Int80.unwrap(x)); }
+function unsubInt88(Int88 x) pure returns (Int88) { return Int88.wrap(-Int88.unwrap(x)); }
+function unsubInt96(Int96 x) pure returns (Int96) { return Int96.wrap(-Int96.unwrap(x)); }
+function unsubInt104(Int104 x) pure returns (Int104) { return Int104.wrap(-Int104.unwrap(x)); }
+function unsubInt112(Int112 x) pure returns (Int112) { return Int112.wrap(-Int112.unwrap(x)); }
+function unsubInt120(Int120 x) pure returns (Int120) { return Int120.wrap(-Int120.unwrap(x)); }
+function unsubInt128(Int128 x) pure returns (Int128) { return Int128.wrap(-Int128.unwrap(x)); }
+function unsubInt136(Int136 x) pure returns (Int136) { return Int136.wrap(-Int136.unwrap(x)); }
+function unsubInt144(Int144 x) pure returns (Int144) { return Int144.wrap(-Int144.unwrap(x)); }
+function unsubInt152(Int152 x) pure returns (Int152) { return Int152.wrap(-Int152.unwrap(x)); }
+function unsubInt160(Int160 x) pure returns (Int160) { return Int160.wrap(-Int160.unwrap(x)); }
+function unsubInt168(Int168 x) pure returns (Int168) { return Int168.wrap(-Int168.unwrap(x)); }
+function unsubInt176(Int176 x) pure returns (Int176) { return Int176.wrap(-Int176.unwrap(x)); }
+function unsubInt184(Int184 x) pure returns (Int184) { return Int184.wrap(-Int184.unwrap(x)); }
+function unsubInt192(Int192 x) pure returns (Int192) { return Int192.wrap(-Int192.unwrap(x)); }
+function unsubInt200(Int200 x) pure returns (Int200) { return Int200.wrap(-Int200.unwrap(x)); }
+function unsubInt208(Int208 x) pure returns (Int208) { return Int208.wrap(-Int208.unwrap(x)); }
+function unsubInt216(Int216 x) pure returns (Int216) { return Int216.wrap(-Int216.unwrap(x)); }
+function unsubInt224(Int224 x) pure returns (Int224) { return Int224.wrap(-Int224.unwrap(x)); }
+function unsubInt232(Int232 x) pure returns (Int232) { return Int232.wrap(-Int232.unwrap(x)); }
+function unsubInt240(Int240 x) pure returns (Int240) { return Int240.wrap(-Int240.unwrap(x)); }
+function unsubInt248(Int248 x) pure returns (Int248) { return Int248.wrap(-Int248.unwrap(x)); }
+function unsubInt256(Int256 x) pure returns (Int256) { return Int256.wrap(-Int256.unwrap(x)); }
+function unsubInt(Int x) pure returns (Int) { return Int.wrap(-Int.unwrap(x)); }
+
+function bitorUint8(Uint8 x, Uint8 y) pure returns (Uint8) { return Uint8.wrap(Uint8.unwrap(x) | Uint8.unwrap(y)); }
+function bitorUint16(Uint16 x, Uint16 y) pure returns (Uint16) { return Uint16.wrap(Uint16.unwrap(x) | Uint16.unwrap(y)); }
+function bitorUint24(Uint24 x, Uint24 y) pure returns (Uint24) { return Uint24.wrap(Uint24.unwrap(x) | Uint24.unwrap(y)); }
+function bitorUint32(Uint32 x, Uint32 y) pure returns (Uint32) { return Uint32.wrap(Uint32.unwrap(x) | Uint32.unwrap(y)); }
+function bitorUint40(Uint40 x, Uint40 y) pure returns (Uint40) { return Uint40.wrap(Uint40.unwrap(x) | Uint40.unwrap(y)); }
+function bitorUint48(Uint48 x, Uint48 y) pure returns (Uint48) { return Uint48.wrap(Uint48.unwrap(x) | Uint48.unwrap(y)); }
+function bitorUint56(Uint56 x, Uint56 y) pure returns (Uint56) { return Uint56.wrap(Uint56.unwrap(x) | Uint56.unwrap(y)); }
+function bitorUint64(Uint64 x, Uint64 y) pure returns (Uint64) { return Uint64.wrap(Uint64.unwrap(x) | Uint64.unwrap(y)); }
+function bitorUint72(Uint72 x, Uint72 y) pure returns (Uint72) { return Uint72.wrap(Uint72.unwrap(x) | Uint72.unwrap(y)); }
+function bitorUint80(Uint80 x, Uint80 y) pure returns (Uint80) { return Uint80.wrap(Uint80.unwrap(x) | Uint80.unwrap(y)); }
+function bitorUint88(Uint88 x, Uint88 y) pure returns (Uint88) { return Uint88.wrap(Uint88.unwrap(x) | Uint88.unwrap(y)); }
+function bitorUint96(Uint96 x, Uint96 y) pure returns (Uint96) { return Uint96.wrap(Uint96.unwrap(x) | Uint96.unwrap(y)); }
+function bitorUint104(Uint104 x, Uint104 y) pure returns (Uint104) { return Uint104.wrap(Uint104.unwrap(x) | Uint104.unwrap(y)); }
+function bitorUint112(Uint112 x, Uint112 y) pure returns (Uint112) { return Uint112.wrap(Uint112.unwrap(x) | Uint112.unwrap(y)); }
+function bitorUint120(Uint120 x, Uint120 y) pure returns (Uint120) { return Uint120.wrap(Uint120.unwrap(x) | Uint120.unwrap(y)); }
+function bitorUint128(Uint128 x, Uint128 y) pure returns (Uint128) { return Uint128.wrap(Uint128.unwrap(x) | Uint128.unwrap(y)); }
+function bitorUint136(Uint136 x, Uint136 y) pure returns (Uint136) { return Uint136.wrap(Uint136.unwrap(x) | Uint136.unwrap(y)); }
+function bitorUint144(Uint144 x, Uint144 y) pure returns (Uint144) { return Uint144.wrap(Uint144.unwrap(x) | Uint144.unwrap(y)); }
+function bitorUint152(Uint152 x, Uint152 y) pure returns (Uint152) { return Uint152.wrap(Uint152.unwrap(x) | Uint152.unwrap(y)); }
+function bitorUint160(Uint160 x, Uint160 y) pure returns (Uint160) { return Uint160.wrap(Uint160.unwrap(x) | Uint160.unwrap(y)); }
+function bitorUint168(Uint168 x, Uint168 y) pure returns (Uint168) { return Uint168.wrap(Uint168.unwrap(x) | Uint168.unwrap(y)); }
+function bitorUint176(Uint176 x, Uint176 y) pure returns (Uint176) { return Uint176.wrap(Uint176.unwrap(x) | Uint176.unwrap(y)); }
+function bitorUint184(Uint184 x, Uint184 y) pure returns (Uint184) { return Uint184.wrap(Uint184.unwrap(x) | Uint184.unwrap(y)); }
+function bitorUint192(Uint192 x, Uint192 y) pure returns (Uint192) { return Uint192.wrap(Uint192.unwrap(x) | Uint192.unwrap(y)); }
+function bitorUint200(Uint200 x, Uint200 y) pure returns (Uint200) { return Uint200.wrap(Uint200.unwrap(x) | Uint200.unwrap(y)); }
+function bitorUint208(Uint208 x, Uint208 y) pure returns (Uint208) { return Uint208.wrap(Uint208.unwrap(x) | Uint208.unwrap(y)); }
+function bitorUint216(Uint216 x, Uint216 y) pure returns (Uint216) { return Uint216.wrap(Uint216.unwrap(x) | Uint216.unwrap(y)); }
+function bitorUint224(Uint224 x, Uint224 y) pure returns (Uint224) { return Uint224.wrap(Uint224.unwrap(x) | Uint224.unwrap(y)); }
+function bitorUint232(Uint232 x, Uint232 y) pure returns (Uint232) { return Uint232.wrap(Uint232.unwrap(x) | Uint232.unwrap(y)); }
+function bitorUint240(Uint240 x, Uint240 y) pure returns (Uint240) { return Uint240.wrap(Uint240.unwrap(x) | Uint240.unwrap(y)); }
+function bitorUint248(Uint248 x, Uint248 y) pure returns (Uint248) { return Uint248.wrap(Uint248.unwrap(x) | Uint248.unwrap(y)); }
+function bitorUint256(Uint256 x, Uint256 y) pure returns (Uint256) { return Uint256.wrap(Uint256.unwrap(x) | Uint256.unwrap(y)); }
+function bitorUint(Uint x, Uint y) pure returns (Uint) { return Uint.wrap(Uint.unwrap(x) | Uint.unwrap(y)); }
+
+function bitnotUint8(Uint8 x) pure returns (Uint8) { return Uint8.wrap(~Uint8.unwrap(x)); }
+function bitnotUint16(Uint16 x) pure returns (Uint16) { return Uint16.wrap(~Uint16.unwrap(x)); }
+function bitnotUint24(Uint24 x) pure returns (Uint24) { return Uint24.wrap(~Uint24.unwrap(x)); }
+function bitnotUint32(Uint32 x) pure returns (Uint32) { return Uint32.wrap(~Uint32.unwrap(x)); }
+function bitnotUint40(Uint40 x) pure returns (Uint40) { return Uint40.wrap(~Uint40.unwrap(x)); }
+function bitnotUint48(Uint48 x) pure returns (Uint48) { return Uint48.wrap(~Uint48.unwrap(x)); }
+function bitnotUint56(Uint56 x) pure returns (Uint56) { return Uint56.wrap(~Uint56.unwrap(x)); }
+function bitnotUint64(Uint64 x) pure returns (Uint64) { return Uint64.wrap(~Uint64.unwrap(x)); }
+function bitnotUint72(Uint72 x) pure returns (Uint72) { return Uint72.wrap(~Uint72.unwrap(x)); }
+function bitnotUint80(Uint80 x) pure returns (Uint80) { return Uint80.wrap(~Uint80.unwrap(x)); }
+function bitnotUint88(Uint88 x) pure returns (Uint88) { return Uint88.wrap(~Uint88.unwrap(x)); }
+function bitnotUint96(Uint96 x) pure returns (Uint96) { return Uint96.wrap(~Uint96.unwrap(x)); }
+function bitnotUint104(Uint104 x) pure returns (Uint104) { return Uint104.wrap(~Uint104.unwrap(x)); }
+function bitnotUint112(Uint112 x) pure returns (Uint112) { return Uint112.wrap(~Uint112.unwrap(x)); }
+function bitnotUint120(Uint120 x) pure returns (Uint120) { return Uint120.wrap(~Uint120.unwrap(x)); }
+function bitnotUint128(Uint128 x) pure returns (Uint128) { return Uint128.wrap(~Uint128.unwrap(x)); }
+function bitnotUint136(Uint136 x) pure returns (Uint136) { return Uint136.wrap(~Uint136.unwrap(x)); }
+function bitnotUint144(Uint144 x) pure returns (Uint144) { return Uint144.wrap(~Uint144.unwrap(x)); }
+function bitnotUint152(Uint152 x) pure returns (Uint152) { return Uint152.wrap(~Uint152.unwrap(x)); }
+function bitnotUint160(Uint160 x) pure returns (Uint160) { return Uint160.wrap(~Uint160.unwrap(x)); }
+function bitnotUint168(Uint168 x) pure returns (Uint168) { return Uint168.wrap(~Uint168.unwrap(x)); }
+function bitnotUint176(Uint176 x) pure returns (Uint176) { return Uint176.wrap(~Uint176.unwrap(x)); }
+function bitnotUint184(Uint184 x) pure returns (Uint184) { return Uint184.wrap(~Uint184.unwrap(x)); }
+function bitnotUint192(Uint192 x) pure returns (Uint192) { return Uint192.wrap(~Uint192.unwrap(x)); }
+function bitnotUint200(Uint200 x) pure returns (Uint200) { return Uint200.wrap(~Uint200.unwrap(x)); }
+function bitnotUint208(Uint208 x) pure returns (Uint208) { return Uint208.wrap(~Uint208.unwrap(x)); }
+function bitnotUint216(Uint216 x) pure returns (Uint216) { return Uint216.wrap(~Uint216.unwrap(x)); }
+function bitnotUint224(Uint224 x) pure returns (Uint224) { return Uint224.wrap(~Uint224.unwrap(x)); }
+function bitnotUint232(Uint232 x) pure returns (Uint232) { return Uint232.wrap(~Uint232.unwrap(x)); }
+function bitnotUint240(Uint240 x) pure returns (Uint240) { return Uint240.wrap(~Uint240.unwrap(x)); }
+function bitnotUint248(Uint248 x) pure returns (Uint248) { return Uint248.wrap(~Uint248.unwrap(x)); }
+function bitnotUint256(Uint256 x) pure returns (Uint256) { return Uint256.wrap(~Uint256.unwrap(x)); }
+function bitnotUint(Uint x) pure returns (Uint) { return Uint.wrap(~Uint.unwrap(x)); }
+
+function bitorBytes1(Bytes1 x, Bytes1 y) pure returns (Bytes1) { return Bytes1.wrap(Bytes1.unwrap(x) | Bytes1.unwrap(y)); }
+function bitorBytes2(Bytes2 x, Bytes2 y) pure returns (Bytes2) { return Bytes2.wrap(Bytes2.unwrap(x) | Bytes2.unwrap(y)); }
+function bitorBytes3(Bytes3 x, Bytes3 y) pure returns (Bytes3) { return Bytes3.wrap(Bytes3.unwrap(x) | Bytes3.unwrap(y)); }
+function bitorBytes4(Bytes4 x, Bytes4 y) pure returns (Bytes4) { return Bytes4.wrap(Bytes4.unwrap(x) | Bytes4.unwrap(y)); }
+function bitorBytes5(Bytes5 x, Bytes5 y) pure returns (Bytes5) { return Bytes5.wrap(Bytes5.unwrap(x) | Bytes5.unwrap(y)); }
+function bitorBytes6(Bytes6 x, Bytes6 y) pure returns (Bytes6) { return Bytes6.wrap(Bytes6.unwrap(x) | Bytes6.unwrap(y)); }
+function bitorBytes7(Bytes7 x, Bytes7 y) pure returns (Bytes7) { return Bytes7.wrap(Bytes7.unwrap(x) | Bytes7.unwrap(y)); }
+function bitorBytes8(Bytes8 x, Bytes8 y) pure returns (Bytes8) { return Bytes8.wrap(Bytes8.unwrap(x) | Bytes8.unwrap(y)); }
+function bitorBytes9(Bytes9 x, Bytes9 y) pure returns (Bytes9) { return Bytes9.wrap(Bytes9.unwrap(x) | Bytes9.unwrap(y)); }
+function bitorBytes10(Bytes10 x, Bytes10 y) pure returns (Bytes10) { return Bytes10.wrap(Bytes10.unwrap(x) | Bytes10.unwrap(y)); }
+function bitorBytes11(Bytes11 x, Bytes11 y) pure returns (Bytes11) { return Bytes11.wrap(Bytes11.unwrap(x) | Bytes11.unwrap(y)); }
+function bitorBytes12(Bytes12 x, Bytes12 y) pure returns (Bytes12) { return Bytes12.wrap(Bytes12.unwrap(x) | Bytes12.unwrap(y)); }
+function bitorBytes13(Bytes13 x, Bytes13 y) pure returns (Bytes13) { return Bytes13.wrap(Bytes13.unwrap(x) | Bytes13.unwrap(y)); }
+function bitorBytes14(Bytes14 x, Bytes14 y) pure returns (Bytes14) { return Bytes14.wrap(Bytes14.unwrap(x) | Bytes14.unwrap(y)); }
+function bitorBytes15(Bytes15 x, Bytes15 y) pure returns (Bytes15) { return Bytes15.wrap(Bytes15.unwrap(x) | Bytes15.unwrap(y)); }
+function bitorBytes16(Bytes16 x, Bytes16 y) pure returns (Bytes16) { return Bytes16.wrap(Bytes16.unwrap(x) | Bytes16.unwrap(y)); }
+function bitorBytes17(Bytes17 x, Bytes17 y) pure returns (Bytes17) { return Bytes17.wrap(Bytes17.unwrap(x) | Bytes17.unwrap(y)); }
+function bitorBytes18(Bytes18 x, Bytes18 y) pure returns (Bytes18) { return Bytes18.wrap(Bytes18.unwrap(x) | Bytes18.unwrap(y)); }
+function bitorBytes19(Bytes19 x, Bytes19 y) pure returns (Bytes19) { return Bytes19.wrap(Bytes19.unwrap(x) | Bytes19.unwrap(y)); }
+function bitorBytes20(Bytes20 x, Bytes20 y) pure returns (Bytes20) { return Bytes20.wrap(Bytes20.unwrap(x) | Bytes20.unwrap(y)); }
+function bitorBytes21(Bytes21 x, Bytes21 y) pure returns (Bytes21) { return Bytes21.wrap(Bytes21.unwrap(x) | Bytes21.unwrap(y)); }
+function bitorBytes22(Bytes22 x, Bytes22 y) pure returns (Bytes22) { return Bytes22.wrap(Bytes22.unwrap(x) | Bytes22.unwrap(y)); }
+function bitorBytes23(Bytes23 x, Bytes23 y) pure returns (Bytes23) { return Bytes23.wrap(Bytes23.unwrap(x) | Bytes23.unwrap(y)); }
+function bitorBytes24(Bytes24 x, Bytes24 y) pure returns (Bytes24) { return Bytes24.wrap(Bytes24.unwrap(x) | Bytes24.unwrap(y)); }
+function bitorBytes25(Bytes25 x, Bytes25 y) pure returns (Bytes25) { return Bytes25.wrap(Bytes25.unwrap(x) | Bytes25.unwrap(y)); }
+function bitorBytes26(Bytes26 x, Bytes26 y) pure returns (Bytes26) { return Bytes26.wrap(Bytes26.unwrap(x) | Bytes26.unwrap(y)); }
+function bitorBytes27(Bytes27 x, Bytes27 y) pure returns (Bytes27) { return Bytes27.wrap(Bytes27.unwrap(x) | Bytes27.unwrap(y)); }
+function bitorBytes28(Bytes28 x, Bytes28 y) pure returns (Bytes28) { return Bytes28.wrap(Bytes28.unwrap(x) | Bytes28.unwrap(y)); }
+function bitorBytes29(Bytes29 x, Bytes29 y) pure returns (Bytes29) { return Bytes29.wrap(Bytes29.unwrap(x) | Bytes29.unwrap(y)); }
+function bitorBytes30(Bytes30 x, Bytes30 y) pure returns (Bytes30) { return Bytes30.wrap(Bytes30.unwrap(x) | Bytes30.unwrap(y)); }
+function bitorBytes31(Bytes31 x, Bytes31 y) pure returns (Bytes31) { return Bytes31.wrap(Bytes31.unwrap(x) | Bytes31.unwrap(y)); }
+function bitorBytes32(Bytes32 x, Bytes32 y) pure returns (Bytes32) { return Bytes32.wrap(Bytes32.unwrap(x) | Bytes32.unwrap(y)); }
+
+function bitnotBytes1(Bytes1 x) pure returns (Bytes1) { return Bytes1.wrap(~Bytes1.unwrap(x)); }
+function bitnotBytes2(Bytes2 x) pure returns (Bytes2) { return Bytes2.wrap(~Bytes2.unwrap(x)); }
+function bitnotBytes3(Bytes3 x) pure returns (Bytes3) { return Bytes3.wrap(~Bytes3.unwrap(x)); }
+function bitnotBytes4(Bytes4 x) pure returns (Bytes4) { return Bytes4.wrap(~Bytes4.unwrap(x)); }
+function bitnotBytes5(Bytes5 x) pure returns (Bytes5) { return Bytes5.wrap(~Bytes5.unwrap(x)); }
+function bitnotBytes6(Bytes6 x) pure returns (Bytes6) { return Bytes6.wrap(~Bytes6.unwrap(x)); }
+function bitnotBytes7(Bytes7 x) pure returns (Bytes7) { return Bytes7.wrap(~Bytes7.unwrap(x)); }
+function bitnotBytes8(Bytes8 x) pure returns (Bytes8) { return Bytes8.wrap(~Bytes8.unwrap(x)); }
+function bitnotBytes9(Bytes9 x) pure returns (Bytes9) { return Bytes9.wrap(~Bytes9.unwrap(x)); }
+function bitnotBytes10(Bytes10 x) pure returns (Bytes10) { return Bytes10.wrap(~Bytes10.unwrap(x)); }
+function bitnotBytes11(Bytes11 x) pure returns (Bytes11) { return Bytes11.wrap(~Bytes11.unwrap(x)); }
+function bitnotBytes12(Bytes12 x) pure returns (Bytes12) { return Bytes12.wrap(~Bytes12.unwrap(x)); }
+function bitnotBytes13(Bytes13 x) pure returns (Bytes13) { return Bytes13.wrap(~Bytes13.unwrap(x)); }
+function bitnotBytes14(Bytes14 x) pure returns (Bytes14) { return Bytes14.wrap(~Bytes14.unwrap(x)); }
+function bitnotBytes15(Bytes15 x) pure returns (Bytes15) { return Bytes15.wrap(~Bytes15.unwrap(x)); }
+function bitnotBytes16(Bytes16 x) pure returns (Bytes16) { return Bytes16.wrap(~Bytes16.unwrap(x)); }
+function bitnotBytes17(Bytes17 x) pure returns (Bytes17) { return Bytes17.wrap(~Bytes17.unwrap(x)); }
+function bitnotBytes18(Bytes18 x) pure returns (Bytes18) { return Bytes18.wrap(~Bytes18.unwrap(x)); }
+function bitnotBytes19(Bytes19 x) pure returns (Bytes19) { return Bytes19.wrap(~Bytes19.unwrap(x)); }
+function bitnotBytes20(Bytes20 x) pure returns (Bytes20) { return Bytes20.wrap(~Bytes20.unwrap(x)); }
+function bitnotBytes21(Bytes21 x) pure returns (Bytes21) { return Bytes21.wrap(~Bytes21.unwrap(x)); }
+function bitnotBytes22(Bytes22 x) pure returns (Bytes22) { return Bytes22.wrap(~Bytes22.unwrap(x)); }
+function bitnotBytes23(Bytes23 x) pure returns (Bytes23) { return Bytes23.wrap(~Bytes23.unwrap(x)); }
+function bitnotBytes24(Bytes24 x) pure returns (Bytes24) { return Bytes24.wrap(~Bytes24.unwrap(x)); }
+function bitnotBytes25(Bytes25 x) pure returns (Bytes25) { return Bytes25.wrap(~Bytes25.unwrap(x)); }
+function bitnotBytes26(Bytes26 x) pure returns (Bytes26) { return Bytes26.wrap(~Bytes26.unwrap(x)); }
+function bitnotBytes27(Bytes27 x) pure returns (Bytes27) { return Bytes27.wrap(~Bytes27.unwrap(x)); }
+function bitnotBytes28(Bytes28 x) pure returns (Bytes28) { return Bytes28.wrap(~Bytes28.unwrap(x)); }
+function bitnotBytes29(Bytes29 x) pure returns (Bytes29) { return Bytes29.wrap(~Bytes29.unwrap(x)); }
+function bitnotBytes30(Bytes30 x) pure returns (Bytes30) { return Bytes30.wrap(~Bytes30.unwrap(x)); }
+function bitnotBytes31(Bytes31 x) pure returns (Bytes31) { return Bytes31.wrap(~Bytes31.unwrap(x)); }
+function bitnotBytes32(Bytes32 x) pure returns (Bytes32) { return Bytes32.wrap(~Bytes32.unwrap(x)); }
+
+using {bitorAddress as |, bitnotAddress as ~} for Address global;
+using {bitorAddressPayable as |, bitnotAddressPayable as ~} for AddressPayable global;
+using {bitorBool as |, bitnotBool as ~} for Bool global;
+
+function bitorAddress(Address x, Address y) pure returns (Address) {
+    return Address.wrap(address(bytes20(Address.unwrap(x)) | bytes20(Address.unwrap(y))));
+}
+function bitnotAddress(Address x) pure returns (Address) {
+    return Address.wrap(address(~bytes20(Address.unwrap(x))));
+}
+
+function bitorAddressPayable(AddressPayable x, AddressPayable y) pure returns (AddressPayable) {
+    return AddressPayable.wrap(payable(address(bytes20(address(AddressPayable.unwrap(x))) | bytes20(address(AddressPayable.unwrap(y))))));
+}
+function bitnotAddressPayable(AddressPayable x) pure returns (AddressPayable) {
+    return AddressPayable.wrap(payable(address(~bytes20(address(AddressPayable.unwrap(x))))));
+}
+
+function bitorBool(Bool x, Bool y) pure returns (Bool) {
+    return Bool.wrap(Bool.unwrap(x) || Bool.unwrap(y));
+}
+function bitnotBool(Bool x) pure returns (Bool) {
+    return Bool.wrap(!Bool.unwrap(x));
+}
+
+contract C {
+    function testIntBinary() public pure {
+        assert(Int8.unwrap(Int8.wrap(1) | Int8.wrap(2)) == 3);
+        assert(Int16.unwrap(Int16.wrap(1) | Int16.wrap(2)) == 3);
+        assert(Int24.unwrap(Int24.wrap(1) | Int24.wrap(2)) == 3);
+        assert(Int32.unwrap(Int32.wrap(1) | Int32.wrap(2)) == 3);
+        assert(Int40.unwrap(Int40.wrap(1) | Int40.wrap(2)) == 3);
+        assert(Int48.unwrap(Int48.wrap(1) | Int48.wrap(2)) == 3);
+        assert(Int56.unwrap(Int56.wrap(1) | Int56.wrap(2)) == 3);
+        assert(Int64.unwrap(Int64.wrap(1) | Int64.wrap(2)) == 3);
+        assert(Int72.unwrap(Int72.wrap(1) | Int72.wrap(2)) == 3);
+        assert(Int80.unwrap(Int80.wrap(1) | Int80.wrap(2)) == 3);
+        assert(Int88.unwrap(Int88.wrap(1) | Int88.wrap(2)) == 3);
+        assert(Int96.unwrap(Int96.wrap(1) | Int96.wrap(2)) == 3);
+        assert(Int104.unwrap(Int104.wrap(1) | Int104.wrap(2)) == 3);
+        assert(Int112.unwrap(Int112.wrap(1) | Int112.wrap(2)) == 3);
+        assert(Int120.unwrap(Int120.wrap(1) | Int120.wrap(2)) == 3);
+        assert(Int128.unwrap(Int128.wrap(1) | Int128.wrap(2)) == 3);
+        assert(Int136.unwrap(Int136.wrap(1) | Int136.wrap(2)) == 3);
+        assert(Int144.unwrap(Int144.wrap(1) | Int144.wrap(2)) == 3);
+        assert(Int152.unwrap(Int152.wrap(1) | Int152.wrap(2)) == 3);
+        assert(Int160.unwrap(Int160.wrap(1) | Int160.wrap(2)) == 3);
+        assert(Int168.unwrap(Int168.wrap(1) | Int168.wrap(2)) == 3);
+        assert(Int176.unwrap(Int176.wrap(1) | Int176.wrap(2)) == 3);
+        assert(Int184.unwrap(Int184.wrap(1) | Int184.wrap(2)) == 3);
+        assert(Int192.unwrap(Int192.wrap(1) | Int192.wrap(2)) == 3);
+        assert(Int200.unwrap(Int200.wrap(1) | Int200.wrap(2)) == 3);
+        assert(Int208.unwrap(Int208.wrap(1) | Int208.wrap(2)) == 3);
+        assert(Int216.unwrap(Int216.wrap(1) | Int216.wrap(2)) == 3);
+        assert(Int224.unwrap(Int224.wrap(1) | Int224.wrap(2)) == 3);
+        assert(Int232.unwrap(Int232.wrap(1) | Int232.wrap(2)) == 3);
+        assert(Int240.unwrap(Int240.wrap(1) | Int240.wrap(2)) == 3);
+        assert(Int248.unwrap(Int248.wrap(1) | Int248.wrap(2)) == 3);
+        assert(Int256.unwrap(Int256.wrap(1) | Int256.wrap(2)) == 3);
+        assert(Int.unwrap(Int.wrap(1) | Int.wrap(2)) == 3);
+    }
+
+    function testIntUnary() public pure {
+        assert(Int8.unwrap(-Int8.wrap(1)) == -1);
+        assert(Int16.unwrap(-Int16.wrap(1)) == -1);
+        assert(Int24.unwrap(-Int24.wrap(1)) == -1);
+        assert(Int32.unwrap(-Int32.wrap(1)) == -1);
+        assert(Int40.unwrap(-Int40.wrap(1)) == -1);
+        assert(Int48.unwrap(-Int48.wrap(1)) == -1);
+        assert(Int56.unwrap(-Int56.wrap(1)) == -1);
+        assert(Int64.unwrap(-Int64.wrap(1)) == -1);
+        assert(Int72.unwrap(-Int72.wrap(1)) == -1);
+        assert(Int80.unwrap(-Int80.wrap(1)) == -1);
+        assert(Int88.unwrap(-Int88.wrap(1)) == -1);
+        assert(Int96.unwrap(-Int96.wrap(1)) == -1);
+        assert(Int104.unwrap(-Int104.wrap(1)) == -1);
+        assert(Int112.unwrap(-Int112.wrap(1)) == -1);
+        assert(Int120.unwrap(-Int120.wrap(1)) == -1);
+        assert(Int128.unwrap(-Int128.wrap(1)) == -1);
+        assert(Int136.unwrap(-Int136.wrap(1)) == -1);
+        assert(Int144.unwrap(-Int144.wrap(1)) == -1);
+        assert(Int152.unwrap(-Int152.wrap(1)) == -1);
+        assert(Int160.unwrap(-Int160.wrap(1)) == -1);
+        assert(Int168.unwrap(-Int168.wrap(1)) == -1);
+        assert(Int176.unwrap(-Int176.wrap(1)) == -1);
+        assert(Int184.unwrap(-Int184.wrap(1)) == -1);
+        assert(Int192.unwrap(-Int192.wrap(1)) == -1);
+        assert(Int200.unwrap(-Int200.wrap(1)) == -1);
+        assert(Int208.unwrap(-Int208.wrap(1)) == -1);
+        assert(Int216.unwrap(-Int216.wrap(1)) == -1);
+        assert(Int224.unwrap(-Int224.wrap(1)) == -1);
+        assert(Int232.unwrap(-Int232.wrap(1)) == -1);
+        assert(Int240.unwrap(-Int240.wrap(1)) == -1);
+        assert(Int248.unwrap(-Int248.wrap(1)) == -1);
+        assert(Int256.unwrap(-Int256.wrap(1)) == -1);
+        assert(Int.unwrap(-Int.wrap(1)) == -1);
+    }
+
+    function testUintBinary() public pure {
+        assert(Uint8.unwrap(Uint8.wrap(1) | Uint8.wrap(2)) == 3);
+        assert(Uint16.unwrap(Uint16.wrap(1) | Uint16.wrap(2)) == 3);
+        assert(Uint24.unwrap(Uint24.wrap(1) | Uint24.wrap(2)) == 3);
+        assert(Uint32.unwrap(Uint32.wrap(1) | Uint32.wrap(2)) == 3);
+        assert(Uint40.unwrap(Uint40.wrap(1) | Uint40.wrap(2)) == 3);
+        assert(Uint48.unwrap(Uint48.wrap(1) | Uint48.wrap(2)) == 3);
+        assert(Uint56.unwrap(Uint56.wrap(1) | Uint56.wrap(2)) == 3);
+        assert(Uint64.unwrap(Uint64.wrap(1) | Uint64.wrap(2)) == 3);
+        assert(Uint72.unwrap(Uint72.wrap(1) | Uint72.wrap(2)) == 3);
+        assert(Uint80.unwrap(Uint80.wrap(1) | Uint80.wrap(2)) == 3);
+        assert(Uint88.unwrap(Uint88.wrap(1) | Uint88.wrap(2)) == 3);
+        assert(Uint96.unwrap(Uint96.wrap(1) | Uint96.wrap(2)) == 3);
+        assert(Uint104.unwrap(Uint104.wrap(1) | Uint104.wrap(2)) == 3);
+        assert(Uint112.unwrap(Uint112.wrap(1) | Uint112.wrap(2)) == 3);
+        assert(Uint120.unwrap(Uint120.wrap(1) | Uint120.wrap(2)) == 3);
+        assert(Uint128.unwrap(Uint128.wrap(1) | Uint128.wrap(2)) == 3);
+        assert(Uint136.unwrap(Uint136.wrap(1) | Uint136.wrap(2)) == 3);
+        assert(Uint144.unwrap(Uint144.wrap(1) | Uint144.wrap(2)) == 3);
+        assert(Uint152.unwrap(Uint152.wrap(1) | Uint152.wrap(2)) == 3);
+        assert(Uint160.unwrap(Uint160.wrap(1) | Uint160.wrap(2)) == 3);
+        assert(Uint168.unwrap(Uint168.wrap(1) | Uint168.wrap(2)) == 3);
+        assert(Uint176.unwrap(Uint176.wrap(1) | Uint176.wrap(2)) == 3);
+        assert(Uint184.unwrap(Uint184.wrap(1) | Uint184.wrap(2)) == 3);
+        assert(Uint192.unwrap(Uint192.wrap(1) | Uint192.wrap(2)) == 3);
+        assert(Uint200.unwrap(Uint200.wrap(1) | Uint200.wrap(2)) == 3);
+        assert(Uint208.unwrap(Uint208.wrap(1) | Uint208.wrap(2)) == 3);
+        assert(Uint216.unwrap(Uint216.wrap(1) | Uint216.wrap(2)) == 3);
+        assert(Uint224.unwrap(Uint224.wrap(1) | Uint224.wrap(2)) == 3);
+        assert(Uint232.unwrap(Uint232.wrap(1) | Uint232.wrap(2)) == 3);
+        assert(Uint240.unwrap(Uint240.wrap(1) | Uint240.wrap(2)) == 3);
+        assert(Uint248.unwrap(Uint248.wrap(1) | Uint248.wrap(2)) == 3);
+        assert(Uint256.unwrap(Uint256.wrap(1) | Uint256.wrap(2)) == 3);
+        assert(Uint.unwrap(Uint.wrap(1) | Uint.wrap(2)) == 3);
+    }
+
+    function testUintUnary() public pure {
+        assert(Uint8.unwrap(~Uint8.wrap(1)) == ~uint8(1));
+        assert(Uint16.unwrap(~Uint16.wrap(1)) == ~uint16(1));
+        assert(Uint24.unwrap(~Uint24.wrap(1)) == ~uint24(1));
+        assert(Uint32.unwrap(~Uint32.wrap(1)) == ~uint32(1));
+        assert(Uint40.unwrap(~Uint40.wrap(1)) == ~uint40(1));
+        assert(Uint48.unwrap(~Uint48.wrap(1)) == ~uint48(1));
+        assert(Uint56.unwrap(~Uint56.wrap(1)) == ~uint56(1));
+        assert(Uint64.unwrap(~Uint64.wrap(1)) == ~uint64(1));
+        assert(Uint72.unwrap(~Uint72.wrap(1)) == ~uint72(1));
+        assert(Uint80.unwrap(~Uint80.wrap(1)) == ~uint80(1));
+        assert(Uint88.unwrap(~Uint88.wrap(1)) == ~uint88(1));
+        assert(Uint96.unwrap(~Uint96.wrap(1)) == ~uint96(1));
+        assert(Uint104.unwrap(~Uint104.wrap(1)) == ~uint104(1));
+        assert(Uint112.unwrap(~Uint112.wrap(1)) == ~uint112(1));
+        assert(Uint120.unwrap(~Uint120.wrap(1)) == ~uint120(1));
+        assert(Uint128.unwrap(~Uint128.wrap(1)) == ~uint128(1));
+        assert(Uint136.unwrap(~Uint136.wrap(1)) == ~uint136(1));
+        assert(Uint144.unwrap(~Uint144.wrap(1)) == ~uint144(1));
+        assert(Uint152.unwrap(~Uint152.wrap(1)) == ~uint152(1));
+        assert(Uint160.unwrap(~Uint160.wrap(1)) == ~uint160(1));
+        assert(Uint168.unwrap(~Uint168.wrap(1)) == ~uint168(1));
+        assert(Uint176.unwrap(~Uint176.wrap(1)) == ~uint176(1));
+        assert(Uint184.unwrap(~Uint184.wrap(1)) == ~uint184(1));
+        assert(Uint192.unwrap(~Uint192.wrap(1)) == ~uint192(1));
+        assert(Uint200.unwrap(~Uint200.wrap(1)) == ~uint200(1));
+        assert(Uint208.unwrap(~Uint208.wrap(1)) == ~uint208(1));
+        assert(Uint216.unwrap(~Uint216.wrap(1)) == ~uint216(1));
+        assert(Uint224.unwrap(~Uint224.wrap(1)) == ~uint224(1));
+        assert(Uint232.unwrap(~Uint232.wrap(1)) == ~uint232(1));
+        assert(Uint240.unwrap(~Uint240.wrap(1)) == ~uint240(1));
+        assert(Uint248.unwrap(~Uint248.wrap(1)) == ~uint248(1));
+        assert(Uint256.unwrap(~Uint256.wrap(1)) == ~uint256(1));
+        assert(Uint.unwrap(~Uint.wrap(1)) == ~uint(1));
+    }
+
+    function testBytesBinary() public pure {
+        assert(Bytes1.unwrap(Bytes1.wrap(0x01) | Bytes1.wrap(0x02)) == bytes1(0x03));
+        assert(Bytes2.unwrap(Bytes2.wrap(bytes2(bytes1(0x01))) | Bytes2.wrap(bytes2(bytes1(0x02)))) == bytes2(bytes1(0x03)));
+        assert(Bytes3.unwrap(Bytes3.wrap(bytes3(bytes1(0x01))) | Bytes3.wrap(bytes3(bytes1(0x02)))) == bytes3(bytes1(0x03)));
+        assert(Bytes4.unwrap(Bytes4.wrap(bytes4(bytes1(0x01))) | Bytes4.wrap(bytes4(bytes1(0x02)))) == bytes4(bytes1(0x03)));
+        assert(Bytes5.unwrap(Bytes5.wrap(bytes5(bytes1(0x01))) | Bytes5.wrap(bytes5(bytes1(0x02)))) == bytes5(bytes1(0x03)));
+        assert(Bytes6.unwrap(Bytes6.wrap(bytes6(bytes1(0x01))) | Bytes6.wrap(bytes6(bytes1(0x02)))) == bytes6(bytes1(0x03)));
+        assert(Bytes7.unwrap(Bytes7.wrap(bytes7(bytes1(0x01))) | Bytes7.wrap(bytes7(bytes1(0x02)))) == bytes7(bytes1(0x03)));
+        assert(Bytes8.unwrap(Bytes8.wrap(bytes8(bytes1(0x01))) | Bytes8.wrap(bytes8(bytes1(0x02)))) == bytes8(bytes1(0x03)));
+        assert(Bytes9.unwrap(Bytes9.wrap(bytes9(bytes1(0x01))) | Bytes9.wrap(bytes9(bytes1(0x02)))) == bytes9(bytes1(0x03)));
+        assert(Bytes10.unwrap(Bytes10.wrap(bytes10(bytes1(0x01))) | Bytes10.wrap(bytes10(bytes1(0x02)))) == bytes10(bytes1(0x03)));
+        assert(Bytes11.unwrap(Bytes11.wrap(bytes11(bytes1(0x01))) | Bytes11.wrap(bytes11(bytes1(0x02)))) == bytes11(bytes1(0x03)));
+        assert(Bytes12.unwrap(Bytes12.wrap(bytes12(bytes1(0x01))) | Bytes12.wrap(bytes12(bytes1(0x02)))) == bytes12(bytes1(0x03)));
+        assert(Bytes13.unwrap(Bytes13.wrap(bytes13(bytes1(0x01))) | Bytes13.wrap(bytes13(bytes1(0x02)))) == bytes13(bytes1(0x03)));
+        assert(Bytes14.unwrap(Bytes14.wrap(bytes14(bytes1(0x01))) | Bytes14.wrap(bytes14(bytes1(0x02)))) == bytes14(bytes1(0x03)));
+        assert(Bytes15.unwrap(Bytes15.wrap(bytes15(bytes1(0x01))) | Bytes15.wrap(bytes15(bytes1(0x02)))) == bytes15(bytes1(0x03)));
+        assert(Bytes16.unwrap(Bytes16.wrap(bytes16(bytes1(0x01))) | Bytes16.wrap(bytes16(bytes1(0x02)))) == bytes16(bytes1(0x03)));
+        assert(Bytes17.unwrap(Bytes17.wrap(bytes17(bytes1(0x01))) | Bytes17.wrap(bytes17(bytes1(0x02)))) == bytes17(bytes1(0x03)));
+        assert(Bytes18.unwrap(Bytes18.wrap(bytes18(bytes1(0x01))) | Bytes18.wrap(bytes18(bytes1(0x02)))) == bytes18(bytes1(0x03)));
+        assert(Bytes19.unwrap(Bytes19.wrap(bytes19(bytes1(0x01))) | Bytes19.wrap(bytes19(bytes1(0x02)))) == bytes19(bytes1(0x03)));
+        assert(Bytes20.unwrap(Bytes20.wrap(bytes20(bytes1(0x01))) | Bytes20.wrap(bytes20(bytes1(0x02)))) == bytes20(bytes1(0x03)));
+        assert(Bytes21.unwrap(Bytes21.wrap(bytes21(bytes1(0x01))) | Bytes21.wrap(bytes21(bytes1(0x02)))) == bytes21(bytes1(0x03)));
+        assert(Bytes22.unwrap(Bytes22.wrap(bytes22(bytes1(0x01))) | Bytes22.wrap(bytes22(bytes1(0x02)))) == bytes22(bytes1(0x03)));
+        assert(Bytes23.unwrap(Bytes23.wrap(bytes23(bytes1(0x01))) | Bytes23.wrap(bytes23(bytes1(0x02)))) == bytes23(bytes1(0x03)));
+        assert(Bytes24.unwrap(Bytes24.wrap(bytes24(bytes1(0x01))) | Bytes24.wrap(bytes24(bytes1(0x02)))) == bytes24(bytes1(0x03)));
+        assert(Bytes25.unwrap(Bytes25.wrap(bytes25(bytes1(0x01))) | Bytes25.wrap(bytes25(bytes1(0x02)))) == bytes25(bytes1(0x03)));
+        assert(Bytes26.unwrap(Bytes26.wrap(bytes26(bytes1(0x01))) | Bytes26.wrap(bytes26(bytes1(0x02)))) == bytes26(bytes1(0x03)));
+        assert(Bytes27.unwrap(Bytes27.wrap(bytes27(bytes1(0x01))) | Bytes27.wrap(bytes27(bytes1(0x02)))) == bytes27(bytes1(0x03)));
+        assert(Bytes28.unwrap(Bytes28.wrap(bytes28(bytes1(0x01))) | Bytes28.wrap(bytes28(bytes1(0x02)))) == bytes28(bytes1(0x03)));
+        assert(Bytes29.unwrap(Bytes29.wrap(bytes29(bytes1(0x01))) | Bytes29.wrap(bytes29(bytes1(0x02)))) == bytes29(bytes1(0x03)));
+        assert(Bytes30.unwrap(Bytes30.wrap(bytes30(bytes1(0x01))) | Bytes30.wrap(bytes30(bytes1(0x02)))) == bytes30(bytes1(0x03)));
+        assert(Bytes31.unwrap(Bytes31.wrap(bytes31(bytes1(0x01))) | Bytes31.wrap(bytes31(bytes1(0x02)))) == bytes31(bytes1(0x03)));
+        assert(Bytes32.unwrap(Bytes32.wrap(bytes32(bytes1(0x01))) | Bytes32.wrap(bytes32(bytes1(0x02)))) == bytes32(bytes1(0x03)));
+    }
+
+    function testBytesUnary() public pure {
+        assert(Bytes1.unwrap(~Bytes1.wrap(bytes1(0x01))) == ~bytes1(0x01));
+        assert(Bytes2.unwrap(~Bytes2.wrap(bytes2(bytes1(0x01)))) == ~bytes2(bytes1(0x01)));
+        assert(Bytes3.unwrap(~Bytes3.wrap(bytes3(bytes1(0x01)))) == ~bytes3(bytes1(0x01)));
+        assert(Bytes4.unwrap(~Bytes4.wrap(bytes4(bytes1(0x01)))) == ~bytes4(bytes1(0x01)));
+        assert(Bytes5.unwrap(~Bytes5.wrap(bytes5(bytes1(0x01)))) == ~bytes5(bytes1(0x01)));
+        assert(Bytes6.unwrap(~Bytes6.wrap(bytes6(bytes1(0x01)))) == ~bytes6(bytes1(0x01)));
+        assert(Bytes7.unwrap(~Bytes7.wrap(bytes7(bytes1(0x01)))) == ~bytes7(bytes1(0x01)));
+        assert(Bytes8.unwrap(~Bytes8.wrap(bytes8(bytes1(0x01)))) == ~bytes8(bytes1(0x01)));
+        assert(Bytes9.unwrap(~Bytes9.wrap(bytes9(bytes1(0x01)))) == ~bytes9(bytes1(0x01)));
+        assert(Bytes10.unwrap(~Bytes10.wrap(bytes10(bytes1(0x01)))) == ~bytes10(bytes1(0x01)));
+        assert(Bytes11.unwrap(~Bytes11.wrap(bytes11(bytes1(0x01)))) == ~bytes11(bytes1(0x01)));
+        assert(Bytes12.unwrap(~Bytes12.wrap(bytes12(bytes1(0x01)))) == ~bytes12(bytes1(0x01)));
+        assert(Bytes13.unwrap(~Bytes13.wrap(bytes13(bytes1(0x01)))) == ~bytes13(bytes1(0x01)));
+        assert(Bytes14.unwrap(~Bytes14.wrap(bytes14(bytes1(0x01)))) == ~bytes14(bytes1(0x01)));
+        assert(Bytes15.unwrap(~Bytes15.wrap(bytes15(bytes1(0x01)))) == ~bytes15(bytes1(0x01)));
+        assert(Bytes16.unwrap(~Bytes16.wrap(bytes16(bytes1(0x01)))) == ~bytes16(bytes1(0x01)));
+        assert(Bytes17.unwrap(~Bytes17.wrap(bytes17(bytes1(0x01)))) == ~bytes17(bytes1(0x01)));
+        assert(Bytes18.unwrap(~Bytes18.wrap(bytes18(bytes1(0x01)))) == ~bytes18(bytes1(0x01)));
+        assert(Bytes19.unwrap(~Bytes19.wrap(bytes19(bytes1(0x01)))) == ~bytes19(bytes1(0x01)));
+        assert(Bytes20.unwrap(~Bytes20.wrap(bytes20(bytes1(0x01)))) == ~bytes20(bytes1(0x01)));
+        assert(Bytes21.unwrap(~Bytes21.wrap(bytes21(bytes1(0x01)))) == ~bytes21(bytes1(0x01)));
+        assert(Bytes22.unwrap(~Bytes22.wrap(bytes22(bytes1(0x01)))) == ~bytes22(bytes1(0x01)));
+        assert(Bytes23.unwrap(~Bytes23.wrap(bytes23(bytes1(0x01)))) == ~bytes23(bytes1(0x01)));
+        assert(Bytes24.unwrap(~Bytes24.wrap(bytes24(bytes1(0x01)))) == ~bytes24(bytes1(0x01)));
+        assert(Bytes25.unwrap(~Bytes25.wrap(bytes25(bytes1(0x01)))) == ~bytes25(bytes1(0x01)));
+        assert(Bytes26.unwrap(~Bytes26.wrap(bytes26(bytes1(0x01)))) == ~bytes26(bytes1(0x01)));
+        assert(Bytes27.unwrap(~Bytes27.wrap(bytes27(bytes1(0x01)))) == ~bytes27(bytes1(0x01)));
+        assert(Bytes28.unwrap(~Bytes28.wrap(bytes28(bytes1(0x01)))) == ~bytes28(bytes1(0x01)));
+        assert(Bytes29.unwrap(~Bytes29.wrap(bytes29(bytes1(0x01)))) == ~bytes29(bytes1(0x01)));
+        assert(Bytes30.unwrap(~Bytes30.wrap(bytes30(bytes1(0x01)))) == ~bytes30(bytes1(0x01)));
+        assert(Bytes31.unwrap(~Bytes31.wrap(bytes31(bytes1(0x01)))) == ~bytes31(bytes1(0x01)));
+        assert(Bytes32.unwrap(~Bytes32.wrap(bytes32(bytes1(0x01)))) == ~bytes32(bytes1(0x01)));
+    }
+
+    function testOtherBinary() public pure {
+        assert(Address.unwrap(Address.wrap(address(0x01)) | Address.wrap(address(0x02))) == address(0x03));
+        assert(AddressPayable.unwrap(AddressPayable.wrap(payable(address(0x01))) | AddressPayable.wrap(payable(address(0x02)))) == payable(address(0x03)));
+        assert(Bool.unwrap(~Bool.wrap(true)) == false);
+    }
+
+    function testOtherUnary() public pure {
+        assert(Address.unwrap(~Address.wrap(address(0))) == address(~bytes20(0)));
+        assert(AddressPayable.unwrap(~AddressPayable.wrap(payable(address(0)))) == payable(address(~bytes20(0))));
+        assert(Bool.unwrap(~Bool.wrap(true)) == false);
+    }
+}
+// ----
+// testIntBinary() ->
+// testIntUnary() ->
+// testUintBinary() ->
+// testUintUnary() ->
+// testBytesBinary() ->
+// testBytesUnary() ->
+// testOtherBinary() ->
+// testOtherUnary() ->
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/attaching_and_defining_operator_with_same_function.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/attaching_and_defining_operator_with_same_function.sol
new file mode 100644
index 00000000..6f032386
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/attaching_and_defining_operator_with_same_function.sol
@@ -0,0 +1,20 @@
+type Int is int16;
+
+using {add as +, add} for Int global;
+
+function add(Int _a, Int _b) pure returns (Int) {
+    return Int.wrap(Int.unwrap(_a) + Int.unwrap(_b));
+}
+
+contract C {
+    function f() pure public returns (Int) {
+        return Int.wrap(5) + Int.wrap(5);
+    }
+
+    function g() pure public returns (Int) {
+        return Int.wrap(7).add(Int.wrap(6));
+    }
+}
+// ----
+// f() -> 10
+// g() -> 13
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/checked_operators.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/checked_operators.sol
new file mode 100644
index 00000000..599e894b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/checked_operators.sol
@@ -0,0 +1,22 @@
+type U8 is uint8;
+
+function checkedAdd(U8 x, U8 y) pure returns (U8) {
+    return U8.wrap(U8.unwrap(x) + U8.unwrap(y));
+}
+
+using {checkedAdd as +} for U8 global;
+
+contract C {
+    function testCheckedOperator() public pure returns (U8) {
+        return U8.wrap(250) + U8.wrap(10);
+    }
+
+    function testCheckedOperatorInUncheckedBlock() public pure returns (U8) {
+        unchecked {
+            return U8.wrap(250) + U8.wrap(10);
+        }
+    }
+}
+// ----
+// testCheckedOperator() -> FAILURE, hex"4e487b71", 0x11
+// testCheckedOperatorInUncheckedBlock() -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/consecutive_operator_invocations.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/consecutive_operator_invocations.sol
new file mode 100644
index 00000000..ef36294a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/consecutive_operator_invocations.sol
@@ -0,0 +1,18 @@
+type A is address;
+
+using {add as +} for A global;
+
+function add(A a, A b) pure returns (A) {
+    return A.wrap(address(uint160(A.unwrap(a)) + uint160(A.unwrap(b))));
+}
+
+contract C {
+    function g() public pure returns (A) {
+        A a = A.wrap(0x3333333333333333333333333333333333333333);
+        A b = A.wrap(0x1111111111111111111111111111111111111111);
+        A c = A.wrap(0x5555555555555555555555555555555555555555);
+        return a + b + c;
+    }
+}
+// ----
+// g() -> 0x9999999999999999999999999999999999999999
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/fixed_point_udvt_with_operators.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/fixed_point_udvt_with_operators.sol
new file mode 100644
index 00000000..6f17b16e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/fixed_point_udvt_with_operators.sol
@@ -0,0 +1,22 @@
+type Fixed is int128;
+using {add as +, mul as *} for Fixed global;
+
+int constant MULTIPLIER = 10**18;
+
+function add(Fixed a, Fixed b) pure returns (Fixed) {
+    return Fixed.wrap(Fixed.unwrap(a) + Fixed.unwrap(b));
+}
+
+function mul(Fixed a, Fixed b) pure returns (Fixed) {
+    int intermediate = (int(Fixed.unwrap(a)) * int(Fixed.unwrap(b))) / MULTIPLIER;
+    if (int128(intermediate) != intermediate) { revert("Overflow"); }
+    return Fixed.wrap(int128(intermediate));
+}
+
+contract C {
+    function applyInterest(Fixed value, Fixed percentage) public pure returns (Fixed result) {
+        return value + value * percentage;
+    }
+}
+// ----
+// applyInterest(int128,int128): 500000000000000000000, 100000000000000000 -> 550000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_different_types_different_functions_separate_directives.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_different_types_different_functions_separate_directives.sol
new file mode 100644
index 00000000..0b2d740a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_different_types_different_functions_separate_directives.sol
@@ -0,0 +1,26 @@
+type SmallInt is int;
+type BigInt is int;
+
+using {addSmall as +} for SmallInt global;
+using {addBig as +} for BigInt global;
+
+function addSmall(SmallInt a, SmallInt b) pure returns (SmallInt) {
+    return SmallInt.wrap(SmallInt.unwrap(a) + SmallInt.unwrap(b));
+}
+
+function addBig(BigInt a, BigInt b) pure returns (BigInt) {
+    return BigInt.wrap(10 * (BigInt.unwrap(a) + BigInt.unwrap(b)));
+}
+
+contract C {
+    function small() public pure returns (SmallInt) {
+        return SmallInt.wrap(1) + SmallInt.wrap(2);
+    }
+
+    function big() public pure returns (BigInt) {
+        return BigInt.wrap(3) + BigInt.wrap(4);
+    }
+}
+// ----
+// small() -> 3
+// big() -> 70
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_same_type_same_function_same_directive.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_same_type_same_function_same_directive.sol
new file mode 100644
index 00000000..3085d8e8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/multiple_operator_definitions_same_type_same_function_same_directive.sol
@@ -0,0 +1,20 @@
+type Int is int32;
+
+using {foo as +, foo as -} for Int global;
+
+function foo(Int a, Int b) pure returns(Int) {
+    return Int.wrap(Int.unwrap(a) + Int.unwrap(b));
+}
+
+contract C {
+    function f() pure public returns (Int) {
+        return Int.wrap(2) + Int.wrap(3);
+    }
+
+    function g() pure public returns (Int) {
+        return Int.wrap(6) - Int.wrap(1);
+    }
+}
+// ----
+// f() -> 5
+// g() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_definition_shadowing_builtin_keccak256.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_definition_shadowing_builtin_keccak256.sol
new file mode 100644
index 00000000..a26a750c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_definition_shadowing_builtin_keccak256.sol
@@ -0,0 +1,15 @@
+type Int is int16;
+
+using {keccak256 as +} for Int global;
+
+function keccak256(Int a, Int b) pure returns (Int) {
+    return Int.wrap(Int.unwrap(a) + Int.unwrap(b));
+}
+
+contract C {
+    function test() public returns (Int) {
+        return Int.wrap(3) + Int.wrap(4);
+    }
+}
+// ----
+// test() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_evaluation_order.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_evaluation_order.sol
new file mode 100644
index 00000000..781f21d1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_evaluation_order.sol
@@ -0,0 +1,83 @@
+type Bool is bool;
+using {add as +, mul as *, unsub as -} for Bool global;
+
+function add(Bool x, Bool y) pure returns (Bool) {
+    return Bool.wrap(Bool.unwrap(x) || Bool.unwrap(y));
+}
+
+function mul(Bool x, Bool y) pure returns (Bool) {
+    return Bool.wrap(Bool.unwrap(x) && Bool.unwrap(y));
+}
+
+function unsub(Bool x) pure returns (Bool) {
+    return Bool.wrap(!Bool.unwrap(x));
+}
+
+contract C {
+    event Wrapped(uint);
+    event Probe(Bool);
+
+    function toBool(uint x) public returns (Bool) {
+        emit Wrapped(x);
+        return Bool.wrap(x > 0);
+    }
+
+    function probe(Bool x) public returns (Bool) {
+        emit Probe(x);
+        return x;
+    }
+
+    function testSingleOperator() public {
+        toBool(0) +
+        (toBool(1) + toBool(2)) +
+        toBool(3);
+    }
+
+    function testTwoBinaryOperators() public {
+        toBool(0) * toBool(1) +
+        (toBool(2) * toBool(3)) +
+        toBool(4) * toBool(5);
+    }
+
+    function testBinaryAndUnaryOperators() public {
+        -toBool(0) * -toBool(1) +
+        (-toBool(2) * -toBool(3)) +
+        -toBool(4) * -toBool(5);
+    }
+
+    function testOperatorsNestedInCalls() public {
+        -probe(toBool(0) * -toBool(1)) +
+        (-probe(toBool(2) * -toBool(3))) +
+        -probe(toBool(4) * -toBool(5));
+    }
+}
+// ----
+// testSingleOperator() ->
+// ~ emit Wrapped(uint256): 0x00
+// ~ emit Wrapped(uint256): 0x01
+// ~ emit Wrapped(uint256): 0x02
+// ~ emit Wrapped(uint256): 0x03
+// testTwoBinaryOperators() ->
+// ~ emit Wrapped(uint256): 0x00
+// ~ emit Wrapped(uint256): 0x01
+// ~ emit Wrapped(uint256): 0x02
+// ~ emit Wrapped(uint256): 0x03
+// ~ emit Wrapped(uint256): 0x04
+// ~ emit Wrapped(uint256): 0x05
+// testBinaryAndUnaryOperators() ->
+// ~ emit Wrapped(uint256): 0x00
+// ~ emit Wrapped(uint256): 0x01
+// ~ emit Wrapped(uint256): 0x02
+// ~ emit Wrapped(uint256): 0x03
+// ~ emit Wrapped(uint256): 0x04
+// ~ emit Wrapped(uint256): 0x05
+// testOperatorsNestedInCalls() ->
+// ~ emit Wrapped(uint256): 0x00
+// ~ emit Wrapped(uint256): 0x01
+// ~ emit Probe(bool): 0x00
+// ~ emit Wrapped(uint256): 0x02
+// ~ emit Wrapped(uint256): 0x03
+// ~ emit Probe(bool): 0x00
+// ~ emit Wrapped(uint256): 0x04
+// ~ emit Wrapped(uint256): 0x05
+// ~ emit Probe(bool): 0x00
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol
new file mode 100644
index 00000000..ce6a0f48
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol
@@ -0,0 +1,61 @@
+type Int32 is int32;
+using {add as +, unsub as -} for Int32 global;
+
+function add(Int32 x, Int32 y) pure returns (Int32) {
+    return loadAdder().mul(x, y);
+}
+
+function unsub(Int32 x) pure returns (Int32) {
+    return loadAdder().inc(x);
+}
+
+interface IAdder {
+    function mul(Int32, Int32) external pure returns (Int32);
+    function inc(Int32) external pure returns (Int32);
+}
+
+contract Adder is IAdder {
+    function mul(Int32 x, Int32 y) external pure override returns (Int32) {
+        return Int32.wrap(Int32.unwrap(x) * Int32.unwrap(y));
+    }
+
+    function inc(Int32 x) external pure override returns (Int32) {
+        return Int32.wrap(Int32.unwrap(x) + 1);
+    }
+}
+
+function storeAdder(IAdder adder) pure {
+    assembly {
+        // This test would also work without assembly if we could hard-code an address here.
+        mstore(0, adder)
+    }
+}
+
+function loadAdder() pure returns (IAdder adder) {
+    assembly {
+        adder := mload(0)
+    }
+}
+
+contract C {
+    function testMul(Int32 x, Int32 y) public returns (Int32) {
+        storeAdder(new Adder());
+
+        return x + y;
+    }
+
+    function testInc(Int32 x) public returns (Int32) {
+        storeAdder(new Adder());
+
+        return -x;
+    }
+}
+// ----
+// testMul(int32,int32): 42, 10 -> 420
+// gas irOptimized: 102563
+// gas legacy: 183981
+// gas legacyOptimized: 123563
+// testInc(int32): 42 -> 43
+// gas irOptimized: 102386
+// gas legacy: 183239
+// gas legacyOptimized: 123251
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol
new file mode 100644
index 00000000..f3f8ebdc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol
@@ -0,0 +1,67 @@
+type Int32 is int32;
+using {add as +, unsub as -} for Int32 global;
+
+function add(Int32 x, Int32 y) pure returns (Int32) {
+    return loadAdder().mul(x, y);
+}
+
+function unsub(Int32 x) pure returns (Int32) {
+    return loadAdder().inc(x);
+}
+
+interface IAdderPure {
+    function mul(Int32, Int32) external pure returns (Int32);
+    function inc(Int32) external pure returns (Int32);
+}
+
+interface IAdderView {
+    function mul(Int32, Int32) external view returns (Int32);
+    function inc(Int32) external view returns (Int32);
+}
+
+contract Adder is IAdderView {
+    function mul(Int32 x, Int32 y) external view override returns (Int32) {
+        return Int32.wrap(Int32.unwrap(x) * Int32.unwrap(y));
+    }
+
+    function inc(Int32 x) external view override returns (Int32) {
+        return Int32.wrap(Int32.unwrap(x) + 1);
+    }
+}
+
+function storeAdder(IAdderView adder) pure {
+    assembly {
+        // This test would also work without assembly if we could hard-code an address here.
+        mstore(0, adder)
+    }
+}
+
+function loadAdder() pure returns (IAdderPure adder) {
+    assembly {
+        // The adder we stored is view but we cheat by using a modified version with pure functions
+        adder := mload(0)
+    }
+}
+
+contract C {
+    function testMul(Int32 x, Int32 y) public returns (Int32) {
+        storeAdder(new Adder());
+
+        return x + y;
+    }
+
+    function testInc(Int32 x) public returns (Int32) {
+        storeAdder(new Adder());
+
+        return -x;
+    }
+}
+// ----
+// testMul(int32,int32): 42, 10 -> 420
+// gas irOptimized: 102563
+// gas legacy: 183981
+// gas legacyOptimized: 123563
+// testInc(int32): 42 -> 43
+// gas irOptimized: 102386
+// gas legacy: 183239
+// gas legacyOptimized: 123251
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_and_return_cleanup_between_calls.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_and_return_cleanup_between_calls.sol
new file mode 100644
index 00000000..b51ad8da
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_and_return_cleanup_between_calls.sol
@@ -0,0 +1,22 @@
+type U8 is uint8;
+using {yoloAdd as +, yoloDiv as /} for U8 global;
+
+function yoloAdd(U8 x, U8 y) pure returns (U8 z) {
+    assembly {
+        z := add(x, y) // Wrong! No cleanup.
+    }
+}
+
+function yoloDiv(U8 x, U8 y) pure returns (U8 z) {
+    assembly {
+        z := div(x, y) // Wrong! No cleanup.
+    }
+}
+
+contract C {
+    function divAddNoOverflow(U8 a, U8 b, U8 c) external pure returns (U8) {
+        return a / (b + c);
+    }
+}
+// ----
+// divAddNoOverflow(uint8,uint8,uint8): 4, 0xff, 3 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_cleanup.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_cleanup.sol
new file mode 100644
index 00000000..fe37a0e1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_parameter_cleanup.sol
@@ -0,0 +1,40 @@
+type U8 is uint8;
+using {f as ~, add as +} for U8 global;
+
+function f(U8 x) pure returns (U8 z) {
+    assembly {
+        // NOTE: Not using shr so that the test works pre-constantinople too
+        z := div(x, 256)
+    }
+}
+
+function add(U8 x, U8 y) pure returns (U8 z) {
+    assembly {
+        z := add(div(x, 256), div(x, 256))
+    }
+}
+
+contract C {
+    function testUnary() external pure returns (U8, U8) {
+        U8 a;
+        assembly {
+            a := 0x4200
+        }
+        // If the result is not 0, no cleanup was performed.
+        return (~a, f(a));
+    }
+
+    function testBinary() external pure returns (U8, U8) {
+        U8 a;
+        U8 b;
+        assembly {
+            a := 0x4200
+            b := 0x4200
+        }
+        // If the result is not 0, no cleanup was performed.
+        return (a + b, add(a, b));
+    }
+}
+// ----
+// testUnary() -> 0x42, 0x42
+// testBinary() -> 0x84, 0x84
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_precendence.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_precendence.sol
new file mode 100644
index 00000000..961e0316
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_precendence.sol
@@ -0,0 +1,71 @@
+type Int is int64;
+using {
+    bitor as |, bitand as &, bitxor as ^, bitnot as ~,
+    add as +, sub as -, unsub as -, mul as *, div as /, mod as %
+} for Int global;
+
+function bitor(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) | Int.unwrap(y)); }
+function bitand(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) & Int.unwrap(y)); }
+function bitxor(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) ^ Int.unwrap(y)); }
+function bitnot(Int x) pure returns (Int) { return Int.wrap(~Int.unwrap(x)); }
+
+function add(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) + Int.unwrap(y)); }
+function sub(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) - Int.unwrap(y)); }
+function unsub(Int x) pure returns (Int) { return Int.wrap(-Int.unwrap(x)); }
+function mul(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) * Int.unwrap(y)); }
+function div(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) / Int.unwrap(y)); }
+function mod(Int x, Int y) pure returns (Int) { return Int.wrap(Int.unwrap(x) % Int.unwrap(y)); }
+
+contract C {
+    Int constant I0 = Int.wrap(0);
+    Int constant I1 = Int.wrap(1);
+    Int constant I2 = Int.wrap(2);
+    Int constant I3 = Int.wrap(3);
+    Int constant I4 = Int.wrap(4);
+    Int constant I5 = Int.wrap(5);
+    Int constant I6 = Int.wrap(6);
+    Int constant I7 = Int.wrap(7);
+    Int constant I8 = Int.wrap(8);
+    Int constant I10 = Int.wrap(10);
+    Int constant I13 = Int.wrap(13);
+    Int constant I15 = Int.wrap(15);
+    Int constant I20 = Int.wrap(20);
+    Int constant I128 = Int.wrap(128);
+
+    function testBitwise() public pure {
+        assert(Int.unwrap(I0 & I0 | I1) == (0 & 0 | 1));
+        assert(Int.unwrap(I0 & I0 | I1) == ((0 & 0) | 1));
+    }
+
+    function testBitwise_arithmetic() public pure {
+        assert(Int.unwrap(I2 + I2 & ~I1 | I6 * I6 - I4 & ~I3) == (2 + 2 & ~1 | 6 * 6 - 4 & ~3));
+        assert(Int.unwrap(I2 + I2 & ~I1 | I6 * I6 - I4 & ~I3) == (((2 + 2) & (~1)) | (((6 * 6) - 4) & (~3))));
+    }
+
+    function testArithmetic() public pure {
+        assert(Int.unwrap(I1 + I8 / I4 - I5 % I6 * I7) == (1 + 8 / 4 - 5 % 6 * 7));
+        assert(Int.unwrap(I1 + I8 / I4 - I5 % I6 * I7) == ((1 + (8 / 4)) - ((5 % 6) * 7)));
+    }
+
+    function testAll() public pure {
+        assert(
+            Int.unwrap(I128 + I1 - I10 + I4 & ~I1 ^ ~I1 * I2 | -I15 % -I10 * I20 / I2 + I13 & ~I3) ==
+            (128 + 1 - 10 + 4 & ~1 ^ ~1 * 2 | -15 % -10 * 20 / 2 + 13 & ~3)
+        );
+        assert(
+            Int.unwrap(I128 + I1 - I10 + I4 & ~I1 ^ ~I1 * I2 | -I15 % -I10 * I20 / I2 + I13 & ~I3) ==
+            (
+                (
+                    ((((128 + 1) - 10) + 4) & (~1)) ^
+                    ((~1) * 2)
+                ) |
+                ((((((-15) % (-10)) * 20) / 2) + 13) & (~3))
+            )
+        );
+    }
+}
+// ----
+// testBitwise() ->
+// testBitwise_arithmetic() ->
+// testArithmetic() ->
+// testAll() ->
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_return_parameter_cleanup.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_return_parameter_cleanup.sol
new file mode 100644
index 00000000..3798a003
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/operator_return_parameter_cleanup.sol
@@ -0,0 +1,58 @@
+type U8 is uint8;
+using {f as ~, g as +} for U8 global;
+
+function f(U8) pure returns (U8 z) {
+    assembly {
+        // Return a value with dirty bytes outside of uint8
+        z := 0xffff
+    }
+}
+
+function g(U8, U8) pure returns (U8 z) {
+    assembly {
+        // Return a value with dirty bytes outside of uint8
+        z := 0xffff
+    }
+}
+
+contract C {
+    function testUnary() external pure returns (uint, uint) {
+        U8 a; // Value does not matter
+
+        U8 opResult = ~a;
+        U8 fResult = f(a);
+
+        // Get the slot, including bytes outside of uint8
+        uint opResultFull;
+        uint fResultFull;
+        assembly {
+            opResultFull := opResult
+            fResultFull := fResult
+        }
+
+        // If the result is not 0xff, no cleanup was performed.
+        return (opResultFull, fResultFull);
+    }
+
+    function testBinary() external pure returns (uint, uint) {
+        U8 a; // Value does not matter
+        U8 b; // Value does not matter
+
+        U8 opResult = a + b;
+        U8 fResult = g(a, b);
+
+        // Get the slot, including bytes outside of uint8
+        uint opResultFull;
+        uint fResultFull;
+        assembly {
+            opResultFull := opResult
+            fResultFull := fResult
+        }
+
+        // If the result is not 0xff, no cleanup was performed.
+        return (opResultFull, fResultFull);
+    }
+}
+// ----
+// testUnary() -> 0xffff, 0xffff
+// testBinary() -> 0xffff, 0xffff
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/recursive_operator.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/recursive_operator.sol
new file mode 100644
index 00000000..3ce080c3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/recursive_operator.sol
@@ -0,0 +1,41 @@
+type Uint is uint;
+using {unaryCountdown as ~, binaryCountdown as ^, eq as ==} for Uint global;
+
+function unaryCountdown(Uint x) pure returns (Uint) {
+    if (x == Uint.wrap(0))
+        return Uint.wrap(0);
+
+    return ~Uint.wrap(Uint.unwrap(x) - 1);
+}
+
+function binaryCountdown(Uint x, Uint y) pure returns (Uint) {
+    if (x == Uint.wrap(0) && y == Uint.wrap(0))
+        return Uint.wrap(0);
+    if (x == Uint.wrap(0))
+        return y ^ x;
+
+    return Uint.wrap(Uint.unwrap(x) - 1) ^ y;
+}
+
+function eq(Uint x, Uint y) pure returns (bool) {
+    return Uint.unwrap(x) == Uint.unwrap(y);
+}
+
+contract C {
+    function testUnary(Uint x) public pure returns (Uint) {
+        return ~x;
+    }
+
+    function testBinary(Uint x, Uint y) public pure returns (Uint) {
+        return x ^ y;
+    }
+}
+// ----
+// testUnary(uint256): 0 -> 0
+// testUnary(uint256): 1 -> 0
+// testUnary(uint256): 99999999999 -> FAILURE
+// testBinary(uint256,uint256): 0, 0 -> 0
+// testBinary(uint256,uint256): 1, 0 -> 0
+// testBinary(uint256,uint256): 0, 1 -> 0
+// testBinary(uint256,uint256): 1, 1 -> 0
+// testBinary(uint256,uint256): 99999999999, 99999999999 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/operators/userDefined/unchecked_operators.sol b/compiler/test/libsolidity/semanticTests/operators/userDefined/unchecked_operators.sol
new file mode 100644
index 00000000..9f3fd5d4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/operators/userDefined/unchecked_operators.sol
@@ -0,0 +1,24 @@
+type U8 is uint8;
+
+function uncheckedAdd(U8 x, U8 y) pure returns (U8) {
+    unchecked {
+        return U8.wrap(U8.unwrap(x) + U8.unwrap(y));
+    }
+}
+
+using {uncheckedAdd as +} for U8 global;
+
+contract D {
+    function testUncheckedOperator() public pure returns (U8) {
+        return U8.wrap(250) + U8.wrap(10);
+    }
+
+    function testUncheckedOperatorInUncheckedBlock() public pure returns (U8) {
+        unchecked {
+            return U8.wrap(250) + U8.wrap(10);
+        }
+    }
+}
+// ----
+// testUncheckedOperator() -> 4
+// testUncheckedOperatorInUncheckedBlock() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/optimizer/shift_bytes.sol b/compiler/test/libsolidity/semanticTests/optimizer/shift_bytes.sol
new file mode 100644
index 00000000..6c7eef89
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/optimizer/shift_bytes.sol
@@ -0,0 +1,42 @@
+// This tests the optimizer rule
+// byte(A, shl(B, X))
+// ->
+// byte(A + B / 8, X)
+// given A <= 32 && B % 8 == 0 && B <= 256
+//
+// and the respective rule about shr
+contract C {
+  function f(uint a) public returns (uint, uint, uint) {
+    uint x = a << (256 - 8);
+    assembly {
+      x := byte(0, x)
+    }
+    uint y = a << 8;
+    assembly {
+      y := byte(30, y)
+    }
+    uint z = a << 16;
+    assembly {
+      z := byte(1, z)
+    }
+    return (x, y, z);
+  }
+  function g(uint a) public returns (uint, uint, uint) {
+    uint x = a >> (256 - 16);
+    assembly {
+      x := byte(31, x)
+    }
+    uint y = a >> 8;
+    assembly {
+      y := byte(4, y)
+    }
+    uint z = a >> 16;
+    assembly {
+      z := byte(7, z)
+    }
+    return (x, y, z);
+  }
+}
+// ----
+// f(uint256): 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f -> 0x1f, 0x1f, 3
+// g(uint256): 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f -> 1, 3, 5
diff --git a/compiler/test/libsolidity/semanticTests/payable/no_nonpayable_circumvention_by_modifier.sol b/compiler/test/libsolidity/semanticTests/payable/no_nonpayable_circumvention_by_modifier.sol
new file mode 100644
index 00000000..c3609591
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/payable/no_nonpayable_circumvention_by_modifier.sol
@@ -0,0 +1,14 @@
+contract C {
+    modifier tryCircumvent {
+        if (false) _; // avoid the function, we should still not accept ether
+    }
+    function f() tryCircumvent public returns (uint) {
+        return msgvalue();
+    }
+    function msgvalue() internal returns (uint) {
+        return msg.value;
+    }
+}
+// ----
+// f(), 27 wei -> FAILURE
+// balance -> 0
diff --git a/compiler/test/libsolidity/semanticTests/receive/empty_calldata_calls_receive.sol b/compiler/test/libsolidity/semanticTests/receive/empty_calldata_calls_receive.sol
new file mode 100644
index 00000000..ce04cd73
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/receive/empty_calldata_calls_receive.sol
@@ -0,0 +1,13 @@
+contract A {
+    uint public x;
+    receive () external payable { ++x; }
+}
+// ----
+// x() -> 0
+// ()
+// x() -> 1
+// (), 1 wei
+// x() -> 2
+// x(), 1 wei -> FAILURE
+// (): hex"00" -> FAILURE
+// (), 1 ether: hex"00" -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/receive/ether_and_data.sol b/compiler/test/libsolidity/semanticTests/receive/ether_and_data.sol
new file mode 100644
index 00000000..4c48df8d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/receive/ether_and_data.sol
@@ -0,0 +1,6 @@
+contract C {
+    receive () payable external { }
+}
+// ----
+// (), 1 ether
+// (), 1 ether: 1 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/receive/inherited.sol b/compiler/test/libsolidity/semanticTests/receive/inherited.sol
new file mode 100644
index 00000000..36273068
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/receive/inherited.sol
@@ -0,0 +1,12 @@
+contract A {
+    uint data;
+    receive() external payable { ++data; }
+    function getData() public returns (uint r) { return data; }
+}
+contract B is A {}
+// ----
+// getData() -> 0
+// () ->
+// getData() -> 1
+// (), 1 ether ->
+// getData() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/reverts/assert_require.sol b/compiler/test/libsolidity/semanticTests/reverts/assert_require.sol
new file mode 100644
index 00000000..bc4db360
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/assert_require.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public {
+        assert(false);
+    }
+
+    function g(bool val) public returns (bool) {
+        assert(val == true);
+        return true;
+    }
+
+    function h(bool val) public returns (bool) {
+        require(val);
+        return true;
+    }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x01
+// g(bool): false -> FAILURE, hex"4e487b71", 0x01
+// g(bool): true -> true
+// h(bool): false -> FAILURE
+// h(bool): true -> true
diff --git a/compiler/test/libsolidity/semanticTests/reverts/error_struct.sol b/compiler/test/libsolidity/semanticTests/reverts/error_struct.sol
new file mode 100644
index 00000000..d6171a41
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/error_struct.sol
@@ -0,0 +1,15 @@
+struct error { uint error; }
+contract C {
+	error test();
+	error _struct;
+	function f() public {
+		revert test();
+	}
+	function g(uint x) public returns (uint) {
+		_struct.error = x;
+		return _struct.error;
+	}
+}
+// ----
+// f() -> FAILURE, hex"f8a8fd6d"
+// g(uint256): 7 -> 7
diff --git a/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_arg.sol b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_arg.sol
new file mode 100644
index 00000000..28c4e01f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_arg.sol
@@ -0,0 +1,21 @@
+contract C {
+    enum X {A, B}
+
+    function tested(X x) public returns (uint256) {
+        return 1;
+    }
+
+    function test() public returns (uint256) {
+        X garbled;
+
+        assembly {
+            garbled := 5
+        }
+
+        return this.tested(garbled);
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// test() -> FAILURE, hex"4e487b71", 0x21 # should throw #
diff --git a/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_ret.sol b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_ret.sol
new file mode 100644
index 00000000..7416d295
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_as_external_ret.sol
@@ -0,0 +1,31 @@
+contract C {
+    enum X {A, B}
+
+    function test_return() public returns (X) {
+        X garbled;
+        assembly {
+            garbled := 5
+        }
+        return garbled;
+    }
+
+    function test_inline_assignment() public returns (X _ret) {
+        assembly {
+            _ret := 5
+        }
+    }
+
+    function test_assignment() public returns (X _ret) {
+        X tmp;
+        assembly {
+            tmp := 5
+        }
+        _ret = tmp;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// test_return() -> FAILURE, hex"4e487b71", 33 # both should throw #
+// test_inline_assignment() -> FAILURE, hex"4e487b71", 33
+// test_assignment() -> FAILURE, hex"4e487b71", 33
diff --git a/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_compared.sol b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_compared.sol
new file mode 100644
index 00000000..527a4320
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_compared.sol
@@ -0,0 +1,30 @@
+contract C {
+    enum X {A, B}
+
+    function test_eq() public returns (bool) {
+        X garbled;
+        assembly {
+            garbled := 5
+        }
+        return garbled == garbled;
+    }
+
+    function test_eq_ok() public returns (bool) {
+        X garbled = X.A;
+        return garbled == garbled;
+    }
+
+    function test_neq() public returns (bool) {
+        X garbled;
+        assembly {
+            garbled := 5
+        }
+        return garbled != garbled;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// test_eq_ok() -> 1
+// test_eq() -> FAILURE, hex"4e487b71", 33 # both should throw #
+// test_neq() -> FAILURE, hex"4e487b71", 33
diff --git a/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_stored.sol b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_stored.sol
new file mode 100644
index 00000000..8049a977
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/invalid_enum_stored.sol
@@ -0,0 +1,24 @@
+contract C {
+    enum X {A, B}
+    X public x;
+
+    function test_store() public returns (uint256) {
+        X garbled = X.A;
+        assembly {
+            garbled := 5
+        }
+        x = garbled;
+        return 1;
+    }
+
+    function test_store_ok() public returns (uint256) {
+        x = X.A;
+        return 1;
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// test_store_ok() -> 1
+// x() -> 0
+// test_store() -> FAILURE, hex"4e487b71", 33 # should throw #
diff --git a/compiler/test/libsolidity/semanticTests/reverts/invalid_instruction.sol b/compiler/test/libsolidity/semanticTests/reverts/invalid_instruction.sol
new file mode 100644
index 00000000..69d9a0cd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/invalid_instruction.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public {
+        assembly {
+            invalid()
+        }
+    }
+}
+// ----
+// f() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/reverts/revert.sol b/compiler/test/libsolidity/semanticTests/reverts/revert.sol
new file mode 100644
index 00000000..2d733b4e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/revert.sol
@@ -0,0 +1,20 @@
+contract C {
+    uint256 public a = 42;
+
+    function f() public {
+        a = 1;
+        revert();
+    }
+
+    function g() public {
+        a = 1;
+        assembly {
+            revert(0, 0)
+        }
+    }
+}
+// ----
+// f() -> FAILURE
+// a() -> 42
+// g() -> FAILURE
+// a() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/reverts/revert_return_area.sol b/compiler/test/libsolidity/semanticTests/reverts/revert_return_area.sol
new file mode 100644
index 00000000..8ab4ca22
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/revert_return_area.sol
@@ -0,0 +1,18 @@
+contract C {
+    fallback() external {
+        revert("abc");
+    }
+
+    function f() public returns (uint s, uint r) {
+        address x = address(this);
+        assembly {
+            mstore(0, 7)
+            s := call(sub(0, 1), x, 0, 0, 0, 0, 32)
+            r := mload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// f() -> 0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/reverts/simple_throw.sol b/compiler/test/libsolidity/semanticTests/reverts/simple_throw.sol
new file mode 100644
index 00000000..1c1bfee0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/reverts/simple_throw.sol
@@ -0,0 +1,10 @@
+contract Test {
+    function f(uint256 x) public returns (uint256) {
+        if (x > 10) return x + 10;
+        else revert();
+        return 2;
+    }
+}
+// ----
+// f(uint256): 11 -> 21
+// f(uint256): 1 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/salted_create/prediction_example.sol b/compiler/test/libsolidity/semanticTests/salted_create/prediction_example.sol
new file mode 100644
index 00000000..1c5ce63a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/salted_create/prediction_example.sol
@@ -0,0 +1,29 @@
+contract D {
+    uint public x;
+    constructor(uint a) {
+        x = a;
+    }
+}
+
+contract C {
+    function createDSalted(bytes32 salt, uint arg) public {
+        address predictedAddress = address(uint160(uint(keccak256(abi.encodePacked(
+            bytes1(0xff),
+            address(this),
+            salt,
+            keccak256(abi.encodePacked(
+                type(D).creationCode,
+                arg
+            ))
+        )))));
+
+        D d = new D{salt: salt}(arg);
+        require(address(d) == predictedAddress, "Address mismatch.");
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: also
+// ----
+// createDSalted(bytes32,uint256): 42, 64 ->
+// gas legacy: 102943
diff --git a/compiler/test/libsolidity/semanticTests/salted_create/salted_create.sol b/compiler/test/libsolidity/semanticTests/salted_create/salted_create.sol
new file mode 100644
index 00000000..743ff5fd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/salted_create/salted_create.sol
@@ -0,0 +1,26 @@
+contract B
+{
+}
+
+contract A {
+    function different_salt() public returns (bool) {
+        B x = new B{salt: "abc"}();
+        B y = new B{salt: "abcef"}();
+        return x != y;
+    }
+    function same_salt() public returns (bool) {
+        B x = new B{salt: "xyz"}();
+        try new B{salt: "xyz"}() {} catch {
+            return true;
+        }
+        return false;
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// different_salt() -> true
+// same_salt() -> true
+// gas irOptimized: 98438895
+// gas legacy: 98439109
+// gas legacyOptimized: 98438967
diff --git a/compiler/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol b/compiler/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol
new file mode 100644
index 00000000..c4db1747
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/salted_create/salted_create_with_value.sol
@@ -0,0 +1,26 @@
+contract B
+{
+    uint x;
+    function getBalance() public view returns (uint) {
+        return address(this).balance * 1000 + x;
+    }
+    constructor(uint _x) payable {
+        x = _x;
+    }
+}
+
+contract A {
+    function f() public payable returns (uint, uint, uint) {
+        B x = new B{salt: "abc", value: 3}(7);
+        B y = new B{value: 3, salt: "abc"}(8);
+        B z = new B{salt: "abc", value: 3}(9);
+        return (x.getBalance(), y.getBalance(), z.getBalance());
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// f(), 10 ether -> 3007, 3008, 3009
+// gas irOptimized: 253005
+// gas legacy: 381063
+// gas legacyOptimized: 279694
diff --git a/compiler/test/libsolidity/semanticTests/shanghai/evmone_support.sol b/compiler/test/libsolidity/semanticTests/shanghai/evmone_support.sol
new file mode 100644
index 00000000..359dc516
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/shanghai/evmone_support.sol
@@ -0,0 +1,31 @@
+contract ShortReturn {
+    constructor() {
+        assembly {
+            // return(0, 32)
+            // PUSH1 0x20 PUSH0 RETURN
+            mstore(0, hex"60205ff3")
+            return(0, 4)
+        }
+    }
+}
+
+interface DoesItReturnZero {
+    function foo() external pure returns (uint256);
+}
+
+contract Test {
+    ShortReturn immutable shortReturn = new ShortReturn();
+    function bytecode() external view returns(bytes memory) {
+        return address(shortReturn).code;
+    }
+    function isPush0Supported() external view returns (bool) {
+        assert(DoesItReturnZero(address(shortReturn)).foo() == 0);
+        return true;
+    }
+}
+// ====
+// compileViaYul: also
+// EVMVersion: >=shanghai
+// ----
+// bytecode() -> 0x20, 4, 0x60205ff300000000000000000000000000000000000000000000000000000000
+// isPush0Supported() -> true
diff --git a/compiler/test/libsolidity/semanticTests/shanghai/push0.sol b/compiler/test/libsolidity/semanticTests/shanghai/push0.sol
new file mode 100644
index 00000000..e1acaaae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/shanghai/push0.sol
@@ -0,0 +1,11 @@
+contract C {
+    function zero() external returns (uint) {
+        return 0;
+    }
+
+}
+// ====
+// compileViaYul: also
+// EVMVersion: >=shanghai
+// ----
+// zero() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/smoke/alignment.sol b/compiler/test/libsolidity/semanticTests/smoke/alignment.sol
new file mode 100644
index 00000000..3e8016f9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/alignment.sol
@@ -0,0 +1,29 @@
+contract C {
+    uint256 public stateDecimal = 0x20;
+}
+
+contract D {
+    bool public stateBool = true;
+    uint256 public stateDecimal = 42;
+    bytes32 public stateBytes = "\x42\x00\xef";
+
+    function internalStateDecimal() public returns (uint256) {
+        return (new C()).stateDecimal();
+    }
+
+    function update(bool _bool, uint256 _decimal, bytes32 _bytes) public returns (bool, uint256, bytes32) {
+        stateBool = _bool;
+        stateDecimal = _decimal;
+        stateBytes = _bytes;
+        return (stateBool, stateDecimal, stateBytes);
+    }
+}
+// ----
+// stateBool() -> true
+// stateBool() -> right(true)
+// stateDecimal() -> 42
+// stateDecimal() -> right(42)
+// stateBytes() -> left(0x4200ef)
+// internalStateDecimal() -> 0x20
+// gas legacy: 100265
+// update(bool,uint256,bytes32): false, -23, left(0x2300ef) -> false, -23, left(0x2300ef)
diff --git a/compiler/test/libsolidity/semanticTests/smoke/basic.sol b/compiler/test/libsolidity/semanticTests/smoke/basic.sol
new file mode 100644
index 00000000..8f05c426
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/basic.sol
@@ -0,0 +1,41 @@
+pragma abicoder               v2;
+
+contract C {
+    function d() public {
+    }
+    function e() public payable returns (uint) {
+        return msg.value;
+    }
+    function f(uint a) public pure returns (uint, uint) {
+        return (a, a);
+    }
+    function g() public  pure returns (uint, uint) {
+        return (2, 3);
+    }
+    function h(uint x, uint y) public  pure returns (uint) {
+        unchecked { return x - y; }
+    }
+    function i(bool b) public  pure returns (bool) {
+        return !b;
+    }
+    function j(bytes32 b) public pure returns (bytes32, bytes32) {
+        return (b, b);
+    }
+    function k() public pure returns (uint) {
+        return msg.data.length;
+    }
+    function l(uint a) public pure returns (uint d) {
+        return a * 7;
+    }
+}
+// ----
+// d() ->
+// e(), 1 wei -> 1
+// e(), 1 ether -> 1000000000000000000
+// f(uint256): 3 -> 3, 3
+// g() -> 2, 3
+// h(uint256,uint256): 1, -2 -> 3
+// i(bool): true -> false
+// j(bytes32): 0x10001 -> 0x10001, 0x10001
+// k(): hex"4200efef" -> 8
+// l(uint256): 99 -> 693
diff --git a/compiler/test/libsolidity/semanticTests/smoke/constructor.sol b/compiler/test/libsolidity/semanticTests/smoke/constructor.sol
new file mode 100644
index 00000000..79b92867
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/constructor.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint public state = 0;
+    constructor(uint _state) payable {
+        state = _state;
+    }
+    function balance() public payable returns (uint256) {
+        return address(this).balance;
+    }
+    function update(uint _state) public {
+        state = _state;
+    }
+}
+// ----
+// constructor(), 2 wei: 3 ->
+// gas irOptimized: 104412
+// gas legacy: 148308
+// gas legacyOptimized: 106727
+// state() -> 3
+// balance() -> 2
+// balance -> 2
+// update(uint256): 4
+// state() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/smoke/failure.sol b/compiler/test/libsolidity/semanticTests/smoke/failure.sol
new file mode 100644
index 00000000..14cf1e62
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/failure.sol
@@ -0,0 +1,24 @@
+contract C {
+    function e() public pure {
+        revert("Transaction failed.");
+    }
+    function f(bool _value) public pure {
+        string memory message;
+        require(_value, message);
+    }
+    function g(bool _value) public pure {
+        require(_value, "Value is false.");
+    }
+    function h() public pure returns (uint) {
+        assert(false);
+    }
+}
+// ====
+// EVMVersion: >homestead
+// allowNonExistingFunctions: true
+// ----
+// _() -> FAILURE
+// e() -> FAILURE, hex"08c379a0", 0x20, 0x13, "Transaction failed."
+// f(bool): false -> FAILURE, hex"08c379a0", 0x20, 0x00
+// g(bool): false -> FAILURE, hex"08c379a0", 0x20, 0x0f, "Value is false."
+// h() -> FAILURE, hex"4e487b71", 0x01
diff --git a/compiler/test/libsolidity/semanticTests/smoke/fallback.sol b/compiler/test/libsolidity/semanticTests/smoke/fallback.sol
new file mode 100644
index 00000000..b0e515db
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/fallback.sol
@@ -0,0 +1,23 @@
+contract A {
+    uint public data;
+    uint public balance;
+    bytes public externalData;
+    fallback() external payable {
+        data += 1;
+        balance = msg.value;
+        externalData = msg.data;
+    }
+}
+// ----
+// data() -> 0
+// ()
+// data() -> 1
+// (): hex"42ef"
+// data() -> 2
+// externalData() -> 0x20, 2, left(0x42ef)
+// balance() -> 0
+// (), 1 wei
+// balance() -> 1
+// (), 2 wei: hex"fefe"
+// balance() -> 2
+// externalData() -> 0x20, 2, left(0xfefe)
diff --git a/compiler/test/libsolidity/semanticTests/smoke/multiline.sol b/compiler/test/libsolidity/semanticTests/smoke/multiline.sol
new file mode 100644
index 00000000..624b1947
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/multiline.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f(uint a, uint b, uint c, uint d, uint e) public returns (uint) {
+        return a + b + c + d + e;
+    }
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// f(uint256,uint256,uint256,uint256,uint256): 1, 1, 1, 1, 1
+// -> 5
+// g()
+// # g() does not exist #
+// -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/smoke/multiline_comments.sol b/compiler/test/libsolidity/semanticTests/smoke/multiline_comments.sol
new file mode 100644
index 00000000..17de40fc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/multiline_comments.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f(uint a, uint b, uint c, uint d, uint e) public returns (uint) {
+        return a + b + c + d + e;
+    }
+}
+// ----
+// f(uint256,uint256,uint256,uint256,uint256): 1, 1, 1, 1, 1
+// # A comment on the function parameters. #
+// -> 5
+// f(uint256,uint256,uint256,uint256,uint256):
+// 1,
+// 1,
+// 1,
+// 1,
+// 1
+// -> 5
+// # Should return sum of all parameters. #
diff --git a/compiler/test/libsolidity/semanticTests/smoke/structs.sol b/compiler/test/libsolidity/semanticTests/smoke/structs.sol
new file mode 100644
index 00000000..d6df382c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/smoke/structs.sol
@@ -0,0 +1,22 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint a;
+        uint b;
+    }
+    struct T {
+        uint a;
+        uint b;
+        string s;
+    }
+    function s() public returns (S memory) {
+        return S(23, 42);
+    }
+    function t() public returns (T memory) {
+        return T(23, 42, "any");
+    }
+}
+// ----
+// s() -> 23, 42
+// t() -> 0x20, 23, 42, 0x60, 3, "any"
diff --git a/compiler/test/libsolidity/semanticTests/specialFunctions/abi_encode_with_signature_from_string.sol b/compiler/test/libsolidity/semanticTests/specialFunctions/abi_encode_with_signature_from_string.sol
new file mode 100644
index 00000000..80f734a3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/specialFunctions/abi_encode_with_signature_from_string.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public pure returns (bytes memory r1, bytes memory r2) {
+        string memory x = "my_signature";
+        r1 = abi.encodeWithSignature("my_signature", 1);
+        r2 = abi.encodeWithSignature(x, 1);
+        assert(r1.length == r2.length);
+        for (uint i = 0; i < r1.length; i++)
+            assert(r1[i] == r2[i]);
+    }
+}
+// ----
+// f() -> 0x40, 0xa0, 0x24, -813742827273327954027712588510533233455028711326166692885570228492575965184, 26959946667150639794667015087019630673637144422540572481103610249216, 0x24, -813742827273327954027712588510533233455028711326166692885570228492575965184, 26959946667150639794667015087019630673637144422540572481103610249216
diff --git a/compiler/test/libsolidity/semanticTests/specialFunctions/abi_functions_member_access.sol b/compiler/test/libsolidity/semanticTests/specialFunctions/abi_functions_member_access.sol
new file mode 100644
index 00000000..b255b188
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/specialFunctions/abi_functions_member_access.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        abi.encode;
+        abi.encodePacked;
+        abi.encodeWithSelector;
+        abi.encodeWithSignature;
+        abi.decode;
+    }
+}
+// ----
+// f() ->
diff --git a/compiler/test/libsolidity/semanticTests/state/blobhash.sol b/compiler/test/libsolidity/semanticTests/state/blobhash.sol
new file mode 100644
index 00000000..f27b4072
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/blobhash.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(uint _index) public returns (bytes32) {
+        return blobhash(_index);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f(uint256): 0 -> 0x0100000000000000000000000000000000000000000000000000000000000001
+// f(uint256): 1 -> 0x0100000000000000000000000000000000000000000000000000000000000002
+// f(uint256): 2 -> 0x00
+// f(uint256): 255 -> 0x00
+// f(uint256): 256 -> 0x00
+// f(uint256): 257 -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/state/block_blobbasefee.sol b/compiler/test/libsolidity/semanticTests/state/block_blobbasefee.sol
new file mode 100644
index 00000000..23da779e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_blobbasefee.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.blobbasefee;
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            ret := blobbasefee()
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 1
+// g() -> 1
+// f() -> 1
+// g() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/state/block_coinbase.sol b/compiler/test/libsolidity/semanticTests/state/block_coinbase.sol
new file mode 100644
index 00000000..e7aae2fc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_coinbase.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (address payable) {
+        return block.coinbase;
+    }
+}
+// ----
+// f() -> 0x7878787878787878787878787878787878787878
+// f() -> 0x7878787878787878787878787878787878787878
+// f() -> 0x7878787878787878787878787878787878787878
diff --git a/compiler/test/libsolidity/semanticTests/state/block_difficulty.sol b/compiler/test/libsolidity/semanticTests/state/block_difficulty.sol
new file mode 100644
index 00000000..921200dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_difficulty.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public returns (uint) {
+        return block.difficulty;
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// f() -> 200000000
+// f() -> 200000000
+// f() -> 200000000
diff --git a/compiler/test/libsolidity/semanticTests/state/block_difficulty_post_paris.sol b/compiler/test/libsolidity/semanticTests/state/block_difficulty_post_paris.sol
new file mode 100644
index 00000000..226a8bbb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_difficulty_post_paris.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public returns (uint) {
+        return block.difficulty;
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// f() -> 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777
+// f() -> 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777
+// f() -> 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777
diff --git a/compiler/test/libsolidity/semanticTests/state/block_gaslimit.sol b/compiler/test/libsolidity/semanticTests/state/block_gaslimit.sol
new file mode 100644
index 00000000..0201068b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_gaslimit.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (uint) {
+        return block.gaslimit;
+    }
+}
+// ----
+// f() -> 20000000
+// f() -> 20000000
+// f() -> 20000000
diff --git a/compiler/test/libsolidity/semanticTests/state/block_number.sol b/compiler/test/libsolidity/semanticTests/state/block_number.sol
new file mode 100644
index 00000000..01ec3096
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_number.sol
@@ -0,0 +1,10 @@
+contract C {
+    constructor() {}
+    function f() public returns (uint) {
+        return block.number;
+    }
+}
+// ----
+// constructor()
+// f() -> 2
+// f() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/state/block_prevrandao.sol b/compiler/test/libsolidity/semanticTests/state/block_prevrandao.sol
new file mode 100644
index 00000000..590265da
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_prevrandao.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.prevrandao;
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// f() -> 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777
diff --git a/compiler/test/libsolidity/semanticTests/state/block_prevrandao_pre_paris.sol b/compiler/test/libsolidity/semanticTests/state/block_prevrandao_pre_paris.sol
new file mode 100644
index 00000000..6824cab5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_prevrandao_pre_paris.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.prevrandao;
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// f() -> 200000000
diff --git a/compiler/test/libsolidity/semanticTests/state/block_timestamp.sol b/compiler/test/libsolidity/semanticTests/state/block_timestamp.sol
new file mode 100644
index 00000000..485ae4be
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/block_timestamp.sol
@@ -0,0 +1,10 @@
+contract C {
+    constructor() {}
+    function f() public returns (uint) {
+        return block.timestamp;
+    }
+}
+// ----
+// constructor() # This is the 1st block #
+// f() -> 0x1e # This is the 2nd block (each block is "15 seconds") #
+// f() -> 0x2d # This is the 3rd block #
diff --git a/compiler/test/libsolidity/semanticTests/state/blockhash_basic.sol b/compiler/test/libsolidity/semanticTests/state/blockhash_basic.sol
new file mode 100644
index 00000000..01069aa0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/blockhash_basic.sol
@@ -0,0 +1,24 @@
+contract C {
+    bytes32 public genesisHash;
+    bytes32 public currentHash;
+    constructor() {
+        require(block.number == 1);
+        genesisHash = blockhash(0);
+        currentHash = blockhash(1);
+    }
+    function f(uint blockNumber) public returns (bytes32) {
+        return blockhash(blockNumber);
+    }
+}
+// ----
+// constructor()
+// gas irOptimized: 108150
+// gas legacy: 152179
+// gas legacyOptimized: 106750
+// genesisHash() -> 0x3737373737373737373737373737373737373737373737373737373737373737
+// currentHash() -> 0
+// f(uint256): 0 -> 0x3737373737373737373737373737373737373737373737373737373737373737
+// f(uint256): 1 -> 0x3737373737373737373737373737373737373737373737373737373737373738
+// f(uint256): 255 -> 0x00
+// f(uint256): 256 -> 0x00
+// f(uint256): 257 -> 0x00
diff --git a/compiler/test/libsolidity/semanticTests/state/gasleft.sol b/compiler/test/libsolidity/semanticTests/state/gasleft.sol
new file mode 100644
index 00000000..6ce623ce
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/gasleft.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (bool) {
+        return gasleft() > 0;
+    }
+}
+// ----
+// f() -> true
+// f() -> true
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/state/msg_sender.sol b/compiler/test/libsolidity/semanticTests/state/msg_sender.sol
new file mode 100644
index 00000000..951d1f52
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/msg_sender.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (address) {
+        return msg.sender;
+    }
+}
+// ----
+// f() -> 0x1212121212121212121212121212120000000012
diff --git a/compiler/test/libsolidity/semanticTests/state/msg_sig.sol b/compiler/test/libsolidity/semanticTests/state/msg_sig.sol
new file mode 100644
index 00000000..f2f26e24
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/msg_sig.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public returns (bytes4) {
+        return msg.sig;
+    }
+    function g() public returns (bytes4) {
+        return msg.sig;
+    }
+}
+// ----
+// f() -> 0x26121ff000000000000000000000000000000000000000000000000000000000
+// g() -> 0xe2179b8e00000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/state/msg_value.sol b/compiler/test/libsolidity/semanticTests/state/msg_value.sol
new file mode 100644
index 00000000..143183b8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/msg_value.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public payable returns (uint) {
+        return msg.value;
+    }
+}
+// ----
+// f() -> 0
+// f(), 12 ether -> 12000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/state/tx_gasprice.sol b/compiler/test/libsolidity/semanticTests/state/tx_gasprice.sol
new file mode 100644
index 00000000..0d6dc6ae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/tx_gasprice.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (uint) {
+        return tx.gasprice;
+    }
+}
+// ----
+// f() -> 3000000000
+// f() -> 3000000000
+// f() -> 3000000000
diff --git a/compiler/test/libsolidity/semanticTests/state/tx_origin.sol b/compiler/test/libsolidity/semanticTests/state/tx_origin.sol
new file mode 100644
index 00000000..aa726c35
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/tx_origin.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (address) {
+        return tx.origin;
+    }
+}
+// ----
+// f() -> 0x9292929292929292929292929292929292929292
+// f() -> 0x9292929292929292929292929292929292929292
+// f() -> 0x9292929292929292929292929292929292929292
diff --git a/compiler/test/libsolidity/semanticTests/state/uncalled_blobhash.sol b/compiler/test/libsolidity/semanticTests/state/uncalled_blobhash.sol
new file mode 100644
index 00000000..df81a469
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/uncalled_blobhash.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public returns (bytes32) {
+        // NOTE: The `tx_context.blob_hashes` is injected into EVMHost with the following hashes, indexed accordingly:
+        // 0 -> 0x0100000000000000000000000000000000000000000000000000000000000001
+        // 1 -> 0x0100000000000000000000000000000000000000000000000000000000000002
+        return (blobhash)(0);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// f() -> 0x0100000000000000000000000000000000000000000000000000000000000001
diff --git a/compiler/test/libsolidity/semanticTests/state/uncalled_blockhash.sol b/compiler/test/libsolidity/semanticTests/state/uncalled_blockhash.sol
new file mode 100644
index 00000000..4e2526c7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state/uncalled_blockhash.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bytes32) {
+        return (blockhash)(block.number - 1);
+    }
+}
+// ----
+// f() -> 0x3737373737373737373737373737373737373737373737373737373737373738
diff --git a/compiler/test/libsolidity/semanticTests/state_var_initialization.sol b/compiler/test/libsolidity/semanticTests/state_var_initialization.sol
new file mode 100644
index 00000000..a8b0f108
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state_var_initialization.sol
@@ -0,0 +1,12 @@
+contract C {
+    uint public i = 1;
+    uint public k = 2;
+
+    constructor() {
+        i = i + i;
+        k = k - i;
+    }
+}
+// ----
+// i() -> 2
+// k() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/state_variables_init_order.sol b/compiler/test/libsolidity/semanticTests/state_variables_init_order.sol
new file mode 100644
index 00000000..6f8a59c1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state_variables_init_order.sol
@@ -0,0 +1,12 @@
+contract A {
+    uint public x = 0;
+    uint y = f();
+    function f() public returns (uint256) {
+        ++x;
+        return 42;
+    }
+}
+contract B is A {
+}
+// ----
+// x() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/state_variables_init_order_2.sol b/compiler/test/libsolidity/semanticTests/state_variables_init_order_2.sol
new file mode 100644
index 00000000..9003898e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/state_variables_init_order_2.sol
@@ -0,0 +1,16 @@
+contract A {
+    uint public x = 0;
+    uint y = f();
+    function f() public returns (uint256) {
+        ++x;
+        return 42;
+    }
+}
+contract B is A {
+    uint public z;
+    constructor() {
+        z = x;
+    }
+}
+// ----
+// z() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/statements/do_while_loop_continue.sol b/compiler/test/libsolidity/semanticTests/statements/do_while_loop_continue.sol
new file mode 100644
index 00000000..76f2bc4a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/statements/do_while_loop_continue.sol
@@ -0,0 +1,14 @@
+contract test {
+    function f() public pure returns(uint r) {
+        uint i = 0;
+        do
+        {
+            if (i > 0) return 0;
+            i++;
+            continue;
+        } while (false);
+        return 42;
+    }
+}
+// ----
+// f() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol b/compiler/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol
new file mode 100644
index 00000000..5f324216
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol
@@ -0,0 +1,32 @@
+contract Test {
+    bytes x;
+    function set(bytes memory _a) public { x = _a; }
+}
+// ----
+// set(bytes): 0x20, 3, "abc"
+// storageEmpty -> 0
+// set(bytes): 0x20, 0
+// storageEmpty -> 1
+// set(bytes): 0x20, 31, "1234567890123456789012345678901"
+// storageEmpty -> 0
+// set(bytes): 0x20, 36, "12345678901234567890123456789012", "XXXX"
+// storageEmpty -> 0
+// set(bytes): 0x20, 3, "abc"
+// storageEmpty -> 0
+// set(bytes): 0x20, 0
+// storageEmpty -> 1
+// set(bytes): 0x20, 3, "abc"
+// storageEmpty -> 0
+// set(bytes): 0x20, 36, "12345678901234567890123456789012", "XXXX"
+// storageEmpty -> 0
+// set(bytes): 0x20, 0
+// storageEmpty -> 1
+// set(bytes): 0x20, 66, "12345678901234567890123456789012", "12345678901234567890123456789012", "12"
+// gas irOptimized: 111886
+// gas legacy: 112734
+// gas legacyOptimized: 112115
+// storageEmpty -> 0
+// set(bytes): 0x20, 3, "abc"
+// storageEmpty -> 0
+// set(bytes): 0x20, 0
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_functions.sol b/compiler/test/libsolidity/semanticTests/storage/packed_functions.sol
new file mode 100644
index 00000000..564a3fab
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_functions.sol
@@ -0,0 +1,47 @@
+contract C {
+    // these should take the same slot
+    function() internal returns (uint) a;
+    function() external returns (uint) b;
+    function() external returns (uint) c;
+    function() internal returns (uint) d;
+    uint8 public x;
+
+    function set() public {
+        x = 2;
+        d = g;
+        c = this.h;
+        b = this.h;
+        a = g;
+    }
+
+    function t1() public returns (uint256) {
+        return a();
+    }
+
+    function t2() public returns (uint256) {
+        return b();
+    }
+
+    function t3() public returns (uint256) {
+        return a();
+    }
+
+    function t4() public returns (uint256) {
+        return b();
+    }
+
+    function g() public returns (uint256) {
+        return 7;
+    }
+
+    function h() public returns (uint256) {
+        return 8;
+    }
+}
+// ----
+// set() ->
+// t1() -> 7
+// t2() -> 8
+// t3() -> 7
+// t4() -> 8
+// x() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_storage_overflow.sol b/compiler/test/libsolidity/semanticTests/storage/packed_storage_overflow.sol
new file mode 100644
index 00000000..af2ecc70
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_storage_overflow.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint16 x = 0x1234;
+    uint16 a = 0xffff;
+    uint16 b;
+
+    function f() public returns (uint256, uint256, uint256, uint256) {
+        unchecked { a++; }
+        uint256 c = b;
+        delete b;
+        unchecked { a -= 2; }
+        return (x, c, b, a);
+    }
+}
+// ----
+// f() -> 0x1234, 0x0, 0x0, 0xfffe
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_storage_signed.sol b/compiler/test/libsolidity/semanticTests/storage/packed_storage_signed.sol
new file mode 100644
index 00000000..92cb82c9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_storage_signed.sol
@@ -0,0 +1,23 @@
+contract C {
+    int8 a;
+    uint8 b;
+    int8 c;
+    uint8 d;
+
+    function test()
+        public
+        returns (uint256 x1, uint256 x2, uint256 x3, uint256 x4)
+    {
+        a = -2;
+        unchecked {
+            b = (0 - uint8(a)) * 2;
+            c = a * int8(120) * int8(121);
+        }
+        x1 = uint256(int256(a));
+        x2 = b;
+        x3 = uint256(int256(c));
+        x4 = d;
+    }
+}
+// ----
+// test() -> -2, 4, -112, 0
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol
new file mode 100644
index 00000000..2c29abc7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol
@@ -0,0 +1,47 @@
+contract C {
+    struct s1 {
+        bytes1 a;
+        bytes1 b;
+        bytes10 c;
+        bytes9 d;
+        bytes10 e;
+    }
+    struct s2 {
+        bytes1 a;
+        s1 inner;
+        bytes1 b;
+        bytes1 c;
+    }
+    bytes1 x;
+    s2 data;
+    bytes1 y;
+
+    function test() public returns (bool) {
+        x = 0x01;
+        data.a = 0x02;
+        data.inner.a = 0x03;
+        data.inner.b = 0x04;
+        data.inner.c = "1234567890";
+        data.inner.d = "123456789";
+        data.inner.e = "abcdefghij";
+        data.b = 0x05;
+        data.c = bytes1(0x06);
+        y = 0x07;
+        return
+            x == 0x01 &&
+            data.a == 0x02 &&
+            data.inner.a == 0x03 &&
+            data.inner.b == 0x04 &&
+            data.inner.c == "1234567890" &&
+            data.inner.d == "123456789" &&
+            data.inner.e == "abcdefghij" &&
+            data.b == 0x05 &&
+            data.c == bytes1(0x06) &&
+            y == 0x07;
+    }
+}
+// ----
+// test() -> true
+// gas irOptimized: 132493
+// gas legacy: 136009
+// gas legacyOptimized: 133478
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_enum.sol b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_enum.sol
new file mode 100644
index 00000000..cda71d33
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_enum.sol
@@ -0,0 +1,32 @@
+contract C {
+    enum small {A, B, C, D}
+    enum larger {A, B, C, D, E}
+    struct str {
+        small a;
+        small b;
+        larger c;
+        larger d;
+    }
+    str data;
+
+    function test() public returns (uint256) {
+        data.a = small.B;
+        if (data.a != small.B) return 2;
+        data.b = small.C;
+        if (data.b != small.C) return 3;
+        data.c = larger.D;
+        if (data.c != larger.D) return 4;
+        if (data.a != small.B) return 5;
+        data.a = small.C;
+        if (data.a != small.C) return 6;
+        if (data.b != small.C) return 7;
+        data.b = small.D;
+        if (data.b != small.D) return 8;
+        if (data.c != larger.D) return 9;
+        data.c = larger.B;
+        if (data.c != larger.B) return 10;
+        return 1;
+    }
+}
+// ----
+// test() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_uint.sol b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_uint.sol
new file mode 100644
index 00000000..ea3c03d6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/packed_storage_structs_uint.sol
@@ -0,0 +1,29 @@
+contract C {
+    struct str {
+        uint8 a;
+        uint16 b;
+        uint248 c;
+    }
+    str data;
+
+    function test() public returns (uint256) {
+        data.a = 2;
+        if (data.a != 2) return 2;
+        data.b = 0xabcd;
+        if (data.b != 0xabcd) return 3;
+        data.c = 0x1234567890;
+        if (data.c != 0x1234567890) return 4;
+        if (data.a != 2) return 5;
+        data.a = 8;
+        if (data.a != 8) return 6;
+        if (data.b != 0xabcd) return 7;
+        data.b = 0xdcab;
+        if (data.b != 0xdcab) return 8;
+        if (data.c != 0x1234567890) return 9;
+        data.c = 0x9876543210;
+        if (data.c != 0x9876543210) return 10;
+        return 1;
+    }
+}
+// ----
+// test() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/storage/simple_accessor.sol b/compiler/test/libsolidity/semanticTests/storage/simple_accessor.sol
new file mode 100644
index 00000000..7aaeb4db
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/simple_accessor.sol
@@ -0,0 +1,8 @@
+contract test {
+    uint256 public data;
+    constructor() {
+        data = 8;
+    }
+}
+// ----
+// data() -> 8
diff --git a/compiler/test/libsolidity/semanticTests/storage/state_smoke_test.sol b/compiler/test/libsolidity/semanticTests/storage/state_smoke_test.sol
new file mode 100644
index 00000000..1b464531
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/storage/state_smoke_test.sol
@@ -0,0 +1,21 @@
+contract test {
+    uint256 value1;
+    uint256 value2;
+    function get(uint8 which) public returns (uint256 value) {
+        if (which == 0) return value1;
+        else return value2;
+    }
+    function set(uint8 which, uint256 value) public {
+        if (which == 0) value1 = value;
+        else value2 = value;
+    }
+}
+// ----
+// get(uint8): 0x00 -> 0
+// get(uint8): 0x01 -> 0
+// set(uint8,uint256): 0x00, 0x1234 ->
+// set(uint8,uint256): 0x01, 0x8765 ->
+// get(uint8): 0x00 -> 0x1234
+// get(uint8): 0x01 -> 0x8765
+// set(uint8,uint256): 0x00, 0x03 ->
+// get(uint8): 0x00 -> 0x03
diff --git a/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_argument_list.sol b/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_argument_list.sol
new file mode 100644
index 00000000..0297bd26
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_argument_list.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (string memory) {
+        return string.concat();
+    }
+}
+// ----
+// f() -> 0x20, 0
diff --git a/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_strings.sol b/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_strings.sol
new file mode 100644
index 00000000..b90235b3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/concat/string_concat_empty_strings.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f() public returns (string memory) {
+        string memory b = "";
+        return string.concat(
+            string.concat(b),
+            string.concat(b, b),
+            string.concat("", b),
+            string.concat(b, "")
+        );
+    }
+
+    function g() public returns (string memory) {
+        return string.concat("", "abc", hex"", "abc", unicode"");
+    }
+
+    function h() public returns (string memory) {
+        string memory b = "";
+        return string.concat(b, "abc", b, "abc", b);
+    }
+}
+// ----
+// f() -> 0x20, 0
+// g() -> 0x20, 6, "abcabc"
+// h() -> 0x20, 6, "abcabc"
diff --git a/compiler/test/libsolidity/semanticTests/strings/empty_string.sol b/compiler/test/libsolidity/semanticTests/strings/empty_string.sol
new file mode 100644
index 00000000..f023c723
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/empty_string.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public pure returns (string memory) {
+        return "";
+    }
+}
+// ----
+// f() -> 0x20, 0
diff --git a/compiler/test/libsolidity/semanticTests/strings/return_string.sol b/compiler/test/libsolidity/semanticTests/strings/return_string.sol
new file mode 100644
index 00000000..704a7859
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/return_string.sol
@@ -0,0 +1,17 @@
+contract Main {
+    string public s;
+    function set(string calldata _s) external {
+        s = _s;
+    }
+    function get1() public returns (string memory r) {
+        return s;
+    }
+    function get2() public returns (string memory r) {
+        r = s;
+    }
+}
+// ----
+// set(string): 0x20, 5, "Julia" ->
+// get1() -> 0x20, 5, "Julia"
+// get2() -> 0x20, 5, "Julia"
+// s() -> 0x20, 5, "Julia"
diff --git a/compiler/test/libsolidity/semanticTests/strings/string_escapes.sol b/compiler/test/libsolidity/semanticTests/strings/string_escapes.sol
new file mode 100644
index 00000000..ea178d64
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/string_escapes.sol
@@ -0,0 +1,8 @@
+contract test {
+    function f() public pure returns (bytes32) {
+        bytes32 escapeCharacters = "\t\n\r\'\"\\";
+        return escapeCharacters;
+    }
+}
+// ----
+// f() -> 0x090a0d27225c0000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/strings/unicode_escapes.sol b/compiler/test/libsolidity/semanticTests/strings/unicode_escapes.sol
new file mode 100644
index 00000000..401d8b61
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/unicode_escapes.sol
@@ -0,0 +1,22 @@
+contract C {
+    function oneByteUTF8() public pure returns (string memory) {
+        return "aaa\u0024aaa"; // usdollar
+    }
+
+    function twoBytesUTF8() public pure returns (string memory) {
+        return "aaa\u00A2aaa"; // cent
+    }
+
+    function threeBytesUTF8() public pure returns (string memory) {
+        return "aaa\u20ACaaa"; // euro
+    }
+
+    function combined() public pure returns (string memory) {
+        return "\u0024\u00A2\u20AC";
+    }
+}
+// ----
+// oneByteUTF8() -> 0x20, 7, "aaa$aaa"
+// twoBytesUTF8() -> 0x20, 8, "aaa\xc2\xa2aaa"
+// threeBytesUTF8() -> 0x20, 9, "aaa\xe2\x82\xacaaa"
+// combined() -> 0x20, 6, "$\xc2\xa2\xe2\x82\xac"
diff --git a/compiler/test/libsolidity/semanticTests/strings/unicode_string.sol b/compiler/test/libsolidity/semanticTests/strings/unicode_string.sol
new file mode 100644
index 00000000..e06556fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/strings/unicode_string.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public pure returns (string memory) {
+        return unicode"😃, 😭, and 😈";
+    }
+    function g() public pure returns (string memory) {
+        return unicode"😃, 😭,\
+ and 😈";
+    }
+}
+// ----
+// f() -> 0x20, 0x14, "\xf0\x9f\x98\x83, \xf0\x9f\x98\xad, and \xf0\x9f\x98\x88"
+// g() -> 0x20, 0x14, "\xf0\x9f\x98\x83, \xf0\x9f\x98\xad, and \xf0\x9f\x98\x88"
diff --git a/compiler/test/libsolidity/semanticTests/structs/array_of_recursive_struct.sol b/compiler/test/libsolidity/semanticTests/structs/array_of_recursive_struct.sol
new file mode 100644
index 00000000..f5f53cc4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/array_of_recursive_struct.sol
@@ -0,0 +1,12 @@
+contract Test {
+    struct RecursiveStruct {
+        RecursiveStruct[] vals;
+    }
+
+    function func() public pure {
+        RecursiveStruct[1] memory val = [ RecursiveStruct(new RecursiveStruct[](42)) ];
+        assert(val[0].vals.length == 42);
+    }
+}
+// ----
+// func() ->
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol
new file mode 100644
index 00000000..418f9e93
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct.sol
@@ -0,0 +1,16 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f(S calldata s) external pure returns (uint256 a, uint256 b) {
+        a = s.a;
+        b = s.b;
+    }
+}
+// ----
+// f((uint256,uint256)): 42, 23 -> 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol
new file mode 100644
index 00000000..5bdd1b42
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_and_ints.sol
@@ -0,0 +1,19 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f(uint256 a, S calldata s, uint256 b)
+        external
+        pure
+        returns (uint256, uint256, uint256, uint256)
+    {
+        return (a, s.a, s.b, b);
+    }
+}
+// ----
+// f(uint256,(uint256,uint256),uint256): 1, 2, 3, 4 -> 1, 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member_dynamic.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member_dynamic.sol
new file mode 100644
index 00000000..14f770a3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_array_member_dynamic.sol
@@ -0,0 +1,22 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint32 a;
+        uint256[] b;
+        uint64 c;
+    }
+
+    function f(S calldata s)
+        external
+        pure
+        returns (uint32 a, uint256 b0, uint256 b1, uint64 c)
+    {
+        a = s.a;
+        b0 = s.b[0];
+        b1 = s.b[1];
+        c = s.c;
+    }
+}
+// ----
+// f((uint32,uint256[],uint64)): 0x20, 42, 0x60, 23, 2, 1, 2 -> 42, 1, 2, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol
new file mode 100644
index 00000000..3aeb0dcb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_memory.sol
@@ -0,0 +1,16 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+        bytes2 c;
+    }
+
+    function f(S calldata s) external pure returns (uint256, uint256, bytes1) {
+        S memory m = s;
+        return (m.a, m.b, m.c[1]);
+    }
+}
+// ----
+// f((uint256,uint256,bytes2)): 42, 23, "ab" -> 42, 23, "b"
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol
new file mode 100644
index 00000000..6b56a73c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_to_storage.sol
@@ -0,0 +1,19 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint256 a;
+        uint64 b;
+        bytes2 c;
+    }
+
+    uint[153] r;
+    S s;
+
+    function f(uint32 a, S calldata c, uint256 b) external returns (uint256, uint256, bytes1) {
+        s = c;
+        return (s.a, s.b, s.c[1]);
+    }
+}
+// ----
+// f(uint32,(uint256,uint64,bytes2),uint256): 1, 42, 23, "ab", 1 -> 42, 23, "b"
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_array_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_array_to_memory.sol
new file mode 100644
index 00000000..b7b3058b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_array_to_memory.sol
@@ -0,0 +1,20 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint256 a;
+        uint256[2] b;
+        uint256 c;
+    }
+
+    function f(S calldata c)
+        external
+        pure
+        returns (uint256, uint256, uint256, uint256)
+    {
+        S memory m = c;
+        return (m.a, m.b[0], m.b[1], m.c);
+    }
+}
+// ----
+// f((uint256,uint256[2],uint256)): 42, 1, 2, 23 -> 42, 1, 2, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_bytes_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_bytes_to_memory.sol
new file mode 100644
index 00000000..3fa7a33f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_bytes_to_memory.sol
@@ -0,0 +1,20 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint256 a;
+        bytes b;
+        uint256 c;
+    }
+
+    function f(S calldata c)
+        external
+        pure
+        returns (uint256, bytes1, bytes1, uint256)
+    {
+        S memory m = c;
+        return (m.a, m.b[0], m.b[1], m.c);
+    }
+}
+// ----
+// f((uint256,bytes,uint256)): 0x20, 42, 0x60, 23, 2, "ab" -> 42, "a", "b", 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol
new file mode 100644
index 00000000..add42a8f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_struct_with_nested_array_to_storage.sol
@@ -0,0 +1,21 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint128 p1;
+        uint256[][2] a;
+        uint32 p2;
+    }
+    S s;
+    function f(uint32 p1, S calldata c) external returns(uint32, uint128, uint256, uint256, uint32) {
+        s = c;
+        assert(s.a[0][0] == c.a[0][0]);
+        assert(s.a[1][1] == c.a[1][1]);
+        return (p1, s.p1, s.a[0][0], s.a[1][1], s.p2);
+    }
+}
+// ----
+// f(uint32,(uint128,uint256[][2],uint32)): 55, 0x40, 77, 0x60, 88, 0x40, 0x40, 2, 1, 2 -> 55, 77, 1, 2, 88
+// gas irOptimized: 202843
+// gas legacy: 207384
+// gas legacyOptimized: 203584
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol
new file mode 100644
index 00000000..b7307713
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/calldata_structs.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S1 {
+        uint256 a;
+        uint256 b;
+    }
+    struct S2 {
+        uint256 a;
+    }
+
+    function f(S1 calldata s1, S2 calldata s2, S1 calldata s3)
+        external
+        pure
+        returns (uint256 a, uint256 b, uint256 c, uint256 d, uint256 e)
+    {
+        a = s1.a;
+        b = s1.b;
+        c = s2.a;
+        d = s3.a;
+        e = s3.b;
+    }
+}
+// ----
+// f((uint256,uint256),(uint256),(uint256,uint256)): 1, 2, 3, 4, 5 -> 1, 2, 3, 4, 5
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol
new file mode 100644
index 00000000..633c4c7b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/dynamic_nested.sol
@@ -0,0 +1,11 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S2 { uint256 b; }
+	struct S { uint256 a; S2[] children; }
+	function f(S calldata s) external pure returns (uint256, uint256, uint256, uint256) {
+		return (s.children.length, s.a, s.children[0].b, s.children[1].b);
+	}
+}
+// ----
+// f((uint256,(uint256)[])): 32, 17, 64, 2, 23, 42 -> 2, 17, 23, 42
diff --git a/compiler/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol b/compiler/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol
new file mode 100644
index 00000000..0dfa2cea
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/calldata/dynamically_encoded.sol
@@ -0,0 +1,10 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S { uint256[] a; }
+	function f(S calldata s) external pure returns (uint256 a, uint256 b, uint256 c) {
+	    return (s.a.length, s.a[0], s.a[1]);
+	}
+}
+// ----
+// f((uint256[])): 32, 32, 2, 42, 23 -> 2, 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol b/compiler/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol
new file mode 100644
index 00000000..69983617
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol
@@ -0,0 +1,28 @@
+contract CopyTest {
+    struct Tree {
+        Tree[] children;
+    }
+
+    Tree storageTree;
+    Tree[] children;
+
+    constructor() {
+        for (uint i = 0; i < 2; i++)
+            storageTree.children.push();
+        for (uint i = 0; i < 23; i++)
+            storageTree.children[0].children.push();
+        for (uint i = 0; i < 42; i++)
+            storageTree.children[1].children.push();
+    }
+
+    function run() public returns (uint256, uint256, uint256) {
+        Tree memory memoryTree;
+        memoryTree = storageTree;
+        return (memoryTree.children.length, memoryTree.children[0].children.length, memoryTree.children[1].children.length);
+    }
+}
+// ----
+// run() -> 2, 23, 42
+// gas irOptimized: 193677
+// gas legacy: 185731
+// gas legacyOptimized: 184458
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_from_mapping.sol b/compiler/test/libsolidity/semanticTests/structs/copy_from_mapping.sol
new file mode 100644
index 00000000..1d1783a1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_from_mapping.sol
@@ -0,0 +1,43 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        bytes b;
+        uint16[] a;
+        uint16 u;
+    }
+
+    constructor() {
+        uint16[] memory a = new uint16[](2);
+        a[0] = 13;
+        a[1] = 14;
+
+        m[7] = S({b: "foo", a: a, u: 7});
+    }
+
+    mapping (uint => S) m;
+    S s;
+
+    function to_state() public returns (S memory) {
+	s = m[7];
+        return s;
+    }
+
+    function to_storage() public returns (S memory) {
+        S storage sLocal = s;
+	sLocal = m[7];
+        return sLocal;
+    }
+
+    function to_memory() public returns (S memory) {
+	return m[7];
+    }
+
+}
+// ----
+// to_state() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 121481
+// gas legacy: 123069
+// gas legacyOptimized: 121756
+// to_storage() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// to_memory() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_struct_array_from_storage.sol b/compiler/test/libsolidity/semanticTests/structs/copy_struct_array_from_storage.sol
new file mode 100644
index 00000000..937eeeaf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_struct_array_from_storage.sol
@@ -0,0 +1,95 @@
+pragma abicoder v2;
+
+struct S { uint value; }
+
+contract Test {
+    S[][] a;
+    S[] b;
+
+    constructor() {
+        a.push();
+        a[0].push(S(1));
+        a[0].push(S(2));
+        a[0].push(S(3));
+
+        b.push(S(4));
+        b.push(S(5));
+        b.push(S(6));
+        b.push(S(7));
+    }
+
+    function test1() external returns (bool) {
+        a.push();
+        a[1] = b;
+
+        assert(a.length == 2);
+        assert(a[0].length == 3);
+        assert(a[1].length == 4);
+        assert(a[1][0].value == 4);
+        assert(a[1][1].value == 5);
+        assert(a[1][2].value == 6);
+        assert(a[1][3].value == 7);
+
+        return true;
+    }
+
+    function test2() external returns (bool) {
+        S[][] memory temp = new S[][](2);
+
+        temp = a;
+
+        assert(temp.length == 2);
+        assert(temp[0].length == 3);
+        assert(temp[1].length == 4);
+        assert(temp[1][0].value == 4);
+        assert(temp[1][1].value == 5);
+        assert(temp[1][2].value == 6);
+        assert(temp[1][3].value == 7);
+
+        return true;
+    }
+
+    function test3() external returns (bool) {
+        S[][] memory temp = new S[][](2);
+
+        temp[0] = a[0];
+        temp[1] = a[1];
+
+        assert(temp.length == 2);
+        assert(temp[0].length == 3);
+        assert(temp[1].length == 4);
+        assert(temp[1][0].value == 4);
+        assert(temp[1][1].value == 5);
+        assert(temp[1][2].value == 6);
+        assert(temp[1][3].value == 7);
+
+        return true;
+    }
+
+    function test4() external returns (bool) {
+        S[][] memory temp = new S[][](2);
+
+        temp[0] = a[0];
+        temp[1] = b;
+
+        assert(temp.length == 2);
+        assert(temp[0].length == 3);
+        assert(temp[1].length == 4);
+        assert(temp[1][0].value == 4);
+        assert(temp[1][1].value == 5);
+        assert(temp[1][2].value == 6);
+        assert(temp[1][3].value == 7);
+
+        return true;
+    }
+}
+// ====
+// EVMVersion: >homestead
+// ----
+// test1() -> true
+// gas irOptimized: 152882
+// gas legacy: 153012
+// gas legacyOptimized: 152637
+// test2() -> true
+// test3() -> true
+// test4() -> true
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_memory.sol
new file mode 100644
index 00000000..6c22c71d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_memory.sol
@@ -0,0 +1,15 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[1] x;
+        uint8[] y;
+    }
+
+    function test(S calldata s) public returns (S memory) {
+        return s;
+    }
+}
+// ----
+// test((uint8[1],uint8[])): 0x20, 3, 0x40, 2, 7, 11 -> 0x20, 3, 0x40, 2, 7, 11
+// test((uint8[1],uint8[])): 0x20, 3, 0x40, 3, 17, 19, 23 -> 0x20, 3, 0x40, 3, 17, 19, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_storage.sol b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_storage.sol
new file mode 100644
index 00000000..dcf2a3a2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_calldata_to_storage.sol
@@ -0,0 +1,21 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[1] x;
+        uint8[] y;
+    }
+
+    S s;
+
+    function test(S calldata src) public {
+        s = src;
+
+        require(s.x[0] == 3);
+        require(s.y.length == 2);
+        require(s.y[0] == 7);
+        require(s.y[1] == 11);
+    }
+}
+// ----
+// test((uint8[1],uint8[])): 0x20, 3, 0x40, 2, 7, 11
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_memory_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_memory_to_memory.sol
new file mode 100644
index 00000000..3d132641
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_memory_to_memory.sol
@@ -0,0 +1,15 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[1] x;
+        uint8[] y;
+    }
+
+    function test(S memory s) public returns (S memory r) {
+        return r;
+    }
+}
+// ----
+// test((uint8[1],uint8[])): 0x20, 3, 0x40, 2, 7, 11 -> 0x20, 0, 0x40, 0
+// test((uint8[1],uint8[])): 0x20, 3, 0x40, 3, 17, 19, 23 -> 0x20, 0, 0x40, 0
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_storage_to_storage.sol b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_storage_to_storage.sol
new file mode 100644
index 00000000..880b7433
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_struct_with_nested_array_from_storage_to_storage.sol
@@ -0,0 +1,26 @@
+contract C {
+    struct S {
+        uint8[1] x;
+        uint8[] y;
+    }
+
+    S src;
+    S dst;
+
+    constructor() {
+        src.x = [3];
+        src.y.push(7);
+        src.y.push(11);
+    }
+
+    function test() public {
+        dst = src;
+
+        require(dst.x[0] == 3);
+        require(dst.y.length == 2);
+        require(dst.y[0] == 7);
+        require(dst.y[1] == 11);
+    }
+}
+// ----
+// test()
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol b/compiler/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol
new file mode 100644
index 00000000..a1b0999f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol
@@ -0,0 +1,51 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        bytes b;
+        uint16[] a;
+        uint16 u;
+    }
+
+    constructor() {
+        uint16[] memory a = new uint16[](2);
+        a[0] = 13;
+        a[1] = 14;
+
+        m[7] = S({b: "foo", a: a, u: 7});
+    }
+
+    mapping (uint => S) m;
+    S s;
+
+    function to_state() public returns (S memory) {
+	s.b = m[7].b;
+	s.a = m[7].a;
+	s.u = m[7].u;
+        return s;
+    }
+
+    function to_storage() public returns (S memory) {
+        S storage sLocal = s;
+	sLocal.b = m[7].b;
+	sLocal.a = m[7].a;
+	sLocal.u = m[7].u;
+        return sLocal;
+    }
+
+    function to_memory() public returns (S memory) {
+        S memory sLocal;
+        sLocal.b = m[7].b;
+        sLocal.a = m[7].a;
+        sLocal.u = m[7].u;
+	return sLocal;
+    }
+
+}
+// ----
+// to_state() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 121598
+// gas legacy: 123208
+// gas legacyOptimized: 121763
+// to_storage() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// to_memory() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol b/compiler/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol
new file mode 100644
index 00000000..b8846611
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol
@@ -0,0 +1,65 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        bytes b;
+        uint16[] a;
+        uint16 u;
+    }
+
+    S s;
+    constructor() {
+        uint16[] memory a = new uint16[](2);
+        a[0] = 13;
+        a[1] = 14;
+
+        s.b = "foo";
+        s.a = a;
+        s.u = 21;
+    }
+
+    mapping (uint => S) m;
+
+    function from_memory() public returns (S memory) {
+        S memory sMemory = s;
+        m[0].b = sMemory.b;
+        m[0].a = sMemory.a;
+        m[0].u = sMemory.u;
+        return m[0];
+    }
+
+    function from_state() public returns (S memory) {
+        m[1].b = s.b;
+        m[1].a = s.a;
+        m[1].u = s.u;
+        return m[1];
+    }
+
+    function from_storage() public returns (S memory) {
+        S storage sLocal = s;
+        m[1].b = sLocal.b;
+        m[1].a = sLocal.a;
+        m[1].u = sLocal.u;
+        return m[1];
+    }
+
+    function from_calldata(S calldata sCalldata) public returns (S memory) {
+        m[2].b = sCalldata.b;
+        m[2].a = sCalldata.a;
+        m[2].u = sCalldata.u;
+        return m[2];
+    }
+}
+// ----
+// from_memory() -> 0x20, 0x60, 0xa0, 0x15, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 123039
+// gas legacy: 130227
+// gas legacyOptimized: 128758
+// from_state() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 121709
+// gas legacy: 123282
+// gas legacyOptimized: 121868
+// from_calldata((bytes,uint16[],uint16)): 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -> 0x20, 0x60, 0xa0, 0x15, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 115130
+// gas legacy: 122516
+// gas legacyOptimized: 120804
diff --git a/compiler/test/libsolidity/semanticTests/structs/copy_to_mapping.sol b/compiler/test/libsolidity/semanticTests/structs/copy_to_mapping.sol
new file mode 100644
index 00000000..e6b56992
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/copy_to_mapping.sol
@@ -0,0 +1,62 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        bytes b;
+        uint16[] a;
+        uint16 u;
+    }
+
+    S s;
+    constructor() {
+        uint16[] memory a = new uint16[](2);
+        a[0] = 13;
+        a[1] = 14;
+
+        s.b = "foo";
+        s.a = a;
+        s.u = 21;
+    }
+
+    mapping (uint => S) m;
+
+    function from_state() public returns (S memory) {
+        m[0] = s;
+        return m[0];
+    }
+
+    function from_storage() public returns (S memory) {
+        S storage sLocal = s;
+        m[1] = sLocal;
+        return m[1];
+    }
+
+    function from_memory() public returns (S memory) {
+        S memory sMemory = s;
+        m[2] = sMemory;
+        return m[2];
+    }
+
+
+    function from_calldata(S calldata sCalldata) public returns (S memory) {
+        m[3] = sCalldata;
+        return m[3];
+    }
+}
+// ----
+// from_state() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 121686
+// gas legacy: 123144
+// gas legacyOptimized: 121808
+// from_storage() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 121731
+// gas legacy: 123193
+// gas legacyOptimized: 121860
+// from_memory() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 122947
+// gas legacy: 130088
+// gas legacyOptimized: 128754
+// from_calldata((bytes,uint16[],uint16)): 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -> 0x20, 0x60, 0xa0, 21, 3, 0x666f6f0000000000000000000000000000000000000000000000000000000000, 2, 13, 14
+// gas irOptimized: 115045
+// gas legacy: 118301
+// gas legacyOptimized: 115432
diff --git a/compiler/test/libsolidity/semanticTests/structs/global.sol b/compiler/test/libsolidity/semanticTests/structs/global.sol
new file mode 100644
index 00000000..05212253
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/global.sol
@@ -0,0 +1,10 @@
+pragma abicoder               v2;
+
+struct S { uint256 a; uint256 b; }
+contract C {
+    function f(S calldata s) external pure returns (uint256, uint256) {
+        return (s.a, s.b);
+    }
+}
+// ----
+// f((uint256,uint256)): 42, 23 -> 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/structs/lone_struct_array_type.sol b/compiler/test/libsolidity/semanticTests/structs/lone_struct_array_type.sol
new file mode 100644
index 00000000..9434e404
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/lone_struct_array_type.sol
@@ -0,0 +1,13 @@
+contract C {
+    struct s {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f() public returns (uint256) {
+        s[7][]; // This is only the type, should not have any effect
+        return 3;
+    }
+}
+// ----
+// f() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol b/compiler/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol
new file mode 100644
index 00000000..f844c08f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/memory_struct_named_constructor.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint256 a;
+        bool x;
+    }
+
+    function s() public returns(S memory)
+    {
+        return S({x: true, a: 8});
+    }
+}
+// ----
+// s() -> 8, true
diff --git a/compiler/test/libsolidity/semanticTests/structs/memory_structs_as_function_args.sol b/compiler/test/libsolidity/semanticTests/structs/memory_structs_as_function_args.sol
new file mode 100644
index 00000000..96b95699
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/memory_structs_as_function_args.sol
@@ -0,0 +1,31 @@
+contract Test {
+    struct S {
+        uint8 x;
+        uint16 y;
+        uint256 z;
+    }
+
+    function test() public returns (uint256 x, uint256 y, uint256 z) {
+        S memory data = combine(1, 2, 3);
+        x = extract(data, 0);
+        y = extract(data, 1);
+        z = extract(data, 2);
+    }
+
+    function extract(S memory s, uint256 which) internal returns (uint256 x) {
+        if (which == 0) return s.x;
+        else if (which == 1) return s.y;
+        else return s.z;
+    }
+
+    function combine(uint8 x, uint16 y, uint256 z)
+        internal
+        returns (S memory s)
+    {
+        s.x = x;
+        s.y = y;
+        s.z = z;
+    }
+}
+// ----
+// test() -> 1, 2, 3
diff --git a/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested.sol b/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested.sol
new file mode 100644
index 00000000..e541fa97
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested.sol
@@ -0,0 +1,41 @@
+contract Test {
+    struct S {
+        uint8 x;
+        uint16 y;
+        uint256 z;
+    }
+    struct X {
+        uint8 x;
+        S s;
+    }
+
+    function test()
+        public
+        returns (uint256 a, uint256 x, uint256 y, uint256 z)
+    {
+        X memory d = combine(1, 2, 3, 4);
+        a = extract(d, 0);
+        x = extract(d, 1);
+        y = extract(d, 2);
+        z = extract(d, 3);
+    }
+
+    function extract(X memory s, uint256 which) internal returns (uint256 x) {
+        if (which == 0) return s.x;
+        else if (which == 1) return s.s.x;
+        else if (which == 2) return s.s.y;
+        else return s.s.z;
+    }
+
+    function combine(uint8 a, uint8 x, uint16 y, uint256 z)
+        internal
+        returns (X memory s)
+    {
+        s.x = a;
+        s.s.x = x;
+        s.s.y = y;
+        s.s.z = z;
+    }
+}
+// ----
+// test() -> 1, 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested_load.sol b/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested_load.sol
new file mode 100644
index 00000000..e5b139d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/memory_structs_nested_load.sol
@@ -0,0 +1,72 @@
+contract Test {
+    struct S {
+        uint8 x;
+        uint16 y;
+        uint256 z;
+    }
+    struct X {
+        uint8 x;
+        S s;
+        uint8[2] a;
+    }
+    X m_x;
+
+    function load()
+        public
+        returns (
+            uint256 a,
+            uint256 x,
+            uint256 y,
+            uint256 z,
+            uint256 a1,
+            uint256 a2
+        )
+    {
+        m_x.x = 1;
+        m_x.s.x = 2;
+        m_x.s.y = 3;
+        m_x.s.z = 4;
+        m_x.a[0] = 5;
+        m_x.a[1] = 6;
+        X memory d = m_x;
+        a = d.x;
+        x = d.s.x;
+        y = d.s.y;
+        z = d.s.z;
+        a1 = d.a[0];
+        a2 = d.a[1];
+    }
+
+    function store()
+        public
+        returns (
+            uint256 a,
+            uint256 x,
+            uint256 y,
+            uint256 z,
+            uint256 a1,
+            uint256 a2
+        )
+    {
+        X memory d;
+        d.x = 1;
+        d.s.x = 2;
+        d.s.y = 3;
+        d.s.z = 4;
+        d.a[0] = 5;
+        d.a[1] = 6;
+        m_x = d;
+        a = m_x.x;
+        x = m_x.s.x;
+        y = m_x.s.y;
+        z = m_x.s.z;
+        a1 = m_x.a[0];
+        a2 = m_x.a[1];
+    }
+}
+// ----
+// load() -> 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
+// gas irOptimized: 110317
+// gas legacy: 112964
+// gas legacyOptimized: 110876
+// store() -> 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
diff --git a/compiler/test/libsolidity/semanticTests/structs/memory_structs_read_write.sol b/compiler/test/libsolidity/semanticTests/structs/memory_structs_read_write.sol
new file mode 100644
index 00000000..fe319d19
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/memory_structs_read_write.sol
@@ -0,0 +1,55 @@
+contract Test {
+    struct S {
+        uint8 x;
+        uint16 y;
+        uint256 z;
+        uint8[2] a;
+    }
+    S[5] data;
+
+    function testInit()
+        public
+        returns (uint8 x, uint16 y, uint256 z, uint8 a, bool flag)
+    {
+        S[2] memory d;
+        x = d[0].x;
+        y = d[0].y;
+        z = d[0].z;
+        a = d[0].a[1];
+        flag = true;
+    }
+
+    function testCopyRead()
+        public
+        returns (uint8 x, uint16 y, uint256 z, uint8 a)
+    {
+        data[2].x = 1;
+        data[2].y = 2;
+        data[2].z = 3;
+        data[2].a[1] = 4;
+        S memory s = data[2];
+        x = s.x;
+        y = s.y;
+        z = s.z;
+        a = s.a[1];
+    }
+
+    function testAssign()
+        public
+        returns (uint8 x, uint16 y, uint256 z, uint8 a)
+    {
+        S memory s;
+        s.x = 1;
+        s.y = 2;
+        s.z = 3;
+        s.a[1] = 4;
+        x = s.x;
+        y = s.y;
+        z = s.z;
+        a = s.a[1];
+    }
+}
+// ----
+// testInit() -> 0, 0, 0, 0, true
+// testCopyRead() -> 1, 2, 3, 4
+// testAssign() -> 1, 2, 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/structs/multislot_struct_allocation.sol b/compiler/test/libsolidity/semanticTests/structs/multislot_struct_allocation.sol
new file mode 100644
index 00000000..648c962c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/multislot_struct_allocation.sol
@@ -0,0 +1,19 @@
+contract C {
+  struct I {
+    uint b;
+    uint c;
+    function(uint) external returns (uint) x;
+  }
+  struct S {
+    I a;
+  }
+
+  function o(uint a) external returns(uint) { return a+1; }
+
+  function f() external returns (uint) {
+    S memory s = S(I(1,2, this.o));
+    return s.a.x(1);
+  }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/structs/nested_struct_allocation.sol b/compiler/test/libsolidity/semanticTests/structs/nested_struct_allocation.sol
new file mode 100644
index 00000000..0037d957
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/nested_struct_allocation.sol
@@ -0,0 +1,16 @@
+contract C {
+  struct I {
+    uint b;
+    uint c;
+  }
+  struct S {
+    I a;
+  }
+
+  function f() external returns (uint) {
+    S memory s = S(I(1,2));
+    return s.a.b;
+  }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/structs/recursive_structs.sol b/compiler/test/libsolidity/semanticTests/structs/recursive_structs.sol
new file mode 100644
index 00000000..f8944f11
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/recursive_structs.sol
@@ -0,0 +1,18 @@
+contract C {
+    struct S {
+        S[] x;
+    }
+    S sstorage;
+
+    function f() public returns (uint256) {
+        S memory s;
+        s.x = new S[](10);
+        delete s;
+        // TODO Uncomment after implemented.
+        // sstorage.x.push();
+        delete sstorage;
+        return 1;
+    }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/structs/simple_struct_allocation.sol b/compiler/test/libsolidity/semanticTests/structs/simple_struct_allocation.sol
new file mode 100644
index 00000000..e45626d3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/simple_struct_allocation.sol
@@ -0,0 +1,12 @@
+contract C {
+  struct S {
+    uint a;
+  }
+
+  function f() external returns (uint) {
+    S memory s = S(1);
+    return s.a;
+  }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_assign_reference_to_struct.sol b/compiler/test/libsolidity/semanticTests/structs/struct_assign_reference_to_struct.sol
new file mode 100644
index 00000000..47b9a9ec
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_assign_reference_to_struct.sol
@@ -0,0 +1,35 @@
+contract test {
+    struct testStruct {
+        uint256 m_value;
+    }
+    testStruct data1;
+    testStruct data2;
+    testStruct data3;
+
+    constructor() {
+        data1.m_value = 2;
+    }
+
+    function assign()
+        public
+        returns (
+            uint256 ret_local,
+            uint256 ret_global,
+            uint256 ret_global3,
+            uint256 ret_global1
+        )
+    {
+        testStruct storage x = data1; //x is a reference data1.m_value == 2 as well as x.m_value = 2
+        data2 = data1; // should copy data. data2.m_value == 2
+
+        ret_local = x.m_value; // = 2
+        ret_global = data2.m_value; // = 2
+
+        x.m_value = 3;
+        data3 = x; //should copy the data. data3.m_value == 3
+        ret_global3 = data3.m_value; // = 3
+        ret_global1 = data1.m_value; // = 3. Changed due to the assignment to x.m_value
+    }
+}
+// ----
+// assign() -> 2, 2, 3, 3
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol b/compiler/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol
new file mode 100644
index 00000000..856edc27
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol
@@ -0,0 +1,39 @@
+contract c {
+    struct Struct { uint a; bytes data; uint b; }
+    Struct data1;
+    Struct data2;
+    function set(uint _a, bytes calldata _data, uint _b) external returns (bool) {
+        data1.a = _a;
+        data1.b = _b;
+        data1.data = _data;
+        return true;
+    }
+    function copy() public returns (bool) {
+        data1 = data2;
+        return true;
+    }
+    function del() public returns (bool) {
+        delete data1;
+        return true;
+    }
+    function test(uint256 i) public returns (bytes1) {
+        return data1.data[i];
+    }
+}
+// ----
+// storageEmpty -> 1
+// set(uint256,bytes,uint256): 12, 0x60, 13, 33, "12345678901234567890123456789012", "3" -> true
+// gas irOptimized: 133592
+// gas legacy: 134628
+// gas legacyOptimized: 133871
+// test(uint256): 32 -> "3"
+// storageEmpty -> 0
+// copy() -> true
+// storageEmpty -> 1
+// set(uint256,bytes,uint256): 12, 0x60, 13, 33, "12345678901234567890123456789012", "3" -> true
+// gas irOptimized: 133592
+// gas legacy: 134628
+// gas legacyOptimized: 133871
+// storageEmpty -> 0
+// del() -> true
+// storageEmpty -> 1
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_copy.sol b/compiler/test/libsolidity/semanticTests/structs/struct_copy.sol
new file mode 100644
index 00000000..a321f068
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_copy.sol
@@ -0,0 +1,52 @@
+contract c {
+    struct Nested {
+        uint256 x;
+        uint256 y;
+    }
+    struct Struct {
+        uint256 a;
+        Nested nested;
+        uint256 c;
+    }
+    mapping(uint256 => Struct) data;
+
+    function set(uint256 k) public returns (bool) {
+        data[k].a = 1;
+        data[k].nested.x = 3;
+        data[k].nested.y = 4;
+        data[k].c = 2;
+        return true;
+    }
+
+    function copy(uint256 from, uint256 to) public returns (bool) {
+        data[to] = data[from];
+        return true;
+    }
+
+    function retrieve(uint256 k)
+        public
+        returns (uint256 a, uint256 x, uint256 y, uint256 c)
+    {
+        a = data[k].a;
+        x = data[k].nested.x;
+        y = data[k].nested.y;
+        c = data[k].c;
+    }
+}
+// ----
+// set(uint256): 7 -> true
+// gas irOptimized: 109893
+// gas legacy: 110597
+// gas legacyOptimized: 110003
+// retrieve(uint256): 7 -> 1, 3, 4, 2
+// copy(uint256,uint256): 7, 8 -> true
+// gas irOptimized: 118582
+// gas legacy: 119147
+// gas legacyOptimized: 118619
+// retrieve(uint256): 7 -> 1, 3, 4, 2
+// retrieve(uint256): 8 -> 1, 3, 4, 2
+// copy(uint256,uint256): 0, 7 -> true
+// retrieve(uint256): 7 -> 0, 0, 0, 0
+// retrieve(uint256): 8 -> 1, 3, 4, 2
+// copy(uint256,uint256): 7, 8 -> true
+// retrieve(uint256): 8 -> 0, 0, 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol b/compiler/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol
new file mode 100644
index 00000000..71b40acc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_copy_via_local.sol
@@ -0,0 +1,22 @@
+contract c {
+    struct Struct {
+        uint256 a;
+        uint256 b;
+    }
+    uint[75] r;
+    Struct data1;
+    Struct data2;
+
+    function test() public returns (bool) {
+        data1.a = 1;
+        data1.b = 2;
+        Struct memory x = data1;
+        data2 = x;
+        return data2.a == data1.a && data2.b == data1.b;
+    }
+}
+// ----
+// test() -> true
+// gas irOptimized: 109706
+// gas legacy: 110615
+// gas legacyOptimized: 109705
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_member.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_member.sol
new file mode 100644
index 00000000..7f991f40
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_member.sol
@@ -0,0 +1,19 @@
+contract test {
+    struct testStruct {
+        uint256 m_value;
+    }
+    testStruct data1;
+
+    constructor() {
+        data1.m_value = 2;
+    }
+
+    function deleteMember() public returns (uint256 ret_value) {
+        testStruct storage x = data1; //should not copy the data. data1.m_value == 2 but x.m_value = 0
+        x.m_value = 4;
+        delete x.m_value;
+        ret_value = data1.m_value;
+    }
+}
+// ----
+// deleteMember() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage.sol
new file mode 100644
index 00000000..31558cfb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage.sol
@@ -0,0 +1,21 @@
+contract C {
+    struct S {
+        uint256 x;
+        uint128 y;
+        uint32 z;
+    }
+    uint8 b = 23;
+    S s;
+    uint8 a = 17;
+    function f() public {
+        s.x = 42; s.y = 42; s.y = 42;
+        delete s;
+        assert(s.x == 0);
+        assert(s.y == 0);
+        assert(s.z == 0);
+        assert(b == 23);
+        assert(a == 17);
+    }
+}
+// ----
+// f() ->
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_small.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_small.sol
new file mode 100644
index 00000000..046e4ec6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_small.sol
@@ -0,0 +1,24 @@
+contract C {
+    struct S {
+        uint64 y;
+        uint64 z;
+    }
+    S s;
+    function f() public returns (uint256 ret) {
+        assembly {
+            // 2 ** 150 - 1
+            sstore(s.slot, 1427247692705959881058285969449495136382746623)
+        }
+        s.y = 1; s.z = 2;
+        delete s;
+        assert(s.y == 0);
+        assert(s.z == 0);
+        assembly {
+            ret := sload(s.slot)
+        }
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol
new file mode 100644
index 00000000..d76618bb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol
@@ -0,0 +1,51 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint128 a;
+        uint256[] x;
+        uint240 b;
+    }
+    uint8 b = 23;
+    S s;
+    uint8 a = 17;
+    function f() public {
+        delete s;
+        s.x.push(42); s.x.push(42); s.x.push(42);
+        delete s;
+        assert(s.x.length == 0);
+        uint256[] storage x = s.x;
+        assembly { sstore(x.slot, 3) }
+        assert(s.x[0] == 0);
+        assert(s.x[1] == 0);
+        assert(s.x[2] == 0);
+        assert(b == 23);
+        assert(a == 17);
+    }
+
+    function g() public {
+        delete s;
+        s.x.push(42); s.x.push(42); s.x.push(42);
+        s.a = 1; s.b = 2;
+        delete s.x;
+        assert(s.x.length == 0);
+        uint256[] storage x = s.x;
+        assembly { sstore(x.slot, 3) }
+        assert(s.x[0] == 0);
+        assert(s.x[1] == 0);
+        assert(s.x[2] == 0);
+        assert(b == 23);
+        assert(a == 17);
+        assert(s.a == 1);
+        assert(s.b == 2);
+    }
+}
+// ----
+// f() ->
+// gas irOptimized: 113210
+// gas legacy: 113591
+// gas legacyOptimized: 113103
+// g() ->
+// gas irOptimized: 118580
+// gas legacy: 118764
+// gas legacyOptimized: 118172
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol
new file mode 100644
index 00000000..2345fea3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_storage_with_arrays_small.sol
@@ -0,0 +1,30 @@
+contract C {
+    struct S {
+        uint32 a;
+        uint32[3] b;
+        uint32[] x;
+    }
+    S s;
+    function f() public returns (uint256 ret) {
+        assembly {
+            // 2 ** 150 - 1
+            sstore(s.slot, 1427247692705959881058285969449495136382746623)
+        }
+        s.a = 1;
+        s.b[0] = 2; s.b[1] = 3;
+        s.x.push(4); s.x.push(5);
+        delete s;
+        assert(s.a == 0);
+        assert(s.b[0] == 0);
+        assert(s.b[1] == 0);
+        assert(s.x.length == 0);
+        assembly {
+            ret := sload(s.slot)
+        }
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> 0
+// gas irOptimized: 111570
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_delete_struct_in_mapping.sol b/compiler/test/libsolidity/semanticTests/structs/struct_delete_struct_in_mapping.sol
new file mode 100644
index 00000000..ae21f6f8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_delete_struct_in_mapping.sol
@@ -0,0 +1,17 @@
+contract test {
+    struct testStruct {
+        uint256 m_value;
+    }
+    mapping(uint256 => testStruct) campaigns;
+
+    constructor() {
+        campaigns[0].m_value = 2;
+    }
+
+    function deleteIt() public returns (uint256) {
+        delete campaigns[0];
+        return campaigns[0].m_value;
+    }
+}
+// ----
+// deleteIt() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol b/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol
new file mode 100644
index 00000000..290c812c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage.sol
@@ -0,0 +1,25 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint32 a;
+        uint128 b;
+        uint256 c;
+    }
+
+    struct X {
+        uint256 a;
+        S s;
+    }
+
+    uint[79] r;
+    X x;
+
+    function f() external returns (uint32, uint128, uint256) {
+        X memory m = X(12, S(42, 23, 34));
+        x = m;
+        return (x.s.a, x.s.b, x.s.c);
+    }
+}
+// ----
+// f() -> 42, 23, 34
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol b/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol
new file mode 100644
index 00000000..9af37746
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol
@@ -0,0 +1,33 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint32 a;
+        uint128 b;
+        uint256 c;
+        function() internal returns (uint32) f;
+    }
+
+    struct X {
+        uint256 a;
+        S s;
+    }
+
+    uint[79] r;
+    X x;
+
+    function f() external returns (uint32, uint128, uint256, uint32, uint32) {
+        X memory m = X(12, S(42, 23, 34, g));
+        x = m;
+        return (x.s.a, x.s.b, x.s.c, x.s.f(), m.s.f());
+    }
+
+    function g() internal returns (uint32) {
+        return x.s.a;
+    }
+}
+// ----
+// f() -> 42, 23, 34, 42, 42
+// gas irOptimized: 110382
+// gas legacy: 111993
+// gas legacyOptimized: 110546
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_named_constructor.sol b/compiler/test/libsolidity/semanticTests/structs/struct_named_constructor.sol
new file mode 100644
index 00000000..f16f61e3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_named_constructor.sol
@@ -0,0 +1,13 @@
+contract C {
+    struct S {
+        uint256 a;
+        bool x;
+    }
+    S public s;
+
+    constructor() {
+        s = S({x: true, a: 1});
+    }
+}
+// ----
+// s() -> 1, true
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_referencing.sol b/compiler/test/libsolidity/semanticTests/structs/struct_referencing.sol
new file mode 100644
index 00000000..93fad63b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_referencing.sol
@@ -0,0 +1,58 @@
+pragma abicoder v2;
+interface I {
+    struct S { uint a; }
+}
+
+library L {
+    struct S { uint b; uint a; }
+    function f() public pure returns (S memory) {
+        S memory s;
+        s.a = 3;
+        return s;
+    }
+    function g() public pure returns (I.S memory) {
+        I.S memory s;
+        s.a = 4;
+        return s;
+    }
+    // argument-dependent lookup tests
+    function a(I.S memory) public pure returns (uint) { return 1; }
+    function a(S memory) public pure returns (uint) { return 2; }
+}
+
+contract C is I {
+    function f() public pure returns (S memory) {
+        S memory s;
+        s.a = 1;
+        return s;
+    }
+    function g() public pure returns (I.S memory) {
+        I.S memory s;
+        s.a = 2;
+        return s;
+    }
+    function h() public pure returns (L.S memory) {
+        L.S memory s;
+        s.a = 5;
+        return s;
+    }
+    function x() public pure returns (L.S memory) {
+        return L.f();
+    }
+    function y() public pure returns (I.S memory) {
+        return L.g();
+    }
+    function a1() public pure returns (uint) { S memory s; return L.a(s); }
+    function a2() public pure returns (uint) { L.S memory s; return L.a(s); }
+}
+// ----
+// library: L
+// f() -> 1
+// g() -> 2
+// f() -> 1
+// g() -> 2
+// h() -> 0, 5
+// x() -> 0, 3
+// y() -> 4
+// a1() -> 1
+// a2() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol b/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol
new file mode 100644
index 00000000..26862fd0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory.sol
@@ -0,0 +1,23 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint32 a;
+        uint128 b;
+        uint256 c;
+    }
+    struct X {
+        uint32 a;
+        S s;
+    }
+
+    uint[79] arr;
+    X x = X(12, S(42, 23, 34));
+
+    function f() external returns (uint32, uint128, uint256) {
+        X memory m = x;
+        return (m.s.a, m.s.b, m.s.c);
+    }
+}
+// ----
+// f() -> 42, 23, 34
diff --git a/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol b/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol
new file mode 100644
index 00000000..5ec25fb3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/struct_storage_to_memory_function_ptr.sol
@@ -0,0 +1,29 @@
+pragma abicoder               v2;
+
+contract C {
+    struct S {
+        uint32 a;
+        uint128 b;
+        uint256 c;
+        function() internal returns (uint32) f;
+    }
+
+    struct X {
+        uint256 a;
+        S s;
+    }
+
+    uint[79] arr;
+    X x = X(12, S(42, 23, 34, g));
+
+    function f() external returns (uint32, uint128, uint256, uint32, uint32) {
+        X memory m = x;
+        return (m.s.a, m.s.b, m.s.c, m.s.f(), x.s.f());
+    }
+
+    function g() internal returns (uint32) {
+        return x.s.a;
+    }
+}
+// ----
+// f() -> 42, 23, 34, 42, 42
diff --git a/compiler/test/libsolidity/semanticTests/structs/structs.sol b/compiler/test/libsolidity/semanticTests/structs/structs.sol
new file mode 100644
index 00000000..b5e9d10b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/structs.sol
@@ -0,0 +1,36 @@
+contract test {
+    struct s1 {
+        uint8 x;
+        bool y;
+    }
+    struct s2 {
+        uint32 z;
+        s1 s1data;
+        mapping(uint8 => s2) recursive;
+    }
+    s2 data;
+    function check() public returns (bool ok) {
+        return data.z == 1 && data.s1data.x == 2 &&
+            data.s1data.y == true &&
+            data.recursive[3].recursive[4].z == 5 &&
+            data.recursive[4].recursive[3].z == 6 &&
+            data.recursive[0].s1data.y == false &&
+            data.recursive[4].z == 9;
+    }
+    function set() public {
+        data.z = 1;
+        data.s1data.x = 2;
+        data.s1data.y = true;
+        data.recursive[3].recursive[4].z = 5;
+        data.recursive[4].recursive[3].z = 6;
+        data.recursive[0].s1data.y = false;
+        data.recursive[4].z = 9;
+    }
+}
+// ----
+// check() -> false
+// set() ->
+// gas irOptimized: 134417
+// gas legacy: 135246
+// gas legacyOptimized: 134062
+// check() -> true
diff --git a/compiler/test/libsolidity/semanticTests/structs/using_for_function_on_struct.sol b/compiler/test/libsolidity/semanticTests/structs/using_for_function_on_struct.sol
new file mode 100644
index 00000000..7b51b59f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/structs/using_for_function_on_struct.sol
@@ -0,0 +1,13 @@
+library D { struct s { uint a; } function mul(s storage self, uint x) public returns (uint) { return self.a *= x; } }
+contract C {
+    using D for D.s;
+    D.s public x;
+    function f(uint a) public returns (uint) {
+        x.a = 3;
+        return x.mul(a);
+    }
+}
+// ----
+// library: D
+// f(uint256): 7 -> 0x15
+// x() -> 0x15
diff --git a/compiler/test/libsolidity/semanticTests/tryCatch/create.sol b/compiler/test/libsolidity/semanticTests/tryCatch/create.sol
new file mode 100644
index 00000000..43d0f22f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/tryCatch/create.sol
@@ -0,0 +1,32 @@
+contract Reverts {
+    constructor(uint) { revert("test message."); }
+}
+contract Succeeds {
+    constructor(uint) { }
+}
+
+contract C {
+    function f() public returns (Reverts x, uint, string memory txt) {
+        uint i = 3;
+        try new Reverts(i) returns (Reverts r) {
+            x = r;
+            txt = "success";
+        } catch Error(string memory s) {
+            txt = s;
+        }
+    }
+    function g() public returns (Succeeds x, uint, string memory txt) {
+        uint i = 8;
+        try new Succeeds(i) returns (Succeeds r) {
+            x = r;
+            txt = "success";
+        } catch Error(string memory s) {
+            txt = s;
+        }
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// f() -> 0, 0, 96, 13, "test message."
+// g() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a, 0, 96, 7, "success"
diff --git a/compiler/test/libsolidity/semanticTests/tryCatch/return_function.sol b/compiler/test/libsolidity/semanticTests/tryCatch/return_function.sol
new file mode 100644
index 00000000..6aac30fe
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/tryCatch/return_function.sol
@@ -0,0 +1,17 @@
+contract C {
+    function g() public returns (uint a, function() external h, uint b) {
+        a = 1;
+        h = this.fun;
+        b = 9;
+    }
+    function f() public returns (uint, function() external, uint) {
+        // Note that the function type uses two stack slots.
+        try this.g() returns (uint a, function() external h, uint b) {
+            return (a, h, b);
+        } catch {
+        }
+    }
+    function fun() public pure {}
+}
+// ----
+// f() -> 0x1, 0xc06afe3a8444fc0004668591e8306bfb9968e79e946644cd0000000000000000, 9
diff --git a/compiler/test/libsolidity/semanticTests/types/assign_calldata_value_type.sol b/compiler/test/libsolidity/semanticTests/types/assign_calldata_value_type.sol
new file mode 100644
index 00000000..8350628e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/assign_calldata_value_type.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f(uint256 x) public pure returns (uint256, uint256) {
+        uint256 b = x;
+        x = 42;
+        return (x, b);
+    }
+}
+// ----
+// f(uint256): 23 -> 42, 23
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_greater_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_greater_size.sol
new file mode 100644
index 00000000..fdfafa9e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_greater_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToBytes(bytes2 input) public returns (bytes4 ret) {
+        return bytes4(input);
+    }
+}
+// ----
+// bytesToBytes(bytes2): "ab" -> "ab"
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_same_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_same_size.sol
new file mode 100644
index 00000000..5c9a6cdc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_same_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToBytes(bytes4 input) public returns (bytes4 ret) {
+        return bytes4(input);
+    }
+}
+// ----
+// bytesToBytes(bytes4): "abcd" -> "abcd"
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_smaller_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_smaller_size.sol
new file mode 100644
index 00000000..2052c9da
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_fixed_bytes_smaller_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToBytes(bytes4 input) public returns (bytes2 ret) {
+        return bytes2(input);
+    }
+}
+// ----
+// bytesToBytes(bytes4): "abcd" -> "ab"
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_greater_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_greater_size.sol
new file mode 100644
index 00000000..b0ab07f5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_greater_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToUint(bytes4 s) public returns (uint64 h) {
+        return uint64(uint32(s));
+    }
+}
+// ----
+// bytesToUint(bytes4): "abcd" -> 0x61626364
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_min_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_min_size.sol
new file mode 100644
index 00000000..ff1dfebf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_min_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToUint(bytes1 s) public returns (uint8 h) {
+        return uint8(s);
+    }
+}
+// ----
+// bytesToUint(bytes1): "a" -> 0x61
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_type.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_type.sol
new file mode 100644
index 00000000..390bf4b0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_same_type.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToUint(bytes32 s) public returns (uint256 h) {
+        return uint(s);
+    }
+}
+// ----
+// bytesToUint(bytes32): "abc2" -> left(0x61626332)
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_smaller_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_smaller_size.sol
new file mode 100644
index 00000000..eb450993
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_fixed_bytes_to_uint_smaller_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function bytesToUint(bytes4 s) public returns (uint16 h) {
+        return uint16(uint32(s));
+    }
+}
+// ----
+// bytesToUint(bytes4): "abcd" -> 0x6364
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_greater_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_greater_size.sol
new file mode 100644
index 00000000..9949b477
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_greater_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function UintToBytes(uint16 h) public returns (bytes8 s) {
+        return bytes8(uint64(h));
+    }
+}
+// ----
+// UintToBytes(uint16): 0x6162 -> "\x00\x00\x00\x00\x00\x00ab"
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_min_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_min_size.sol
new file mode 100644
index 00000000..60b9a4cf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_min_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function UintToBytes(uint8 h) public returns (bytes1 s) {
+        return bytes1(h);
+    }
+}
+// ----
+// UintToBytes(uint8): 0x61 -> "a"
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_size.sol
new file mode 100644
index 00000000..5662d909
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_same_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function uintToBytes(uint256 h) public returns (bytes32 s) {
+        return bytes32(h);
+    }
+}
+// ----
+// uintToBytes(uint256): left(0x616263) -> left(0x616263)
diff --git a/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_smaller_size.sol b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_smaller_size.sol
new file mode 100644
index 00000000..963cbc34
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/convert_uint_to_fixed_bytes_smaller_size.sol
@@ -0,0 +1,7 @@
+contract Test {
+    function uintToBytes(uint32 h) public returns (bytes2 s) {
+        return bytes2(uint16(h));
+    }
+}
+// ----
+// uintToBytes(uint32): 0x61626364 -> "cd"
diff --git a/compiler/test/libsolidity/semanticTests/types/external_function_to_address.sol b/compiler/test/libsolidity/semanticTests/types/external_function_to_address.sol
new file mode 100644
index 00000000..fb938d37
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/external_function_to_address.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public returns (bool) {
+        return this.f.address == address(this);
+    }
+    function g(function() external cb) public returns (address) {
+        return cb.address;
+    }
+}
+// ----
+// f() -> true
+// g(function): hex"00000000000000000000000000000000000004226121ff00000000000000000" -> 0x42
diff --git a/compiler/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol b/compiler/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol
new file mode 100644
index 00000000..b17ba6d9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol
@@ -0,0 +1,34 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8[3] x;
+        uint8[][] y;
+        uint16 z;
+    }
+
+    mapping (uint8 => S) src;
+    mapping (uint8 => S) dst;
+
+    constructor() {
+        uint8[] memory d = new uint8[](2);
+        d[0] = 3;
+        d[1] = 4;
+
+        uint8[][] memory y = new uint8[][](2);
+        y[0] = d;
+        y[1] = d;
+
+        src[0] = S({x: [7, 8, 9], y: y, z: 13});
+    }
+
+    function f() public returns (S memory) {
+        dst[0] = src[0];
+        return dst[0];
+    }
+}
+// ----
+// f() -> 0x20, 7, 8, 9, 0xa0, 13, 2, 0x40, 0xa0, 2, 3, 4, 2, 3, 4
+// gas irOptimized: 197082
+// gas legacy: 199891
+// gas legacyOptimized: 196817
diff --git a/compiler/test/libsolidity/semanticTests/types/mapping/copy_struct_to_array_stored_in_mapping.sol b/compiler/test/libsolidity/semanticTests/types/mapping/copy_struct_to_array_stored_in_mapping.sol
new file mode 100644
index 00000000..43f2a80f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/mapping/copy_struct_to_array_stored_in_mapping.sol
@@ -0,0 +1,56 @@
+pragma abicoder v2;
+
+contract C {
+    struct S {
+        uint8 x;
+    }
+
+    constructor() {
+        s = S({x: 7});
+        m2[0].push();
+    }
+
+    S s;
+
+    mapping (uint8 => S[2]) m1;
+    mapping (uint8 => S[]) m2;
+
+    function from_storage_to_static_array() public returns (S[2] memory) {
+        m1[0][1] = s;
+        return m1[0];
+    }
+
+    function from_storage_to_dynamic_array() public returns (S[] memory) {
+        m2[0][0] = s;
+        return m2[0];
+    }
+
+    function from_memory_to_static_array() public returns (S[2] memory) {
+        S memory sLocal = s;
+        m1[0][1] = sLocal;
+        return m1[0];
+    }
+
+    function from_memory_to_dynamic_array() public returns (S[] memory) {
+        S memory sLocal = s;
+        m2[0][0] = sLocal;
+        return m2[0];
+    }
+
+    function from_calldata_to_static_array(S calldata sCalldata) public returns (S[2] memory) {
+        m1[0][1] = sCalldata;
+        return m1[0];
+    }
+
+    function from_calldata_to_dynamic_array(S calldata sCalldata) public returns (S[] memory) {
+        m2[0][0] = sCalldata;
+        return m2[0];
+    }
+}
+// ----
+// from_storage_to_static_array() -> 0, 7
+// from_storage_to_dynamic_array() -> 0x20, 1, 7
+// from_memory_to_static_array() -> 0, 7
+// from_memory_to_dynamic_array() -> 0x20, 1, 7
+// from_calldata_to_static_array((uint8)): 8 -> 0, 8
+// from_calldata_to_dynamic_array((uint8)): 8 -> 0x20, 1, 8
diff --git a/compiler/test/libsolidity/semanticTests/types/mapping/user_defined_types_mapping_storage.sol b/compiler/test/libsolidity/semanticTests/types/mapping/user_defined_types_mapping_storage.sol
new file mode 100644
index 00000000..a8a8fca4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/mapping/user_defined_types_mapping_storage.sol
@@ -0,0 +1,25 @@
+type A is uint;
+type B is uint;
+
+library L {
+  function f(mapping(A=>B) storage _m, B _v) public { _m[A.wrap(uint(2))] = _v; }
+  function f(mapping(uint=>uint) storage _m, uint _v) public { _m[uint(3)] = _v; }
+}
+
+contract C {
+	mapping(uint=>uint) uintMap;
+	mapping(A=>B) abMap;
+
+	function testAB() public returns (bool) {
+		L.f(abMap, B.wrap(3));
+		return B.unwrap(abMap[A.wrap(uint(2))]) == 3;
+	}
+	function testUint() public returns (bool) {
+		L.f(uintMap, 4);
+		return uintMap[3] == 4;
+	}
+}
+// ----
+// library: L
+// testAB() -> true
+// testUint() -> true
diff --git a/compiler/test/libsolidity/semanticTests/types/nested_tuples.sol b/compiler/test/libsolidity/semanticTests/types/nested_tuples.sol
new file mode 100644
index 00000000..32203a9c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/nested_tuples.sol
@@ -0,0 +1,34 @@
+contract test {
+    function f0() public returns(int, bool) {
+        int a;
+        bool b;
+        ((a, b)) = (2, true);
+        return (a, b);
+    }
+    function f1() public returns(int) {
+        int a;
+        (((a, ), )) = ((1, 2) ,3);
+        return a;
+    }
+    function f2() public returns(int) {
+        int a;
+        (((, a),)) = ((1, 2), 3);
+        return a;
+    }
+    function f3() public returns(int) {
+        int a = 3;
+        ((, ), ) = ((7, 8), 9);
+        return a;
+    }
+    function f4() public returns(int) {
+        int a;
+        (a, ) = (4, (8, 16, 32));
+        return a;
+    }
+}
+// ----
+// f0() -> 2, true
+// f1() -> 1
+// f2() -> 2
+// f3() -> 3
+// f4() -> 4
diff --git a/compiler/test/libsolidity/semanticTests/types/packing_signed_types.sol b/compiler/test/libsolidity/semanticTests/types/packing_signed_types.sol
new file mode 100644
index 00000000..2d2e0e16
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/packing_signed_types.sol
@@ -0,0 +1,8 @@
+contract test {
+    function run() public returns(int8 y) {
+        uint8 x = 0xfa;
+        return int8(x);
+    }
+}
+// ----
+// run() -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa
diff --git a/compiler/test/libsolidity/semanticTests/types/packing_unpacking_types.sol b/compiler/test/libsolidity/semanticTests/types/packing_unpacking_types.sol
new file mode 100644
index 00000000..8b500cca
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/packing_unpacking_types.sol
@@ -0,0 +1,10 @@
+contract test {
+    function run(bool a, uint32 b, uint64 c) public returns(uint256 y) {
+        if (a) y = 1;
+        y = y * 0x100000000 | ~b;
+        y = y * 0x10000000000000000 | ~c;
+    }
+}
+// ----
+// run(bool,uint32,uint64): true, 0x0f0f0f0f, 0xf0f0f0f0f0f0f0f0
+// -> 0x0000000000000000000000000000000000000001f0f0f0f00f0f0f0f0f0f0f0f
diff --git a/compiler/test/libsolidity/semanticTests/types/strings.sol b/compiler/test/libsolidity/semanticTests/types/strings.sol
new file mode 100644
index 00000000..f76116bb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/strings.sol
@@ -0,0 +1,16 @@
+contract test {
+    function fixedBytesHex() public returns(bytes32 ret) {
+        return hex"aabb00ff";
+    }
+    function fixedBytes() public returns(bytes32 ret) {
+        return "abc\x00\xff__";
+    }
+    function pipeThrough(bytes2 small, bool one) public returns(bytes16 large, bool oneRet) {
+        oneRet = one;
+        large = small;
+    }
+}
+// ----
+// fixedBytesHex() -> "\xaa\xbb\x00\xff"
+// fixedBytes() -> "abc\x00\xff__"
+// pipeThrough(bytes2,bool): "\x00\x02", true -> "\x00\x02", true
diff --git a/compiler/test/libsolidity/semanticTests/types/tuple_assign_multi_slot_grow.sol b/compiler/test/libsolidity/semanticTests/types/tuple_assign_multi_slot_grow.sol
new file mode 100644
index 00000000..6574dcb5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/tuple_assign_multi_slot_grow.sol
@@ -0,0 +1,11 @@
+contract C {
+
+	function f() public pure returns (uint, uint, uint) {
+		bytes memory a; bytes memory b; bytes memory c;
+		(a, (b, c)) = ("0", ("1", "2"));
+		return (uint8(a[0]), uint8(b[0]), uint8(c[0]));
+	}
+
+}
+// ----
+// f() -> 0x30, 0x31, 0x32
diff --git a/compiler/test/libsolidity/semanticTests/types/type_conversion_cleanup.sol b/compiler/test/libsolidity/semanticTests/types/type_conversion_cleanup.sol
new file mode 100644
index 00000000..d3d2b01b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/types/type_conversion_cleanup.sol
@@ -0,0 +1,5 @@
+contract Test {
+    function test() public returns (uint ret) { return uint(uint160(address(uint160(uint128(type(uint200).max))))); }
+}
+// ----
+// test() -> 0xffffffffffffffffffffffffffffffff
diff --git a/compiler/test/libsolidity/semanticTests/underscore/as_function.sol b/compiler/test/libsolidity/semanticTests/underscore/as_function.sol
new file mode 100644
index 00000000..be60a01b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/underscore/as_function.sol
@@ -0,0 +1,18 @@
+contract C {
+    function _() public pure returns (uint) {
+        return 88;
+    }
+
+    function g() public pure returns (uint){
+        return _();
+    }
+
+    function h() public pure returns (uint) {
+        _;
+        return 33;
+    }
+}
+// ----
+// _() -> 88
+// g() -> 88
+// h() -> 33
diff --git a/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidInConstructor.sol b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidInConstructor.sol
new file mode 100644
index 00000000..e4e6453c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidInConstructor.sol
@@ -0,0 +1,23 @@
+contract C {
+
+  function() internal storedFn;
+
+  bool flag;
+
+  constructor() {
+    if (!flag) {
+      flag = true;
+      function() internal invalid;
+      storedFn = invalid;
+      invalid();
+    }
+  }
+  function f() public pure {}
+}
+contract Test {
+  function f() public {
+    new C();
+  }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidStoredInConstructor.sol b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidStoredInConstructor.sol
new file mode 100644
index 00000000..fbaca1a6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/invalidStoredInConstructor.sol
@@ -0,0 +1,23 @@
+contract C {
+
+  function() internal storedFn;
+
+  bool flag;
+
+  constructor() {
+    if (!flag) {
+      flag = true;
+      function() internal invalid;
+      storedFn = invalid;
+      storedFn();
+    }
+  }
+  function f() public pure {}
+}
+contract Test {
+  function f() public {
+    new C();
+  }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/store2.sol b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/store2.sol
new file mode 100644
index 00000000..1c1e596a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/store2.sol
@@ -0,0 +1,39 @@
+pragma solidity >=0.4.0 <0.9.0;
+
+contract InvalidTest {
+
+  function() internal storedFn;
+  uint public x;
+
+  constructor() {
+    uint _y1;
+    uint _y2;
+    uint _y3;
+    uint _y4;
+    uint _y5;
+    uint _y6;
+    uint _y7;
+    uint _y8;
+    uint _y9;
+    uint _y10;
+    uint _y11;
+    uint _y12;
+    uint _y13;
+    uint _y14;
+
+
+    function() internal invalid;
+    storedFn = invalid;
+  }
+
+  function run() public {
+    // this did not always cause revert in the past
+    storedFn();
+  }
+
+  function z() public {
+      x++;
+  }
+}
+// ----
+// run() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/storeInConstructor.sol b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/storeInConstructor.sol
new file mode 100644
index 00000000..08a96792
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/storeInConstructor.sol
@@ -0,0 +1,19 @@
+contract InvalidTest {
+
+  function() internal storedFn;
+
+  bool flag;
+
+  constructor() {
+    function() internal invalid;
+    storedFn = invalid;
+  }
+  function f() public returns (uint) {
+    if (flag) return 2;
+    flag = true;
+    storedFn();
+  }
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x51
+// f() -> FAILURE, hex"4e487b71", 0x51
diff --git a/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/uninitialized_internal_storage_function_via_yul.sol b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/uninitialized_internal_storage_function_via_yul.sol
new file mode 100644
index 00000000..bf8eab8c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/uninitializedFunctionPointer/uninitialized_internal_storage_function_via_yul.sol
@@ -0,0 +1,17 @@
+contract Test {
+	function() internal x;
+	function f() public returns (bool) {
+		function() internal t = x;
+		// The legacy codegen  would use a specific function
+		// entry tag that always panics.
+		// Via Yul, the internal dispatch will panic instead.
+		uint z;
+		assembly { z := t }
+		assert(z == 0);
+		return true;
+	}
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol
new file mode 100644
index 00000000..9ed64be0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol
@@ -0,0 +1,63 @@
+pragma abicoder v2;
+type MyAddress is address;
+
+contract C {
+    MyAddress[] public addresses;
+    function f(MyAddress[] calldata _addresses) external {
+        for (uint i = 0; i < _addresses.length; i++) {
+            MyAddress.unwrap(_addresses[i]).call("");
+        }
+        addresses = _addresses;
+    }
+    function g(MyAddress[] memory _addresses) external {
+        for (uint i = 0; i < _addresses.length; i++) {
+            MyAddress.unwrap(_addresses[i]).call("");
+        }
+        addresses = _addresses;
+    }
+    function test_f() external returns (bool) {
+        clean();
+        MyAddress[] memory test = new MyAddress[](3);
+        test[0] = MyAddress.wrap(address(21));
+        test[1] = MyAddress.wrap(address(22));
+        test[2] = MyAddress.wrap(address(23));
+        this.f(test);
+        test_equality(test);
+        return true;
+    }
+    function test_g() external returns (bool) {
+        clean();
+        MyAddress[] memory test = new MyAddress[](5);
+        test[0] = MyAddress.wrap(address(24));
+        test[1] = MyAddress.wrap(address(25));
+        test[2] = MyAddress.wrap(address(26));
+        test[3] = MyAddress.wrap(address(27));
+        test[4] = MyAddress.wrap(address(28));
+        this.g(test);
+        test_equality(test);
+        return true;
+    }
+    function clean() internal {
+        delete addresses;
+    }
+    function test_equality(MyAddress[] memory _addresses) internal view {
+        require (_addresses.length == addresses.length);
+        for (uint i = 0; i < _addresses.length; i++) {
+            require(MyAddress.unwrap(_addresses[i]) == MyAddress.unwrap(addresses[i]));
+        }
+    }
+}
+// ----
+// test_f() -> true
+// gas irOptimized: 122078
+// gas legacy: 125322
+// gas legacyOptimized: 122709
+// test_g() -> true
+// gas irOptimized: 106215
+// gas legacy: 111120
+// gas legacyOptimized: 106964
+// addresses(uint256): 0 -> 0x18
+// addresses(uint256): 1 -> 0x19
+// addresses(uint256): 3 -> 0x1b
+// addresses(uint256): 4 -> 0x1c
+// addresses(uint256): 5 -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup.sol
new file mode 100644
index 00000000..cc165e87
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup.sol
@@ -0,0 +1,41 @@
+pragma abicoder v2;
+type MyUInt8 is uint8;
+
+// Note that this wraps from a uint256
+function wrap(uint x) pure returns (MyUInt8 y) { assembly { y := x } }
+function unwrap(MyUInt8 x) pure returns (uint8 y) { assembly { y := x } }
+
+contract C {
+    uint8 a;
+    MyUInt8 b;
+    uint8 c;
+    function ret() external returns(MyUInt8) {
+        return wrap(0x1ff);
+    }
+    function f(MyUInt8 x) external returns(MyUInt8) {
+        return x;
+    }
+    function mem() external returns (MyUInt8[] memory) {
+        MyUInt8[] memory x = new MyUInt8[](2);
+        x[0] = wrap(0x1ff);
+        x[1] = wrap(0xff);
+        require(unwrap(x[0]) == unwrap(x[1]));
+        assembly {
+            mstore(add(x, 0x20), 0x1ff)
+        }
+        require(unwrap(x[0]) == unwrap(x[1]));
+        return x;
+    }
+    function stor() external returns (uint8, MyUInt8, uint8) {
+        a = 1;
+        c = 2;
+        b = wrap(0x1ff);
+        return (a, b, c);
+    }
+}
+// ----
+// ret() -> 0xff
+// f(uint8): 0x1ff -> FAILURE
+// f(uint8): 0xff -> 0xff
+// mem() -> 0x20, 2, 0xff, 0xff
+// stor() -> 1, 0xff, 2
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup_abicoderv1.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup_abicoderv1.sol
new file mode 100644
index 00000000..727c6606
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/cleanup_abicoderv1.sol
@@ -0,0 +1,43 @@
+pragma abicoder v1;
+type MyUInt8 is uint8;
+
+// Note that this wraps from a uint256
+function wrap(uint x) pure returns (MyUInt8 y) { assembly { y := x } }
+function unwrap(MyUInt8 x) pure returns (uint8 y) { assembly { y := x } }
+
+contract C {
+    uint8 a;
+    MyUInt8 b;
+    uint8 c;
+    function ret() external returns(MyUInt8) {
+        return wrap(0x1ff);
+    }
+    function f(MyUInt8 x) external returns(MyUInt8) {
+        return x;
+    }
+    function mem() external returns (MyUInt8[] memory) {
+        MyUInt8[] memory x = new MyUInt8[](2);
+        x[0] = wrap(0x1ff);
+        x[1] = wrap(0xff);
+        require(unwrap(x[0]) == unwrap(x[1]));
+        assembly {
+            mstore(add(x, 0x20), 0x1ff)
+        }
+        require(unwrap(x[0]) == unwrap(x[1]));
+        return x;
+    }
+    function stor() external returns (uint8, MyUInt8, uint8) {
+        a = 1;
+        c = 2;
+        b = wrap(0x1ff);
+        return (a, b, c);
+    }
+}
+// ====
+// compileViaYul: false
+// ----
+// ret() -> 0xff
+// f(uint8): 0x1ff -> 0xff
+// f(uint8): 0xff -> 0xff
+// mem() -> 0x20, 2, 0x01ff, 0xff
+// stor() -> 1, 0xff, 2
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion.sol
new file mode 100644
index 00000000..24b316f9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion.sol
@@ -0,0 +1,54 @@
+pragma abicoder v2;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+    function f(uint a) external returns(MyUInt8) {
+        return MyUInt8.wrap(uint8(a));
+    }
+    function g(uint a) external returns(MyInt8) {
+        return MyInt8.wrap(int8(int(a)));
+    }
+    function h(MyUInt8 a) external returns (MyInt8) {
+        return MyInt8.wrap(int8(MyUInt8.unwrap(a)));
+    }
+    function i(MyUInt8 a) external returns(MyUInt16) {
+        return MyUInt16.wrap(MyUInt8.unwrap(a));
+    }
+    function j(MyUInt8 a) external returns (uint) {
+        return MyUInt8.unwrap(a);
+    }
+    function k(MyUInt8 a) external returns (MyUInt16) {
+        return MyUInt16.wrap(MyUInt8.unwrap(a));
+    }
+    function m(MyUInt16 a) external returns (MyUInt8) {
+        return MyUInt8.wrap(uint8(MyUInt16.unwrap(a)));
+    }
+}
+// ----
+// f(uint256): 1 -> 1
+// f(uint256): 2 -> 2
+// f(uint256): 257 -> 1
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 2
+// g(uint256): 255 -> -1
+// g(uint256): 257 -> 1
+// h(uint8): 1 -> 1
+// h(uint8): 2 -> 2
+// h(uint8): 255 -> -1
+// h(uint8): 257 -> FAILURE
+// i(uint8): 250 -> 250
+// j(uint8): 1 -> 1
+// j(uint8): 2 -> 2
+// j(uint8): 255 -> 0xff
+// j(uint8): 257 -> FAILURE
+// k(uint8): 1 -> 1
+// k(uint8): 2 -> 2
+// k(uint8): 255 -> 0xff
+// k(uint8): 257 -> FAILURE
+// m(uint16): 1 -> 1
+// m(uint16): 2 -> 2
+// m(uint16): 255 -> 0xff
+// m(uint16): 257 -> 1
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion_abicoderv1.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion_abicoderv1.sol
new file mode 100644
index 00000000..e8fbfb24
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/conversion_abicoderv1.sol
@@ -0,0 +1,56 @@
+pragma abicoder v1;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+    function f(uint a) external returns(MyUInt8) {
+        return MyUInt8.wrap(uint8(a));
+    }
+    function g(uint a) external returns(MyInt8) {
+        return MyInt8.wrap(int8(int(a)));
+    }
+    function h(MyUInt8 a) external returns (MyInt8) {
+        return MyInt8.wrap(int8(MyUInt8.unwrap(a)));
+    }
+    function i(MyUInt8 a) external returns(MyUInt16) {
+        return MyUInt16.wrap(MyUInt8.unwrap(a));
+    }
+    function j(MyUInt8 a) external returns (uint) {
+        return MyUInt8.unwrap(a);
+    }
+    function k(MyUInt8 a) external returns (MyUInt16) {
+        return MyUInt16.wrap(MyUInt8.unwrap(a));
+    }
+    function m(MyUInt16 a) external returns (MyUInt8) {
+        return MyUInt8.wrap(uint8(MyUInt16.unwrap(a)));
+    }
+}
+// ====
+// compileViaYul: false
+// ----
+// f(uint256): 1 -> 1
+// f(uint256): 2 -> 2
+// f(uint256): 257 -> 1
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 2
+// g(uint256): 255 -> -1
+// g(uint256): 257 -> 1
+// h(uint8): 1 -> 1
+// h(uint8): 2 -> 2
+// h(uint8): 255 -> -1
+// h(uint8): 257 -> 1
+// i(uint8): 250 -> 250
+// j(uint8): 1 -> 1
+// j(uint8): 2 -> 2
+// j(uint8): 255 -> 0xff
+// j(uint8): 257 -> 1
+// k(uint8): 1 -> 1
+// k(uint8): 2 -> 2
+// k(uint8): 255 -> 0xff
+// k(uint8): 257 -> 1
+// m(uint16): 1 -> 1
+// m(uint16): 2 -> 2
+// m(uint16): 255 -> 0xff
+// m(uint16): 257 -> 1
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol
new file mode 100644
index 00000000..27ab530c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol
@@ -0,0 +1,145 @@
+pragma abicoder v2;
+// A rewrite of the test/libsolidity/semanticTests/various/erc20.sol, but using user defined value
+// types.
+
+// User defined type name. Indicating a type with 18 decimals.
+type UFixed18 is uint256;
+
+library FixedMath
+{
+    function add(UFixed18 a, UFixed18 b) internal pure returns (UFixed18 c) {
+        return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+    }
+    function sub(UFixed18 a, UFixed18 b) internal pure returns (UFixed18 c) {
+        return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+    }
+}
+
+contract ERC20 {
+    using FixedMath for UFixed18;
+
+    event Transfer(address indexed from, address indexed to, UFixed18 value);
+    event Approval(address indexed owner, address indexed spender, UFixed18 value);
+
+    mapping (address => UFixed18) private _balances;
+    mapping (address => mapping (address => UFixed18)) private _allowances;
+    UFixed18 private _totalSupply;
+
+    constructor() {
+        _mint(msg.sender, UFixed18.wrap(20));
+    }
+
+    function totalSupply() public view returns (UFixed18) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address owner) public view returns (UFixed18) {
+        return _balances[owner];
+    }
+
+    function allowance(address owner, address spender) public view returns (UFixed18) {
+        return _allowances[owner][spender];
+    }
+
+    function transfer(address to, UFixed18 value) public returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function approve(address spender, UFixed18 value) public returns (bool) {
+        _approve(msg.sender, spender, value);
+        return true;
+    }
+
+    function transferFrom(address from, address to, UFixed18 value) public returns (bool) {
+        _transfer(from, to, value);
+        // The subtraction here will revert on overflow.
+        _approve(from, msg.sender, _allowances[from][msg.sender].sub(value));
+        return true;
+    }
+
+    function increaseAllowance(address spender, UFixed18 addedValue) public returns (bool) {
+        // The addition here will revert on overflow.
+        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
+        return true;
+    }
+
+    function decreaseAllowance(address spender, UFixed18 subtractedValue) public returns (bool) {
+        // The subtraction here will revert on overflow.
+        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
+        return true;
+    }
+
+    function _transfer(address from, address to, UFixed18 value) internal {
+        require(to != address(0), "ERC20: transfer to the zero address");
+
+        // The subtraction and addition here will revert on overflow.
+        _balances[from] = _balances[from].sub(value);
+        _balances[to] = _balances[to].add(value);
+        emit Transfer(from, to, value);
+    }
+
+    function _mint(address account, UFixed18 value) internal {
+        require(account != address(0), "ERC20: mint to the zero address");
+
+        // The additions here will revert on overflow.
+        _totalSupply = _totalSupply.add(value);
+        _balances[account] = _balances[account].add(value);
+        emit Transfer(address(0), account, value);
+    }
+
+    function _burn(address account, UFixed18 value) internal {
+        require(account != address(0), "ERC20: burn from the zero address");
+
+        // The subtractions here will revert on overflow.
+        _totalSupply = _totalSupply.sub(value);
+        _balances[account] = _balances[account].sub(value);
+        emit Transfer(account, address(0), value);
+    }
+
+    function _approve(address owner, address spender, UFixed18 value) internal {
+        require(owner != address(0), "ERC20: approve from the zero address");
+        require(spender != address(0), "ERC20: approve to the zero address");
+
+        _allowances[owner][spender] = value;
+        emit Approval(owner, spender, value);
+    }
+
+    function _burnFrom(address account, UFixed18 value) internal {
+        _burn(account, value);
+        _approve(account, msg.sender, _allowances[account][msg.sender].sub(value));
+    }
+}
+// ----
+// constructor()
+// ~ emit Transfer(address,address,uint256): #0x00, #0x1212121212121212121212121212120000000012, 0x14
+// gas irOptimized: 352698
+// gas legacy: 834932
+// gas legacyOptimized: 412648
+// totalSupply() -> 20
+// gas irOptimized: 23415
+// gas legacy: 23653
+// gas legacyOptimized: 23368
+// transfer(address,uint256): 2, 5 -> true
+// ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x05
+// gas irOptimized: 48471
+// gas legacy: 49572
+// gas legacyOptimized: 48575
+// decreaseAllowance(address,uint256): 2, 0 -> true
+// ~ emit Approval(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x00
+// gas irOptimized: 26275
+// gas legacy: 27204
+// gas legacyOptimized: 26317
+// decreaseAllowance(address,uint256): 2, 1 -> FAILURE, hex"4e487b71", 0x11
+// gas irOptimized: 24042
+// gas legacy: 24506
+// gas legacyOptimized: 24077
+// transfer(address,uint256): 2, 14 -> true
+// ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x0e
+// gas irOptimized: 28571
+// gas legacy: 29672
+// gas legacyOptimized: 28675
+// transfer(address,uint256): 2, 2 -> FAILURE, hex"4e487b71", 0x11
+// gas irOptimized: 24071
+// gas legacy: 24492
+// gas legacyOptimized: 24074
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/storage_layout_struct.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/storage_layout_struct.sol
new file mode 100644
index 00000000..8c51b292
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/storage_layout_struct.sol
@@ -0,0 +1,178 @@
+type MyInt64 is int64;
+struct HalfSlot {
+    MyInt64 a;
+    MyInt64 b;
+}
+
+struct RegularHalfSlot {
+    int64 a;
+    int64 b;
+}
+
+type MyAddress is address;
+type MyInt96 is int96;
+struct FullSlot {
+    MyInt96 a;
+    MyAddress b;
+}
+struct RegularFullSlot {
+    int96 a;
+    address b;
+}
+
+contract C {
+    HalfSlot public a;
+    RegularHalfSlot public ra;
+
+    HalfSlot public b;
+    RegularHalfSlot public rb;
+
+    HalfSlot public c;
+    RegularHalfSlot public rc;
+
+    FullSlot public d;
+    RegularFullSlot public rd;
+
+    function storage_a() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := a.slot
+            offset := a.offset
+        }
+    }
+
+    function storage_ra() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := ra.slot
+            offset := ra.offset
+        }
+    }
+
+    function storage_b() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := b.slot
+            offset := b.offset
+        }
+    }
+
+    function storage_rb() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := rb.slot
+            offset := rb.offset
+        }
+    }
+
+   function storage_c() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := c.slot
+            offset := c.offset
+        }
+    }
+
+   function storage_rc() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := rc.slot
+            offset := rc.offset
+        }
+    }
+
+   function storage_d() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := d.slot
+            offset := d.offset
+        }
+    }
+
+   function storage_rd() pure external returns(uint slot, uint offset) {
+        assembly {
+            slot := rd.slot
+            offset := rd.offset
+        }
+    }
+
+
+   function set_a(MyInt64 _a, MyInt64 _b) external {
+       a.a = _a;
+       a.b = _b;
+   }
+
+   function set_ra(int64 _a, int64 _b) external {
+       ra.a = _a;
+       ra.b = _b;
+   }
+
+   function set_b(MyInt64 _a, MyInt64 _b) external {
+       b.a = _a;
+       b.b = _b;
+   }
+
+   function set_rb(int64 _a, int64 _b) external {
+       rb.a = _a;
+       rb.b = _b;
+   }
+
+   function set_c(MyInt64 _a, MyInt64 _b) external {
+       c.a = _a;
+       c.b = _b;
+   }
+
+   function set_rc(int64 _a, int64 _b) external {
+       rc.a = _a;
+       rc.b = _b;
+   }
+
+   function set_d(MyInt96 _a, MyAddress _b) external {
+       d.a = _a;
+       d.b = _b;
+   }
+
+   function set_rd(int96 _a, address _b) external {
+       rd.a = _a;
+       rd.b = _b;
+   }
+
+   function read_slot(uint slot) view external returns (uint value) {
+       assembly {
+           value := sload(slot)
+       }
+   }
+
+   function read_contents_asm() external returns (bytes32 rxa, bytes32 rya, bytes32 rxb, bytes32 ryb) {
+       b.a = MyInt64.wrap(-2);
+       b.b = MyInt64.wrap(-3);
+       HalfSlot memory x = b;
+       MyInt64 y = b.a;
+       MyInt64 z = b.b;
+       assembly {
+           rxa := mload(x)
+           rya := y
+           rxb := mload(add(x, 0x20))
+           ryb := z
+       }
+   }
+}
+// ----
+// storage_a() -> 0, 0
+// set_a(int64,int64): 100, 200 ->
+// read_slot(uint256): 0 -> 0xc80000000000000064
+// storage_ra() -> 1, 0
+// set_ra(int64,int64): 100, 200 ->
+// read_slot(uint256): 1 -> 0xc80000000000000064
+// storage_b() -> 2, 0
+// set_b(int64,int64): 0, 200 ->
+// read_slot(uint256): 2 -> 3689348814741910323200
+// storage_rb() -> 3, 0
+// set_rb(int64,int64): 0, 200 ->
+// read_slot(uint256): 3 -> 3689348814741910323200
+// storage_c() -> 4, 0
+// set_c(int64,int64): 100, 0 ->
+// read_slot(uint256): 4 -> 0x64
+// storage_rc() -> 5, 0
+// set_rc(int64,int64): 100, 0 ->
+// read_slot(uint256): 5 -> 0x64
+// storage_d() -> 6, 0
+// set_d(int96,address): 39614081257132168796771975167, 1461501637330902918203684832716283019655932542975 ->
+// read_slot(uint256): 6 -> -39614081257132168796771975169
+// storage_rd() -> 7, 0
+// set_rd(int96,address): 39614081257132168796771975167, 1461501637330902918203684832716283019655932542975 ->
+// read_slot(uint256): 7 -> -39614081257132168796771975169
+// read_contents_asm() -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_elementary.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_elementary.sol
new file mode 100644
index 00000000..2c5a15bb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_elementary.sol
@@ -0,0 +1,34 @@
+// a test to compare the cost between using user defined value types and elementary type. See the
+// test zero_cost_abstraction_userdefined.sol for a comparison.
+
+pragma abicoder v2;
+
+contract C {
+    int x;
+    function setX(int _x) external {
+        x = _x;
+    }
+    function getX() view external returns (int) {
+        return x;
+    }
+    function add(int a, int b) view external returns (int) {
+        return a + b;
+    }
+}
+// ----
+// getX() -> 0
+// gas irOptimized: 23379
+// gas legacy: 23479
+// gas legacyOptimized: 23311
+// setX(int256): 5 ->
+// gas irOptimized: 43510
+// gas legacy: 43724
+// gas legacyOptimized: 43516
+// getX() -> 5
+// gas irOptimized: 23379
+// gas legacy: 23479
+// gas legacyOptimized: 23311
+// add(int256,int256): 200, 99 -> 299
+// gas irOptimized: 21764
+// gas legacy: 22394
+// gas legacyOptimized: 21813
diff --git a/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_userdefined.sol b/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_userdefined.sol
new file mode 100644
index 00000000..2f275c54
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/userDefinedValueType/zero_cost_abstraction_comparison_userdefined.sol
@@ -0,0 +1,35 @@
+// a test to compare the cost between using user defined value types and elementary type. See the
+// test zero_cost_abstraction_elementary.sol for comparison.
+
+pragma abicoder v2;
+
+type MyInt is int;
+contract C {
+    int x;
+    function setX(MyInt _x) external {
+        x = MyInt.unwrap(_x);
+    }
+    function getX() view external returns (MyInt) {
+        return MyInt.wrap(x);
+    }
+    function add(MyInt a, MyInt b) pure external returns(MyInt) {
+        return MyInt.wrap(MyInt.unwrap(a) + MyInt.unwrap(b));
+    }
+}
+// ----
+// getX() -> 0
+// gas irOptimized: 23379
+// gas legacy: 23608
+// gas legacyOptimized: 23311
+// setX(int256): 5 ->
+// gas irOptimized: 43510
+// gas legacy: 43724
+// gas legacyOptimized: 43516
+// getX() -> 5
+// gas irOptimized: 23379
+// gas legacy: 23608
+// gas legacyOptimized: 23311
+// add(int256,int256): 200, 99 -> 299
+// gas irOptimized: 21764
+// gas legacy: 22523
+// gas legacyOptimized: 21813
diff --git a/compiler/test/libsolidity/semanticTests/using/free_function_multi.sol b/compiler/test/libsolidity/semanticTests/using/free_function_multi.sol
new file mode 100644
index 00000000..31ac50bc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/free_function_multi.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f(uint z) pure external returns(uint) {
+        return z.id();
+    }
+
+    using {id, zero, zero, id} for uint;
+
+    function g(uint z) pure external returns (uint) {
+        return z.zero();
+    }
+}
+
+function id(uint x) pure returns (uint) {
+    return x;
+}
+
+function zero(uint) pure returns (uint) {
+    return 0;
+}
+// ----
+// f(uint256): 10 -> 10
+// g(uint256): 10 -> 0
+// f(uint256): 256 -> 0x0100
+// g(uint256): 256 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/using/free_functions_individual.sol b/compiler/test/libsolidity/semanticTests/using/free_functions_individual.sol
new file mode 100644
index 00000000..5a14cd7c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/free_functions_individual.sol
@@ -0,0 +1,26 @@
+using {zero} for uint;
+
+contract C {
+    using {id} for uint;
+
+    function f(uint z) pure external returns(uint) {
+        return z.id();
+    }
+
+    function g(uint z) pure external returns (uint) {
+        return z.zero();
+    }
+}
+
+function id(uint x) pure returns (uint) {
+    return x;
+}
+
+function zero(uint) pure returns (uint) {
+    return 0;
+}
+// ----
+// f(uint256): 10 -> 10
+// g(uint256): 10 -> 0
+// f(uint256): 256 -> 0x0100
+// g(uint256): 256 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/using/library_functions_inside_contract.sol b/compiler/test/libsolidity/semanticTests/using/library_functions_inside_contract.sol
new file mode 100644
index 00000000..170bc785
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/library_functions_inside_contract.sol
@@ -0,0 +1,31 @@
+library L {
+    function externalFunction(uint a) external pure returns (uint) { return a * 1; }
+    function publicFunction(uint b) public pure returns (uint) { return b * 2; }
+    function internalFunction(uint c) internal pure returns (uint) { return c * 3; }
+}
+
+contract C {
+    using {L.externalFunction} for uint;
+    using {L.publicFunction} for uint;
+    using {L.internalFunction} for uint;
+
+    function f() public pure returns (uint) {
+        uint x = 1;
+        return x.externalFunction();
+    }
+
+    function g() public pure returns (uint) {
+        uint x = 1;
+        return x.publicFunction();
+    }
+
+    function h() public pure returns (uint) {
+        uint x = 1;
+        return x.internalFunction();
+    }
+}
+// ----
+// library: L
+// f() -> 1
+// g() -> 2
+// h() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/using/private_library_function.sol b/compiler/test/libsolidity/semanticTests/using/private_library_function.sol
new file mode 100644
index 00000000..e1440492
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/private_library_function.sol
@@ -0,0 +1,10 @@
+library L {
+    using {L.privateFunction} for uint;
+    function privateFunction(uint x) private pure returns (uint) { return x + 1; }
+    function f() public pure returns (uint) {
+        uint x = 1;
+        return x.privateFunction();
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/using/using_global_for_global.sol b/compiler/test/libsolidity/semanticTests/using/using_global_for_global.sol
new file mode 100644
index 00000000..67a31c34
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/using_global_for_global.sol
@@ -0,0 +1,17 @@
+==== Source: A ====
+type global is uint;
+using { f } for global global;
+function f(global x) pure returns (global) { return global.wrap(global.unwrap(x) + 1); }
+==== Source: B ====
+import { global } from "A";
+
+function g(global x) pure returns (global) { return global.wrap(global.unwrap(x) + 10); }
+
+contract C {
+    using { g } for global;
+    function f(global r) public pure returns (global) {
+        return r.f().g();
+    }
+}
+// ----
+// f(uint256): 100 -> 111
\ No newline at end of file
diff --git a/compiler/test/libsolidity/semanticTests/using/using_global_invisible.sol b/compiler/test/libsolidity/semanticTests/using/using_global_invisible.sol
new file mode 100644
index 00000000..3e767a18
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/using/using_global_invisible.sol
@@ -0,0 +1,43 @@
+==== Source: A ====
+type T is uint;
+using L for T global;
+library L {
+    function inc(T x) internal pure returns (T) {
+        return T.wrap(T.unwrap(x) + 1);
+    }
+    function dec(T x) external pure returns (T) {
+        return T.wrap(T.unwrap(x) - 1);
+    }
+}
+using {unwrap} for T global;
+function unwrap(T x) pure returns (uint) {
+    return T.unwrap(x);
+}
+
+==== Source: B ====
+contract C {
+    function f() public pure returns (T r1) {
+        r1 = r1.inc().inc();
+    }
+}
+
+import {T} from "A";
+
+==== Source: C ====
+import {C} from "B";
+
+contract D {
+    function test() public returns (uint) {
+        C c = new C();
+        // This tests that attached functions are available
+        // even if the type is not available by name.
+        // This is a regular function call, a
+        // public and an internal library call
+        // and a free function call.
+        return c.f().inc().inc().dec().unwrap();
+    }
+}
+// ----
+// library: "A":L
+// test() -> 3
+// gas legacy: 120881
diff --git a/compiler/test/libsolidity/semanticTests/variables/delete_local.sol b/compiler/test/libsolidity/semanticTests/variables/delete_local.sol
new file mode 100644
index 00000000..1d00bace
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/variables/delete_local.sol
@@ -0,0 +1,9 @@
+contract test {
+    function delLocal() public returns (uint res){
+        uint v = 5;
+        delete v;
+        res = v;
+    }
+}
+// ----
+// delLocal() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/variables/delete_locals.sol b/compiler/test/libsolidity/semanticTests/variables/delete_locals.sol
new file mode 100644
index 00000000..e442b8e8
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/variables/delete_locals.sol
@@ -0,0 +1,12 @@
+contract test {
+    function delLocal() public returns (uint res1, uint res2){
+        uint v = 5;
+        uint w = 6;
+        uint x = 7;
+        delete v;
+        res1 = w;
+        res2 = x;
+    }
+}
+// ----
+// delLocal() -> 6, 7
diff --git a/compiler/test/libsolidity/semanticTests/variables/public_state_overridding.sol b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding.sol
new file mode 100644
index 00000000..78e0fb44
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding.sol
@@ -0,0 +1,17 @@
+contract A
+{
+	function test() external virtual returns (uint256)
+	{
+		return 5;
+	}
+}
+contract X is A
+{
+	uint256 public override test;
+
+	function set() public { test = 2; }
+}
+// ----
+// test() -> 0
+// set() ->
+// test() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol
new file mode 100644
index 00000000..15226b5e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_dynamic_struct.sol
@@ -0,0 +1,22 @@
+pragma abicoder               v2;
+
+struct S { uint256 v; string s; }
+
+contract A
+{
+	function test() external virtual returns (uint256 v, string memory s)
+	{
+	    v = 42;
+	    s = "test";
+	}
+}
+contract X is A
+{
+	S public override test;
+
+	function set() public { test.v = 2; test.s = "statevar"; }
+}
+// ----
+// test() -> 0, 64, 0
+// set() ->
+// test() -> 2, 0x40, 8, "statevar"
diff --git a/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol
new file mode 100644
index 00000000..62aa616e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/variables/public_state_overridding_mapping_to_dynamic_struct.sol
@@ -0,0 +1,24 @@
+pragma abicoder               v2;
+
+struct S { uint256 v; string s; }
+
+contract A
+{
+	function test(uint256 x) external virtual returns (uint256 v, string memory s)
+	{
+	    v = x;
+	    s = "test";
+	}
+}
+contract X is A
+{
+	mapping(uint256 => S) public override test;
+
+	function set() public { test[42].v = 2; test[42].s = "statevar"; }
+}
+// ----
+// test(uint256): 0 -> 0, 64, 0
+// test(uint256): 42 -> 0, 64, 0
+// set() ->
+// test(uint256): 0 -> 0, 64, 0
+// test(uint256): 42 -> 2, 0x40, 8, "statevar"
diff --git a/compiler/test/libsolidity/semanticTests/various/address_code.sol b/compiler/test/libsolidity/semanticTests/various/address_code.sol
new file mode 100644
index 00000000..80daf116
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/address_code.sol
@@ -0,0 +1,23 @@
+contract C {
+    bytes public initCode;
+
+    constructor() {
+        // This should catch problems, but lets also test the case the optimiser is buggy.
+        assert(address(this).code.length == 0);
+        initCode = address(this).code;
+    }
+
+    // To avoid dependency on exact length.
+    function f() public view returns (bool) { return address(this).code.length > 400; }
+    function g() public view returns (uint) { return address(0).code.length; }
+    function h() public view returns (uint) { return address(1).code.length; }
+}
+// ----
+// constructor() ->
+// gas irOptimized: 173273
+// gas legacy: 241796
+// gas legacyOptimized: 153670
+// initCode() -> 0x20, 0
+// f() -> true
+// g() -> 0
+// h() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/various/assignment_to_const_var_involving_expression.sol b/compiler/test/libsolidity/semanticTests/various/assignment_to_const_var_involving_expression.sol
new file mode 100644
index 00000000..110240ce
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/assignment_to_const_var_involving_expression.sol
@@ -0,0 +1,9 @@
+contract C {
+    uint256 constant x = 0x123 + 0x456;
+
+    function f() public returns (uint256) {
+        return x + 1;
+    }
+}
+// ----
+// f() -> 0x57a
diff --git a/compiler/test/libsolidity/semanticTests/various/balance.sol b/compiler/test/libsolidity/semanticTests/various/balance.sol
new file mode 100644
index 00000000..8638f409
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/balance.sol
@@ -0,0 +1,10 @@
+contract test {
+    constructor() payable {}
+
+    function getBalance() public returns (uint256 balance) {
+        return address(this).balance;
+    }
+}
+// ----
+// constructor(), 23 wei ->
+// getBalance() -> 23
diff --git a/compiler/test/libsolidity/semanticTests/various/byte_optimization_bug.sol b/compiler/test/libsolidity/semanticTests/various/byte_optimization_bug.sol
new file mode 100644
index 00000000..b850ea32
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/byte_optimization_bug.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f(uint256 x) public returns (uint256 a) {
+        assembly {
+            a := byte(x, 31)
+        }
+    }
+
+    function g(uint256 x) public returns (uint256 a) {
+        assembly {
+            a := byte(31, x)
+        }
+    }
+}
+// ----
+// f(uint256): 2 -> 0
+// g(uint256): 2 -> 2
diff --git a/compiler/test/libsolidity/semanticTests/various/code_access_content.sol b/compiler/test/libsolidity/semanticTests/various/code_access_content.sol
new file mode 100644
index 00000000..92d31d62
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/code_access_content.sol
@@ -0,0 +1,43 @@
+contract D {
+    bytes32 public x;
+
+    constructor() {
+        bytes32 codeHash;
+        assembly {
+            let size := codesize()
+            codecopy(mload(0x40), 0, size)
+            codeHash := keccak256(mload(0x40), size)
+        }
+        x = codeHash;
+    }
+}
+
+
+contract C {
+    function testRuntime() public returns (bool) {
+        D d = new D();
+        bytes32 runtimeHash = keccak256(type(D).runtimeCode);
+        bytes32 otherHash;
+        uint256 size;
+        assembly {
+            size := extcodesize(d)
+            extcodecopy(d, mload(0x40), 0, size)
+            otherHash := keccak256(mload(0x40), size)
+        }
+        require(size == type(D).runtimeCode.length);
+        require(runtimeHash == otherHash);
+        return true;
+    }
+
+    function testCreation() public returns (bool) {
+        D d = new D();
+        bytes32 creationHash = keccak256(type(D).creationCode);
+        require(creationHash == d.x());
+        return true;
+    }
+}
+// ----
+// testRuntime() -> true
+// gas legacy: 100177
+// testCreation() -> true
+// gas legacy: 100600
diff --git a/compiler/test/libsolidity/semanticTests/various/code_access_create.sol b/compiler/test/libsolidity/semanticTests/various/code_access_create.sol
new file mode 100644
index 00000000..07568212
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/code_access_create.sol
@@ -0,0 +1,26 @@
+contract D {
+    uint256 x;
+
+    constructor() {
+        x = 7;
+    }
+
+    function f() public view returns (uint256) {
+        return x;
+    }
+}
+
+
+contract C {
+    function test() public returns (uint256) {
+        bytes memory c = type(D).creationCode;
+        D d;
+        assembly {
+            d := create(0, add(c, 0x20), mload(c))
+        }
+        return d.f();
+    }
+}
+// ----
+// test() -> 7
+// gas legacy: 100849
diff --git a/compiler/test/libsolidity/semanticTests/various/code_access_runtime.sol b/compiler/test/libsolidity/semanticTests/various/code_access_runtime.sol
new file mode 100644
index 00000000..9a9e7a80
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/code_access_runtime.sol
@@ -0,0 +1,26 @@
+contract D {
+    uint256 x;
+
+    constructor() {
+        x = 7;
+    }
+
+    function f() public view returns (uint256) {
+        return x;
+    }
+}
+
+contract C {
+    function test() public returns (uint256) {
+        D d = new D();
+        bytes32 hash;
+        assembly { hash := extcodehash(d) }
+        assert(hash == keccak256(type(D).runtimeCode));
+        return 42;
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// test() -> 42
+// gas legacy: 100235
diff --git a/compiler/test/libsolidity/semanticTests/various/code_length.sol b/compiler/test/libsolidity/semanticTests/various/code_length.sol
new file mode 100644
index 00000000..97a76379
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/code_length.sol
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0
+contract C {
+    uint len1;
+    uint len2;
+    constructor() {
+        uint mem_ptr_before;
+        uint mem_ptr_after;
+
+        assembly {
+            mem_ptr_before := mload(64)
+        }
+
+        len1 = address(0).code.length;
+
+        assembly {
+            mem_ptr_after := mload(64)
+        }
+
+        // To check that no memory was allocated and written.
+        assert(mem_ptr_before == mem_ptr_after);
+
+        len2 = address(this).code.length;
+
+        // To check that no memory was allocated and written.
+        assembly {
+            mem_ptr_after := mload(64)
+        }
+
+        assert(mem_ptr_before == mem_ptr_after);
+
+    }
+
+    function f() public view returns (bool r1, bool r2) {
+        uint mem_ptr_before;
+        uint mem_ptr_after;
+
+        assembly {
+            mem_ptr_before := mload(64)
+        }
+
+        r1 = address(this).code.length > 50;
+
+        assembly {
+            mem_ptr_after := mload(64)
+        }
+
+        // To check that no memory was allocated and written.
+        assert(mem_ptr_before == mem_ptr_after);
+
+        address a = address(0);
+        r2 = a.code.length == 0;
+
+        // To check that no memory was allocated and written.
+        assembly {
+            mem_ptr_after := mload(64)
+        }
+
+    }
+}
+// ----
+// constructor()
+// gas legacy: 124168
+// f(): true, true -> true, true
diff --git a/compiler/test/libsolidity/semanticTests/various/code_length_contract_member.sol b/compiler/test/libsolidity/semanticTests/various/code_length_contract_member.sol
new file mode 100644
index 00000000..ff883139
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/code_length_contract_member.sol
@@ -0,0 +1,15 @@
+// Test to see if type.code.length does extcodesize(type) only when type is an address.
+struct S {
+    bytes32 code;
+    bytes32 another;
+}
+
+contract C {
+    S s;
+
+    function f() public returns (uint, uint, bool) {
+        return (s.code.length, s.another.length, address(this).code.length > 50);
+    }
+}
+// ----
+// f() -> 0x20, 0x20, true
diff --git a/compiler/test/libsolidity/semanticTests/various/codebalance_assembly.sol b/compiler/test/libsolidity/semanticTests/various/codebalance_assembly.sol
new file mode 100644
index 00000000..fad0d3e5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/codebalance_assembly.sol
@@ -0,0 +1,27 @@
+contract C {
+    constructor() payable {}
+
+    function f() public returns (uint256 ret) {
+        assembly {
+            ret := balance(0)
+        }
+    }
+    function g() public returns (uint256 ret) {
+        assembly {
+            ret := balance(1)
+        }
+    }
+    function h() public returns (uint256 ret) {
+        assembly {
+            ret := balance(address())
+        }
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// constructor(), 23 wei ->
+// gas legacy: 100517
+// f() -> 0
+// g() -> 1
+// h() -> 23
diff --git a/compiler/test/libsolidity/semanticTests/various/codehash.sol b/compiler/test/libsolidity/semanticTests/various/codehash.sol
new file mode 100644
index 00000000..fa7dab9d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/codehash.sol
@@ -0,0 +1,19 @@
+contract C {
+    function f() public returns (bytes32) {
+        // non-existent in tests
+        return address(0).codehash;
+    }
+    function g() public returns (bytes32) {
+        // precompile
+        return address(0x1).codehash;
+    }
+    function h() public returns (bool) {
+        return address(this).codehash != 0;
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// f() -> 0x0
+// g() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+// h() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/codehash_assembly.sol b/compiler/test/libsolidity/semanticTests/various/codehash_assembly.sol
new file mode 100644
index 00000000..fe2210fa
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/codehash_assembly.sol
@@ -0,0 +1,23 @@
+contract C {
+    function f() public returns (bytes32 ret) {
+        assembly {
+            ret := extcodehash(0)
+        }
+    }
+    function g() public returns (bytes32 ret) {
+        assembly {
+            ret := extcodehash(1)
+        }
+    }
+    function h() public returns (bool ret) {
+        assembly {
+            ret := iszero(iszero(extcodehash(address())))
+        }
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// f() -> 0
+// g() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+// h() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/contract_binary_dependencies.sol b/compiler/test/libsolidity/semanticTests/various/contract_binary_dependencies.sol
new file mode 100644
index 00000000..0ebf772f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/contract_binary_dependencies.sol
@@ -0,0 +1,20 @@
+contract A {
+    function f() public {
+        new B();
+    }
+}
+
+
+contract B {
+    function f() public {}
+}
+
+
+contract C {
+    function f() public {
+        new B();
+    }
+}
+// ----
+// constructor() ->
+// gas irOptimized: 100415
diff --git a/compiler/test/libsolidity/semanticTests/various/crazy_elementary_typenames_on_stack.sol b/compiler/test/libsolidity/semanticTests/various/crazy_elementary_typenames_on_stack.sol
new file mode 100644
index 00000000..bc16bacb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/crazy_elementary_typenames_on_stack.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public returns (uint256 r) {
+        uint256;
+        uint256;
+        uint256;
+        uint256;
+        int256 x = -7;
+        return uint256(x);
+    }
+}
+// ----
+// f() -> -7
diff --git a/compiler/test/libsolidity/semanticTests/various/create_calldata.sol b/compiler/test/libsolidity/semanticTests/various/create_calldata.sol
new file mode 100644
index 00000000..c3d03813
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/create_calldata.sol
@@ -0,0 +1,14 @@
+contract C {
+	bytes public s;
+	constructor(uint256 x) {
+		// Due to a bug in EVMHost, msg.data used to contain initcode and constructor arguments.
+		s = msg.data;
+		assert(msg.data.length == 0);
+	}
+}
+// ----
+// constructor(): 42 ->
+// gas irOptimized: 145578
+// gas legacy: 173845
+// gas legacyOptimized: 137877
+// s() -> 0x20, 0
diff --git a/compiler/test/libsolidity/semanticTests/various/create_random.sol b/compiler/test/libsolidity/semanticTests/various/create_random.sol
new file mode 100644
index 00000000..676ec32a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/create_random.sol
@@ -0,0 +1,39 @@
+contract C {
+    function addr() external returns (address) {
+        return address(this);
+    }
+
+    function testRunner() external returns (address a1, address a2) {
+        assembly {
+            // This is `return(0, 1)`. We are using a simplified/fixed initcode to avoid
+            // instability due to metadata changes.
+            let initcode := hex"60016000f3"
+            mstore(0, initcode)
+
+            a1 := create(0, 0, 5)
+            a2 := create2(0, 0, 5, address())
+        }
+    }
+
+    function testCalc() external returns (address a1, address a2) {
+        a1 = calculateCreate(address(this), 1);
+        a2 = calculateCreate2(address(this), keccak256(hex"60016000f3"), bytes32(uint256(uint160(address(this)))));
+    }
+
+    function calculateCreate(address from, uint256 nonce) private pure returns (address) {
+        assert(nonce <= 127);
+        bytes memory data =
+            bytes.concat(hex"d694", bytes20(uint160(from)), nonce == 0 ? bytes1(hex"80") : bytes1(uint8(nonce)));
+        return address(uint160(uint256(keccak256(data)))); // Take the lower 160-bits
+    }
+
+    function calculateCreate2(address creator, bytes32 codehash, bytes32 salt) private pure returns (address) {
+        return address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), creator, salt, codehash)))));
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// addr() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
+// testRunner() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a, 0x2c1c30623ddd93e0b765a6caaca0c859eeb0644d
+// testCalc() -> 0x137aa4dfc0911524504fcd4d98501f179bc13b4a, 0x2c1c30623ddd93e0b765a6caaca0c859eeb0644d
diff --git a/compiler/test/libsolidity/semanticTests/various/cross_contract_types.sol b/compiler/test/libsolidity/semanticTests/various/cross_contract_types.sol
new file mode 100644
index 00000000..9c7728a0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/cross_contract_types.sol
@@ -0,0 +1,16 @@
+contract Lib {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+}
+
+
+contract Test {
+    function f() public returns (uint256 r) {
+        Lib.S memory x = Lib.S({a: 2, b: 3});
+        r = x.b;
+    }
+}
+// ----
+// f() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/various/decayed_tuple.sol b/compiler/test/libsolidity/semanticTests/various/decayed_tuple.sol
new file mode 100644
index 00000000..799da348
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/decayed_tuple.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (uint256) {
+        uint256 x = 1;
+        (x) = 2;
+        return x;
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/various/destructuring_assignment.sol b/compiler/test/libsolidity/semanticTests/various/destructuring_assignment.sol
new file mode 100644
index 00000000..b8236e2c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/destructuring_assignment.sol
@@ -0,0 +1,38 @@
+contract C {
+    uint256 x = 7;
+    bytes data;
+    uint256[] y;
+    uint256[] arrayData;
+
+    function returnsArray() public returns (uint256[] memory) {
+        arrayData = new uint256[](9);
+        arrayData[2] = 5;
+        arrayData[7] = 4;
+        return arrayData;
+    }
+
+    function f(bytes memory s) public returns (uint256) {
+        uint256 loc;
+        uint256[] memory memArray;
+        (loc, x, y, data, arrayData[3]) = (8, 4, returnsArray(), s, 2);
+        if (loc != 8) return 1;
+        if (x != 4) return 2;
+        if (y.length != 9) return 3;
+        if (y[2] != 5) return 4;
+        if (y[7] != 4) return 5;
+        if (data.length != s.length) return 6;
+        if (data[3] != s[3]) return 7;
+        if (arrayData[3] != 2) return 8;
+        (memArray, loc) = (arrayData, 3);
+        if (loc != 3) return 9;
+        if (memArray.length != arrayData.length) return 10;
+        bytes memory memBytes;
+        (x, memBytes, y[2], , ) = (456, s, 789, 101112, 131415);
+        if (x != 456 || memBytes.length != s.length || y[2] != 789) return 11;
+    }
+}
+// ----
+// f(bytes): 0x20, 0x5, "abcde" -> 0
+// gas irOptimized: 241837
+// gas legacy: 243284
+// gas legacyOptimized: 242420
diff --git a/compiler/test/libsolidity/semanticTests/various/empty_name_return_parameter.sol b/compiler/test/libsolidity/semanticTests/various/empty_name_return_parameter.sol
new file mode 100644
index 00000000..71eb0077
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/empty_name_return_parameter.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f(uint256 k) public returns (uint256) {
+        return k;
+    }
+}
+// ----
+// f(uint256): 9 -> 9
diff --git a/compiler/test/libsolidity/semanticTests/various/erc20.sol b/compiler/test/libsolidity/semanticTests/various/erc20.sol
new file mode 100644
index 00000000..b752a521
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/erc20.sol
@@ -0,0 +1,128 @@
+pragma solidity >=0.4.0 <0.9.0;
+
+contract ERC20 {
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    mapping (address => uint256) private _balances;
+    mapping (address => mapping (address => uint256)) private _allowances;
+    uint256 private _totalSupply;
+
+    constructor() {
+        _mint(msg.sender, 20);
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address owner) public view returns (uint256) {
+        return _balances[owner];
+    }
+
+    function allowance(address owner, address spender) public view returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function transfer(address to, uint256 value) public returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function approve(address spender, uint256 value) public returns (bool) {
+        _approve(msg.sender, spender, value);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 value) public returns (bool) {
+        _transfer(from, to, value);
+        // The subtraction here will revert on overflow.
+        _approve(from, msg.sender, _allowances[from][msg.sender] - value);
+        return true;
+    }
+
+    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
+        // The addition here will revert on overflow.
+        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
+        // The subtraction here will revert on overflow.
+        _approve(msg.sender, spender, _allowances[msg.sender][spender] - subtractedValue);
+        return true;
+    }
+
+    function _transfer(address from, address to, uint256 value) internal {
+        require(to != address(0), "ERC20: transfer to the zero address");
+
+        // The subtraction and addition here will revert on overflow.
+        _balances[from] = _balances[from] - value;
+        _balances[to] = _balances[to] + value;
+        emit Transfer(from, to, value);
+    }
+
+    function _mint(address account, uint256 value) internal {
+        require(account != address(0), "ERC20: mint to the zero address");
+
+        // The additions here will revert on overflow.
+        _totalSupply = _totalSupply + value;
+        _balances[account] = _balances[account] + value;
+        emit Transfer(address(0), account, value);
+    }
+
+    function _burn(address account, uint256 value) internal {
+        require(account != address(0), "ERC20: burn from the zero address");
+
+        // The subtractions here will revert on overflow.
+        _totalSupply = _totalSupply - value;
+        _balances[account] = _balances[account] - value;
+        emit Transfer(account, address(0), value);
+    }
+
+    function _approve(address owner, address spender, uint256 value) internal {
+        require(owner != address(0), "ERC20: approve from the zero address");
+        require(spender != address(0), "ERC20: approve to the zero address");
+
+        _allowances[owner][spender] = value;
+        emit Approval(owner, spender, value);
+    }
+
+    function _burnFrom(address account, uint256 value) internal {
+        _burn(account, value);
+        _approve(account, msg.sender, _allowances[account][msg.sender] - value);
+    }
+}
+// ----
+// constructor()
+// ~ emit Transfer(address,address,uint256): #0x00, #0x1212121212121212121212121212120000000012, 0x14
+// gas irOptimized: 353276
+// gas legacy: 807683
+// gas legacyOptimized: 408718
+// totalSupply() -> 20
+// gas irOptimized: 23415
+// gas legacy: 23524
+// gas legacyOptimized: 23368
+// transfer(address,uint256): 2, 5 -> true
+// ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x05
+// gas irOptimized: 48471
+// gas legacy: 49317
+// gas legacyOptimized: 48491
+// decreaseAllowance(address,uint256): 2, 0 -> true
+// ~ emit Approval(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x00
+// gas irOptimized: 26275
+// gas legacy: 27012
+// gas legacyOptimized: 26275
+// decreaseAllowance(address,uint256): 2, 1 -> FAILURE, hex"4e487b71", 0x11
+// gas irOptimized: 24042
+// gas legacy: 24467
+// gas legacyOptimized: 24056
+// transfer(address,uint256): 2, 14 -> true
+// ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x0e
+// gas irOptimized: 28571
+// gas legacy: 29417
+// gas legacyOptimized: 28591
+// transfer(address,uint256): 2, 2 -> FAILURE, hex"4e487b71", 0x11
+// gas irOptimized: 24071
+// gas legacy: 24453
+// gas legacyOptimized: 24053
diff --git a/compiler/test/libsolidity/semanticTests/various/external_types_in_calls.sol b/compiler/test/libsolidity/semanticTests/various/external_types_in_calls.sol
new file mode 100644
index 00000000..e8742c23
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/external_types_in_calls.sol
@@ -0,0 +1,28 @@
+contract C1 {
+    C1 public bla;
+
+    constructor(C1 x) {
+        bla = x;
+    }
+}
+
+
+contract C {
+    function test() public returns (C1 x, C1 y) {
+        C1 c = new C1(C1(address(9)));
+        x = c.bla();
+        y = this.t1(C1(address(7)));
+    }
+
+    function t1(C1 a) public returns (C1) {
+        return a;
+    }
+
+    function t2() public returns (C1) {
+        return C1(address(9));
+    }
+}
+// ----
+// test() -> 9, 7
+// gas legacy: 127514
+// t2() -> 9
diff --git a/compiler/test/libsolidity/semanticTests/various/flipping_sign_tests.sol b/compiler/test/libsolidity/semanticTests/various/flipping_sign_tests.sol
new file mode 100644
index 00000000..174fb993
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/flipping_sign_tests.sol
@@ -0,0 +1,9 @@
+contract test {
+    function f() public returns (bool) {
+        int256 x = -2**255;
+        unchecked { assert(-x == x); }
+        return true;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/gasleft_decrease.sol b/compiler/test/libsolidity/semanticTests/various/gasleft_decrease.sol
new file mode 100644
index 00000000..ab730274
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/gasleft_decrease.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint256 v;
+
+    function f() public returns (bool) {
+        uint256 startGas = gasleft();
+        v++;
+        assert(startGas > gasleft());
+        return true;
+    }
+
+    function g() public returns (bool) {
+        uint256 startGas = gasleft();
+        assert(startGas > gasleft());
+        return true;
+    }
+}
+// ----
+// f() -> true
+// g() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/gasleft_shadow_resolution.sol b/compiler/test/libsolidity/semanticTests/various/gasleft_shadow_resolution.sol
new file mode 100644
index 00000000..280bc496
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/gasleft_shadow_resolution.sol
@@ -0,0 +1,11 @@
+contract C {
+    function gasleft() public returns (uint256) {
+        return 0;
+    }
+
+    function f() public returns (uint256) {
+        return gasleft();
+    }
+}
+// ----
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/various/inline_member_init.sol b/compiler/test/libsolidity/semanticTests/various/inline_member_init.sol
new file mode 100644
index 00000000..5c48b5d7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/inline_member_init.sol
@@ -0,0 +1,18 @@
+contract test {
+    constructor() {
+        m_b = 6;
+        m_c = 8;
+    }
+
+    uint256 m_a = 5;
+    uint256 m_b;
+    uint256 m_c = 7;
+
+    function get() public returns (uint256 a, uint256 b, uint256 c) {
+        a = m_a;
+        b = m_b;
+        c = m_c;
+    }
+}
+// ----
+// get() -> 5, 6, 8
diff --git a/compiler/test/libsolidity/semanticTests/various/inline_member_init_inheritence.sol b/compiler/test/libsolidity/semanticTests/various/inline_member_init_inheritence.sol
new file mode 100644
index 00000000..b440b35a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/inline_member_init_inheritence.sol
@@ -0,0 +1,23 @@
+contract Base {
+    constructor() {}
+
+    uint256 m_base = 5;
+
+    function getBMember() public returns (uint256 i) {
+        return m_base;
+    }
+}
+
+
+contract Derived is Base {
+    constructor() {}
+
+    uint256 m_derived = 6;
+
+    function getDMember() public returns (uint256 i) {
+        return m_derived;
+    }
+}
+// ----
+// getBMember() -> 5
+// getDMember() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/various/inline_tuple_with_rational_numbers.sol b/compiler/test/libsolidity/semanticTests/various/inline_tuple_with_rational_numbers.sol
new file mode 100644
index 00000000..e85a38dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/inline_tuple_with_rational_numbers.sol
@@ -0,0 +1,8 @@
+contract c {
+    function f() public returns (int8) {
+        int8[5] memory foo3 = [int8(1), -1, 0, 0, 0];
+        return foo3[0];
+    }
+}
+// ----
+// f() -> 1
diff --git a/compiler/test/libsolidity/semanticTests/various/iszero_bnot_correct.sol b/compiler/test/libsolidity/semanticTests/various/iszero_bnot_correct.sol
new file mode 100644
index 00000000..d797ab9c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/iszero_bnot_correct.sol
@@ -0,0 +1,18 @@
+// A long time ago, some opcodes were renamed, which involved the opcodes
+// "iszero" and "not".
+contract C {
+    function f() public returns (bool) {
+        bytes32 x = bytes32(uint256(1));
+        assembly {
+            x := not(x)
+        }
+        if (x != ~bytes32(uint256(1))) return false;
+        assembly {
+            x := iszero(x)
+        }
+        if (x != bytes32(0)) return false;
+        return true;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/literal_empty_string.sol b/compiler/test/libsolidity/semanticTests/various/literal_empty_string.sol
new file mode 100644
index 00000000..44154fa5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/literal_empty_string.sol
@@ -0,0 +1,19 @@
+contract C {
+    bytes32 public x;
+    uint256 public a;
+
+    function f(bytes32 _x, uint256 _a) public {
+        x = _x;
+        a = _a;
+    }
+
+    function g() public {
+        this.f("", 2);
+    }
+}
+// ----
+// x() -> 0
+// a() -> 0
+// g() ->
+// x() -> 0
+// a() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/various/many_subassemblies.sol b/compiler/test/libsolidity/semanticTests/various/many_subassemblies.sol
new file mode 100644
index 00000000..26c3a1bb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/many_subassemblies.sol
@@ -0,0 +1,35 @@
+contract C0 {}
+contract C1 {}
+contract C2 {}
+contract C3 {}
+contract C4 {}
+contract C5 {}
+contract C6 {}
+contract C7 {}
+contract C8 {}
+contract C9 {}
+contract C10 {}
+
+contract D {
+    function run() public {
+        // This is primarily meant to test assembly import via --import-asm-json.
+        // The exported JSON will fail the reimport unless the subassembly indices are parsed
+        // correctly - as hex numbers.
+        new C0();
+        new C1();
+        new C2();
+        new C3();
+        new C4();
+        new C5();
+        new C6();
+        new C7();
+        new C8();
+        new C9();
+        new C10();
+    }
+}
+// ----
+// run() ->
+// gas irOptimized: 381615
+// gas legacy: 392719
+// gas legacyOptimized: 392719
diff --git a/compiler/test/libsolidity/semanticTests/various/memory_overwrite.sol b/compiler/test/libsolidity/semanticTests/various/memory_overwrite.sol
new file mode 100644
index 00000000..3ab16a3e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/memory_overwrite.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (bytes memory x) {
+        x = "12345";
+        x[3] = 0x61;
+        x[0] = 0x62;
+    }
+}
+// ----
+// f() -> 0x20, 5, "b23a5"
diff --git a/compiler/test/libsolidity/semanticTests/various/multi_modifiers.sol b/compiler/test/libsolidity/semanticTests/various/multi_modifiers.sol
new file mode 100644
index 00000000..07f6c038
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/multi_modifiers.sol
@@ -0,0 +1,23 @@
+// This triggered a bug in some version because the variable in the modifier was not
+// unregistered correctly.
+contract C {
+    uint256 public x;
+    modifier m1 {
+        address a1 = msg.sender;
+        x++;
+        _;
+    }
+
+    function f1() public m1() {
+        x += 7;
+    }
+
+    function f2() public m1() {
+        x += 3;
+    }
+}
+// ----
+// f1() ->
+// x() -> 0x08
+// f2() ->
+// x() -> 0x0c
diff --git a/compiler/test/libsolidity/semanticTests/various/multi_variable_declaration.sol b/compiler/test/libsolidity/semanticTests/various/multi_variable_declaration.sol
new file mode 100644
index 00000000..de4ecdbe
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/multi_variable_declaration.sol
@@ -0,0 +1,46 @@
+contract C {
+    function g() public returns (uint256 a, uint256 b, uint256 c) {
+        a = 1;
+        b = 2;
+        c = 3;
+    }
+
+    function h() public returns (uint256 a, uint256 b, uint256 c, uint256 d) {
+        a = 1;
+        b = 2;
+        c = 3;
+        d = 4;
+    }
+
+    function f1() public returns (bool) {
+        (uint256 x, uint256 y, uint256 z) = g();
+        if (x != 1 || y != 2 || z != 3) return false;
+        (, uint256 a, ) = g();
+        if (a != 2) return false;
+        (uint256 b, , ) = g();
+        if (b != 1) return false;
+        (, , uint256 c) = g();
+        if (c != 3) return false;
+        return true;
+    }
+
+    function f2() public returns (bool) {
+        (uint256 a1, , uint256 a3, ) = h();
+        if (a1 != 1 || a3 != 3) return false;
+        (uint256 b1, uint256 b2, , ) = h();
+        if (b1 != 1 || b2 != 2) return false;
+        (, uint256 c2, uint256 c3, ) = h();
+        if (c2 != 2 || c3 != 3) return false;
+        (, , uint256 d3, uint256 d4) = h();
+        if (d3 != 3 || d4 != 4) return false;
+        (uint256 e1, , uint256 e3, uint256 e4) = h();
+        if (e1 != 1 || e3 != 3 || e4 != 4) return false;
+        return true;
+    }
+
+    function f() public returns (bool) {
+        return f1() && f2();
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/negative_stack_height.sol b/compiler/test/libsolidity/semanticTests/various/negative_stack_height.sol
new file mode 100644
index 00000000..3c9130e9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/negative_stack_height.sol
@@ -0,0 +1,69 @@
+contract C {
+    mapping(uint256 => Invoice) public invoices;
+    struct Invoice {
+        uint256 AID;
+        bool Aboola;
+        bool Aboolc;
+        bool exists;
+    }
+
+    function nredit(uint256 startindex)
+        public
+        pure
+        returns (
+            uint256[500] memory CIDs,
+            uint256[500] memory dates,
+            uint256[500] memory RIDs,
+            bool[500] memory Cboolas,
+            uint256[500] memory amounts
+        )
+    {}
+
+    function return500InvoicesByDates(
+        uint256 begindate,
+        uint256 enddate,
+        uint256 startindex
+    )
+        public
+        view
+        returns (
+            uint256[500] memory AIDs,
+            bool[500] memory Aboolas,
+            uint256[500] memory dates,
+            bytes32[3][500] memory Abytesas,
+            bytes32[3][500] memory bytesbs,
+            bytes32[2][500] memory bytescs,
+            uint256[500] memory amounts,
+            bool[500] memory Aboolbs,
+            bool[500] memory Aboolcs
+        )
+    {}
+
+    function return500PaymentsByDates(
+        uint256 begindate,
+        uint256 enddate,
+        uint256 startindex
+    )
+        public
+        view
+        returns (
+            uint256[500] memory BIDs,
+            uint256[500] memory dates,
+            uint256[500] memory RIDs,
+            bool[500] memory Bboolas,
+            bytes32[3][500] memory bytesbs,
+            bytes32[2][500] memory bytescs,
+            uint256[500] memory amounts,
+            bool[500] memory Bboolbs
+        )
+    {}
+}
+
+// via yul disabled because of stack issues.
+
+// ====
+// compileViaYul: false
+// ----
+// constructor() ->
+// gas legacy: 575272
+// gas legacyOptimized: 345026
diff --git a/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct.sol b/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct.sol
new file mode 100644
index 00000000..b1124132
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct.sol
@@ -0,0 +1,25 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S1 {
+        uint256 a;
+        uint256 b;
+    }
+    struct S2 {
+        uint256 a;
+        uint256 b;
+        S1 s;
+        uint256 c;
+    }
+
+    function f(S2 calldata s)
+        external
+        pure
+        returns (uint256 a, uint256 b, uint256 sa, uint256 sb, uint256 c)
+    {
+        return (s.a, s.b, s.s.a, s.s.b, s.c);
+    }
+}
+// ----
+// f((uint256,uint256,(uint256,uint256),uint256)): 1, 2, 3, 4, 5 -> 1, 2, 3, 4, 5
diff --git a/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol b/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol
new file mode 100644
index 00000000..25cd645e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/nested_calldata_struct_to_memory.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+
+contract C {
+    struct S1 {
+        uint256 a;
+        uint256 b;
+    }
+    struct S2 {
+        uint256 a;
+        uint256 b;
+        S1 s;
+        uint256 c;
+    }
+
+    function f(S2 calldata s)
+        external
+        pure
+        returns (uint256 a, uint256 b, uint256 sa, uint256 sb, uint256 c)
+    {
+        S2 memory m = s;
+        return (m.a, m.b, m.s.a, m.s.b, m.c);
+    }
+}
+// ----
+// f((uint256,uint256,(uint256,uint256),uint256)): 1, 2, 3, 4, 5 -> 1, 2, 3, 4, 5
diff --git a/compiler/test/libsolidity/semanticTests/various/positive_integers_to_signed.sol b/compiler/test/libsolidity/semanticTests/various/positive_integers_to_signed.sol
new file mode 100644
index 00000000..4c0d7114
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/positive_integers_to_signed.sol
@@ -0,0 +1,9 @@
+contract test {
+    int8 public x = 2;
+    int8 public y = 127;
+    int16 public q = 250;
+}
+// ----
+// x() -> 2
+// y() -> 127
+// q() -> 250
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol
new file mode 100644
index 00000000..85c95be4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol
@@ -0,0 +1,88 @@
+contract C {
+    constructor() payable {}
+
+    function terminate() external {
+        // NOTE: The contract `c` should still exist in the test below
+        // when the call to selfdestruct is executed in a transaction
+        // different from the one in which the contract was created.
+        // However, it should still send all Ether in `c` to the beneficiary.
+        selfdestruct(payable(msg.sender));
+        assert(false);
+    }
+}
+
+contract D {
+    C public c;
+
+    constructor() payable {}
+
+    function deploy_create() public payable {
+        c = new C{value: 1 ether}();
+    }
+
+    function deploy_create2() public payable {
+        c = new C{value: 1 ether, salt: hex"1234"}();
+    }
+
+    function terminate() public {
+        // NOTE: A second call to `c.terminate()` or any other function of the contract `c` will succeed if the
+        // previous selfdestruct was performed in a different transaction, since the contract will still exists.
+        c.terminate();
+    }
+
+    function test_create_and_terminate() public {
+        deploy_create();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_create2_and_terminate() public {
+        deploy_create2();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_balance_after_create() public view {
+        assert(address(this).balance == 0);
+        assert(address(c).balance == 1 ether);
+    }
+
+    function test_balance_after_selfdestruct() public view {
+        assert(address(this).balance == 1 ether);
+        assert(address(c).balance == 0);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 455954
+// gas legacy: 375495
+// gas legacyOptimized: 507630
+// exists() -> false
+// test_create_and_terminate() ->
+// exists() -> false
+// terminate() -> FAILURE
+// deploy_create() ->
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> true
+// test_create2_and_terminate() ->
+// exists() -> false
+// deploy_create2() ->
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> true
+// terminate() ->
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol
new file mode 100644
index 00000000..4bc65b76
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol
@@ -0,0 +1,56 @@
+contract C {
+    constructor() payable {}
+    function terminate(address _beneficiary) public {
+        selfdestruct(payable(_beneficiary));
+        assert(false);
+    }
+}
+
+contract D {
+    address account1 = payable(0x1111111111111111111111111111111111111111);
+    address account2 = payable(0x2222222222222222222222222222222222222222);
+    C public c;
+
+    constructor() payable {}
+
+    function deploy() public payable {
+        c = new C{value: 1 ether}();
+    }
+
+    function terminate(address _beneficiary) public {
+        c.terminate(_beneficiary);
+    }
+
+    function test_deploy_and_terminate_twice() public {
+        deploy();
+        terminate(account1);
+        terminate(account2);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor(), 2 ether ->
+// balance: 0x1111111111111111111111111111111111111111 -> 0
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 2000000000000000000
+// exists() -> false
+// test_deploy_and_terminate_twice() ->
+// exists() -> false
+// balance: 0x1111111111111111111111111111111111111111 -> 1000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 1000000000000000000
+// deploy() ->
+// exists() -> true
+// balance: 0x1111111111111111111111111111111111111111 -> 1000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 0
+// terminate(address): 0x1111111111111111111111111111111111111111 ->
+// balance: 0x1111111111111111111111111111111111111111 -> 2000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 0
+// exists() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol
new file mode 100644
index 00000000..473571bf
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol
@@ -0,0 +1,101 @@
+contract Factory {
+    event Deployed(address, bytes32);
+
+    function deploy(bytes32 _salt) external payable returns (address implAddr) {
+        // NOTE: The bytecode of contract C is used here instead of `type(C).creationCode` since the address calculation depends on the precise init code
+        // and that will change in our test framework between legacy and via-IR codegen and via optimized vs non-optimized.
+        //contract C {
+        //    constructor() payable {}
+        //    function terminate() external {
+        //        selfdestruct(payable(msg.sender));
+        //    }
+        //}
+        bytes memory initCode =
+            hex"6080806040526068908160108239f3fe6004361015600b575f80fd5b5f3560e0"
+            hex"1c630c08bf8814601d575f80fd5b34602e575f366003190112602e5733ff5b5f"
+            hex"80fdfea2646970667358221220fe3c4fe66c1838016e2efdc5b65538e5ff3dbf"
+            hex"ced7eff135da3556db4bd841aa64736f6c63430008180033";
+
+        address target = address(uint160(uint256(keccak256(abi.encodePacked(
+            bytes1(0xff),
+            address(this),
+            _salt,
+            keccak256(abi.encodePacked(initCode))
+        )))));
+
+        assembly {
+            implAddr := create2(callvalue(), add(initCode, 0x20), mload(initCode), _salt)
+            if iszero(extcodesize(implAddr)) {
+                revert(0, 0)
+            }
+        }
+        assert(address(implAddr) == target);
+        emit Deployed(implAddr, _salt);
+    }
+}
+
+interface IC {
+    function terminate() external;
+}
+
+contract D {
+    Factory public factory = new Factory();
+    IC public c;
+
+    constructor() payable {}
+
+    function deploy_create2() public payable {
+        // NOTE: `create2` cannot be used anymore to redeploy a contract in the same place to make it upgradable
+        // if not performed in the same transaction.
+        // Therefore, an attempt to redeploy using `create2` in a different transaction must revert for EVM >= Cancun.
+        c = IC(factory.deploy{value: 1 ether}(hex"1234"));
+    }
+
+    function terminate() public {
+        c.terminate();
+    }
+
+    function test_deploy_and_terminate() public {
+        deploy_create2();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_balance_after_create() public view {
+        assert(address(this).balance == 0);
+        assert(address(c).balance == 1 ether);
+    }
+
+    function test_balance_after_selfdestruct() public view {
+        assert(address(this).balance == 1 ether);
+        assert(address(c).balance == 0);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+
+// ====
+// EVMVersion: >=cancun
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 562058
+// gas legacy: 633310
+// gas legacyOptimized: 590051
+// exists() -> false
+// test_deploy_and_terminate() ->
+// ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000
+// gas irOptimized: 118541
+// gas legacyOptimized: 118305
+// exists() -> false
+// deploy_create2() ->
+// ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> true
+// deploy_create2() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun.sol
new file mode 100644
index 00000000..4142eb25
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun.sol
@@ -0,0 +1,86 @@
+contract C {
+    constructor() payable {}
+
+    function terminate() external {
+        // NOTE: The contract `c` should still exists in the test below,
+        // since the call to the selfdestruct method was done in a tx that is
+        // not the same tx that the contract was created.
+        // However, it should send all Ether in `c` to the beneficiary.
+        selfdestruct(payable(msg.sender));
+        assert(false);
+    }
+}
+
+contract D {
+    C public c;
+
+    constructor() payable {}
+
+    function deploy_create() public payable {
+        c = new C{value: 1 ether}();
+    }
+
+    function deploy_create2() public payable {
+        c = new C{value: 1 ether, salt: hex"1234"}();
+    }
+
+    function terminate() public {
+        c.terminate();
+    }
+
+    function test_create_and_terminate() public {
+        deploy_create();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_create2_and_terminate() public {
+        deploy_create2();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_balance_after_create() public view {
+        assert(address(this).balance == 0);
+        assert(address(c).balance == 1 ether);
+    }
+
+    function test_balance_after_selfdestruct() public view {
+        assert(address(this).balance == 1 ether);
+        assert(address(c).balance == 0);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+// ====
+// EVMVersion: =shanghai
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 242428
+// gas legacy: 373563
+// gas legacyOptimized: 234516
+// exists() -> false
+// test_create_and_terminate() ->
+// exists() -> false
+// terminate() -> FAILURE
+// deploy_create() ->
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> false
+// test_create2_and_terminate() ->
+// exists() -> false
+// deploy_create2() ->
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> false
+// terminate() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_multiple_beneficiaries.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_multiple_beneficiaries.sol
new file mode 100644
index 00000000..57b2d5c6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_multiple_beneficiaries.sol
@@ -0,0 +1,67 @@
+contract C {
+    constructor() payable {}
+    function terminate(address _beneficiary) public {
+        selfdestruct(payable(_beneficiary));
+        assert(false);
+    }
+}
+
+contract D {
+    address account1 = payable(0x1111111111111111111111111111111111111111);
+    address account2 = payable(0x2222222222222222222222222222222222222222);
+    C public c;
+
+    constructor() payable {}
+
+    function deploy() public payable {
+        c = new C{value: 1 ether}();
+    }
+
+    function terminate(address _beneficiary) public {
+        c.terminate(_beneficiary);
+    }
+
+    function test_deploy_and_terminate_twice() public {
+        deploy();
+        terminate(account1);
+        terminate(account2);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
+// constructor(), 2 ether ->
+// gas irOptimized: 223918
+// gas legacy: 374228
+// gas legacyOptimized: 239815
+// balance: 0x1111111111111111111111111111111111111111 -> 0
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 2000000000000000000
+// exists() -> false
+// test_deploy_and_terminate_twice() ->
+// gas irOptimized: 135350
+// gas legacy: 165584
+// gas legacyOptimized: 144396
+// exists() -> false
+// balance: 0x1111111111111111111111111111111111111111 -> 1000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 1000000000000000000
+// deploy() ->
+// gas legacy: 101691
+// exists() -> true
+// balance: 0x1111111111111111111111111111111111111111 -> 1000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 0
+// terminate(address): 0x1111111111111111111111111111111111111111 ->
+// balance: 0x1111111111111111111111111111111111111111 -> 2000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 0
+// terminate(address): 0x2222222222222222222222222222222222222222 -> FAILURE
+// balance: 0x1111111111111111111111111111111111111111 -> 2000000000000000000
+// balance: 0x2222222222222222222222222222222222222222 -> 0
+// balance -> 0
+// exists() -> false
diff --git a/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_redeploy.sol b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_redeploy.sol
new file mode 100644
index 00000000..9c994985
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/selfdestruct_pre_cancun_redeploy.sol
@@ -0,0 +1,100 @@
+contract Factory {
+    event Deployed(address, bytes32);
+
+    function deploy(bytes32 _salt) external payable returns (address implAddr) {
+        // NOTE: The bytecode of contract C is used here instead of `type(C).creationCode` since the address calculation depends on the precise init code
+        // and that will change in our test framework between legacy and via-IR codegen and via optimized vs non-optimized.
+        //contract C {
+        //    constructor() payable {}
+        //    function terminate() external {
+        //        selfdestruct(payable(msg.sender));
+        //    }
+        //}
+        bytes memory initCode =
+            hex"6080806040526068908160108239f3fe6004361015600b575f80fd5b5f3560e0"
+            hex"1c630c08bf8814601d575f80fd5b34602e575f366003190112602e5733ff5b5f"
+            hex"80fdfea2646970667358221220fe3c4fe66c1838016e2efdc5b65538e5ff3dbf"
+            hex"ced7eff135da3556db4bd841aa64736f6c63430008180033";
+
+        address target = address(uint160(uint256(keccak256(abi.encodePacked(
+            bytes1(0xff),
+            address(this),
+            _salt,
+            keccak256(abi.encodePacked(initCode))
+        )))));
+
+        assembly {
+            implAddr := create2(callvalue(), add(initCode, 0x20), mload(initCode), _salt)
+            if iszero(extcodesize(implAddr)) {
+                revert(0, 0)
+            }
+        }
+        assert(address(implAddr) == target);
+        emit Deployed(implAddr, _salt);
+    }
+}
+
+interface IC {
+    function terminate() external;
+}
+
+contract D {
+    Factory public factory = new Factory();
+    IC public c;
+
+    constructor() payable {}
+
+    function deploy_create2() public payable {
+        c = IC(factory.deploy{value: 1 ether}(hex"1234"));
+    }
+
+    function terminate() public {
+        c.terminate();
+    }
+
+    function test_deploy_and_terminate() public {
+        deploy_create2();
+        assert(exists());
+        test_balance_after_create();
+        terminate();
+        test_balance_after_selfdestruct();
+    }
+
+    function test_balance_after_create() public view {
+        assert(address(this).balance == 0);
+        assert(address(c).balance == 1 ether);
+    }
+
+    function test_balance_after_selfdestruct() public view {
+        assert(address(this).balance == 1 ether);
+        assert(address(c).balance == 0);
+    }
+
+    function exists() public view returns (bool) {
+        return address(c).code.length != 0;
+    }
+}
+
+// ====
+// EVMVersion: =shanghai
+// ----
+// constructor(), 1 ether ->
+// gas irOptimized: 430265
+// gas legacy: 690264
+// gas legacyOptimized: 412819
+// exists() -> false
+// test_deploy_and_terminate() ->
+// ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000
+// gas irOptimized: 117489
+// gas legacy: 118895
+// gas legacyOptimized: 117137
+// exists() -> false
+// deploy_create2() ->
+// ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000
+// test_balance_after_create() ->
+// exists() -> true
+// terminate() ->
+// test_balance_after_selfdestruct() ->
+// exists() -> false
+// deploy_create2() ->
+// ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/various/senders_balance.sol b/compiler/test/libsolidity/semanticTests/various/senders_balance.sol
new file mode 100644
index 00000000..6628454d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/senders_balance.sol
@@ -0,0 +1,22 @@
+contract C {
+    function f() public view returns (uint256) {
+        return msg.sender.balance;
+    }
+}
+
+
+contract D {
+    C c = new C();
+
+    constructor() payable {}
+
+    function f() public view returns (uint256) {
+        return c.f();
+    }
+}
+// ----
+// constructor(), 27 wei ->
+// gas irOptimized: 167865
+// gas legacy: 218459
+// gas legacyOptimized: 167292
+// f() -> 27
diff --git a/compiler/test/libsolidity/semanticTests/various/single_copy_with_multiple_inheritance.sol b/compiler/test/libsolidity/semanticTests/various/single_copy_with_multiple_inheritance.sol
new file mode 100644
index 00000000..69c4c412
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/single_copy_with_multiple_inheritance.sol
@@ -0,0 +1,32 @@
+contract Base {
+    uint256 data;
+
+    function setData(uint256 i) public {
+        data = i;
+    }
+
+    function getViaBase() public returns (uint256 i) {
+        return data;
+    }
+}
+
+
+contract A is Base {
+    function setViaA(uint256 i) public {
+        setData(i);
+    }
+}
+
+
+contract B is Base {
+    function getViaB() public returns (uint256 i) {
+        return getViaBase();
+    }
+}
+
+
+contract Derived is Base, B, A {}
+// ----
+// getViaB() -> 0
+// setViaA(uint256): 23 ->
+// getViaB() -> 23
diff --git a/compiler/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol b/compiler/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol
new file mode 100644
index 00000000..ce8946c5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol
@@ -0,0 +1,24 @@
+// For accessors, the dynamic types are already removed in the external signature itself.
+contract C {
+    struct S {
+        uint256 x;
+        string a; // this is present in the accessor
+        uint256[] b; // this is not present
+        uint256 y;
+    }
+    S public s;
+
+    function g() public returns (uint256, uint256) {
+        s.x = 2;
+        s.a = "abc";
+        s.b = [7, 8, 9];
+        s.y = 6;
+        (uint256 x, , uint256 y) = this.s();
+        return (x, y);
+    }
+}
+// ----
+// g() -> 2, 6
+// gas irOptimized: 178475
+// gas legacy: 180839
+// gas legacyOptimized: 179374
diff --git a/compiler/test/libsolidity/semanticTests/various/state_variable_local_variable_mixture.sol b/compiler/test/libsolidity/semanticTests/various/state_variable_local_variable_mixture.sol
new file mode 100644
index 00000000..f7add5fb
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/state_variable_local_variable_mixture.sol
@@ -0,0 +1,10 @@
+contract A {
+    uint256 x = 1;
+    uint256 y = 2;
+
+    function a() public returns (uint256 x) {
+        x = A.y;
+    }
+}
+// ----
+// a() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/various/state_variable_under_contract_name.sol b/compiler/test/libsolidity/semanticTests/various/state_variable_under_contract_name.sol
new file mode 100644
index 00000000..1167da57
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/state_variable_under_contract_name.sol
@@ -0,0 +1,9 @@
+contract Scope {
+    uint256 stateVar = 42;
+
+    function getStateVar() public view returns (uint256 stateVar) {
+        stateVar = Scope.stateVar;
+    }
+}
+// ----
+// getStateVar() -> 42
diff --git a/compiler/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol b/compiler/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol
new file mode 100644
index 00000000..1306529d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol
@@ -0,0 +1,46 @@
+contract C {
+    uint256 x;
+
+    function f() public returns (uint256) {
+        x = 3;
+        return 1;
+    }
+}
+
+
+interface CView {
+    function f() external view returns (uint256);
+}
+
+
+interface CPure {
+    function f() external pure returns (uint256);
+}
+
+
+contract D {
+    function f() public returns (uint256) {
+        return (new C()).f();
+    }
+
+    function fview() public returns (uint256) {
+        return (CView(address(new C()))).f();
+    }
+
+    function fpure() public returns (uint256) {
+        return (CPure(address(new C()))).f();
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// f() -> 0x1 # This should work, next should throw #
+// gas legacy: 102095
+// fview() -> FAILURE
+// gas irOptimized: 98438588
+// gas legacy: 98438774
+// gas legacyOptimized: 98438580
+// fpure() -> FAILURE
+// gas irOptimized: 98438589
+// gas legacy: 98438774
+// gas legacyOptimized: 98438580
diff --git a/compiler/test/libsolidity/semanticTests/various/string_tuples.sol b/compiler/test/libsolidity/semanticTests/various/string_tuples.sol
new file mode 100644
index 00000000..57028ae3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/string_tuples.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public returns (string memory, uint256) {
+        return ("abc", 8);
+    }
+
+    function g() public returns (string memory, string memory) {
+        return (h(), "def");
+    }
+
+    function h() public returns (string memory) {
+        return ("abc");
+    }
+}
+// ----
+// f() -> 0x40, 0x8, 0x3, "abc"
+// g() -> 0x40, 0x80, 0x3, "abc", 0x3, "def"
diff --git a/compiler/test/libsolidity/semanticTests/various/super.sol b/compiler/test/libsolidity/semanticTests/various/super.sol
new file mode 100644
index 00000000..cd1b4a71
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/super.sol
@@ -0,0 +1,28 @@
+contract A {
+    function f() public virtual returns (uint256 r) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() public virtual override returns (uint256 r) {
+        return super.f() | 2;
+    }
+}
+
+
+contract C is A {
+    function f() public virtual override returns (uint256 r) {
+        return super.f() | 4;
+    }
+}
+
+
+contract D is B, C {
+    function f() public override(B, C) returns (uint256 r) {
+        return super.f() | 8;
+    }
+}
+// ----
+// f() -> 15
diff --git a/compiler/test/libsolidity/semanticTests/various/super_alone.sol b/compiler/test/libsolidity/semanticTests/various/super_alone.sol
new file mode 100644
index 00000000..223e3176
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/super_alone.sol
@@ -0,0 +1,7 @@
+contract A {
+    function f() public {
+        super;
+    }
+}
+// ----
+// f() ->
diff --git a/compiler/test/libsolidity/semanticTests/various/super_parentheses.sol b/compiler/test/libsolidity/semanticTests/various/super_parentheses.sol
new file mode 100644
index 00000000..fd794476
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/super_parentheses.sol
@@ -0,0 +1,28 @@
+contract A {
+    function f() public virtual returns (uint256 r) {
+        return 1;
+    }
+}
+
+
+contract B is A {
+    function f() public virtual override returns (uint256 r) {
+        return ((super).f)() | 2;
+    }
+}
+
+
+contract C is A {
+    function f() public virtual override returns (uint256 r) {
+        return ((super).f)() | 4;
+    }
+}
+
+
+contract D is B, C {
+    function f() public override(B, C) returns (uint256 r) {
+        return ((super).f)() | 8;
+    }
+}
+// ----
+// f() -> 15
diff --git a/compiler/test/libsolidity/semanticTests/various/swap_in_storage_overwrite.sol b/compiler/test/libsolidity/semanticTests/various/swap_in_storage_overwrite.sol
new file mode 100644
index 00000000..bd5a5951
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/swap_in_storage_overwrite.sol
@@ -0,0 +1,36 @@
+// This tests a swap in storage which does not work as one
+// might expect because we do not have temporary storage.
+// (x, y) = (y, x) is the same as
+// y = x;
+// x = y;
+contract c {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+    S public x;
+    S public y;
+
+    function set() public {
+        x.a = 1;
+        x.b = 2;
+        y.a = 3;
+        y.b = 4;
+    }
+
+    function swap() public {
+        (x, y) = (y, x);
+    }
+}
+// ----
+// x() -> 0, 0
+// y() -> 0, 0
+// set() ->
+// gas irOptimized: 109684
+// gas legacy: 109728
+// gas legacyOptimized: 109680
+// x() -> 1, 2
+// y() -> 3, 4
+// swap() ->
+// x() -> 1, 2
+// y() -> 1, 2
diff --git a/compiler/test/libsolidity/semanticTests/various/test_underscore_in_hex.sol b/compiler/test/libsolidity/semanticTests/various/test_underscore_in_hex.sol
new file mode 100644
index 00000000..b9503e44
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/test_underscore_in_hex.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f(bool cond) public pure returns (uint256) {
+        uint32 x = 0x1234_ab;
+        uint256 y = 0x1234_abcd_1234;
+        return cond ? x : y;
+    }
+}
+// ----
+// f(bool): true -> 0x1234ab
+// f(bool): false -> 0x1234abcd1234
diff --git a/compiler/test/libsolidity/semanticTests/various/typed_multi_variable_declaration.sol b/compiler/test/libsolidity/semanticTests/various/typed_multi_variable_declaration.sol
new file mode 100644
index 00000000..c9f12fda
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/typed_multi_variable_declaration.sol
@@ -0,0 +1,25 @@
+contract C {
+    struct S {
+        uint256 x;
+    }
+    S s;
+
+    function g() internal returns (uint256, S storage, uint256) {
+        s.x = 7;
+        return (1, s, 2);
+    }
+
+    function f() public returns (bool) {
+        (uint256 x1, S storage y1, uint256 z1) = g();
+        if (x1 != 1 || y1.x != 7 || z1 != 2) return false;
+        (, S storage y2, ) = g();
+        if (y2.x != 7) return false;
+        (uint256 x2, , ) = g();
+        if (x2 != 1) return false;
+        (, , uint256 z2) = g();
+        if (z2 != 2) return false;
+        return true;
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/various/value_complex.sol b/compiler/test/libsolidity/semanticTests/various/value_complex.sol
new file mode 100644
index 00000000..9f262fbd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/value_complex.sol
@@ -0,0 +1,25 @@
+contract helper {
+    function getBalance() public payable returns (uint256 myBalance) {
+        return address(this).balance;
+    }
+}
+
+
+contract test {
+    helper h;
+
+    constructor() payable {
+        h = new helper();
+    }
+
+    function sendAmount(uint256 amount) public payable returns (uint256 bal) {
+        uint256 someStackElement = 20;
+        return h.getBalance{value: amount + 3, gas: 1000}();
+    }
+}
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 172407
+// gas legacy: 252296
+// gas legacyOptimized: 180352
+// sendAmount(uint256): 5 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/various/value_insane.sol b/compiler/test/libsolidity/semanticTests/various/value_insane.sol
new file mode 100644
index 00000000..1e591050
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/value_insane.sol
@@ -0,0 +1,24 @@
+contract helper {
+    function getBalance() public payable returns (uint256 myBalance) {
+        return address(this).balance;
+    }
+}
+
+
+contract test {
+    helper h;
+
+    constructor() payable {
+        h = new helper();
+    }
+
+    function sendAmount(uint256 amount) public returns (uint256 bal) {
+        return h.getBalance{value: amount + 3, gas: 1000}();
+    }
+}
+// ----
+// constructor(), 20 wei ->
+// gas irOptimized: 173271
+// gas legacy: 253820
+// gas legacyOptimized: 180784
+// sendAmount(uint256): 5 -> 8
diff --git a/compiler/test/libsolidity/semanticTests/various/write_storage_external.sol b/compiler/test/libsolidity/semanticTests/various/write_storage_external.sol
new file mode 100644
index 00000000..a8959b24
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/various/write_storage_external.sol
@@ -0,0 +1,39 @@
+contract C {
+    uint256 public x;
+
+    function f(uint256 y) public payable {
+        x = y;
+    }
+
+    function g(uint256 y) external {
+        x = y;
+    }
+
+    function h() public {
+        this.g(12);
+    }
+}
+
+
+contract D {
+    C c = new C();
+
+    function f() public payable returns (uint256) {
+        c.g(3);
+        return c.x();
+    }
+
+    function g() public returns (uint256) {
+        c.g(8);
+        return c.x();
+    }
+
+    function h() public returns (uint256) {
+        c.h();
+        return c.x();
+    }
+}
+// ----
+// f() -> 3
+// g() -> 8
+// h() -> 12
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/assert.sol b/compiler/test/libsolidity/semanticTests/viaYul/assert.sol
new file mode 100644
index 00000000..bd1cabc4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/assert.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(bool a) public pure returns (bool x) {
+        bool b = a;
+        x = b;
+        assert(b);
+    }
+    function fail() public pure returns (bool x) {
+        x = true;
+        assert(false);
+    }
+    function succeed() public pure returns (bool x) {
+        x = true;
+        assert(true);
+    }
+}
+// ----
+// f(bool): true -> true
+// f(bool): false -> FAILURE, hex"4e487b71", 0x01
+// fail() -> FAILURE, hex"4e487b71", 0x01
+// succeed() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/assert_and_require.sol b/compiler/test/libsolidity/semanticTests/viaYul/assert_and_require.sol
new file mode 100644
index 00000000..a403b5d6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/assert_and_require.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f(bool a) public pure returns (bool x) {
+        bool b = a;
+        x = b;
+        assert(b);
+    }
+    function f2(bool a) public pure returns (bool x) {
+        bool b = a;
+        x = b;
+        require(b);
+    }
+}
+// ----
+// f(bool): true -> true
+// f(bool): false -> FAILURE, hex"4e487b71", 0x01
+// f2(bool): true -> true
+// f2(bool): false -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/assign_tuple_from_function_call.sol b/compiler/test/libsolidity/semanticTests/viaYul/assign_tuple_from_function_call.sol
new file mode 100644
index 00000000..5da58b31
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/assign_tuple_from_function_call.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public pure returns (uint, uint, uint) {
+        return (1, 2, 3);
+    }
+    function g() public pure returns (uint a, uint b, uint c) {
+        (c, b, a) = f();
+    }
+    function h() public pure returns (uint a) {
+        (,,a) = f();
+    }
+}
+// ----
+// g() -> 3, 2, 1
+// h() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/cleanup/checked_arithmetic.sol b/compiler/test/libsolidity/semanticTests/viaYul/cleanup/checked_arithmetic.sol
new file mode 100644
index 00000000..19b7cb84
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/cleanup/checked_arithmetic.sol
@@ -0,0 +1,65 @@
+contract C {
+	function add() public pure returns (uint8, uint8) {
+		uint8 x; uint8 y = 0;
+		assembly { x := 0x0101 }
+		return (x + y, y + x);
+	}
+	function sub() public pure returns (uint8, uint8) {
+		uint8 x; uint8 y = 1;
+		assembly { x := 0x0101 }
+		return (x - y, y - x);
+	}
+	function mul() public pure returns (uint8, uint8) {
+		uint8 x; uint8 y = 1;
+		assembly { x := 0x0101 }
+		return (x * y, y * x);
+	}
+	function div() public pure returns (uint8, uint8) {
+		uint8 x; uint8 y = 1;
+		assembly { x := 0x0101 }
+		return (x / y, y / x);
+	}
+	function mod() public pure returns (uint8, uint8) {
+		uint8 x; uint8 y = 2;
+		assembly { x := 0x0101 }
+		return (x % y, y % x);
+	}
+	function inc_pre() public pure returns (uint8) {
+		uint8 x;
+		assembly { x := 0x0100 }
+		return ++x;
+	}
+	function inc_post() public pure returns (uint8) {
+		uint8 x;
+		assembly { x := 0x0100 }
+		return x++;
+	}
+	function dec_pre() public pure returns (uint8) {
+		uint8 x;
+		assembly { x := not(0xFF) }
+		return --x;
+	}
+	function dec_post() public pure returns (uint8) {
+		uint8 x;
+		assembly { x := not(0xFF) }
+		return x--;
+	}
+	function neg() public pure returns (int8) {
+		int8 x;
+		assembly { x := 0x80 }
+		return -x;
+	}
+}
+// ====
+// compileViaYul: true
+// ----
+// add() -> 1, 1
+// sub() -> 0, 0
+// mul() -> 1, 1
+// div() -> 1, 1
+// mod() -> 1, 0
+// inc_pre() -> 1
+// inc_post() -> 0
+// dec_pre() -> FAILURE, hex"4e487b71", 0x11
+// dec_post() -> FAILURE, hex"4e487b71", 0x11
+// neg() -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/cleanup/comparison.sol b/compiler/test/libsolidity/semanticTests/viaYul/cleanup/comparison.sol
new file mode 100644
index 00000000..035c2690
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/cleanup/comparison.sol
@@ -0,0 +1,39 @@
+contract C {
+	function eq() public pure returns (bool) {
+		uint8 x = 1; uint8 y;
+		assembly { y := 0x0101 }
+		return (x == y);
+	}
+	function neq() public pure returns (bool) {
+		uint8 x = 1; uint8 y;
+		assembly { y := 0x0101 }
+		return (x != y);
+	}
+	function geq() public pure returns (bool) {
+		uint8 x = 1; uint8 y;
+		assembly { y := 0x0101 }
+		return (x >= y);
+	}
+	function leq() public pure returns (bool) {
+		uint8 x = 2; uint8 y;
+		assembly { y := 0x0101 }
+		return (x <= y);
+	}
+	function gt() public pure returns (bool) {
+		uint8 x = 2; uint8 y;
+		assembly { y := 0x0101 }
+		return (x > y);
+	}
+	function lt() public pure returns (bool) {
+		uint8 x = 1; uint8 y;
+		assembly { y := 0x0101 }
+		return (x < y);
+	}
+}
+// ----
+// eq() -> true
+// neq() -> false
+// geq() -> true
+// leq() -> false
+// gt() -> true
+// lt() -> false
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/comparison.sol b/compiler/test/libsolidity/semanticTests/viaYul/comparison.sol
new file mode 100644
index 00000000..1ac2aec1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/comparison.sol
@@ -0,0 +1,72 @@
+contract C {
+    function f(address a) public pure returns (bool) {
+        return a == address(0);
+    }
+    function g() public pure returns (bool) {
+        return bytes3("abc") == bytes4("abc");
+    }
+    function lt(uint a, uint b) public pure returns (bool) {
+        return a < b;
+    }
+    function slt(int a, int b) public pure returns (bool) {
+        return a < b;
+    }
+    function lte(uint a, uint b) public pure returns (bool) {
+        return a <= b;
+    }
+    function slte(int a, int b) public pure returns (bool) {
+        return a <= b;
+    }
+    function gt(uint a, uint b) public pure returns (bool) {
+        return a > b;
+    }
+    function sgt(int a, int b) public pure returns (bool) {
+        return a > b;
+    }
+    function gte(uint a, uint b) public pure returns (bool) {
+        return a >= b;
+    }
+    function sgte(int a, int b) public pure returns (bool) {
+        return a >= b;
+    }
+    function eq(uint a, uint b) public pure returns (bool) {
+        return a == b;
+    }
+    function neq(uint a, uint b) public pure returns (bool) {
+        return a != b;
+    }
+}
+// ----
+// f(address): 0x1234 -> false
+// f(address): 0x00 -> true
+// g() -> true
+// lt(uint256,uint256): 4, 5 -> true
+// lt(uint256,uint256): 5, 5 -> false
+// lt(uint256,uint256): 6, 5 -> false
+// gt(uint256,uint256): 4, 5 -> false
+// gt(uint256,uint256): 5, 5 -> false
+// gt(uint256,uint256): 6, 5 -> true
+// lte(uint256,uint256): 4, 5 -> true
+// lte(uint256,uint256): 5, 5 -> true
+// lte(uint256,uint256): 6, 5 -> false
+// gte(uint256,uint256): 4, 5 -> false
+// gte(uint256,uint256): 5, 5 -> true
+// gte(uint256,uint256): 6, 5 -> true
+// eq(uint256,uint256): 4, 5 -> false
+// eq(uint256,uint256): 5, 5 -> true
+// eq(uint256,uint256): 6, 5 -> false
+// neq(uint256,uint256): 4, 5 -> true
+// neq(uint256,uint256): 5, 5 -> false
+// neq(uint256,uint256): 6, 5 -> true
+// slt(int256,int256): -1, 0 -> true
+// slt(int256,int256): 0, 0 -> false
+// slt(int256,int256): 1, 0 -> false
+// sgt(int256,int256): -1, 0 -> false
+// sgt(int256,int256): 0, 0 -> false
+// sgt(int256,int256): 1, 0 -> true
+// slte(int256,int256): -1, 0 -> true
+// slte(int256,int256): 0, 0 -> true
+// slte(int256,int256): 1, 0 -> false
+// sgte(int256,int256): -1, 0 -> false
+// sgte(int256,int256): 0, 0 -> true
+// sgte(int256,int256): 1, 0 -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/comparison_functions.sol b/compiler/test/libsolidity/semanticTests/viaYul/comparison_functions.sol
new file mode 100644
index 00000000..a004299b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/comparison_functions.sol
@@ -0,0 +1,29 @@
+contract C {
+	// If these two functions are identical, the optimiser
+	// on the old codegen path can deduplicate them, and breaking the test.
+	function internal1() internal pure returns (bool) {
+		return true;
+	}
+	function internal2() internal pure returns (bool) {
+		return false;
+	}
+
+	function equal() public pure returns (bool same, bool diff, bool inv) {
+		function() internal pure returns (bool) invalid;
+		delete invalid;
+		same = internal1 == internal1;
+		diff = internal1 == internal2;
+		inv  = internal1 == invalid;
+	}
+
+	function unequal() public pure returns (bool same, bool diff, bool inv) {
+		function() internal pure returns (bool) invalid;
+		delete invalid;
+		same = internal1 != internal1;
+		diff = internal1 != internal2;
+		inv  = internal1 != invalid;
+	}
+}
+// ----
+// equal() -> true, false, false
+// unequal() -> false, true, true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_multiple.sol b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_multiple.sol
new file mode 100644
index 00000000..828398f5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_multiple.sol
@@ -0,0 +1,8 @@
+contract A {
+	function f() public pure returns (uint) {
+		uint x = 3 < 0 ? 2 > 1 ? 2 : 1 : 7 > 2 ? 7 : 6;
+		return x;
+	}
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_true_false_literal.sol b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_true_false_literal.sol
new file mode 100644
index 00000000..c2bbb08d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_true_false_literal.sol
@@ -0,0 +1,9 @@
+contract A {
+	function f() public pure returns (uint) {
+		uint x = true ? 1 : 0;
+		uint y = false ? 0 : 1;
+		return x + y;
+	}
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_tuple.sol b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_tuple.sol
new file mode 100644
index 00000000..51030f9a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_tuple.sol
@@ -0,0 +1,9 @@
+contract A {
+	function f(bool cond) public pure returns (uint, uint) {
+		(uint a, uint b) = cond ? (1, 2) : (3, 4);
+		return (a, b);
+	}
+}
+// ----
+// f(bool): true -> 1, 2
+// f(bool): false -> 3, 4
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_assignment.sol
new file mode 100644
index 00000000..80d4dde6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_assignment.sol
@@ -0,0 +1,11 @@
+contract A {
+    function f() public pure returns (uint, uint, uint, uint) {
+		uint y1 = 1;
+		uint y2 = 1;
+		uint x = 3 < 0 ? y1 = 3 : 6;
+		uint z = 3 < 10 ? y2 = 5 : 6;
+		return (x, y1, y2, z);
+	}
+}
+// ----
+// f() -> 6, 1, 5, 5
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_variables.sol b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_variables.sol
new file mode 100644
index 00000000..4de29663
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conditional/conditional_with_variables.sol
@@ -0,0 +1,11 @@
+contract A {
+	function f() public pure returns (uint, uint, uint, uint) {
+		uint x = 3;
+		uint y = 1;
+		uint z = (x > y) ? x : y;
+		uint w = x < y ? x : y;
+		return (x, y, z, w);
+	}
+}
+// ----
+// f() -> 3, 1, 3, 1
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_assignment.sol
new file mode 100644
index 00000000..cc5a156e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (uint16 x) {
+        uint8 y = uint8(0x78);
+        x = y;
+    }
+}
+// ----
+// f() -> 0x78
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_function_call.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_function_call.sol
new file mode 100644
index 00000000..0ab4b34a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_function_call.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(bytes32 b) public pure returns (bytes32 x) {
+        x = b;
+    }
+    function g() public pure returns (bytes32 x) {
+        x = f(bytes4(uint32(0x12345678)));
+    }
+}
+// ----
+// g() -> 0x1234567800000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_local_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_local_assignment.sol
new file mode 100644
index 00000000..425c6eae
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/explicit_cast_local_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint a) public pure returns (uint8 x) {
+        uint8 b = uint8(a);
+        x = b;
+    }
+}
+// ----
+// f(uint256): 0x12345678 -> 0x78
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol
new file mode 100644
index 00000000..843376ba
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/function_cast.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f(uint x) public pure returns (uint) {
+		return 2 * x;
+	}
+	function g() public view returns (function (uint) external returns (uint)) {
+		return this.f;
+	}
+	function h(uint x) public returns (uint) {
+		return this.g()(x) + 1;
+	}
+	function t() external view returns (
+			function(uint) external returns (uint) a,
+			function(uint) external view returns (uint) b) {
+		a = this.f;
+		b = this.f;
+	}
+}
+// ----
+// f(uint256): 2 -> 4
+// h(uint256): 2 -> 5
+// t() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79eb3de648b0000000000000000, 0xc06afe3a8444fc0004668591e8306bfb9968e79eb3de648b0000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_assignment.sol
new file mode 100644
index 00000000..e2246601
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_assignment.sol
@@ -0,0 +1,12 @@
+// Tests IRGeneratorForStatements::visit(Assignment const& _assignment)
+contract C {
+    function f() public pure returns (uint16 x) {
+        uint8 y;
+        assembly {
+            y := 0x12345678
+        }
+        x = y;
+    }
+}
+// ----
+// f() -> 0x78
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_function_call.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_function_call.sol
new file mode 100644
index 00000000..e62d45b3
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_function_call.sol
@@ -0,0 +1,15 @@
+// IRGeneratorForStatements::visit(FunctionCall const& _functionCall)
+contract C {
+    function f(uint b) public pure returns (uint x) {
+        x = b;
+    }
+    function g() public pure returns (uint x) {
+        uint8 a;
+        assembly {
+            a := 0x12345678
+        }
+        x = f(a);
+    }
+}
+// ----
+// g() -> 0x78
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_local_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_local_assignment.sol
new file mode 100644
index 00000000..3793b4e0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/conversion/implicit_cast_local_assignment.sol
@@ -0,0 +1,11 @@
+// IRGeneratorForStatements::visit(VariableDeclarationStatement const& _varDeclStatement)
+contract C {
+    function f() public pure returns (uint y) {
+        uint8 a;
+        assembly { a := 0x12345678 }
+        uint z = a;
+        y = z;
+    }
+}
+// ----
+// f() -> 0x78
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol b/compiler/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol
new file mode 100644
index 00000000..5a85ba07
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol
@@ -0,0 +1,26 @@
+contract C {
+	struct Struct {
+		function () external el;
+	}
+	Struct[] array;
+	int externalCalled = 0;
+
+	function ext() external {
+		externalCalled++;
+	}
+
+	function f() public {
+		array.push(Struct(this.ext));
+		array.push(array[0]);
+
+		array[0].el();
+		array[1].el();
+
+		assert(externalCalled == 2);
+	}
+}
+// ----
+// f() ->
+// gas irOptimized: 112969
+// gas legacy: 112890
+// gas legacyOptimized: 112580
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/define_tuple_from_function_call.sol b/compiler/test/libsolidity/semanticTests/viaYul/define_tuple_from_function_call.sol
new file mode 100644
index 00000000..3e1559bc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/define_tuple_from_function_call.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public pure returns (uint, uint, uint) {
+        return (1, 2, 3);
+    }
+    function g() public pure returns (uint x, uint y, uint z) {
+        (uint c, uint b, uint a) = f();
+        (x, y, z) = (a, b, c);
+    }
+    function h() public pure returns (uint) {
+        (,,uint a) = f();
+        return a;
+    }
+}
+// ----
+// g() -> 3, 2, 1
+// h() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/delete.sol b/compiler/test/libsolidity/semanticTests/viaYul/delete.sol
new file mode 100644
index 00000000..6a0f3d59
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/delete.sol
@@ -0,0 +1,23 @@
+contract C {
+	function internal_func() internal pure returns (int8)
+	{
+		return 1;
+	}
+	function call_internal_func() public pure returns (bool ret)
+	{
+		function() internal pure returns(int8) func = internal_func;
+
+		return func() == internal_func();
+	}
+	function call_deleted_internal_func() public pure returns (bool ret)
+	{
+		function() internal pure returns(int8) func = internal_func;
+
+		delete func;
+
+		return func() == internal_func();
+	}
+}
+// ----
+// call_deleted_internal_func() -> FAILURE, hex"4e487b71", 0x51
+// call_internal_func() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow.sol
new file mode 100644
index 00000000..412998b5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x) {
+        x = a + b;
+    }
+    function g(uint8 a, uint8 b) public pure returns (uint8 x) {
+        x = a + b;
+    }
+}
+// ----
+// f(uint256,uint256): 5, 6 -> 11
+// f(uint256,uint256): -2, 1 -> -1
+// f(uint256,uint256): -2, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 2, -2 -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 128, 64 -> 192
+// g(uint8,uint8): 128, 127 -> 255
+// g(uint8,uint8): 128, 128 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow_signed.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow_signed.sol
new file mode 100644
index 00000000..5c721ac2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_add_overflow_signed.sol
@@ -0,0 +1,37 @@
+contract C {
+    function f(int a, int b) public pure returns (int x) {
+        x = a + b;
+    }
+    function g(int8 a, int8 b) public pure returns (int8 x) {
+        x = a + b;
+    }
+}
+// ----
+// f(int256,int256): 5, 6 -> 11
+// f(int256,int256): -2, 1 -> -1
+// f(int256,int256): -2, 2 -> 0
+// f(int256,int256): 2, -2 -> 0
+// f(int256,int256): -5, -6 -> -11
+// f(int256,int256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0, 0x0F -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+// f(int256,int256): 0x0F, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+// f(int256,int256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 1 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 1, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000001, -1 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): -1, 0x8000000000000000000000000000000000000000000000000000000000000001 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000000, -1 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): -1, 0x8000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 5, 6 -> 11
+// g(int8,int8): -2, 1 -> -1
+// g(int8,int8): -2, 2 -> 0
+// g(int8,int8): 2, -2 -> 0
+// g(int8,int8): -5, -6 -> -11
+// g(int8,int8): 126, 1 -> 127
+// g(int8,int8): 1, 126 -> 127
+// g(int8,int8): 127, 1 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 1, 127 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -127, -1 -> -128
+// g(int8,int8): -1, -127 -> -128
+// g(int8,int8): -127, -2 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -2, -127 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -128, 0 -> -128
+// g(int8,int8): 0, -128 -> -128
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_div_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_div_overflow.sol
new file mode 100644
index 00000000..d4cefe12
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_div_overflow.sol
@@ -0,0 +1,25 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x) {
+        x = a / b;
+    }
+    function g(int8 a, int8 b) public pure returns (int8 x) {
+        x = a / b;
+    }
+    function h(uint256 a, uint256 b) public pure returns (uint256 x) {
+        x = a / b;
+    }
+}
+// ----
+// f(uint256,uint256): 10, 3 -> 3
+// f(uint256,uint256): 1, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(uint256,uint256): 0, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(uint256,uint256): 0, 1 -> 0
+// g(int8,int8): -10, 3 -> -3
+// g(int8,int8): -10, -3 -> 3
+// g(int8,int8): -10, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(int8,int8): -128, 1 -> -128
+// g(int8,int8): -128, -2 -> 64
+// g(int8,int8): -128, 2 -> -64
+// g(int8,int8): -128, -1 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -127, -1 -> 127
+// h(uint256,uint256): 0x8000000000000000000000000000000000000000000000000000000000000000, -1 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero.sol
new file mode 100644
index 00000000..0d043298
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero.sol
@@ -0,0 +1,23 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x) {
+        x = a % b;
+    }
+    function g(uint8 a, uint8 b) public pure returns (uint8 x) {
+        x = a % b;
+    }
+}
+// ----
+// f(uint256,uint256): 10, 3 -> 1
+// f(uint256,uint256): 10, 2 -> 0
+// f(uint256,uint256): 11, 2 -> 1
+// f(uint256,uint256): 2, 2 -> 0
+// f(uint256,uint256): 1, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(uint256,uint256): 0, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(uint256,uint256): 0, 1 -> 0
+// g(uint8,uint8): 10, 3 -> 1
+// g(uint8,uint8): 10, 2 -> 0
+// g(uint8,uint8): 11, 2 -> 1
+// g(uint8,uint8): 2, 2 -> 0
+// g(uint8,uint8): 1, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(uint8,uint8): 0, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(uint8,uint8): 0, 1 -> 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero_signed.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero_signed.sol
new file mode 100644
index 00000000..e97bc4cc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_mod_zero_signed.sol
@@ -0,0 +1,35 @@
+contract C {
+    function f(int a, int b) public pure returns (int x) {
+        x = a % b;
+    }
+    function g(int8 a, int8 b) public pure returns (int8 x) {
+        x = a % b;
+    }
+}
+// ----
+// f(int256,int256): 10, 3 -> 1
+// f(int256,int256): 10, 2 -> 0
+// f(int256,int256): 11, 2 -> 1
+// f(int256,int256): -10, 3 -> -1
+// f(int256,int256): 10, -3 -> 1
+// f(int256,int256): -10, -3 -> -1
+// f(int256,int256): 2, 2 -> 0
+// f(int256,int256): 1, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(int256,int256): -1, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(int256,int256): 0, 0 -> FAILURE, hex"4e487b71", 0x12
+// f(int256,int256): 0, 1 -> 0
+// f(int256,int256): 0, -1 -> 0
+// g(int8,int8): 10, 3 -> 1
+// g(int8,int8): 10, 2 -> 0
+// g(int8,int8): 11, 2 -> 1
+// g(int8,int8): -10, 3 -> -1
+// g(int8,int8): 10, -3 -> 1
+// g(int8,int8): -10, -3 -> -1
+// g(int8,int8): 2, 2 -> 0
+// g(int8,int8): 1, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(int8,int8): -1, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(int8,int8): 0, 0 -> FAILURE, hex"4e487b71", 0x12
+// g(int8,int8): 0, 1 -> 0
+// g(int8,int8): 0, -1 -> 0
+// g(int8,int8): -128, -128 -> 0
+// g(int8,int8): -128, 127 -> -1
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow.sol
new file mode 100644
index 00000000..935d0375
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow.sol
@@ -0,0 +1,35 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x) {
+        x = a * b;
+    }
+    function g(uint8 a, uint8 b) public pure returns (uint8 x) {
+        x = a * b;
+    }
+}
+// ----
+// f(uint256,uint256): 5, 6 -> 30
+// f(uint256,uint256): -1, 1 -> -1
+// f(uint256,uint256): -1, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 0x8000000000000000000000000000000000000000000000000000000000000000, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> -2
+// f(uint256,uint256): 2, 0x8000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 2, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> -2
+// f(uint256,uint256): 0x0100000000000000000000000000000000, 0x0100000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 0x0100000000000000000000000000000000, 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000
+// f(uint256,uint256): 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 0x0100000000000000000000000000000000 -> 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000
+// f(uint256,uint256): 0x0100000000000000000000000000000001, 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> -1
+// f(uint256,uint256): 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 0x0100000000000000000000000000000001 -> -1
+// f(uint256,uint256): 0x0100000000000000000000000000000002, 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 0x0100000000000000000000000000000002 -> FAILURE, hex"4e487b71", 0x11
+// f(uint256,uint256): -1, 0 -> 0
+// f(uint256,uint256): 0, -1 -> 0
+// g(uint8,uint8): 5, 6 -> 30
+// g(uint8,uint8): 0x80, 2 -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 0x7F, 2 -> 254
+// g(uint8,uint8): 2, 0x7F -> 254
+// g(uint8,uint8): 0x10, 0x10 -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 0x0F, 0x11 -> 0xFF
+// g(uint8,uint8): 0x0F, 0x12 -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 0x12, 0x0F -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 0xFF, 0 -> 0
+// g(uint8,uint8): 0, 0xFF -> 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow_signed.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow_signed.sol
new file mode 100644
index 00000000..213b1a6d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_mul_overflow_signed.sol
@@ -0,0 +1,82 @@
+contract C {
+    function f(int a, int b) public pure returns (int x) {
+        x = a * b;
+    }
+    function g(int8 a, int8 b) public pure returns (int8 x) {
+        x = a * b;
+    }
+    function h(int160 a, int160 b) public pure returns (int160 x) {
+        x = a * b;
+    }
+}
+// ----
+// f(int256,int256): 5, 6 -> 30
+// f(int256,int256): -1, 1 -> -1
+// f(int256,int256): -1, 2 -> -2 # positive, positive #
+// f(int256,int256): 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+// f(int256,int256): 0x4000000000000000000000000000000000000000000000000000000000000000, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 2, 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+// f(int256,int256): 2, 0x4000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): -1, 0x8000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000000, -1 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 2, 0x4000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// f(int256,int256): 2, 0x4000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// f(int256,int256): 2, 0x4000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// f(int256,int256): 0x4000000000000000000000000000000000000000000000000000000000000000, -2 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): 0x4000000000000000000000000000000000000000000000000000000000000001, -2 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 2, 0xC000000000000000000000000000000000000000000000000000000000000000 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): 2, 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// f(int256,int256): 2, 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// f(int256,int256): 2, 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// f(int256,int256): -2, 0x4000000000000000000000000000000000000000000000000000000000000000 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): -2, 0x4000000000000000000000000000000000000000000000000000000000000001 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0xC000000000000000000000000000000000000000000000000000000000000000, 2 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// f(int256,int256): 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// f(int256,int256): 0xBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// f(int256,int256): 0xC000000000000000000000000000000000000000000000000000000000000001, -2 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+// f(int256,int256): 0xC000000000000000000000000000000000000000000000000000000000000000, -2 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): -2, 0xC000000000000000000000000000000000000000000000000000000000000001 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+// f(int256,int256): -2, 0xC000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # small type #
+// f(int256,int256): -2, 0xC000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # small type #
+// f(int256,int256): -2, 0xC000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11 # small type #
+// g(int8,int8): 5, 6 -> 30
+// g(int8,int8): -1, 1 -> -1
+// g(int8,int8): -1, 2 -> -2 # positive, positive #
+// g(int8,int8): 63, 2 -> 126
+// g(int8,int8): 64, 2 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 2, 63 -> 126
+// g(int8,int8): 2, 64 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// g(int8,int8): 2, 64 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// g(int8,int8): 2, 64 -> FAILURE, hex"4e487b71", 0x11 # positive, negative #
+// g(int8,int8): 64, -2 -> -128
+// g(int8,int8): 65, -2 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 2, -64 -> -128
+// g(int8,int8): 2, -65 -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// g(int8,int8): 2, -65 -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// g(int8,int8): 2, -65 -> FAILURE, hex"4e487b71", 0x11 # negative, positive #
+// g(int8,int8): -2, 64 -> -128
+// g(int8,int8): -2, 65 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -64, 2 -> -128
+// g(int8,int8): -65, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// g(int8,int8): -65, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// g(int8,int8): -65, 2 -> FAILURE, hex"4e487b71", 0x11 # negative, negative #
+// g(int8,int8): -63, -2 -> 126
+// g(int8,int8): -64, -2 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -2, -63 -> 126
+// g(int8,int8): -2, -64 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): -1, 1 -> -1
+// h(int160,int160): 1, -1 -> -1
+// h(int160,int160): -1, 2 -> -2
+// h(int160,int160): 2, -1 -> -2
+// h(int160,int160): -1, 0xFFFFFFFFFFFFFFFFFFFFFFFF8000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): -1, 0xFFFFFFFFFFFFFFFFFFFFFFFF8000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 0xFFFFFFFFFFFFFFFFFFFFFFFF8000000000000000000000000000000000000000, -1 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 0x0000000000000000000000004000000000000000000000000000000000000000, -2 -> 0xFFFFFFFFFFFFFFFFFFFFFFFF8000000000000000000000000000000000000000
+// h(int160,int160): -2, 0x0000000000000000000000004000000000000000000000000000000000000000 -> 0xFFFFFFFFFFFFFFFFFFFFFFFF8000000000000000000000000000000000000000
+// h(int160,int160): -2, 0x0000000000000000000000004000000000000000000000000000000000000001 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 0x0000000000000000000000004000000000000000000000000000000000000001, -2 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 0x0000000000000000000000004000000000000000000000000000000000000001, 2 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 2, 0x0000000000000000000000004000000000000000000000000000000000000001 -> FAILURE, hex"4e487b71", 0x11
+// h(int160,int160): 0x0000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, 2 -> 0x0000000000000000000000007FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE
+// h(int160,int160): 2, 0x0000000000000000000000004000000000000000000000000000000000000001 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow.sol
new file mode 100644
index 00000000..ee059137
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x) {
+        x = a - b;
+    }
+    function g(uint8 a, uint8 b) public pure returns (uint8 x) {
+        x = a - b;
+    }
+}
+// ----
+// f(uint256,uint256): 6, 5 -> 1
+// f(uint256,uint256): 6, 6 -> 0
+// f(uint256,uint256): 5, 6 -> FAILURE, hex"4e487b71", 0x11
+// g(uint8,uint8): 6, 5 -> 1
+// g(uint8,uint8): 6, 6 -> 0
+// g(uint8,uint8): 5, 6 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow_signed.sol b/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow_signed.sol
new file mode 100644
index 00000000..a247af68
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/detect_sub_overflow_signed.sol
@@ -0,0 +1,40 @@
+contract C {
+    function f(int a, int b) public pure returns (int x) {
+        x = a - b;
+    }
+    function g(int8 a, int8 b) public pure returns (int8 x) {
+        x = a - b;
+    }
+}
+// ----
+// f(int256,int256): 5, 6 -> -1
+// f(int256,int256): -2, 1 -> -3
+// f(int256,int256): -2, 2 -> -4
+// f(int256,int256): 2, -2 -> 4
+// f(int256,int256): 2, 2 -> 0
+// f(int256,int256): -5, -6 -> 1
+// f(int256,int256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0, -15 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+// f(int256,int256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0, -16 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, -1 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 15, 0x8000000000000000000000000000000000000000000000000000000000000010 -> 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+// f(int256,int256): 16, 0x8000000000000000000000000000000000000000000000000000000000000010 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 1, 0x8000000000000000000000000000000000000000000000000000000000000000 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): -1, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): -2, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000001, 1 -> 0x8000000000000000000000000000000000000000000000000000000000000000
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000001, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(int256,int256): 0x8000000000000000000000000000000000000000000000000000000000000000, 1 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 5, 6 -> -1
+// g(int8,int8): -2, 1 -> -3
+// g(int8,int8): -2, 2 -> -4
+// g(int8,int8): 2, -2 -> 4
+// g(int8,int8): 2, 2 -> 0
+// g(int8,int8): -5, -6 -> 1
+// g(int8,int8): 126, -1 -> 127
+// g(int8,int8): 1, -126 -> 127
+// g(int8,int8): 127, -1 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): 1, -127 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -127, 1 -> -128
+// g(int8,int8): -1, 127 -> -128
+// g(int8,int8): -127, 2 -> FAILURE, hex"4e487b71", 0x11
+// g(int8,int8): -2, 127 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_dynamic_array.sol b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_dynamic_array.sol
new file mode 100644
index 00000000..36a253b0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_dynamic_array.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public pure returns (bool correct) {
+        uint8[] memory m = new uint8[](1);
+        assembly {
+            mstore(add(m, 32), 258)
+        }
+        uint8 x = m[0];
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = (m[0] == 0x02) && (r == 0x02);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_int32.sol b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_int32.sol
new file mode 100644
index 00000000..fc2fe425
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_int32.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public pure returns (bool correct) {
+        uint256[1] memory m;
+        assembly {
+            mstore(m, 0xdeadbeef15dead)
+        }
+        int32 x = int32(uint32(m[0]));
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = (m[0] == 0xdeadbeef15dead) && (r == (((2 ** 224 - 1) << 32) | 0xef15dead));
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_static_array.sol b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_static_array.sol
new file mode 100644
index 00000000..4742bae2
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_static_array.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public pure returns (bool correct) {
+        uint8[1] memory m;
+        assembly {
+            mstore(m, 257)
+        }
+        uint8 x = m[0];
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = (m[0] == 0x01) && (r == 0x01);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_struct.sol b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_struct.sol
new file mode 100644
index 00000000..411cbe06
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_struct.sol
@@ -0,0 +1,22 @@
+contract C {
+    struct S {
+        uint8[] m;
+    }
+    function f() public pure returns (bool correct) {
+        S memory s;
+        s.m = new uint8[](1);
+        assembly {
+            mstore(add(s, 64), 257)
+        }
+        uint8 x = s.m[0];
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = r == 0x01;
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_uint32.sol b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_uint32.sol
new file mode 100644
index 00000000..a23a566c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/dirty_memory_uint32.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public pure returns (bool correct) {
+        uint256[1] memory m;
+        assembly {
+            mstore(m, 0xdeadbeef15dead)
+        }
+        uint32 x = uint32(m[0]);
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = (r == 0xef15dead) && (m[0] == 0xdeadbeef15dead);
+    }
+}
+// ====
+// compileViaYul: true
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp.sol
new file mode 100644
index 00000000..324256b4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f(uint x, uint y) public returns (uint) {
+        return x**y;
+    }
+}
+// ----
+// f(uint256,uint256): 0, 0 -> 1
+// f(uint256,uint256): 0, 1 -> 0x00
+// f(uint256,uint256): 0, 2 -> 0x00
+// f(uint256,uint256): 1, 0 -> 1
+// f(uint256,uint256): 1, 1 -> 1
+// f(uint256,uint256): 1, 2 -> 1
+// f(uint256,uint256): 2, 0 -> 1
+// f(uint256,uint256): 2, 1 -> 2
+// f(uint256,uint256): 2, 2 -> 4
+// f(uint256,uint256): 7, 63 -> 174251498233690814305510551794710260107945042018748343
+// f(uint256,uint256): 128, 2 -> 0x4000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_literals.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_literals.sol
new file mode 100644
index 00000000..382d7518
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_literals.sol
@@ -0,0 +1,49 @@
+contract C {
+    function exp_2(uint y) public returns (uint) {
+        return 2**y;
+    }
+    function exp_minus_2(uint y) public returns (int) {
+        return (-2)**y;
+    }
+
+    function exp_uint_max(uint y) public returns (uint) {
+        return (2**256 - 1)**y;
+    }
+    function exp_int_max(uint y) public returns (int) {
+        return ((-2)**255)**y;
+    }
+
+    function exp_5(uint y) public returns (uint) {
+        return 5**y;
+    }
+    function exp_minus_5(uint y) public returns (int) {
+        return (-5)**y;
+    }
+
+    function exp_256(uint y) public returns (uint) {
+        return 256**y;
+    }
+    function exp_minus_256(uint y) public returns (int) {
+        return (-256)**y;
+    }
+
+}
+// ====
+// compileViaYul: true
+// ----
+// exp_2(uint256): 255 -> 57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_2(uint256): 256 -> FAILURE, hex"4e487b71", 0x11
+// exp_minus_2(uint256): 255 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_minus_2(uint256): 256 -> FAILURE, hex"4e487b71", 0x11
+// exp_uint_max(uint256): 1 -> 115792089237316195423570985008687907853269984665640564039457584007913129639935
+// exp_uint_max(uint256): 2 -> FAILURE, hex"4e487b71", 0x11
+// exp_int_max(uint256): 1 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_int_max(uint256): 2 -> FAILURE, hex"4e487b71", 0x11
+// exp_5(uint256): 110 -> 77037197775489434122239117703397092741524065928615527809597551822662353515625
+// exp_5(uint256): 111 -> FAILURE, hex"4e487b71", 0x11
+// exp_minus_5(uint256): 109 -> -15407439555097886824447823540679418548304813185723105561919510364532470703125
+// exp_minus_5(uint256): 110 -> FAILURE, hex"4e487b71", 0x11
+// exp_256(uint256): 31 -> 452312848583266388373324160190187140051835877600158453279131187530910662656
+// exp_256(uint256): 32 -> FAILURE, hex"4e487b71", 0x11
+// exp_minus_256(uint256): 31 -> -452312848583266388373324160190187140051835877600158453279131187530910662656
+// exp_minus_256(uint256): 32 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_literals_success.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_literals_success.sol
new file mode 100644
index 00000000..12ab3392
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_literals_success.sol
@@ -0,0 +1,39 @@
+contract C {
+    function exp_2(uint y) public returns (uint) {
+        return 2**y;
+    }
+    function exp_minus_2(uint y) public returns (int) {
+        return (-2)**y;
+    }
+
+    function exp_uint_max(uint y) public returns (uint) {
+        return (2**256 - 1)**y;
+    }
+    function exp_int_max(uint y) public returns (int) {
+        return ((-2)**255)**y;
+    }
+
+    function exp_5(uint y) public returns (uint) {
+        return 5**y;
+    }
+    function exp_minus_5(uint y) public returns (int) {
+        return (-5)**y;
+    }
+
+    function exp_256(uint y) public returns (uint) {
+        return 256**y;
+    }
+    function exp_minus_256(uint y) public returns (int) {
+        return (-256)**y;
+    }
+
+}
+// ----
+// exp_2(uint256): 255 -> 57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_minus_2(uint256): 255 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_uint_max(uint256): 1 -> 115792089237316195423570985008687907853269984665640564039457584007913129639935
+// exp_int_max(uint256): 1 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// exp_5(uint256): 110 -> 77037197775489434122239117703397092741524065928615527809597551822662353515625
+// exp_minus_5(uint256): 109 -> -15407439555097886824447823540679418548304813185723105561919510364532470703125
+// exp_256(uint256): 31 -> 452312848583266388373324160190187140051835877600158453279131187530910662656
+// exp_minus_256(uint256): 31 -> -452312848583266388373324160190187140051835877600158453279131187530910662656
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_neg.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_neg.sol
new file mode 100644
index 00000000..a6ba617d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_neg.sol
@@ -0,0 +1,31 @@
+contract C {
+    function f(int x, uint y) public returns (int) {
+        return x**y;
+    }
+}
+// ----
+// f(int256,uint256): 0, 0 -> 1
+// f(int256,uint256): 0, 1 -> 0x00
+// f(int256,uint256): 0, 2 -> 0x00
+// f(int256,uint256): 1, 0 -> 1
+// f(int256,uint256): 1, 1 -> 1
+// f(int256,uint256): 1, 2 -> 1
+// f(int256,uint256): 2, 0 -> 1
+// f(int256,uint256): 2, 1 -> 2
+// f(int256,uint256): 2, 2 -> 4
+// f(int256,uint256): 7, 63 -> 174251498233690814305510551794710260107945042018748343
+// f(int256,uint256): 128, 2 -> 0x4000
+// f(int256,uint256): -1, 0 -> 1
+// f(int256,uint256): -1, 1 -> -1
+// f(int256,uint256): -1, 2 -> 1
+// f(int256,uint256): -2, 0 -> 1
+// f(int256,uint256): -2, 1 -> -2
+// f(int256,uint256): -2, 2 -> 4
+// f(int256,uint256): -7, 63 -> -174251498233690814305510551794710260107945042018748343
+// f(int256,uint256): -128, 2 -> 0x4000
+// f(int256,uint256): -1, 115792089237316195423570985008687907853269984665640564039457584007913129639935 -> -1
+// f(int256,uint256): -2, 255 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// f(int256,uint256): -8, 85 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// f(int256,uint256): -131072, 15 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// f(int256,uint256): -32, 51 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
+// f(int256,uint256): -57896044618658097711785492504343953926634992332820282019728792003956564819968, 1 -> -57896044618658097711785492504343953926634992332820282019728792003956564819968
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_neg_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_neg_overflow.sol
new file mode 100644
index 00000000..a966e3cc
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_neg_overflow.sol
@@ -0,0 +1,36 @@
+contract C {
+    function f(int8 x, uint y) public returns (int) {
+        return x**y;
+    }
+    function g(int256 x, uint y) public returns (int) {
+        return x**y;
+    }
+}
+// ----
+// f(int8,uint256): 2, 6 -> 64
+// f(int8,uint256): 2, 7 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 2, 8 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -2, 6 -> 64
+// f(int8,uint256): -2, 7 -> -128
+// f(int8,uint256): -2, 8 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 6, 3 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 7, 2 -> 0x31
+// f(int8,uint256): 7, 3 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -7, 2 -> 0x31
+// f(int8,uint256): -7, 3 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -7, 4 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 127, 31 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 127, 131 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -128, 0 -> 1
+// f(int8,uint256): -128, 1 -> -128
+// f(int8,uint256): -128, 31 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -128, 131 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -11, 2 -> 121
+// f(int8,uint256): -12, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): 12, 2 -> FAILURE, hex"4e487b71", 0x11
+// f(int8,uint256): -5, 3 -> -125
+// f(int8,uint256): -6, 3 -> FAILURE, hex"4e487b71", 0x11
+// g(int256,uint256): -7, 90 -> 11450477594321044359340126713545146077054004823284978858214566372120240027249
+// g(int256,uint256): -7, 91 -> FAILURE, hex"4e487b71", 0x11
+// g(int256,uint256): -63, 42 -> 3735107253208426854890677539053540390278853997836851167913009474475553834369
+// g(int256,uint256): -63, 43 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_overflow.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_overflow.sol
new file mode 100644
index 00000000..7a100c2b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_overflow.sol
@@ -0,0 +1,29 @@
+contract C {
+    function f(uint8 x, uint8 y) public returns (uint) {
+        return x**y;
+    }
+    function g(uint x, uint y) public returns (uint) {
+        return x**y;
+    }
+}
+// ----
+// f(uint8,uint8): 2, 7 -> 0x80
+// f(uint8,uint8): 2, 8 -> FAILURE, hex"4e487b71", 0x11
+// f(uint8,uint8): 15, 2 -> 225
+// f(uint8,uint8): 6, 3 -> 0xd8
+// f(uint8,uint8): 7, 2 -> 0x31
+// f(uint8,uint8): 7, 3 -> FAILURE, hex"4e487b71", 0x11
+// f(uint8,uint8): 7, 4 -> FAILURE, hex"4e487b71", 0x11
+// f(uint8,uint8): 255, 31 -> FAILURE, hex"4e487b71", 0x11
+// f(uint8,uint8): 255, 131 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 0x200000000000000000000000000000000, 1 -> 0x0200000000000000000000000000000000
+// g(uint256,uint256): 0x100000000000000000000000000000010, 2 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 0x200000000000000000000000000000000, 2 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 0x200000000000000000000000000000000, 3 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 255, 31 -> 400631961586894742455537928461950192806830589109049416147172451019287109375
+// g(uint256,uint256): 255, 32 -> -13630939032658036097408813250890608687528184442832962921928608997994916749311
+// g(uint256,uint256): 255, 33 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 255, 131 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 258, 31 -> 575719427506838823084316385994930914701079543089399988096291424922125729792
+// g(uint256,uint256): 258, 37 -> FAILURE, hex"4e487b71", 0x11
+// g(uint256,uint256): 258, 131 -> FAILURE, hex"4e487b71", 0x11
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/exp_various.sol b/compiler/test/libsolidity/semanticTests/viaYul/exp_various.sol
new file mode 100644
index 00000000..3e9cf9d4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/exp_various.sol
@@ -0,0 +1,48 @@
+contract C {
+    function f(uint8 x, uint8 y) public returns (uint) {
+        return x**y;
+    }
+    function g(uint x, uint y) public returns (uint) {
+        return x**y;
+    }
+}
+// ----
+// f(uint8,uint8): 0, 0 -> 1
+// f(uint8,uint8): 0, 1 -> 0x00
+// f(uint8,uint8): 0, 2 -> 0x00
+// f(uint8,uint8): 0, 3 -> 0x00
+// f(uint8,uint8): 1, 0 -> 1
+// f(uint8,uint8): 1, 1 -> 1
+// f(uint8,uint8): 1, 2 -> 1
+// f(uint8,uint8): 1, 3 -> 1
+// f(uint8,uint8): 2, 0 -> 1
+// f(uint8,uint8): 2, 1 -> 2
+// f(uint8,uint8): 2, 2 -> 4
+// f(uint8,uint8): 2, 3 -> 8
+// f(uint8,uint8): 3, 0 -> 1
+// f(uint8,uint8): 3, 1 -> 3
+// f(uint8,uint8): 3, 2 -> 9
+// f(uint8,uint8): 3, 3 -> 0x1b
+// f(uint8,uint8): 10, 0 -> 1
+// f(uint8,uint8): 10, 1 -> 0x0a
+// f(uint8,uint8): 10, 2 -> 100
+// g(uint256,uint256): 0, 0 -> 1
+// g(uint256,uint256): 0, 1 -> 0x00
+// g(uint256,uint256): 0, 2 -> 0x00
+// g(uint256,uint256): 0, 3 -> 0x00
+// g(uint256,uint256): 1, 0 -> 1
+// g(uint256,uint256): 1, 1 -> 1
+// g(uint256,uint256): 1, 2 -> 1
+// g(uint256,uint256): 1, 3 -> 1
+// g(uint256,uint256): 2, 0 -> 1
+// g(uint256,uint256): 2, 1 -> 2
+// g(uint256,uint256): 2, 2 -> 4
+// g(uint256,uint256): 2, 3 -> 8
+// g(uint256,uint256): 3, 0 -> 1
+// g(uint256,uint256): 3, 1 -> 3
+// g(uint256,uint256): 3, 2 -> 9
+// g(uint256,uint256): 3, 3 -> 0x1b
+// g(uint256,uint256): 10, 10 -> 10000000000
+// g(uint256,uint256): 10, 77 -> -15792089237316195423570985008687907853269984665640564039457584007913129639936
+// g(uint256,uint256): 256, 2 -> 0x010000
+// g(uint256,uint256): 256, 31 -> 0x0100000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/function_address.sol b/compiler/test/libsolidity/semanticTests/viaYul/function_address.sol
new file mode 100644
index 00000000..0c1c58dd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/function_address.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() external returns (address) {
+        return this.f.address;
+    }
+    function g() external returns (bool) {
+      return this.f.address == address(this);
+    }
+    function h(function() external a) public returns (address) {
+      return a.address;
+    }
+}
+// ----
+// f() -> 0xc06afe3a8444fc0004668591e8306bfb9968e79e
+// g() -> true
+// h(function): left(0x1122334400112233445566778899AABBCCDDEEFF42424242) -> 0x1122334400112233445566778899AABBCCDDEEFF
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/function_entry_checks.sol b/compiler/test/libsolidity/semanticTests/viaYul/function_entry_checks.sol
new file mode 100644
index 00000000..6f5f9082
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/function_entry_checks.sol
@@ -0,0 +1,28 @@
+contract C {
+    function f() public returns (uint) {
+    }
+    function g(uint x, uint y) public returns (uint) {
+    }
+    function h() public payable returns (uint) {
+    }
+    function i(bytes32 b) public returns (bytes32) {
+    }
+    function j(bool b) public returns (bool) {
+    }
+    function k(bytes32 b) public returns (bytes32) {
+    }
+    function s() public returns (uint256[] memory) {
+    }
+    function t(uint) public pure {
+    }
+}
+// ----
+// f() -> 0
+// g(uint256,uint256): 1, -2 -> 0
+// h(), 1 ether -> 0
+// i(bytes32), 1 ether: 2 -> FAILURE
+// i(bytes32): 2 -> 0
+// j(bool): true -> false
+// k(bytes32): 0x31 -> 0x00
+// s(): hex"4200ef" -> 0x20, 0
+// t(uint256) -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/function_pointers.sol b/compiler/test/libsolidity/semanticTests/viaYul/function_pointers.sol
new file mode 100644
index 00000000..b34f0198
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/function_pointers.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public {
+		function() internal returns (uint) _f;
+		_f();
+	}
+	function g() public {
+		function() external returns (uint) _g;
+		_g();
+	}
+	function h1() internal returns (function() internal returns (uint) _h) {}
+	function h2() public {
+		h1()();
+	}
+	function k1() internal returns (function() external returns (uint) _k) {}
+	function k2() public {
+		k1()();
+	}
+}
+// ----
+// f() -> FAILURE, hex"4e487b71", 0x51
+// g() -> FAILURE
+// h2() -> FAILURE, hex"4e487b71", 0x51
+// k2() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/function_selector.sol b/compiler/test/libsolidity/semanticTests/viaYul/function_selector.sol
new file mode 100644
index 00000000..4737a36d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/function_selector.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() external returns (bytes4) {
+        return this.f.selector;
+    }
+    function h(function() external a) public returns (bytes4) {
+        return a.selector;
+    }
+}
+// ----
+// f() -> left(0x26121ff0)
+// h(function): left(0x1122334400112233445566778899AABBCCDDEEFF42424242) -> left(0x42424242)
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/if.sol b/compiler/test/libsolidity/semanticTests/viaYul/if.sol
new file mode 100644
index 00000000..0fe752d5
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/if.sol
@@ -0,0 +1,80 @@
+contract C {
+    function f(bool condition) public returns (uint x) {
+        x = 23;
+        if (condition)
+            x = 42;
+    }
+    function g(bool condition) public returns (uint x) {
+        x = 0;
+        if (condition)
+            x = 42;
+        else
+            x = 23;
+    }
+    function h(bool condition) public returns (uint x) {
+        if (condition)
+            return 42;
+        x = 23;
+    }
+    function i(bool condition) public returns (uint x) {
+        if (condition)
+            x = 10;
+        else
+            return 23;
+        x = 42;
+    }
+    function j(uint a, uint b) public returns (uint x, uint y) {
+        x = 42;
+        if (a + b < 10)
+            x = a;
+        else
+            x = b;
+        y = 100;
+    }
+    function k(uint a, uint b) public returns (uint x, uint y) {
+        x = 42;
+        do {
+            if (a + b < 10)
+            {
+                if (a == b)
+                {
+                    x = 99; y = 99;
+                    break;
+                }
+                else
+                {
+                    x = a;
+                }
+            }
+            else
+            {
+                x = b;
+                if (a != b)
+                    y = 17;
+                else
+                    y = 13;
+                break;
+            }
+            y = 100;
+        } while(false);
+    }
+}
+// ----
+// f(bool): 0 -> 23
+// f(bool): 1 -> 42
+// g(bool): 0 -> 23
+// g(bool): 1 -> 42
+// h(bool): 0 -> 23
+// h(bool): 1 -> 42
+// i(bool): 0 -> 23
+// i(bool): 1 -> 42
+// j(uint256,uint256): 1, 3 -> 1, 100
+// j(uint256,uint256): 3, 1 -> 3, 100
+// j(uint256,uint256): 10, 23 -> 23, 100
+// j(uint256,uint256): 23, 10 -> 10, 100
+// k(uint256,uint256): 1, 3 -> 1, 100
+// k(uint256,uint256): 3, 1 -> 3, 100
+// k(uint256,uint256): 3, 3 -> 99, 99
+// k(uint256,uint256): 10, 23 -> 23, 17
+// k(uint256,uint256): 23, 10 -> 10, 17
+// k(uint256,uint256): 23, 23 -> 23, 13
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/local_address_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/local_address_assignment.sol
new file mode 100644
index 00000000..529513ea
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/local_address_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(address a) public pure returns (address x) {
+        address b = a;
+        x = b;
+    }
+}
+// ----
+// f(address): 0x1234 -> 0x1234
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/local_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/local_assignment.sol
new file mode 100644
index 00000000..f77d25c6
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/local_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint a) public pure returns (uint x) {
+        uint b = a;
+        x = b;
+    }
+}
+// ----
+// f(uint256): 6 -> 6
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/local_bool_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/local_bool_assignment.sol
new file mode 100644
index 00000000..d32e281d
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/local_bool_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(bool a) public pure returns (bool x) {
+        bool b = a;
+        x = b;
+    }
+}
+// ----
+// f(bool): true -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/local_tuple_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/local_tuple_assignment.sol
new file mode 100644
index 00000000..ff7f0785
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/local_tuple_assignment.sol
@@ -0,0 +1,30 @@
+contract C {
+    uint public x = 17;
+    function f(uint a1, uint a2) public returns (uint r1, uint r2) {
+        (uint b1, uint b2) = (a1, a2);
+        (r1, x, r2) = (b1, b2, b2);
+    }
+    function g() public returns (uint a, uint b, uint c) {
+        uint256[3] memory m;
+        (m[0], m[1], m[2]) = (1, x, 3);
+        return (m[2], m[1], m[0]);
+    }
+    function h() public returns (uint a, uint b, uint c) {
+        uint256[3] memory m;
+        (m[0], m[1], , m[2], m[0]) = (1, x, 3, 4, 42);
+        return (m[2], m[1], m[0]);
+    }
+    function i() public returns (uint a, uint b, uint c, uint d) {
+        (a) = 42;
+        (((((b))))) = 23;
+        c = (((17)));
+        (((d))) = (13);
+    }
+}
+// ----
+// x() -> 17
+// f(uint256,uint256): 23, 42 -> 23, 42
+// x() -> 42
+// g() -> 3, 42, 1
+// h() -> 4, 42, 1
+// i() -> 42, 23, 17, 13
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/local_variable_without_init.sol b/compiler/test/libsolidity/semanticTests/viaYul/local_variable_without_init.sol
new file mode 100644
index 00000000..f1b2b174
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/local_variable_without_init.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (uint) {
+        uint x;
+        return x;
+    }
+}
+// ----
+// f() -> 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/loops/break.sol b/compiler/test/libsolidity/semanticTests/viaYul/loops/break.sol
new file mode 100644
index 00000000..77ecface
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/loops/break.sol
@@ -0,0 +1,29 @@
+contract C {
+    function f() public returns (uint x) {
+        x = 1;
+        for (uint a = 0; a < 10; a = a + 1) {
+            x = x + x;
+            break;
+        }
+    }
+    function g() public returns (uint x) {
+        x = 1;
+        uint a = 0;
+        while (a < 10) {
+            x = x + x;
+            break;
+            a = a + 1;
+        }
+    }
+    function h() public returns (uint x) {
+        x = 1;
+        do {
+            x = x + 1;
+            break;
+        } while (x < 3);
+    }
+}
+// ----
+// f() -> 2
+// g() -> 2
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/loops/continue.sol b/compiler/test/libsolidity/semanticTests/viaYul/loops/continue.sol
new file mode 100644
index 00000000..b9c3f167
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/loops/continue.sol
@@ -0,0 +1,35 @@
+contract C {
+    function f() public returns (uint x) {
+        x = 1;
+        uint a = 0;
+        for (; a < 10; a = a + 1) {
+            continue;
+            x = x + x;
+        }
+        x = x + a;
+    }
+    function g() public returns (uint x) {
+        x = 1;
+        uint a = 0;
+        while (a < 10) {
+            a = a + 1;
+            continue;
+            x = x + x;
+        }
+        x = x + a;
+    }
+    function h() public returns (uint x) {
+        x = 1;
+        uint a = 0;
+        do {
+            a = a + 1;
+            continue;
+            x = x + x;
+        } while (a < 4);
+        x = x + a;
+    }
+}
+// ----
+// f() -> 11
+// g() -> 11
+// h() -> 5
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/loops/return.sol b/compiler/test/libsolidity/semanticTests/viaYul/loops/return.sol
new file mode 100644
index 00000000..ee7062e7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/loops/return.sol
@@ -0,0 +1,32 @@
+contract C {
+    function f() public returns (uint x) {
+        x = 1;
+        uint a;
+        for (; a < 10; a = a + 1) {
+            return x;
+            x = x + x;
+        }
+        x = x + a;
+    }
+    function g() public returns (uint x) {
+        x = 1;
+        uint a;
+        while (a < 10) {
+            return x;
+            x = x + x;
+            a = a + 1;
+        }
+        x = x + a;
+    }
+    function h() public returns (uint x) {
+        x = 1;
+        do {
+            x = x + 1;
+            return x;
+        } while (x < 3);
+    }
+}
+// ----
+// f() -> 1
+// g() -> 1
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/loops/simple.sol b/compiler/test/libsolidity/semanticTests/viaYul/loops/simple.sol
new file mode 100644
index 00000000..a4d07632
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/loops/simple.sol
@@ -0,0 +1,37 @@
+contract C {
+    function f() public returns (uint x) {
+        x = 1;
+        for (uint a = 0; a < 10; a = a + 1) {
+            x = x + x;
+        }
+    }
+    function g() public returns (uint x) {
+        x = 1;
+        uint a = 0;
+        while (a < 10) {
+            x = x + x;
+            a = a + 1;
+        }
+    }
+    function h() public returns (uint x) {
+        x = 1;
+        do {
+            x = x + 1;
+        } while (false);
+    }
+    function i() public returns (uint x) {
+        x = 1;
+        do {
+            x = x + 1;
+        } while (x < 3);
+    }
+    function j() public {
+        for (;;) {break;}
+    }
+}
+// ----
+// f() -> 1024
+// g() -> 1024
+// h() -> 2
+// i() -> 3
+// j() ->
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/memory_struct_allow.sol b/compiler/test/libsolidity/semanticTests/viaYul/memory_struct_allow.sol
new file mode 100644
index 00000000..9f87c7b9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/memory_struct_allow.sol
@@ -0,0 +1,19 @@
+contract C {
+    struct S {
+        uint256 a;
+        uint256 b;
+    }
+
+    function f() public pure returns (uint256 a, uint256 b){
+        assembly {
+            // Make free memory dirty to check that the struct allocation cleans it up again.
+            let freeMem := mload(0x40)
+            mstore(freeMem, 42)
+            mstore(add(freeMem, 32), 42)
+        }
+        S memory s;
+        return (s.a, s.b);
+    }
+}
+// ----
+// f() -> 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/msg_sender.sol b/compiler/test/libsolidity/semanticTests/viaYul/msg_sender.sol
new file mode 100644
index 00000000..058f142f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/msg_sender.sol
@@ -0,0 +1,9 @@
+contract C {
+    function test() public view returns (bool) {
+        address x;
+        assembly { x := caller() }
+        return x == msg.sender;
+    }
+}
+// ----
+// test() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/require.sol b/compiler/test/libsolidity/semanticTests/viaYul/require.sol
new file mode 100644
index 00000000..39677b4f
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/require.sol
@@ -0,0 +1,43 @@
+contract C {
+	function f(bool a) public pure returns (bool x) {
+		bool b = a;
+		x = b;
+		require(b);
+	}
+	function fail() public pure returns (bool x) {
+		x = true;
+		require(false);
+	}
+	function succeed() public pure returns (bool x) {
+		x = true;
+		require(true);
+	}
+	function f2(bool a) public pure returns (bool x) {
+		x = a;
+		string memory message;
+		message = "fancy message!";
+		require(a, message);
+	}
+	function f3(bool a) public pure returns (bool x) {
+		x = a;
+		require(a, "msg");
+	}
+	function f4(bool a) public pure returns (bool x) {
+		x = a;
+		string memory message;
+		require(a, message);
+	}
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// f(bool): true -> true
+// f(bool): false -> FAILURE
+// fail() -> FAILURE
+// succeed() -> true
+// f2(bool): true -> true
+// f2(bool): false -> FAILURE, hex"08c379a0", 0x20, 14, "fancy message!"
+// f3(bool): true -> true
+// f3(bool): false -> FAILURE, hex"08c379a0", 0x20, 3, "msg"
+// f4(bool): true -> true
+// f4(bool): false -> FAILURE, hex"08c379a0", 0x20, 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/return.sol b/compiler/test/libsolidity/semanticTests/viaYul/return.sol
new file mode 100644
index 00000000..f58632b9
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/return.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (uint x) {
+        return 7;
+        x = 3;
+    }
+}
+// ----
+// f() -> 7
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/return_and_convert.sol b/compiler/test/libsolidity/semanticTests/viaYul/return_and_convert.sol
new file mode 100644
index 00000000..78e9e3be
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/return_and_convert.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (uint) {
+        uint8 b;
+        assembly { b := 0xffff }
+        return b;
+    }
+}
+// ----
+// f() -> 255
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/return_storage_pointers.sol b/compiler/test/libsolidity/semanticTests/viaYul/return_storage_pointers.sol
new file mode 100644
index 00000000..93605812
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/return_storage_pointers.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint[] arr1;
+	uint[][] arr2;
+	function f() internal returns (uint[] storage ptr1, uint[][] storage ptr2) {
+		ptr1 = arr1;
+		ptr2 = arr2;
+	}
+	function g() public returns (uint, uint) {
+		return (arr1.length, arr2.length);
+	}
+
+}
+// ----
+// g() -> 0, 0
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/short_circuit.sol b/compiler/test/libsolidity/semanticTests/viaYul/short_circuit.sol
new file mode 100644
index 00000000..b160bbd7
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/short_circuit.sol
@@ -0,0 +1,15 @@
+contract C {
+    function or(uint x) public returns (bool t, uint y) {
+        t = (x == 0 || ((x = 8) > 0));
+        y = x;
+    }
+    function and(uint x) public returns (bool t, uint y) {
+        t = (x == 0 && ((x = 8) > 0));
+        y = x;
+    }
+}
+// ----
+// or(uint256): 0 -> true, 0
+// and(uint256): 0 -> true, 8
+// or(uint256): 1 -> true, 8
+// and(uint256): 1 -> false, 1
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/simple_assignment.sol b/compiler/test/libsolidity/semanticTests/viaYul/simple_assignment.sol
new file mode 100644
index 00000000..ed0ba287
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/simple_assignment.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint x, uint y) {
+        x = a;
+        y = b;
+    }
+}
+// ----
+// f(uint256,uint256): 5, 6 -> 5, 6
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/simple_inline_asm.sol b/compiler/test/libsolidity/semanticTests/viaYul/simple_inline_asm.sol
new file mode 100644
index 00000000..8e8cd78e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/simple_inline_asm.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() public pure returns (uint32 x) {
+        uint32 a;
+        uint32 b;
+        uint32 c;
+        assembly {
+            a := 1
+            b := 2
+            c := 3
+        }
+        x = a + b + c;
+    }
+}
+// ----
+// f() -> 6
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/smoke_test.sol b/compiler/test/libsolidity/semanticTests/viaYul/smoke_test.sol
new file mode 100644
index 00000000..53a11869
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/smoke_test.sol
@@ -0,0 +1,6 @@
+contract C {
+}
+// ====
+// allowNonExistingFunctions: true
+// ----
+// f() -> FAILURE
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_bytes.sol b/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_bytes.sol
new file mode 100644
index 00000000..d1ec20db
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_bytes.sol
@@ -0,0 +1,16 @@
+contract C {
+    bytes b;
+    function f() public returns (bool correct) {
+        assembly {
+            sstore(b.slot, or("deadbeef", 0x08))
+        }
+        bytes1 s = b[3];
+        uint r;
+        assembly {
+            r := s
+        }
+        correct = r == (0x64 << 248);
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_static_array.sol b/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_static_array.sol
new file mode 100644
index 00000000..7c035f05
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/storage/dirty_storage_static_array.sol
@@ -0,0 +1,16 @@
+contract C {
+    uint8[1] s;
+    function f() public returns (bool correct) {
+        assembly {
+            sstore(s.slot, 257)
+        }
+        uint8 x = s[0];
+        uint r;
+        assembly {
+            r := x
+        }
+        correct = (s[0] == 0x01) && (r == 0x01);
+    }
+}
+// ----
+// f() -> true
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/storage/packed_storage.sol b/compiler/test/libsolidity/semanticTests/viaYul/storage/packed_storage.sol
new file mode 100644
index 00000000..5253a6a1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/storage/packed_storage.sol
@@ -0,0 +1,14 @@
+contract C {
+    uint16 x;
+    bytes1 y;
+    uint16 z;
+    function f(uint8 a) public returns (uint _x) {
+        x = a;
+        y = bytes1(uint8(x) + 1);
+        z = uint8(y) + 1;
+        x = z + 1;
+        _x = x;
+    }
+}
+// ----
+// f(uint8): 6 -> 9
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/storage/simple_storage.sol b/compiler/test/libsolidity/semanticTests/viaYul/storage/simple_storage.sol
new file mode 100644
index 00000000..03d7ed92
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/storage/simple_storage.sol
@@ -0,0 +1,15 @@
+contract C {
+    uint x;
+    uint y;
+    function setX(uint a) public returns (uint _x) {
+        x = a;
+        _x = x;
+    }
+    function setY(uint a) public returns (uint _y) {
+        y = a;
+        _y = y;
+    }
+}
+// ----
+// setX(uint256): 6 -> 6
+// setY(uint256): 2 -> 2
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/string_format.sol b/compiler/test/libsolidity/semanticTests/viaYul/string_format.sol
new file mode 100644
index 00000000..5869ea2e
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/string_format.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f1() external pure returns (string memory) { return "abcabc"; }
+	function f2() external pure returns (string memory) { return "abcabc`~12345677890- _=+!@#$%^&*()[{]}|;:',<.>?"; }
+	function g() external pure returns (bytes32) { return "abcabc"; }
+	function h() external pure returns (bytes4) { return 0xcafecafe; }
+}
+// ----
+// f1() -> 0x20, 6, left(0x616263616263)
+// f2() -> 32, 47, 44048183223289766195424279195050628400112610419087780792899004030957505095210, 18165586057823232067963737336409268114628061002662705707816940456850361417728
+// g() -> left(0x616263616263)
+// h() -> left(0xcafecafe)
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/string_literals.sol b/compiler/test/libsolidity/semanticTests/viaYul/string_literals.sol
new file mode 100644
index 00000000..985d2635
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/string_literals.sol
@@ -0,0 +1,27 @@
+contract C {
+    function short_dyn() public pure returns (string memory x) {
+        x = "abc";
+    }
+    function long_dyn() public pure returns (string memory x) {
+        x = "12345678901234567890123456789012345678901234567890123456789012345678901234567890";
+    }
+    function short_bytes_dyn() public pure returns (bytes memory x) {
+        x = "abc";
+    }
+    function long_bytes_dyn() public pure returns (bytes memory x) {
+        x = "12345678901234567890123456789012345678901234567890123456789012345678901234567890";
+    }
+    function bytesNN() public pure returns (bytes3 x) {
+        x = "abc";
+    }
+    function bytesNN_padded() public pure returns (bytes4 x) {
+        x = "abc";
+    }
+}
+// ----
+// short_dyn() -> 0x20, 3, "abc"
+// long_dyn() -> 0x20, 80, "12345678901234567890123456789012", "34567890123456789012345678901234", "5678901234567890"
+// short_bytes_dyn() -> 0x20, 3, "abc"
+// long_bytes_dyn() -> 0x20, 80, "12345678901234567890123456789012", "34567890123456789012345678901234", "5678901234567890"
+// bytesNN() -> 0x6162630000000000000000000000000000000000000000000000000000000000
+// bytesNN_padded() -> 0x6162630000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/tuple_evaluation_order.sol b/compiler/test/libsolidity/semanticTests/viaYul/tuple_evaluation_order.sol
new file mode 100644
index 00000000..e1a1689b
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/tuple_evaluation_order.sol
@@ -0,0 +1,12 @@
+contract C {
+    uint256 x;
+    uint256 y;
+    function set(uint256 v) public returns (uint256) { x = v; return v; }
+    function f() public returns (uint256, uint256) {
+       (y, y, y) = (set(1), set(2), set(3));
+       assert(y == 1 && x == 3);
+       return (x, y);
+    }
+}
+// ----
+// f() -> 3, 1
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/unary_fixedbytes.sol b/compiler/test/libsolidity/semanticTests/viaYul/unary_fixedbytes.sol
new file mode 100644
index 00000000..d8e64071
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/unary_fixedbytes.sol
@@ -0,0 +1,76 @@
+contract C {
+	function conv(bytes25 a) public pure returns (bytes32) {
+		// truncating and widening
+		return ~bytes32(bytes16(~a));
+	}
+
+	function upcast(bytes25 a) public pure returns (bytes32) {
+		// implicit widening is allowed
+		return ~a;
+	}
+
+	function downcast(bytes25 a) public pure returns (bytes12) {
+		// truncating cast must be explicit
+		return bytes12(~a);
+	}
+
+	function r_b32() public pure returns (bytes32) {
+		return ~bytes32(hex"ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00");
+	}
+	function r_b25() public pure returns (bytes25) {
+		return ~bytes25(hex"ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff");
+	}
+	function r_b16() public pure returns (bytes16) {
+		return ~bytes16(hex"ff00ff00ff00ff00ff00ff00ff00ff00");
+	}
+	function r_b8() public pure returns (bytes8) {
+		return ~bytes8(hex"ff00ff00ff00ff00");
+	}
+	function r_b4() public pure returns (bytes4) {
+		return ~bytes4(hex"ff00ff00");
+	}
+	function r_b1() public pure returns (bytes1) {
+		return ~bytes1(hex"55");
+	}
+
+	function a_b32() public pure returns (bytes32) {
+		bytes32 r = ~bytes32(hex"ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00");
+		return r;
+	}
+	function a_b25() public pure returns (bytes25) {
+		bytes25 r = ~bytes25(hex"ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff");
+		return r;
+	}
+	function a_b16() public pure returns (bytes16) {
+		bytes16 r =  ~bytes16(hex"ff00ff00ff00ff00ff00ff00ff00ff00");
+		return r;
+	}
+	function a_b8() public pure returns (bytes8) {
+		bytes8 r =  ~bytes8(hex"ff00ff00ff00ff00");
+		return r;
+	}
+	function a_b4() public pure returns (bytes4) {
+		bytes4 r =  ~bytes4(hex"ff00ff00");
+		return r;
+	}
+	function a_b1() public pure returns (bytes1) {
+		bytes1 r =  ~bytes1(hex"55");
+		return r;
+	}
+}
+// ----
+// conv(bytes25): left(0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff) -> 0xff00ff00ff00ff00ff00ff00ff00ff00ffffffffffffffffffffffffffffffff
+// upcast(bytes25): left(0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff) -> 0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff0000000000000000
+// downcast(bytes25): left(0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff) -> 0xff00ff00ff00ff00ff00ff0000000000000000000000000000000000000000
+// r_b32() -> 0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
+// r_b25() -> 0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff0000000000000000
+// r_b16() -> 0xff00ff00ff00ff00ff00ff00ff00ff00000000000000000000000000000000
+// r_b8() -> 0xff00ff00ff00ff000000000000000000000000000000000000000000000000
+// r_b4() -> 0xff00ff00000000000000000000000000000000000000000000000000000000
+// r_b1() -> 0xaa00000000000000000000000000000000000000000000000000000000000000
+// a_b32() -> 0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
+// a_b25() -> 0xff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff0000000000000000
+// a_b16() -> 0xff00ff00ff00ff00ff00ff00ff00ff00000000000000000000000000000000
+// a_b8() -> 0xff00ff00ff00ff000000000000000000000000000000000000000000000000
+// a_b4() -> 0xff00ff00000000000000000000000000000000000000000000000000000000
+// a_b1() -> 0xaa00000000000000000000000000000000000000000000000000000000000000
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/unary_operations.sol b/compiler/test/libsolidity/semanticTests/viaYul/unary_operations.sol
new file mode 100644
index 00000000..17d8dad0
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/unary_operations.sol
@@ -0,0 +1,136 @@
+contract C {
+	function preincr_u8(uint8 a) public pure returns (uint8) {
+		return ++a + a;
+	}
+	function postincr_u8(uint8 a) public pure returns (uint8) {
+		return a++ + a;
+	}
+	function predecr_u8(uint8 a) public pure returns (uint8) {
+		return --a + a;
+	}
+	function postdecr_u8(uint8 a) public pure returns (uint8) {
+		return a-- + a;
+	}
+	function preincr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {
+		ret1 = ++a;
+		ret2 = a;
+	}
+	function postincr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {
+		ret1 = a++;
+		ret2 = a;
+	}
+	function predecr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {
+		ret1 = --a;
+		ret2 = a;
+	}
+	function postdecr_s8(int8 a) public pure returns (int8 ret1, int8 ret2) {
+		ret1 = a--;
+		ret2 = a;
+	}
+	function preincr(uint a) public pure returns (uint) {
+		return ++a + a;
+	}
+	function postincr(uint a) public pure returns (uint) {
+		return a++ + a;
+	}
+	function predecr(uint a) public pure returns (uint) {
+		return --a + a;
+	}
+	function postdecr(uint a) public pure returns (uint) {
+		return a-- + a;
+	}
+	function not(bool a) public pure returns (bool)
+	{
+		return !a;
+	}
+	function bitnot(int256 a) public pure returns (int256)
+	{
+		return ~a;
+	}
+	function bitnot_u8(uint8 a) public pure returns (uint256 ret)
+	{
+		a = ~a;
+		assembly {
+			// Tests that the lower bit parts are cleaned up
+			ret := a
+		}
+	}
+	function bitnot_s8() public pure returns (int256 ret)
+	{
+		int8 a;
+		assembly {
+			a := 0x9C
+		}
+
+		a = ~a;
+
+		assembly {
+			// Tests that the lower bit parts are cleaned up
+			ret := a
+		}
+	}
+	function negate(int256 a) public pure returns (int256)
+	{
+		return -a;
+	}
+	function negate_s8(int8 a) public pure returns (int8)
+	{
+		return -a;
+	}
+	function negate_s16(int16 a) public pure returns (int16)
+	{
+		return -a;
+	}
+}
+// ====
+// compileViaYul: true
+// ----
+// preincr_s8(int8): 128 -> FAILURE
+// postincr_s8(int8): 128 -> FAILURE
+// preincr_s8(int8): 127 -> FAILURE, hex"4e487b71", 0x11
+// postincr_s8(int8): 127 -> FAILURE, hex"4e487b71", 0x11
+// preincr_s8(int8): 126 -> 127, 127
+// postincr_s8(int8): 126 -> 126, 127
+// predecr_s8(int8): -128 -> FAILURE, hex"4e487b71", 0x11
+// postdecr_s8(int8): -128 -> FAILURE, hex"4e487b71", 0x11
+// predecr_s8(int8): -127 -> -128, -128
+// postdecr_s8(int8): -127 -> -127, -128
+// preincr_s8(int8): -5 -> -4, -4
+// postincr_s8(int8): -5 -> -5, -4
+// predecr_s8(int8): -5 -> -6, -6
+// postdecr_s8(int8): -5 -> -5, -6
+// preincr_u8(uint8): 255 -> FAILURE, hex"4e487b71", 0x11
+// postincr_u8(uint8): 255 -> FAILURE, hex"4e487b71", 0x11
+// preincr_u8(uint8): 254 -> FAILURE, hex"4e487b71", 0x11
+// postincr_u8(uint8): 254 -> FAILURE, hex"4e487b71", 0x11
+// predecr_u8(uint8): 0 -> FAILURE, hex"4e487b71", 0x11
+// postdecr_u8(uint8): 0 -> FAILURE, hex"4e487b71", 0x11
+// predecr_u8(uint8): 1 -> 0
+// postdecr_u8(uint8): 1 -> 1
+// preincr_u8(uint8): 2 -> 6
+// postincr_u8(uint8): 2 -> 5
+// predecr_u8(uint8): 2 -> 2
+// postdecr_u8(uint8): 2 -> 3
+// preincr(uint256): 2 -> 6
+// postincr(uint256): 2 -> 5
+// predecr(uint256): 2 -> 2
+// postdecr(uint256): 2 -> 3
+// not(bool): true -> false
+// not(bool): false -> true
+// bitnot(int256): 5 -> -6
+// bitnot(int256): 10 -> -11
+// bitnot(int256): 0 -> -1
+// bitnot(int256): -100 -> 99
+// bitnot_u8(uint8): 100 -> 155
+// bitnot_s8() -> 99
+// negate(int256): -57896044618658097711785492504343953926634992332820282019728792003956564819968 -> FAILURE, hex"4e487b71", 0x11
+// negate(int256): -57896044618658097711785492504343953926634992332820282019728792003956564819967 -> 57896044618658097711785492504343953926634992332820282019728792003956564819967
+// negate(int256): 0 -> 0
+// negate(int256): 1 -> -1
+// negate(int256): -1 -> 1
+// negate_s8(int8): -128 -> FAILURE, hex"4e487b71", 0x11
+// negate_s8(int8): -138 -> FAILURE
+// negate_s8(int8): -127 -> 127
+// negate_s8(int8): 127 -> -127
+// negate_s16(int16): -32768 -> FAILURE, hex"4e487b71", 0x11
+// negate_s16(int16): -32767 -> 32767
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/various_inline_asm.sol b/compiler/test/libsolidity/semanticTests/viaYul/various_inline_asm.sol
new file mode 100644
index 00000000..b440d8e1
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/various_inline_asm.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public pure returns (uint32 x) {
+        uint32 a;
+        uint32 b;
+        uint32 c;
+        assembly {
+            function myAwesomeFunction(param) -> returnMe {
+                let localVar := 10
+                returnMe := add(localVar, param)
+            }
+            let abc := sub(10, a)
+            let xyz := 20
+            a := abc
+            b := myAwesomeFunction(30)
+            c := xyz
+        }
+        x = a + b + c;
+    }
+}
+// ----
+// f() -> 70
diff --git a/compiler/test/libsolidity/semanticTests/viaYul/virtual_functions.sol b/compiler/test/libsolidity/semanticTests/viaYul/virtual_functions.sol
new file mode 100644
index 00000000..798f90ff
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/viaYul/virtual_functions.sol
@@ -0,0 +1,30 @@
+contract X {
+    function f() public returns (uint x) {
+        x = g();
+    }
+    function g() public virtual returns (uint x) {
+        x = 2;
+    }
+}
+contract C is X {
+    function f1() public returns (uint x) {
+        // direct call
+        x = g();
+    }
+    function f2() public returns (uint x) {
+        // call via base
+        x = f();
+    }
+    function f3() public returns (uint x) {
+        // explicit call via base
+        //x = super.g();
+    }
+    function g() public override returns (uint x) {
+        x = 3;
+    }
+}
+// ----
+// f() -> 3
+// f1() -> 3
+// f2() -> 3
+// g() -> 3
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls.sol
new file mode 100644
index 00000000..28705ee4
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls.sol
@@ -0,0 +1,18 @@
+contract Base {
+    function f() public returns (uint256 i) {
+        return g();
+    }
+
+    function g() internal virtual returns (uint256 i) {
+        return 1;
+    }
+}
+
+
+contract Derived is Base {
+    function g() internal override returns (uint256 i) {
+        return 2;
+    }
+}
+// ----
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls_through_dispatch.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls_through_dispatch.sol
new file mode 100644
index 00000000..d8334304
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/internal_virtual_function_calls_through_dispatch.sol
@@ -0,0 +1,23 @@
+contract Base {
+    function f() internal returns (uint256 i) {
+        function() internal returns (uint256) ptr = g;
+        return ptr();
+    }
+
+    function g() internal virtual returns (uint256 i) {
+        return 1;
+    }
+}
+
+
+contract Derived is Base {
+    function g() internal override returns (uint256 i) {
+        return 2;
+    }
+
+    function h() public returns (uint256 i) {
+        return f();
+    }
+}
+// ----
+// h() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_calls.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_calls.sol
new file mode 100644
index 00000000..ea543a78
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_calls.sol
@@ -0,0 +1,19 @@
+contract Base {
+    function f() public returns (uint256 i) {
+        return g();
+    }
+
+    function g() public virtual returns (uint256 i) {
+        return 1;
+    }
+}
+
+
+contract Derived is Base {
+    function g() public override returns (uint256 i) {
+        return 2;
+    }
+}
+// ----
+// g() -> 2
+// f() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_usage_in_constructor_arguments.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_usage_in_constructor_arguments.sol
new file mode 100644
index 00000000..55a50a5c
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_function_usage_in_constructor_arguments.sol
@@ -0,0 +1,31 @@
+contract BaseBase {
+    uint256 m_a;
+
+    constructor(uint256 a) {
+        m_a = a;
+    }
+
+    function overridden() public virtual returns (uint256 r) {
+        return 1;
+    }
+
+    function g() public returns (uint256 r) {
+        return overridden();
+    }
+}
+
+
+contract Base is BaseBase(BaseBase.g()) {}
+
+
+contract Derived is Base {
+    function getA() public returns (uint256 r) {
+        return m_a;
+    }
+
+    function overridden() public override returns (uint256 r) {
+        return 2;
+    }
+}
+// ----
+// getA() -> 2
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_internal.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_internal.sol
new file mode 100644
index 00000000..cee1bcdd
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_internal.sol
@@ -0,0 +1,23 @@
+contract A {
+    function f() internal virtual {
+        mutableWithViewOverride();
+        mutableWithPureOverride();
+        viewWithPureOverride();
+    }
+
+    function mutableWithViewOverride() internal virtual {}
+    function mutableWithPureOverride() internal virtual {}
+    function viewWithPureOverride() internal view virtual {}
+}
+
+contract C is A {
+    function run() public {
+        f();
+    }
+
+    function mutableWithViewOverride() internal view override {}
+    function mutableWithPureOverride() internal pure override {}
+    function viewWithPureOverride() internal pure override {}
+}
+// ----
+// run() ->
diff --git a/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_public.sol b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_public.sol
new file mode 100644
index 00000000..c3d9e60a
--- /dev/null
+++ b/compiler/test/libsolidity/semanticTests/virtualFunctions/virtual_override_changing_mutability_public.sol
@@ -0,0 +1,23 @@
+contract A {
+    function f() internal virtual {
+        mutableWithViewOverride();
+        mutableWithPureOverride();
+        viewWithPureOverride();
+    }
+
+    function mutableWithViewOverride() public virtual {}
+    function mutableWithPureOverride() public virtual {}
+    function viewWithPureOverride() public view virtual {}
+}
+
+contract C is A {
+    function run() public {
+        f();
+    }
+
+    function mutableWithViewOverride() public view override {}
+    function mutableWithPureOverride() public pure override {}
+    function viewWithPureOverride() public pure override {}
+}
+// ----
+// run() ->
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_array.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_array.sol
new file mode 100644
index 00000000..da30d302
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_array.sol
@@ -0,0 +1,45 @@
+pragma abicoder v2;
+
+contract C {
+	function abiDecodeArray(bytes memory b1, bytes memory b2) public pure {
+		(uint[] memory a, uint[] memory b) = abi.decode(b1, (uint[], uint[]));
+		assert(a.length == b.length); // should fail
+
+		(uint[] memory c, uint[] memory d) = abi.decode(b1, (uint[], uint[]));
+		assert(a.length == c.length);
+		assert(a.length == d.length); // should fail
+		assert(b.length == d.length);
+		assert(b.length == c.length); // should fail
+
+		(uint[] memory e, uint[] memory f, uint[] memory g) = abi.decode(b1, (uint[], uint[], uint[]));
+		assert(e.length == a.length); // should fail
+		assert(f.length == b.length); // should fail
+		assert(e.length == g.length); // should fail
+
+		(uint[][] memory h, uint[][][] memory i, uint j) = abi.decode(b1, (uint[][], uint[][][], uint));
+		require(j < h.length);
+		require(j < i.length);
+		require(j < i[j].length);
+		assert(h[j].length == i[j][j].length); // should fail
+
+		(uint[] memory k, uint[] memory l) = abi.decode(b2, (uint[], uint[]));
+		assert(k.length == a.length); // should fail
+		assert(k.length == l.length); // should fail
+		assert(l.length == b.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (182-210): CHC: Assertion violation happens here.
+// Warning 6328: (335-363): CHC: Assertion violation happens here.
+// Warning 6328: (414-442): CHC: Assertion violation happens here.
+// Warning 6328: (560-588): CHC: Assertion violation happens here.
+// Warning 6328: (607-635): CHC: Assertion violation happens here.
+// Warning 6328: (654-682): CHC: Assertion violation happens here.
+// Warning 6328: (879-916): CHC: Assertion violation happens here.
+// Warning 6328: (1009-1037): CHC: Assertion violation happens here.
+// Warning 6328: (1056-1084): CHC: Assertion violation happens here.
+// Warning 6328: (1103-1131): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_simple.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_simple.sol
new file mode 100644
index 00000000..76c2ec2e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_decode_simple.sol
@@ -0,0 +1,31 @@
+contract C {
+	function abiDecodeSimple(bytes memory b1, bytes memory b2) public pure {
+		(uint x, uint y) = abi.decode(b1, (uint, uint));
+		(uint z, uint w) = abi.decode(b1, (uint, uint));
+		assert(x == z);
+		assert(x == y); // should fail
+		assert(y == w);
+		assert(z == w); // should fail
+
+		(uint a, uint b, bool c) = abi.decode(b1, (uint, uint, bool));
+		assert(a == x); // should fail
+		assert(b == y); // should fail
+		assert(c); // should fail
+
+		(uint k, uint l) = abi.decode(b2, (uint, uint));
+		assert(k == x); // should fail
+		assert(l == y); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (209-223): CHC: Assertion violation happens here.
+// Warning 6328: (260-274): CHC: Assertion violation happens here.
+// Warning 6328: (359-373): CHC: Assertion violation happens here.
+// Warning 6328: (392-406): CHC: Assertion violation happens here.
+// Warning 6328: (425-434): CHC: Assertion violation happens here.
+// Warning 6328: (505-519): CHC: Assertion violation happens here.
+// Warning 6328: (538-552): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_1.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_1.sol
new file mode 100644
index 00000000..db29d511
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_1.sol
@@ -0,0 +1,23 @@
+contract C {
+	function callMeMaybe(uint a, uint b) external {}
+
+	function abiEncodeSimple(uint x, uint y, uint z) public view {
+		require(x == y);
+		function (uint, uint) external f = this.callMeMaybe;
+		bytes memory b1 = abi.encodeCall(f, (x, z));
+		bytes memory b2 = abi.encodeCall(f, (y, z));
+		assert(b1.length == b2.length); // should hold
+		assert(b1[0] == b2[0]); // should hold
+
+		bytes memory b3 = abi.encodeCall(this.callMeMaybe, (3, z));
+		assert(b1.length == b3.length); // should hold, but we don't encode the length computation precisely
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (354-359): CHC: Out of bounds access happens here.
+// Warning 6368: (363-368): CHC: Out of bounds access happens here.
+// Warning 6328: (451-481): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_2.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_2.sol
new file mode 100644
index 00000000..2ce3d625
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	function callMeMaybe(uint a, uint b) external {}
+
+	function abiEncodeSimple(uint x, uint y, uint z) public view {
+		require(x == y);
+		bytes memory b1 = abi.encodeCall(this.callMeMaybe, (x, z));
+		bytes memory b2 = abi.encodeCall(this.callMeMaybe, (y, z));
+		assert(b1.length == b2.length); // should hold
+		assert(b1[0] == b2[0]); // should hold
+
+		bytes memory b3 = abi.encodeCall(this.callMeMaybe, (3, z));
+		assert(b1.length == b3.length); // should hold but we don't compute the length precisely
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (329-334): CHC: Out of bounds access happens here.
+// Warning 6368: (338-343): CHC: Out of bounds access happens here.
+// Warning 6328: (426-456): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_3.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_3.sol
new file mode 100644
index 00000000..691493b5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_3.sol
@@ -0,0 +1,22 @@
+contract C {
+	function callMeMaybe(uint a, uint b) external {}
+
+	function abiEncodeSimple(uint x, uint y, uint z) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encodeCall(C.callMeMaybe, (x, z));
+		bytes memory b2 = abi.encodeCall(C.callMeMaybe, (y, z));
+		assert(b1.length == b2.length); // should hold
+		assert(b1[0] == b2[0]); // should hold
+
+		bytes memory b3 = abi.encodeCall(C.callMeMaybe, (3, z));
+		assert(b1.length == b3.length); // should hold but we don't compute the length precisely
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (323-328): CHC: Out of bounds access happens here.
+// Warning 6368: (332-337): CHC: Out of bounds access happens here.
+// Warning 6328: (417-447): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_4.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_4.sol
new file mode 100644
index 00000000..358f4955
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_4.sol
@@ -0,0 +1,26 @@
+abstract contract D {
+	function no(uint a, uint b) external virtual;
+}
+
+contract C {
+	function callMeMaybe(uint a, uint b) external {}
+
+	function abiEncodeSimple(uint x, uint y, uint z) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encodeCall(D.no, (x, z));
+		bytes memory b2 = abi.encodeCall(D.no, (y, z));
+		assert(b1.length == b2.length); // should hold
+		assert(b1[0] == b2[0]); // should hold
+
+		bytes memory b3 = abi.encodeCall(D.no, (3, z));
+		assert(b1.length == b3.length); // should hold but we don't compute the length precisely
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (377-382): CHC: Out of bounds access happens here.
+// Warning 6368: (386-391): CHC: Out of bounds access happens here.
+// Warning 6328: (462-492): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_5.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_5.sol
new file mode 100644
index 00000000..21173a70
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_call_simple_5.sol
@@ -0,0 +1,26 @@
+abstract contract D {
+	function no(uint a, uint b) external virtual;
+}
+
+contract C {
+	function callMeMaybe(uint a, uint b) external {}
+
+	function abiEncodeSimple(D d, uint x, uint y, uint z) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encodeCall(d.no, (x, z));
+		bytes memory b2 = abi.encodeCall(d.no, (y, z));
+		assert(b1.length == b2.length); // should hold
+		assert(b1[0] == b2[0]); // should hold
+
+		bytes memory b3 = abi.encodeCall(d.no, (3, z));
+		assert(b1.length == b3.length); // should hold but we don't compute the length precisely
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (382-387): CHC: Out of bounds access happens here.
+// Warning 6368: (391-396): CHC: Out of bounds access happens here.
+// Warning 6328: (467-497): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_function.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_function.sol
new file mode 100644
index 00000000..2bce234d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_function.sol
@@ -0,0 +1,8 @@
+contract C {
+	function f() public view {
+		abi.encode(this.f);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_hash.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_hash.sol
new file mode 100644
index 00000000..6260ebde
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_hash.sol
@@ -0,0 +1,12 @@
+contract C {
+	function abiEncodeHash(uint a, uint b) public pure {
+		require(a == b);
+		bytes memory b1 = abi.encode(a, a, a, a);
+		bytes memory b2 = abi.encode(b, a, b, a);
+		assert(keccak256(b1) == keccak256(b2));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_no_arguments.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_no_arguments.sol
new file mode 100644
index 00000000..2d4c8119
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_no_arguments.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() pure public {
+		bytes memory res = abi.encode();
+		assert(res.length == 0); // should hold
+		assert(res.length > 0); // should fail
+		res = abi.encodePacked();
+		assert(res.length == 0); // should hold
+		assert(res.length > 0); // should fail
+		res = abi.encodeWithSelector(0);
+		assert(res.length == 4); // should hold, but SMTChecker cannot know this yet
+		res = abi.encodeWithSignature("");
+		assert(res.length == 4); // should hold, but SMTChecker cannot know this yet
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (120-142): CHC: Assertion violation happens here.
+// Warning 6328: (231-253): CHC: Assertion violation happens here.
+// Warning 6328: (307-330): CHC: Assertion violation happens here.
+// Warning 6328: (423-446): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_hash.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_hash.sol
new file mode 100644
index 00000000..dc886246
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_hash.sol
@@ -0,0 +1,17 @@
+contract C {
+	function abiencodePackedHash(uint a, uint b) public pure {
+		require(a == b);
+		bytes memory b1 = abi.encodePacked(a, a, a, a);
+		bytes memory b2 = abi.encodePacked(b, a, b, a);
+		assert(keccak256(b1) == keccak256(b2));
+
+		bytes memory b3 = abi.encode(a, a, a, a);
+		assert(keccak256(b1) == keccak256(b3)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (281-319): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_simple.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_simple.sol
new file mode 100644
index 00000000..50d474a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_simple.sol
@@ -0,0 +1,30 @@
+contract C {
+	function abiencodePackedSimple(bool t, uint x, uint y, uint z, uint[] memory a, uint[] memory b) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encodePacked(x, z, a);
+		bytes memory b2 = abi.encodePacked(y, z, a);
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encodePacked(y, z, b);
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodePacked(t, z, a);
+		assert(b1.length == b4.length); // should fail
+
+		bytes memory b5 = abi.encodePacked(y, y, y, y, a, a, a);
+		assert(b1.length != b5.length); // should fail
+		assert(b1.length == b5.length); // should fail
+
+		// Commented out because of nondeterminism in Spacer in Z3 4.8.9
+		//bytes memory b6 = abi.encode(x, z, a);
+		//assert(b1.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (322-352): CHC: Assertion violation happens here.
+// Warning 6328: (419-449): CHC: Assertion violation happens here.
+// Warning 6328: (528-558): CHC: Assertion violation happens here.
+// Warning 6328: (577-607): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal.sol
new file mode 100644
index 00000000..08c48cbd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal.sol
@@ -0,0 +1,30 @@
+contract C {
+	function abiencodePackedStringLiteral() public pure {
+		bytes memory b1 = abi.encodePacked("");
+		bytes memory b2 = abi.encodePacked("");
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encodePacked(bytes(""));
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodePacked(bytes24(""));
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b4.length);
+
+		bytes memory b5 = abi.encodePacked(string(""));
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encode("");
+		assert(b1.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (226-256): CHC: Assertion violation happens here.\nCounterexample:\n\nb1 = [0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42]\nb3 = []\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (310-340): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72]\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (483-513): CHC: Assertion violation happens here.\nCounterexample:\n\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (568-598): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc]\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (654-684): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = [0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a]\nb6 = [0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117]\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal_no_unproved.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal_no_unproved.sol
new file mode 100644
index 00000000..f8002762
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_packed_string_literal_no_unproved.sol
@@ -0,0 +1,31 @@
+contract C {
+	function abiencodePackedStringLiteral() public pure {
+		bytes memory b1 = abi.encodePacked("");
+		bytes memory b2 = abi.encodePacked("");
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encodePacked(bytes(""));
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodePacked(bytes24(""));
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b4.length);
+
+		bytes memory b5 = abi.encodePacked(string(""));
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encode("");
+		assert(b1.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTShowUnproved: no
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (226-256): CHC: Assertion violation happens here.\nCounterexample:\n\nb1 = [0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42]\nb3 = []\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (310-340): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72]\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (483-513): CHC: Assertion violation happens here.\nCounterexample:\n\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (568-598): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc]\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
+// Warning 6328: (654-684): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = [0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a, 0x011a]\nb6 = [0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117]\n\nTransaction trace:\nC.constructor()\nC.abiencodePackedStringLiteral()
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_simple.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_simple.sol
new file mode 100644
index 00000000..bf3bd61b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_simple.sol
@@ -0,0 +1,27 @@
+contract C {
+	function abiEncodeSimple(bool t, uint x, uint y, uint z, uint[] memory a, uint[] memory b) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encode(x, z, a);
+		bytes memory b2 = abi.encode(y, z, a);
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encode(y, z, b);
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encode(t, z, a);
+		assert(b1.length == b4.length); // should fail
+
+		bytes memory b5 = abi.encode(y, y, y, y, a, a, a);
+		assert(b1.length != b5.length); // should fail
+		// Disabled because of nondeterminism in Spacer Z3 4.8.9
+		//assert(b1.length == b5.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (298-328): CHC: Assertion violation happens here.
+// Warning 6328: (389-419): CHC: Assertion violation happens here.
+// Warning 6328: (492-522): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_string_literal.sol
new file mode 100644
index 00000000..b55952ee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_string_literal.sol
@@ -0,0 +1,26 @@
+contract C {
+	function abiEncodeStringLiteral() public pure {
+		bytes memory b1 = abi.encode("");
+		bytes memory b2 = abi.encode("");
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encode(bytes(""));
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encode(bytes24(""));
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b4.length);
+
+		bytes memory b5 = abi.encode(string(""));
+		assert(b1.length == b5.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (208-238): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = []\nb4 = []\nb5 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral()
+// Warning 6328: (286-316): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d]\nb3 = [0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d]\nb4 = []\nb5 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral()
+// Warning 6328: (453-483): CHC: Assertion violation happens here.\nCounterexample:\n\nb5 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral()
+// Warning 6328: (532-562): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = [0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca]\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral()
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice.sol
new file mode 100644
index 00000000..67c8b92e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice.sol
@@ -0,0 +1,33 @@
+contract C {
+	function abiEncodeSlice(bytes4 sel, bytes calldata data) external pure {
+		bytes memory b1 = abi.encodeWithSelector(sel, data);
+		bytes memory b2 = abi.encodeWithSelector(sel, data[0:]);
+		// should hold but the engine cannot infer that data is fully equals data[0:] because each index is assigned separately
+		assert(b1.length == b2.length); // fails for now
+
+		bytes memory b3 = abi.encodeWithSelector(sel, data[:data.length]);
+		// should hold but the engine cannot infer that data is fully equals data[:data.length] because each index is assigned separately
+		assert(b1.length == b3.length); // fails for now
+
+		bytes memory b4 = abi.encodeWithSelector(sel, data[5:10]);
+		assert(b1.length == b4.length); // should fail
+
+		uint x = 5;
+		uint y = 10;
+		bytes memory b5 = abi.encodeWithSelector(sel, data[x:y]);
+		// should hold but the engine cannot infer that data[5:10] is fully equals data[x:y] because each index is assigned separately
+		assert(b1.length == b5.length); // fails for now
+
+		bytes memory b6 = abi.encodeWithSelector(0xcafecafe, data[5:10]);
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (325-355): CHC: Assertion violation happens here.
+// Warning 6328: (578-608): CHC: Assertion violation happens here.
+// Warning 6328: (1079-1109): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (1079-1109): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice_2.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice_2.sol
new file mode 100644
index 00000000..69a3482b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_array_slice_2.sol
@@ -0,0 +1,33 @@
+contract C {
+	function abiEncodeSlice(bytes4 sel, uint[] calldata data) external pure {
+		bytes memory b1 = abi.encodeWithSelector(sel, data);
+		bytes memory b2 = abi.encodeWithSelector(sel, data[0:]);
+		// should hold but the engine cannot infer that data is fully equals data[0:] because each index is assigned separately
+		assert(b1.length == b2.length); // fails for now
+
+		bytes memory b3 = abi.encodeWithSelector(sel, data[:data.length]);
+		// should hold but the engine cannot infer that data is fully equals data[:data.length] because each index is assigned separately
+		assert(b1.length == b3.length); // fails for now
+
+		bytes memory b4 = abi.encodeWithSelector(sel, data[5:10]);
+		assert(b1.length == b4.length); // should fail
+
+		uint x = 5;
+		uint y = 10;
+		bytes memory b5 = abi.encodeWithSelector(sel, data[x:y]);
+		// should hold but the engine cannot infer that data[5:10] is fully equals data[x:y] because each index is assigned separately
+		assert(b1.length == b5.length); // fails for now
+
+		bytes memory b6 = abi.encodeWithSelector(0xcafecafe, data[5:10]);
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (326-356): CHC: Assertion violation happens here.
+// Warning 6328: (579-609): CHC: Assertion violation happens here.
+// Warning 6328: (1080-1110): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (1080-1110): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_simple.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_simple.sol
new file mode 100644
index 00000000..07090e1e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_simple.sol
@@ -0,0 +1,32 @@
+contract C {
+	function abiEncodeSimple(bytes4 sel, bool t, uint x, uint y, uint z, uint[] memory a, uint[] memory b) public pure {
+		require(x == y);
+		// Disabled because of Spacer nondeterminism
+		bytes memory b1 = abi.encodeWithSelector(sel, x, z, a);
+		//bytes memory b2 = abi.encodeWithSelector(sel, y, z, a);
+		//assert(b1.length == b2.length);
+
+		// Disabled because of Spacer nondeterminism
+		//bytes memory b3 = abi.encodeWithSelector(sel, y, z, b);
+		//assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodeWithSelector(sel, t, z, a);
+		assert(b1.length == b4.length); // should fail
+
+		bytes memory b5 = abi.encodeWithSelector(sel, y, y, y, y, a, a, a);
+		assert(b1.length != b5.length); // should fail
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encodeWithSelector(0xcafecafe, x, z, a);
+		assert(b1.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 5667: (100-115): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (571-601): CHC: Assertion violation happens here.
+// Warning 6328: (691-721): CHC: Assertion violation happens here.
+// Warning 6328: (740-770): CHC: Assertion violation happens here.
+// Warning 6328: (855-885): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal.sol
new file mode 100644
index 00000000..6d1ab306
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal.sol
@@ -0,0 +1,30 @@
+contract C {
+	function abiEncodeStringLiteral(bytes4 sel) public pure {
+		bytes memory b1 = abi.encodeWithSelector(sel, "");
+		bytes memory b2 = abi.encodeWithSelector(sel, "");
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encodeWithSelector(sel, bytes(""));
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodeWithSelector(sel, bytes24(""));
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b4.length);
+
+		bytes memory b5 = abi.encodeWithSelector(sel, string(""));
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encodeWithSelector(0xcafecafe, bytes24(""));
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (252-282): CHC: Assertion violation happens here.\nCounterexample:\n\nsel = 0x0\nb1 = [0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46]\nb3 = []\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(0x0)
+// Warning 6328: (347-377): CHC: Assertion violation happens here.\nCounterexample:\n\nsel = 0x0\nb3 = [0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d]\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(0x0)
+// Warning 6328: (531-561): CHC: Assertion violation happens here.\nCounterexample:\n\nsel = 0x0\nb1 = [0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90]\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(0x0)
+// Warning 6328: (627-657): CHC: Assertion violation happens here.\nCounterexample:\n\nsel = 0x0\nb5 = [0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1]\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(0x0)
+// Warning 6328: (746-776): CHC: Assertion violation happens here.\nCounterexample:\n\nsel = 0x0\nb2 = []\nb5 = [0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2]\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(0x0)
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal_2.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal_2.sol
new file mode 100644
index 00000000..6737700b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_string_literal_2.sol
@@ -0,0 +1,12 @@
+contract C {
+	function abiEncodeStringLiteral(bytes4 sel) public pure {
+		bytes memory b1 = abi.encodeWithSelector("");
+		require(sel == "");
+		bytes memory b2 = abi.encodeWithSelector(sel);
+		assert(b1.length == b2.length); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_vs_sig.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_vs_sig.sol
new file mode 100644
index 00000000..4b4f7a3a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_selector_vs_sig.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(string memory sig, uint x, uint[] memory a) public pure {
+		bytes memory b1 = abi.encodeWithSignature(sig, x, a);
+		bytes memory b2 = abi.encodeWithSelector(bytes4(keccak256(bytes(sig))), x, a);
+		// should hold but we do not evaluate keccak256 in an interpreted way
+		//assert(b1.length == b2.length);
+		assert(b1.length != b2.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (330-360): CHC: Assertion violation might happen here.
+// Warning 7812: (330-360): BMC: Assertion violation might happen here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice.sol
new file mode 100644
index 00000000..fad74374
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice.sol
@@ -0,0 +1,33 @@
+contract C {
+	function abiEncodeSlice(string memory sig, bytes calldata data) external pure {
+		bytes memory b1 = abi.encodeWithSignature(sig, data);
+		bytes memory b2 = abi.encodeWithSignature(sig, data[0:]);
+		// should hold but the engine cannot infer that data is fully equals data[0:] because each index is assigned separately
+		assert(b1.length == b2.length); // fails for now
+
+		bytes memory b3 = abi.encodeWithSignature(sig, data[:data.length]);
+		// should hold but the engine cannot infer that data is fully equals data[:data.length] because each index is assigned separately
+		assert(b1.length == b3.length); // fails for now
+
+		bytes memory b4 = abi.encodeWithSignature(sig, data[5:10]);
+		assert(b1.length == b4.length); // should fail
+
+		uint x = 5;
+		uint y = 10;
+		bytes memory b5 = abi.encodeWithSignature(sig, data[x:y]);
+		// should hold but the engine cannot infer that data[5:10] is fully equals data[x:y] because each index is assigned separately
+		assert(b1.length == b5.length); // fails for now
+
+		bytes memory b6 = abi.encodeWithSelector("f()", data[5:10]);
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (334-364): CHC: Assertion violation happens here.
+// Warning 6328: (588-618): CHC: Assertion violation happens here.
+// Warning 6328: (1086-1116): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (1086-1116): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice_2.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice_2.sol
new file mode 100644
index 00000000..41e71ee5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_array_slice_2.sol
@@ -0,0 +1,33 @@
+contract C {
+	function abiEncodeSlice(string memory sig, uint[] calldata data) external pure {
+		bytes memory b1 = abi.encodeWithSignature(sig, data);
+		bytes memory b2 = abi.encodeWithSignature(sig, data[0:]);
+		// should hold but the engine cannot infer that data is fully equals data[0:] because each index is assigned separately
+		assert(b1.length == b2.length); // fails for now
+
+		bytes memory b3 = abi.encodeWithSignature(sig, data[:data.length]);
+		// should hold but the engine cannot infer that data is fully equals data[:data.length] because each index is assigned separately
+		assert(b1.length == b3.length); // fails for now
+
+		bytes memory b4 = abi.encodeWithSignature(sig, data[5:10]);
+		assert(b1.length == b4.length); // should fail
+
+		uint x = 5;
+		uint y = 10;
+		bytes memory b5 = abi.encodeWithSignature(sig, data[x:y]);
+		// should hold but the engine cannot infer that data[5:10] is fully equals data[x:y] because each index is assigned separately
+		assert(b1.length == b5.length); // fails for now
+
+		bytes memory b6 = abi.encodeWithSelector("f()", data[5:10]);
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (335-365): CHC: Assertion violation happens here.
+// Warning 6328: (589-619): CHC: Assertion violation happens here.
+// Warning 6328: (1087-1117): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (1087-1117): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_hash.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_hash.sol
new file mode 100644
index 00000000..fbcaa160
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_hash.sol
@@ -0,0 +1,19 @@
+contract C {
+	function abiEncodeHash(string memory sig, uint a, uint b) public pure {
+		require(a == b);
+		bytes memory b1 = abi.encodeWithSignature(sig, a, a, a, a);
+		bytes memory b2 = abi.encodeWithSignature(sig, b, a, b, a);
+		assert(keccak256(b1) == keccak256(b2));
+
+		bytes memory b3 = abi.encodeWithSelector("f()", a, a, a, a);
+		assert(keccak256(b1) == keccak256(b3)); // should fail
+		assert(keccak256(b1) != keccak256(b3)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (337-375): CHC: Assertion violation happens here.
+// Warning 6328: (394-432): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_simple.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_simple.sol
new file mode 100644
index 00000000..bd0f8a33
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_simple.sol
@@ -0,0 +1,32 @@
+contract C {
+	function abiEncodeSimple(string memory sig, bool t, uint x, uint y, uint z, uint[] memory a, uint[] memory b) public pure {
+		require(x == y);
+		bytes memory b1 = abi.encodeWithSignature(sig, x, z, a);
+		bytes memory b2 = abi.encodeWithSignature(sig, y, z, a);
+		assert(b1.length == b2.length);
+
+		// Disabled because of nondeterminism in Spacer Z3 4.8.9
+		//bytes memory b3 = abi.encodeWithSignature(sig, y, z, b);
+		//assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodeWithSignature(sig, t, z, a);
+		assert(b1.length == b4.length); // should fail
+
+		bytes memory b5 = abi.encodeWithSignature(sig, y, y, y, y, a, a, a);
+		assert(b1.length != b5.length); // should fail
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encodeWithSignature("f()", x, z, a);
+		assert(b1.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 5667: (107-122): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (543-573): CHC: Assertion violation happens here.
+// Warning 6328: (664-694): CHC: Assertion violation happens here.
+// Warning 6328: (713-743): CHC: Assertion violation happens here.
+// Warning 6328: (824-854): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_string_literal.sol
new file mode 100644
index 00000000..de218cfa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/abi/abi_encode_with_sig_string_literal.sol
@@ -0,0 +1,30 @@
+contract C {
+	function abiEncodeStringLiteral(string memory sig) public pure {
+		bytes memory b1 = abi.encodeWithSignature(sig, "");
+		bytes memory b2 = abi.encodeWithSignature(sig, "");
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b2.length);
+
+		bytes memory b3 = abi.encodeWithSignature(sig, bytes(""));
+		assert(b1.length == b3.length); // should fail
+
+		bytes memory b4 = abi.encodeWithSignature(sig, bytes24(""));
+		// should hold, but currently fails due to string literal abstraction
+		assert(b1.length == b4.length);
+
+		bytes memory b5 = abi.encodeWithSignature(sig, string(""));
+		assert(b1.length == b5.length); // should fail
+
+		bytes memory b6 = abi.encodeWithSelector("f()", bytes24(""));
+		assert(b4.length == b6.length); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (261-291): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a]\nb3 = []\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(sig)
+// Warning 6328: (357-387): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = [0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90]\nb4 = []\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(sig)
+// Warning 6328: (542-572): CHC: Assertion violation happens here.\nCounterexample:\n\nb3 = [0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]\nb5 = []\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(sig)
+// Warning 6328: (639-669): CHC: Assertion violation happens here.\nCounterexample:\n\nb4 = [0x22, 0x22, 0x22, 0x22, 0x22, 0x0d, 0x22, 0x22, 0x22, 0x22, 0x09, 0x22, 0x0b, 0x22, 0x22, 0x0e, 0x22, 0x10, 0x22, 0x12, 0x22, 0x14, 0x22, 0x16, 0x22, 0x18, 0x22, 0x1a, 0x22, 0x1c, 0x22, 0x1e, 0x22, 0x20, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22]\nb6 = []\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(sig)
+// Warning 6328: (753-783): CHC: Assertion violation happens here.\nCounterexample:\n\nb2 = [0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117, 0x0117]\nb4 = []\nb5 = [0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118, 0x0118]\n\nTransaction trace:\nC.constructor()\nC.abiEncodeStringLiteral(sig)
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_7.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_7.sol
new file mode 100644
index 00000000..5ba845e7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_7.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.push();
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_8.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_8.sol
new file mode 100644
index 00000000..f3546acf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/array_pop_length_8.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.pop();
+		a.push();
+		a.push();
+		a.push();
+		a.pop();
+		a.pop();
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2529: (49-56): CHC: Empty array "pop" happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/array_push_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/array_push_string_literal.sol
new file mode 100644
index 00000000..cbded7ca
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/array_push_string_literal.sol
@@ -0,0 +1,20 @@
+contract C {
+	bytes data;
+	function g() public {
+		require(data.length == 0);
+		data.push("b");
+		assert(data[0] == "b"); // should hold
+		assert(data[0] == "c"); // should fail
+		delete data;
+		data.push(hex"01");
+		assert(uint8(data[0]) == 1); // should hold
+		assert(uint8(data[0]) == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (139-161): CHC: Assertion violation happens here.
+// Warning 6328: (263-290): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol
new file mode 100644
index 00000000..3d68cef6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_memory_to_memory.sol
@@ -0,0 +1,14 @@
+pragma abicoder               v2;
+
+contract C {
+	function f(uint[][] memory arr) public pure {
+		require(arr.length > 0);
+		uint[][] memory arr2 = arr;
+		assert(arr2[0].length == arr[0].length);
+		assert(arr.length == arr2.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol
new file mode 100644
index 00000000..a20d20e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_assignment_2d_storage_to_storage.sol
@@ -0,0 +1,21 @@
+pragma abicoder               v2;
+
+contract C {
+	uint[][] arr;
+	uint[][] arr2;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr2.push();
+		arr2.push();
+	}
+	function f() public view {
+		assert(arr2[0].length == arr[0].length);
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol
new file mode 100644
index 00000000..cc584573
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_memory_to_storage.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+contract C {
+	uint[][] arr;
+	function f(uint[][] memory arr2) public {
+		require(arr2.length > 0);
+		arr = arr2;
+		assert(arr2[0].length == arr[0].length);
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol
new file mode 100644
index 00000000..8c952aa7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_copy_2d_storage_to_memory.sol
@@ -0,0 +1,20 @@
+pragma abicoder               v2;
+
+contract C {
+	uint[][] arr;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+	}
+	function f() public view {
+		uint[][] memory arr2 = arr;
+		assert(arr2[0].length == arr[0].length);
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_1.sol
new file mode 100644
index 00000000..233c9556
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_1.sol
@@ -0,0 +1,10 @@
+contract C {
+	mapping (uint => uint[]) map;
+	function f() public view {
+		assert(map[0].length == map[1].length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2.sol
new file mode 100644
index 00000000..245d4b8d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2.sol
@@ -0,0 +1,11 @@
+contract C {
+	mapping (uint => uint[]) map;
+	function f(uint x, uint y) public view {
+		require(x == y);
+		assert(map[x].length == map[y].length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2d_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2d_1.sol
new file mode 100644
index 00000000..d6efabeb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_mapping_array_2d_1.sol
@@ -0,0 +1,12 @@
+contract C {
+	mapping (uint => uint[][]) map;
+	function f(uint x, uint y) public {
+		require(x == y);
+		map[x].push();
+		assert(map[x][0].length == map[y][0].length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_1.sol
new file mode 100644
index 00000000..f12f2bd9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	struct S {
+		uint[] arr;
+	}
+	S s1;
+	S s2;
+	function f() public view {
+		assert(s1.arr.length == s2.arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_2d_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_2d_1.sol
new file mode 100644
index 00000000..ab3bf9a7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_1d_struct_array_2d_1.sol
@@ -0,0 +1,25 @@
+contract C {
+	struct S {
+		uint[][] arr;
+	}
+	S s1;
+	S s2;
+	constructor() {
+		s1.arr.push();
+		s2.arr.push();
+		s1.arr[0].push();
+		s1.arr[0].push();
+		s1.arr[0].push();
+		s2.arr[0].push();
+		s2.arr[0].push();
+		s2.arr[0].push();
+	}
+	function f() public view {
+		assert(s1.arr[0].length == s2.arr[0].length);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol
new file mode 100644
index 00000000..9a6a00b8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_2d_memory_to_memory.sol
@@ -0,0 +1,12 @@
+pragma abicoder               v2;
+
+contract C {
+	function f(uint[][] memory arr) public pure {
+		uint[][] memory arr2 = arr;
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_memory_to_memory.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_memory_to_memory.sol
new file mode 100644
index 00000000..72aca44e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_memory_to_memory.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(uint[] memory arr) public pure {
+		uint[] memory arr2 = arr;
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_storage_to_storage.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_storage_to_storage.sol
new file mode 100644
index 00000000..f198c962
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_assignment_storage_to_storage.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[] arr;
+	uint[] arr2;
+	function f() public {
+		arr2 = arr;
+		assert(arr2.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_basic.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_basic.sol
new file mode 100644
index 00000000..981311a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_basic.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint[] arr;
+	function f() public view {
+		uint x = arr.length;
+		uint y = x;
+		assert(arr.length == y);
+		assert(arr.length != y);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (120-143): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_memory_to_storage.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_memory_to_storage.sol
new file mode 100644
index 00000000..07b0bbb4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_memory_to_storage.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] arr;
+	function f(uint[] memory marr) public {
+		arr = marr;
+		assert(marr.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_storage_to_memory.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_storage_to_memory.sol
new file mode 100644
index 00000000..a750ba59
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_copy_storage_to_memory.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] arr;
+	function f() public view {
+		uint[] memory marr = arr;
+		assert(marr.length == arr.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_function_call.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_function_call.sol
new file mode 100644
index 00000000..4b30e2a6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_function_call.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[] arr;
+	function f() public view {
+		assert(arr.length == g().length);
+	}
+	function g() internal pure returns (uint[] memory) {
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment.sol
new file mode 100644
index 00000000..aa1a0613
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint[] arr;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+	}
+	function f() public view {
+		uint[] memory arr2 = arr;
+		arr2[2] = 3;
+		assert(arr.length == arr2.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2.sol
new file mode 100644
index 00000000..783ad207
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint[][] arr;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr[2].push();
+		arr[2].push();
+		arr[2].push();
+		arr[2].push();
+	}
+	function f() public {
+		uint x = arr[2].length;
+		uint y = arr[3].length;
+		uint z = arr.length;
+		arr[2][3] = 444;
+		assert(arr[2].length == x);
+		assert(arr[3].length == y);
+		assert(arr.length == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 13 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2_fail.sol
new file mode 100644
index 00000000..40effc4c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_2_fail.sol
@@ -0,0 +1,30 @@
+contract C {
+	uint[][] arr;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr[2].push();
+		arr[2].push();
+		arr[2].push();
+		arr[2].push();
+	}
+	function f() public {
+		uint x = arr[2].length;
+		uint y = arr[3].length;
+		uint z = arr.length;
+		arr[2][3] = 444;
+		assert(arr[2].length != x);
+		assert(arr[3].length != y);
+		assert(arr.length != z);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (291-317): CHC: Assertion violation happens here.
+// Warning 6328: (321-347): CHC: Assertion violation happens here.
+// Warning 6328: (351-374): CHC: Assertion violation happens here.
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3.sol
new file mode 100644
index 00000000..8ba2cd75
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3.sol
@@ -0,0 +1,31 @@
+contract C {
+	uint[][] arr;
+
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+	}
+
+	function f() public {
+		uint x = arr[2].length;
+		uint y = arr[3].length;
+		uint z = arr.length;
+		uint t = arr[5].length;
+		arr[5] = arr[8];
+		assert(arr[2].length == x);
+		assert(arr[3].length == y);
+		assert(arr.length == z);
+		assert(arr[5].length == t);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3_fail.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3_fail.sol
new file mode 100644
index 00000000..d346692d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/length_same_after_assignment_3_fail.sol
@@ -0,0 +1,34 @@
+contract C {
+	uint[][] arr;
+	constructor() {
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+		arr.push();
+	}
+	function f() public {
+		uint x = arr[2].length;
+		uint y = arr[3].length;
+		uint z = arr.length;
+		uint t = arr[5].length;
+		arr[5] = arr[8];
+		assert(arr[2].length != x);
+		assert(arr[3].length != y);
+		assert(arr.length != z);
+		assert(arr[5].length != t);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (319-345): CHC: Assertion violation happens here.
+// Warning 6328: (349-375): CHC: Assertion violation happens here.
+// Warning 6328: (379-402): CHC: Assertion violation happens here.
+// Warning 6328: (406-432): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_safe.sol
new file mode 100644
index 00000000..5ba845e7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_safe.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.push();
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_unsafe.sol
new file mode 100644
index 00000000..83398346
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_1_unsafe.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 2529: (49-56): CHC: Empty array "pop" happens here.\nCounterexample:\na = []\n\nTransaction trace:\nC.constructor()\nState: a = []\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_safe.sol
new file mode 100644
index 00000000..e915d4df
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_safe.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		a[0].push();
+		a[0].pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_unsafe.sol
new file mode 100644
index 00000000..ea9f6a25
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_2d_unsafe.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		a.push();
+		a[0].push();
+		a[1].pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2529: (90-100): CHC: Empty array "pop" happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_safe.sol
new file mode 100644
index 00000000..06be68f9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_safe.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	constructor() {
+		a.push();
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_unsafe.sol
new file mode 100644
index 00000000..7e1eb8b6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_constructor_unsafe.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	constructor() {
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 2529: (43-50): CHC: Empty array "pop" happens here.\nCounterexample:\na = []\n\nTransaction trace:\nC.constructor()
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_safe.sol
new file mode 100644
index 00000000..5bd322cd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_safe.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint[] a;
+	function f(uint l) public {
+		for (uint i = 0; i < l; ++i) {
+			a.push();
+			a.pop();
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_unsafe.sol
new file mode 100644
index 00000000..0bb7b4f1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/pop_loop_unsafe.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint[] a;
+	function f(uint l) public {
+		for (uint i = 0; i < l; ++i) {
+			a.push();
+			a.pop();
+		}
+		a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2529: (117-124): CHC: Empty array "pop" happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_safe.sol
new file mode 100644
index 00000000..665fb13c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_safe.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[][] a;
+	function f(uint[] memory x, uint y) public {
+		a.push(x);
+		a[0].push(y);
+		assert(a[0][a[0].length - 1] == y);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_unsafe.sol
new file mode 100644
index 00000000..c60e983c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_2d_arg_1_unsafe.sol
@@ -0,0 +1,16 @@
+contract C {
+	uint[][] a;
+	function f(uint[] memory x, uint y) public {
+		a.push(x);
+		a[0].push(y);
+		a[0].pop();
+		assert(a[0][a[0].length - 1] == y);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 3944: (129-144): CHC: Underflow (resulting value less than 0) happens here.
+// Warning 6328: (117-151): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_arg_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_arg_1.sol
new file mode 100644
index 00000000..002d9246
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_arg_1.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	function f(uint x) public {
+		a.push(x);
+		assert(a[a.length - 1] == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_1d.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_1d.sol
new file mode 100644
index 00000000..42dd2e49
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_1d.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint[] b;
+
+	function f() public {
+		require(b.length == 0);
+		b.push() = 1;
+		assert(b[0] == 1);
+	}
+
+	function g() public {
+		b.push() = 1;
+		assert(b[b.length - 1] == 1);
+		// Fails
+		assert(b[b.length - 1] == 100);
+	}
+
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (199-229): CHC: Assertion violation happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d.sol
new file mode 100644
index 00000000..71997ecd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint[][] c;
+
+	function f() public {
+		require(c.length == 0);
+		c.push().push() = 2;
+		assert(c.length == 1);
+		assert(c[0].length == 1);
+		assert(c[0][0] == 2);
+	}
+
+	function g() public {
+		c.push().push() = 2;
+		assert(c.length > 0);
+		assert(c[c.length - 1].length == 1);
+		assert(c[c.length - 1][c[c.length - 1].length - 1] == 2);
+		// Fails
+		assert(c[c.length - 1][c[c.length - 1].length - 1] == 200);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (362-420): CHC: Assertion violation happens here.
+// Info 1391: CHC: 23 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d_2.sol
new file mode 100644
index 00000000..180e70cb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_2d_2.sol
@@ -0,0 +1,12 @@
+contract C {
+	int[][] array2d;
+	function s() public returns (int[] memory) {
+		array2d.push() = array2d.push();
+		assert(array2d[array2d.length - 1].length == array2d[array2d.length - 2].length);
+		return array2d[1];
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_3d.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_3d.sol
new file mode 100644
index 00000000..380dd892
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_3d.sol
@@ -0,0 +1,31 @@
+contract C {
+	uint[][][] c;
+
+	function f() public {
+		require(c.length == 0);
+		c.push().push().push() = 2;
+		assert(c.length == 1);
+		assert(c[0].length == 1);
+		assert(c[0][0].length == 1);
+		assert(c[0][0][0] == 2);
+	}
+
+	function g() public {
+		c.push().push().push() = 2;
+		uint length1 = c.length;
+		uint length2 = c[length1 - 1].length;
+		uint length3 = c[length1 - 1][length2 - 1].length;
+		assert(length1 > 0);
+		assert(length2 == 1);
+		assert(length3 == 1);
+		assert(c[length1 - 1][length2 - 1][length3 - 1] == 2);
+		// Fails
+		assert(c[length1 - 1][length2 - 1][length3 - 1] == 200);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (537-592): CHC: Assertion violation happens here.
+// Info 1391: CHC: 32 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_1d.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_1d.sol
new file mode 100644
index 00000000..d52b657d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_1d.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint[] b;
+	function f() public {
+		b.push() = b.push();
+		uint length = b.length;
+		assert(length >= 2);
+		assert(b[length - 1] == 0);
+		assert(b[length - 1] == b[length - 2]);
+		// Fails
+		assert(b[length - 1] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (204-230): CHC: Assertion violation happens here.
+// Info 1391: CHC: 11 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_1.sol
new file mode 100644
index 00000000..efc775ed
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_1.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint[][] b;
+	function f() public {
+		require(b.length == 0);
+		b.push().push() = b.push().push();
+		assert(b.length == 2);
+		assert(b[0].length == 1);
+		assert(b[0].length == 1);
+		assert(b[0][0] == 0);
+		assert(b[1][0] == 0);
+		assert(b[0][0] == b[1][0]);
+		// Fails
+		assert(b[0][0] != b[1][0]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (284-310): CHC: Assertion violation happens here.
+// Info 1391: CHC: 20 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_2.sol
new file mode 100644
index 00000000..ccfc5440
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_2d_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint[][] b;
+	function f() public {
+		b.push().push() = b.push().push();
+		uint length = b.length;
+		assert(length >= 2);
+		uint length1 = b[length - 1].length;
+		uint length2 = b[length - 2].length;
+		assert(length1 == 1);
+		assert(length2 == 1);
+		assert(b[length - 1][length1 - 1] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_bytes.sol
new file mode 100644
index 00000000..b29bdde3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_and_rhs_bytes.sol
@@ -0,0 +1,18 @@
+contract C {
+	bytes b;
+	function f() public {
+		b.push() = b.push();
+		uint length = b.length;
+		assert(length >= 2);
+		assert(b[length - 1] == 0);
+		assert(b[length - 1] == b[length - 2]);
+		// Fails
+		assert(b[length - 1] == bytes1(uint8(1)));
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (203-244): CHC: Assertion violation happens here.
+// Info 1391: CHC: 11 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes.sol
new file mode 100644
index 00000000..ce8fa065
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes.sol
@@ -0,0 +1,24 @@
+contract C {
+	bytes b;
+
+	function f() public {
+		require(b.length == 0);
+		b.push() = bytes1(uint8(1));
+		assert(b[0] == bytes1(uint8(1)));
+	}
+
+	function g() public {
+		bytes1 one = bytes1(uint8(1));
+		b.push() = one;
+		assert(b[b.length - 1] == one);
+		// Fails
+		assert(b[b.length - 1] == bytes1(uint8(100)));
+	}
+
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (265-310): CHC: Assertion violation happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes_2d.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes_2d.sol
new file mode 100644
index 00000000..4dc7a7c3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_bytes_2d.sol
@@ -0,0 +1,28 @@
+contract C {
+	bytes[] c;
+
+	function f() public {
+		bytes1 val = bytes1(uint8(2));
+		require(c.length == 0);
+		c.push().push() = val;
+		assert(c.length == 1);
+		assert(c[0].length == 1);
+		assert(c[0][0] == val);
+	}
+
+	function g() public {
+		bytes1 val = bytes1(uint8(2));
+		c.push().push() = val;
+		assert(c.length > 0);
+		assert(c[c.length - 1].length == 1);
+		assert(c[c.length - 1][c[c.length - 1].length - 1] == val);
+		// Fails
+		assert(c[c.length - 1][c[c.length - 1].length - 1] == bytes1(uint8(100)));
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (435-508): CHC: Assertion violation happens here.
+// Info 1391: CHC: 23 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_compound_assignment.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_compound_assignment.sol
new file mode 100644
index 00000000..4d20c8ae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_compound_assignment.sol
@@ -0,0 +1,16 @@
+contract C {
+
+	int[] u;
+
+	function t() public {
+		require(u.length == 0);
+		u.push() -= 1;
+		assert(u[0] < 0); // should hold
+		assert(u[0] >= 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (128-145): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_struct.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_struct.sol
new file mode 100644
index 00000000..a92b69f7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_as_lhs_struct.sol
@@ -0,0 +1,18 @@
+contract C {
+	struct S {
+		int[] b;
+	}
+	S s;
+	struct T {
+		S s;
+	}
+	T t;
+	function f() public {
+		s.b.push() = t.s.b.push();
+		assert(s.b[s.b.length -1] == t.s.b[t.s.b.length - 1]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe.sol
new file mode 100644
index 00000000..0d923642
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint256[] x;
+	constructor() { x.push(42); }
+	function f() public {
+		x.push(23);
+		assert(x[0] == 42 || x[0] == 23);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe_no_overflow_assumption.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe_no_overflow_assumption.sol
new file mode 100644
index 00000000..66cd2111
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_1_safe_no_overflow_assumption.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint256[] x;
+	constructor() { x.push(42); }
+	function f() public {
+		x.push(23);
+		assert(x[0] == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe.sol
new file mode 100644
index 00000000..798f8fce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint256[] x;
+	function f(uint256 l) public {
+		require(x.length == 0);
+		x.push(42);
+		x.push(84);
+		for(uint256 i = 0; i < l; ++i)
+			x.push(23);
+		assert(x[0] == 42 || x[0] == 23);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe_no_overflow_assumption.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe_no_overflow_assumption.sol
new file mode 100644
index 00000000..cbd65e04
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_overflow_2_safe_no_overflow_assumption.sol
@@ -0,0 +1,16 @@
+contract C {
+	uint256[] x;
+	function f(uint256 l) public {
+		require(x.length == 0);
+		x.push(42);
+		x.push(84);
+		for(uint256 i = 0; i < l; ++i)
+			x.push(23);
+		assert(x[0] == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1.sol
new file mode 100644
index 00000000..5d3f01fe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1.sol
@@ -0,0 +1,12 @@
+contract C {
+	int[][] array2d;
+	function l() public {
+		array2d.push().push();
+		assert(array2d.length > 0);
+		assert(array2d[array2d.length - 1].length > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1_fail.sol
new file mode 100644
index 00000000..2d54d3ae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_1_fail.sol
@@ -0,0 +1,14 @@
+contract C {
+	int[][] array2d;
+	function l() public {
+		array2d.push().push();
+		assert(array2d.length > 2);
+		assert(array2d[array2d.length - 1].length > 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (81-107): CHC: Assertion violation happens here.
+// Warning 6328: (111-157): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2.sol
new file mode 100644
index 00000000..f78f917e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2.sol
@@ -0,0 +1,14 @@
+contract C {
+	int[][][] array2d;
+	function l() public {
+		array2d.push().push().push();
+		assert(array2d.length > 0);
+		uint last = array2d[array2d.length - 1].length;
+		assert(last > 0);
+		assert(array2d[array2d.length - 1][last - 1].length > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2_fail.sol
new file mode 100644
index 00000000..5ff371cd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_push_no_args_2_fail.sol
@@ -0,0 +1,18 @@
+contract C {
+	int[][][] array2d;
+	function l() public {
+		array2d.push().push().push();
+		assert(array2d.length > 2);
+		uint last = array2d[array2d.length - 1].length;
+		assert(last > 3);
+		assert(array2d[array2d.length - 1][last - 1].length > 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (90-116): CHC: Assertion violation happens here.
+// Warning 6328: (170-186): CHC: Assertion violation happens here.
+// Warning 6328: (190-246): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_safe_aliasing.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_safe_aliasing.sol
new file mode 100644
index 00000000..e43d83c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_safe_aliasing.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		uint[] storage b = a[0];
+		b.push(8);
+		assert(b[b.length - 1] == 8);
+		// Safe but fails due to aliasing.
+		assert(a[0][a[0].length - 1] == 8);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (179-183): CHC: Out of bounds access happens here.
+// Warning 6368: (184-188): CHC: Out of bounds access happens here.
+// Warning 3944: (184-199): CHC: Underflow (resulting value less than 0) happens here.
+// Warning 6328: (172-206): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_aliasing.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_aliasing.sol
new file mode 100644
index 00000000..502274fb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_aliasing.sol
@@ -0,0 +1,21 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		a[0].push();
+		a[0][0] = 16;
+		uint[] storage b = a[0];
+		b[0] = 32;
+		// Access is safe but fails due to aliasing.
+		assert(a[0][0] == 16);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (188-192): CHC: Out of bounds access happens here.
+// Warning 6368: (188-195): CHC: Out of bounds access happens here.
+// Warning 6328: (181-202): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_length.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_length.sol
new file mode 100644
index 00000000..ebabc970
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_storage_ref_unsafe_length.sol
@@ -0,0 +1,40 @@
+contract C {
+	uint[][] a;
+	uint[][][] c;
+	uint[] d;
+	constructor() {
+		c.push().push().push();
+		d.push(); d.push();
+	}
+	function f() public {
+		a.push();
+		uint[] storage b = a[0];
+		// Access is safe but oob reported due to aliasing.
+		c[0][0][0] = 12;
+		// Access is safe but oob reported due to aliasing.
+		d[1] = 7;
+		b.push(8);
+		assert(a[0].length == 0);
+		// Safe but knowledge about `c` is erased because `b` could be pointing to `c[x][y]`.
+		// Access is safe but oob reported due to aliasing.
+		assert(c[0][0][0] == 12);
+		// Safe but knowledge about `d` is erased because `b` could be pointing to `d`.
+		// Removed assertion because current Spacer seg faults in cex generation.
+		//assert(d[1] == 7);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (238-242): CHC: Out of bounds access happens here.
+// Warning 6368: (238-245): CHC: Out of bounds access happens here.
+// Warning 6368: (238-248): CHC: Out of bounds access happens here.
+// Warning 6368: (311-315): CHC: Out of bounds access happens here.
+// Warning 6368: (343-347): CHC: Out of bounds access happens here.
+// Warning 6328: (336-360): CHC: Assertion violation happens here.
+// Warning 6368: (513-517): CHC: Out of bounds access happens here.
+// Warning 6368: (513-520): CHC: Out of bounds access happens here.
+// Warning 6368: (513-523): CHC: Out of bounds access happens here.
+// Warning 6328: (506-530): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_1.sol
new file mode 100644
index 00000000..bb69ec9e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_1.sol
@@ -0,0 +1,17 @@
+contract C {
+	struct S {
+		int[] b;
+	}
+	S s;
+	struct T {
+		S s;
+	}
+	T t;
+	function f() public {
+		s.b.push();
+		t.s.b.push();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_2.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_2.sol
new file mode 100644
index 00000000..ad7a675b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_struct_member_2.sol
@@ -0,0 +1,19 @@
+contract C {
+	struct S {
+		int[] b;
+	}
+	S s;
+	struct T {
+		S[] s;
+	}
+	T t;
+	function f() public {
+		s.b.push();
+		t.s.push();
+		t.s[0].b.push();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_safe.sol
new file mode 100644
index 00000000..73fb5386
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_safe.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		a[a.length - 1].push();
+		assert(a[a.length - 1][0] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_unsafe.sol
new file mode 100644
index 00000000..dde8a837
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_2d_unsafe.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint[][] a;
+	function f() public {
+		a.push();
+		a[a.length - 1].push();
+		assert(a[a.length - 1][0] == 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (89-122): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_safe.sol
new file mode 100644
index 00000000..3c33fbda
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_safe.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.push();
+		assert(a[a.length - 1] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_unsafe.sol
new file mode 100644
index 00000000..ed846fae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/push_zero_unsafe.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint[] a;
+	function f() public {
+		a.push();
+		assert(a[a.length - 1] == 100);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (61-91): CHC: Assertion violation happens here.\nCounterexample:\na = [0]\n\nTransaction trace:\nC.constructor()\nState: a = []\nC.f()
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1.sol
new file mode 100644
index 00000000..cbe2d659
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1.sol
@@ -0,0 +1,22 @@
+contract C {
+	int[][] array2d;
+	function l() public {
+		s().push();
+		// False positive.
+		// Knowledge is erased because `s()` is a storage pointer.
+		assert(array2d[2].length > 0);
+	}
+	function s() internal returns (int[] storage) {
+		array2d.push();
+		array2d.push();
+		array2d.push();
+		return array2d[2];
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (159-169): CHC: Out of bounds access happens here.
+// Warning 6328: (152-181): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1_safe.sol b/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1_safe.sol
new file mode 100644
index 00000000..74906c3d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/array_members/storage_pointer_push_1_safe.sol
@@ -0,0 +1,18 @@
+contract C {
+	int[][] array2d;
+	function l() public {
+		s();
+		array2d[2].push();
+		assert(array2d[2].length > 0);
+	}
+	function s() internal returns (int[] storage) {
+		array2d.push();
+		array2d.push();
+		array2d.push();
+		return array2d[2];
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_non_zero_2.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_non_zero_2.sol
new file mode 100644
index 00000000..e5c913c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_non_zero_2.sol
@@ -0,0 +1,14 @@
+contract C {
+	constructor() payable {
+		require(msg.value > 100);
+	}
+	function f() public view {
+		assert(address(this).balance > 100); // should hold
+		assert(address(this).balance > 200); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (153-188): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive.sol
new file mode 100644
index 00000000..79614473
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive.sol
@@ -0,0 +1,19 @@
+contract C {
+	uint prevBalance;
+	constructor() payable {
+		prevBalance = address(this).balance;
+	}
+	function f() public payable {
+		assert(address(this).balance == prevBalance + msg.value); // should fail because there might be funds from selfdestruct/block.coinbase
+		assert(address(this).balance < prevBalance + msg.value); // should fail
+		assert(address(this).balance >= prevBalance + msg.value); // should hold
+		prevBalance = address(this).balance;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (132-188): CHC: Assertion violation happens here.
+// Warning 6328: (269-324): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_2.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_2.sol
new file mode 100644
index 00000000..f1c423bc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_2.sol
@@ -0,0 +1,21 @@
+contract C {
+	uint x;
+	bool once;
+	constructor() payable {
+		x = address(this).balance;
+	}
+	function f() public payable {
+		require(!once);
+		once = true;
+		require(msg.value > 0);
+		assert(address(this).balance > x); // should hold
+		assert(address(this).balance > x + 10); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (266-272): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (235-273): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_4.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_4.sol
new file mode 100644
index 00000000..dfa571c3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_4.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint c;
+	function f() public payable {
+		require(msg.value > 10);
+		++c;
+	}
+	function inv() public view {
+		assert(address(this).balance >= c * 11); // should hold
+		assert(address(this).balance >= c * 12); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 4984: (82-85): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 4984: (154-160): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 4984: (212-218): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 6328: (180-219): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (82-85): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 2661: (154-160): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 2661: (212-218): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_5.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_5.sol
new file mode 100644
index 00000000..26009b3b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_5.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint sum = msg.value;
+	function f() public payable {
+		sum += msg.value;
+	}
+	function inv() public view {
+		assert(address(this).balance == sum); // should fail
+		assert(address(this).balance >= sum); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (122-158): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_calls.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_calls.sol
new file mode 100644
index 00000000..7379b199
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_calls.sol
@@ -0,0 +1,28 @@
+contract C {
+	bool once;
+	function f() public payable {
+		require(!once);
+		once = true;
+		require(msg.value == 10);
+		assert(address(this).balance >= 10); // should hold
+		assert(address(this).balance >= 20); // should fail
+		g();
+	}
+	function g() internal view {
+		assert(address(this).balance >= 10); // should hold
+		assert(address(this).balance >= 20); // should fail
+		h();
+	}
+	function h() internal view {
+		assert(address(this).balance >= 10); // should hold
+		assert(address(this).balance >= 20); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (173-208): CHC: Assertion violation happens here.
+// Warning 6328: (321-356): CHC: Assertion violation happens here.
+// Warning 6328: (469-504): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls.sol
new file mode 100644
index 00000000..7f22d1d0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls.sol
@@ -0,0 +1,18 @@
+interface I {
+	function ext() external;
+}
+
+contract C {
+	function f(I _i) public {
+		uint x = address(this).balance;
+		_i.ext();
+		assert(address(this).balance == x); // should fail
+		assert(address(this).balance >= x); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (131-165): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_2.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_2.sol
new file mode 100644
index 00000000..0a306688
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_2.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f(address _a) public {
+		uint x = address(this).balance;
+		_a.call("");
+		assert(address(this).balance == x); // should fail
+		assert(address(this).balance >= x); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreInv: yes
+// ----
+// Warning 9302: (82-93): Return value of low-level calls not used.
+// Warning 6328: (97-131): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_mutex.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_mutex.sol
new file mode 100644
index 00000000..b74f34c3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_receive_ext_calls_mutex.sol
@@ -0,0 +1,25 @@
+interface I {
+	function ext() external;
+}
+
+contract C {
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+	function f(I _i) public mutex {
+		uint x = address(this).balance;
+		_i.ext();
+		assert(address(this).balance == x); // should hold
+		assert(address(this).balance < x); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (277-310): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_spend.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_spend.sol
new file mode 100644
index 00000000..387e45bb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/balance_spend.sol
@@ -0,0 +1,23 @@
+contract C {
+	constructor() payable {
+		require(msg.value > 100);
+	}
+	uint c;
+	function f(address payable _a, uint _v) public {
+		require(_v < 10);
+		require(c < 2);
+		++c;
+		_a.transfer(_v);
+	}
+	function inv() public view {
+		assert(address(this).balance > 80); // should hold
+		assert(address(this).balance > 90); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (280-314): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 1236: (175-190): BMC: Insufficient funds happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/decreasing_balance.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/decreasing_balance.sol
new file mode 100644
index 00000000..76455060
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/decreasing_balance.sol
@@ -0,0 +1,21 @@
+contract C {
+	uint t;
+	constructor() {
+		t = address(this).balance;
+	}
+	function f(address payable a, uint x) public {
+		require(address(this).balance >= x);
+		a.transfer(x);
+	}
+	function inv() public view {
+		// If only looking at `f`, it looks like this.balance always decreases.
+		// However, the edge case of a contract `selfdestruct` sending its remaining balance
+		// to this contract should make the claim false (since there's no fallback/receive here).
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(address(this).balance == t);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_1.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_1.sol
new file mode 100644
index 00000000..e7e7d924
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_1.sol
@@ -0,0 +1,17 @@
+function l(address payable a) {}
+
+contract C {
+	uint x;
+	function f(address payable a) public payable {
+		require(msg.value > 1);
+		uint b1 = address(this).balance;
+		l(a);
+		uint b2 = address(this).balance;
+		assert(b1 == b2); // should hold
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_2.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_2.sol
new file mode 100644
index 00000000..e2e18703
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/free_function_2.sol
@@ -0,0 +1,24 @@
+function l(address payable a) {
+	a.transfer(1);
+}
+
+contract C {
+	uint x;
+	function f(address payable a) public payable {
+		require(msg.value > 1);
+		uint b1 = address(this).balance;
+		require(a != address(this));
+		l(a);
+		uint b2 = address(this).balance;
+		assert(b1 == b2); // should fail
+		assert(b1 == b2 + 1); // should hold
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (258-274): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 1236: (33-46): BMC: Insufficient funds happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_1.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_1.sol
new file mode 100644
index 00000000..4314db11
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_1.sol
@@ -0,0 +1,20 @@
+library L {
+	function l(address payable a) internal {}
+}
+
+contract C {
+	using L for address payable;
+	uint x;
+	function f(address payable a) public payable {
+		require(msg.value > 1);
+		uint b1 = address(this).balance;
+		a.l();
+		uint b2 = address(this).balance;
+		assert(b1 == b2); // should hold
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_2.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_2.sol
new file mode 100644
index 00000000..f16a57ac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/library_internal_2.sol
@@ -0,0 +1,27 @@
+library L {
+	function l(address payable a) internal {
+		require(a != address(this));
+		a.transfer(1);
+	}
+}
+
+contract C {
+	using L for address payable;
+	uint x;
+	function f(address payable a) public payable {
+		require(msg.value > 1);
+		uint b1 = address(this).balance;
+		a.l();
+		uint b2 = address(this).balance;
+		assert(b1 == b2); // should fail
+		assert(b1 == b2 + 1); // should hold
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (315-331): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 1236: (87-100): BMC: Insufficient funds happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change.sol
new file mode 100644
index 00000000..a51f73dd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change.sol
@@ -0,0 +1,14 @@
+contract C {
+	address t;
+	constructor() {
+		t = address(this);
+	}
+	function inv() public view {
+		assert(address(this) == t);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_external_call.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_external_call.sol
new file mode 100644
index 00000000..2c9e58e7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_external_call.sol
@@ -0,0 +1,22 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+	address t;
+	constructor() {
+		t = address(this);
+	}
+	function f(D d) public {
+		address a = address(this);
+		d.d();
+		assert(address(this) == t);
+		assert(a == t);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_internal_call.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_internal_call.sol
new file mode 100644
index 00000000..1b1adc9d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/this_does_not_change_internal_call.sol
@@ -0,0 +1,17 @@
+contract C {
+	address t;
+	constructor() {
+		t = address(this);
+	}
+	function f() public view {
+		g(address(this));
+	}
+	function g(address a) internal view {
+		assert(a == t);
+		assert(a == address(this));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/blockchain_state/transfer.sol b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/transfer.sol
new file mode 100644
index 00000000..c099ffb2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/blockchain_state/transfer.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f(address payable a) public {
+		require(address(this).balance > 1000);
+		a.transfer(666);
+		assert(address(this).balance > 100);
+		// Fails.
+		assert(address(this).balance > 500);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (166-201): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/assert_in_constructor.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/assert_in_constructor.sol
new file mode 100644
index 00000000..65f07964
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/assert_in_constructor.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint x = initX();
+
+	function initX() internal pure returns (uint) {
+		return 42;
+	}
+}
+
+contract D is C {
+	uint y;
+
+	constructor() {
+		assert(x == 42);
+		y = x;
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers.sol
new file mode 100644
index 00000000..422f57c0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers.sol
@@ -0,0 +1,27 @@
+contract C {
+
+	uint x;
+
+	modifier check() {
+		require(x == 0);
+		_;
+		assert(x == 1); // should fail;
+		assert(x == 0); // should hold;
+	}
+
+	modifier inc() {
+		if (x == 0) {
+			return;
+		}
+		x = x + 1;
+		_;
+	}
+
+	function test() check inc public {
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (70-84): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers_2.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers_2.sol
new file mode 100644
index 00000000..2b845fbc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/branches_in_modifiers_2.sol
@@ -0,0 +1,44 @@
+contract C {
+
+    uint x;
+
+    function reset_if_overflow() internal postinc {
+        if (x < 10)
+            return;
+        x = 0;
+    }
+
+    modifier postinc() {
+        if (x == 0) {
+            return;
+        }
+        _;
+        x = x + 1;
+    }
+
+    function test() public {
+        if (x == 0) {
+            reset_if_overflow();
+            assert(x == 1); // should fail;
+            assert(x == 0); // should hold;
+            return;
+        }
+        if (x < 10) {
+            uint oldx = x;
+            reset_if_overflow();
+            assert(oldx + 1 == x); // should hold;
+            assert(oldx == x);     // should fail;
+            return;
+        }
+        reset_if_overflow();
+        assert(x == 1); // should hold;
+        assert(x == 0); // should fail;
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (351-365): BMC: Assertion violation happens here.
+// Warning 4661: (602-619): BMC: Assertion violation happens here.
+// Warning 4661: (748-762): BMC: Assertion violation happens here.
+// Info 6002: BMC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init.sol
new file mode 100644
index 00000000..c262e248
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init.sol
@@ -0,0 +1,42 @@
+contract A {
+	int x;
+	constructor (int a) { x = a;}
+}
+
+contract B is A {
+	int y;
+	constructor(int a) A(-a) {
+		if (a > 0) {
+			y = 2;
+			return;
+		}
+		else {
+			y = 3;
+		}
+		y = 4; // overwrites the else branch
+	}
+}
+
+contract C is B {
+	constructor(int a) B(a) {
+		assert(y != 3); // should hold
+		assert(y == 4); // should fail
+		if (a > 0) {
+			assert(x < 0 && y == 2); // should hold
+			assert(x < 0 && y == 4); // should fail
+		}
+		else {
+			assert(x >= 0 && y == 4); // should hold
+			assert(x >= 0 && y == 2); // should fail
+			assert(x > 0); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (297-311): BMC: Assertion violation happens here.
+// Warning 4661: (389-412): BMC: Assertion violation happens here.
+// Warning 4661: (489-513): BMC: Assertion violation happens here.
+// Warning 4661: (533-546): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_chain_alternate.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_chain_alternate.sol
new file mode 100644
index 00000000..63e49db4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_chain_alternate.sol
@@ -0,0 +1,29 @@
+contract A {
+	uint x = 1;
+}
+
+contract B is A {
+	constructor(int a) {
+		if (a > 0) {
+			x = 2;
+			return;
+		}
+		x = 3;
+	}
+}
+
+abstract contract C is B {
+}
+
+contract D is C {
+	constructor(int a) B(a) {
+		assert(a > 0 || x == 3); // should hold
+		assert(a <= 0 || x == 2); // should hold
+		assert(x == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (286-300): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_diamond.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_diamond.sol
new file mode 100644
index 00000000..4a7794ac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructor_state_variable_init_diamond.sol
@@ -0,0 +1,71 @@
+contract A {
+	int x;
+}
+
+contract B is A {
+	int y;
+	constructor (int a) {
+		if (a >= 0) {
+			y = 1;
+			return;
+		}
+		x = 1;
+		y = 2;
+	}
+}
+
+contract C is A {
+	int z;
+	constructor (int a) {
+		if (a >= 0) {
+			z = 1;
+			return;
+		}
+		x = -1;
+		z = 2;
+	}
+}
+
+contract D1 is B, C {
+	constructor() B(1) C(1) {
+		assert(x == 0); // should hold
+		assert(x == 1); // should fail
+		assert(x == -1); // should fail
+	}
+}
+
+contract D2 is B, C {
+	constructor() B(1) C(-1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should fail
+		assert(x == -1); // should hold (constructor of C is executed AFTER constructor of B)
+	}
+}
+
+contract D3 is B, C {
+	constructor() B(-1) C(1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should hold
+		assert(x == -1); // should fail
+	}
+}
+
+contract D4 is B, C {
+	constructor() B(-1) C(-1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should fail
+		assert(x == -1); // should hold (constructor of C is executed AFTER constructor of B)
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (337-351): BMC: Assertion violation happens here.
+// Warning 4661: (370-385): BMC: Assertion violation happens here.
+// Warning 4661: (460-474): BMC: Assertion violation happens here.
+// Warning 4661: (493-507): BMC: Assertion violation happens here.
+// Warning 4661: (670-684): BMC: Assertion violation happens here.
+// Warning 4661: (736-751): BMC: Assertion violation happens here.
+// Warning 4661: (827-841): BMC: Assertion violation happens here.
+// Warning 4661: (860-874): BMC: Assertion violation happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructors.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructors.sol
new file mode 100644
index 00000000..3d06983f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/constructors.sol
@@ -0,0 +1,32 @@
+contract B {
+	int x;
+	constructor(int b) {
+		if (b > 0) {
+			x = 1;
+			return;
+		}
+		else {
+			x = 2;
+			return;
+		}
+		x = 3; // dead code
+	}
+}
+
+contract C is B {
+	constructor(int a) B(a) {
+		assert(a > 0 || x == 2); // should hold
+		assert(a <= 0 || x == 1); // should hold
+		assert(x == 3); // should fail
+		assert(x == 2); // should fail
+		assert(x == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 5740: (119-124): Unreachable code.
+// Warning 4661: (277-291): BMC: Assertion violation happens here.
+// Warning 4661: (310-324): BMC: Assertion violation happens here.
+// Warning 4661: (343-357): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/nested_if.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/nested_if.sol
new file mode 100644
index 00000000..f496f398
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/nested_if.sol
@@ -0,0 +1,27 @@
+contract C {
+
+	function test(uint256 a, uint256 b) public pure {
+		assert(nested_if(a,b) != 42); // should hold
+		assert(nested_if(a,b) == 1);  // should fail
+	}
+
+	function nested_if(uint256 a, uint256 b) internal pure returns (uint256) {
+		if (a < 5) {
+			if (b > 1) {
+				return 0;
+			}
+		}
+		if (a == 2 && b == 2) {
+			return 42; // unreachable
+		}
+		else {
+			return 1;
+		}
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (114-141): BMC: Assertion violation happens here.
+// Warning 6838: (299-315): BMC: Condition is always false.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/return_in_both_branches.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/return_in_both_branches.sol
new file mode 100644
index 00000000..60abfb09
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/return_in_both_branches.sol
@@ -0,0 +1,22 @@
+contract C {
+
+	function test() public pure {
+		assert(branches(0) == 0);
+		assert(branches(1) == 42);
+	}
+
+	function branches(uint256 a) internal pure returns (uint256) {
+		if (a == 0) {
+			return 0;
+		}
+		else {
+			return 42;
+		}
+		return 1; // dead code
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 5740: (232-240): Unreachable code.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if.sol
new file mode 100644
index 00000000..3c9ff609
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if.sol
@@ -0,0 +1,12 @@
+contract C {
+	function test(uint256 a, uint256 b) public pure returns (uint256) {
+		if (a == 0) {
+			return 0;
+		}
+		return b / a; // This division is safe because of the early return in if-block.
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_array.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_array.sol
new file mode 100644
index 00000000..a5f9f3a5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_array.sol
@@ -0,0 +1,29 @@
+contract C {
+
+	uint[] a;
+
+	constructor () {
+		a.push();
+		a.push();
+	}
+
+	function check() public {
+		require(a.length >= 2);
+		require(a[1] == 0);
+		conditional_store();
+		assert(a[1] == 1); // should fail;
+		assert(a[1] == 0); // should hold;
+	}
+
+	function conditional_store() internal {
+		if (a[1] == 0) {
+			return;
+		}
+		a[1] = 1;
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (172-189): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_state_var.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_state_var.sol
new file mode 100644
index 00000000..db4abe9c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_state_var.sol
@@ -0,0 +1,23 @@
+contract C {
+
+	uint x;
+
+	function check() public {
+		require(x == 0);
+		conditional_increment();
+		assert(x == 1); // should fail;
+		assert(x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (x == 0) {
+			return;
+		}
+		x = 1;
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (99-113): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct.sol
new file mode 100644
index 00000000..9f987cea
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct.sol
@@ -0,0 +1,26 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+	S s;
+
+	function check() public {
+		require(s.x == 0);
+		conditional_increment();
+		assert(s.x == 1); // should fail;
+		assert(s.x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (s.x == 0) {
+			return;
+		}
+		s.x = 1;
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (123-139): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct_2.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct_2.sol
new file mode 100644
index 00000000..d001ed3d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_struct_2.sol
@@ -0,0 +1,26 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+	S s;
+
+	function check() public {
+		require(s.x == 0);
+		conditional_increment();
+		assert(s.x == 1); // should fail;
+		assert(s.x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (s.x == 0) {
+			return;
+		}
+		s = S(1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (123-139): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_tuple.sol
new file mode 100644
index 00000000..589931f6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/simple_if_tuple.sol
@@ -0,0 +1,28 @@
+contract C {
+
+	uint x;
+	uint y;
+
+	function check() public {
+		require(x == 0);
+		require(y == 0);
+		conditional_increment();
+		assert(x == 0); // should fail;
+		assert(x == 1); // should fail;
+		assert(x == 2); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (x == 0) {
+			(x,y) = (2,2);
+			return;
+		}
+		(x,y) = (1,1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (127-141): BMC: Assertion violation happens here.
+// Warning 4661: (161-175): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/triple_nested_if.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/triple_nested_if.sol
new file mode 100644
index 00000000..7c25f5b8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/branches_with_return/triple_nested_if.sol
@@ -0,0 +1,21 @@
+contract C {
+
+    uint a;
+    uint b;
+    uint c;
+
+	function test() public view {
+		if (a == 0) {
+			if (b == 0) {
+				if (c == 0) {
+					return;
+				}
+			}
+		}
+		assert(a != 0 || b != 0 || c != 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/implicit_constructor_with_function_calls.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/implicit_constructor_with_function_calls.sol
new file mode 100644
index 00000000..a3e97448
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/implicit_constructor_with_function_calls.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x = initX();
+	uint y = initY();
+
+    function initX() internal pure returns (uint) {
+		return 42;
+	}
+
+	function initY() internal view returns (uint) {
+		assert(x == 42);
+		return x;
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (172-187): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/msg_value_4.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/msg_value_4.sol
new file mode 100644
index 00000000..bb89407a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/msg_value_4.sol
@@ -0,0 +1,17 @@
+contract A {
+    uint x = msg.value;
+    constructor() {
+        assert(x == 0); // should hold
+    }
+}
+
+contract B {
+    constructor() payable {
+        assert(msg.value == 0); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (154-176): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/range_check.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/range_check.sol
new file mode 100644
index 00000000..a1137332
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/range_check.sol
@@ -0,0 +1,65 @@
+contract C {
+	constructor() payable {
+		assert(tx.origin >= address(0));
+		assert(tx.origin <= address(2**160 - 1));
+		assert(tx.gasprice >= 0);
+		assert(tx.gasprice <= 2**256 - 1);
+		assert(msg.sender >= address(0));
+		assert(msg.sender <= address(2**160 - 1));
+		assert(msg.value >= 0);
+		assert(msg.value <= 2**256 - 1);
+
+		assert(block.coinbase >= address(0));
+		assert(block.coinbase <= address(2**160 - 1));
+		assert(block.timestamp >= 0);
+		assert(block.timestamp <= 2**256 - 1);
+		assert(block.chainid >= 0);
+		assert(block.chainid <= 2**256 - 1);
+		assert(block.difficulty >= 0);
+		assert(block.difficulty <= 2**256 - 1);
+		assert(block.prevrandao > 2**64);
+		assert(block.prevrandao <= 2**256 - 1);
+		assert(block.gaslimit >= 0);
+		assert(block.gaslimit <= 2**256 - 1);
+		assert(block.number >= 0);
+		assert(block.number <= 2**256 - 1);
+	}
+}
+
+contract D {
+	constructor() payable {
+		unchecked {
+			assert(tx.origin >= address(0));
+			assert(tx.origin <= address(2**160 - 1));
+			assert(tx.gasprice >= 0);
+			assert(tx.gasprice <= 2**256 - 1);
+			assert(msg.sender >= address(0));
+			assert(msg.sender <= address(2**160 - 1));
+			assert(msg.value >= 0);
+			assert(msg.value <= 2**256 - 1);
+
+			assert(block.coinbase >= address(0));
+			assert(block.coinbase <= address(2**160 - 1));
+			assert(block.timestamp >= 0);
+			assert(block.timestamp <= 2**256 - 1);
+			assert(block.chainid >= 0);
+			assert(block.chainid <= 2**256 - 1);
+			assert(block.difficulty >= 0);
+			assert(block.difficulty <= 2**256 - 1);
+			assert(block.prevrandao > 2**64);
+			assert(block.prevrandao <= 2**256 - 1);
+			assert(block.gaslimit >= 0);
+			assert(block.gaslimit <= 2**256 - 1);
+			assert(block.number >= 0);
+			assert(block.number <= 2**256 - 1);
+		}
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 8417: (565-581): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (598-614): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1447-1463): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1481-1497): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Info 6002: BMC: 44 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_balance.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_balance.sol
new file mode 100644
index 00000000..cfbdebfd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_balance.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(address _a) public view {
+		uint b1 = address(this).balance;
+		_a.staticcall("");
+		uint b2 = address(this).balance;
+		assert(b1 == b2); // should hold
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 9302: (88-105): Return value of low-level calls not used.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_state_var.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_state_var.sol
new file mode 100644
index 00000000..ad50613c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/staticcall_state_var.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint x;
+	function f(address _a) public {
+		x = 2;
+		_a.staticcall("");
+		assert(x == 2); // should hold
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 9302: (66-83): Return value of low-level calls not used.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/timestamp.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/timestamp.sol
new file mode 100644
index 00000000..93064ff6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/timestamp.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (uint) {
+        uint b = block.timestamp;
+        uint a = b + 0; // Overflow not possible!
+        return a;
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_catch_clauses_2.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_catch_clauses_2.sol
new file mode 100644
index 00000000..279d22b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_catch_clauses_2.sol
@@ -0,0 +1,24 @@
+contract C {
+
+	function g() public pure {}
+
+	function f() public view {
+		uint x = 0;
+		bool success = false;
+		try this.g() {
+			success = true;
+			x = 1;
+		} catch Error (string memory /*reason*/) {
+			x = 2;
+		} catch (bytes memory /*reason*/) {
+			x = 3;
+		}
+		assert(x > 0 && x < 4); // should hold
+		assert(x == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (306-320): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_returned_values_with_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_returned_values_with_tuple.sol
new file mode 100644
index 00000000..75458fad
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bmc_coverage/try_multiple_returned_values_with_tuple.sol
@@ -0,0 +1,28 @@
+contract C {
+
+	struct S {
+		uint x;
+		int y;
+	}
+
+	function g() public pure returns (bool b, S memory s) {
+		b = true;
+		s.x = 42;
+		s.y = -1;
+	}
+
+	function f() public view {
+		bool success = false;
+		try this.g() returns (bool b, S memory s) {
+			success = true;
+			assert(b && s.x == 42 && s.y == -1); // should hold
+		} catch {
+		}
+		assert(success); // fails, not guaranteed that there will be no error
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (336-351): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bytes_concat/equals.sol b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/equals.sol
new file mode 100644
index 00000000..334a2e0c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/equals.sol
@@ -0,0 +1,52 @@
+contract C {
+
+	function concatCall(bytes8 a) public pure returns (bytes memory) {
+		return bytes.concat(a, a);
+	}
+
+	function equalArguments1(bytes8 a, bytes8 b, bytes8 c, bytes8 d) public pure {
+		require(a == c);
+		require(b == d);
+		bytes memory concat1 = bytes.concat(a, b);
+		bytes memory concat2 = bytes.concat(c, d);
+		assert(keccak256(concat1) == keccak256(concat2));
+	}
+
+	function equalArguments2(bytes8 a, bytes8 c) public pure {
+		require(a == c);
+		bytes memory concat1 = bytes.concat(a, concatCall(a));
+		bytes memory concat2 = bytes.concat(c, concatCall(c));
+		assert(keccak256(concat1) == keccak256(concat2));
+	}
+
+	function equalLengthFixedBytes(bytes8 a, bytes8 b) public pure {
+		bytes memory concat1 = bytes.concat(a, b);
+		bytes memory concat2 = bytes.concat(a, b);
+		assert(concat1.length == concat2.length);
+	}
+
+	function equalLengthMemoryBytes(bytes memory a, bytes memory b) public pure {
+		bytes memory concat1 = bytes.concat(a, b);
+		bytes memory concat2 = bytes.concat(a, b);
+		assert(concat1.length == concat2.length);
+	}
+
+	function equalLengthMixed(bytes memory a, bytes2 b) public pure {
+		bytes memory concat1 = bytes.concat(a, b);
+		bytes memory concat2 = bytes.concat(a, b);
+		assert(concat1.length == concat2.length);
+	}
+
+	function equalLengthLiterals() public pure {
+		bytes memory a = hex"aa";
+		bytes1 b = bytes1(0xbb);
+		bytes memory c = "c";
+		bytes memory concat1 = bytes.concat(a, b, c);
+		bytes memory concat2 = bytes.concat(a, b, c);
+		assert(concat1.length == concat2.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bytes_concat/one_arg_call.sol b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/one_arg_call.sol
new file mode 100644
index 00000000..4f539f31
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/one_arg_call.sol
@@ -0,0 +1,10 @@
+contract C {
+	function oneArg(bytes memory a) public pure {
+		bytes memory concat = bytes.concat(a);
+		assert(keccak256(a) == keccak256(concat));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/bytes_concat/simple.sol b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/simple.sol
new file mode 100644
index 00000000..834d89ee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/bytes_concat/simple.sol
@@ -0,0 +1,35 @@
+contract C {
+	function zeroArgs() public pure returns(bytes memory) {
+		bytes memory a = bytes.concat();
+		assert(a.length == 0); // zero args call is an empty bytes array
+		return bytes.concat();
+	}
+
+	function oneArg(bytes memory a) public pure returns(bytes memory) {
+		return bytes.concat(a);
+	}
+
+	function oneArgFixedBytes(bytes8 a) public pure returns(bytes memory) {
+		return bytes.concat(a);
+	}
+
+	function fixedBytes(bytes8 a, bytes8 b) public pure returns(bytes memory) {
+		return bytes.concat(a, b);
+	}
+
+	function memoryBytes(bytes memory a, bytes memory b) public pure returns(bytes memory) {
+		return bytes.concat(a, b);
+	}
+
+	function mixed(bytes memory a, bytes2 b) public pure returns(bytes memory) {
+		return bytes.concat(a, b, "StringLiteral");
+	}
+
+	function functionCallAsArg(bytes memory a) public pure returns(bytes memory) {
+		return bytes.concat(oneArg(a), zeroArgs());
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/complex/MerkleProof.sol b/compiler/test/libsolidity/smtCheckerTests/complex/MerkleProof.sol
new file mode 100644
index 00000000..ac268409
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/complex/MerkleProof.sol
@@ -0,0 +1,35 @@
+/**
+ * @title MerkleProof
+ * @dev Merkle proof verification based on
+ * https://github.com/ameensol/merkle-tree-solidity/blob/master/src/MerkleProof.sol
+ */
+library MerkleProof {
+    /**
+     * @dev Verifies a Merkle proof proving the existence of a leaf in a Merkle tree. Assumes that each pair of leaves
+     * and each pair of pre-images are sorted.
+     * @param proof Merkle proof containing sibling hashes on the branch from the leaf to the root of the Merkle tree
+     * @param root Merkle root
+     * @param leaf Leaf of Merkle tree
+     */
+    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
+        bytes32 computedHash = leaf;
+
+        for (uint256 i = 0; i < proof.length; i++) {
+            bytes32 proofElement = proof[i];
+
+            if (computedHash < proofElement) {
+                // Hash(current computed hash + current element of the proof)
+                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
+            } else {
+                // Hash(current element of the proof + current computed hash)
+                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
+            }
+        }
+
+        // Check if the computed hash (root) is equal to the provided root
+        return computedHash == root;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/complex/slither/external_function.sol b/compiler/test/libsolidity/smtCheckerTests/complex/slither/external_function.sol
new file mode 100644
index 00000000..936ad170
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/complex/slither/external_function.sol
@@ -0,0 +1,88 @@
+contract ContractWithFunctionCalled {
+    function funcCalled() external  {
+        uint256 i = 0;
+    }
+}
+
+contract ContractWithFunctionCalledSuper is ContractWithFunctionCalled {
+    function callWithSuper() public {
+        uint256 i = 0;
+    }
+}
+
+contract ContractWithFunctionNotCalled {
+
+    function funcNotCalled3() public {
+
+    }
+
+    function funcNotCalled2() public {
+
+    }
+
+    function funcNotCalled() public {
+
+    }
+
+    function my_func() internal returns(bool){
+        return true;
+    }
+
+}
+
+contract ContractWithFunctionNotCalled2 is ContractWithFunctionCalledSuper {
+    function funcNotCalled() public {
+        uint256 i = 0;
+        address three = address(new ContractWithFunctionNotCalled());
+        three.call(abi.encode(bytes4(keccak256("helloTwo()"))));
+        super.callWithSuper();
+        ContractWithFunctionCalled c = new ContractWithFunctionCalled();
+        c.funcCalled();
+    }
+}
+
+contract InternalCall {
+
+    function() returns(uint) ptr;
+
+    function set_test1() external{
+        ptr = test1;
+    }
+
+    function set_test2() external{
+        ptr = test2;
+    }
+
+    function test1() public returns(uint){
+        return 1;
+    }
+
+    function test2() public returns(uint){
+        return 2;
+    }
+
+    function test3() public returns(uint){
+        return 3;
+    }
+
+    function exec() external returns(uint){
+        return ptr();
+    }
+
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (727-782): Return value of low-level calls not used.
+// Warning 2072: (84-93): Unused local variable.
+// Warning 2072: (227-236): Unused local variable.
+// Warning 2072: (634-643): Unused local variable.
+// Warning 2018: (42-104): Function state mutability can be restricted to pure
+// Warning 2018: (185-247): Function state mutability can be restricted to pure
+// Warning 2018: (437-506): Function state mutability can be restricted to pure
+// Warning 2018: (1111-1173): Function state mutability can be restricted to pure
+// Warning 2018: (1179-1241): Function state mutability can be restricted to pure
+// Warning 2018: (1247-1309): Function state mutability can be restricted to pure
+// Warning 8729: (681-716): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 8729: (854-886): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 5729: (1370-1375): BMC does not yet implement this type of function call.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/assignment_in_declaration.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/assignment_in_declaration.sol
new file mode 100644
index 00000000..3f9e379a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/assignment_in_declaration.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public pure { uint a = 2; assert(a == 2); }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_1.sol
new file mode 100644
index 00000000..229a93dd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_1.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint x) public pure {
+        if (x > 10) {
+            assert(x > 9);
+        }
+        else
+        {
+            assert(x < 11);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_2.sol
new file mode 100644
index 00000000..299da87e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_assert_condition_2.sol
@@ -0,0 +1,19 @@
+contract C {
+    function f(uint x) public pure {
+        if (x > 10) {
+            assert(x > 9);
+        }
+        else if (x > 2)
+        {
+            assert(x <= 10 && x > 2);
+        }
+        else
+        {
+           assert(0 <= x && x <= 2);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_1.sol
new file mode 100644
index 00000000..b70b2024
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_1.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint x;
+    modifier m(uint z) {
+		uint y = 3;
+        if (z == 10)
+            x = 2 + y;
+        _;
+        if (z == 10)
+            x = 4 + y;
+    }
+    function f() m(10) internal {
+        x = 3;
+    }
+    function g() public {
+        x = 0;
+        f();
+        assert(x == 7);
+        // Fails
+        assert(x == 6);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (327-341): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_2.sol
new file mode 100644
index 00000000..974c3250
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_2.sol
@@ -0,0 +1,27 @@
+contract C {
+    uint x;
+    modifier m(uint z) {
+		uint y = 3;
+        if (z == 10)
+            x = 2 + y;
+        _;
+        if (z == 10)
+            x = 4 + y;
+    }
+    function f() m(10) m(12) internal {
+        x = 3;
+    }
+    function g() public {
+        x = 0;
+        f();
+        assert(x == 3);
+        // Fails
+        assert(x == 6);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (333-347): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_3.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_3.sol
new file mode 100644
index 00000000..6889f36d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_3.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint x;
+    modifier m(uint z) {
+		uint y = 3;
+        if (z == 10)
+            x = 2 + y;
+        _;
+        if (z == 10)
+            x = 4 + y;
+    }
+    function f() m(8) internal {
+        x = 3;
+    }
+    function g() public {
+        x = 0;
+        f();
+        assert(x == 3);
+        // Fails
+        assert(x == 6);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (326-340): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_4.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_4.sol
new file mode 100644
index 00000000..135f18b2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_inside_modifiers_4.sol
@@ -0,0 +1,27 @@
+contract C {
+    uint x;
+    modifier m(uint z) {
+		uint y = 3;
+        if (z >= 10)
+            x = 2 + y;
+        _;
+        if (z >= 10)
+            x = 4 + y;
+    }
+    function f() m(10) m(12) internal {
+        x = 3;
+    }
+    function g() public {
+        x = 0;
+        f();
+        assert(x == 7);
+        // Fails
+        assert(x == 6);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (333-347): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_1.sol
new file mode 100644
index 00000000..a76f4110
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_1.sol
@@ -0,0 +1,13 @@
+// Branch does not touch variable a
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_2.sol
new file mode 100644
index 00000000..36618ec5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_2.sol
@@ -0,0 +1,14 @@
+// Positive branch touches variable a, but assertion should still hold.
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+            a = 3;
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_3.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_3.sol
new file mode 100644
index 00000000..deda2c85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_3.sol
@@ -0,0 +1,15 @@
+// Negative branch touches variable a, but assertion should still hold.
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+        } else {
+            a = 3;
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_4.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_4.sol
new file mode 100644
index 00000000..95589bfe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_4.sol
@@ -0,0 +1,16 @@
+// Variable is not merged, if it is only read.
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+            assert(a == 3);
+        } else {
+            assert(a == 3);
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_5.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_5.sol
new file mode 100644
index 00000000..82665aec
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_5.sol
@@ -0,0 +1,16 @@
+// Variable is reset in both branches
+contract C {
+    function f(uint x) public pure {
+        uint a = 2;
+        if (x > 10) {
+            a = 3;
+        } else {
+            a = 3;
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_6.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_6.sol
new file mode 100644
index 00000000..c388054c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_merge_variables_6.sol
@@ -0,0 +1,16 @@
+// Variable is reset in both branches
+contract C {
+    function f(uint x) public pure {
+        uint a = 2;
+        if (x > 10) {
+            a = 3;
+        } else {
+            a = 4;
+        }
+        assert(a >= 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers.sol
new file mode 100644
index 00000000..42315c89
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers.sol
@@ -0,0 +1,27 @@
+contract C {
+
+	uint x;
+
+	modifier check() {
+		require(x == 0);
+		_;
+		assert(x == 1); // should fail;
+		assert(x == 0); // should hold;
+	}
+
+	modifier inc() {
+		if (x == 0) {
+			return;
+		}
+		x = x + 1;
+		_;
+	}
+
+	function test() check inc public {
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (70-84): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers_2.sol
new file mode 100644
index 00000000..d297959c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/branches_in_modifiers_2.sol
@@ -0,0 +1,50 @@
+contract C {
+
+	uint x;
+
+	function reset_if_overflow() internal postinc {
+		if (x < 10)
+			return;
+		x = 0;
+	}
+
+	modifier postinc() {
+		if (x == 0) {
+			return;
+		}
+		_;
+		x = x + 1;
+	}
+
+	function test() public {
+		if (x == 0) {
+			reset_if_overflow();
+			assert(x == 1); // should fail;
+			assert(x == 0); // should hold;
+			return;
+		}
+		if (x < 10) {
+			uint oldx = x;
+			reset_if_overflow();
+			// Disabled because of nondeterminism in Spacer Z3 4.8.9
+			//assert(oldx + 1 == x); // should hold;
+			assert(oldx == x);     // should fail;
+			return;
+		}
+		reset_if_overflow();
+		assert(x == 1); // should hold;
+		assert(x == 0); // should fail;
+	}
+
+	function set(uint _x) public {
+		x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (255-269): CHC: Assertion violation happens here.
+// Warning 6328: (502-519): CHC: Assertion violation happens here.
+// Warning 6328: (615-629): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init.sol
new file mode 100644
index 00000000..d33f9571
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init.sol
@@ -0,0 +1,42 @@
+contract A {
+	int x;
+	constructor (int a) { x = a;}
+}
+
+contract B is A {
+	int y;
+	constructor(int a) A(-a) {
+		if (a > 0) {
+			y = 2;
+			return;
+		}
+		else {
+			y = 3;
+		}
+		y = 4; // overwrites the else branch
+	}
+}
+
+contract C is B {
+	constructor(int a) B(a) {
+		assert(y != 3); // should hold
+		assert(y == 4); // should fail
+		if (a > 0) {
+			assert(x < 0 && y == 2); // should hold
+			assert(x < 0 && y == 4); // should fail
+		}
+		else {
+			assert(x >= 0 && y == 4); // should hold
+			assert(x >= 0 && y == 2); // should fail
+			assert(x > 0); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (297-311): CHC: Assertion violation happens here.
+// Warning 6328: (389-412): CHC: Assertion violation happens here.
+// Warning 6328: (489-513): CHC: Assertion violation happens here.
+// Warning 6328: (533-546): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_chain_alternate.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_chain_alternate.sol
new file mode 100644
index 00000000..22148e0b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_chain_alternate.sol
@@ -0,0 +1,30 @@
+contract A {
+	uint x = 1;
+}
+
+contract B is A {
+	constructor(int a) {
+		if (a > 0) {
+			x = 2;
+			return;
+		}
+		x = 3;
+	}
+}
+
+abstract contract C is B {
+}
+
+contract D is C {
+	constructor(int a) B(a) {
+		assert(a > 0 || x == 3); // should hold
+		assert(a <= 0 || x == 2); // should hold
+		assert(x == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (286-300): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_diamond.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_diamond.sol
new file mode 100644
index 00000000..68903703
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructor_state_variable_init_diamond.sol
@@ -0,0 +1,71 @@
+contract A {
+	int x;
+}
+
+contract B is A {
+	int y;
+	constructor (int a) {
+		if (a >= 0) {
+			y = 1;
+			return;
+		}
+		x = 1;
+		y = 2;
+	}
+}
+
+contract C is A {
+	int z;
+	constructor (int a) {
+		if (a >= 0) {
+			z = 1;
+			return;
+		}
+		x = -1;
+		z = 2;
+	}
+}
+
+contract D1 is B, C {
+	constructor() B(1) C(1) {
+		assert(x == 0); // should hold
+		assert(x == 1); // should fail
+		assert(x == -1); // should fail
+	}
+}
+
+contract D2 is B, C {
+	constructor() B(1) C(-1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should fail
+		assert(x == -1); // should hold (constructor of C is executed AFTER constructor of B)
+	}
+}
+
+contract D3 is B, C {
+	constructor() B(-1) C(1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should hold
+		assert(x == -1); // should fail
+	}
+}
+
+contract D4 is B, C {
+	constructor() B(-1) C(-1) {
+		assert(x == 0); // should fail
+		assert(x == 1); // should fail
+		assert(x == -1); // should hold (constructor of C is executed AFTER constructor of B)
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (337-351): CHC: Assertion violation happens here.
+// Warning 6328: (370-385): CHC: Assertion violation happens here.
+// Warning 6328: (460-474): CHC: Assertion violation happens here.
+// Warning 6328: (493-507): CHC: Assertion violation happens here.
+// Warning 6328: (670-684): CHC: Assertion violation happens here.
+// Warning 6328: (736-751): CHC: Assertion violation happens here.
+// Warning 6328: (827-841): CHC: Assertion violation happens here.
+// Warning 6328: (860-874): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructors.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructors.sol
new file mode 100644
index 00000000..def9bea4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/constructors.sol
@@ -0,0 +1,32 @@
+contract B {
+	int x;
+	constructor(int b) {
+		if (b > 0) {
+			x = 1;
+			return;
+		}
+		else {
+			x = 2;
+			return;
+		}
+		x = 3; // dead code
+	}
+}
+
+contract C is B {
+	constructor(int a) B(a) {
+		assert(a > 0 || x == 2); // should hold
+		assert(a <= 0 || x == 1); // should hold
+		assert(x == 3); // should fail
+		assert(x == 2); // should fail
+		assert(x == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5740: (119-124): Unreachable code.
+// Warning 6328: (277-291): CHC: Assertion violation happens here.
+// Warning 6328: (310-324): CHC: Assertion violation happens here.
+// Warning 6328: (343-357): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/nested_if.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/nested_if.sol
new file mode 100644
index 00000000..ecccf888
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/nested_if.sol
@@ -0,0 +1,27 @@
+contract C {
+
+	function test(uint256 a, uint256 b) public pure {
+		assert(nested_if(a,b) != 42); // should hold
+		assert(nested_if(a,b) == 1);  // should fail
+	}
+
+	function nested_if(uint256 a, uint256 b) internal pure returns (uint256) {
+		if (a < 5) {
+			if (b > 1) {
+				return 0;
+			}
+		}
+		if (a == 2 && b == 2) {
+			return 42; // unreachable
+		}
+		else {
+			return 1;
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (114-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (299-315): BMC: Condition is always false.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/return_in_both_branches.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/return_in_both_branches.sol
new file mode 100644
index 00000000..f5294a6b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/return_in_both_branches.sol
@@ -0,0 +1,22 @@
+contract C {
+
+	function test() public pure {
+		assert(branches(0) == 0);
+		assert(branches(1) == 42);
+	}
+
+	function branches(uint256 a) internal pure returns (uint256) {
+		if (a == 0) {
+			return 0;
+		}
+		else {
+			return 42;
+		}
+		return 1; // dead code
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5740: (232-240): Unreachable code.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if.sol
new file mode 100644
index 00000000..627ffa27
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if.sol
@@ -0,0 +1,12 @@
+contract C {
+	function test(uint256 a, uint256 b) public pure returns (uint256) {
+		if (a == 0) {
+			return 0;
+		}
+		return b / a; // This division is safe because of the early return in if-block.
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_array.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_array.sol
new file mode 100644
index 00000000..2b41f3ab
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_array.sol
@@ -0,0 +1,29 @@
+contract C {
+
+	uint[] a;
+
+	constructor () {
+		a.push();
+		a.push();
+	}
+
+	function check() public {
+		require(a.length >= 2);
+		require(a[1] == 0);
+		conditional_store();
+		assert(a[1] == 1); // should fail;
+		assert(a[1] == 0); // should hold;
+	}
+
+	function conditional_store() internal {
+		if (a[1] == 0) {
+			return;
+		}
+		a[1] = 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (172-189): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_state_var.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_state_var.sol
new file mode 100644
index 00000000..4df0b8ce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_state_var.sol
@@ -0,0 +1,23 @@
+contract C {
+
+	uint x;
+
+	function check() public {
+		require(x == 0);
+		conditional_increment();
+		assert(x == 1); // should fail;
+		assert(x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (x == 0) {
+			return;
+		}
+		x = 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (99-113): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct.sol
new file mode 100644
index 00000000..02d16893
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct.sol
@@ -0,0 +1,26 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+	S s;
+
+	function check() public {
+		require(s.x == 0);
+		conditional_increment();
+		assert(s.x == 1); // should fail;
+		assert(s.x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (s.x == 0) {
+			return;
+		}
+		s.x = 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (123-139): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct_2.sol
new file mode 100644
index 00000000..87fbcc18
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_struct_2.sol
@@ -0,0 +1,26 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+	S s;
+
+	function check() public {
+		require(s.x == 0);
+		conditional_increment();
+		assert(s.x == 1); // should fail;
+		assert(s.x == 0); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (s.x == 0) {
+			return;
+		}
+		s = S(1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (123-139): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_tuple.sol
new file mode 100644
index 00000000..f3fce1f0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/simple_if_tuple.sol
@@ -0,0 +1,28 @@
+contract C {
+
+	uint x;
+	uint y;
+
+	function check() public {
+		require(x == 0);
+		require(y == 0);
+		conditional_increment();
+		assert(x == 0); // should fail;
+		assert(x == 1); // should fail;
+		assert(x == 2); // should hold;
+	}
+
+	function conditional_increment() internal {
+		if (x == 0) {
+			(x,y) = (2,2);
+			return;
+		}
+		(x,y) = (1,1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (127-141): CHC: Assertion violation happens here.
+// Warning 6328: (161-175): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/triple_nested_if.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/triple_nested_if.sol
new file mode 100644
index 00000000..c6d6450f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/branches_with_return/triple_nested_if.sol
@@ -0,0 +1,22 @@
+contract C {
+
+    uint a;
+    uint b;
+    uint c;
+
+	function test() public view {
+		if (a == 0) {
+			if (b == 0) {
+				if (c == 0) {
+					return;
+				}
+			}
+		}
+		assert(a != 0 || b != 0 || c != 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch.sol
new file mode 100644
index 00000000..fd76ceab
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		if (true) {
+			address a = g();
+			assert(a == address(0));
+		}
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_2.sol
new file mode 100644
index 00000000..8d8cdae5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_2.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		if (true) {
+			address a = g();
+			assert(a == address(0));
+		}
+		else
+		{
+			address b = g();
+			assert(b == address(0));
+		}
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_3.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_3.sol
new file mode 100644
index 00000000..462ff871
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_3.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		if (true) {
+			address a = g();
+			assert(a == address(0));
+		}
+		if (true) {
+			address a = g();
+			assert(a == address(0));
+		}
+
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_4.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_4.sol
new file mode 100644
index 00000000..dbe7fc07
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_branch_4.sol
@@ -0,0 +1,28 @@
+contract C
+{
+	function f() public pure {
+		if (true) {
+			address a = g();
+			assert(a == address(0));
+		}
+		if (true) {
+			address a = h();
+			assert(a == address(0));
+		}
+
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+	function h() public pure returns (address) {
+		address a;
+		return a;
+	}
+
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_else_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_else_branch.sol
new file mode 100644
index 00000000..b99811b8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_else_branch.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() public pure {
+		if (true) {
+		} else {
+			address a = g();
+			assert(a == address(0));
+		}
+	}
+	function g() public pure returns (address) {
+		address x;
+		x = address(0);
+		return x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_modifier_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_modifier_branch.sol
new file mode 100644
index 00000000..52f11010
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_modifier_branch.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	modifier m(address a) {
+		if (true) {
+			a = g();
+			_;
+			assert(a == address(0));
+		}
+	}
+
+	function f(address a) m(a) public pure {
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_placeholder_inside_modifier_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_placeholder_inside_modifier_branch.sol
new file mode 100644
index 00000000..ce535462
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/function_call_inside_placeholder_inside_modifier_branch.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	modifier m {
+		if (true)
+			_;
+	}
+
+	function f(address a) m public pure {
+		if (true) {
+			a = g();
+			assert(a == address(0));
+		}
+	}
+	function g() public pure returns (address) {
+		address a;
+		a = address(0);
+		return a;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/require.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/require.sol
new file mode 100644
index 00000000..31b243a3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/require.sol
@@ -0,0 +1,35 @@
+contract C {
+	function f() pure public {
+		require(false);
+		// This is not reachable.
+		assert(false);
+	}
+
+	function g() pure public {
+		require(false, "require message");
+		// This is not reachable.
+		assert(false);
+	}
+
+	function h(bool b) pure public {
+		if (b)
+			require(false);
+		assert(!b);
+	}
+
+	// Check that arguments are evaluated.
+	bool x = false;
+	function m() view internal returns (string memory) {
+		assert(x != true);
+	}
+	function i() public {
+		x = true;
+		require(false, m());
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (396-409): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (415-432): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1.sol
new file mode 100644
index 00000000..2d532f77
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1.sol
@@ -0,0 +1,22 @@
+contract C {
+	function add(uint x, uint y) internal pure returns (uint) {
+		if (y == 0)
+			return x;
+		if (y == 1)
+			return ++x;
+		if (y == 2)
+			return x + 2;
+		return x + y;
+	}
+
+	function f() public pure {
+		assert(add(100, 0) == 100);
+		assert(add(100, 1) == 101);
+		assert(add(100, 2) == 102);
+		assert(add(100, 100) == 200);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1_fail.sol
new file mode 100644
index 00000000..375e7260
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_1_fail.sol
@@ -0,0 +1,27 @@
+contract C {
+	function add(uint x, uint y) internal pure returns (uint) {
+		if (y == 0)
+			return x;
+		if (y == 1)
+			return ++x;
+		if (y == 2)
+			return x + 2;
+		return x + y;
+	}
+
+	function f() public pure {
+		assert(add(100, 0) != 100);
+		assert(add(100, 1) != 101);
+		assert(add(100, 2) != 102);
+		assert(add(100, 100) != 200);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (211-237): CHC: Assertion violation happens here.
+// Warning 6328: (241-267): CHC: Assertion violation happens here.
+// Warning 6328: (271-297): CHC: Assertion violation happens here.
+// Warning 6328: (301-329): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2.sol
new file mode 100644
index 00000000..92f030e8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2.sol
@@ -0,0 +1,31 @@
+contract C {
+	uint c;
+	function add(uint x, uint y) internal returns (uint) {
+		c = 0xff;
+		if (y == 0)
+			return x;
+		c = 0xffff;
+		if (y == 1)
+			return ++x;
+		c = 0xffffff;
+		if (y == 2)
+			return x + 2;
+		c = 0xffffffff;
+		return x + y;
+	}
+
+	function f() public {
+		assert(add(100, 0) == 100);
+		assert(c == 0xff);
+		assert(add(100, 1) == 101);
+		assert(c == 0xffff);
+		assert(add(100, 2) == 102);
+		assert(c == 0xffffff);
+		assert(add(100, 100) == 200);
+		assert(c == 0xffffffff);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 11 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2_fail.sol
new file mode 100644
index 00000000..0596647d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/return_2_fail.sol
@@ -0,0 +1,40 @@
+contract C {
+	uint c;
+	function add(uint x, uint y) internal returns (uint) {
+		c = 0xff;
+		if (y == 0)
+			return x;
+		c = 0xffff;
+		if (y == 1)
+			return ++x;
+		c = 0xffffff;
+		if (y == 2)
+			return x + 2;
+		c = 0xffffffff;
+		return x + y;
+	}
+
+	function f() public {
+		assert(add(100, 0) != 100);
+		assert(c != 0xff);
+		assert(add(100, 1) != 101);
+		assert(c != 0xffff);
+		assert(add(100, 2) != 102);
+		assert(c != 0xffffff);
+		assert(add(100, 100) != 200);
+		assert(c != 0xffffffff);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (270-296): CHC: Assertion violation happens here.
+// Warning 6328: (300-317): CHC: Assertion violation happens here.
+// Warning 6328: (321-347): CHC: Assertion violation happens here.
+// Warning 6328: (351-370): CHC: Assertion violation happens here.
+// Warning 6328: (374-400): CHC: Assertion violation happens here.
+// Warning 6328: (404-425): CHC: Assertion violation happens here.
+// Warning 6328: (429-457): CHC: Assertion violation happens here.
+// Warning 6328: (461-484): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/revert.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/revert.sol
new file mode 100644
index 00000000..a19e745a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/revert.sol
@@ -0,0 +1,37 @@
+contract C {
+	function f() pure public {
+		revert();
+		// This is not reachable.
+		assert(false);
+	}
+
+	function g() pure public {
+		revert("revert message");
+		// This is not reachable.
+		assert(false);
+	}
+
+	function h(bool b) pure public {
+		if (b)
+			revert();
+		assert(!b);
+	}
+
+	// Check that arguments are evaluated.
+	bool x = false;
+	function m() view internal returns (string memory) {
+		assert(x != true);
+	}
+	function i() public {
+		x = true;
+		revert(m());
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5740: (83-96): Unreachable code.
+// Warning 5740: (188-201): Unreachable code.
+// Warning 6321: (375-388): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (394-411): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/revert_complex_flow.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/revert_complex_flow.sol
new file mode 100644
index 00000000..848f1edb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/revert_complex_flow.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f(bool b, uint a) pure public {
+		require(a <= 256);
+		if (b)
+			revert();
+		uint c = a + 1;
+		if (b)
+			c--;
+		else
+			c++;
+		assert(c == a);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (150-164): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (122-123): BMC: Condition is always false.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and.sol
new file mode 100644
index 00000000..118e66ce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and.sol
@@ -0,0 +1,18 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() == 0) && (f() == 0);
+		assert(x == 1);
+		assert(!b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_fail.sol
new file mode 100644
index 00000000..a38ffdf8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_fail.sol
@@ -0,0 +1,20 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() == 0) && (f() == 0);
+		assert(x == 1);
+		assert(b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (194-203): CHC: Assertion violation happens here.\nCounterexample:\nx = 1\n = false\nb = false\n\nTransaction trace:\nc.constructor()\nState: x = 0\nc.g()\n    c.f() -- internal call\n    c.f() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_inside_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_inside_branch.sol
new file mode 100644
index 00000000..0f4736f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_inside_branch.sol
@@ -0,0 +1,22 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		bool b;
+			x = 100;
+			b = f() > 0;
+			assert(x == 102);
+			// Should fail.
+			assert(!b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (169-185): CHC: Assertion violation happens here.
+// Warning 6328: (209-219): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both.sol
new file mode 100644
index 00000000..0b79769d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both.sol
@@ -0,0 +1,18 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 0) && (f() > 0);
+		assert(x == 2);
+		assert(b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both_fail.sol
new file mode 100644
index 00000000..a5337675
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_and_need_both_fail.sol
@@ -0,0 +1,20 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 0) && (f() > 0);
+		assert(x == 2);
+		assert(!b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (192-202): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n = false\nb = true\n\nTransaction trace:\nc.constructor()\nState: x = 0\nc.g()\n    c.f() -- internal call\n    c.f() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or.sol
new file mode 100644
index 00000000..437a7890
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or.sol
@@ -0,0 +1,18 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 0) || (f() > 0);
+		assert(x == 1);
+		assert(b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_fail.sol
new file mode 100644
index 00000000..c60dcc11
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_fail.sol
@@ -0,0 +1,20 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 0) || (f() > 0);
+		assert(x == 1);
+		assert(!b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (192-202): CHC: Assertion violation happens here.\nCounterexample:\nx = 1\n = false\nb = true\n\nTransaction trace:\nc.constructor()\nState: x = 0\nc.g()\n    c.f() -- internal call\n    c.f() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_inside_branch.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_inside_branch.sol
new file mode 100644
index 00000000..8d23f1e4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_inside_branch.sol
@@ -0,0 +1,28 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g(bool a) public returns (bool) {
+		bool b;
+		if (a) {
+			x = 0;
+			b = (f() > 0) || (f() > 0);
+			assert(x == 1);
+			assert(b);
+		} else {
+			x = 100;
+			b = (f() == 0) || (f() > 0);
+			assert(x == 102);
+			// Should fail.
+			assert(!b);
+		}
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (327-337): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both.sol
new file mode 100644
index 00000000..237a9000
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both.sol
@@ -0,0 +1,18 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 1) || (f() > 1);
+		assert(x == 2);
+		assert(b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both_fail.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both_fail.sol
new file mode 100644
index 00000000..e528cf49
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/short_circuit_or_need_both_fail.sol
@@ -0,0 +1,20 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+	function g() public returns (bool) {
+		x = 0;
+		bool b = (f() > 1) || (f() > 1);
+		assert(x == 2);
+		assert(!b);
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (192-202): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n = false\nb = true\n\nTransaction trace:\nc.constructor()\nState: x = 0\nc.g()\n    c.f() -- internal call\n    c.f() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_1.sol
new file mode 100644
index 00000000..9bea0383
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_1.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() public pure {
+        uint x;
+        if (++x < 3) {}
+
+        assert(x == 1); // should hold
+        assert(x != 1); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 6838: (72-79): BMC: Condition is always true.
+// Warning 4661: (132-146): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_2.sol
new file mode 100644
index 00000000..1780a7e2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_2.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint x;
+
+    function inc() internal returns (uint) {
+        // BMC inlines function calls and also looks at functions in isolation,
+        // therefore it says once that this is safe, when called by `f`,
+        // but also that it is unsafe just looking at this function (false positive).
+        ++x;
+        return x;
+    }
+
+    function f() public {
+        require(x < 1000);
+        uint y = x;
+        if (inc() < 3) {}
+
+        assert(x == y + 1); // should hold
+        assert(x != y + 1); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 2661: (318-321): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4661: (499-517): BMC: Assertion violation happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_3.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_3.sol
new file mode 100644
index 00000000..2e415a7b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_3.sol
@@ -0,0 +1,30 @@
+contract C {
+    uint x;
+
+    function inc() internal returns (uint) {
+        // BMC inlines function calls and also looks at functions in isolation,
+        // therefore it says once that this is safe, when called by `f`,
+        // but also that it is unsafe just looking at this function (false positive).
+        ++x;
+        return x;
+    }
+
+    function inc2() internal returns (uint) {
+        return inc();
+    }
+
+    function f() public {
+        require(x < 1000);
+        uint y = x;
+        if (inc2() < 3) {}
+
+        assert(x == y + 1); // should hold
+        assert(x != y + 1); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 2661: (318-321): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4661: (575-593): BMC: Assertion violation happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_4.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_4.sol
new file mode 100644
index 00000000..6e624184
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_if_4.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() public pure {
+        uint x = 2;
+        if (--x < 3) {}
+
+        assert(x == 1); // should hold
+        assert(x != 1); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 6838: (76-83): BMC: Condition is always true.
+// Warning 4661: (136-150): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_1.sol
new file mode 100644
index 00000000..9801b99b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_1.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public pure {
+        uint x;
+        uint y = (++x < 3) ? ++x : --x;
+
+        assert(y == x); // should hold;
+        assert(x == 2); // should hold
+        assert(x != 2); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 6838: (77-86): BMC: Condition is always true.
+// Warning 4661: (188-202): BMC: Assertion violation happens here.
+// Info 6002: BMC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_2.sol
new file mode 100644
index 00000000..54d72960
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_2.sol
@@ -0,0 +1,27 @@
+contract C {
+    uint x;
+
+    function inc() internal returns (uint) {
+        // BMC inlines function calls and also looks at functions in isolation,
+        // therefore it says once that this is safe, when called by `f`,
+        // but also that it is unsafe just looking at this function (false positive).
+        ++x;
+        return x;
+    }
+
+    function f() public {
+        require(x < 1000);
+        uint z = x;
+        uint y = (inc() < 3) ? inc() : inc();
+
+        assert(y == x);
+        assert(x == z + 2); // should hold
+        assert(x != z + 2); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 2661: (318-321): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4661: (543-561): BMC: Assertion violation happens here.
+// Info 6002: BMC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_3.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_3.sol
new file mode 100644
index 00000000..18e36c8f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_3.sol
@@ -0,0 +1,31 @@
+contract C {
+    uint x;
+
+    function inc() internal returns (uint) {
+        // BMC inlines function calls and also looks at functions in isolation,
+        // therefore it says once that this is safe, when called by `f`,
+        // but also that it is unsafe just looking at this function (false positive).
+        ++x;
+        return x;
+    }
+
+    function inc2() internal returns (uint) {
+        return inc();
+    }
+
+    function f() public {
+        require(x < 1000);
+        uint z = x;
+        uint y = (inc2() < 3) ? inc2() : inc2();
+
+        assert(y == x); // should hold
+        assert(x == z + 2); // should hold
+        assert(x != z + 2); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 2661: (318-321): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4661: (636-654): BMC: Assertion violation happens here.
+// Info 6002: BMC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_4.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_4.sol
new file mode 100644
index 00000000..e24cdf29
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/side_effects_inside_ternary_4.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public pure {
+        uint x = 2;
+        uint y = (--x < 3) ? --x : 0;
+
+        assert(y == x); // should hold
+        assert(x == 0); // should hold
+        assert(x != 0); // should fail
+    }
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 6838: (81-90): BMC: Condition is always true.
+// Warning 4661: (189-203): BMC: Assertion violation happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_1.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_1.sol
new file mode 100644
index 00000000..ce0ce630
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_1.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+            a++;
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (127-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_2.sol b/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_2.sol
new file mode 100644
index 00000000..4ceff5f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/control_flow/ways_to_merge_variables_2.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(uint x) public pure {
+        uint a = 3;
+        if (x > 10) {
+            ++a;
+        }
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (127-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_compare_hashes.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_compare_hashes.sol
new file mode 100644
index 00000000..a49aeac0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_compare_hashes.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(bytes memory data) public pure {
+		bytes32 k = keccak256(data);
+		bytes32 s = sha256(data);
+		bytes32 r = ripemd160(data);
+		assert(k == s);
+		assert(s == r);
+		assert(r == k);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (150-164): CHC: Assertion violation happens here.
+// Warning 6328: (168-182): CHC: Assertion violation happens here.
+// Warning 6328: (186-200): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_fail.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_fail.sol
new file mode 100644
index 00000000..8485b89a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_fail.sol
@@ -0,0 +1,36 @@
+contract C {
+	function k(bytes memory b0, bytes memory b1) public pure {
+		bytes32 k0 = keccak256(b0);
+		bytes32 k1 = keccak256(b1);
+		assert(k0 == k1);
+	}
+	function s(bytes memory b0, bytes memory b1) public pure {
+		bytes32 s0 = sha256(b0);
+		bytes32 s1 = sha256(b1);
+		// Disabled because of Spacer nondeterminism.
+		//assert(s0 == s1);
+	}
+	function r(bytes memory b0, bytes memory b1) public pure {
+		bytes32 r0 = ripemd160(b0);
+		bytes32 r1 = ripemd160(b1);
+		// Disabled because of Spacer nondeterminism.
+		//assert(r0 == r1);
+	}
+	function e(bytes32 h0, uint8 v0, bytes32 r0, bytes32 s0, bytes32 h1, uint8 v1, bytes32 r1, bytes32 s1) public pure {
+		address a0 = ecrecover(h0, v0, r0, s0);
+		address a1 = ecrecover(h1, v1, r1, s1);
+		// Disabled because of Spacer nondeterminism.
+		//assert(a0 == a1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2072: (218-228): Unused local variable.
+// Warning 2072: (245-255): Unused local variable.
+// Warning 2072: (405-415): Unused local variable.
+// Warning 2072: (435-445): Unused local variable.
+// Warning 2072: (656-666): Unused local variable.
+// Warning 2072: (698-708): Unused local variable.
+// Warning 6328: (135-151): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_not_same.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_not_same.sol
new file mode 100644
index 00000000..a8c6199d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_not_same.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(bytes memory data) public pure {
+		bytes32 k = keccak256(data);
+		fi(data, k);
+	}
+	function fi(bytes memory data, bytes32 k) internal pure {
+		bytes32 h = sha256(data);
+		assert(h == k);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (196-210): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_over_blocks.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_over_blocks.sol
new file mode 100644
index 00000000..99d6f7c7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_over_blocks.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bytes memory data) public pure {
+		bytes32 k = keccak256(data);
+		fi(data, k);
+	}
+	function fi(bytes memory data, bytes32 k) internal pure {
+		bytes32 h = keccak256(data);
+		assert(h == k);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output.sol
new file mode 100644
index 00000000..a39cfc88
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output.sol
@@ -0,0 +1,40 @@
+contract C {
+	bytes data;
+	bytes32 h;
+	uint8 v;
+	bytes32 r;
+	bytes32 s;
+
+	bytes32 kec;
+	bytes32 sha;
+	bytes32 rip;
+	address erc;
+
+	constructor(bytes memory _data, bytes32 _h, uint8 _v, bytes32 _r, bytes32 _s) {
+		data = _data;
+		h = _h;
+		v = _v;
+		r = _r;
+		s = _s;
+
+		kec = keccak256(data);
+		sha = sha256(data);
+		rip = ripemd160(data);
+		erc = ecrecover(h, v, r, s);
+	}
+
+	function f() public view {
+		bytes32 _kec = keccak256(data);
+		bytes32 _sha = sha256(data);
+		bytes32 _rip = ripemd160(data);
+		address _erc = ecrecover(h, v, r, s);
+		assert(_kec == kec);
+		assert(_sha == sha);
+		assert(_rip == rip);
+		assert(_erc == erc);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output_fail.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output_fail.sol
new file mode 100644
index 00000000..c088b121
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_over_state_same_output_fail.sol
@@ -0,0 +1,52 @@
+contract C {
+	bytes data;
+	bytes32 h;
+	uint8 v;
+	bytes32 r;
+	bytes32 s;
+
+	bytes32 kec;
+	bytes32 sha;
+	bytes32 rip;
+	address erc;
+
+	constructor(bytes memory _data, bytes32 _h, uint8 _v, bytes32 _r, bytes32 _s) {
+		data = _data;
+		h = _h;
+		v = _v;
+		r = _r;
+		s = _s;
+
+		kec = keccak256(data);
+		sha = sha256(data);
+		rip = ripemd160(data);
+		erc = ecrecover(h, v, r, s);
+	}
+
+	function set(bytes memory _data, bytes32 _h, uint8 _v, bytes32 _r, bytes32 _s) public {
+		data = _data;
+		h = _h;
+		v = _v;
+		r = _r;
+		s = _s;
+	}
+
+	function f() public view {
+		bytes32 _kec = keccak256(data);
+		bytes32 _sha = sha256(data);
+		bytes32 _rip = ripemd160(data);
+		address _erc = ecrecover(h, v, r, s);
+		assert(_kec == kec);
+		assert(_sha == sha);
+		assert(_rip == rip);
+		assert(_erc == erc);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (693-712): CHC: Assertion violation happens here.\nCounterexample:\nh = 0x0, v = 0, r = 0x0, s = 0x0, kec = 0x52f7, sha = 0x0, rip = 0x0, erc = 0x0\n_kec = 0x52f6\n_sha = 0x2e15\n_rip = 0x2297\n_erc = 0x0985\n\nTransaction trace:\nC.constructor(_data, 0x23c6, 198, 0x1599, 0x1980)\nState: h = 0x23c6, v = 198, r = 0x1599, s = 0x1980, kec = 0x52f7, sha = 0x0, rip = 0x0, erc = 0x0\nC.set(_data, 0x0, 0, 0x0, 0x0)\nState: h = 0x0, v = 0, r = 0x0, s = 0x0, kec = 0x52f7, sha = 0x0, rip = 0x0, erc = 0x0\nC.f()
+// Warning 6328: (716-735): CHC: Assertion violation happens here.\nCounterexample:\nh = 0x0, v = 0, r = 0x0, s = 0x0, kec = 0x0986, sha = 0x0, rip = 0x0, erc = 0x0\n_kec = 0x0985\n_sha = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdd68\n_rip = 0x20ad\n_erc = 0x2e15\n\nTransaction trace:\nC.constructor([0x19, 0x19, 0x19, 0x19, 0x19, 0x38, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x2b, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x36, 0x19, 0x19, 0x39, 0x19, 0x3b, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19], 0x1169, 88, 0x0a12, 0x1599)\nState: data = [0x19, 0x19, 0x19, 0x19, 0x19, 0x38, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x2b, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x36, 0x19, 0x19, 0x39, 0x19, 0x3b, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19], h = 0x1169, v = 88, r = 0x0a12, s = 0x1599, kec = 0x0986, sha = 0x0, rip = 0x0, erc = 0x0\nC.set(_data, 0x0, 0, 0x0, 0x0)\nState: h = 0x0, v = 0, r = 0x0, s = 0x0, kec = 0x0986, sha = 0x0, rip = 0x0, erc = 0x0\nC.f()
+// Warning 6328: (739-758): CHC: Assertion violation happens here.
+// Warning 6328: (762-781): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_same_output.sol b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_same_output.sol
new file mode 100644
index 00000000..a6abfdec
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/crypto/crypto_functions_same_input_same_output.sol
@@ -0,0 +1,30 @@
+contract C {
+	function k(bytes memory b0) public pure {
+		bytes memory b1 = b0;
+		bytes32 k0 = keccak256(b0);
+		bytes32 k1 = keccak256(b1);
+		assert(k0 == k1);
+	}
+	function s(bytes memory b0) public pure {
+		bytes memory b1 = b0;
+		bytes32 s0 = sha256(b0);
+		bytes32 s1 = sha256(b1);
+		assert(s0 == s1);
+	}
+	function r(bytes memory b0) public pure {
+		bytes memory b1 = b0;
+		bytes32 r0 = ripemd160(b0);
+		bytes32 r1 = ripemd160(b1);
+		assert(r0 == r1);
+	}
+	function e(bytes32 h0, uint8 v0, bytes32 r0, bytes32 s0) public pure {
+		(bytes32 h1, uint8 v1, bytes32 r1, bytes32 s1) = (h0, v0, r0, s0);
+		address a0 = ecrecover(h0, v0, r0, s0);
+		address a1 = ecrecover(h1, v1, r1, s1);
+		assert(a0 == a1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_trusted.sol
new file mode 100644
index 00000000..81ddc515
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_trusted.sol
@@ -0,0 +1,18 @@
+contract D {
+	uint x;
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	function g() public {
+		D d = new D();
+		uint y = d.f();
+		assert(y == 0); // should fail in BMC
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTExtCalls: trusted
+// ----
+// Warning 8729: (124-131): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 4661: (153-167): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_untrusted.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_untrusted.sol
new file mode 100644
index 00000000..f69a8d6c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_bmc_untrusted.sol
@@ -0,0 +1,17 @@
+contract D {
+	uint x;
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	function g() public {
+		D d = new D();
+		uint y = d.f();
+		assert(y == 0); // should fail in ext calls untrusted mode
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 8729: (124-131): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 4661: (153-167): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted.sol
new file mode 100644
index 00000000..00d0f5d6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted.sol
@@ -0,0 +1,17 @@
+contract D {
+	uint x;
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	function g() public {
+		D d = new D();
+		uint y = d.f();
+		assert(y == 0); // should hold in ext calls trusted mode
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_addresses.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_addresses.sol
new file mode 100644
index 00000000..01c68790
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_addresses.sol
@@ -0,0 +1,19 @@
+contract D {
+	uint x;
+}
+
+contract C {
+	function f() public {
+		D d1 = new D();
+		D d2 = new D();
+
+		assert(d1 != d2); // should hold in ext calls trusted mode
+		assert(address(this) != address(d1)); // should hold in ext calls trusted mode
+		assert(address(this) != address(d2)); // should hold in ext calls trusted mode
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_flow.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_flow.sol
new file mode 100644
index 00000000..09f00171
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_flow.sol
@@ -0,0 +1,30 @@
+contract D {
+	uint x;
+	function inc() public { ++x; }
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	function f() public {
+		D d = new D();
+		assert(d.f() == 0); // should hold
+		d.inc();
+		assert(d.f() == 1); // should hold
+		d = new D();
+		assert(d.f() == 0); // should hold
+		assert(d.f() == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 4984: (47-50): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 6328: (167-185): CHC: Assertion violation might happen here.
+// Warning 6328: (215-233): CHC: Assertion violation might happen here.
+// Warning 6328: (304-322): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (47-50): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4661: (167-185): BMC: Assertion violation happens here.
+// Warning 4661: (215-233): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_keep_storage_constraints.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_keep_storage_constraints.sol
new file mode 100644
index 00000000..f31f9a3e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_keep_storage_constraints.sol
@@ -0,0 +1,17 @@
+contract D {
+	uint x;
+}
+
+contract C {
+	uint y;
+	function g() public {
+		D d = new D();
+		assert(y == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Warning 2072: (72-75): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow.sol
new file mode 100644
index 00000000..b2712306
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint x;
+	function inc() public { ++x; }
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	D d;
+	constructor() {
+		d = new D();
+		assert(d.f() == 0); // should hold
+	}
+	function g() public view {
+		assert(d.f() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 4984: (47-50): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 6328: (233-251): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (47-50): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_2.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_2.sol
new file mode 100644
index 00000000..0f904454
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_2.sol
@@ -0,0 +1,20 @@
+contract D {
+	uint x;
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	D d;
+	constructor() {
+		d = new D();
+		assert(d.f() == 0); // should hold
+	}
+	function g() public view {
+		assert(d.f() == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_3.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_3.sol
new file mode 100644
index 00000000..260909b8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_3.sol
@@ -0,0 +1,21 @@
+contract D {
+	uint x;
+	function s(uint _x) public { x = _x; }
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	D d;
+	constructor() {
+		d = new D();
+	}
+	function g() public view {
+		assert(d.f() == 0); // should fail
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (204-222): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_4.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_4.sol
new file mode 100644
index 00000000..5bd27c3b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_trusted_state_flow_4.sol
@@ -0,0 +1,20 @@
+contract D {
+	bool b;
+	function s() public { b = true; }
+	function f() public view returns (bool) { return b; }
+}
+
+contract C {
+	D d;
+	constructor() {
+		d = new D();
+	}
+	function g() public view {
+		assert(d.f()); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (199-212): CHC: Assertion violation happens here.\nCounterexample:\nd = (- 1)\n\nTransaction trace:\nC.constructor()\nState: d = (- 1)\nC.g()\n    D.f() -- trusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted.sol
new file mode 100644
index 00000000..a28d4621
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted.sol
@@ -0,0 +1,17 @@
+contract D {
+	uint x;
+	function f() public view returns (uint) { return x; }
+}
+
+contract C {
+	function g() public {
+		D d = new D();
+		uint y = d.f();
+		assert(y == 0); // should fail in ext calls untrusted mode
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8729: (124-131): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 6328: (153-167): CHC: Assertion violation happens here.\nCounterexample:\n\nd = 0\ny = 1\n\nTransaction trace:\nC.constructor()\nC.g()\n    d.f() -- untrusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_addresses.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_addresses.sol
new file mode 100644
index 00000000..c934e152
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_addresses.sol
@@ -0,0 +1,22 @@
+contract D {
+	uint x;
+}
+
+contract C {
+	function f() public {
+		D d1 = new D();
+		D d2 = new D();
+
+		assert(d1 != d2); // should fail in ext calls untrusted mode
+		assert(address(this) != address(d1)); // should fail in ext calls untrusted mode
+		assert(address(this) != address(d2)); // should fail in ext calls untrusted mode
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8729: (70-77): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 8729: (88-95): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 6328: (100-116): CHC: Assertion violation happens here.\nCounterexample:\n\nd1 = 0\nd2 = 0\n\nTransaction trace:\nC.constructor()\nC.f()
+// Warning 6328: (163-199): CHC: Assertion violation happens here.\nCounterexample:\n\nd1 = 21238\nd2 = 21238\n\nTransaction trace:\nC.constructor()\nC.f()
+// Warning 6328: (246-282): CHC: Assertion violation happens here.\nCounterexample:\n\nd1 = 21238\nd2 = 21238\n\nTransaction trace:\nC.constructor()\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_erase_storage_constraints.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_erase_storage_constraints.sol
new file mode 100644
index 00000000..be18b33f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deploy_untrusted_erase_storage_constraints.sol
@@ -0,0 +1,17 @@
+contract D {
+	uint x;
+}
+
+contract C {
+	uint y;
+	function g() public {
+		D d = new D();
+		assert(y == 0); // should fail in ext calls untrusted mode
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2072: (72-75): Unused local variable.
+// Warning 8729: (78-85): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 6328: (89-103): CHC: Assertion violation happens here.\nCounterexample:\ny = 1\nd = 0\n\nTransaction trace:\nC.constructor()\nState: y = 0\nC.g()
diff --git a/compiler/test/libsolidity/smtCheckerTests/deployment/deployment_trusted_with_value_1.sol b/compiler/test/libsolidity/smtCheckerTests/deployment/deployment_trusted_with_value_1.sol
new file mode 100644
index 00000000..37f5ca80
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/deployment/deployment_trusted_with_value_1.sol
@@ -0,0 +1,21 @@
+contract A {
+	constructor() payable {}
+}
+
+contract B {
+	function f() public payable {
+		require(address(this).balance == 100);
+		A a = new A{value: 50}();
+		assert(address(this).balance == 50); // should hold
+		assert(address(this).balance == 60); // should fail
+		assert(address(a).balance >= 50); // should hold
+		assert(address(a).balance == 50); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (211-246): CHC: Assertion violation happens here.
+// Warning 6328: (316-348): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_1.sol
new file mode 100644
index 00000000..985ee26d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_1.sol
@@ -0,0 +1,29 @@
+contract D {
+	constructor(uint _x) { x = _x; }
+	uint public x;
+}
+
+contract E {
+	constructor() { x = 2; }
+	uint public x;
+}
+
+contract C {
+	constructor() {
+		address d = address(new D(42));
+		assert(D(d).x() == 42); // should hold
+		assert(D(d).x() == 43); // should fail
+		uint y = E(d).x();
+		assert(y == 2); // should fail, it would still call D.x() == 42
+		assert(y == 42); // should hold, but fails due to false positive
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (231-253): CHC: Assertion violation happens here.
+// Warning 6328: (293-307): CHC: Assertion violation happens here.
+// Warning 6328: (359-374): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_2.sol
new file mode 100644
index 00000000..b078a32e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_constructor_trusted_2.sol
@@ -0,0 +1,26 @@
+contract D {
+	constructor(uint _x) { x = _x; }
+	function setD(uint _x) public { x = _x; }
+	uint public x;
+}
+
+contract C {
+	constructor() {
+		address d = address(new D(42));
+		assert(D(d).x() == 42); // should hold
+		assert(D(d).x() == 21); // should fail
+		d.call(abi.encodeCall(D.setD, (21)));
+		assert(D(d).x() == 21); // should hold, but false positive cus low level calls are not handled precisely
+		assert(D(d).x() == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// ----
+// Warning 9302: (257-293): Return value of low-level calls not used.
+// Warning 6328: (216-238): CHC: Assertion violation happens here.
+// Warning 6328: (297-319): CHC: Assertion violation happens here.
+// Warning 6328: (404-426): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_1.sol
new file mode 100644
index 00000000..904a5967
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_1.sol
@@ -0,0 +1,29 @@
+contract D {
+	constructor(uint _x) { x = _x; }
+	uint public x;
+}
+
+contract E {
+	constructor() { x = 2; }
+	uint public x;
+}
+
+contract C {
+	function f() public {
+		address d = address(new D(42));
+		assert(D(d).x() == 42); // should hold
+		assert(D(d).x() == 43); // should fail
+		uint y = E(d).x();
+		assert(y == 2); // should fail, it would still call D.x() == 42
+		assert(y == 42); // should hold, but fails due to false positive
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (237-259): CHC: Assertion violation happens here.
+// Warning 6328: (299-313): CHC: Assertion violation happens here.
+// Warning 6328: (365-380): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_2.sol
new file mode 100644
index 00000000..41d771b5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_2.sol
@@ -0,0 +1,26 @@
+contract D {
+	constructor(uint _x) { x = _x; }
+	function setD(uint _x) public { x = _x; }
+	uint public x;
+}
+
+contract C {
+	function f() public {
+		address d = address(new D(42));
+		assert(D(d).x() == 42); // should hold
+		assert(D(d).x() == 21); // should fail
+		d.call(abi.encodeCall(D.setD, (21)));
+		assert(D(d).x() == 21); // should hold, but false positive cus low level calls are not handled precisely
+		assert(D(d).x() == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// ----
+// Warning 9302: (263-299): Return value of low-level calls not used.
+// Warning 6328: (222-244): CHC: Assertion violation happens here.
+// Warning 6328: (303-325): CHC: Assertion violation happens here.
+// Warning 6328: (410-432): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_3.sol
new file mode 100644
index 00000000..b224dae2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_abstract_trusted_3.sol
@@ -0,0 +1,30 @@
+contract D {
+	constructor(uint _x) { x = _x; }
+	function setD(uint _x) public { x = _x; }
+	uint public x;
+}
+
+contract C {
+	uint x;
+
+	function f() public {
+		x = 666;
+		address d = address(new D(42));
+		assert(D(d).x() == 42); // should hold
+		assert(D(d).x() == 21); // should fail
+		d.call(abi.encodeCall(D.setD, (21)));
+		assert(D(d).x() == 21); // should hold, but false positive cus low level calls are not handled precisely
+		assert(D(d).x() == 42); // should fail
+		assert(x == 666); // should hold, C's storage should not have been havoced
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// ----
+// Warning 9302: (284-320): Return value of low-level calls not used.
+// Warning 6328: (243-265): CHC: Assertion violation happens here.
+// Warning 6328: (324-346): CHC: Assertion violation happens here.
+// Warning 6328: (431-453): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_1.sol
new file mode 100644
index 00000000..9c29f329
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_1.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint x;
+	constructor(address _a) {
+		_a.call("aaaa");
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (51-66): Return value of low-level calls not used.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_2.sol
new file mode 100644
index 00000000..b7e735b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_constructor_2.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint x;
+	function f(uint _x) public {
+		x = _x;
+	}
+	constructor(address _a) {
+		_a.call("aaaa");
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (94-109): Return value of low-level calls not used.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex.sol
new file mode 100644
index 00000000..f238fd63
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint x;
+
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+
+	function set(uint _x) mutex public {
+		x = _x;
+	}
+
+	function f(address _a) mutex public {
+		uint y = x;
+		_a.call("aaaaa");
+		assert(y == x); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (218-234): Return value of low-level calls not used.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex_unsafe.sol
new file mode 100644
index 00000000..e8c17d3e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_mutex_unsafe.sol
@@ -0,0 +1,27 @@
+contract C {
+	uint x;
+
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+
+	function set(uint _x) mutex public {
+		x = _x;
+	}
+
+	function f(address _a) public {
+		uint y = x;
+		_a.call("aaaaa");
+		assert(y == x); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 9302: (212-228): Return value of low-level calls not used.
+// Warning 6328: (232-246): CHC: Assertion violation happens here.\nCounterexample:\nx = 0, lock = false\n_a = 0x0\ny = 1\n\nTransaction trace:\nC.constructor()\nState: x = 0, lock = false\nC.set(1)\nState: x = 1, lock = false\nC.f(0x0)\n    _a.call("aaaaa") -- untrusted external call, synthesized as:\n        C.set(0) -- reentrant call
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_reentrancy_view.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_reentrancy_view.sol
new file mode 100644
index 00000000..89ed906f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_reentrancy_view.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x;
+	function s(uint _x) public view {
+		x == _x;
+	}
+	function f(address a) public {
+		(bool s, bytes memory data) = a.call("");
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 2519: (106-112): This declaration shadows an existing declaration.
+// Warning 2072: (106-112): Unused local variable.
+// Warning 2072: (114-131): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/call_safe.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_safe.sol
new file mode 100644
index 00000000..0f6548d9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/call_safe.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint x;
+	function f(address a) public {
+		(bool s, bytes memory data) = a.call("");
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// ----
+// Warning 2072: (57-63): Unused local variable.
+// Warning 2072: (65-82): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external.sol
new file mode 100644
index 00000000..5ddb61a2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external.sol
@@ -0,0 +1,21 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+	uint x;
+	D d;
+	function f() public {
+		if (x < 10)
+			++x;
+	}
+	function g() public {
+		d.d();
+		assert(x < 10);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (167-181): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_1_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_1_trusted.sol
new file mode 100644
index 00000000..6f2b717b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_1_trusted.sol
@@ -0,0 +1,22 @@
+contract State {
+	function f(uint _x) public pure returns (uint) {
+		assert(_x < 100); // should fail
+		return _x;
+	}
+}
+contract C {
+	State s;
+	uint z = s.f(2);
+
+	function f() public view {
+		assert(z == 2); // should hold in trusted mode
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: all
+// SMTExtCalls: trusted
+// SMTIgnoreInv: yes
+// ----
+// Warning 6328: (69-85): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2.sol
new file mode 100644
index 00000000..48bcf93a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint z = this.g(2);
+
+	function g(uint _x) public pure returns (uint) {
+		assert(_x > 0);
+		return _x;
+	}
+
+	function f() public view {
+		assert(z == 2); // should fail since we don't trust s.f's code
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (87-101): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2_trusted.sol
new file mode 100644
index 00000000..c2b8f839
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_2_trusted.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint z = this.g(2);
+
+	function g(uint _x) public pure returns (uint) {
+		assert(_x > 0); // should fail
+		return _x;
+	}
+
+	function f() public view {
+		assert(z == 2); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (87-101): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3.sol
new file mode 100644
index 00000000..a468186b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3.sol
@@ -0,0 +1,24 @@
+contract State {
+	function f(uint _x) public pure returns (uint) {
+		assert(_x < 100);
+		return _x;
+	}
+}
+contract C {
+	State s;
+	uint z;
+
+	constructor() {
+		z = s.f(2);
+	}
+
+	function f() public view {
+		assert(z == 2); // should fail since we don't trust s.f's code
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (69-85): CHC: Assertion violation happens here.\nCounterexample:\n\n_x = 100\n = 0\n\nTransaction trace:\nState.constructor()\nState.f(100)
+// Warning 6328: (203-217): CHC: Assertion violation happens here.\nCounterexample:\ns = 0, z = 0\n\nTransaction trace:\nC.constructor()\nState: s = 0, z = 0\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3_trusted.sol
new file mode 100644
index 00000000..59066405
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_3_trusted.sol
@@ -0,0 +1,25 @@
+contract State {
+	function f(uint _x) public pure returns (uint) {
+		assert(_x < 100); // should fail
+		return _x;
+	}
+}
+contract C {
+	State s;
+	uint z;
+
+	constructor() {
+		z = s.f(2);
+	}
+
+	function f() public view {
+		assert(z == 2); // should hold in trusted mode
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (69-85): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_reentrancy_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_reentrancy_1.sol
new file mode 100644
index 00000000..75fb4a7c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_from_constructor_reentrancy_1.sol
@@ -0,0 +1,18 @@
+interface D {
+	function ext(C c) external returns (uint);
+}
+
+contract C {
+	uint x;
+	function s(uint _x) public { x = _x; }
+	constructor(D d) {
+		uint a = d.ext(this);
+		assert(x == 0); // should hold because there's no reentrancy from the constructor
+		assert(a == 2); // should fail
+	}
+}
+// ====
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (253-267): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_1.sol
new file mode 100644
index 00000000..c6b46b2f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_1.sol
@@ -0,0 +1,42 @@
+contract A {
+	uint x;
+	function setX(uint _x) public {
+		x = _x;
+	}
+	function getX() public view returns (uint) {
+		return x;
+	}
+}
+
+contract B {
+	A a;
+	constructor() {
+		a = new A();
+		assert(a.getX() == 0); // should hold
+	}
+	function g() public view {
+		assert(a.getX() == 0); // should fail because A.setX() can be called without B
+	}
+	function getX() public view returns (uint) {
+		return a.getX();
+	}
+}
+
+contract C {
+	B b;
+	constructor() {
+		b = new B();
+		assert(b.getX() == 0); // should hold
+	}
+	function f() public view {
+		assert(b.getX() == 0); // should fail because A.setX() can be called without A
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (256-277): CHC: Assertion violation happens here.
+// Warning 6328: (533-554): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_2.sol
new file mode 100644
index 00000000..c1d567cf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_2.sol
@@ -0,0 +1,53 @@
+contract A {
+    uint x;
+    address immutable owner;
+    constructor() {
+        owner = msg.sender;
+    }
+    function setX(uint _x) public {
+        require(msg.sender == owner);
+        x = _x;
+    }
+    function getX() public view returns (uint) {
+        return x;
+    }
+}
+
+contract B {
+    A a;
+    constructor() {
+        a = new A();
+        assert(a.getX() == 0); // should hold
+    }
+    function g() public view {
+        assert(a.getX() == 0); // should hold, but fails because
+        // the nondet_interface constraint added for `A a` in between
+        // txs of `B` does not have the constraint that `msg.sender != address(this)`
+        // so `A.setX` is allowed with `msg.sender = address(this)` inside
+        // the current rules defining nondet_interface.
+        // If we want to support that, we likely need a new type of nondet_interface
+        // `nondet_interface_with_tx` that contains tx data as well as restricts
+        // every further `nondet_interface_with_tx` to not have that `msg.sender`.
+    }
+    function getX() public view returns (uint) {
+        return a.getX();
+    }
+}
+
+contract C {
+    B b;
+    constructor() {
+        b = new B();
+        assert(b.getX() == 0); // should hold
+    }
+    function f() public view {
+        assert(b.getX() == 0); // should hold
+    }
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (434-455): CHC: Assertion violation happens here.
+// Warning 6328: (1270-1291): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_3.sol
new file mode 100644
index 00000000..ff17649d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_3.sol
@@ -0,0 +1,46 @@
+contract A {
+	uint x;
+	address immutable owner;
+	constructor() {
+		owner = msg.sender;
+	}
+	function setX(uint _x) public {
+		require(msg.sender == owner);
+		x = _x;
+	}
+	function getX() public view returns (uint) {
+		return x;
+	}
+}
+
+contract B {
+	A a;
+	constructor() {
+		a = new A();
+		assert(a.getX() == 0); // should hold
+	}
+	function g() public {
+		a.setX(42);
+	}
+	function getX() public view returns (uint) {
+		return a.getX();
+	}
+}
+
+contract C {
+	B b;
+	constructor() {
+		b = new B();
+		assert(b.getX() == 0); // should hold
+	}
+	function f() public view {
+		assert(b.getX() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (561-582): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_4.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_4.sol
new file mode 100644
index 00000000..766f6e13
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_4.sol
@@ -0,0 +1,49 @@
+contract A {
+	uint x;
+	address immutable owner;
+	constructor() {
+		owner = msg.sender;
+	}
+	function setX(uint _x) public {
+		require(msg.sender == owner);
+		x = _x;
+	}
+	function getX() public view returns (uint) {
+		return x;
+	}
+}
+
+contract B {
+	A a;
+	address immutable owner;
+	constructor() {
+		owner = msg.sender;
+		a = new A();
+		assert(a.getX() == 0); // should hold
+	}
+	function g() public {
+		require(msg.sender == owner);
+		a.setX(42);
+	}
+	function getX() public view returns (uint) {
+		return a.getX();
+	}
+}
+
+contract C {
+	B b;
+	constructor() {
+		b = new B();
+		assert(b.getX() == 0); // should hold
+	}
+	function f() public view {
+		assert(b.getX() == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (641-662): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_5.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_5.sol
new file mode 100644
index 00000000..9313858c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_indirect_5.sol
@@ -0,0 +1,51 @@
+contract A {
+	uint x;
+	address immutable owner;
+	constructor() {
+		owner = msg.sender;
+	}
+	function setX(uint _x) public {
+		require(msg.sender == owner);
+		x = _x;
+	}
+	function getX() public view returns (uint) {
+		return x;
+	}
+}
+
+contract B {
+	A a;
+	address immutable owner;
+	constructor() {
+		owner = msg.sender;
+		a = new A();
+	}
+	function g() public {
+		require(msg.sender == owner);
+		a.setX(42);
+	}
+	function getX() public view returns (uint) {
+		return a.getX();
+	}
+}
+
+contract C {
+	B b;
+	constructor() {
+		b = new B();
+		assert(b.getX() == 0); // should hold
+	}
+	function f() public view {
+		assert(b.getX() == 0); // should fail
+	}
+	function h() public {
+		b.g();
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (601-622): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_1.sol
new file mode 100644
index 00000000..6b449323
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_1.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x;
+	function i() public { ++x; }
+	function f() public {
+		x = 0;
+		this.i();
+		assert(x == 1); // should hold in trusted mode
+		assert(x != 1); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (147-161): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_2.sol
new file mode 100644
index 00000000..55e88488
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint x;
+	function i() public { ++x; }
+	function f() public {
+		x = 0;
+		((this)).i();
+		assert(x == 1); // should hold in trusted mode
+		assert(x != 1); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (151-165): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_3.sol
new file mode 100644
index 00000000..5435e5dc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_semantic_this_3.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x;
+	function i() public { ++x; }
+	function f() public {
+		x = 0;
+		C c = this;
+		c.i();
+		assert(x == 1); // should hold in trusted mode
+		assert(x != 1); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (158-172): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_1.sol
new file mode 100644
index 00000000..6075548d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_1.sol
@@ -0,0 +1,24 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	S[] ss;
+	constructor() {
+		ss.push(S(address(new D())));
+		assert(D(ss[0].d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(ss[0].d).x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (210-237): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_2.sol
new file mode 100644
index 00000000..c8834ab8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_struct_trusted_2.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	S[] ss;
+	constructor() {
+		ss.push(S(address(new D())));
+		assert(D(ss[0].d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(ss[0].d).x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (253-280): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_1.sol
new file mode 100644
index 00000000..4a7da793
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_1.sol
@@ -0,0 +1,22 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	address[] ds;
+	constructor() {
+		ds.push(address(new D()));
+		assert(D(ds[0]).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(ds[0]).x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (226-251): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_2.sol
new file mode 100644
index 00000000..84608799
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_array_trusted_2.sol
@@ -0,0 +1,21 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	address[] ds;
+	constructor() {
+		ds.push(address(new D()));
+		assert(D(ds[0]).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(ds[0]).x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (183-208): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_1.sol
new file mode 100644
index 00000000..3f1c7acb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_1.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	S s;
+	constructor() {
+		s.d = address(new D());
+		assert(D(s.d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(s.d).x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (240-263): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_2.sol
new file mode 100644
index 00000000..146141fb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_2.sol
@@ -0,0 +1,24 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	S s;
+	constructor() {
+		s.d = address(new D());
+		assert(D(s.d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(s.d).x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (197-220): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_3.sol
new file mode 100644
index 00000000..b2711cb5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_3.sol
@@ -0,0 +1,27 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	struct T {
+		S s;
+	}
+	T t;
+	constructor() {
+		t.s.d = address(new D());
+		assert(D(t.s.d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(t.s.d).x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (223-248): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_4.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_4.sol
new file mode 100644
index 00000000..e8387b74
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_address_inside_struct_trusted_4.sol
@@ -0,0 +1,28 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		address d;
+	}
+	struct T {
+		S s;
+	}
+	T t;
+	constructor() {
+		t.s.d = address(new D());
+		assert(D(t.s.d).x() == 0); // should hold
+	}
+	function f() public view {
+		assert(D(t.s.d).x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (266-291): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_1.sol
new file mode 100644
index 00000000..aefad8a7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_1.sol
@@ -0,0 +1,24 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	S[] ss;
+	constructor() {
+		ss.push(S(new D()));
+		assert(ss[0].d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(ss[0].d.x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (192-216): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_2.sol
new file mode 100644
index 00000000..3f03cd71
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_struct_trusted_2.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	S[] ss;
+	constructor() {
+		ss.push(S(new D()));
+		assert(ss[0].d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(ss[0].d.x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (235-259): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_1.sol
new file mode 100644
index 00000000..017e760e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_1.sol
@@ -0,0 +1,22 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	D[] ds;
+	constructor() {
+		ds.push(new D());
+		assert(ds[0].x() == 0); // should hold
+	}
+	function f() public view {
+		assert(ds[0].x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (208-230): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_2.sol
new file mode 100644
index 00000000..0ac805b2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_array_trusted_2.sol
@@ -0,0 +1,22 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	D[] ds;
+	constructor() {
+		ds.push(new D());
+		assert(ds[0].x() == 0); // should hold
+	}
+	function f() public view {
+		assert(ds[0].x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (165-187): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_1.sol
new file mode 100644
index 00000000..f7c705c1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_1.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	S s;
+	constructor() {
+		s.d = new D();
+		assert(s.d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(s.d.x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (222-242): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_2.sol
new file mode 100644
index 00000000..50bab617
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_2.sol
@@ -0,0 +1,25 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	S s;
+	constructor() {
+		s.d = new D();
+		assert(s.d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(s.d.x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (179-199): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_3.sol
new file mode 100644
index 00000000..7a5791c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_3.sol
@@ -0,0 +1,28 @@
+contract D {
+	uint public x;
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	struct T {
+		S s;
+	}
+	T t;
+	constructor() {
+		t.s.d = new D();
+		assert(t.s.d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(t.s.d.x() == 0); // should hold, but fails because we havoc the state
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (205-227): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_4.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_4.sol
new file mode 100644
index 00000000..3bc9abaf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_state_var_contract_inside_struct_trusted_4.sol
@@ -0,0 +1,28 @@
+contract D {
+	uint public x;
+	function setD(uint _x) public { x = _x; }
+}
+
+contract C {
+	struct S {
+		D d;
+	}
+	struct T {
+		S s;
+	}
+	T t;
+	constructor() {
+		t.s.d = new D();
+		assert(t.s.d.x() == 0); // should hold
+	}
+	function f() public view {
+		assert(t.s.d.x() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (248-270): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_1.sol
new file mode 100644
index 00000000..fbf4140b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_1.sol
@@ -0,0 +1,15 @@
+contract C {
+	function g() public {
+		require(address(this).balance == 100);
+		this.h{value: 10}();
+		assert(address(this).balance == 100); // should hold
+		assert(address(this).balance == 90); // should fail
+	}
+
+	function h() external payable {}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (157-192): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_2.sol
new file mode 100644
index 00000000..0cdf7ec8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_call_this_with_value_2.sol
@@ -0,0 +1,20 @@
+contract C {
+	function g(uint i) public {
+		require(address(this).balance == 100);
+		// if called address is same as this, don't do anything with the value stuff
+		// or fix the receiving end
+		this.h{value: i}();
+		uint x = address(this).balance;
+		assert(x == 100); // should hold
+		assert(address(this).balance == 100); // should hold
+		assert(address(this).balance == 90); // should fail
+	}
+
+	function h() external payable {}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (340-375): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash.sol
new file mode 100644
index 00000000..6b8d41ad
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash.sol
@@ -0,0 +1,31 @@
+abstract contract Crypto {
+	function hash(bytes32) external pure virtual returns (bytes32);
+}
+
+contract C {
+	address owner;
+	bytes32 sig_1;
+	bytes32 sig_2;
+	Crypto d;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function f1(bytes32 _msg) public {
+		address prevOwner = owner;
+		sig_1 = d.hash(_msg);
+		sig_2 = d.hash(_msg);
+		assert(prevOwner == owner);
+	}
+
+	function inv() public view {
+		assert(sig_1 == sig_2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (390-412): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure.sol
new file mode 100644
index 00000000..514e6a5c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure.sol
@@ -0,0 +1,33 @@
+contract Crypto {
+	function hash(bytes32) external pure returns (bytes32) {
+		return bytes32(0);
+	}
+}
+
+contract C {
+	address owner;
+	bytes32 sig_1;
+	bytes32 sig_2;
+	Crypto d;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function f1(bytes32 _msg) public {
+		address prevOwner = owner;
+		sig_1 = d.hash(_msg);
+		sig_2 = d.hash(_msg);
+		assert(prevOwner == owner);
+	}
+
+	function inv() public view {
+		assert(sig_1 == sig_2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (398-420): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure_trusted.sol
new file mode 100644
index 00000000..aa5cb403
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_pure_trusted.sol
@@ -0,0 +1,33 @@
+contract Crypto {
+	function hash(bytes32) external pure returns (bytes32) {
+		return bytes32(0);
+	}
+}
+
+contract C {
+	address owner;
+	bytes32 sig_1;
+	bytes32 sig_2;
+	Crypto d;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function f1(bytes32 _msg) public {
+		address prevOwner = owner;
+		sig_1 = d.hash(_msg);
+		sig_2 = d.hash(_msg);
+		assert(prevOwner == owner);
+	}
+
+	function inv() public view {
+		assert(sig_1 == sig_2);
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: all
+// SMTExtCalls: trusted
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state.sol
new file mode 100644
index 00000000..90b91e9b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state.sol
@@ -0,0 +1,39 @@
+contract State {
+	uint x;
+	function f() public returns (uint) {
+		if (x == 0) x = 1;
+		else if (x == 1) x = 2;
+		else if (x == 2) x = 0;
+		return x;
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		y = s.f();
+		z = s.f();
+		assert(prevOwner == owner);
+	}
+
+	function inv() public view {
+		// This is safe but external calls do not yet support the state
+		// of the called contract.
+		assert(owner == address(0) || y != z);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (495-532): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2.sol
new file mode 100644
index 00000000..2fc1f030
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2.sol
@@ -0,0 +1,46 @@
+contract State {
+	uint x;
+	C c;
+	function f() public returns (uint) {
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+	bool insidef;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function zz() public {
+		require(insidef);
+		z = 3;
+	}
+
+	function f() public {
+		require(!insidef);
+		address prevOwner = owner;
+		insidef = true;
+		s.f();
+		assert(z == y);
+		assert(prevOwner == owner);
+		insidef = false;
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 2018: (33-88): Function state mutability can be restricted to view
+// Warning 6328: (367-381): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2_trusted.sol
new file mode 100644
index 00000000..720b2023
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_2_trusted.sol
@@ -0,0 +1,47 @@
+contract State {
+	C c;
+	constructor(C _c) {
+		c = _c;
+	}
+	function f() public view returns (uint) {
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+	bool insidef;
+
+	constructor() {
+		owner = msg.sender;
+		s = new State(this);
+	}
+
+	function zz() public {
+		require(insidef);
+		z = 3;
+	}
+
+	function f() public {
+		require(!insidef);
+		address prevOwner = owner;
+		insidef = true;
+		s.f();
+		assert(z == y);
+		assert(prevOwner == owner);
+		insidef = false;
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_3.sol
new file mode 100644
index 00000000..80e27e7e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_3.sol
@@ -0,0 +1,45 @@
+contract State {
+	uint x;
+	C c;
+	function f() public view returns (uint) {
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+	bool insidef;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function zz() public {
+		require(insidef);
+		z = 3;
+	}
+
+	function f() public {
+		require(!insidef);
+		address prevOwner = owner;
+		insidef = true;
+		// s.f() cannot call zz() because it is `view`
+		// and zz modifies the state.
+		s.f();
+		assert(z == y);
+		assert(prevOwner == owner);
+		insidef = false;
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect.sol
new file mode 100644
index 00000000..bd779b56
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect.sol
@@ -0,0 +1,48 @@
+contract Other {
+	C c;
+	function h() public {
+		c.setOwner(address(0));
+	}
+}
+
+contract State {
+	uint x;
+	Other o;
+	C c;
+	function f() public returns (uint) {
+		o.h();
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+	}
+
+	function setOwner(address _owner) public {
+		owner = _owner;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		uint z = s.f();
+		assert(z == y);
+		assert(prevOwner == owner);
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (419-433): CHC: Assertion violation happens here.
+// Warning 6328: (437-463): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect_trusted.sol
new file mode 100644
index 00000000..8000b326
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_indirect_trusted.sol
@@ -0,0 +1,56 @@
+contract Other {
+	C c;
+	constructor(C _c) {
+		c = _c;
+	}
+	function h() public {
+		c.setOwner(address(0));
+	}
+}
+
+contract State {
+	uint x;
+	Other o;
+	C c;
+	constructor(C _c) {
+		c = _c;
+		o = new Other(_c);
+	}
+	function f() public returns (uint) {
+		o.h();
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+		s = new State(this);
+	}
+
+	function setOwner(address _owner) public {
+		owner = _owner;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		uint z = s.f();
+		assert(z == y); // should hold
+		assert(prevOwner == owner); // should not hold because of reentrancy
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (531-545): CHC: Assertion violation might happen here.
+// Warning 6328: (564-590): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_trusted.sol
new file mode 100644
index 00000000..34df5c0e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_trusted.sol
@@ -0,0 +1,38 @@
+contract State {
+	C c;
+	constructor(C _c) {
+		c = _c;
+	}
+	function f() public view returns (uint) {
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+		s = new State(this);
+	}
+
+	function f() public view {
+		address prevOwner = owner;
+		uint z = s.f();
+		assert(z == y);
+		assert(prevOwner == owner);
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (314-328): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_unsafe_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_unsafe_trusted.sol
new file mode 100644
index 00000000..4d179ddf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_reentrancy_unsafe_trusted.sol
@@ -0,0 +1,44 @@
+contract State {
+	C c;
+	constructor(C _c) {
+		c = _c;
+	}
+	function f() public returns (uint) {
+		c.setOwner(address(0));
+		return c.g();
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+		s = new State(this);
+	}
+
+	function setOwner(address _owner) public {
+		owner = _owner;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		uint z = s.f();
+		assert(z == y); // should hold
+		assert(prevOwner == owner); // should not hold because of reentrancy
+	}
+
+	function g() public view returns (uint) {
+		return y;
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (396-410): CHC: Assertion violation might happen here.
+// Warning 6328: (429-455): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_trusted.sol
new file mode 100644
index 00000000..1c557f7a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_trusted.sol
@@ -0,0 +1,36 @@
+contract State {
+	uint x;
+	function f() public returns (uint) {
+		if (x == 0) x = 1;
+		else if (x == 1) x = 2;
+		else if (x == 2) x = 0;
+		return x;
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+
+	constructor() {
+		s = new State();
+		owner = msg.sender;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		y = s.f();
+		z = s.f();
+		assert(prevOwner == owner);
+		assert(y != z);
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (355-381): CHC: Assertion violation might happen here.
+// Warning 6328: (385-399): CHC: Assertion violation might happen here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_unsafe_trusted.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_unsafe_trusted.sol
new file mode 100644
index 00000000..7d217e14
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_hash_known_code_state_unsafe_trusted.sol
@@ -0,0 +1,40 @@
+contract State {
+	uint x;
+	function f() public returns (uint) {
+		if (x == 0) x = 1;
+		else if (x == 1) x = 2;
+		else if (x == 2) x = 0;
+		return x;
+	}
+}
+
+contract C {
+	address owner;
+	uint y;
+	uint z;
+	State s;
+
+	constructor() {
+		owner = msg.sender;
+		s = new State();
+	}
+
+	function setOwner(address _owner) public {
+		owner = _owner;
+	}
+
+	function f() public {
+		address prevOwner = owner;
+		y = s.f();
+		z = s.f();
+		assert(prevOwner == owner);
+		assert(y != z);
+	}
+}
+// ====
+// SMTContract: C
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// ----
+// Warning 6328: (421-447): CHC: Assertion violation might happen here.
+// Warning 6328: (451-465): CHC: Assertion violation might happen here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_inc1_inc2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_inc1_inc2.sol
new file mode 100644
index 00000000..0a874a78
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_inc1_inc2.sol
@@ -0,0 +1,30 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+	uint x;
+	uint y;
+	D d;
+
+	function inc2() public {
+		if (y == 1)
+			x = 1;
+	}
+	function inc1() public {
+		if (x == 0)
+			y = 1;
+	}
+
+	function f() public {
+		uint oldX = x;
+		// Removed because Spacer 4.8.9 seg faults.
+		//d.d();
+		assert(oldX == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2018: (203-322): Function state mutability can be restricted to view
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_1.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_1.sol
new file mode 100644
index 00000000..4df99bfe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_1.sol
@@ -0,0 +1,20 @@
+interface D { function e() external; }
+
+contract C {
+	bool locked = true;
+
+	function call(address target) public {
+		locked = false;
+		D(target).e();
+		locked = true;
+	}
+
+	function broken() public view {
+		assert(locked);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (206-220): CHC: Assertion violation happens here.\nCounterexample:\nlocked = false\ntarget = 0x0\n\nTransaction trace:\nC.constructor()\nState: locked = true\nC.call(0x0)\n    D(target).e() -- untrusted external call, synthesized as:\n        C.broken() -- reentrant call
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_2.sol
new file mode 100644
index 00000000..1783be78
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_2.sol
@@ -0,0 +1,17 @@
+interface D { function e() external; }
+
+contract C {
+	bool locked = true;
+
+	function call(address target) public {
+		assert(locked);
+		locked = false;
+		D(target).e();
+		locked = true;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (117-131): CHC: Assertion violation happens here.\nCounterexample:\nlocked = false\ntarget = 0x0\n\nTransaction trace:\nC.constructor()\nState: locked = true\nC.call(0x0)\n    D(target).e() -- untrusted external call, synthesized as:\n        C.call(0x0) -- reentrant call
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_3.sol
new file mode 100644
index 00000000..cfe12434
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_3.sol
@@ -0,0 +1,35 @@
+abstract contract D {
+	function d() virtual public {}
+}
+
+contract A {
+	int x = 0;
+
+	function f() virtual public view {
+		assert(x == 0); // should hold
+		assert(x == 1); // should fail
+	}
+}
+contract C is A {
+	constructor() {
+		x = 1;
+	}
+
+	function call(D d) public {
+		d.d();
+	}
+
+	function f() public view override {
+		assert(x == 1); // should hold
+		//Disabled because of Spacer nondeterminism.
+		//assert(x == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreInv: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (154-168): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_crypto.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_crypto.sol
new file mode 100644
index 00000000..2cac5443
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_reentrancy_crypto.sol
@@ -0,0 +1,32 @@
+abstract contract D {
+	function d() virtual public;
+}
+
+contract C {
+	bytes data;
+
+	bytes32 kec;
+
+	constructor(bytes memory _data) {
+		data = _data;
+
+		kec = keccak256(data);
+	}
+
+	function check(bytes memory _data) public view {
+		bytes32 _kec = keccak256(data);
+		assert(_kec == kec); // should hold
+		assert(kec == keccak256(_data)); // should fail
+	}
+
+	function ext(D d) public {
+		d.d();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreInv: yes
+// ----
+// Warning 6328: (302-333): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/external_safe.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_safe.sol
new file mode 100644
index 00000000..593aba28
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/external_safe.sol
@@ -0,0 +1,21 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+	uint x;
+	D d;
+	function f() public {
+		if (x < 10)
+			++x;
+	}
+	function g() public {
+		d.d();
+		assert(x < 11);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_2.sol
new file mode 100644
index 00000000..3dca6dd3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_2.sol
@@ -0,0 +1,29 @@
+interface I {
+    function i() external;
+}
+
+library L {
+    function f(I _i) internal {
+        _i.i();
+    }
+	function g(I _i) internal {
+		f(_i);
+	}
+}
+
+contract C {
+    uint x;
+    bool inG;
+    function s() public {
+        require(inG);
+        x = 2;
+    }
+    function g(I _i) public {
+        inG = true;
+        L.g(_i);
+        assert(x == 0);
+        inG = false;
+    }
+}
+// ----
+// Warning 6328: (337-351): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_3.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_3.sol
new file mode 100644
index 00000000..c9d35e64
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/internal_library_external_call_3.sol
@@ -0,0 +1,32 @@
+interface I {
+    function i() external;
+}
+
+library M {
+    function f(I _i) internal {
+        _i.i();
+    }
+}
+
+library L {
+	function g(I _i) internal {
+		M.f(_i);
+	}
+}
+
+contract C {
+    uint x;
+    bool inG;
+    function s() public {
+        require(inG);
+        x = 2;
+    }
+    function g(I _i) public {
+        inG = true;
+        L.g(_i);
+        assert(x == 0);
+        inG = false;
+    }
+}
+// ----
+// Warning 6328: (354-368): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/mutex.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/mutex.sol
new file mode 100644
index 00000000..ffe23ae8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/mutex.sol
@@ -0,0 +1,31 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+	uint x;
+	D d;
+
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+
+	function set(uint _x) mutex public {
+		x = _x;
+	}
+
+	function f() mutex public {
+		uint y = x;
+		d.d();
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex.sol
new file mode 100644
index 00000000..54b0d36f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint x;
+
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+
+	function set(uint _x) mutex public {
+		x = _x;
+	}
+
+	function f(address _a) mutex public {
+		uint y = x;
+		_a.staticcall("aaaaa");
+		assert(y == x); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (218-240): Return value of low-level calls not used.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex_2.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex_2.sol
new file mode 100644
index 00000000..19b5e546
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_mutex_2.sol
@@ -0,0 +1,27 @@
+contract C {
+	uint x;
+
+	bool lock;
+	modifier mutex {
+		require(!lock);
+		lock = true;
+		_;
+		lock = false;
+	}
+
+	function set(uint _x) mutex public {
+		x = _x;
+	}
+
+	function f(address _a) public {
+		uint y = x;
+		_a.staticcall("aaaaa");
+		assert(y == x); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 9302: (212-234): Return value of low-level calls not used.
+// Warning 2018: (164-271): Function state mutability can be restricted to view
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_reentrancy_view.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_reentrancy_view.sol
new file mode 100644
index 00000000..70a81731
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/staticcall_reentrancy_view.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x;
+	function s(uint _x) public view {
+		x == _x;
+	}
+	function f(address a) public {
+		(bool s, bytes memory data) = a.staticcall("");
+		assert(x == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2519: (106-112): This declaration shadows an existing declaration.
+// Warning 2072: (106-112): Unused local variable.
+// Warning 2072: (114-131): Unused local variable.
+// Warning 2018: (72-188): Function state mutability can be restricted to view
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_correct.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_correct.sol
new file mode 100644
index 00000000..f9f65bb7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_correct.sol
@@ -0,0 +1,66 @@
+interface Token {
+	function balanceOf(address _a) external view returns (uint);
+	function transfer(address _to, uint _amt) external;
+}
+
+contract TokenCorrect is Token {
+	mapping (address => uint) balance;
+	constructor(address _a, uint _b) {
+		balance[_a] = _b;
+	}
+	function balanceOf(address _a) public view override returns (uint) {
+		return balance[_a];
+	}
+	function transfer(address _to, uint _amt) public override {
+		require(balance[msg.sender] >= _amt);
+		balance[msg.sender] -= _amt;
+		balance[_to] += _amt;
+	}
+}
+
+contract Test {
+	function property_transfer(address _token, address _to, uint _amt) public {
+		require(_to != address(this));
+
+		TokenCorrect t = TokenCorrect(_token);
+
+		uint xPre = t.balanceOf(address(this));
+		require(xPre >= _amt);
+		uint yPre = t.balanceOf(_to);
+
+		t.transfer(_to, _amt);
+		uint xPost = t.balanceOf(address(this));
+		uint yPost = t.balanceOf(_to);
+
+		assert(xPost == xPre - _amt);
+		assert(yPost == yPre + _amt);
+	}
+
+	function test_concrete() public {
+		TokenCorrect t = new TokenCorrect(address(this), 1000);
+
+		uint b = t.balanceOf(address(this));
+		assert(b == 1000);
+
+		address other = address(0x333);
+		require(address(this) != other);
+
+		uint c = t.balanceOf(other);
+		assert(c == 0);
+
+		t.transfer(other, 100);
+
+		uint d = t.balanceOf(address(this));
+		assert(d == 900);
+
+		uint e = t.balanceOf(other);
+		assert(e == 100);
+	}
+}
+// ====
+// SMTContract: Test
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_wrong.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_wrong.sol
new file mode 100644
index 00000000..2aee3c8d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/token_trusted_transfer_wrong.sol
@@ -0,0 +1,69 @@
+interface Token {
+	function balanceOf(address _a) external view returns (uint);
+	function transfer(address _to, uint _amt) external;
+}
+
+contract TokenWrong is Token {
+	mapping (address => uint) balance;
+	constructor(address _a, uint _b) {
+		balance[_a] = _b;
+	}
+	function balanceOf(address _a) public view override returns (uint) {
+		return balance[_a];
+	}
+	function transfer(address _to, uint _amt) public override {
+		require(balance[msg.sender] >= _amt);
+		// Commented out to make this token implementation wrong.
+		//balance[msg.sender] -= _amt;
+		balance[_to] += _amt;
+	}
+}
+
+contract Test {
+	function property_transfer(address _token, address _to, uint _amt) public {
+		require(_to != address(this));
+
+		TokenWrong t = TokenWrong(_token);
+
+		uint xPre = t.balanceOf(address(this));
+		require(xPre >= _amt);
+		uint yPre = t.balanceOf(_to);
+
+		t.transfer(_to, _amt);
+		uint xPost = t.balanceOf(address(this));
+		uint yPost = t.balanceOf(_to);
+
+		assert(xPost == xPre - _amt); // should fail
+		assert(yPost == yPre + _amt);
+	}
+
+	function test_concrete() public {
+		TokenWrong t = new TokenWrong(address(this), 1000);
+
+		uint b = t.balanceOf(address(this));
+		assert(b == 1000);
+
+		address other = address(0x333);
+		require(address(this) != other);
+
+		uint c = t.balanceOf(other);
+		assert(c == 0);
+
+		t.transfer(other, 100);
+
+		uint d = t.balanceOf(address(this));
+		assert(d == 900); // should fail
+
+		uint e = t.balanceOf(other);
+		assert(e == 100);
+	}
+}
+// ====
+// SMTContract: Test
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (950-978): CHC: Assertion violation happens here.
+// Warning 6328: (1370-1386): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/external_calls/underflow_only_in_external_call.sol b/compiler/test/libsolidity/smtCheckerTests/external_calls/underflow_only_in_external_call.sol
new file mode 100644
index 00000000..0b5c8fa0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/external_calls/underflow_only_in_external_call.sol
@@ -0,0 +1,24 @@
+contract C {
+
+	uint v;
+	bool guard = true;
+
+	function dec() public returns (uint) {
+		if (guard) return 0;
+		--v;
+		return v;
+	}
+
+	function f() public returns (uint) {
+		guard = false;
+		uint ret = this.dec();
+		guard = true;
+		return ret;
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTIgnoreCex: no
+// SMTTargets: underflow
+// ----
+// Warning 3944: (109-112): CHC: Underflow (resulting value less than 0) happens here.\nCounterexample:\nv = 0, guard = false\n = 0\n\nTransaction trace:\nC.constructor()\nState: v = 0, guard = true\nC.f()\n    C.dec() -- trusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/constant_string_at_file_level.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/constant_string_at_file_level.sol
new file mode 100644
index 00000000..55120bcb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/constant_string_at_file_level.sol
@@ -0,0 +1,42 @@
+bytes constant a = "\x03\x01\x02";
+bytes constant b = hex"030102";
+string constant c = "hello";
+uint256 constant x = 56;
+enum ActionChoices {GoLeft, GoRight, GoStraight, Sit}
+ActionChoices constant choices = ActionChoices.GoRight;
+bytes32 constant st = "abc\x00\xff__";
+
+contract C {
+	function f() internal pure returns (bytes memory) {
+		return a;
+	}
+
+	function g() internal pure returns (bytes memory) {
+		return b;
+	}
+
+	function h() internal pure returns (bytes memory) {
+		return bytes(c);
+	}
+
+	function i() internal pure returns (uint, ActionChoices, bytes32) {
+		return (x, choices, st);
+	}
+
+	function p() public pure {
+		assert(f().length == 3); // should hold
+		assert(g().length == 3); // should hold
+		assert(h().length == 5); // should hold
+		(uint w, ActionChoices z, bytes32 t) = i();
+		assert(x == 56); // should hold
+		assert(w == 56); // should hold
+		assert(z == ActionChoices.GoRight); // should hold
+		assert(t == "abc\x00\xff__"); // should hold
+		assert(w == 59); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (968-983): CHC: Assertion violation happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/constants_at_file_level_referencing.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/constants_at_file_level_referencing.sol
new file mode 100644
index 00000000..c7be2248
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/constants_at_file_level_referencing.sol
@@ -0,0 +1,66 @@
+==== Source: s1.sol ====
+
+
+bytes constant a = b;
+bytes constant b = hex"030102";
+
+function fre() pure returns (bytes memory) {
+	return a;
+}
+
+==== Source: s2.sol ====
+
+import "s1.sol";
+
+uint256 constant c = uint8(a[0]) + 2;
+
+contract C {
+	function f() internal pure returns (bytes memory) {
+		return a;
+	}
+
+	function g() internal pure returns (bytes memory) {
+		return b;
+	}
+
+	function h() internal pure returns (uint) {
+		return c;
+	}
+
+	function i() internal pure returns (bytes memory) {
+		return fre();
+	}
+
+	function p() public pure {
+		bytes memory r1 = f();
+		assert(r1[0] == 0x03); // should hold
+		assert(r1[1] == 0x01); // should hold
+		assert(r1[2] == 0x02); // should hold
+		assert(r1[2] == 0x04); // should fail
+
+		bytes memory r2 = g();
+		assert(r2[0] == 0x03); // should hold
+		assert(r2[1] == 0x01); // should hold
+		assert(r2[2] == 0x02); // should hold
+		assert(r2[2] == 0x04); // should fail
+
+		bytes memory r3 = i();
+		assert(r3[0] == 0x03); // should hold
+		assert(r3[1] == 0x01); // should hold
+		assert(r3[2] == 0x02); // should hold
+		assert(r3[2] == 0x04); // should fail
+
+		uint z = h();
+		assert(z == 5); // should hold
+		assert(z == 7); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (s2.sol:518-539): CHC: Assertion violation happens here.
+// Warning 6328: (s2.sol:704-725): CHC: Assertion violation happens here.
+// Warning 6328: (s2.sol:890-911): CHC: Assertion violation happens here.
+// Warning 6328: (s2.sol:980-994): CHC: Assertion violation happens here.
+// Info 1391: CHC: 24 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/easy.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/easy.sol
new file mode 100644
index 00000000..2cbef3f5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/easy.sol
@@ -0,0 +1,19 @@
+function add(uint a, uint b) pure returns (uint) {
+	return a + b;
+}
+
+contract C {
+	function f(uint x) internal pure returns (uint) {
+		return add(x, 2);
+	}
+	function g() public pure {
+		assert(f(7) == 9); // should hold
+		assert(f(8) == 9); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (222-239): CHC: Assertion violation happens here.\nCounterexample:\n\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f(7) -- internal call\n        add(7, 2) -- internal call\n    C.f(8) -- internal call\n        add(8, 2) -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/enum.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/enum.sol
new file mode 100644
index 00000000..0cefa021
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/enum.sol
@@ -0,0 +1,24 @@
+enum E {
+	READ,
+	WRITE
+}
+
+function allocate(bool b) pure returns (E) {
+	if (b) return E.READ;
+	return E.WRITE;
+}
+
+contract C {
+	function f() public pure {
+		E e1 = allocate(true);
+		assert(e1 == E.READ); // should hold
+		E e2 = allocate(false);
+		assert(e2 == E.READ); // should fail
+		assert(allocate(false) == E.WRITE); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (247-267): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/file_level_call_via_module.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/file_level_call_via_module.sol
new file mode 100644
index 00000000..95468f12
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/file_level_call_via_module.sol
@@ -0,0 +1,23 @@
+==== Source: a.sol ====
+function f(uint) pure returns (uint) { return 7; }
+function f(bytes memory x) pure returns (uint) { return x.length; }
+==== Source: b.sol ====
+import "a.sol" as M;
+contract C {
+	function f() internal pure returns (uint, uint) {
+		return (M.f(2), M.f("abc"));
+	}
+	function p() public pure {
+		(uint a, uint b) = f();
+		assert(a == 7); // should hold
+		assert(a == 9); // should fail
+		assert(b == 3); // should hold
+		assert(b == 5); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (b.sol:208-222): CHC: Assertion violation happens here.
+// Warning 6328: (b.sol:274-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/free_namesake_contract_function.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/free_namesake_contract_function.sol
new file mode 100644
index 00000000..3119fd1c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/free_namesake_contract_function.sol
@@ -0,0 +1,15 @@
+function f() pure returns (uint) { return 1337; }
+
+contract C {
+	function g() public pure {
+		assert(f() == 42); // should hold
+		assert(f() == 1337); // should fail
+	}
+	function f() internal pure returns (uint) { return 42; }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2519: (170-226): This declaration shadows an existing declaration.
+// Warning 6328: (130-149): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/import.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/import.sol
new file mode 100644
index 00000000..44595363
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/import.sol
@@ -0,0 +1,28 @@
+==== Source: A ====
+struct S { uint x; }
+function set(S storage a, uint v) { a.x = v; }
+
+==== Source: B ====
+import "A";
+import "A" as A;
+contract C {
+	A.S data;
+	function f(uint v) internal returns (uint one, uint two) {
+		A.set(data, v);
+		one = data.x;
+		set(data, v + 1);
+		two = data.x;
+	}
+	function g() public {
+		(uint x, uint y) = f(7);
+		assert(x == 7); // should hold but the SMTChecker doesn't know that
+		assert(y == 8); // should hold but the SMTChecker doesn't know that
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (B:238-252): CHC: Assertion violation happens here.
+// Warning 6328: (B:308-322): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_1.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_1.sol
new file mode 100644
index 00000000..45109a6f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_1.sol
@@ -0,0 +1,27 @@
+==== Source: s1.sol ====
+uint constant a = 89;
+==== Source: s2.sol ====
+uint constant a = 88;
+
+==== Source: s3.sol ====
+import "s1.sol" as M;
+import "s2.sol" as N;
+
+contract C {
+	function f() internal pure returns (uint, uint) {
+		return (M.a, N.a);
+	}
+	function p() public pure {
+		(uint x, uint y) = f();
+		assert(x == 89); // should hold
+		assert(x == 88); // should fail
+		assert(y == 88); // should hold
+		assert(y == 89); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Warning 6328: (s3.sol:223-238): CHC: Assertion violation happens here.
+// Warning 6328: (s3.sol:291-306): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_functions_1.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_functions_1.sol
new file mode 100644
index 00000000..27527ab8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/module_constants_functions_1.sol
@@ -0,0 +1,47 @@
+==== Source: s1.sol ====
+uint constant a = 89;
+
+function fre() pure returns (uint) {
+	return a;
+}
+
+==== Source: s2.sol ====
+function foo() pure returns (uint) {
+	return 42;
+}
+
+==== Source: s3.sol ====
+import {fre as foo} from "s1.sol";
+import "s1.sol" as M;
+import "s2.sol" as N;
+
+uint256 constant a = 13;
+
+contract C {
+	function f() internal pure returns (uint, uint, uint, uint) {
+		return (a, foo(), N.foo(), M.a);
+	}
+	function p() public pure {
+		(uint x, uint y, uint z, uint t) = f();
+
+		assert(x == 13); // should hold
+		assert(x == 89); // should fail
+
+		assert(y == 89); // should hold
+		assert(y == 42); // should fail
+
+		assert(z == 42); // should hold
+		assert(z == 89); // should fail
+
+		assert(t == 89); // should hold
+		assert(t == 13); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (s3.sol:327-342): CHC: Assertion violation happens here.
+// Warning 6328: (s3.sol:396-411): CHC: Assertion violation happens here.
+// Warning 6328: (s3.sol:465-480): CHC: Assertion violation happens here.
+// Warning 6328: (s3.sol:534-549): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/new_operator.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/new_operator.sol
new file mode 100644
index 00000000..925f53bc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/new_operator.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint public x = 2;
+}
+
+function test() returns (uint) {
+	return (new C()).x();
+}
+
+contract D {
+	function f() public {
+		assert(test() == 2); // should hold but the SMTChecker doesn't support `new`
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8729: (78-85): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 6328: (133-152): CHC: Assertion violation happens here.\nCounterexample:\n\n\nTransaction trace:\nD.constructor()\nD.f()\n    test() -- internal call\n        (new C()).x() -- untrusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/overloads.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/overloads.sol
new file mode 100644
index 00000000..b6457055
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/overloads.sol
@@ -0,0 +1,19 @@
+function f(uint) pure returns (uint) {
+	return 2;
+}
+function f(string memory) pure returns (uint) {
+	return 3;
+}
+
+contract C {
+	function g() public pure {
+		(uint x, uint y) = (f(2), f("abc"));
+		assert(x == 2); // should hold
+		assert(y == 4); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (229-243): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/same_constants_different_files.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/same_constants_different_files.sol
new file mode 100644
index 00000000..7a8bcc0a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/same_constants_different_files.sol
@@ -0,0 +1,32 @@
+==== Source: s1.sol ====
+
+
+uint constant a = 89;
+
+function fre() pure returns (uint) {
+	return a;
+}
+
+==== Source: s2.sol ====
+
+import {a as b, fre} from "s1.sol";
+import "s1.sol" as M;
+
+uint256 constant a = 13;
+
+contract C {
+	function f() internal pure returns (uint, uint, uint, uint) {
+		return (a, fre(), M.a, b);
+	}
+	function p() public pure {
+		(uint x, uint y, uint z, uint t) = f();
+		assert(x == 13); // should hold
+		assert(y == 89); // should hold
+		assert(z == 89); // should hold
+		assert(t == 89); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/file_level/struct.sol b/compiler/test/libsolidity/smtCheckerTests/file_level/struct.sol
new file mode 100644
index 00000000..f469933d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/file_level/struct.sol
@@ -0,0 +1,29 @@
+struct S {
+	uint x;
+	uint[] a;
+}
+
+function allocate(uint _x, uint _f) pure returns (S memory) {
+	S memory s;
+	s.x = _x;
+	s.a = new uint[](1);
+	s.a[0] = _f;
+	return s;
+}
+
+contract C {
+	function f() public pure {
+		S memory s = allocate(2, 1);
+		assert(s.x == 2); // should hold
+		assert(s.a[0] == 1); // should hold
+		assert(s.x == 3); // should fail
+		assert(s.a[0] == 4); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (317-333): CHC: Assertion violation happens here.\nCounterexample:\n\ns = {x: 2, a: [1]}\n\nTransaction trace:\nC.constructor()\nC.f()\n    allocate(2, 1) -- internal call
+// Warning 6328: (352-371): CHC: Assertion violation happens here.\nCounterexample:\n\ns = {x: 2, a: [1]}\n\nTransaction trace:\nC.constructor()\nC.f()\n    allocate(2, 1) -- internal call
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/function_selector/function_types_sig.sol b/compiler/test/libsolidity/smtCheckerTests/function_selector/function_types_sig.sol
new file mode 100644
index 00000000..45910c66
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/function_selector/function_types_sig.sol
@@ -0,0 +1,30 @@
+contract C {
+    uint256 public x;
+
+    function f() public pure returns (bytes4) {
+        return this.f.selector;
+    }
+
+    function g() public view returns (bytes4) {
+        function () pure external returns (bytes4) fun = this.f;
+        return fun.selector;
+    }
+
+    function i() public pure returns (bytes4) {
+        return this.x.selector;
+    }
+
+    function check() public view {
+        assert(f() == 0x26121ff0);
+        assert(g() == 0x26121ff0);
+        assert(i() == 0x0c55699c);
+        assert(i() == 0x26121ff0);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7650: (251-263): Assertion checker does not yet support this expression.
+// Warning 6328: (437-462): CHC: Assertion violation happens here.
+// Warning 6328: (507-532): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/function_selector/homer.sol b/compiler/test/libsolidity/smtCheckerTests/function_selector/homer.sol
new file mode 100644
index 00000000..a3bb0c64
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/function_selector/homer.sol
@@ -0,0 +1,45 @@
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+interface Simpson {
+    function is2D() external returns (bool);
+    function skinColor() external returns (string memory);
+}
+
+interface PeaceMaker {
+    function achieveWorldPeace() external;
+}
+
+contract Homer is ERC165, Simpson {
+    function supportsInterface(bytes4 interfaceID) public pure override returns (bool) {
+        return
+            interfaceID == this.supportsInterface.selector || // ERC165
+            interfaceID == this.is2D.selector ^ this.skinColor.selector; // Simpson
+    }
+
+    function is2D() external pure override returns (bool) {
+        return true;
+    }
+
+    function skinColor() external pure override returns (string memory) {
+        return "yellow";
+    }
+
+    function check() public pure {
+        assert(supportsInterface(type(Simpson).interfaceId));
+        assert(supportsInterface(type(ERC165).interfaceId));
+        assert(supportsInterface(type(PeaceMaker).interfaceId));
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (1340-1395): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/function_selector/selector.sol b/compiler/test/libsolidity/smtCheckerTests/function_selector/selector.sol
new file mode 100644
index 00000000..486f48c4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/function_selector/selector.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure {
+        assert(msg.sig == this.f.selector);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/function_selector/selector_3.sol b/compiler/test/libsolidity/smtCheckerTests/function_selector/selector_3.sol
new file mode 100644
index 00000000..c4dd67e1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/function_selector/selector_3.sol
@@ -0,0 +1,15 @@
+
+contract C {
+    int public x;
+    int public y;
+
+    function f() public pure {
+        assert(this.x.selector != this.y.selector);
+        assert(this.x.selector == this.y.selector);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (142-184): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy.sol
new file mode 100644
index 00000000..d95dbdce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+contract A is C {
+	constructor() C(2) {
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (120-134): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_2.sol
new file mode 100644
index 00000000..62d9c83e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_2.sol
@@ -0,0 +1,9 @@
+contract C { uint a; constructor(uint x) { a = x; } }
+contract A is C { constructor() C(2) { assert(a == 2); } }
+contract B is C { constructor() C(3) { assert(a == 3); } }
+contract J is C { constructor() C(3) { assert(a == 4); } }
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (211-225): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_3.sol
new file mode 100644
index 00000000..9e79ebfb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_3.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B is C {
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+contract A is B {
+	constructor(uint x) B(x) C(x + 2) {
+		assert(a == x);
+		assert(a == x + 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (171-176): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (200-218): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_4.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_4.sol
new file mode 100644
index 00000000..3cefaa78
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_4.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B is C {
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+contract A is B {
+	constructor(uint x) C(x + 2) B(x + 1) {
+		assert(a == x + 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (166-171): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (175-180): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond.sol
new file mode 100644
index 00000000..44ccc2b7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond.sol
@@ -0,0 +1,32 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B1 is C {
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+contract B2 is C {
+	constructor(uint x) C(x + 2) {
+		a = x;
+	}
+}
+
+contract A is B2, B1 {
+	constructor(uint x) B2(x) B1(x) {
+		assert(a == x);
+		assert(a == x + 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (168-173): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (270-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_2.sol
new file mode 100644
index 00000000..d826bc38
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_2.sol
@@ -0,0 +1,32 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B1 is C {
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+contract B2 is C {
+	constructor(uint x) C(x + 2) {
+		a = x;
+	}
+}
+
+contract A is B2, B1 {
+	constructor(uint x) B1(x) B2(x) {
+		assert(a == x);
+		assert(a == x + 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (168-173): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (270-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_3.sol
new file mode 100644
index 00000000..593a2ae7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_3.sol
@@ -0,0 +1,35 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B1 is C {
+	uint b1;
+	constructor(uint x) {
+		b1 = x + a;
+	}
+}
+
+contract B2 is C {
+	uint b2;
+	constructor(uint x) C(x + 2) {
+		b2 = x + a;
+	}
+}
+
+contract A is B2, B1 {
+	constructor(uint x) B2(x) B1(x) {
+		assert(b1 == b2);
+		assert(b1 != b2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (193-198): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (209-214): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (302-318): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle.sol
new file mode 100644
index 00000000..bf1c0ee6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle.sol
@@ -0,0 +1,25 @@
+contract C {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract B is C {
+}
+
+contract B2 is C {
+}
+
+contract A is B, B2 {
+	constructor(uint x) {
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (132-138): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (162-176): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle_empty_base.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle_empty_base.sol
new file mode 100644
index 00000000..57a0f40d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_diamond_empty_middle_empty_base.sol
@@ -0,0 +1,22 @@
+contract C {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract B is C {
+}
+
+contract B2 is C {
+	constructor() {
+		assert(a == 2);
+	}
+}
+
+contract A is B, B2 {
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_chain.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_chain.sol
new file mode 100644
index 00000000..113e80da
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_chain.sol
@@ -0,0 +1,24 @@
+contract F {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract E is F {}
+contract D is E {}
+contract C is D {}
+contract B is C {}
+
+contract A is B {
+	constructor(uint x) {
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (162-168): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (192-206): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_middle.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_middle.sol
new file mode 100644
index 00000000..8c6ca28e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_empty_middle.sol
@@ -0,0 +1,22 @@
+contract C {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract B is C {
+}
+
+contract A is B {
+	constructor(uint x) B() {
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (106-112): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (140-154): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain.sol
new file mode 100644
index 00000000..75d5efb4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain.sol
@@ -0,0 +1,32 @@
+contract F {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract E is F {}
+contract D is E {
+	constructor() {
+		a = 3;
+	}
+}
+contract C is D {}
+contract B is C {
+	constructor() {
+		a = 4;
+	}
+}
+
+contract A is B {
+	constructor(uint x) {
+		assert(a == 4);
+		assert(a == 5);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (222-228): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (252-266): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_empty_base.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_empty_base.sol
new file mode 100644
index 00000000..4eac4fe9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_empty_base.sol
@@ -0,0 +1,27 @@
+contract F {
+	uint a;
+	constructor() {
+		a = 2;
+	}
+}
+
+contract E is F {}
+contract D is E {
+	constructor() {
+		a = 3;
+	}
+}
+contract C is D {}
+contract B is C {
+	constructor() {
+		assert(a == 3);
+		a = 4;
+	}
+}
+
+contract A is B {
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_local_vars.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_local_vars.sol
new file mode 100644
index 00000000..ea1f31aa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_local_vars.sol
@@ -0,0 +1,37 @@
+contract F {
+	uint a;
+	constructor() {
+		uint f = 2;
+		a = f;
+	}
+}
+
+contract E is F {}
+contract D is E {
+	constructor() {
+		uint d = 3;
+		a = d;
+	}
+}
+contract C is D {}
+contract B is C {
+	constructor() {
+		uint b = 4;
+		a = b;
+	}
+}
+
+contract A is B {
+	constructor(uint x) {
+		uint a1 = 4;
+		uint a2 = 5;
+		assert(a == a1);
+		assert(a == a2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (264-270): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (325-340): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params.sol
new file mode 100644
index 00000000..2d49cd1e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params.sol
@@ -0,0 +1,32 @@
+contract F {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract E is F {}
+abstract contract D is E {
+	constructor() {
+		a = 3;
+	}
+}
+abstract contract C is D {}
+contract B is C {
+	constructor(uint x) F(x + 1) {
+	}
+}
+
+contract A is B {
+	constructor(uint x) B(x) {
+		assert(a == 3);
+		assert(a == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (215-220): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (296-310): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params_2.sol
new file mode 100644
index 00000000..383392c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_hierarchy_mixed_chain_with_params_2.sol
@@ -0,0 +1,28 @@
+contract F {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract E is F {}
+abstract contract D is E {
+	constructor() {
+		a = 3;
+	}
+}
+abstract contract C is D {}
+contract B is C {
+	constructor() F(1) {
+		assert(a == 3);
+		assert(a == 2);
+	}
+}
+
+contract A is B {
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (234-248): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_simple.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_simple.sol
new file mode 100644
index 00000000..ef0a5467
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_simple.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x;
+
+	constructor() {
+		assert(x == 0);
+		x = 10;
+	}
+
+	function f(uint y) public view {
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (108-122): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value.sol
new file mode 100644
index 00000000..1726c89f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value.sol
@@ -0,0 +1,18 @@
+contract C {
+	uint x = 5;
+
+	constructor() {
+		assert(x == 5);
+		x = 10;
+	}
+
+	function f(uint y) public view {
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (112-126): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_inherited.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_inherited.sol
new file mode 100644
index 00000000..1fc6e011
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_inherited.sol
@@ -0,0 +1,20 @@
+contract B {
+	uint x = 5;
+}
+
+contract C is B {
+	constructor() {
+		assert(x == 5);
+		x = 10;
+	}
+
+	function f(uint y) public view {
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (132-146): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_parameter.sol b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_parameter.sol
new file mode 100644
index 00000000..008338ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/constructor_state_value_parameter.sol
@@ -0,0 +1,19 @@
+contract C {
+	uint x = 5;
+
+	constructor(uint a, uint b) {
+		assert(x == 5);
+		x = a + b;
+	}
+
+	function f(uint y) view public {
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (82-87): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (129-143): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/function_call_does_not_clear_local_vars.sol b/compiler/test/libsolidity/smtCheckerTests/functions/function_call_does_not_clear_local_vars.sol
new file mode 100644
index 00000000..32b51d53
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/function_call_does_not_clear_local_vars.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public {
+        uint a = 3;
+        this.f();
+        assert(a == 3);
+        f();
+        assert(a == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5740: (122-136): Unreachable code.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/function_inline_chain.sol b/compiler/test/libsolidity/smtCheckerTests/functions/function_inline_chain.sol
new file mode 100644
index 00000000..47ace2a9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/function_inline_chain.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	uint y;
+
+	function f() public {
+		if (y != 1)
+			g();
+		assert(y == 1);
+	}
+
+	function g() internal {
+		y = 1;
+		h();
+	}
+
+	function h() internal {
+		f();
+		assert(y == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var.sol b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var.sol
new file mode 100644
index 00000000..bd74fe1b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint x;
+	function f() internal {
+		require(x < 10000);
+		x = x + 1;
+	}
+	function g(bool b) public {
+		x = 0;
+		if (b)
+			f();
+		// Should fail for `b == true`.
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (176-190): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_2.sol
new file mode 100644
index 00000000..3f45d8b5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_2.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint x;
+	function f() internal {
+		require(x < 10000);
+		x = x + 1;
+	}
+	function g(bool b) public {
+		x = 0;
+		if (b)
+			f();
+		else
+			f();
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_3.sol
new file mode 100644
index 00000000..0795c832
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/function_inside_branch_modify_state_var_3.sol
@@ -0,0 +1,29 @@
+contract C
+{
+	uint x;
+	function f() internal {
+		require(x < 10000);
+		x = x + 1;
+	}
+	function g(bool b) public {
+		x = 0;
+		if (b)
+			f();
+		// Should fail for `b == true`.
+		assert(x == 0);
+	}
+	function h(bool b) public {
+		x = 0;
+		if (!b)
+			f();
+		// Should fail for `b == false`.
+		assert(x == 0);
+	}
+
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (176-190): CHC: Assertion violation happens here.
+// Warning 6328: (288-302): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1.sol
new file mode 100644
index 00000000..0a646d0e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1.sol
@@ -0,0 +1,21 @@
+library L
+{
+	function add(uint x, uint y) internal pure returns (uint) {
+		require(x < 1000);
+		require(y < 1000);
+		return x + y;
+	}
+}
+
+contract C
+{
+	using L for uint;
+	function f(uint x) public pure {
+		uint y = x.add(999);
+		assert(y < 10000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1_fail.sol
new file mode 100644
index 00000000..e739aa57
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_attached_1_fail.sol
@@ -0,0 +1,22 @@
+library L
+{
+	function add(uint x, uint y) internal pure returns (uint) {
+		require(x < 1000);
+		require(y < 1000);
+		return x + y;
+	}
+}
+
+contract C
+{
+	using L for uint;
+	function f(uint x) public pure {
+		uint y = x.add(999);
+		assert(y < 1000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (228-244): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_1.sol
new file mode 100644
index 00000000..56090df2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_1.sol
@@ -0,0 +1,22 @@
+abstract contract D
+{
+	function g(uint x) public virtual;
+}
+
+contract C
+{
+	uint x;
+	function f(uint y, D d) public {
+		require(x == y);
+		assert(x == y);
+		d.g(y);
+		// Storage knowledge is cleared after an external call.
+		assert(x == y);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_2.sol
new file mode 100644
index 00000000..d3373b62
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_2.sol
@@ -0,0 +1,28 @@
+abstract contract D
+{
+	function g(uint x) public virtual;
+}
+
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint y, D d) public {
+		require(map[0] == map[1]);
+		assert(map[0] == map[1]);
+		d.g(y);
+		assert(map[0] == map[1]);
+		assert(map[0] == 0); // should fail
+	}
+
+	function set(uint x) public {
+		map[0] = x;
+		map[1] = x;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (234-253): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_3.sol
new file mode 100644
index 00000000..6f80e1e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_external_3.sol
@@ -0,0 +1,21 @@
+abstract contract D
+{
+	function g(uint x) public virtual;
+}
+
+contract C
+{
+	mapping (uint => uint) storageMap;
+	function f(uint y, D d) public {
+		mapping (uint => uint) storage map = storageMap;
+		require(map[0] == map[1]);
+		assert(map[0] == map[1]);
+		d.g(y);
+		// Storage knowledge is cleared after an external call.
+		assert(map[0] == map[1]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_1.sol
new file mode 100644
index 00000000..bddefceb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_1.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint x;
+	function f() public {
+		x = 0;
+		((inc))();
+		assert(x == 1); // should hold
+	}
+
+	function inc() internal returns (uint) {
+		require(x < 100);
+		return ++x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_2.sol
new file mode 100644
index 00000000..8e491d8d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identifier_nested_tuple_2.sol
@@ -0,0 +1,22 @@
+library L {
+	struct S {
+		uint256[] data;
+	}
+	function f(S memory _s) internal pure returns (uint256) {
+		require(_s.data.length > 0);
+		return 42;
+	}
+}
+
+contract C {
+	using L for L.S;
+	function f() public pure returns (uint256 y) {
+		L.S memory x;
+		y = (x.f)();
+		assert(y == 42); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1.sol
new file mode 100644
index 00000000..40a023bb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = h(42);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1_fail.sol
new file mode 100644
index 00000000..414a8a52
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_1_fail.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = h(0);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (129-142): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.h(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2.sol
new file mode 100644
index 00000000..54d0abaf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return k(x);
+	}
+
+	function k(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = h(2);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2_fail.sol
new file mode 100644
index 00000000..955f6906
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_2_fail.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return k(x);
+	}
+
+	function k(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = h(0);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (197-210): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.h(0) -- internal call\n        C.k(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple.sol
new file mode 100644
index 00000000..e140fded
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = (h)(42);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple_fail.sol
new file mode 100644
index 00000000..b511dc63
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_identity_as_tuple_fail.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function h(uint x) public pure returns (uint) {
+		return x;
+	}
+	function g() public pure {
+		uint x;
+		x = (h)(0);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (131-144): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.h(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1.sol
new file mode 100644
index 00000000..a6c1539f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1.sol
@@ -0,0 +1,20 @@
+library L
+{
+	function add(uint x, uint y) internal pure returns (uint) {
+		require(x < 1000);
+		require(y < 1000);
+		return x + y;
+	}
+}
+
+contract C
+{
+	function f(uint x) public pure {
+		uint y = L.add(x, 999);
+		assert(y < 10000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1_fail.sol
new file mode 100644
index 00000000..843679a5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_1_fail.sol
@@ -0,0 +1,21 @@
+library L
+{
+	function add(uint x, uint y) internal pure returns (uint) {
+		require(x < 1000);
+		require(y < 1000);
+		return x + y;
+	}
+}
+
+contract C
+{
+	function f(uint x) public pure {
+		uint y = L.add(x, 999);
+		assert(y < 1000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (212-228): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_internal.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_internal.sol
new file mode 100644
index 00000000..405c3f71
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_library_internal.sol
@@ -0,0 +1,14 @@
+library L {
+	function value(function()internal a, uint256 b) internal {}
+}
+contract C {
+	using L for function()internal;
+
+	function f() public {
+		function()internal x;
+		x.value(42);
+ 	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive.sol
new file mode 100644
index 00000000..0e3699e6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint a;
+	function g() public {
+		if (a > 0)
+		{
+			a = a - 1;
+			g();
+		}
+		else
+			assert(a == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive_indirect.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive_indirect.sol
new file mode 100644
index 00000000..903afbbc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_recursive_indirect.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint a;
+	function f() public {
+		if (a > 0)
+		{
+			a = a - 1;
+			g();
+		}
+		else
+			assert(a == 0);
+	}
+	function g() public {
+		if (a > 0)
+		{
+			a = a - 1;
+			f();
+		}
+		else
+			assert(a == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1.sol
new file mode 100644
index 00000000..2b6289b9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint a;
+	function f(uint x) public {
+		uint y;
+		a = (y = x);
+	}
+	function g() public {
+		f(1);
+		assert(a > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1_fail.sol
new file mode 100644
index 00000000..3e045cee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_1_fail.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint a;
+	function f(uint x) public {
+		uint y;
+		a = (y = x);
+	}
+	function g() public {
+		f(0);
+		assert(a > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (112-125): CHC: Assertion violation happens here.\nCounterexample:\na = 0\n\nTransaction trace:\nC.constructor()\nState: a = 0\nC.g()\n    C.f(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2.sol
new file mode 100644
index 00000000..001067a2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint a;
+	function f(uint x) public {
+		uint y;
+		a = (y = x);
+	}
+	function g() public {
+		f(1);
+		f(42);
+		assert(a > 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2_fail.sol
new file mode 100644
index 00000000..35906db3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/functions_storage_var_2_fail.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint a;
+	function f(uint x) public {
+		uint y;
+		a = (y = x);
+	}
+	function g() public {
+		f(1);
+		f(0);
+		assert(a > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (120-133): CHC: Assertion violation happens here.\nCounterexample:\na = 0\n\nTransaction trace:\nC.constructor()\nState: a = 0\nC.g()\n    C.f(1) -- internal call\n    C.f(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/address.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/address.sol
new file mode 100644
index 00000000..cf8c9158
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/address.sol
@@ -0,0 +1,19 @@
+contract C {
+	address public x;
+	address payable public y;
+
+	function f() public view {
+		address a = this.x();
+		address b = this.y();
+		assert(a == x); // should hold
+		assert(a == address(this)); // should fail
+		assert(b == y); // should hold
+		assert(y == address(this)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (171-197): CHC: Assertion violation happens here.
+// Warning 6328: (249-275): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_1.sol
new file mode 100644
index 00000000..658e0b85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_1.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint[] public a;
+	constructor() {
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+	}
+	function f() public view {
+		uint y = this.a(2);
+		assert(y == a[2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (187-201): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_2.sol
new file mode 100644
index 00000000..2d92413d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_2.sol
@@ -0,0 +1,23 @@
+contract C {
+	uint[][] public a;
+	constructor() {
+		a.push();
+		a.push();
+		a.push();
+		a[2].push();
+		a[2].push();
+		a[2].push();
+		a[2].push();
+	}
+	function f() public view {
+		uint y = this.a(2,3);
+		assert(y == a[2][3]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (242-256): CHC: Assertion violation happens here.\nCounterexample:\na = [[], [], [0, 0, 0, 0]]\ny = 0\n\nTransaction trace:\nC.constructor()\nState: a = [[], [], [0, 0, 0, 0]]\nC.f()
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_1.sol
new file mode 100644
index 00000000..209b00f5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_1.sol
@@ -0,0 +1,18 @@
+pragma abicoder v1;
+struct Item {
+	uint x;
+	uint y;
+}
+
+contract D {
+	Item[][][] public items;
+
+	function test() public view returns (uint) {
+		(uint a, uint b) = this.items(1, 2, 3);
+		return a + b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_2.sol
new file mode 100644
index 00000000..b62611b5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_2.sol
@@ -0,0 +1,24 @@
+pragma abicoder v1;
+struct Item {
+	uint x;
+	uint y;
+}
+
+contract D {
+	Item[] public items;
+
+	function test() public {
+		delete items;
+		items.push(Item(42, 43));
+		(uint a, uint b) = this.items(0);
+		assert(a == 42); // should hold
+		assert(b == 43); // should hold
+		assert(b == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (267-281): CHC: Assertion violation happens here.\nCounterexample:\nitems = [{x: 42, y: 43}]\na = 42\nb = 43\n\nTransaction trace:\nD.constructor()\nState: items = []\nD.test()
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_3.sol
new file mode 100644
index 00000000..abe50e8a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/array_of_structs_3.sol
@@ -0,0 +1,25 @@
+pragma abicoder v1;
+struct Item {
+	uint x;
+	uint y;
+	uint[] arr;
+}
+
+contract D {
+	Item[] public items;
+
+	function test() public {
+		delete items;
+		uint[] memory tmp = new uint[](1);
+		items.push(Item(42, 43, tmp));
+		(uint a, uint b) = this.items(0);
+		assert(a == 42); // should hold
+		assert(b == 43); // should hold
+		assert(b == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (322-336): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/bytes.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/bytes.sol
new file mode 100644
index 00000000..63522d61
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/bytes.sol
@@ -0,0 +1,14 @@
+contract C {
+	bytes public str2 = 'c';
+
+	function f() public view {
+		bytes memory a2 = this.str2();
+		assert(keccak256(a2) == keccak256(str2)); // should hold
+		assert(keccak256(a2) == keccak256('a')); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (162-201): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/contract.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/contract.sol
new file mode 100644
index 00000000..7da893bd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/contract.sol
@@ -0,0 +1,16 @@
+contract D {}
+
+contract C {
+	D public d;
+
+	function f() public view {
+		D e = this.d();
+		assert(e == d); // should hold
+		assert(address(e) == address(this)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (123-158): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/double_access.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/double_access.sol
new file mode 100644
index 00000000..844773ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/double_access.sol
@@ -0,0 +1,20 @@
+contract C {
+	struct S {
+		uint u;
+	}
+
+	S public s;
+
+	function f() public view {
+		uint u = this.s();
+		uint v = this.s();
+		assert(u == s.u); // should hold
+		assert(u == v); // should hold
+		assert(u == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (193-207): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/enum.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/enum.sol
new file mode 100644
index 00000000..fabe4445
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/enum.sol
@@ -0,0 +1,16 @@
+
+contract C {
+	enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
+	ActionChoices public choice;
+
+	function f() public view {
+		ActionChoices e = this.choice();
+		assert(e == choice); // should hold
+		assert(e == ActionChoices.SitStill); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (210-245): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_1.sol
new file mode 100644
index 00000000..31397eed
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_1.sol
@@ -0,0 +1,23 @@
+contract D {
+	uint public d;
+	function g() public {
+		++d;
+	}
+}
+
+contract C {
+	function f() public {
+		D a = new D();
+		assert(a.d() == 0); // should hold
+		a.g();
+		assert(a.d() == 1); // should hold
+		assert(a.d() == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (203-221): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_2.sol
new file mode 100644
index 00000000..ad8ddcd0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_2.sol
@@ -0,0 +1,34 @@
+contract E {
+	uint public e;
+	function setE(uint _e) public {
+		e = _e;
+	}
+}
+
+contract D {
+	E e;
+	constructor(E _e) {
+		e = _e;
+	}
+	function setE(uint x) public {
+		e.setE(x);
+	}
+}
+
+contract C {
+	function f() public {
+		E e = new E();
+		D d = new D(e);
+		assert(e.e() == 0); // should hold
+		d.setE(42);
+		assert(e.e() == 42); // should hold
+		assert(e.e() == 2); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTTargets: assert
+// ----
+// Warning 6328: (344-362): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_1.sol
new file mode 100644
index 00000000..f23af4f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_1.sol
@@ -0,0 +1,19 @@
+contract C {
+	uint public x;
+
+	function f() public {
+		x = 2;
+		x = 3;
+		uint y = this.x();
+		assert(y == 3); // should hold
+		assert(y == 2); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (127-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_2.sol
new file mode 100644
index 00000000..0673b14a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/external_getter_this_2.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint public x;
+
+	function f() public {
+		x = 2;
+		x = 3;
+		C c = this;
+		uint y = c.x();
+		assert(y == 3); // should hold
+		assert(y == 2); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTExtCalls: trusted
+// SMTIgnoreCex: yes
+// SMTTargets: assert
+// ----
+// Warning 6328: (138-152): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/fixed_bytes.sol
new file mode 100644
index 00000000..6edf2a88
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/fixed_bytes.sol
@@ -0,0 +1,19 @@
+contract C {
+	bytes1 public x;
+	bytes3 public y;
+
+	function f() public view {
+		bytes1 a = this.x();
+		bytes3 b = this.y();
+		assert(a == x); // should hold
+		assert(a == 'a'); // should fail
+		assert(b == y); // should hold
+		assert(y == "abc"); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (159-175): CHC: Assertion violation happens here.
+// Warning 6328: (227-245): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/function.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/function.sol
new file mode 100644
index 00000000..a5339f7a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/function.sol
@@ -0,0 +1,20 @@
+contract C {
+	function () external returns (uint) public g;
+
+	function f() public {
+		g = this.X;
+		function () external returns (uint) e = this.g();
+		assert(e() == g()); // should hold, but fails because of the lack of support for tracking function pointers
+		assert(e() == 1); // should fail
+	}
+
+	function X() public pure returns (uint) {
+		return 42;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8364: (140-146): Assertion checker does not yet implement type function () view external returns (function () external returns (uint256))
+// Warning 6328: (152-170): CHC: Assertion violation happens here.
+// Warning 6328: (262-278): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_1.sol
new file mode 100644
index 00000000..4dbd6a48
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_1.sol
@@ -0,0 +1,15 @@
+contract C {
+	mapping (uint => uint) public map;
+
+	function f() public view {
+		uint y = this.map(2);
+		assert(y == map[2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (142-156): CHC: Assertion violation happens here.\nCounterexample:\n\ny = 0\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_2.sol
new file mode 100644
index 00000000..418515a2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_2.sol
@@ -0,0 +1,15 @@
+contract C {
+	mapping (uint => mapping (uint => uint)) public map;
+
+	function f() public view {
+		uint y = this.map(2, 3);
+		assert(y == map[2][3]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (166-180): CHC: Assertion violation happens here.\nCounterexample:\n\ny = 0\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_with_cast.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_with_cast.sol
new file mode 100644
index 00000000..b78f44d5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/mapping_with_cast.sol
@@ -0,0 +1,14 @@
+contract C {
+	mapping (bytes16 => uint) public m;
+
+	function f() public view {
+		uint y = this.m("foo");
+		assert(y == m["foo"]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (147-161): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_1.sol
new file mode 100644
index 00000000..6e221e65
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_1.sol
@@ -0,0 +1,20 @@
+contract C {
+	mapping (uint => uint[]) public m;
+
+	constructor() {
+		m[0].push();
+		m[0].push();
+		m[0][1] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1);
+		assert(y == m[0][1]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (210-224): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_10.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_10.sol
new file mode 100644
index 00000000..ce840d7d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_10.sol
@@ -0,0 +1,23 @@
+contract C {
+	mapping (uint => uint[])[] public m;
+
+	constructor() {
+		m.push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1][2] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2);
+		assert(y == m[0][1][2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (256-270): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_2.sol
new file mode 100644
index 00000000..934eb854
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_2.sol
@@ -0,0 +1,24 @@
+contract C {
+	mapping (uint => uint[][]) public m;
+
+	constructor() {
+		m[0].push();
+		m[0].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1][2] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2);
+		assert(y == m[0][1][2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (274-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_3.sol
new file mode 100644
index 00000000..8471d6f2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_3.sol
@@ -0,0 +1,27 @@
+contract C {
+	mapping (uint => uint[][][]) public m;
+
+	constructor() {
+		m[0].push();
+		m[0].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2][3] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2,3);
+		assert(y == m[0][1][2][3]); // should hold
+		// Disabled because of Spacer seg fault
+		//assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 18 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_4.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_4.sol
new file mode 100644
index 00000000..3e0f0b63
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_4.sol
@@ -0,0 +1,22 @@
+contract C {
+	mapping (uint => mapping (uint => uint[])) public m;
+
+	constructor() {
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1][2] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2);
+		assert(y == m[0][1][2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (260-274): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_5.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_5.sol
new file mode 100644
index 00000000..17c280e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_5.sol
@@ -0,0 +1,26 @@
+contract C {
+	mapping (uint => mapping (uint => uint[][])) public m;
+
+	constructor() {
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2][3] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2,3);
+		assert(y == m[0][1][2][3]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (354-368): CHC: Assertion violation happens here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_6.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_6.sol
new file mode 100644
index 00000000..08af1f55
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_6.sol
@@ -0,0 +1,22 @@
+contract C {
+	mapping (uint => mapping (uint => mapping (uint => uint[]))) public m;
+
+	constructor() {
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2].push();
+		m[0][1][2][3] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2,3);
+		assert(y == m[0][1][2][3]); // should hold
+		// Disabled because Spacer seg faults
+		//assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_7.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_7.sol
new file mode 100644
index 00000000..d22fe68d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_7.sol
@@ -0,0 +1,19 @@
+contract C {
+	mapping (uint => uint)[] public m;
+
+	constructor() {
+		m.push();
+		m[0][1] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1);
+		assert(y == m[0][1]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (192-206): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_8.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_8.sol
new file mode 100644
index 00000000..d57591c7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_8.sol
@@ -0,0 +1,21 @@
+contract C {
+	mapping (uint => uint)[][] public m;
+
+	constructor() {
+		m.push();
+		m[0].push();
+		m[0].push();
+		m[0][1][2] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2);
+		assert(y == m[0][1][2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (232-246): CHC: Assertion violation happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_9.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_9.sol
new file mode 100644
index 00000000..8bb9f9fb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/nested_arrays_mappings_9.sol
@@ -0,0 +1,19 @@
+contract C {
+	mapping (uint => mapping (uint => uint))[] public m;
+
+	constructor() {
+		m.push();
+		m[0][1][2] = 42;
+	}
+
+	function f() public view {
+		uint y = this.m(0,1,2);
+		assert(y == m[0][1][2]); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (218-232): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/static_array.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/static_array.sol
new file mode 100644
index 00000000..a7b057be
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/static_array.sol
@@ -0,0 +1,16 @@
+
+contract C {
+
+	uint[2] public x = [42,1];
+
+	function f() public view {
+		assert(this.x(0) == x[0]); // should hold
+		assert(this.x(1) == x[1]); // should hold
+		assert(this.x(0) == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (162-184): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/string.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/string.sol
new file mode 100644
index 00000000..9649372f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/string.sol
@@ -0,0 +1,14 @@
+contract C {
+	string public str1 = 'b';
+
+	function f() public view {
+		string memory a1 = this.str1();
+		assert(keccak256(bytes(a1)) == keccak256(bytes(str1))); // should hold
+		assert(keccak256(bytes(a1)) == keccak256('a')); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (178-224): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_1.sol
new file mode 100644
index 00000000..06c02170
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_1.sol
@@ -0,0 +1,32 @@
+pragma abicoder v2;
+
+contract C {
+	struct T {
+		uint t;
+	}
+	struct S {
+		uint x;
+		T t;
+		bool b;
+		uint[] a;
+	}
+
+	S public s;
+
+	function f() public view {
+		uint y;
+		bool c;
+		T memory t;
+		(y,t,c) = this.s();
+		assert(y == s.x); // this should hold
+		assert(c == s.b); // this should hold
+		assert(t.t == s.t.t); // this should hold
+		assert(c == true); // this should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (338-355): CHC: Assertion violation happens here.\nCounterexample:\ns = {x: 0, t: {t: 0}, b: false, a: []}\ny = 0\nc = false\nt = {t: 0}\n\nTransaction trace:\nC.constructor()\nState: s = {x: 0, t: {t: 0}, b: false, a: []}\nC.f()
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_2.sol
new file mode 100644
index 00000000..b43df21f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_2.sol
@@ -0,0 +1,22 @@
+//pragma abicoder v2;
+
+contract C {
+	struct S {
+		uint[2] a;
+		uint u;
+	}
+
+	S public s;
+
+	function f() public view {
+		uint u = this.s();
+		assert(u == s.u); // should hold
+		assert(u == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (175-189): CHC: Assertion violation happens here.\nCounterexample:\ns = {a: [0, 0], u: 0}\nu = 0\n\nTransaction trace:\nC.constructor()\nState: s = {a: [0, 0], u: 0}\nC.f()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_3.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_3.sol
new file mode 100644
index 00000000..ea68e048
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_3.sol
@@ -0,0 +1,25 @@
+contract C {
+	struct S {
+		string s;
+		bytes b;
+	}
+
+	S public m;
+
+	constructor() {
+		m.s = "foo";
+		m.b = "bar";
+	}
+
+	function f() public view {
+		(string memory s, bytes memory b) = this.m();
+		assert(keccak256(bytes(s)) == keccak256(bytes(m.s))); // should hold
+		assert(b[0] == m.b[0]); // should hold
+		assert(b[0] == "t"); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (307-326): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_4.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_4.sol
new file mode 100644
index 00000000..34595935
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_4.sol
@@ -0,0 +1,24 @@
+contract D {
+}
+
+contract C {
+	struct S {
+		D d;
+		function () external returns (uint) f;
+	}
+
+	S public s;
+
+	function test() public view {
+		(D d, function () external returns (uint) f) = this.s();
+		assert(d == s.d); // should hold
+		assert(address(d) == address(this)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2072: (146-183): Unused local variable.
+// Warning 8364: (187-193): Assertion checker does not yet implement type function () view external returns (contract D,function () external returns (uint256))
+// Warning 6328: (234-269): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_with_reassignment.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_with_reassignment.sol
new file mode 100644
index 00000000..a322f4fb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/struct_with_reassignment.sol
@@ -0,0 +1,34 @@
+contract C {
+	struct S {
+		uint x;
+		bool b;
+	}
+
+	S public s;
+
+	constructor() {
+		s.x = 1;
+		s.b = false;
+	}
+
+	function f() public {
+		uint x;
+		bool b;
+		(x,b) = this.s();
+		assert(x == s.x); // this should hold
+		assert(b == s.b); // this should hold
+		assert(b == true); // this should fail
+		s.x = 42;
+		(uint y, bool c) = this.s();
+		assert(c == b); // this should hold
+		assert(y == x); // this should fail
+
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (255-272): CHC: Assertion violation happens here.\nCounterexample:\ns = {x: 1, b: false}\nx = 1\nb = false\ny = 0\nc = false\n\nTransaction trace:\nC.constructor()\nState: s = {x: 1, b: false}\nC.f()
+// Warning 6328: (377-391): CHC: Assertion violation happens here.\nCounterexample:\ns = {x: 42, b: false}\nx = 1\nb = false\ny = 42\nc = false\n\nTransaction trace:\nC.constructor()\nState: s = {x: 1, b: false}\nC.f()
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/getters/uint.sol b/compiler/test/libsolidity/smtCheckerTests/functions/getters/uint.sol
new file mode 100644
index 00000000..d05753dd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/getters/uint.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint public x;
+
+	function f() public view {
+		uint y = this.x();
+		assert(y == x); // should hold
+		assert(y == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (114-128): CHC: Assertion violation happens here.\nCounterexample:\nx = 0\ny = 0\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.f()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_state_var_init_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_state_var_init_2.sol
new file mode 100644
index 00000000..4a8ed0d7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_state_var_init_2.sol
@@ -0,0 +1,12 @@
+contract c {
+	uint x;
+	function f() internal returns (uint) {
+		x = x + 1;
+	}
+	bool b = (f() > 0) || (f() > 0);
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (54-58): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1.sol
new file mode 100644
index 00000000..f42bdb7d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1.sol
@@ -0,0 +1,25 @@
+contract C{
+    uint x;
+	constructor(uint y) {
+		assert(x == 0);
+		x = 1;
+	}
+    function f() public {
+		assert(x == 1);
+		++x;
+		g();
+		assert(x == 1);
+    }
+
+	function g() internal {
+		assert(x == 2);
+		--x;
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 5667: (37-43): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1_fail.sol
new file mode 100644
index 00000000..1aaa973f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_1_fail.sol
@@ -0,0 +1,29 @@
+contract C{
+    uint x;
+	constructor(uint y) {
+		assert(x == 1);
+		x = 1;
+	}
+    function f() public {
+		assert(x == 2);
+		++x;
+		g();
+		assert(x == 2);
+    }
+
+	function g() internal {
+		assert(x == 3);
+		--x;
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (37-43): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (49-63): CHC: Assertion violation happens here.
+// Warning 6328: (105-119): CHC: Assertion violation happens here.
+// Warning 6328: (137-151): CHC: Assertion violation happens here.
+// Warning 6328: (187-201): CHC: Assertion violation happens here.
+// Warning 6328: (212-226): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1.sol
new file mode 100644
index 00000000..3ad9aa48
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1.sol
@@ -0,0 +1,20 @@
+contract A {
+	uint x;
+	function f() internal {
+		assert(x == 1);
+		--x;
+	}
+}
+
+contract C is A {
+	constructor() {
+		assert(x == 0);
+		++x;
+		f();
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1_fail.sol
new file mode 100644
index 00000000..9f2fca60
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_call_with_assertion_inheritance_1_fail.sol
@@ -0,0 +1,23 @@
+contract A {
+	uint x;
+	function f() internal {
+		assert(x == 2);
+		--x;
+	}
+}
+
+contract C is A {
+	constructor() {
+		assert(x == 1);
+		++x;
+		f();
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (49-63): CHC: Assertion violation happens here.
+// Warning 6328: (115-129): CHC: Assertion violation happens here.
+// Warning 6328: (147-161): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1.sol
new file mode 100644
index 00000000..e7e6ec61
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1.sol
@@ -0,0 +1,24 @@
+contract C{
+    uint x;
+	constructor(uint y) {
+		assert(x == 0);
+		x = 1;
+	}
+    function f() public {
+		assert(x == 1);
+		++x;
+		++x;
+		g();
+		g();
+		assert(x == 1);
+    }
+
+	function g() internal {
+		--x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (37-43): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1_fail.sol
new file mode 100644
index 00000000..34d793d0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/internal_multiple_calls_with_assertion_1_fail.sol
@@ -0,0 +1,27 @@
+contract C{
+    uint x;
+	constructor(uint y) {
+		assert(x == 1);
+		x = 1;
+	}
+    function f() public {
+		assert(x == 2);
+		++x;
+		++x;
+		g();
+		g();
+		assert(x == 3);
+    }
+
+	function g() internal {
+		--x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (37-43): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (49-63): CHC: Assertion violation happens here.
+// Warning 6328: (105-119): CHC: Assertion violation happens here.
+// Warning 6328: (151-165): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/library_after_contract.sol b/compiler/test/libsolidity/smtCheckerTests/functions/library_after_contract.sol
new file mode 100644
index 00000000..7fe00f57
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/library_after_contract.sol
@@ -0,0 +1,17 @@
+contract C {
+	function g(uint y) public {
+		uint z = L.f(y);
+		assert(z == y);
+	}
+}
+
+library L {
+	function f(uint x) internal returns (uint) {
+		return x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2018: (98-157): Function state mutability can be restricted to pure
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/library_constant.sol b/compiler/test/libsolidity/smtCheckerTests/functions/library_constant.sol
new file mode 100644
index 00000000..53349f0b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/library_constant.sol
@@ -0,0 +1,24 @@
+library l1 {
+
+	uint private constant TON = 1000;
+	function f1() public pure {
+		assert(TON == 1000);
+		assert(TON == 2000);
+	}
+	function f2(uint x, uint y) internal pure returns (uint) {
+		return x + y;
+	}
+}
+
+contract C {
+	function f(uint x) public pure {
+		uint z = l1.f2(x, 1);
+		assert(z == x + 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (103-122): CHC: Assertion violation happens here.
+// Warning 4984: (196-201): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/library_constant_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/library_constant_2.sol
new file mode 100644
index 00000000..bfa26030
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/library_constant_2.sol
@@ -0,0 +1,11 @@
+library l1 {
+
+	uint private constant TON = 1000;
+	function f1() public pure {
+		assert(TON == 1000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_1.sol b/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_1.sol
new file mode 100644
index 00000000..fd763b8c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_1.sol
@@ -0,0 +1,26 @@
+library L {
+    function f1(uint x) public pure {
+        assert(x > 0); // should fail
+    }
+    function f(uint x) internal pure { f1(x); }
+}
+
+contract C {
+    function g(uint x) external pure {
+        // This should trigger the assertion failure
+        // since it calls `f` internally, which calls
+        // `f1` internally.
+        return L.f(x);
+    }
+
+    function h(uint x) external pure {
+        // This should not trigger the assertion failure
+        // since it delegatecalls and that's not supported.
+        return L.f1(x);
+    }
+}
+// ====
+// SMTContract: C
+// ----
+// Warning 4588: (533-540): Assertion checker does not yet implement this type of function call.
+// Warning 6328: (58-71): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\n\nTransaction trace:\nC.constructor()\nC.g(0)\n    L.f(0) -- internal call\n        L.f1(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_2.sol
new file mode 100644
index 00000000..c0c62c24
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/library_public_called_as_internal_2.sol
@@ -0,0 +1,24 @@
+library L {
+    function f1(uint x) public pure {
+        assert(x > 0); // should fail
+    }
+    function f() internal pure {
+        f1(0); // should cause the assertion in `f1` to fail
+    }
+    function g() internal pure {
+        f1(1); // should not cause the assertion in `f1` to fail
+    }
+}
+
+contract C {
+    function f() external pure {
+        return L.f(); // should cause the assertion to fail
+    }
+    function g() external pure {
+        return L.g(); // should not cause the assertion to fail
+    }
+}
+// ====
+// SMTContract: C
+// ----
+// Warning 6328: (58-71): CHC: Assertion violation happens here.\nCounterexample:\n\n\nTransaction trace:\nC.constructor()\nC.f()\n    L.f() -- internal call\n        L.f1(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/payable_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/payable_2.sol
new file mode 100644
index 00000000..2a381fd4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/payable_2.sol
@@ -0,0 +1,29 @@
+contract C {
+	function g() external {
+		f();
+		h();
+		i();
+	}
+
+	function g2() external payable {
+		i();
+	}
+
+	function f() internal {
+		require(msg.value == 0);
+	}
+
+	function h() internal {
+		assert(msg.value == 0); // should hold
+	}
+
+	function i() internal {
+		assert(msg.value == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (261-283): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/super_function_assert.sol b/compiler/test/libsolidity/smtCheckerTests/functions/super_function_assert.sol
new file mode 100644
index 00000000..e0b19157
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/super_function_assert.sol
@@ -0,0 +1,35 @@
+contract A {
+	int x = 0;
+
+	function f() virtual internal {
+		x = 2;
+	}
+
+	function proxy() public {
+		f();
+	}
+}
+
+contract C is A {
+	function f() internal virtual override {
+		super.f();
+		assert(x == 2);
+		assert(x == 3); // should fail
+	}
+}
+
+contract D is C {
+
+	function f() internal override {
+		super.f();
+		assert(x == 2);
+		assert(x == 3); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (205-219): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 0\nA.proxy()\n    C.f() -- internal call\n        A.f() -- internal call
+// Warning 6328: (328-342): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nD.constructor()\nState: x = 0\nA.proxy()\n    D.f() -- internal call\n        C.f() -- internal call\n            A.f() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call.sol
new file mode 100644
index 00000000..c079ba49
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint x;
+	function f(uint y) public {
+		x = y;
+	}
+	function g(uint y) public {
+		require(y < 1000);
+		this.f(y);
+		assert(x < 1000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_2.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_2.sol
new file mode 100644
index 00000000..7d7064c9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_2.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint a;
+    function f(uint x) public {
+        this.g(x);
+        assert(a == x);
+        assert(a != 42);
+    }
+
+    function g(uint x) public {
+        a = x;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (108-123): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_return.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_return.sol
new file mode 100644
index 00000000..06ba5dd4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_return.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint x;
+	function f(uint y) public returns (uint) {
+		x = y;
+		return x;
+	}
+	function g(uint y) public {
+		require(y < 1000);
+		uint z = this.f(y);
+		assert(z < 1000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_sender.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_sender.sol
new file mode 100644
index 00000000..4907a740
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_sender.sol
@@ -0,0 +1,30 @@
+contract C {
+    address lastCaller;
+
+    constructor() {
+        lastCaller = msg.sender;
+    }
+
+    modifier log {
+        lastCaller = msg.sender;
+        _;
+    }
+
+    function test() log public {
+        assert(lastCaller == msg.sender);
+        this.g();
+        assert(lastCaller == address(this));
+        assert(lastCaller == msg.sender);
+        assert(lastCaller == address(0));
+    }
+
+    function g() log public {
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (314-346): CHC: Assertion violation happens here.
+// Warning 6328: (356-388): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_tx_origin.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_tx_origin.sol
new file mode 100644
index 00000000..6b07cf2d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_external_call_tx_origin.sol
@@ -0,0 +1,15 @@
+contract C {
+
+	function test() view public {
+		require(address(this) != tx.origin);
+		assert(!this.g());
+	}
+
+	function g() view public returns (bool) {
+		return msg.sender == tx.origin;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/this_state.sol b/compiler/test/libsolidity/smtCheckerTests/functions/this_state.sol
new file mode 100644
index 00000000..dec10106
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/this_state.sol
@@ -0,0 +1,16 @@
+contract C
+{
+    uint public x;
+    function g() public {
+		x = 0;
+        this.h();
+		assert(x == 2);
+    }
+    function h() public {
+        x = 2;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_assert.sol b/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_assert.sol
new file mode 100644
index 00000000..d39aaad5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_assert.sol
@@ -0,0 +1,23 @@
+contract A {
+    int x = 0;
+
+    function f() virtual internal view {
+        assert(x == 0);
+    }
+
+    function proxy() public view {
+        f();
+    }
+}
+
+contract C is A {
+
+    function f() internal view override {
+        assert(x == 1);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (227-241): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_called_by_constructor.sol b/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_called_by_constructor.sol
new file mode 100644
index 00000000..b4deddc7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/functions/virtual_function_called_by_constructor.sol
@@ -0,0 +1,30 @@
+contract A {
+    uint public x;
+    function v() internal virtual {
+        x = 2;
+    }
+    constructor() {
+        v();
+    }
+	function i() public view virtual {
+		assert(x == 2); // should hold
+		assert(x == 10); // should fail
+	}
+}
+
+contract C is A {
+    function v() internal override {
+        x = 10;
+    }
+	function i() public view override {
+		assert(x == 10); // should hold
+		assert(x == 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (199-214): CHC: Assertion violation happens here.
+// Warning 6328: (387-401): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/imports/ExtCall.sol b/compiler/test/libsolidity/smtCheckerTests/imports/ExtCall.sol
new file mode 100644
index 00000000..7675bc42
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/imports/ExtCall.sol
@@ -0,0 +1,42 @@
+==== Source: ExtCall.sol ====
+interface Unknown {
+    function callme() external;
+}
+
+contract ExtCall {
+    uint x;
+
+    bool lock;
+    modifier mutex {
+        require(!lock);
+        lock = true;
+        _;
+        lock = false;
+    }
+
+    function setX(uint y) mutex public {
+        x = y;
+    }
+
+    function xMut(Unknown u) public {
+        uint x_prev = x;
+        u.callme();
+        assert(x_prev == x);
+    }
+}
+==== Source: ExtCall.t.sol ====
+import "ExtCall.sol";
+
+contract ExtCallTest {
+    ExtCall call;
+
+    function setUp() public {
+        call = new ExtCall();
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (ExtCall.sol:362-381): CHC: Assertion violation happens here.
+// Warning 8729: (ExtCall.t.sol:110-123): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
diff --git a/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_1.sol b/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_1.sol
new file mode 100644
index 00000000..cd9a6476
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_1.sol
@@ -0,0 +1,21 @@
+==== Source: A ====
+import "s1.sol" as M;
+contract D is M.C {
+	function f(uint _y) public {
+		g(_y);
+		assert(x == _y); // should hold
+		assert(x > 100); // should fail
+	}
+}
+==== Source: s1.sol ====
+contract C {
+	uint x;
+	function g(uint _x) public {
+		x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (A:117-132): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_2.sol b/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_2.sol
new file mode 100644
index 00000000..1298f1f0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/imports/import_as_module_2.sol
@@ -0,0 +1,23 @@
+==== Source: A ====
+import "s1.sol" as M;
+function f(uint _x) pure {
+	assert(_x > 0);
+}
+contract D {
+	function g(uint _y) public pure {
+		M.f(200); // should hold
+		M.f(_y); // should fail
+		f(10); // should hold
+		f(_y); // should fail
+	}
+}
+==== Source: s1.sol ====
+function f(uint _x) pure {
+	assert(_x > 100);
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (A:50-64): CHC: Assertion violation happens here.\nCounterexample:\n\n_y = 0\n\nTransaction trace:\nD.constructor()\nD.g(0)\n    s1.sol:f(200) -- internal call\n    s1.sol:f(0) -- internal call\n    A:f(10) -- internal call\n    A:f(0) -- internal call
+// Warning 6328: (s1.sol:28-44): CHC: Assertion violation happens here.\nCounterexample:\n\n_y = 0\n\nTransaction trace:\nD.constructor()\nD.g(0)\n    s1.sol:f(200) -- internal call\n    s1.sol:f(0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/imports/import_base.sol b/compiler/test/libsolidity/smtCheckerTests/imports/import_base.sol
new file mode 100644
index 00000000..3e8aeefe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/imports/import_base.sol
@@ -0,0 +1,24 @@
+==== Source: base ====
+contract Base {
+	uint x;
+	address a;
+	function f() internal returns (uint) {
+		a = address(this);
+		++x;
+		return 2;
+	}
+}
+==== Source: der ====
+import "base";
+contract Der is Base {
+	function g(uint y) public {
+		require(x < 10); // added to restrict the search space and avoid non-determinsm in Spacer
+		x += f();
+		assert(y > x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (der:173-186): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/imports/import_library_2.sol b/compiler/test/libsolidity/smtCheckerTests/imports/import_library_2.sol
new file mode 100644
index 00000000..a1c3160e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/imports/import_library_2.sol
@@ -0,0 +1,29 @@
+==== Source: Address.sol ====
+pragma solidity ^0.8.0;
+library Address { function s() internal pure {} }
+==== Source: ERC20.sol ====
+pragma solidity ^0.8.0;
+
+import "./Address.sol";
+
+library SafeMath {
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a - b;
+    }
+}
+
+contract ERC20 {
+    using SafeMath for uint256;
+    using Address for address;
+
+    mapping (address => uint256) private _balances;
+
+    function transferFrom(uint256 amount) public view {
+        _balances[msg.sender].sub(amount);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 3944: (ERC20.sol:157-162): CHC: Underflow (resulting value less than 0) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_1.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_1.sol
new file mode 100644
index 00000000..6ecfed79
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_1.sol
@@ -0,0 +1,20 @@
+contract B {
+	uint x;
+	function f() public view {
+		assert(x == 0);
+	}
+}
+
+contract C is B {
+	uint y;
+	function g() public {
+		x = 1;
+		f();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (52-66): CHC: Assertion violation happens here.\nCounterexample:\ny = 0, x = 1\n\nTransaction trace:\nC.constructor()\nState: y = 0, x = 0\nC.g()\n    B.f() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_2.sol
new file mode 100644
index 00000000..85e2677f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_2.sol
@@ -0,0 +1,27 @@
+contract A {
+	uint x;
+	function f() internal view {
+		assert(x == 0);
+	}
+}
+
+contract B is A {
+	uint a;
+	uint b;
+}
+
+contract C is B {
+	uint y;
+	uint z;
+	uint w;
+	function g() public {
+		x = 1;
+		f();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (54-68): CHC: Assertion violation happens here.\nCounterexample:\ny = 0, z = 0, w = 0, a = 0, b = 0, x = 1\n\nTransaction trace:\nC.constructor()\nState: y = 0, z = 0, w = 0, a = 0, b = 0, x = 0\nC.g()\n    A.f() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_3.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_3.sol
new file mode 100644
index 00000000..f1481197
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_3.sol
@@ -0,0 +1,33 @@
+contract A {
+	uint x;
+	function f() internal virtual {
+		v();
+		assert(x == 0); // should fail
+		assert(x == 2); // should hold
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+}
+
+contract B is A {
+	function f() internal virtual override {
+		super.f();
+	}
+}
+
+contract C is B {
+	function g() public {
+		x = 1;
+		f();
+	}
+	function v() internal override {
+		x = 2;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (64-78): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.g()\n    B.f() -- internal call\n        A.f() -- internal call\n            C.v() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_4.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_4.sol
new file mode 100644
index 00000000..04b7ea74
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_4.sol
@@ -0,0 +1,40 @@
+contract A {
+	uint x;
+	function f() internal virtual {
+		v();
+		assert(x == 0); // should fail
+		assert(x == 2); // should hold
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+}
+contract A1 is A {
+	function f() internal virtual override {
+		super.f();
+	}
+}
+contract B is A {
+	function f() internal virtual override {
+		super.f();
+	}
+}
+
+contract C is B, A1 {
+	function g() public {
+		x = 1;
+		f();
+	}
+	function f() internal override(B, A1) {
+		super.f();
+	}
+	function v() internal override {
+		x = 2;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (64-78): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.g()\n    C.f() -- internal call\n        A1.f() -- internal call\n            B.f() -- internal call\n                A.f() -- internal call\n                    C.v() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_5.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_5.sol
new file mode 100644
index 00000000..e386c4b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_5.sol
@@ -0,0 +1,34 @@
+contract A {
+	uint x;
+	function f() internal virtual {
+		v();
+		assert(x == 0); // should hold
+		assert(x == 2); // should fail
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+}
+
+contract B is A {
+	function f() internal virtual override {
+		super.f();
+	}
+}
+
+contract C is B {
+	function g() public {
+		x = 1;
+		f();
+	}
+	function v() internal override {
+		x = 2;
+		super.v();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (97-111): CHC: Assertion violation happens here.\nCounterexample:\nx = 0\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.g()\n    B.f() -- internal call\n        A.f() -- internal call\n            C.v() -- internal call\n                A.v() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_6.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_6.sol
new file mode 100644
index 00000000..2bac9303
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_6.sol
@@ -0,0 +1,36 @@
+contract A {
+	uint x;
+	function f() internal virtual {
+		v();
+		assert(x == 2); // should hold
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+	function g() public virtual {
+		v();
+		assert(x == 2); // should fail
+	}
+}
+
+contract B is A {
+	function f() internal virtual override {
+		super.f();
+	}
+}
+
+contract C is B {
+	function g() public override {
+		x = 1;
+		f();
+	}
+	function v() internal override {
+		x = 2;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (183-197): CHC: Assertion violation happens here.\nCounterexample:\nx = 0\n\nTransaction trace:\nA.constructor()\nState: x = 0\nA.g()\n    A.v() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_7.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_7.sol
new file mode 100644
index 00000000..45cf7fe1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_7.sol
@@ -0,0 +1,27 @@
+contract A {
+	uint x;
+	function f() internal {
+		v();
+		assert(x == 0); // should fail
+		assert(x == 2); // should hold
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+}
+
+contract C is A {
+	function g() public {
+		x = 1;
+		f();
+	}
+	function v() internal override {
+		x = 2;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (56-70): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.g()\n    A.f() -- internal call\n        C.v() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_8.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_8.sol
new file mode 100644
index 00000000..068531b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_8.sol
@@ -0,0 +1,19 @@
+abstract contract A {
+	uint x;
+	function f() public view {
+		assert(x == 2);
+	}
+}
+
+contract C is  A {
+	function g() public {
+		x = 2;
+		f();
+		x = 0;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (61-75): CHC: Assertion violation happens here.\nCounterexample:\nx = 0\n\nTransaction trace:\nC.constructor()\nState: x = 0\nA.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_9.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_9.sol
new file mode 100644
index 00000000..9972c7e3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/base_contract_assertion_fail_9.sol
@@ -0,0 +1,34 @@
+contract A {
+	uint x;
+	function f() public virtual {
+		v();
+		assert(x == 0); // should fail when C is the most derived contract
+		assert(x == 2); // should fail when A is the most derived contract
+	}
+	function v() internal virtual {
+		x = 0;
+	}
+}
+
+contract B is A {
+	function f() public virtual override {
+		super.f();
+	}
+}
+
+contract C is B {
+	function g() public {
+		x = 1;
+		f();
+	}
+	function v() internal override {
+		x = 2;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (62-76): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 0\nB.f()\n    A.f() -- internal call\n        C.v() -- internal call
+// Warning 6328: (131-145): CHC: Assertion violation happens here.\nCounterexample:\nx = 0\n\nTransaction trace:\nA.constructor()\nState: x = 0\nA.f()\n    A.v() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_1.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_1.sol
new file mode 100644
index 00000000..edc345c4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_1.sol
@@ -0,0 +1,37 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+
+	function g() internal returns (uint) {
+		x = 42;
+		return x;
+	}
+}
+
+contract Z is B {
+	constructor(uint z) B(z + f()) {
+	}
+}
+
+contract C is Z(5) {
+	constructor() {
+		assert(x == 6);
+		assert(x > 9); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (292-299): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (367-380): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_2.sol
new file mode 100644
index 00000000..f97b0b7e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_inheritance_specifier_2.sol
@@ -0,0 +1,40 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A(9) {
+	constructor(uint b) {
+		x += b;
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+
+	function g() internal returns (uint) {
+		x = 42;
+		return x;
+	}
+}
+
+contract Z is B {
+	constructor(uint z) B(z + f()) {
+	}
+}
+
+contract C is Z(5) {
+	constructor() {
+		assert(x == 15);
+		assert(x > 90); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (110-116): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (300-307): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (376-390): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_1.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_1.sol
new file mode 100644
index 00000000..16b6db13
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_1.sol
@@ -0,0 +1,36 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b + f()) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor() B(x) Z(x) {
+		assert(x == 1);
+		assert(k == 0);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (105-112): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (351-365): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_2.sol
new file mode 100644
index 00000000..55ee0e77
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_2.sol
@@ -0,0 +1,34 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor() B(f()) Z(f()) {
+		assert(x == 1);
+		assert(k == 2);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (349-363): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_3.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_3.sol
new file mode 100644
index 00000000..ebaffc71
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_3.sol
@@ -0,0 +1,36 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b + f()) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor(uint c) B(c) Z(x) {
+		assert(x == c + 1);
+		assert(k == 0);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (105-112): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (361-375): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_4.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_4.sol
new file mode 100644
index 00000000..35cb038a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_4.sol
@@ -0,0 +1,36 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b + f()) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor(uint c) Z(x) B(c) {
+		assert(x == c + 1);
+		assert(k == 0);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (105-112): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (361-375): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_5.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_5.sol
new file mode 100644
index 00000000..a8d87ce2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_5.sol
@@ -0,0 +1,41 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b + f()) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+
+	function g() internal returns (uint) {
+		x = 42;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor() Z(g()) B(f()) {
+		assert(x == 44);
+		assert(k == 42);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (105-112): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (423-437): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_6.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_6.sol
new file mode 100644
index 00000000..76ba2073
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_6.sol
@@ -0,0 +1,39 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+
+	function g() internal returns (uint) {
+		x = 42;
+		return x;
+	}
+}
+
+abstract contract Z is A {
+	uint k;
+	constructor(uint z) {
+		k = z;
+	}
+}
+
+contract C is Z, B {
+	constructor() Z(g()) B(f()) {
+		assert(x == 1);
+		assert(k == 42);
+		assert(x == k); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (416-430): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_7.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_7.sol
new file mode 100644
index 00000000..d861ac2e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_7.sol
@@ -0,0 +1,36 @@
+contract A {
+	uint public x;
+	constructor(uint a) { x = a; }
+}
+
+contract B is A {
+	constructor(uint b) A(b) {
+	}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+
+	function g() internal returns (uint) {
+		x = 42;
+		return x;
+	}
+}
+
+contract Z is B {
+	constructor() B(f()) {
+	}
+}
+
+contract C is Z {
+	constructor() {
+		assert(x == 1);
+		assert(x > 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (354-367): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_8.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_8.sol
new file mode 100644
index 00000000..5815f9ed
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_8.sol
@@ -0,0 +1,23 @@
+contract A {
+	uint public x;
+	constructor(uint) {}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+contract C is A {
+	constructor() A(f()) {
+		assert(x == 1);
+		assert(x == 0); // should fail
+		assert(x > 2000); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (185-199): CHC: Assertion violation happens here.
+// Warning 6328: (218-234): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_9.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_9.sol
new file mode 100644
index 00000000..bfb7abb9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_base_calls_with_side_effects_9.sol
@@ -0,0 +1,25 @@
+contract A {
+	uint public x = 42;
+	constructor(uint) {}
+
+	function f() internal returns (uint) {
+		x = x + 1;
+		return x;
+	}
+}
+
+contract C is A {
+	constructor() A(f()) {
+		assert(x == 42);
+		assert(x == 0); // should fail
+		assert(x == 1); // should fail
+		assert(x > 2000); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (191-205): CHC: Assertion violation happens here.
+// Warning 6328: (224-238): CHC: Assertion violation happens here.
+// Warning 6328: (257-273): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_mixed_chain_with_params.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_mixed_chain_with_params.sol
new file mode 100644
index 00000000..2d49cd1e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_hierarchy_mixed_chain_with_params.sol
@@ -0,0 +1,32 @@
+contract F {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract E is F {}
+abstract contract D is E {
+	constructor() {
+		a = 3;
+	}
+}
+abstract contract C is D {}
+contract B is C {
+	constructor(uint x) F(x + 1) {
+	}
+}
+
+contract A is B {
+	constructor(uint x) B(x) {
+		assert(a == 3);
+		assert(a == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (215-220): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (296-310): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init.sol
new file mode 100644
index 00000000..db94b516
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint x = 2;
+	constructor () {
+		assert(x == 2);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (64-78): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_asserts.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_asserts.sol
new file mode 100644
index 00000000..03b634ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_asserts.sol
@@ -0,0 +1,40 @@
+contract A {
+	int x;
+	constructor (int a) { x = a;}
+}
+
+contract B is A {
+	int y;
+	constructor(int a) A(-a) {
+		if (a > 0) {
+			y = 2;
+		}
+		else {
+			y = 4;
+		}
+	}
+}
+
+contract C is B {
+	constructor(int a) B(a) {
+		assert(y != 3); // should hold
+		assert(y == 4); // should fail
+		if (a > 0) {
+			assert(x < 0 && y == 2); // should hold
+			assert(x < 0 && y == 4); // should fail
+		}
+		else {
+			assert(x >= 0 && y == 4); // should hold
+			assert(x >= 0 && y == 2); // should fail
+			assert(x > 0); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (247-261): CHC: Assertion violation happens here.
+// Warning 6328: (339-362): CHC: Assertion violation happens here.
+// Warning 6328: (439-463): CHC: Assertion violation happens here.
+// Warning 6328: (483-496): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_base.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_base.sol
new file mode 100644
index 00000000..0ebbed1d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_base.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint x = 2;
+}
+
+contract D is C {
+	constructor() {
+		assert(x == 2);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (84-98): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain.sol
new file mode 100644
index 00000000..f9382fb6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain.sol
@@ -0,0 +1,23 @@
+contract A {
+	uint x = 1;
+}
+
+contract B is A {
+	constructor() { x = 2; }
+}
+
+contract C is B {
+	constructor() { x = 3; }
+}
+
+contract D is C {
+	constructor() {
+		assert(x == 3);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (178-192): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_alternate.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_alternate.sol
new file mode 100644
index 00000000..e3be37f2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_alternate.sol
@@ -0,0 +1,22 @@
+contract A {
+	uint x = 1;
+}
+
+contract B is A {
+	constructor() { x = 2; }
+}
+
+contract C is B {
+}
+
+contract D is C {
+	constructor() {
+		assert(x == 2);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (152-166): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all.sol
new file mode 100644
index 00000000..09833f14
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all.sol
@@ -0,0 +1,29 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B is C {
+	uint b;
+	constructor(uint x) {
+		b = a + x;
+	}
+}
+
+contract A is B {
+	constructor(uint x) B(x) C(x + 2) {
+		assert(a == x + 2);
+		assert(b == x + x + 2);
+		assert(a == x + 5);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (125-130): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (184-189): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (243-261): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all_2.sol
new file mode 100644
index 00000000..035a901b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_run_all_2.sol
@@ -0,0 +1,29 @@
+contract C {
+	uint a;
+	constructor(uint x) {
+		a = x;
+	}
+}
+
+abstract contract B is C {
+	uint b;
+	constructor(uint x) {
+		b = x + 10;
+	}
+}
+
+contract A is B {
+	constructor(uint x) B(x) C(x + 2) {
+		assert(a == x + 2);
+		assert(b == x + 10);
+		assert(b == x + 5);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (125-131): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (185-190): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6328: (241-259): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_tree.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_tree.sol
new file mode 100644
index 00000000..e98ddcb6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_chain_tree.sol
@@ -0,0 +1,44 @@
+contract A {
+	int x;
+	constructor (int a) { x = a; }
+}
+
+contract Z {
+	int z;
+	constructor(int _z) {
+		z = _z;
+	}
+}
+
+contract B is A, Z {
+	constructor(int b) A(b) Z(x) {
+		assert(x == b);
+		assert(z == 0);
+	}
+}
+
+contract F is Z, A {
+	constructor(int b) Z(x) A(b) {
+		assert(x == b);
+		assert(z == 0);
+	}
+}
+
+contract C is B {
+	constructor(int c) B(-c) {
+		if (x > 0) {
+			assert(c < 0); // should hold
+			assert(c >= 0); // should fail
+		}
+		else {
+			assert(c < 0); // should fail
+			assert(c >= 0); // should hold
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (403-417): CHC: Assertion violation happens here.
+// Warning 6328: (450-463): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond.sol
new file mode 100644
index 00000000..ed61c1c2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond.sol
@@ -0,0 +1,21 @@
+contract A {
+	uint x = 2;
+}
+
+contract B is A {
+}
+
+contract C is A {
+}
+
+contract D is B, C {
+	constructor() {
+		assert(x == 2);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (129-143): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond_middle.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond_middle.sol
new file mode 100644
index 00000000..8590b0bc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_diamond_middle.sol
@@ -0,0 +1,30 @@
+contract A {
+	uint x = 1;
+}
+
+contract B is A {
+	constructor() {
+		assert(x == 1);
+		x = 2;
+	}
+}
+
+contract C is A {
+	constructor() {
+		assert(x == 1);
+		x = 3;
+	}
+}
+
+contract D is B, C {
+	constructor() {
+		assert(x == 3);
+		assert(x == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (134-148): CHC: Assertion violation happens here.
+// Warning 6328: (223-237): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_function_call.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_function_call.sol
new file mode 100644
index 00000000..031f5a1c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_state_variable_init_function_call.sol
@@ -0,0 +1,16 @@
+contract C {
+	uint x = f(2);
+	constructor () {
+		assert(x == 2);
+	}
+
+	function f(uint y) internal view returns (uint) {
+		assert(y > 0);
+		assert(x == 0);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_uses_function_base.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_uses_function_base.sol
new file mode 100644
index 00000000..1c0defa9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/constructor_uses_function_base.sol
@@ -0,0 +1,21 @@
+contract A {
+	uint x;
+	constructor() {
+		x = 42;
+	}
+	function f() public view returns(uint256) {
+		return x;
+	}
+}
+contract B is A {
+	uint y = f();
+}
+contract C is B {
+	function g() public view {
+		assert(y == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_1.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_1.sol
new file mode 100644
index 00000000..546f934b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_1.sol
@@ -0,0 +1,34 @@
+contract A {
+	function f() public virtual returns (uint256 r) {
+		return 1;
+	}
+}
+
+
+contract B is A {
+	function f() public virtual override returns (uint256 r) {
+		return super.f() + 2;
+	}
+}
+
+
+contract C is A {
+	function f() public virtual override returns (uint256 r) {
+		return super.f() + 4;
+	}
+}
+
+
+contract D is B, C {
+	function f() public override(B, C) returns (uint256 r) {
+		r = super.f() + 8;
+		assert(r == 15); // should hold
+		assert(r == 13); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (437-452): CHC: Assertion violation happens here.\nCounterexample:\n\nr = 15\n\nTransaction trace:\nD.constructor()\nD.f()\n    C.f() -- internal call\n        B.f() -- internal call\n            A.f() -- internal call
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_2.sol
new file mode 100644
index 00000000..1825098a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_2.sol
@@ -0,0 +1,36 @@
+contract A {
+	function f() public virtual returns (uint256 r) {
+		return 1;
+	}
+}
+
+
+contract B is A {
+	function f() public virtual override returns (uint256 r) {
+		return super.f() + 2;
+	}
+}
+
+
+contract C is A {
+	function f() public virtual override returns (uint256 r) {
+		return 2 * (super.f() + 4);
+	}
+}
+
+
+contract D is B, C {
+	function f() public override(B, C) returns (uint256 r) {
+		r = super.f() + 8;
+		assert(r == 22); // should hold
+		assert(r == 20); // should fail
+		assert(r == 18); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (443-458): CHC: Assertion violation happens here.\nCounterexample:\n\nr = 22\n\nTransaction trace:\nD.constructor()\nD.f()\n    C.f() -- internal call\n        B.f() -- internal call\n            A.f() -- internal call
+// Warning 6328: (477-492): CHC: Assertion violation happens here.\nCounterexample:\n\nr = 22\n\nTransaction trace:\nD.constructor()\nD.f()\n    C.f() -- internal call\n        B.f() -- internal call\n            A.f() -- internal call
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_3.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_3.sol
new file mode 100644
index 00000000..f6674021
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/diamond_super_3.sol
@@ -0,0 +1,37 @@
+contract A {
+	int public x;
+	function f() public virtual {
+		x = 1;
+	}
+}
+
+contract B is A {
+	function f() public virtual override {
+		super.f();
+		x += 100;
+	}
+}
+
+contract C is B {
+	function f() public virtual override {
+		super.f();
+		x += 10;
+	}
+}
+
+contract D is B {
+}
+
+contract E is C,D {
+	function f() public override(C,B) {
+		super.f();
+		assert(x == 111); // should hold
+		assert(x == 13); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (379-394): CHC: Assertion violation happens here.\nCounterexample:\nx = 111\n\nTransaction trace:\nE.constructor()\nState: x = 0\nE.f()\n    C.f() -- internal call\n        B.f() -- internal call\n            A.f() -- internal call
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_constructor_hierarchy.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_constructor_hierarchy.sol
new file mode 100644
index 00000000..f43195d6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_constructor_hierarchy.sol
@@ -0,0 +1,20 @@
+contract A {
+	uint x;
+	constructor (uint y) { assert(x == 0); x = y; }
+}
+
+contract B is A {
+	constructor () A(2) { assert(x == 2); }
+}
+
+contract C is B {
+	function f() public view {
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_only_constructor_hierarchy.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_only_constructor_hierarchy.sol
new file mode 100644
index 00000000..799bba43
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/implicit_only_constructor_hierarchy.sol
@@ -0,0 +1,23 @@
+contract A {
+	uint x;
+	function h() public view {
+		assert(x == 0);
+	}
+}
+
+contract B is A {
+	function g() public view {
+		assert(x == 0);
+	}
+}
+
+contract C is B {
+	function f() public view {
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/overriden_function_static_call_parent.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/overriden_function_static_call_parent.sol
new file mode 100644
index 00000000..b339e5a1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/overriden_function_static_call_parent.sol
@@ -0,0 +1,24 @@
+contract BaseBase {
+	uint x;
+	function init(uint a, uint b) public virtual {
+		x = a;
+	}
+}
+contract Base is BaseBase {
+	function init(uint a, uint b) public override {
+	}
+}
+contract Child is Base {
+	function bInit(uint c, uint d) public {
+		BaseBase.init(c, d);
+		assert(x == c);
+		assert(x == d); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 5667: (52-58): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (282-296): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables.sol
new file mode 100644
index 00000000..0b927967
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables.sol
@@ -0,0 +1,18 @@
+contract Base {
+	uint x;
+	uint z;
+	uint private t;
+}
+
+contract C is Base {
+	function f(uint y) public {
+		require(x < 10);
+		require(y < 100);
+		z = x + y;
+		assert(z < 150);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_2.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_2.sol
new file mode 100644
index 00000000..fd1fbcca
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_2.sol
@@ -0,0 +1,20 @@
+contract Base1 {
+	uint x;
+}
+
+contract Base2 is Base1 {
+	uint z;
+}
+
+contract C is Base2 {
+	function f(uint y) public {
+		require(x < 10);
+		require(y < 100);
+		z = x + y;
+		assert(z < 150);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_3.sol b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_3.sol
new file mode 100644
index 00000000..03a1e797
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inheritance/state_variables_3.sol
@@ -0,0 +1,19 @@
+contract Base {
+	uint x;
+	uint private t;
+}
+
+contract C is Base {
+
+	uint private z;
+	function f(uint y) public {
+		require(x < 10);
+		require(y < 100);
+		z = x + y;
+		assert(z < 150);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_2.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_2.sol
new file mode 100644
index 00000000..ad18cb32
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_2.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure returns (bool) {
+		bool b;
+		int x = 42;
+		assembly { b := 1 }
+		assert(x == 42); // should hold
+		assert(b); // should hold, but fails due to overapproximation
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7737: (82-101): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Warning 6328: (138-147): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_3.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_3.sol
new file mode 100644
index 00000000..73cdcd4d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_3.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public pure returns (bool) {
+        bool b;
+        bool c = true;
+        assembly { b := c }
+        assert(c); // should hold, c is not assigned in the assembly
+        assert(b); // should hold, but fails currently because of overapproximation
+        return b;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7737: (106-125): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Warning 6328: (203-212): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_4.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_4.sol
new file mode 100644
index 00000000..59db8c8c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_4.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure returns (bool) {
+		bool b;
+		int x = 42;
+		assembly { b := 1 }
+		b = true;
+		assert(x == 42); // should hold
+		assert(b); // should hold
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7737: (82-101): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_5.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_5.sol
new file mode 100644
index 00000000..b81ae766
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_5.sol
@@ -0,0 +1,26 @@
+contract C {
+	struct S {
+		uint x;
+	}
+
+	S s;
+
+	function f() public {
+		s.x = 42;
+		S memory sm = s;
+		assert(sm.x == 42); // should hold
+		uint256 i = 7;
+		assembly {
+			mstore(sm, i)
+		}
+		sm.x = 10;
+		assert(sm.x == 10); // should hold
+		assert(s.x == 42); // should hold, storage not changed by the assembly
+		assert(i == 7); // should hold, not changed by the assembly
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7737: (156-187): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_6.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_6.sol
new file mode 100644
index 00000000..21a32c0f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_6.sol
@@ -0,0 +1,25 @@
+contract C {
+	struct S {
+		uint x;
+	}
+
+	S s;
+
+	function f() public {
+		s.x = 42;
+		S storage sm = s;
+		assert(sm.x == 42); // should hold
+		uint256 i = 7;
+		assembly {
+			sstore(sm.slot, i)
+		}
+		sm.x = 10;
+		assert(sm.x == 10); // should hold
+		assert(i == 7); // should hold, not changed by the assembly
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 7737: (157-193): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_access_inside_function.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_access_inside_function.sol
new file mode 100644
index 00000000..b8df9f3e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_access_inside_function.sol
@@ -0,0 +1,25 @@
+contract C {
+	uint256 public z;
+
+	function f() public {
+		z = 42;
+		uint i = 32;
+		assembly {
+			function f() {
+				sstore(z.slot, 7)
+			}
+			f()
+		}
+		assert(z == 42); // should fail
+		assert(z == 7); // should hold, but the analysis cannot know this yet
+		assert(i == 32); // should hold, not changed by the assembly
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 7737: (83-149): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Warning 6328: (152-167): CHC: Assertion violation happens here.
+// Warning 6328: (186-200): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_pointer.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_pointer.sol
new file mode 100644
index 00000000..390ce10a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_local_storage_pointer.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint256[] public a;
+
+	function f() public {
+		require(a.length == 0);
+		uint256[] storage x = a;
+		assert(x.length == 0); // should hold
+		uint256 i = 7;
+		assembly {
+			sstore(x.slot, 7)
+		}
+		assert(x.length == 0); // should fail
+		assert(x.length == 7); // should hold, but the analysis cannot know this yet
+		assert(i == 7); // should hold, not changed by the assembly
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 7737: (170-205): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Warning 6328: (208-229): CHC: Assertion violation happens here.
+// Warning 6328: (248-269): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_memory_write.sol b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_memory_write.sol
new file mode 100644
index 00000000..7eb44139
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/inline_assembly/assembly_memory_write.sol
@@ -0,0 +1,29 @@
+contract C {
+	struct S {
+		uint x;
+	}
+
+	S s;
+
+	function f() public {
+		s.x = 42;
+		S memory sm = s;
+		assert(sm.x == 42); // should hold
+		uint256 i = 7;
+		assembly {
+			mstore(sm, i)
+		}
+		assert(sm.x == 42); // should fail
+		assert(sm.x == 7); // should hold, but the analysis cannot know this yet
+		assert(s.x == 42); // should hold, storage not changed by the assembly
+		assert(i == 7); // should hold, not changed by the assembly
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 7737: (156-187): Inline assembly may cause SMTChecker to produce spurious warnings (false positives).
+// Warning 6328: (190-208): CHC: Assertion violation happens here.
+// Warning 6328: (227-244): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic.sol b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic.sol
new file mode 100644
index 00000000..f43b61f8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic.sol
@@ -0,0 +1,14 @@
+contract Simple {
+	function f(uint x) public pure {
+		uint y;
+		require(x > 0);
+		while (y < x)
+			++y;
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic_for.sol b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic_for.sol
new file mode 100644
index 00000000..dcc731bf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_basic_for.sol
@@ -0,0 +1,12 @@
+contract Simple {
+	function f(uint x) public pure {
+		uint y;
+		for (y = 0; y < x; ++y) {}
+		assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested.sol b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested.sol
new file mode 100644
index 00000000..d14c2a2a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested.sol
@@ -0,0 +1,20 @@
+contract Simple {
+	function f() public pure {
+		uint x = 10;
+		uint y;
+		while (y < x)
+		{
+			++y;
+			x = 0;
+			while (x < 10)
+				++x;
+			assert(x == 10);
+		}
+		// Removed because of Spacer nondeterminism.
+		//assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested_for.sol b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested_for.sol
new file mode 100644
index 00000000..55f5b617
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/invariants/loop_nested_for.sol
@@ -0,0 +1,17 @@
+contract Simple {
+	function f() public pure {
+		uint x;
+		uint y;
+		for (x = 10; y < x; ++y)
+		{
+			for (x = 0; x < 10; ++x) {}
+			assert(x == 10);
+		}
+		// Disabled because of Spacer nondeterminism.
+		//assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/invariants/state_machine_1.sol b/compiler/test/libsolidity/smtCheckerTests/invariants/state_machine_1.sol
new file mode 100644
index 00000000..fd0610ea
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/invariants/state_machine_1.sol
@@ -0,0 +1,36 @@
+contract C {
+	uint x;
+
+	function f() public {
+		if (x == 0)
+			x = 1;
+	}
+
+	function g() public {
+		if (x == 1)
+			x = 2;
+	}
+
+	function h() public {
+		if (x == 2)
+			x = 0;
+	}
+
+	// This function shows that (x < 9) is not inductive and
+	// a stronger invariant is needed to be found.
+	// (x < 3) is the one found in the end.
+	function j() public {
+		if (x == 7)
+			x = 100;
+	}
+
+	function i() public view {
+		assert(x < 9);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1.sol
new file mode 100644
index 00000000..f49fb588
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		do {
+			x = x + 1;
+		} while (x < 1000);
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1_fail.sol
new file mode 100644
index 00000000..6ebaa267
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_1_fail.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		do {
+			x = x + 1;
+		} while (x < 10);
+		assert(x < 14);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 6328: (110-124): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_1.sol
new file mode 100644
index 00000000..bff046b0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_1.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		do {
+			++x;
+		} while (x < 2);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_2.sol
new file mode 100644
index 00000000..92cbc1be
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_2.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			{
+				++x;
+				++x;
+			}
+		} while (x < 3);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_3.sol
new file mode 100644
index 00000000..d4a37786
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_3.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		do {
+			if (x >= 2)
+				++x;
+			++x;
+		} while (x < 3);
+		assert(x == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_4.sol
new file mode 100644
index 00000000..cce896b7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_4.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+		} while (true);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_5.sol
new file mode 100644
index 00000000..6f25a4f5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_5.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint x;
+
+    function condition() private returns(bool) {
+		++x;
+		return x < 3;
+	}
+
+	function f() public {
+		require(x == 0);
+		do {
+		} while (condition());
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (77-80): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_6.sol
new file mode 100644
index 00000000..8f7c82ad
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_6.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint x;
+	uint y;
+
+	function condition() private returns(bool) {
+		x = (x + 1) % 2;
+		return (x == 1);
+	}
+
+	function f() public {
+		require(x == 0);
+		require(y == 0);
+		do {
+			++y;
+		} while (condition());
+		assert(y == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (85-90): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_7.sol
new file mode 100644
index 00000000..81d94e1b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_7.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint256[] y;
+
+	function f() public view {
+		uint256 x = 0;
+		do {
+			++x;
+		} while (x < y.length);
+		require(x != 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Warning 6838: (124-130): BMC: Condition is always true.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_1.sol
new file mode 100644
index 00000000..54ede91c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_1.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		do {
+			++x;
+		} while (x < 2);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (102-116): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_2.sol
new file mode 100644
index 00000000..8c742b74
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_2.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			break;
+		} while (x < 3);
+		assert(x == 0);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Warning 5740: (87-92): Unreachable code.
+// Warning 4661: (97-111): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_3.sol
new file mode 100644
index 00000000..0742c5cd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_assertion_fails_3.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			continue;
+		} while (x < 2);
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Warning 4661: (100-114): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_1.sol
new file mode 100644
index 00000000..e7bb9d14
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_1.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			break;
+		} while (x < 3);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 5740: (87-92): Unreachable code.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_2.sol
new file mode 100644
index 00000000..9dec6054
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		do {
+			if (x > 0)
+				break;
+			++x;
+		} while (x < 3);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_3.sol
new file mode 100644
index 00000000..0f1c7d03
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_3.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		do {
+			if (x >= 0) {
+				++x;
+				break;
+			}
+			++x;
+		} while (x < 3);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_4.sol
new file mode 100644
index 00000000..c2c04680
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_4.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		do {
+			if (x > 0) {
+				++x;
+				break;
+			}
+			++x;
+		} while (x < 3);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_5.sol
new file mode 100644
index 00000000..4379d4f6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_5.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		do {
+			++x;
+			if (x > 1) {
+				++x;
+				break;
+			}
+		} while (x < 3);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_6.sol
new file mode 100644
index 00000000..d0a917fa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_6.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			if (x > 0) {
+ 				x = 2;
+				break;
+			}
+			if (x > 1) {
+				x = 3;
+				break;
+			}
+		} while (x < 3);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_7.sol
new file mode 100644
index 00000000..52c3270b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_7.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			++x;
+			if (x > 1) {
+				x = 3;
+				break;
+ 			}
+			if (x > 0) {
+				x = 2;
+				break;
+ 			}
+		} while (x < 3);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_8.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_8.sol
new file mode 100644
index 00000000..c25f9821
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_8.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			break;
+		} while (++x < 2);
+        // loop condition is not executed after break
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 5740: (79-86): Unreachable code.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_1.sol
new file mode 100644
index 00000000..53ce958f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_1.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			if (x > 1) {
+				break;
+ 			}
+			if (x >= 0) {
+				x = 10;
+				continue;
+ 			}
+		} while (x < 3);
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_2.sol
new file mode 100644
index 00000000..12d6fff6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_break_continue_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			if (x > 1) {
+				x = 3;
+				break;
+ 			}
+			if (x >= 0) {
+				x = 2;
+				continue;
+ 			}
+		} while (x < 4);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_1.sol
new file mode 100644
index 00000000..aa69cb90
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_1.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		do {
+			++x;
+			if (x == 3) {
+				continue;
+			}
+			++x;
+		} while (x < 3);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_2.sol
new file mode 100644
index 00000000..83826575
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_2.sol
@@ -0,0 +1,25 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		uint y = 0;
+		do {
+			++x;
+			if (x == 2) {
+				++x;
+				y = 1;
+				continue;
+			}
+			if (x == 3) {
+				y = 2;
+				continue;
+			}
+		} while (x < 3);
+		assert(y == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_3.sol
new file mode 100644
index 00000000..1afe9034
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_3.sol
@@ -0,0 +1,24 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		uint y = 0;
+		do {
+			++x;
+			if (x > 0) {
+				y = 1;
+				continue;
+			}
+			if (x > 0) {
+				y = 2;
+				continue;
+			}
+		} while (x < 3);
+		assert(y == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_4.sol
new file mode 100644
index 00000000..69ad6529
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_continue_4.sol
@@ -0,0 +1,25 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		uint i;
+		do {
+			++i;
+			if (i == 2) {
+				x = 2;
+				continue;
+			}
+			if (i == 1) {
+				x = 1;
+				continue;
+			}
+		} while (i < 3);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested.sol
new file mode 100644
index 00000000..62d1b793
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	function f(uint z) public pure {
+		uint x = 0;
+		require(z == 0);
+		do {
+			uint y = 0;
+			do {
+				++z;
+				++y;
+			} while (y < 2);
+			++x;
+		} while (x < 2);
+		assert(z == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_break.sol
new file mode 100644
index 00000000..267e18ec
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_break.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	function f(uint z) public pure {
+		uint x = 0;
+		require(z == 0);
+		do {
+			uint y = 0;
+			do {
+				if (y > 0)
+					break;
+				++z;
+				++y;
+			} while (y < 2);
+			++x;
+		} while (x < 2);
+		assert(z == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_continue.sol
new file mode 100644
index 00000000..42ef9bcc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_nested_continue.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	function f(uint z) public pure {
+		uint x = 0;
+		require(z == 0);
+		do {
+			uint y = 0;
+			do {
+				++y;
+				if (y > 0)
+					continue;
+				++z;
+			} while (y < 2);
+			++x;
+		} while (x < 2);
+		assert(z == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_1.sol
new file mode 100644
index 00000000..4d1112ac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_1.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		do {
+			if (x >= 3)
+				y = 1;
+			++x;
+		} while (x < 3 || y == 1);
+		// BMC loop iteration setting is not enough to leave the loop
+		assert(x == 0); // should hold - no assumptions on value if didn't complete loop
+		assert(y == 0); // should hold - no assumptions on value if didn't complete loop
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_2.sol
new file mode 100644
index 00000000..9db49261
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		do {
+			if (x >= 3)
+				y = 1;
+			++x;
+		} while (x < 3 || y == 1);
+		// BMC loop iteration setting is just enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail, when x == 3 loop is completed
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 4661: (223-237): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_3.sol
new file mode 100644
index 00000000..e5e03d3d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_3.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		do {
+			if (x >= 3)
+				y = 1;
+			++x;
+		} while (x < 3 || y == 1);
+		// BMC loop iteration setting is more than enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 4661: (228-242): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_4.sol
new file mode 100644
index 00000000..04d19704
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_semantics_4.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		do {
+			++x;
+			if (x >= 3)
+				y = 1;
+		} while (x < 3 || y == 1);
+		// BMC loop iteration setting is more than enough to leave the loop
+		assert(x == 3); // should hold
+		assert(y == 1); // should hold
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_shallow_unroll.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_shallow_unroll.sol
new file mode 100644
index 00000000..449d41c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_bmc_iterations_shallow_unroll.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f(uint x) public pure {
+		require(x == 0);
+		uint y;
+		do {
+			++y;
+			if (y == 2)
+			    x = 3;
+		} while (y < 3);
+		// nothing is reported because loop condition is true after unrolling the loop one time
+		assert(x == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break.sol
new file mode 100644
index 00000000..7d779c47
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			break;
+			x = 1;
+		} while (x == 0);
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5740: (71-76): Unreachable code.
+// Warning 5740: (89-95): Unreachable code.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break_2.sol
new file mode 100644
index 00000000..c7710320
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_break_2.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f() public pure {
+		uint a = 0;
+		while (true) {
+			do {
+				break;
+				a = 2;
+			} while (true);
+			a = 1;
+			break;
+		}
+		assert(a == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5740: (95-100): Unreachable code.
+// Warning 5740: (114-118): Unreachable code.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/do_while_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_continue.sol
new file mode 100644
index 00000000..5564b6a5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/do_while_continue.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure {
+		uint x;
+		do {
+			continue;
+			x = 1;
+		} while (x == 0);
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5740: (74-79): Unreachable code.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break.sol
new file mode 100644
index 00000000..31b92ef0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		for (; x < 10; ) {
+			if (b)
+				++x;
+			else {
+				x = 20;
+				break;
+			}
+		}
+		assert(x >= 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break_fail.sol
new file mode 100644
index 00000000..271d220f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_break_fail.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		for (; x < 10; ) {
+			if (b)
+				++x;
+			else {
+				break;
+			}
+		}
+		// Fails because the loop might break.
+		assert(x >= 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 6328: (168-183): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue.sol
new file mode 100644
index 00000000..66193a31
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		for (; x < 10; ++x) {
+			if (b) {
+				x = 20;
+				continue;
+			}
+		}
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue_fail.sol
new file mode 100644
index 00000000..d35e727c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_continue_fail.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		for (; x < 10; ) {
+			++x;
+		}
+		assert(x > 15);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5667: (33-39): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (109-123): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_1_false_positive.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_false_positive.sol
new file mode 100644
index 00000000..0b4ac7e6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_1_false_positive.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		for(uint i = 0; i < 5; ++i) {
+			x = x + 1;
+		}
+		// Disabled because of non-determinism in Spacer in Z3 4.8.9, check with next solver release.
+		//assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (106-111): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_break_direct.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_break_direct.sol
new file mode 100644
index 00000000..a25f0fcc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_break_direct.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function f(uint x) public pure {
+		for (x = 0; x < 10; ++x)
+			break;
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5740: (69-72): Unreachable code.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_1.sol
new file mode 100644
index 00000000..155aa45b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_1.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint x) public pure {
+        require(x == 2);
+        for (;;) {}
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_2.sol
new file mode 100644
index 00000000..212feb82
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_2.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint x) public pure {
+        for (; x == 2; ) {
+            assert(x == 2);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_3.sol
new file mode 100644
index 00000000..ae6392bd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_3.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint x) public pure {
+        for (uint y = 2; x < 10; ) {
+            assert(y == 2);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_6.sol
new file mode 100644
index 00000000..976d2540
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_6.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint x) public pure {
+        uint y;
+        for (y = 2; x < 10; ) {
+            y = 3;
+        }
+        // False positive due to resetting y.
+        assert(y < 4);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_memory.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_memory.sol
new file mode 100644
index 00000000..953a6d50
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_memory.sol
@@ -0,0 +1,27 @@
+contract LoopFor2 {
+	function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public pure {
+		require(n < b.length);
+		require(n < c.length);
+		require(n > 0 && n < 100);
+		b[0] = 900;
+		uint[] memory a = b;
+		for (uint i = 0; i < n; i += 1) {
+			// Accesses are safe but oob is reported due to potential aliasing after c's assignment.
+			// Disabled because of Spacer nondeterminism.
+			//b[i] = i + 1;
+			//c[i] = b[i];
+		}
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == c[0]);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(a[0] == 900);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2072: (202-217): Unused local variable.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_storage.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_storage.sol
new file mode 100644
index 00000000..53a6142a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_memory_storage.sol
@@ -0,0 +1,30 @@
+contract LoopFor2 {
+	uint[] a;
+	function p() public {
+		a.push();
+	}
+	function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public {
+		require(n < a.length);
+		require(n < b.length);
+		require(n < c.length);
+		require(n > 0 && n < 100);
+		b[0] = 900;
+		a = b;
+		for (uint i = 0; i < n; i += 1) {
+			// Accesses are safe but oob is reported due to potential aliasing after c's assignment.
+			b[i] = i + 1;
+			// Disabled because of Spacer's nondeterminism.
+			//c[i] = b[i];
+		}
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == c[0]);
+		//assert(a[0] == 900);
+		//assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_storage_memory.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_storage_memory.sol
new file mode 100644
index 00000000..d52cc2c9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_array_assignment_storage_memory.sol
@@ -0,0 +1,26 @@
+// Most of the code has been commented out because of nondeterminism in Spacer in Z3 4.8.9
+contract LoopFor2 {
+	uint[] b;
+	//uint[] c;
+	function p() public {
+		b.push();
+	}
+	function testUnboundedForLoop(uint n) public {
+		require(b.length > 0);
+		b[0] = 900;
+		//uint[] memory a = b;
+		require(n > 0 && n < 100);
+		for (uint i = 0; i < n; i += 1) {
+			//b[i] = i + 1;
+			//c[i] = b[i];
+		}
+		// This is safe but too hard to solve currently.
+		//assert(b[0] == c[0]);
+		//assert(a[0] == 900);
+		//assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_1.sol
new file mode 100644
index 00000000..a352b6e3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_1.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i)
+			++x;
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_10.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_10.sol
new file mode 100644
index 00000000..5c91d2ce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_10.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint256[] y;
+
+	function f() public view {
+		uint256 x = 0;
+		for (uint i = 0; i < y.length; i++) {
+			x = 1;
+		}
+		// tests that constant condition warning is not reported
+		require(x != 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_2.sol
new file mode 100644
index 00000000..d460ea77
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_2.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i)
+			x = i;
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_3.sol
new file mode 100644
index 00000000..63b43466
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_3.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i)
+			if (i > 1)
+				x = 10;
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+//  Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_4.sol
new file mode 100644
index 00000000..e3fea509
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_4.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 0; ++i)
+			++x;
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_5.sol
new file mode 100644
index 00000000..38437fce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_5.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (; x < 0; ++x) {}
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_6.sol
new file mode 100644
index 00000000..cdbc4148
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_6.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		for (uint i = 1; i < 3;) {
+			x = i;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_7.sol
new file mode 100644
index 00000000..834529b3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_7.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	uint x;
+
+	function condition() private returns(bool) {
+		++x;
+		return x < 3;
+	}
+
+	function f() public {
+		require(x == 0);
+		for (; condition();) {
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (71-74): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_8.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_8.sol
new file mode 100644
index 00000000..421c965e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_8.sol
@@ -0,0 +1,31 @@
+contract C
+{
+	uint x;
+	uint y;
+
+	function condition() private returns(bool) {
+		++x;
+		return x < 3;
+	}
+
+	function expression() private {
+		++y;
+	}
+
+	function f() public {
+		require(x == 0);
+		require(y == 0);
+		for (; condition(); expression()) {
+		}
+		assert(x == 3);
+		assert(y == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (80-83): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 2661: (140-143): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_9.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_9.sol
new file mode 100644
index 00000000..a4601068
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_9.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint x;
+	uint y;
+
+	function condition() private returns(bool) {
+		x = (x + 1) % 2;
+		return (x == 1);
+	}
+
+	function f() public {
+		require(x == 0);
+		require(y == 0);
+		for (; condition();) {
+			++y;
+		}
+		assert(y == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (85-90): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_1.sol
new file mode 100644
index 00000000..67290785
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_1.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i)
+			++x;
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (92-106): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_2.sol
new file mode 100644
index 00000000..cd1ae918
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_2.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i) {
+			++x;
+			break;
+		}
+		assert(x == 0);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 5740: (77-80): Unreachable code.
+// Warning 4661: (108-122): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_3.sol
new file mode 100644
index 00000000..8e1cb97b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_assertion_fails_3.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i) {
+			++x;
+			continue;
+		}
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (111-125): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_1.sol
new file mode 100644
index 00000000..26958bf1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_1.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			break;
+			++x;
+		}
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 5740: (77-80): Unreachable code.
+// Warning 5740: (97-100): Unreachable code.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_2.sol
new file mode 100644
index 00000000..cada2d85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_2.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			++x;
+ 			break;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 5740: (77-80): Unreachable code.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_3.sol
new file mode 100644
index 00000000..eb947d55
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_3.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 0)
+				break;
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_4.sol
new file mode 100644
index 00000000..3d4855ab
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_4.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			++x;
+			if (i > 0)
+				break;
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_5.sol
new file mode 100644
index 00000000..f2125550
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_5.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 1) {
+				x = 1;
+				break;
+			}
+			if (i > 1) {
+				x = 2;
+				break;
+			}
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_6.sol
new file mode 100644
index 00000000..401491e9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_6.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 1) {
+				x = 1;
+				break;
+			}
+			if (i >= 1) {
+				x = 2;
+				break;
+			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_7.sol
new file mode 100644
index 00000000..4bb4ffdf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_7.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (;;) {
+			++x;
+			break;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_8.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_8.sol
new file mode 100644
index 00000000..a88a031e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_8.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (;;) {
+ 			break;
+			++x;
+		}
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 5740: (78-81): Unreachable code.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_9.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_9.sol
new file mode 100644
index 00000000..4ce3d926
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_9.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (;x < 2;) {
+			++x;
+ 			break;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_1.sol
new file mode 100644
index 00000000..b999f9cf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_1.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 1) {
+				break;
+ 			}
+			if (i >= 0) {
+				x = 10;
+				continue;
+ 			}
+		}
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_2.sol
new file mode 100644
index 00000000..0da0f5d9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_2.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i) {
+			if (i > 0) {
+				x = 1;
+				break;
+ 			}
+			if (i >= 0) {
+				x = 2;
+				continue;
+			}
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_3.sol
new file mode 100644
index 00000000..9f762bb4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_break_continue_3.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 0) {
+				x = 1;
+				break;
+ 			} else {
+				x = 2;
+				continue;
+			}
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_1.sol
new file mode 100644
index 00000000..44983ecd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_1.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		for (uint i = 0; i < 3; ++i) {
+			if (i > 1)
+				continue;
+			++x;
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_2.sol
new file mode 100644
index 00000000..2c7fc123
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_2.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i) {
+			if (i == 1) {
+				x = 1;
+				continue;
+			}
+			if (i == 0) {
+				x = 2;
+				continue;
+			}
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_3.sol
new file mode 100644
index 00000000..b74709e4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_3.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		for (uint i = 0; i < 3; ++i) {
+			if (x > 1) {
+				x = 10;
+				continue;
+			}
+ 			if (x > 0) {
+				x = 11;
+				continue;
+			}
+			++x;
+		}
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_4.sol
new file mode 100644
index 00000000..246aa74c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_4.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (; x < 2; ++x) {
+			if (x > 1) {
+				x = 10;
+				continue;
+			}
+			if (x > 0) {
+				x = 11;
+				continue;
+			}
+		}
+		// x > 0 branch triggers x = 11 and continue triggers ++x loop expression
+		assert(x == 12);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_5.sol
new file mode 100644
index 00000000..270d8d4d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_continue_5.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (; x < 2; ++x) {
+			continue;
+		}
+		// loop expression is executed after continue
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_false_positive.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_false_positive.sol
new file mode 100644
index 00000000..20071a64
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_false_positive.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		for (;;) {
+			x = 1;
+		}
+		assert(x == 1000);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested.sol
new file mode 100644
index 00000000..d63e2ca5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f() public pure {
+		uint x;
+		for (uint i = 0; i < 2; ++i) {
+			for (uint j = 0; j < 2; ++j)
+				++x;
+		}
+		assert(x == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_break.sol
new file mode 100644
index 00000000..c302deca
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_break.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		for (uint i = 0; i < 2; ++i) {
+			for (uint j = 0; j < 2; ++j) {
+				x = x + 1;
+				break;
+			}
+			break;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 5740: (92-95): Unreachable code.
+// Warning 5740: (126-129): Unreachable code.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_continue.sol
new file mode 100644
index 00000000..8c07d096
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_nested_continue.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		for (uint i = 0; i < 2; ++i) {
+			for (uint j = 0; j < 2; ++j) {
+			    if (i > 0)
+					continue;
+				++x;
+			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_1.sol
new file mode 100644
index 00000000..d3a6c825
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_1.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		for (; x < 3 || y == 1; ++x) {
+			if (x >= 3)
+				y = 1;
+		}
+        // BMC loop iteration setting is not enough to leave the loop
+		assert(x == 0); // should hold - no assumptions on value if didn't complete the loop
+		assert(y == 0); // should hold - no assumptions on value if didn't complete the loop
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_2.sol
new file mode 100644
index 00000000..720f621d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_2.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		for (; x < 3 || y == 1; ++x) {
+			if (x >= 3)
+				y = 1;
+		}
+		// BMC loop iteration setting is just enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (216-230): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_3.sol
new file mode 100644
index 00000000..00cd3a5c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_semantics_3.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		for (; x < 3 || y == 1; ++x) {
+			if (x >= 3)
+				y = 1;
+		}
+		// BMC loop iteration setting is more than enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 4661: (221-235): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_shallow_unroll.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_shallow_unroll.sol
new file mode 100644
index 00000000..8bfecdfa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_bmc_iterations_shallow_unroll.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		for (uint i = 0; i < 2; ++i) {
+			++x;
+		}
+		// nothing is reported because loop condition is still true after BMCLoopIterations
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_1.sol
new file mode 100644
index 00000000..36af4f9b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_1.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(uint x) public pure {
+        require(x == 2);
+        for (; x == 2;) {}
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_2.sol
new file mode 100644
index 00000000..0847066a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_2.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f(uint x) public pure {
+        require(x == 2);
+        uint y;
+        for (; x == 2;) {
+            y = 7;
+        }
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_3.sol
new file mode 100644
index 00000000..e5219bad
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/for_loop_trivial_condition_3.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(uint x) public pure {
+        require(x == 2);
+        uint y;
+        // The loop condition is always true,
+        // but since x is touched in the body
+        // we can't infer that.
+        for (; x == 2;) {
+            x = 2;
+        }
+        // False positive due to resetting x.
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 2072: (83-89): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1.sol
new file mode 100644
index 00000000..ffb407fe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 100);
+		while (x < 10) {
+			if (b)
+				x = x + 1;
+			else
+				x = 0;
+		}
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break.sol
new file mode 100644
index 00000000..136509f6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b)
+				++x;
+			else {
+				x = 20;
+				break;
+			}
+		}
+		assert(x >= 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break_fail.sol
new file mode 100644
index 00000000..84ec71f4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_break_fail.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b)
+				++x;
+			else {
+				break;
+			}
+		}
+		// Fails because the loop might break.
+		assert(x >= 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 6328: (185-200): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_continue.sol
new file mode 100644
index 00000000..b2e63a3b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_continue.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b) {
+				x = 20;
+				continue;
+			}
+			++x;
+		}
+		assert(x >= 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_fail.sol
new file mode 100644
index 00000000..941bd541
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_fail.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		while (x < 10) {
+			x = x + 1;
+		}
+		assert(x < 14);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 6328: (106-120): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_1_infinite.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_infinite.sol
new file mode 100644
index 00000000..bbd7bfe4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_1_infinite.sol
@@ -0,0 +1,23 @@
+contract C
+{
+	function f(uint x, bool b) public pure {
+		require(x < 100);
+		while (x < 10) {
+			if (b)
+				x = x + 1;
+			else
+				x = 0;
+		}
+		// CHC proves it safe because
+		// 1- if it doesn't go in the loop in the first place, x >= 10
+		// 2- if it goes in the loop and b == true, x increases until >= 10
+		// 3- if it goes in the loop and b == false, it's an infinite loop, therefore
+		//    the assertion and the error are unreachable.
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_2.sol
new file mode 100644
index 00000000..b4d0edac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(uint x) public pure {
+		x = 2;
+		while (x > 1) {
+			if (x > 10)
+				x = 2;
+			else
+				--x;
+		}
+		assert(x < 2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break.sol
new file mode 100644
index 00000000..5e2bbd44
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint x = 0;
+		while (x == 0) {
+			++x;
+			break;
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 5740: (95-98): Unreachable code.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break_fail.sol
new file mode 100644
index 00000000..95e5b4c3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_break_fail.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f(uint x) public pure {
+		while (x == 0) {
+			++x;
+			break;
+			++x;
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTSolvers: z3
+// ----
+// Warning 5740: (87-90): Unreachable code.
+// Warning 6328: (98-112): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_fail.sol
new file mode 100644
index 00000000..95324dd6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_2_fail.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(uint x) public pure {
+		x = 2;
+		while (x > 1) {
+			if (x > 10)
+				x = 2;
+			else
+				x = 10;
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_1.sol
new file mode 100644
index 00000000..11a4e758
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_1.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f(uint x) public pure {
+		require(x == 0);
+		uint y;
+		while (y < 3) {
+			++y;
+			if (y == 2)
+			    x = 3;
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_2.sol
new file mode 100644
index 00000000..075e342e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_2.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			{
+				++x;
+				++x;
+			}
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_3.sol
new file mode 100644
index 00000000..2596af24
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_3.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			if (x >= 2)
+				++x;
+			++x;
+		}
+		assert(x == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_4.sol
new file mode 100644
index 00000000..8bfbe32d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_4.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(uint x) public pure {
+		x = 0;
+		while (x < 1) {
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_5.sol
new file mode 100644
index 00000000..f3166cee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_5.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (true) {
+			++x;
+		}
+		assert(x == 1000);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_6.sol
new file mode 100644
index 00000000..ffdeeba1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_6.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint x;
+	uint y;
+
+	function condition() private returns(bool) {
+		x = (x + 1) % 2;
+		return (x == 1);
+	}
+
+	function f() public {
+		require(x == 0);
+		require(y == 0);
+		while (condition()) {
+			++y;
+		}
+		assert(y == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (85-90): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_7.sol
new file mode 100644
index 00000000..3f6a5b4b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_7.sol
@@ -0,0 +1,22 @@
+contract C {
+    uint x;
+
+    function condition() private returns(bool) {
+		++x;
+		return x < 3;
+	}
+
+	function f() public {
+		require(x == 0);
+		while (condition()) {
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 5
+// ----
+// Warning 2661: (77-80): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_8.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_8.sol
new file mode 100644
index 00000000..b7ad4e2e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_8.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	uint256[] y;
+
+	function f() public view {
+ 		uint256 x = 0;
+		while (x < y.length) {
+			x = 1;
+		}
+		// tests that constant condition warning is not reported
+		require(x != 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_1.sol
new file mode 100644
index 00000000..a43c7489
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_1.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x == 0);
+		while (x < 2) {
+			++x;
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (98-112): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_2.sol
new file mode 100644
index 00000000..c16f755b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_2.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 2) {
+			++x;
+			break;
+		}
+		assert(x == 0);
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Warning 4661: (93-107): BMC: Assertion violation happens here.
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_3.sol
new file mode 100644
index 00000000..acaf4f9a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_assertion_fails_3.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 2) {
+			++x;
+			continue;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (96-110): BMC: Assertion violation happens here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_1.sol
new file mode 100644
index 00000000..c8b45bac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_1.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			break;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_2.sol
new file mode 100644
index 00000000..c4a8c2f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			if (x > 0)
+				break;
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_3.sol
new file mode 100644
index 00000000..c089b906
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_3.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			if (x > 0) {
+				++x;
+				break;
+			}
+			++x;
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_4.sol
new file mode 100644
index 00000000..d1939871
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_4.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			if (x > 0) {
+ 				++x;
+				break;
+			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_5.sol
new file mode 100644
index 00000000..f7ba610a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_5.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			if (x > 1) {
+				++x;
+				break;
+			}
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_6.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_6.sol
new file mode 100644
index 00000000..0546e48c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_6.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			if (x > 0) {
+ 				x = 2;
+				break;
+			}
+			if (x > 1) {
+				x = 3;
+				break;
+			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_7.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_7.sol
new file mode 100644
index 00000000..8e4d3b62
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_7.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			++x;
+			if (x > 1) {
+				x = 3;
+				break;
+ 			}
+			if (x > 0) {
+				x = 2;
+				break;
+ 			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_8.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_8.sol
new file mode 100644
index 00000000..be6b04bb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_8.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		while (x < 3) {
+			if (x >= 0) {
+				++x;
+				break;
+			}
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_9.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_9.sol
new file mode 100644
index 00000000..caaa4f57
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_9.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		while (x < 3) {
+			++x;
+			break;
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 5740: (94-97): Unreachable code.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_1.sol
new file mode 100644
index 00000000..bb955452
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_1.sol
@@ -0,0 +1,21 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			if (x > 1) {
+				break;
+ 			}
+			if (x >= 0) {
+				x = 10;
+				continue;
+ 			}
+		}
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_2.sol
new file mode 100644
index 00000000..b65404e2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_break_continue_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x;
+		while (x < 3) {
+			if (x > 1) {
+				x = 3;
+				break;
+ 			}
+			if (x >= 0) {
+				x = 2;
+				continue;
+ 			}
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_1.sol
new file mode 100644
index 00000000..e17fa303
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_1.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint x;
+		uint i;
+		while (i < 3) {
+			++i;
+			if (i > 1)
+				continue;
+			++x;
+		}
+		assert(x == 1);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_2.sol
new file mode 100644
index 00000000..3670f8da
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_continue_2.sol
@@ -0,0 +1,24 @@
+contract C {
+	function f(uint x) public pure {
+		require(x == 0);
+		uint i;
+		while (i < 3) {
+			 ++i;
+			if (i == 2) {
+				x = 2;
+				continue;
+			}
+			if (i == 1) {
+				x = 1;
+				continue;
+			}
+		}
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested.sol
new file mode 100644
index 00000000..887ce60f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f(uint z) public pure {
+		uint x = 0;
+		require(z == 0);
+		while (x < 2) {
+			uint y = 0;
+			while (y < 2) {
+				++z;
+				++y;
+			}
+			++x;
+		}
+		assert(z == 4);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_break.sol
new file mode 100644
index 00000000..170c5a3c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_break.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f(uint z) public pure {
+		uint x = 0;
+		require(z == 0);
+		while (x < 2) {
+			uint y = 0;
+			while (y < 2) {
+				if (y > 0)
+					break;
+				++z;
+				++y;
+			}
+			++x;
+		}
+		assert(z == 2);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_continue.sol
new file mode 100644
index 00000000..66ad2081
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_nested_continue.sol
@@ -0,0 +1,23 @@
+contract C {
+	function f() public pure {
+		uint x;
+		uint i;
+		while (i < 3) {
+			++i;
+			uint j;
+			while (j < 3) {
+				++j;
+				if (i > 1)
+					continue;
+				++x;
+			}
+		}
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_1.sol
new file mode 100644
index 00000000..7de8b814
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_1.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		while (x < 3 || y == 1) {
+			if (x >= 3)
+				y = 1;
+			++x;
+		}
+		// BMC loop iteration setting is not enough to leave the loop
+		assert(x == 0); // should hold - no assumptions on value if didn't complete the loop
+		assert(y == 0); // should hold - no assumptions on value if didn't complete the loop
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 2
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_2.sol
new file mode 100644
index 00000000..a50acf4d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		while (x < 3 || y == 1) {
+			if (x >= 3)
+				y = 1;
+			++x;
+		}
+ 		// BMC loop iteration setting is just enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 3
+// ----
+// Warning 4661: (220-234): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_3.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_3.sol
new file mode 100644
index 00000000..6ead5814
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_semantics_3.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		int y = 0;
+		while (x < 3 || y == 1) {
+			if (x >= 3)
+				y = 1;
+			++x;
+		}
+		// BMC loop iteration setting is more than enough to leave the loop
+		assert(x == 3);
+		assert(y == 1); // should fail
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 4
+// ----
+// Warning 4661: (224-238): BMC: Assertion violation happens here.
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_shallow_unroll.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_shallow_unroll.sol
new file mode 100644
index 00000000..3134e35c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_bmc_iterations_shallow_unroll.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		uint x = 0;
+		while (x < 5) {
+			x = x + 1;
+		}
+		// nothing is reported because loop condition is true after unrolling the loop one time
+		assert(x == 5);
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: bmc
+// SMTSolvers: z3
+// BMCLoopIterations: 1
+// ----
+// Info 6002: BMC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_break_direct.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_break_direct.sol
new file mode 100644
index 00000000..4a6245b0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_break_direct.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(uint x) public pure {
+		x = 0;
+		while (x < 10)
+			break;
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_memory.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_memory.sol
new file mode 100644
index 00000000..be350ef5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_memory.sol
@@ -0,0 +1,33 @@
+contract LoopFor2 {
+	function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public pure {
+		require(n < b.length);
+		require(n < c.length);
+		require(n > 0 && n < 100);
+		b[0] = 900;
+		uint[] memory a = b;
+		uint i;
+		// Disabled because of Spacer's nondeterminism.
+		/*
+		while (i < n) {
+			// Accesses are safe but oob is reported due to potential aliasing after c's assignment.
+			b[i] = i + 1;
+			c[i] = b[i];
+			++i;
+		}
+		*/
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == c[0]);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(a[0] == 900);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTSolvers: z3
+// ----
+// Warning 2072: (202-217): Unused local variable.
+// Warning 2072: (225-231): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_storage.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_storage.sol
new file mode 100644
index 00000000..1e5e2fbe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_memory_storage.sol
@@ -0,0 +1,37 @@
+contract LoopFor2 {
+	uint[] a;
+	function p() public {
+		a.push();
+	}
+	function testUnboundedForLoop(uint n, uint[] memory b, uint[] memory c) public {
+		require(n < a.length);
+		require(n < b.length);
+		require(n < c.length);
+		b[0] = 900;
+		a = b;
+		require(n > 0 && n < 100);
+		uint i;
+		// Disabled because of Spacer nondeterminism.
+		/*
+		while (i < n) {
+			// Accesses are safe but oob is reported due to potential aliasing after c's assignment.
+			b[i] = i + 1;
+			c[i] = b[i];
+			++i;
+		}
+		*/
+		// Fails due to aliasing, since both b and c are
+		// memory references of same type.
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == c[0]);
+		assert(a[0] == 900);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 2072: (280-286): Unused local variable.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_storage_storage.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_storage_storage.sol
new file mode 100644
index 00000000..ed7ebdfb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_array_assignment_storage_storage.sol
@@ -0,0 +1,32 @@
+contract LoopFor2 {
+	uint[] b;
+	uint[] c;
+	function p() public {
+		b.push();
+		c.push();
+	}
+	function testUnboundedForLoop(uint n) public {
+		require(n < b.length);
+		require(n < c.length);
+		require(n > 0 && n < 100);
+		b[0] = 900;
+		uint[] storage a = b;
+		uint i;
+		while (i < n) {
+			b[i] = i + 1;
+			//c[i] = b[i]; // Removed because of Spacer's nondeterminism
+			++i;
+		}
+		//assert(b[0] == c[0]); // Removed because of Spacer's nondeterminism
+		assert(a[0] == 900);
+		assert(b[0] == 900);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (288-292): CHC: Out of bounds access might happen here.
+// Warning 6368: (459-463): CHC: Out of bounds access happens here.
+// Warning 6328: (452-471): CHC: Assertion violation happens here.
+// Warning 6328: (475-494): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_1.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_1.sol
new file mode 100644
index 00000000..461e4f4e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_1.sol
@@ -0,0 +1,16 @@
+// Check that variables are cleared
+contract C {
+    function f(uint x) public pure {
+        x = 2;
+        while (x > 1) {
+            x = 1;
+        }
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (162-176): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 1\n\nTransaction trace:\nC.constructor()\nC.f(0)
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_2.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_2.sol
new file mode 100644
index 00000000..e71e73ee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_2.sol
@@ -0,0 +1,13 @@
+// Check that condition is assumed.
+contract C {
+    function f(uint x) public pure {
+        while (x == 2) {
+            assert(x == 2);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_4.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_4.sol
new file mode 100644
index 00000000..f5ee2dfa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_4.sol
@@ -0,0 +1,13 @@
+// Check that negation of condition is not assumed after the body anymore
+contract C {
+    function f(uint x) public pure {
+        while (x == 2) {
+        }
+        assert(x != 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_5.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_5.sol
new file mode 100644
index 00000000..5a085fdb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_loop_simple_5.sol
@@ -0,0 +1,16 @@
+// Check that side-effects of condition are taken into account
+contract C {
+    function f(uint x, uint y) public pure {
+        x = 7;
+        while ((x = y) > 0) {
+			--y;
+        }
+        assert(x == 7);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Warning 6328: (192-206): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break.sol
new file mode 100644
index 00000000..8f80745b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break.sol
@@ -0,0 +1,33 @@
+contract C
+{
+	function f(uint x, uint y, bool b, bool c) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b) {
+				++x;
+				if (x == 10)
+					x = 15;
+			}
+			else {
+				require(y < 10);
+				while (y < 10) {
+					if (c)
+						++y;
+					else {
+						y = 20;
+						break;
+					}
+				}
+				assert(y >= 10);
+				x = 15;
+				break;
+			}
+		}
+		assert(x >= 15);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break_fail.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break_fail.sol
new file mode 100644
index 00000000..60ce3be9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_break_fail.sol
@@ -0,0 +1,34 @@
+contract C
+{
+	function f(uint x, uint y, bool b, bool c) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b) {
+				++x;
+				if (x == 10)
+					x = 15;
+			}
+			else {
+				require(y < 10);
+				while (y < 10) {
+					if (c)
+						++y;
+					else {
+						y = 20;
+						break;
+					}
+				}
+				assert(y >= 15);
+				x = 15;
+				break;
+			}
+		}
+		assert(x >= 20);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (296-311): CHC: Assertion violation happens here.
+// Warning 6328: (347-362): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_continue.sol b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_continue.sol
new file mode 100644
index 00000000..eee4d91d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/loops/while_nested_continue.sol
@@ -0,0 +1,31 @@
+contract C
+{
+	function f(uint x, uint y, bool b, bool c) public pure {
+		require(x < 10);
+		while (x < 10) {
+			if (b) {
+				x = 20;
+				continue;
+			}
+			else {
+				require(y < 10);
+				while (y < 10) {
+					if (c) {
+						y = 20;
+						continue;
+					}
+					y = 15;
+					break;
+				}
+				assert(y >= 15);
+				x = y;
+			}
+		}
+		assert(x >= 15);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/math/addmod_1.sol b/compiler/test/libsolidity/smtCheckerTests/math/addmod_1.sol
new file mode 100644
index 00000000..3ec75c8c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/math/addmod_1.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		assert(addmod(2**256 - 1, 10, 9) == 7);
+		uint y = 0;
+		uint x = addmod(2**256 - 1, 10, y);
+		assert(x == 1);
+	}
+	function g(uint x, uint y, uint k) public pure returns (uint) {
+		return addmod(x, y, k);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4281: (108-133): CHC: Division by zero happens here.
+// Warning 6328: (137-151): CHC: Assertion violation happens here.
+// Warning 4281: (230-245): CHC: Division by zero happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod.sol b/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod.sol
new file mode 100644
index 00000000..b957a9b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod.sol
@@ -0,0 +1,14 @@
+contract C {
+	function test() public pure {
+		uint x;
+		if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) x = 1;
+		if ((2**255 + 2**255) % 7 != addmod(2**255, 2**255, 7)) x = 2;
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (60-110): BMC: Condition is always false.
+// Warning 6838: (125-175): BMC: Condition is always false.
diff --git a/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod_zero.sol b/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod_zero.sol
new file mode 100644
index 00000000..90a4f8b9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/math/addmod_mulmod_zero.sol
@@ -0,0 +1,29 @@
+contract C {
+	function f(uint256 d) public pure {
+		uint x = addmod(1, 2, d);
+		assert(x < d);
+	}
+
+	function g(uint256 d) public pure {
+		uint x = mulmod(1, 2, d);
+		assert(x < d);
+	}
+
+	function h() public pure returns (uint256) {
+		uint x = mulmod(0, 1, 2);
+		uint y = mulmod(1, 0, 2);
+		assert(x == y);
+		uint z = addmod(0, 1, 2);
+		uint t = addmod(1, 0, 2);
+		assert(z == t);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (220-227): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 4281: (61-76): CHC: Division by zero happens here.
+// Warning 6328: (80-93): CHC: Assertion violation happens here.
+// Warning 4281: (147-162): CHC: Division by zero happens here.
+// Warning 6328: (166-179): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/math/addmulmod.sol b/compiler/test/libsolidity/smtCheckerTests/math/addmulmod.sol
new file mode 100644
index 00000000..47812128
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/math/addmulmod.sol
@@ -0,0 +1,20 @@
+contract C {
+	function test_addmod(uint x, uint y) public pure {
+		require(x % 13 == 0);
+		require(y % 13 == 0);
+
+		uint z = addmod(x, y, 13);
+		assert(z == 0);
+	}
+	function test_mulmod(uint x, uint y) public pure {
+		require(x % 13 == 0);
+		require(y % 13 == 0);
+
+		uint z = mulmod(x, y, 13);
+		assert(z == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/math/mulmod_1.sol b/compiler/test/libsolidity/smtCheckerTests/math/mulmod_1.sol
new file mode 100644
index 00000000..de15f362
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/math/mulmod_1.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		assert(mulmod(2**256 - 1, 2, 14) == 2);
+		uint y = 0;
+		uint x = mulmod(2**256 - 1, 10, y);
+		assert(x == 1);
+	}
+	function g(uint x, uint y, uint k) public pure returns (uint) {
+		return mulmod(x, y, k);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4281: (108-133): CHC: Division by zero happens here.
+// Warning 6328: (137-151): CHC: Assertion violation happens here.
+// Warning 4281: (230-245): CHC: Division by zero happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_code_after_placeholder.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_code_after_placeholder.sol
new file mode 100644
index 00000000..5f08811b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_code_after_placeholder.sol
@@ -0,0 +1,25 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x > 0);
+		_;
+		// Fails because of overflow behavior.
+		assert(x > 1);
+	}
+
+	function f() m public {
+		assert(x > 0);
+		unchecked { x = x + 1; }
+	}
+
+	function g(uint _x) public {
+		x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (103-116): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_control_flow.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_control_flow.sol
new file mode 100644
index 00000000..f348bf24
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_control_flow.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		if (x == 0)
+			_;
+	}
+
+	function f() m public view {
+		assert(x == 0);
+		assert(x > 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (111-124): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment.sol
new file mode 100644
index 00000000..caa67b0d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint x;
+	address owner;
+
+	modifier onlyOwner {
+		if (msg.sender == owner) _;
+	}
+
+	function f() public onlyOwner {
+		x = 0;
+	}
+	function g(uint y) public {
+		x = 1;
+		if (y > 0)
+			f();
+		// Fails for {y = >0, msg.sender == owner, x = 0}.
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (254-267): CHC: Assertion violation happens here.\nCounterexample:\nx = 0, owner = 0x0\ny = 1\n\nTransaction trace:\nC.constructor()\nState: x = 0, owner = 0x0\nC.f()\nState: x = 0, owner = 0x0\nC.g(1)\n    C.f() -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_branch.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_branch.sol
new file mode 100644
index 00000000..187305a6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_branch.sol
@@ -0,0 +1,28 @@
+contract C {
+	uint x;
+	address owner;
+
+	modifier onlyOwner {
+		if (msg.sender == owner) {
+			require(x > 0);
+			_;
+		}
+	}
+
+	function f() public onlyOwner {
+		// Condition is always true due to `require(x > 0)` in the modifier.
+		if (x > 0)
+			x -= 1;
+	}
+	function g(uint y) public {
+		x = 2;
+		if (y > 0)
+			f();
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (233-238): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_multi_branches.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_multi_branches.sol
new file mode 100644
index 00000000..db597db2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_inside_branch_assignment_multi_branches.sol
@@ -0,0 +1,38 @@
+contract C {
+	uint x;
+	address owner;
+
+	modifier onlyOwner {
+		if (msg.sender == owner) {
+			require(x > 0);
+			_;
+		}
+	}
+
+	function f() public onlyOwner {
+		x -= 1;
+		h();
+	}
+	function h() public onlyOwner {
+		require(x < 10000);
+		x += 2;
+	}
+	function g(uint y) public {
+		require(y > 0 && y < 10000);
+		require(msg.sender == owner);
+		x = y;
+		if (y > 1) {
+			f();
+			// This now fails as a false positive because
+			// CHC does not propagate msg.sender throughout predicates.
+			assert(x == y + 1);
+		}
+		// Fails for {y = 0, x = 0}.
+		assert(x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (540-554): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi.sol
new file mode 100644
index 00000000..292c44ae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi.sol
@@ -0,0 +1,30 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x > 0);
+		require(x < 10000);
+		_;
+	}
+
+	modifier n {
+		x = x + 1;
+		_;
+		assert(x > 2);
+		assert(x > 8);
+	}
+
+	function f() m n public {
+		x = x + 1;
+	}
+
+	function g(uint _x) public {
+		x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (137-150): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions.sol
new file mode 100644
index 00000000..fb503bb7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	modifier m(uint a, uint b) {
+		require(g(a, b));
+		_;
+	}
+
+	modifier notZero(uint x) {
+		require(x > 0);
+		_;
+	}
+
+	function g(uint a, uint b) notZero(a) internal pure returns (bool) {
+		return a > b;
+	}
+
+	function f(uint x) m(x, 0) public pure {
+		assert(x > 0);
+		assert(x > 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (278-291): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions_recursive.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions_recursive.sol
new file mode 100644
index 00000000..1e55dab1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_functions_recursive.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	modifier m(uint a, uint b) {
+		require(g(a, b));
+		_;
+	}
+
+	function g(uint a, uint b) m(a, b) internal pure returns (bool) {
+		return a > b;
+	}
+
+	function f(uint x) m(x, 0) public pure {
+		assert(x > 0);
+		assert(x > 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5740: (137-157): Unreachable code.
+// Warning 5740: (199-237): Unreachable code.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_parameters.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_parameters.sol
new file mode 100644
index 00000000..31578a31
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_multi_parameters.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	modifier m(uint a, uint b) {
+		require(a > b);
+		_;
+	}
+
+	function f(uint x) m(x, 0) public pure {
+		assert(x > 0);
+		assert(x > 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (131-144): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overflow.sol
new file mode 100644
index 00000000..b3c5b8ed
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overflow.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x > 0);
+		_;
+	}
+
+	function f() m public {
+		assert(x > 0);
+		x = x + 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_1.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_1.sol
new file mode 100644
index 00000000..9165ed13
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_1.sol
@@ -0,0 +1,24 @@
+abstract contract A {
+	uint s;
+
+	function f() public mod(s) {}
+	modifier mod(uint x) virtual;
+}
+
+contract B is A {
+	modifier mod(uint x) override {
+		require(x == 42);
+		_;
+		assert(x == 42); // should hold
+		assert(x == 0); // should fail
+	}
+
+	function set(uint x) public {
+		s = x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (209-223): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_3.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_3.sol
new file mode 100644
index 00000000..f85e1b3b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_3.sol
@@ -0,0 +1,22 @@
+abstract contract A {
+	bool s;
+
+	function f() public view mod {
+		assert(s); // holds for B
+		assert(!s); // fails for B
+	}
+	modifier mod() virtual;
+}
+
+contract B is A {
+	modifier mod() virtual override {
+		bool x = true;
+		s = x;
+		_;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (94-104): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_4.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_4.sol
new file mode 100644
index 00000000..652dd811
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_overriding_4.sol
@@ -0,0 +1,42 @@
+abstract contract A {
+	int x = 0;
+
+	function f() public view mod() {
+		assert(x != 0); // does not hold for A, but A is abstract so it should not be reported
+		assert(x != 1); // fails for B
+		assert(x != 2); // fails for C
+		assert(x != 3); // fails for D
+	}
+
+	modifier mod() virtual {
+		_;
+	}
+}
+
+contract B is A {
+	modifier mod() virtual override {
+		x = 1;
+		_;
+	}
+}
+
+contract C is A {
+	modifier mod() virtual override {
+		x = 2;
+		_;
+	}
+}
+
+contract D is B,C {
+	modifier mod() virtual override (B,C){
+		x = 3;
+		_;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (160-174): CHC: Assertion violation happens here.
+// Warning 6328: (193-207): CHC: Assertion violation happens here.
+// Warning 6328: (226-240): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameter_copy.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameter_copy.sol
new file mode 100644
index 00000000..1612cb8e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameter_copy.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	modifier m(uint x) {
+		x == 2;
+		_;
+	}
+
+	function f(uint x) m(x) public pure {
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (95-109): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\nx = 0\n\nTransaction trace:\nC.constructor()\nC.f(0)
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameters.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameters.sol
new file mode 100644
index 00000000..761dd8a3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_parameters.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	uint s;
+	modifier m(uint a) {
+		// Condition is always true for m(2).
+		require(a > 0);
+		_;
+	}
+
+	function f(uint x) m(x) m(2) m(s) public view {
+		assert(x > 0);
+		assert(s > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_return.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_return.sol
new file mode 100644
index 00000000..baa295d8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_return.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	modifier m(uint x) {
+		require(x == 2);
+		_;
+		return;
+	}
+
+	modifier n(uint x) {
+		require(x == 3);
+		_;
+	}
+
+	function f(uint x) m(x) n(x) public pure {
+		assert(x == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_simple.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_simple.sol
new file mode 100644
index 00000000..7875bb80
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_simple.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x > 0);
+		_;
+	}
+
+	function f() m public view {
+		assert(x > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations.sol
new file mode 100644
index 00000000..26197459
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		// Condition is always true for the second invocation.
+		require(x > 0);
+		require(x < 10000);
+		_;
+		assert(x > 1);
+	}
+
+	function f() m m public {
+		x = x + 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations_2.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations_2.sol
new file mode 100644
index 00000000..d6bc51ff
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_invocations_2.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x == 0);
+		_;
+		x = x + 1;
+		assert(x <= 2);
+	}
+
+	function f() m m public {
+		x = x + 1;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (76-90): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_placeholders.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_placeholders.sol
new file mode 100644
index 00000000..00b6fab5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_two_placeholders.sol
@@ -0,0 +1,27 @@
+contract C
+{
+	uint x;
+
+	modifier m {
+		require(x > 0);
+		require(x < 10000);
+		_;
+		assert(x > 1);
+		_;
+		assert(x > 2);
+		assert(x > 10);
+	}
+
+	function f() m public {
+		x = x + 1;
+	}
+
+	function g(uint _x) public {
+		x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (123-137): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_virtual_static_call_2.sol b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_virtual_static_call_2.sol
new file mode 100644
index 00000000..b270fb2b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/modifiers/modifier_virtual_static_call_2.sol
@@ -0,0 +1,24 @@
+contract A {
+	int x = 0;
+
+	modifier m virtual {
+		assert(x == 0); // should hold
+		assert(x == 42); // should fail
+		_;
+	}
+}
+contract C is A {
+
+	modifier m override {
+		assert(x == 1); // This assert is not reachable, should NOT be reported
+		_;
+	}
+
+	function f() public A.m returns (uint) {
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (83-98): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_free_function_1.sol b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_free_function_1.sol
new file mode 100644
index 00000000..d0136705
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_free_function_1.sol
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+contract C {
+    function f(uint x) external pure {
+        uint t = msb(x);
+        assert(t == 0); // should fail
+    }
+}
+
+/// @custom:smtchecker abstract-function-nondet
+function msb(uint256 x) pure returns (uint256 result) {}
+
+// ====
+// SMTEngine: chc
+// ----
+// Warning 6328: (144-158): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_no_abstraction.sol b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_no_abstraction.sol
new file mode 100644
index 00000000..b9bca035
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_no_abstraction.sol
@@ -0,0 +1,39 @@
+contract C {
+	function e(uint _e) public pure {
+		// Without abstracting function `pow` the solver
+		// fails to prove that `++i` does not overflow.
+		for (uint i = 0; i < _e; ++i)
+			pow(_e, _e);
+	}
+
+	function pow(uint base, uint exponent) internal pure returns (uint) {
+		// Disabled because of Spacer nondet
+		/*
+		if (base == 0) {
+			return 0;
+		}
+		if (exponent == 0) {
+			return 1;
+		}
+		if (exponent == 1) {
+			return base;
+		}
+		uint y = 1;
+		while(exponent > 1) {
+			if(exponent % 2 == 0) {
+				base = base * base;
+				exponent = exponent / 2;
+			} else {
+				y = base * y;
+				base = base * base;
+				exponent = (exponent - 1) / 2;
+			}
+		}
+		return base * y;
+		*/
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_with_abstraction.sol b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_with_abstraction.sol
new file mode 100644
index 00000000..e0647000
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/natspec/abstract_function_nondet_pow_with_abstraction.sol
@@ -0,0 +1,37 @@
+contract C {
+	function e(uint _e) public pure {
+		// Without abstracting function `pow` the solver
+		// fails to prove that `++i` does not overflow.
+		for (uint i = 0; i < _e; ++i)
+			pow(_e, _e);
+	}
+
+	/// @custom:smtchecker abstract-function-nondet
+	function pow(uint base, uint exponent) internal pure returns (uint) {
+		if (base == 0) {
+			return 0;
+		}
+		if (exponent == 0) {
+			return 1;
+		}
+		if (exponent == 1) {
+			return base;
+		}
+		uint y = 1;
+		while(exponent > 1) {
+			if(exponent % 2 == 0) {
+				base = base * base;
+				exponent = exponent / 2;
+			} else {
+				y = base * y;
+				base = base * base;
+				exponent = (exponent - 1) / 2;
+			}
+		}
+		return base * y;
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/natspec/natspec_smtchecker_multi_errors_1.sol b/compiler/test/libsolidity/smtCheckerTests/natspec/natspec_smtchecker_multi_errors_1.sol
new file mode 100644
index 00000000..a19923c9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/natspec/natspec_smtchecker_multi_errors_1.sol
@@ -0,0 +1,10 @@
+contract C {
+    /// @custom:smtchecker b
+    /// @custom:smtchecker
+    /// @custom:smtchecker a b c
+    function f() internal {}
+}
+
+contract D is C {}
+// ----
+// Warning 3130: (106-130): Unknown option for "custom:smtchecker": "b"
diff --git a/compiler/test/libsolidity/smtCheckerTests/natspec/safe_assert_false_positive_pure.sol b/compiler/test/libsolidity/smtCheckerTests/natspec/safe_assert_false_positive_pure.sol
new file mode 100644
index 00000000..552c8d4f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/natspec/safe_assert_false_positive_pure.sol
@@ -0,0 +1,31 @@
+contract C {
+	uint x;
+	uint y;
+
+	function g(uint _x) public {
+		uint z = f1(_x);
+		assert(x == 0); // should hold because f1 is pure
+		assert(z == _x); // should hold but f1 was abstracted as nondet, so it fails
+
+		uint t = f2(_x);
+		assert(y == 0); // should hold because f1 is pure and f2 is view
+		assert(t == _x); // should hold
+	}
+
+	/// @custom:smtchecker abstract-function-nondet
+	function f1(uint _x) internal pure returns (uint) {
+		return _x;
+	}
+
+	function f2(uint _y) internal view returns (uint) {
+		return _y;
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTIgnoreCex: yes
+// ----
+// Warning 2018: (33-335): Function state mutability can be restricted to view
+// Warning 2018: (457-524): Function state mutability can be restricted to pure
+// Warning 6328: (135-150): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_1.sol
new file mode 100644
index 00000000..a0fd84c9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_1.sol
@@ -0,0 +1,10 @@
+contract C {
+    string public name = (C).name = type(C).name;
+
+    function f() external view {
+        assert(keccak256(bytes(name)) == keccak256(bytes("C"))); // should fail because SMTChecker doesn't support type(C).name
+    }
+}
+// ----
+// Warning 7507: (49-61): Assertion checker does not yet support this expression.
+// Warning 6328: (105-160): CHC: Assertion violation happens here.\nCounterexample:\n\n\nTransaction trace:\nC.constructor()\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_2.sol
new file mode 100644
index 00000000..c89314e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_2.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint x = ((((C)))).x = ((C)).x = 2;
+
+    function f() external view {
+        assert(x == 2); // should hold
+    }
+
+    function g() external view {
+        assert(x != 2); // should fail
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (174-188): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 2\nC.g()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_3.sol
new file mode 100644
index 00000000..e53436a0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_chain_tuple_contract_3.sol
@@ -0,0 +1,26 @@
+contract C {
+    uint x = ((((C)))).x = ((C)).x = 2;
+
+    function f() external view {
+        assert(x == 2); // should fail for D
+    }
+
+    function g() external view {
+        assert(x != 2); // should fail for C
+    }
+}
+
+contract D is C {
+    uint y = ((C)).x = 3;
+
+    function h() external view {
+        assert(y == 3); // should hold
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (95-109): CHC: Assertion violation happens here.\nCounterexample:\ny = 3, x = 3\n\nTransaction trace:\nD.constructor()\nState: y = 3, x = 3\nC.f()
+// Warning 6328: (180-194): CHC: Assertion violation happens here.\nCounterexample:\nx = 2\n\nTransaction trace:\nC.constructor()\nState: x = 2\nC.g()
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable.sol
new file mode 100644
index 00000000..40eb4867
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable.sol
@@ -0,0 +1,33 @@
+contract A {
+	int x;
+	int y;
+	function a() public {
+		require(A.x < 100);
+		A.y = A.x++;
+		assert(A.y == A.x - 1);
+		// Fails
+		// assert(A.y == 0); // Disabled because of nondeterminism in Spacer
+		A.y = ++A.x;
+		assert(A.y == A.x);
+		delete A.x;
+		assert(A.x == 0);
+		A.y = A.x--;
+		assert(A.y == A.x + 1);
+		assert(A.y == 0);
+		A.y = --A.x;
+		assert(A.y == A.x);
+		A.x += 10;
+		// Fails
+		assert(A.y == 0);
+		assert(A.y + 10 == A.x);
+		A.x -= 10;
+		assert(A.y == A.x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreInv: yes
+// ----
+// Warning 6328: (392-408): CHC: Assertion violation happens here.
+// Info 1391: CHC: 17 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array.sol
new file mode 100644
index 00000000..3a93659f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array.sol
@@ -0,0 +1,16 @@
+contract A {
+	uint[] a;
+	function f() public {
+		A.a.push(2);
+		assert(A.a[A.a.length - 1] == 2);
+		A.a.pop();
+		// Fails
+		assert(A.a.length > 0);
+		assert(A.a.length == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (124-146): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_2.sol
new file mode 100644
index 00000000..15bb168a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_2.sol
@@ -0,0 +1,11 @@
+contract A {
+    int[] a;
+    function f() public {
+		A.a.push();
+        A.a[0] = 2;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_3.sol
new file mode 100644
index 00000000..0fe3e68b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_contract_member_variable_array_3.sol
@@ -0,0 +1,33 @@
+contract A {
+	int[] a;
+	constructor() {
+		p();
+	}
+	function p() public {
+		a.push(1);
+	}
+	function f() public {
+		require(a.length == 1 && a[0] == 1);
+		int[] storage u = a;
+		assert(u[0] == 1); // should hold
+		int[] memory b = new int[](2);
+		a = b;
+		// Access is safe but oob is reported due to aliasing.
+		assert(u[0] == 1); // should fail
+		A.a = b;
+		// Access is safe but oob is reported due to aliasing.
+		assert(u[0] == 1); // should fail
+	}
+
+	function push_v(int x) public {
+		a.push(x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (318-322): CHC: Out of bounds access happens here.
+// Warning 6328: (311-328): CHC: Assertion violation happens here.
+// Warning 6368: (422-426): CHC: Out of bounds access happens here.
+// Warning 6328: (415-432): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/assignment_module_contract_member_variable.sol b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_module_contract_member_variable.sol
new file mode 100644
index 00000000..baa1c75a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/assignment_module_contract_member_variable.sol
@@ -0,0 +1,34 @@
+==== Source: AASource ====
+import "AASource" as AA;
+contract A {
+	int x;
+	int y;
+	function a() public {
+		require(A.x < 100);
+		AA.A.y = A.x++;
+		assert(A.y == AA.A.x - 1);
+		// Fails
+		assert(AA.A.y == 0);
+		A.y = ++AA.A.x;
+		assert(A.y == A.x);
+		delete AA.A.x;
+		assert(A.x == 0);
+		A.y = A.x--;
+		assert(AA.A.y == AA.A.x + 1);
+		A.y = --A.x;
+		assert(A.y == A.x);
+		AA.A.x += 10;
+		// Fails
+		assert(A.y == 0);
+		assert(A.y + 10 == A.x);
+		A.x -= 10;
+		assert(AA.A.y == A.x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (AASource:159-178): CHC: Assertion violation happens here.
+// Warning 6328: (AASource:370-386): CHC: Assertion violation happens here.
+// Info 1391: CHC: 16 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_fixed_bytes.sol
new file mode 100644
index 00000000..175702d6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_fixed_bytes.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		assert(bytes1("") & ("") == bytes1(0)); // should hold
+		assert(bytes1(0xAA) & bytes1(0x55) == bytes1(0)); // should hold
+		assert(bytes1(0xFF) & bytes1(0xAA) == bytes1(0xAA)); // should hold
+		assert(bytes1(0xFF) & bytes1(0xAA) == bytes1(0)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (237-285): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_int.sol
new file mode 100644
index 00000000..b280038a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_int.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		int8 x = 1;
+		int8 y = 0;
+		assert(x & y != 0); // should fail
+		x = -1; y = 3;
+		assert(x & y == 3); // should hold
+		y = -1;
+		int8 z = x & y;
+		assert(z == -1); // should hold
+		y = 127;
+		assert(x & y == 127); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (71-89): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 1\ny = 0\nz = 0\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_rational.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_rational.sol
new file mode 100644
index 00000000..ec649ce7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_rational.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		assert(1 & 0 != 0);
+		assert(-1 & 3 == 3);
+		assert(-1 & -1 == -1);
+		assert(-1 & 127 == 127);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (43-61): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_uint.sol
new file mode 100644
index 00000000..fcf2bdfc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_and_uint.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		uint8 x = 1;
+		uint16 y = 0;
+		assert(x & y != 0);
+		x = 0xff;
+		y = 0xffff;
+		assert(x & y == 0xff);
+		assert(x & y == 0xffff);
+		assert(x & y == 0x0000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (74-92): CHC: Assertion violation happens here.
+// Warning 6328: (147-170): CHC: Assertion violation happens here.
+// Warning 6328: (174-197): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_combo.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_combo.sol
new file mode 100644
index 00000000..0a0822dd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_combo.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		uint8 x = 0xff;
+		uint8 y = ~x;
+		assert(x & y == 0);
+		assert(x | y == 0xff);
+		assert(x ^ y == 0xff);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_fixed_bytes.sol
new file mode 100644
index 00000000..c028baf9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_fixed_bytes.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		// ffff0000 in bytes4
+		bytes4 x = ~bytes4(hex"ffff");
+		assert(x == 0xffff0000); // should fail
+		assert(x == 0x0000ffff); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (100-123): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_int.sol
new file mode 100644
index 00000000..cf6d0900
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_int.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		int16 x = 1;
+		assert(~x == 0);
+		x = 0xff;
+		assert(~x == 0);
+		x = 0x0f;
+		assert(~x == 0xf0);
+		x = -1;
+		assert(~x != 0);
+		x = -2;
+		assert(~x == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (58-73): CHC: Assertion violation happens here.
+// Warning 6328: (89-104): CHC: Assertion violation happens here.
+// Warning 6328: (120-138): CHC: Assertion violation happens here.
+// Warning 6328: (152-167): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_uint.sol
new file mode 100644
index 00000000..19b33bd6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_not_uint.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure {
+		uint8 x = 0xff;
+		assert(~x == 0x00);
+		uint16 y = 0xff00;
+		assert(~y == 0xff);
+		assert(~y == 0xffff);
+		assert(~y == 0x0000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (126-146): CHC: Assertion violation happens here.
+// Warning 6328: (150-170): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_operators_do_not_throw_exceptions.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_operators_do_not_throw_exceptions.sol
new file mode 100644
index 00000000..f1e89940
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_operators_do_not_throw_exceptions.sol
@@ -0,0 +1,13 @@
+contract C {
+    // tests that bitwise operators are parsed from z3 answer
+    function test(uint x, uint y) public pure {
+        x | y;
+        x & y;
+        x ^ y;
+        assert(true);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_fixed_bytes.sol
new file mode 100644
index 00000000..9ae3b79e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_fixed_bytes.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure returns (bytes1) {
+		bytes1 b = (bytes1(0x0F) | (bytes1(0xF0)));
+		assert(b == bytes1(0xFF)); // should hold
+		assert(b == bytes1(0x00)); // should fail
+		return b;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (150-175): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_int.sol
new file mode 100644
index 00000000..9f1ff332
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_int.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		int16 x = 1;
+		int16 y = 0;
+		assert(x | y == 1);
+		x = 0; y = 0;
+		assert(x | y != 0);
+		y = 240;
+		x = 15;
+		int16 z = x | y;
+		assert(z == 255);
+		x = -1; y = 200;
+		assert(x | y == x);
+		assert(x | z != -1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (111-129): CHC: Assertion violation happens here.
+// Warning 6328: (234-253): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_uint.sol
new file mode 100644
index 00000000..e66c5e8c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_or_uint.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		uint8 x = 1;
+		uint16 y = 0;
+		assert(x | y != 0);
+		x = 0xff;
+		y = 0xff00;
+		assert(x | y == 0xff);
+		assert(x | y == 0xffff);
+		assert(x | y == 0x0000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (122-143): CHC: Assertion violation happens here.
+// Warning 6328: (174-197): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_1.sol
new file mode 100644
index 00000000..1783a4e3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_1.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f() public pure {
+		uint x = type(uint256).max - 1;
+		assert(x == 2**256 - 2);
+		assert(~1 == -2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_2.sol
new file mode 100644
index 00000000..5dc27441
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_rational_2.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure {
+		assert(~1 | (~0xff & 0) == -2);
+		int x = ~1 | (~0xff ^ 0);
+		/// Result is negative, assertion fails.
+		assert(x > 0);
+		int y = ~x | (0xff & 1);
+		assert(y > 0);
+		assert(y & (0xffffffffffffffffff & 1) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (148-161): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_fixed_bytes.sol
new file mode 100644
index 00000000..92709755
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_fixed_bytes.sol
@@ -0,0 +1,14 @@
+contract Simp {
+	function f3() public pure returns (bytes1) {
+		bytes memory y = "def";
+		assert(y[0] ^ "e" != bytes1(0)); // should hold
+		assert(y[1] ^ "e" != bytes1(0)); // should fail
+		return y[0];
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (140-171): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_int.sol
new file mode 100644
index 00000000..67b2246e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_int.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		int8 x = 1;
+		int16 y = 0;
+		assert(x ^ y == 1);
+		int16 z = -1;
+		assert(x ^ z == -2);
+		assert(y ^ z == -1);
+		assert(y ^ z > 0);
+		x = 7; y = 3;
+		assert(x ^ y < 5);
+		assert(x ^ y > 5);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (156-173): CHC: Assertion violation happens here.
+// Warning 6328: (214-231): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_uint.sol
new file mode 100644
index 00000000..6dcbcc8b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bitwise_xor_uint.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() public pure {
+		uint8 x = 1;
+		uint16 y = 0;
+		assert(x ^ y != 0);
+		x = 0xff;
+		y = 0xff00;
+		assert(x ^ y == 0xff);
+		assert(x ^ y == 0xffff);
+		assert(x ^ y == 0x0000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (122-143): CHC: Assertion violation happens here.
+// Warning 6328: (174-197): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/bytes_new.sol b/compiler/test/libsolidity/smtCheckerTests/operators/bytes_new.sol
new file mode 100644
index 00000000..2c9d5e39
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/bytes_new.sol
@@ -0,0 +1,39 @@
+contract C {
+	function f() public pure {
+		bytes memory x = new bytes(0);
+		assert(x.length == 0);
+	}
+	function g() public pure {
+		bytes memory x = new bytes(3);
+		assert(x.length == 3);
+		assert(x[0] == 0);
+		assert(x[1] == 0);
+		assert(x[2] == 0);
+	}
+	function h() public pure {
+		bytes memory x = new bytes(3);
+		assert(x.length == 3);
+		x[0] = 0x12;
+		x[1] = 0x34;
+		assert(x[0] == 0x12);
+		assert(x[1] == 0x34);
+		// This should be an out-of-bounds assertion.
+		x[5] = 0xff;
+		assert(x[5] == 0xff);
+	}
+	function h(uint size) public pure {
+		bytes memory x = new bytes(size);
+		assert(x.length == size);
+		require(size >= 2);
+		x[0] = 0x12;
+		x[1] = 0x34;
+		assert(x[0] == 0x12);
+		assert(x[1] == 0x34);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (468-472): CHC: Out of bounds access happens here.
+// Warning 6368: (490-494): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 23 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_add.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add.sol
new file mode 100644
index 00000000..7a18b1c7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		uint y = 100;
+		y += y + x;
+		assert(y < 300);
+		assert(y < 110);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (118-133): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_array_index.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_array_index.sol
new file mode 100644
index 00000000..5d8b4aaa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_array_index.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	uint[] array;
+	constructor() {
+		q(); q();
+	}
+	function q() public {
+		array.push();
+	}
+	function f(uint x, uint p) public {
+		require(p < array.length);
+		require(x < 100);
+		array[p] = 100;
+		array[p] += array[p] + x;
+		assert(array[p] < 300);
+		assert(array[p] < 110);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (262-284): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_chain.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_chain.sol
new file mode 100644
index 00000000..07a41244
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_chain.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		uint a = 1;
+		uint b = 3;
+		uint c = 7;
+		a += b += c;
+		assert(b ==  10 && a == 11);
+		a += (b += c);
+		assert(b ==  17 && a == 28);
+		a += a += a;
+		assert(a == 112);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_mapping.sol
new file mode 100644
index 00000000..e0025230
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_add_mapping.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x, uint p) public {
+		require(x < 100);
+		map[p] = 100;
+		map[p] += map[p] + x;
+		assert(map[p] < 300);
+		assert(map[p] < 110);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (165-185): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_1.sol
new file mode 100644
index 00000000..5922c59d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(uint x) public pure {
+		require(x == 2);
+		uint y = 10;
+		y /= y / x;
+		assert(y == x);
+		assert(y == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (115-129): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_2.sol
new file mode 100644
index 00000000..9290d364
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_2.sol
@@ -0,0 +1,22 @@
+contract C {
+	uint[] array;
+	constructor() {
+		q(); q();
+	}
+	function q() public {
+		array.push();
+	}
+	function f(uint x, uint p) public {
+		require(p < array.length);
+		require(x == 2);
+		array[p] = 10;
+		array[p] /= array[p] / x;
+		assert(array[p] == x);
+		assert(array[p] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (259-280): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_3.sol
new file mode 100644
index 00000000..66115311
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_division_3.sol
@@ -0,0 +1,16 @@
+contract C {
+	mapping (uint => uint) map;
+	function f(uint x, uint p) public {
+		require(x == 2);
+		map[p] = 10;
+		map[p] /= map[p] / x;
+		assert(map[p] == x);
+		assert(map[p] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (162-181): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_right_shift.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_right_shift.sol
new file mode 100644
index 00000000..01f89d97
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_assignment_right_shift.sol
@@ -0,0 +1,12 @@
+contract C {
+	function f(int a, uint b) public view {
+		a >>= tx.gasprice;
+		require(a == 16 && b == 2);
+		a >>= b;
+		assert(a == 4); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_fixed_bytes.sol
new file mode 100644
index 00000000..d596ddb8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_fixed_bytes.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public pure returns (bytes1) {
+        bytes1 a = 0xff;
+        bytes1 b = 0xf0;
+        a &= b;
+        assert(a == b);
+
+        a &= ~b;
+        assert(a != 0); // fails
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (51-57): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (177-191): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_int.sol
new file mode 100644
index 00000000..0797321f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_int.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		int8 x = 1;
+		int8 y = 0;
+		x &= y;
+		assert(x != 0); // fails
+		x = -1; y = 3;
+		y &= x;
+		assert(y == 3);
+		y = -1;
+		y &= x;
+		assert(y == -1);
+		y = 127;
+		x &= y;
+		assert(x == 127);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (81-95): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_uint.sol
new file mode 100644
index 00000000..3fe528ce
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_and_uint.sol
@@ -0,0 +1,34 @@
+contract C {
+    function f() public pure {
+        uint v = 1;
+        v &= 1;
+        assert(v == 1);
+
+        v = 7;
+        v &= 3;
+        assert(v != 3); // fails, as 7 & 3 = 3
+
+        uint c = 0;
+        c &= v;
+        assert(c == 0);
+
+        uint8 x = 0xff;
+        uint16 y = 0xffff;
+        y &= x;
+        assert(y == 0xff);
+        assert(y == 0xffff); // fails
+
+        y = 0xffff;
+        x = 0xff;
+        y &= y | x;
+        assert(y == 0xffff);
+        assert(y == 0xff); // fails
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (144-158): CHC: Assertion violation happens here.
+// Warning 6328: (347-366): CHC: Assertion violation happens here.
+// Warning 6328: (473-490): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_fixed_bytes.sol
new file mode 100644
index 00000000..f8206376
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_fixed_bytes.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public pure returns (bytes1) {
+        bytes1 a = 0xff;
+        bytes1 b = 0xf0;
+        b |= a;
+        assert(a == b);
+
+        a |= ~b;
+        assert(a == 0); // fails
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (51-57): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (177-191): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int.sol
new file mode 100644
index 00000000..3309b5d8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int.sol
@@ -0,0 +1,22 @@
+contract C {
+	function f() public pure {
+		int8 x = 1;
+		int8 y = 0;
+		x |= y;
+		assert(x == 0); // fails
+		x = -1; y = 3;
+		x |= y;
+		assert(x == -1);
+		x = 4;
+		y |= x;
+		assert(y == 7);
+		y = 127;
+		x |= y;
+		assert(x == 127);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (81-95): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int_1.sol
new file mode 100644
index 00000000..d3fbc322
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_int_1.sol
@@ -0,0 +1,23 @@
+contract C {
+    int[1][20] c;
+    function f(bool b) public {
+	    require(c[10][0] == 0);
+        if (b)
+            c[10][0] |= 1;
+        assert(c[10][0] == 0 || c[10][0] == 1);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (76-81): CHC: Out of bounds access might happen here.
+// Warning 6368: (76-84): CHC: Out of bounds access might happen here.
+// Warning 6368: (119-124): CHC: Out of bounds access might happen here.
+// Warning 6368: (119-127): CHC: Out of bounds access might happen here.
+// Warning 6368: (149-154): CHC: Out of bounds access might happen here.
+// Warning 6368: (149-157): CHC: Out of bounds access might happen here.
+// Warning 6368: (166-171): CHC: Out of bounds access might happen here.
+// Warning 6368: (166-174): CHC: Out of bounds access might happen here.
+// Warning 6328: (142-180): CHC: Assertion violation might happen here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint.sol
new file mode 100644
index 00000000..d022f87e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f() public pure {
+        uint v = 7;
+        v |= 3;
+        assert(v != 7); // fails, as 7 | 3 = 7
+
+        uint c = 0;
+        c |= v;
+        assert(c == 7);
+
+        uint16 x = 0xff;
+        uint16 y = 0xffff;
+        y |= x;
+        assert(y == 0xff); // fails
+        assert(y == 0xffff);
+
+        y = 0xf1ff;
+        x = 0xff00;
+        x |= y & x;
+        assert(y == 0xffff); // fails
+        assert(x == 0xff00);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (88-102): CHC: Assertion violation happens here.
+// Warning 6328: (265-282): CHC: Assertion violation happens here.
+// Warning 6328: (391-410): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint_1.sol
new file mode 100644
index 00000000..f0916cf7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_or_uint_1.sol
@@ -0,0 +1,17 @@
+contract C {
+    uint[1] c;
+    function f(bool b) public {
+        require(c[0] == 0);
+        if (b)
+            c[0] |= 1;
+        assert(c[0] <= 1);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (76-80): CHC: Out of bounds access might happen here.
+// Warning 6368: (115-119): CHC: Out of bounds access might happen here.
+// Warning 6368: (141-145): CHC: Out of bounds access might happen here.
+// Warning 6328: (134-151): CHC: Assertion violation might happen here.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal.sol
new file mode 100644
index 00000000..57d47eb1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal.sol
@@ -0,0 +1,20 @@
+contract C {
+	function f() public pure {
+		bytes memory y = "def";
+		y[0] &= "d";
+		assert(y[0] == "d");
+
+		y[0] |= "e";
+		assert(y[0] == "d"); // fails
+
+		y[0] ^= "f";
+		// Disabled because of nondeterminism in Spacer in Z3 4.8.9
+		//assert(y[0] == (bytes1("d") | bytes1("e")) ^ bytes1("f"));
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (123-142): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_2.sol
new file mode 100644
index 00000000..70f9095f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_2.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f() public pure {
+        bytes3 y = "def";
+        y &= "def";
+        assert(y == "def");
+
+        y |= "dee";
+        assert(y == "def"); // fails
+
+        y ^= "fed";
+        assert(y == (bytes3("def") | bytes3("dee")) ^ bytes3("fed"));
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (147-165): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_3.sol
new file mode 100644
index 00000000..81b92965
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_string_literal_3.sol
@@ -0,0 +1,23 @@
+contract C {
+    function f() public pure {
+        bytes32 y = "abcdefghabcdefghabcdefghabcdefgh";
+        bytes32 z = y;
+        y &= "bcdefghabcdefghabcdefghabcdefgha";
+        z &= "bcdefghabcdefghabcdefghabcdefgha";
+        assert(y == "abcdefghabcdefghabcdefghabcdefgh"); // fails
+
+        y |= "cdefghabcdefghabcdefghabcdefghab";
+        z |= "cdefghabcdefghabcdefghabcdefghab";
+        assert(y == "abcdefghabcdefghabcdefghabcd"); // fails
+
+        y ^= "abcdefghabcdefghabcdefghabcdefgh";
+        assert(y == z ^ "abcdefghabcdefghabcdefghabcdefgh");
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (229-276): CHC: Assertion violation happens here.
+// Warning 6328: (394-437): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_fixed_bytes.sol
new file mode 100644
index 00000000..58902c22
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_fixed_bytes.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public pure returns (bytes1) {
+        bytes1 a = 0xff;
+        bytes1 b = 0xf0;
+        a ^= ~b;
+        assert(a == b);
+
+        a ^= ~b;
+        assert(a != 0xff); // fails
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (51-57): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (178-195): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_int.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_int.sol
new file mode 100644
index 00000000..58cb7c5b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_int.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		int8 x = 1;
+		int8 y = 0;
+		x ^= y;
+		assert(x != 1); // fails
+		x = -1; y = 1;
+		x ^= y;
+		assert(x == -2);
+		x = 4;
+		y ^= x;
+		assert(y == 5);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (81-95): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_uint.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_uint.sol
new file mode 100644
index 00000000..6d2daabb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_bitwise_xor_uint.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f() public pure {
+        uint v = 7;
+        v ^= 3;
+        assert(v != 4); // fails, as 7 ^ 3 = 4
+
+        uint c = 0;
+        c ^= v;
+        assert(c == 4);
+
+        uint16 x = 0xff;
+        uint16 y = 0xffff;
+        y ^= x;
+        assert(y == 0xff); // fails
+        assert(y == 0xff00);
+
+        y = 0xf1;
+        x = 0xff00;
+        y ^= x | y;
+        assert(y == 0xffff); // fails
+        assert(x == 0xff00);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (88-102): CHC: Assertion violation happens here.
+// Warning 6328: (265-282): CHC: Assertion violation happens here.
+// Warning 6328: (389-408): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul.sol
new file mode 100644
index 00000000..c04affe2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 10);
+		uint y = 10;
+		y *= y + x;
+		assert(y <= 190);
+		assert(y < 50);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (117-131): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_array_index.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_array_index.sol
new file mode 100644
index 00000000..18b2792d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_array_index.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint[] array;
+	function q() public { array.push(); }
+	function f(uint x, uint p) public {
+		require(p < array.length);
+		require(x < 10);
+		array[p] = 10;
+		array[p] *= array[p] + x;
+		assert(array[p] <= 190);
+		assert(array[p] < 50);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (226-247): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_mapping.sol
new file mode 100644
index 00000000..df7c9d03
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_mul_mapping.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x, uint p) public {
+		require(x < 10);
+		map[p] = 10;
+		map[p] *= map[p] + x;
+		assert(map[p] <= 190);
+		assert(map[p] < 50);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (164-183): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_shl_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_shl_1.sol
new file mode 100644
index 00000000..b2b1af4a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_shl_1.sol
@@ -0,0 +1,12 @@
+contract C {
+	function f(bool b) public pure {
+		uint v = 1000000;
+		if (b)
+			v <<= 2;
+		assert(v > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub.sol
new file mode 100644
index 00000000..bcfb3f78
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 100);
+		uint y = 200;
+		y -= y - x;
+		assert(y >= 0);
+		assert(y < 90);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (117-131): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_array_index.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_array_index.sol
new file mode 100644
index 00000000..9d44f415
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_array_index.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint[] array;
+	function q() public { array.push(); }
+	function f(uint x, uint p) public {
+		require(p < array.length);
+		require(x < 100);
+		array[p] = 200;
+		array[p] -= array[p] - x;
+		assert(array[p] >= 0);
+		assert(array[p] < 90);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (226-247): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_mapping.sol
new file mode 100644
index 00000000..b1076331
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/compound_sub_mapping.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x, uint p) public {
+		require(x < 100);
+		map[p] = 200;
+		map[p] -= map[p] - x;
+		assert(map[p] >= 0);
+		assert(map[p] < 90);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (164-183): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_2.sol
new file mode 100644
index 00000000..38dee0b2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_2.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(uint b) public pure {
+		require(b < 3);
+		uint c = (b > 0) ? b++ : ++b;
+		assert(c == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (99-113): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_3.sol
new file mode 100644
index 00000000..34763bd2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_3.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(uint a, uint b) public pure {
+		require(a < 10);
+		require(b <= a);
+
+		uint c = (b > 4) ? a++ : b++;
+		assert(c > a);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (128-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_4.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_4.sol
new file mode 100644
index 00000000..1e9b4021
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_4.sol
@@ -0,0 +1,26 @@
+abstract contract D {
+    function d() public virtual ;
+}
+
+contract C {
+    bool a;
+    uint x;
+    D d;
+    function g() public returns (uint) {
+        x = 2;
+        return x;
+    }
+    function f(bool b) public {
+        x = 1;
+        uint y = b ? g() : 3;
+        assert(x == 2 || x == 1);
+    }
+    function h() public {
+        x = 3;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2072: (240-246): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_6.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_6.sol
new file mode 100644
index 00000000..87ca405b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_6.sol
@@ -0,0 +1,28 @@
+abstract contract D {
+    function d() public virtual ;
+}
+
+contract C {
+    bool a;
+    uint x;
+    D d;
+    function g() public returns (uint) {
+        x = 2;
+        d.d();
+        return x;
+    }
+    function f(bool b) public {
+        x = 1;
+        uint y = b ? g() : 3;
+        assert(x == 2 || x == 1);
+    }
+    function h() internal {
+        x = 3;
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 2072: (255-261): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_function_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_function_2.sol
new file mode 100644
index 00000000..ebd04d04
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_function_2.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f(uint a) internal pure returns (uint b) {
+        require(a < 1000);
+        return a * a;
+    }
+    function g(uint a) internal pure returns (uint b) {
+        require(a < 1000);
+        return a + 100;
+    }
+    function h(uint a) public pure {
+        uint c = a < 5 ? g(a) : f(a);
+        assert(c >= 25);
+        assert(c < 20); // should fail
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (345-359): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_nested_always_true.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_nested_always_true.sol
new file mode 100644
index 00000000..3aa38dac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_nested_always_true.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(bool b1, bool b2) public pure {
+        require(b1 || b2);
+        uint c = b1 ? 3 : (b2 ? 2 : 1);
+        assert(c > 1);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (114-116): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_statevar_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_statevar_1.sol
new file mode 100644
index 00000000..32d5435d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/conditional_assignment_statevar_1.sol
@@ -0,0 +1,19 @@
+contract C {
+    uint a;
+    bool b;
+
+	constructor(bool _b) {
+		b = _b;
+	}
+
+    function f() public returns(uint c) {
+        c = b ? a + 10 : ++a;
+        assert(c >= a);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (143-146): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (143-146): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/const_exp_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/const_exp_1.sol
new file mode 100644
index 00000000..54d37f8b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/const_exp_1.sol
@@ -0,0 +1,16 @@
+contract C {
+	uint constant x = 2;
+	uint constant y = x ** 10;
+
+	function f() public view {
+		assert(y == 2 ** 10);
+		assert(y == 1024);
+		assert(y == 14); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2018: (65-173): Function state mutability can be restricted to pure
+// Warning 6328: (139-154): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_1.sol
new file mode 100644
index 00000000..a7dc7047
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint constant DEPOSIT_CONTRACT_TREE_DEPTH = 32;
+	uint constant MAX_DEPOSIT_COUNT = 2**DEPOSIT_CONTRACT_TREE_DEPTH - 1;
+	function f() public pure {
+		assert(DEPOSIT_CONTRACT_TREE_DEPTH == 32);
+		assert(MAX_DEPOSIT_COUNT == 4294967295);
+		assert(MAX_DEPOSIT_COUNT == 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (251-281): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_2.sol
new file mode 100644
index 00000000..a38fd31d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/constant_propagation_2.sol
@@ -0,0 +1,16 @@
+contract C {
+	uint constant x = 7;
+	uint constant y = 3;
+	uint constant z = x / y;
+
+	function f() public pure {
+		assert(z == 2);
+		assert(z == x / 3);
+		assert(z == 7 / y);
+		assert(z * 3 != 7);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_array.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array.sol
new file mode 100644
index 00000000..0fae6444
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	uint[] a;
+	function f(bool b) public {
+		a.push();
+		a.push();
+		a.push();
+		a[2] = 3;
+		require(b);
+		if (b)
+			delete a;
+		else
+			delete a[2];
+		assert(a.length == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (121-122): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_2d.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_2d.sol
new file mode 100644
index 00000000..d13e1e36
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_2d.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint[][] a;
+	constructor() {
+		a.push(); a.push(); a.push();
+		a[2].push();
+		a[2].push();
+		a[2].push();
+		a[2].push();
+	}
+	function f() public {
+		require(a[2][3] == 4);
+		delete a;
+		assert(a[2][3] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index.sol
new file mode 100644
index 00000000..a56bfed5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	uint[] a;
+	constructor() {
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+	}
+	function f(bool b) public {
+		a[2] = 3;
+		require(!b);
+		if (b)
+			delete a;
+		else
+			delete a[2];
+		assert(a[2] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (154-155): BMC: Condition is always false.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index_2d.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index_2d.sol
new file mode 100644
index 00000000..71d26090
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_index_2d.sol
@@ -0,0 +1,31 @@
+contract C
+{
+	uint[][] a;
+	constructor() {
+		init();
+	}
+	function init() internal {
+		a.push();
+		a.push();
+		a[0].push();
+		a[1].push();
+	}
+	function f(bool b) public {
+		// Removed due to Spacer's nondeterminism.
+		//a[1][1] = 512;
+		if (b)
+			delete a;
+		else
+			delete a[1];
+		init();
+		assert(a[1][0] == 0);
+		assert(a[0][0] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (315-335): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (315-335): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_push.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_push.sol
new file mode 100644
index 00000000..d65a2fdc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_array_push.sol
@@ -0,0 +1,22 @@
+contract C {
+	int[][] array2d;
+	function s() public {
+		delete array2d.push();
+		assert(array2d[array2d.length - 1].length == 0);
+		// Fails
+		assert(array2d[array2d.length - 1].length != 0);
+		delete array2d.push().push();
+		uint length = array2d.length;
+		uint length2 = array2d[length - 1].length;
+		assert(array2d[length - 1][length2 - 1] == 0);
+		// Fails
+		assert(array2d[length - 1][length2 - 1] != 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (143-190): CHC: Assertion violation happens here.
+// Warning 6328: (363-408): CHC: Assertion violation happens here.
+// Info 1391: CHC: 16 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_function.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function.sol
new file mode 100644
index 00000000..510254e8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function.sol
@@ -0,0 +1,32 @@
+contract C
+{
+	uint[] a;
+	constructor() { init(); }
+	function init() internal {
+		a.push();
+		a.push();
+		a.push();
+	}
+	function g() internal {
+		delete a;
+	}
+	function h() internal {
+		delete a[2];
+	}
+	function f(bool b) public {
+		a[2] = 3;
+		require(b);
+		if (b)
+			g();
+		else
+			h();
+		init();
+		assert(a[2] == 0);
+		assert(a[1] == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (262-263): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_1.sol
new file mode 100644
index 00000000..7df2b127
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_1.sol
@@ -0,0 +1,16 @@
+struct S {
+    function() external e;
+}
+
+contract C {
+    S s;
+    function() external f;
+
+    constructor() {
+        delete s.e;
+        assert(s.e == f); // should fail for now because function pointer comparisons are not supported
+    }
+}
+// ----
+// Warning 7229: (146-154): Assertion checker does not yet implement the type function () external for comparisons
+// Warning 6328: (139-155): CHC: Assertion violation happens here.\nCounterexample:\ns = {e: 0}, f = 0\n\nTransaction trace:\nC.constructor()
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_2.sol
new file mode 100644
index 00000000..a2168a7c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_2.sol
@@ -0,0 +1,13 @@
+contract C {
+    mapping (uint => function() external) m;
+    function() external f;
+
+    constructor() {
+        m[2] = f;
+        delete m[2];
+        assert(m[2] == f); // should fail for now because function pointer comparisons are not supported
+    }
+}
+// ----
+// Warning 7229: (160-169): Assertion checker does not yet implement the type function () external for comparisons
+// Warning 6328: (153-170): CHC: Assertion violation happens here.\nCounterexample:\nf = 0\n\nTransaction trace:\nC.constructor()
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_3.sol
new file mode 100644
index 00000000..06fd29cc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_function_type_3.sol
@@ -0,0 +1,20 @@
+contract C {
+    function() external[] arr;
+    function() external f;
+
+    constructor() {
+        arr.push();
+        arr.push();
+        arr[1] = f;
+        delete arr[1];
+        assert(arr[1] == f); // should fail for now because function pointer comparisons are not supported
+    }
+}
+// ----
+// Warning 8364: (100-108): Assertion checker does not yet implement type function (function () external[] storage pointer) returns (function () external)
+// Warning 8364: (120-128): Assertion checker does not yet implement type function (function () external[] storage pointer) returns (function () external)
+// Warning 7229: (190-201): Assertion checker does not yet implement the type function () external for comparisons
+// Warning 6368: (167-173): CHC: Out of bounds access happens here.\nCounterexample:\nf = 0\n\nTransaction trace:\nC.constructor()
+// Warning 6368: (190-196): CHC: Out of bounds access happens here.\nCounterexample:\nf = 0\n\nTransaction trace:\nC.constructor()
+// Warning 6328: (183-202): CHC: Assertion violation happens here.\nCounterexample:\narr = [14, 0], f = 0\n\nTransaction trace:\nC.constructor()
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_multid_array.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_multid_array.sol
new file mode 100644
index 00000000..53a1a253
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_multid_array.sol
@@ -0,0 +1,60 @@
+contract C {
+	uint[] a;
+	uint[][] b;
+	function p() public { a.push(); }
+	function q() public { b.push().push(); }
+	function f(uint x, uint v) public {
+		require(x < a.length);
+		a[x] = v;
+		delete a;
+		assert(a.length == 0);
+	}
+ 	function g(uint x, uint y, uint v) public {
+		require(x < b.length);
+		require(y < b[x].length);
+		b[x][y] = v;
+		delete b;
+		assert(b.length == 0);
+	}
+ 	function h(uint x, uint y, uint v) public {
+		require(x < b.length);
+		require(y < b[x].length);
+		b[x][y] = v;
+		delete b[x];
+		assert(b[x].length == 0);
+	}
+ 	function i(uint x, uint y, uint v) public {
+		require(x < b.length);
+		require(y < b[x].length);
+		b[x][y] = v;
+		require(y < b.length);
+		delete b[y];
+		assert(b[y].length == 0);
+	}
+ 	function j(uint x, uint y, uint z, uint v) public {
+		require(x < b.length);
+		require(y < b[x].length);
+		b[x][y] = v;
+		require(z < b.length);
+		delete b[z];
+		// Not necessarily the case.
+		require(y < b.length);
+		require(x < b[x].length);
+		// Disabled because of Spacer nondeterminism.
+		//assert(b[y][x] == 0);
+	}
+	function setA(uint x, uint y) public {
+		require(x < a.length);
+		a[x] = y;
+	}
+	function setB(uint x, uint y, uint z) public {
+		require(x < b.length);
+		require(y < b[x].length);
+		b[x][y] = z;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Info 1391: CHC: 27 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_struct.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_struct.sol
new file mode 100644
index 00000000..76338a0a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_struct.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	struct S
+	{
+		uint x;
+	}
+	function f(bool b) public pure {
+		S memory s;
+		s.x = 2;
+		if (b)
+			delete s;
+		else
+			delete s.x;
+		assert(s.x == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/delete_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/operators/delete_tuple.sol
new file mode 100644
index 00000000..19251978
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/delete_tuple.sol
@@ -0,0 +1,9 @@
+contract A{
+	function f() public pure {
+		delete ([""][0]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_2.sol
new file mode 100644
index 00000000..8704c665
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_2.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(uint x, uint y) public pure returns (uint) {
+		require(y != 0);
+		return x / y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_3.sol
new file mode 100644
index 00000000..af4ed582
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_3.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure returns (int) {
+		require(y != 0);
+		return x / y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (95-100): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_4.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_4.sol
new file mode 100644
index 00000000..54403b1e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_4.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure returns (int) {
+		require(y != 0);
+		require(y != -1);
+		return x / y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_6.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_6.sol
new file mode 100644
index 00000000..69d4ee58
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_6.sol
@@ -0,0 +1,16 @@
+contract C {
+	function mul(uint8 a, uint8 b) public pure returns (uint8) {
+		if (a == 0) {
+			return 0;
+		}
+		uint8 c = a * b;
+		require(c / a == b);
+		return c;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (120-125): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (137-147): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_1.sol
new file mode 100644
index 00000000..5d3725f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_1.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(uint x, uint y) public pure {
+		x = 7;
+		y = 2;
+		assert(x / y == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_2.sol
new file mode 100644
index 00000000..29af565a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_2.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure {
+		x = 7;
+		y = 2;
+		assert(x / y == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_3.sol
new file mode 100644
index 00000000..573f6d24
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_3.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure {
+		x = -7;
+		y = 2;
+		assert(x / y == -3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_4.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_4.sol
new file mode 100644
index 00000000..6610bc52
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_4.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure {
+		x = 7;
+		y = -2;
+		assert(x / y == -3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_5.sol b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_5.sol
new file mode 100644
index 00000000..97faba60
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/division_truncates_correctly_5.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f(int x, int y) public pure {
+		x = -7;
+		y = -2;
+		assert(x / y == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/function_call_named_arguments.sol b/compiler/test/libsolidity/smtCheckerTests/operators/function_call_named_arguments.sol
new file mode 100644
index 00000000..d925ca44
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/function_call_named_arguments.sol
@@ -0,0 +1,34 @@
+library L {
+	function l(uint x, uint y) internal pure returns (uint) {
+		return x + y;
+	}
+}
+
+contract C {
+	function f(uint u, uint s, bool b) internal pure returns (uint z) {
+		if (b)
+			z = u;
+		else
+			z = s;
+	}
+
+	using L for uint;
+
+	function call() public pure {
+		uint a = 2;
+		uint b = a.l({y: 3});
+		assert(b == 5);
+		b = L.l({x: 3, y: 3});
+		assert(b == 6);
+		b = f({b: true, u: 1, s: 2});
+		assert(b == 1);
+		b = f({b: false, u: 1, s: 2});
+		// Fails, should be 2.
+		assert(b == 6);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (475-489): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytes.sol
new file mode 100644
index 00000000..71dac3e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytes.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        bytes memory x = hex"00112233";
+        assert(x[0] == 0x00);
+        assert(x[1] == 0x11);
+        assert(x.length == 3);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (152-173): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytesNN.sol b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytesNN.sol
new file mode 100644
index 00000000..c516675d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_bytesNN.sol
@@ -0,0 +1,12 @@
+contract C {
+    bytes20 x;
+    function f(bytes16 b) public view {
+        b[uint8(x[2])];
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (76-90): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_string.sol b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_string.sol
new file mode 100644
index 00000000..535335de
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_for_string.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        string memory x = "\x12\x34";
+        bytes memory y = bytes(x);
+        assert(y[0] == 0x12);
+        assert(y[1] == 0x34);
+        assert(y.length == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/index_access_side_effect.sol b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_side_effect.sol
new file mode 100644
index 00000000..32c9780d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/index_access_side_effect.sol
@@ -0,0 +1,26 @@
+contract C {
+	uint[] a;
+	constructor() {
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+	}
+	// Accesses are safe but oob is reported due to aliasing.
+	function h() internal returns (uint[] storage) {
+		if (a[2] == 0)
+			a[2] = 3;
+		return a;
+	}
+	function g() public {
+		// Disabled because of Spacer nondeterminism.
+		//h()[2] = 4;
+		assert(h()[2] == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/integer_new.sol b/compiler/test/libsolidity/smtCheckerTests/operators/integer_new.sol
new file mode 100644
index 00000000..d85fb407
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/integer_new.sol
@@ -0,0 +1,39 @@
+contract C {
+	function f() public pure {
+		uint[] memory x = new uint[](0);
+		assert(x.length == 0);
+	}
+	function g() public pure {
+		uint[] memory x = new uint[](3);
+		assert(x.length == 3);
+		assert(x[0] == 0);
+		assert(x[1] == 0);
+		assert(x[2] == 0);
+	}
+	function h() public pure {
+		uint[] memory x = new uint[](3);
+		assert(x.length == 3);
+		x[0] = 0x12;
+		x[1] = 0x34;
+		assert(x[0] == 0x12);
+		assert(x[1] == 0x34);
+		// This should be an out-of-bounds assertion.
+		x[5] = 0xff;
+		assert(x[5] == 0xff);
+	}
+	function h(uint size) public pure {
+		uint[] memory x = new uint[](size);
+		assert(x.length == size);
+		require(size >= 2);
+		x[0] = 0x12;
+		x[1] = 0x34;
+		assert(x[0] == 0x12);
+		assert(x[1] == 0x34);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (474-478): CHC: Out of bounds access happens here.
+// Warning 6368: (496-500): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 23 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/mod.sol b/compiler/test/libsolidity/smtCheckerTests/operators/mod.sol
new file mode 100644
index 00000000..a600ef03
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/mod.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(int x, int y) public pure {
+		require(y == -10);
+		require(x == 100);
+		int z1 = x % y;
+		int z2 = x % -y;
+		assert(z1 == z2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/mod_even.sol b/compiler/test/libsolidity/smtCheckerTests/operators/mod_even.sol
new file mode 100644
index 00000000..b6195bac
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/mod_even.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(uint x) public pure {
+		require(x < 10000);
+		uint y = x * 2;
+		assert((y % 2) == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/mod_n.sol b/compiler/test/libsolidity/smtCheckerTests/operators/mod_n.sol
new file mode 100644
index 00000000..a9b0b464
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/mod_n.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(uint x, uint y) public pure {
+		require(y > 0);
+		uint z = x % y;
+		assert(z < y);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/mod_n_uint16.sol b/compiler/test/libsolidity/smtCheckerTests/operators/mod_n_uint16.sol
new file mode 100644
index 00000000..a45fd3ef
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/mod_n_uint16.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(uint16 x, uint16 y) public pure {
+		require(y > 0);
+		uint z = x % y;
+		assert(z < 100_000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/mod_signed.sol b/compiler/test/libsolidity/smtCheckerTests/operators/mod_signed.sol
new file mode 100644
index 00000000..2e640f53
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/mod_signed.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f(int x, int y) public pure {
+		require(y != 0);
+		require(x == 42);
+		int z1 = x % y;
+		int z2 = -x % y;
+		assert(z1 == -z2);
+		assert((x >= 0 && z1 >=0) || (x <= 0 && z1 <= 0));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (131-148): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_left.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_left.sol
new file mode 100644
index 00000000..f5313726
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_left.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f(uint256 a, uint256 b) internal pure returns (uint256) {
+        a <<= b;
+        return a;
+    }
+    function t() public pure {
+        assert(f(0x4266, 0x0) == 0x4266);
+        assert(f(0x4266, 0x8) == 0x426600);
+        assert(f(0x4266, 0xf0) == 0x4266000000000000000000000000000000000000000000000000000000000000);
+        assert(f(0x4266, 0x4266) == 0);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_right.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_right.sol
new file mode 100644
index 00000000..d566bf24
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/compound_shift_right.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f(uint256 a, uint256 b) internal pure returns (uint256) {
+        a >>= b;
+        return a;
+    }
+    function t() public pure {
+        assert(f(0x4266, 0) == 0x4266);
+        assert(f(0x4266, 0x8) == 0x42);
+        assert(f(0x4266, 0x11) == 0);
+        assert(f(57896044618658097711785492504343953926634992332820282019728792003956564819968, 5) == 1809251394333065553493296640760748560207343510400633813116524750123642650624);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cex.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cex.sol
new file mode 100644
index 00000000..8670b79c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cex.sol
@@ -0,0 +1,22 @@
+contract C {
+	function left() public pure {
+		uint x = 0x4266;
+		assert(x << 0x0 == 0x4266);
+		// Fails because the above is true.
+		assert(x << 0x0 == 0x4268);
+	}
+
+	function right() public pure {
+		uint x = 0x4266;
+		assert(x >> 0x0 == 0x4266);
+		// Fails because the above is true.
+		assert(x >> 0x0 == 0x4268);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (133-159): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 16998\n\nTransaction trace:\nC.constructor()\nC.left()
+// Warning 6328: (286-312): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 16998\n\nTransaction trace:\nC.constructor()\nC.right()
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cleanup.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cleanup.sol
new file mode 100644
index 00000000..14ae9f72
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_cleanup.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure returns (uint16 x) {
+		unchecked {
+			x = 0xffff;
+			x += 32;
+			x = x << 8;
+			x = x >> 16;
+		}
+		assert(x == 0);
+		// Fails because x = 0.
+		assert(x == 10);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (182-197): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left.sol
new file mode 100644
index 00000000..ac8a961f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a << b;
+    }
+	function t() public pure {
+		assert(f(0x4266, 0x0) == 0x4266);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x0) == 0x4268);
+
+		assert(f(0x4266, 0x8) == 0x426600);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x8) == 0x120939);
+
+		assert(f(0x4266, 0xf0) == 0x4266000000000000000000000000000000000000000000000000000000000000);
+		// Fails because the above is true.
+		assert(f(0x4266, 0xf0) == 0x4266000000000000000000000000000000000000000000000000000000000001);
+
+		assert(f(0x4266, 0x4266) == 0);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x4266) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (217-249): CHC: Assertion violation happens here.
+// Warning 6328: (330-364): CHC: Assertion violation happens here.
+// Warning 6328: (504-597): CHC: Assertion violation happens here.
+// Warning 6328: (674-704): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_larger_type.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_larger_type.sol
new file mode 100644
index 00000000..0867aa4c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_larger_type.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f() public pure returns (int8) {
+		uint8 x = 254;
+		int8 y = 1;
+		assert(y << x == 0);
+		// Fails because z = 0.
+		assert(y << x == 10);
+		return y << x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (138-158): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint32.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint32.sol
new file mode 100644
index 00000000..7e0128dc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint32.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f(uint32 a, uint32 b) internal pure returns (uint256) {
+        return a << b;
+    }
+	function t() public pure {
+		assert(f(0x4266, 0) == 0x4266);
+		// Fails because the above is true.
+		assert(f(0x4266, 0) == 0x4267);
+
+		assert(f(0x4266, 0x10) == 0x42660000);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x10) == 0x426600000);
+
+		assert(f(0x4266, 0x11) == 0x84cc0000);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x11) == 0x84cc000);
+
+		assert(f(0x4266, 0x20) == 0);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x20) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (213-243): CHC: Assertion violation happens here.
+// Warning 6328: (327-365): CHC: Assertion violation happens here.
+// Warning 6328: (449-485): CHC: Assertion violation happens here.
+// Warning 6328: (560-588): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint8.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint8.sol
new file mode 100644
index 00000000..bbbea4ef
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_left_uint8.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(uint8 a, uint8 b) internal pure returns (uint256) {
+        return a << b;
+    }
+	function t() public pure {
+		assert(f(0x66, 0x0) == 0x66);
+		// Fails because the above is true.
+		assert(f(0x66, 0x0) == 0x660);
+
+		assert(f(0x66, 0x8) == 0);
+		// Fails because the above is true.
+		assert(f(0x66, 0x8) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (209-238): CHC: Assertion violation happens here.
+// Warning 6328: (310-335): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_overflow.sol
new file mode 100644
index 00000000..efe69945
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_overflow.sol
@@ -0,0 +1,40 @@
+contract C {
+    function leftU(uint8 x, uint8 y) internal pure returns (uint8) {
+        return x << y;
+    }
+
+    function leftS(int8 x, uint8 y) internal pure returns (int8) {
+        return x << y;
+    }
+
+	function t() public pure {
+		assert(leftU(255, 8) == 0);
+		// Fails because the above is true.
+		assert(leftU(255, 8) == 1);
+
+		assert(leftU(255, 1) == 254);
+		// Fails because the above is true.
+		assert(leftU(255, 1) == 255);
+
+		assert(leftU(255, 0) == 255);
+		// Fails because the above is true.
+		assert(leftU(255, 0) == 0);
+
+		assert(leftS(1, 7) == -128);
+		// Fails because the above is true.
+		assert(leftS(1, 7) == 127);
+
+		assert(leftS(1, 6) == 64);
+		// Fails because the above is true.
+		assert(leftS(1, 6) == -64);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (307-333): CHC: Assertion violation happens here.
+// Warning 6328: (408-436): CHC: Assertion violation happens here.
+// Warning 6328: (511-537): CHC: Assertion violation happens here.
+// Warning 6328: (611-637): CHC: Assertion violation happens here.
+// Warning 6328: (709-735): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right.sol
new file mode 100644
index 00000000..6d893efc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(0x4266, 0) == 0x4266);
+		// Fails because the above is true.
+		assert(f(0x4266, 0) == 0x426);
+
+		assert(f(0x4266, 0x8) == 0x42);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x8) == 0x420);
+
+		assert(f(0x4266, 0x11) == 0);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x11) == 1);
+
+		assert(f(57896044618658097711785492504343953926634992332820282019728792003956564819968, 5) == 1809251394333065553493296640760748560207343510400633813116524750123642650624);
+		// Fails because the above is true.
+		assert(f(57896044618658097711785492504343953926634992332820282019728792003956564819968, 5) == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (215-244): CHC: Assertion violation happens here.
+// Warning 6328: (321-352): CHC: Assertion violation happens here.
+// Warning 6328: (427-455): CHC: Assertion violation happens here.
+// Warning 6328: (673-769): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_literal.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_literal.sol
new file mode 100644
index 00000000..61de9aa4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_literal.sol
@@ -0,0 +1,41 @@
+contract C {
+	function f(int16 x, uint16 y, int16 z) internal pure returns (bool) {
+		return x >> y == z;
+	}
+
+	function t() public pure {
+		assert(f(-4266, 0, -4266));
+		// Fails because the above is true.
+		assert(f(-4266, 0, -426));
+
+		assert(f(-4266, 1, -2133));
+		// Fails because the above is true.
+		assert(f(-4266, 1, -2134));
+
+		assert(f(-4266, 4, -267));
+		// Fails because the above is true.
+		assert(f(-4266, 4, -2670));
+
+		assert(f(-4266, 8, -17));
+		// Fails because the above is true.
+		assert(f(-4266, 8, -1));
+
+		assert(f(-4266, 16, -1));
+		// Fails because the above is true.
+		assert(f(-4266, 16, -0));
+
+		assert(f(-4266, 17, -1));
+		// Fails because the above is true.
+		assert(f(-4266, 17, -0));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (208-233): CHC: Assertion violation happens here.
+// Warning 6328: (306-332): CHC: Assertion violation happens here.
+// Warning 6328: (404-430): CHC: Assertion violation happens here.
+// Warning 6328: (501-524): CHC: Assertion violation happens here.
+// Warning 6328: (595-619): CHC: Assertion violation happens here.
+// Warning 6328: (690-714): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue.sol
new file mode 100644
index 00000000..773a77bc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue.sol
@@ -0,0 +1,41 @@
+contract C {
+    function f(int256 a, uint256 b) internal pure returns (int256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(-4266, 0) == -4266);
+		// Fails because the above is true.
+		assert(f(-4266, 0) == -426);
+
+		assert(f(-4266, 1) == -2133);
+		// Fails because the above is true.
+		assert(f(-4266, 1) == -21330);
+
+		assert(f(-4266, 4) == -267);
+		// Fails because the above is true.
+		assert(f(-4266, 4) == -255);
+
+		assert(f(-4266, 8) == -17);
+		// Fails because the above is true.
+		assert(f(-4266, 8) == -1);
+
+		assert(f(-4266, 16) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 16) == 0);
+
+		assert(f(-4266, 17) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 17) == 0);
+	}
+
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (211-238): CHC: Assertion violation happens here.
+// Warning 6328: (313-342): CHC: Assertion violation happens here.
+// Warning 6328: (416-443): CHC: Assertion violation happens here.
+// Warning 6328: (516-541): CHC: Assertion violation happens here.
+// Warning 6328: (614-639): CHC: Assertion violation happens here.
+// Warning 6328: (712-737): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int16.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int16.sol
new file mode 100644
index 00000000..043a640a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int16.sol
@@ -0,0 +1,40 @@
+contract C {
+    function f(int16 a, uint16 b) internal pure returns (int256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(-4266, 0) == -4266);
+		// Fails because the above is true.
+		assert(f(-4266, 0) == -426);
+
+		assert(f(-4266, 1) == -2133);
+		// Fails because the above is true.
+		assert(f(-4266, 1) == -21330);
+
+		assert(f(-4266, 4) == -267);
+		// Fails because the above is true.
+		assert(f(-4266, 4) == -255);
+
+		assert(f(-4266, 8) == -17);
+		// Fails because the above is true.
+		assert(f(-4266, 8) == -1);
+
+		assert(f(-4266, 16) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 16) == 0);
+
+		assert(f(-4266, 17) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 17) == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (209-236): CHC: Assertion violation happens here.
+// Warning 6328: (311-340): CHC: Assertion violation happens here.
+// Warning 6328: (414-441): CHC: Assertion violation happens here.
+// Warning 6328: (514-539): CHC: Assertion violation happens here.
+// Warning 6328: (612-637): CHC: Assertion violation happens here.
+// Warning 6328: (710-735): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int32.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int32.sol
new file mode 100644
index 00000000..94b212a6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int32.sol
@@ -0,0 +1,40 @@
+contract C {
+    function f(int32 a, uint32 b) internal pure returns (int256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(-4266, 0) == -4266);
+		// Fails because the above is true.
+		assert(f(-4266, 0) == -426);
+
+		assert(f(-4266, 1) == -2133);
+		// Fails because the above is true.
+		assert(f(-4266, 1) == -21330);
+
+		assert(f(-4266, 4) == -267);
+		// Fails because the above is true.
+		assert(f(-4266, 4) == -255);
+
+		assert(f(-4266, 8) == -17);
+		// Fails because the above is true.
+		assert(f(-4266, 8) == -1);
+
+		assert(f(-4266, 16) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 16) == 0);
+
+		assert(f(-4266, 17) == -1);
+		// Fails because the above is true.
+		assert(f(-4266, 17) == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (209-236): CHC: Assertion violation happens here.
+// Warning 6328: (311-340): CHC: Assertion violation happens here.
+// Warning 6328: (414-441): CHC: Assertion violation happens here.
+// Warning 6328: (514-539): CHC: Assertion violation happens here.
+// Warning 6328: (612-637): CHC: Assertion violation happens here.
+// Warning 6328: (710-735): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int8.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int8.sol
new file mode 100644
index 00000000..400f26cf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_negative_lvalue_int8.sol
@@ -0,0 +1,40 @@
+contract C {
+    function f(int8 a, uint8 b) internal pure returns (int256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(-66, 0) == -66);
+		// Fails because the above is true.
+		assert(f(-66, 0) == -6);
+
+		assert(f(-66, 1) == -33);
+		// Fails because the above is true.
+		assert(f(-66, 1) == -3);
+
+		assert(f(-66, 4) == -5);
+		// Fails because the above is true.
+		assert(f(-66, 4) == -2);
+
+		assert(f(-66, 8) == -1);
+		// Fails because the above is true.
+		assert(f(-66, 8) == -2);
+
+		assert(f(-66, 16) == -1);
+		// Fails because the above is true.
+		assert(f(-66, 16) == 0);
+
+		assert(f(-66, 17) == -1);
+		// Fails because the above is true.
+		assert(f(-66, 17) == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (203-226): CHC: Assertion violation happens here.
+// Warning 6328: (297-320): CHC: Assertion violation happens here.
+// Warning 6328: (390-413): CHC: Assertion violation happens here.
+// Warning 6328: (483-506): CHC: Assertion violation happens here.
+// Warning 6328: (577-600): CHC: Assertion violation happens here.
+// Warning 6328: (671-694): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint32.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint32.sol
new file mode 100644
index 00000000..9e68e22e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint32.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f(uint32 a, uint32 b) internal pure returns (uint256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(0x4266, 0) == 0x4266);
+		// Fails because the above is true.
+		assert(f(0x4266, 0) == 0x426);
+
+		assert(f(0x4266, 8) == 0x42);
+		// Fails because the above is true.
+		assert(f(0x4266, 8) == 0x420);
+
+		assert(f(0x4266, 0x10) == 0);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x10) == 255);
+
+		assert(f(0x4266, 0x11) == 0);
+		// Fails because the above is true.
+		assert(f(0x4266, 0x11) == 255);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (213-242): CHC: Assertion violation happens here.
+// Warning 6328: (317-346): CHC: Assertion violation happens here.
+// Warning 6328: (421-451): CHC: Assertion violation happens here.
+// Warning 6328: (526-556): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint8.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint8.sol
new file mode 100644
index 00000000..864a760e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_right_uint8.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f(uint8 a, uint8 b) internal pure returns (uint256) {
+        return a >> b;
+    }
+	function t() public pure {
+		assert(f(0x66, 0) == 0x66);
+		// Fails because the above is true.
+		assert(f(0x66, 0) == 0x6);
+
+		assert(f(0x66, 8) == 0);
+		// Fails because the above is true.
+		assert(f(0x66, 8) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (207-232): CHC: Assertion violation happens here.
+// Warning 6328: (302-325): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_underflow_negative_rvalue.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_underflow_negative_rvalue.sol
new file mode 100644
index 00000000..d02e1440
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shift_underflow_negative_rvalue.sol
@@ -0,0 +1,25 @@
+contract C {
+    function f(int256 a, uint256 b) internal pure returns (int256) {
+        return a << b;
+    }
+
+    function g(int256 a, uint256 b) internal pure returns (int256) {
+        return a >> b;
+    }
+
+	function t() public pure {
+		assert(f(1, 2**256 - 1) == 0);
+		// Fails because the above is true.
+		assert(f(1, 2**256 - 1) == 1);
+
+		assert(g(1, 2**256 - 1) == 0);
+		// Fails because the above is true.
+		assert(g(1, 2**256 - 1) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (312-341): CHC: Assertion violation happens here.
+// Warning 6328: (417-446): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shr_unused.sol b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shr_unused.sol
new file mode 100644
index 00000000..8f34b530
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/shifts/shr_unused.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f() public pure {
+		fixed x;
+		assert(x >>> 6 == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// UnimplementedFeatureError: Not yet implemented - FixedPointType.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/slice.sol b/compiler/test/libsolidity/smtCheckerTests/operators/slice.sol
new file mode 100644
index 00000000..29f89295
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/slice.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(bytes calldata b) external pure {
+		require(b.length > 10);
+		require(b[10] == 0xff);
+		assert(bytes(b[10:20]).length == 10);
+		// Disabled because of Spacer nondeterminism
+		//assert(bytes(b[10:20])[0] == 0xff);
+		// Disabled because of Spacer nondeterminism
+		//assert(bytes(b[10:20])[5] == 0xff);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/slice_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/operators/slice_bytes.sol
new file mode 100644
index 00000000..8c8c9536
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/slice_bytes.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(bytes calldata b) external pure {
+		require(b.length > 10);
+		((b[:])[5]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_end.sol b/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_end.sol
new file mode 100644
index 00000000..b017b7ff
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_end.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f(bytes calldata b) external pure {
+		require(b.length == 30);
+		require(b[10] == 0xff);
+		require(b[b.length - 1] == 0xaa);
+		assert(bytes(b[10:]).length == 20); // should hold
+		// Disabled because of Spacer's nondeterminism.
+		//assert(bytes(b[10:])[0] == 0xff); // should hold
+		//assert(bytes(b[10:])[5] == 0xff); // Removed because of Spacer's nondeterminism
+		//assert(bytes(b[10:])[19] == 0xaa); // Removed because of Spacer nondeterminism
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_start.sol b/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_start.sol
new file mode 100644
index 00000000..ef422245
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/slice_default_start.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(bytes calldata b) external pure {
+		require(b.length > 20);
+		require(b[0] == 0xff);
+		assert(bytes(b[:20]).length == 20);
+		assert(bytes(b[:20])[0] == 0xff);
+		assert(bytes(b[:20])[5] == 0xff);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (150-182): CHC: Assertion violation might happen here.
+// Warning 6328: (186-218): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (150-182): BMC: Assertion violation happens here.
+// Warning 4661: (186-218): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/slices_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/slices_3.sol
new file mode 100644
index 00000000..530b870c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/slices_3.sol
@@ -0,0 +1,17 @@
+contract C {
+int[] s;
+function f(int[] calldata b, uint256 start, uint256 end) public returns (int) {
+    s = b[start:end];
+    uint len = end - start;
+    assert(len == s.length);
+    for (uint i = 0; i < len; i++) {
+        // Removed because of Spacer nondeterminism.
+        //assert(b[start:end][i] == s[i]);
+    }
+    return s[0];
+}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_1.sol
new file mode 100644
index 00000000..ce475d91
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_1.sol
@@ -0,0 +1,9 @@
+contract C {
+	function f(uint x) public pure returns (uint) {
+		return x > 0 ? x - 1 : 0; // Underflow cannot happen
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_2.sol
new file mode 100644
index 00000000..3f2e42ef
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_2.sol
@@ -0,0 +1,14 @@
+contract C {
+
+	function decrement(uint x) private pure returns (uint) {
+		return x - 1; // No underflow, the method can be called only with positive value
+	}
+
+	function f(uint x) public pure returns (uint) {
+		return x > 0 ? decrement(x) : 0;
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_3.sol
new file mode 100644
index 00000000..dac62d38
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_3.sol
@@ -0,0 +1,31 @@
+abstract contract D {
+	function d() external virtual returns (uint);
+}
+
+contract C {
+
+	D d;
+	uint v;
+	bool guard = true;
+
+	function inc() public {
+		++v;
+	}
+
+	function dec() public {
+		if (guard) return;
+		--v;
+	}
+
+	function f() public returns (uint) {
+		guard = false;
+		uint ret = v > 0 ? d.d() : 0;
+		guard = true;
+		return ret;
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTTargets: underflow
+// ----
+// Warning 3944: (206-209): CHC: Underflow (resulting value less than 0) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_double_function_call.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_double_function_call.sol
new file mode 100644
index 00000000..96d00ff6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_double_function_call.sol
@@ -0,0 +1,4 @@
+contract C { function decrement(uint x) private pure returns (uint) { return x - 1; } function decrement2(uint x) private pure returns (uint) { return x - 1; } function f(uint x) public pure returns (uint) { return x > 0 ? decrement(x) : decrement2(x); } }
+// ----
+// Warning 3944: (151-156): CHC: Underflow (resulting value less than 0) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_external_code_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_external_code_1.sol
new file mode 100644
index 00000000..7da04b46
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_external_code_1.sol
@@ -0,0 +1,32 @@
+abstract contract D {
+	function d() external virtual returns (uint);
+}
+
+contract C {
+
+	D d;
+	uint v;
+	bool guard = true;
+
+	function inc() public {
+		++v;
+	}
+
+	function dec() public {
+		if (guard) return;
+		--v;
+		guard = true;
+	}
+
+	function f() public returns (uint) {
+		guard = false;
+		uint ret = v > 0 ? d.d() : 0;
+		guard = true;
+		return ret;
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTTargets: underflow
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_1.sol
new file mode 100644
index 00000000..d2722fc0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_1.sol
@@ -0,0 +1,15 @@
+contract C {
+
+	function unreachable() private pure returns (uint) {
+		assert(false);
+		return 0;
+	}
+
+	function f(uint x) public pure returns (uint) {
+		return x <= 1 ? 0 : x < 2 ? unreachable() : 0;
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_2.sol
new file mode 100644
index 00000000..71e294fb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_2.sol
@@ -0,0 +1,27 @@
+contract C {
+
+	function decrement(uint x) private pure returns (uint) {
+		return x - 1;
+	}
+
+	function decrement2(uint x) private pure returns (uint) {
+		return x - 1;
+	}
+
+	function increment(uint x) private pure returns (uint) {
+		return x + 1;
+	}
+
+	function increment2(uint x) private pure returns (uint) {
+		return x + 1;
+	}
+
+	function f(uint x) public pure returns (uint) {
+		return x < 10 ? (x > 0 ? decrement(x) : increment(x)) : (x > 100 ? increment2(x) : decrement2(x));
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Warning 4984: (317-322): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_3.sol
new file mode 100644
index 00000000..0638e483
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_3.sol
@@ -0,0 +1,19 @@
+contract C {
+
+	function increment(uint x) private pure returns (uint) {
+		return x + 1;
+	}
+
+	function increment2(uint x) private pure returns (uint) {
+		return x + 1;
+	}
+
+	function f(uint x) public pure returns (uint) {
+		return x < 10 ? (x > 0 ? 0 : increment(x)) : (x > 100 ? increment2(x) : 0);
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Warning 4984: (160-165): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_4.sol b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_4.sol
new file mode 100644
index 00000000..29559022
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/ternary_operator_nested_4.sol
@@ -0,0 +1,24 @@
+contract C {
+
+	uint s = 1;
+
+	function decrement() private returns (uint) {
+		return --s;
+	}
+
+	function increment() private returns (uint) {
+		return ++s;
+	}
+
+	function f(uint x) public returns (uint) {
+		require(s > 0 && s < 10);
+		uint olds = s;
+		uint ret = x < 1 ? increment() : decrement();
+		assert(s != olds);
+		return ret;
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/tuple_rationals_conditional.sol b/compiler/test/libsolidity/smtCheckerTests/operators/tuple_rationals_conditional.sol
new file mode 100644
index 00000000..c5732293
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/tuple_rationals_conditional.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(bool x) public pure {
+		(uint a, uint b) = x ? (10000000001, 2) : (3, 4);
+		assert(a != 0);
+		assert(b != 0);
+		assert(a % 2 == 1);
+		assert(b % 2 == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add.sol
new file mode 100644
index 00000000..571cd666
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() public pure {
+		uint x = 2;
+		uint a = ++x;
+		assert(x == 3);
+		assert(a == 3);
+		uint b = x++;
+		assert(x == 4);
+		// Should fail.
+		assert(b < 3);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (161-174): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 4\na = 3\nb = 3\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array.sol
new file mode 100644
index 00000000..a45a5b98
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array.sol
@@ -0,0 +1,24 @@
+contract C
+{
+	uint[] array;
+	function p() public {
+		array.push();
+	}
+	function f(uint x) public {
+		require(x < array.length);
+		array[x] = 2;
+		uint a = ++array[x];
+		assert(array[x] == 3);
+		assert(a == 3);
+		uint b = array[x]++;
+		assert(array[x] == 4);
+		// Should fail.
+		assert(b < 3);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (278-291): CHC: Assertion violation happens here.
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_1.sol
new file mode 100644
index 00000000..4617fa91
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_1.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint[] x;
+	function f() public {
+		require(x.length == 0);
+		++x.push();
+		assert(x.length == 1);
+		assert(x[0] == 1); // should hold
+		assert(x[0] == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (150-168): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_2.sol
new file mode 100644
index 00000000..a6cacac0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_array_push_2.sol
@@ -0,0 +1,21 @@
+contract C {
+	struct S {
+		int[][] d;
+	}
+	S[] data;
+	constructor() {
+		data.push();
+		data.push();
+		data[1].d.push();
+		data[1].d.push();
+		data[1].d.push();
+		data[1].d.push();
+	}
+	function f() public {
+		++data[1].d[3].push();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_mapping.sol
new file mode 100644
index 00000000..5b208787
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_mapping.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x) public {
+		map[x] = 2;
+		uint a = ++map[x];
+		assert(map[x] == 3);
+		assert(a == 3);
+		uint b = map[x]++;
+		assert(map[x] == 4);
+		// Should fail.
+		assert(b < 3);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (211-224): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly.sol
new file mode 100644
index 00000000..f1d57fa9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint8 x = 254;
+
+	function inc_pre() public {
+		++x;
+	}
+
+	function check() view public {
+		uint y = x;
+		assert(y < 256);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (61-64): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly_struct.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly_struct.sol
new file mode 100644
index 00000000..12687d9e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_add_overflows_correctly_struct.sol
@@ -0,0 +1,25 @@
+contract C {
+	struct S {
+		uint8 x;
+	}
+
+	S s;
+
+	constructor() {
+		s.x = 254;
+	}
+
+	function inc_pre() public {
+		++s.x;
+	}
+
+	function check() view public {
+		uint y = s.x;
+		assert(y < 256);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (112-117): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_1.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_1.sol
new file mode 100644
index 00000000..72b29230
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bool b) public pure {
+		uint x;
+		if (b) ++(x);
+		if (b) --(x);
+		if (b) delete(b);
+		assert(x == 0);
+		assert(!b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_2.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_2.sol
new file mode 100644
index 00000000..e61109c3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_2.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bool b) public pure {
+		uint x;
+		if (b) ++((((((x))))));
+		if (b) --((((((x))))));
+		if (b) delete((((((b))))));
+		assert(x == 0);
+		assert(!b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_3.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_3.sol
new file mode 100644
index 00000000..bef3d128
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_operators_tuple_3.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bool b) public pure {
+		uint x;
+		if (b) ++(x);
+		else x += 1;
+		assert(x == 1);
+		assert(!b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (108-118): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub.sol
new file mode 100644
index 00000000..86ec9806
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() public pure {
+		uint x = 5;
+		uint a = --x;
+		assert(x == 4);
+		assert(a == 4);
+		uint b = x--;
+		assert(x == 3);
+		// Should fail.
+		assert(b > 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (161-174): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 3\na = 4\nb = 4\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_array.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_array.sol
new file mode 100644
index 00000000..f0cfe36c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_array.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	uint[] array;
+	function p() public { array.push(); }
+	function f(uint x) public {
+		require(x < array.length);
+		array[x] = 5;
+		uint a = --array[x];
+		assert(array[x] == 4);
+		assert(a == 4);
+		uint b = array[x]--;
+		assert(array[x] == 3);
+		// Should fail.
+		assert(b > 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (275-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_mapping.sol
new file mode 100644
index 00000000..20f2c838
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/unary_sub_mapping.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x) public {
+		map[x] = 5;
+		uint a = --map[x];
+		assert(map[x] == 4);
+		assert(a == 4);
+		uint b = map[x]--;
+		assert(map[x] == 3);
+		// Should fail.
+		assert(b > 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (211-224): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_same_as_builtin.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_same_as_builtin.sol
new file mode 100644
index 00000000..1e94e41d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_same_as_builtin.sol
@@ -0,0 +1,16 @@
+type U is uint;
+using {div as /} for U global;
+
+function div(U x, U y) pure returns (U) {
+    return U.wrap(U.unwrap(x) / U.unwrap(y)); // detects division by zero
+}
+
+contract C {
+    function f(U x, U y) public pure returns (U) {
+        return x / y; // reports division by zero in the implementation
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4281: (108-133): CHC: Division by zero happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_with_safe_division_by_zero.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_with_safe_division_by_zero.sol
new file mode 100644
index 00000000..8f8e6c53
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_division_with_safe_division_by_zero.sol
@@ -0,0 +1,19 @@
+type U is uint;
+using {div as /} for U global;
+
+function div(U x, U y) pure returns (U) {
+    if (U.unwrap(y) == 0)
+        return U.wrap(0);
+
+    return U.wrap(U.unwrap(x) / U.unwrap(y));
+}
+
+contract C {
+    function f(U x, U y) public pure returns (U) {
+        return x / y; // no div by zero possible here
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants.sol
new file mode 100644
index 00000000..c39360b6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants.sol
@@ -0,0 +1,64 @@
+type I16 is int16;
+using {
+    bitor as |, bitand as &, bitxor as ^, bitnot as ~,
+    add as +, sub as -, unsub as -, mul as *, div as /, mod as %,
+    eq as ==, noteq as !=, lt as <, gt as >, leq as <=, geq as >=
+} for I16 global;
+
+function bitor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) | I16.unwrap(y)); }
+function bitand(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) & I16.unwrap(y)); }
+function bitxor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) ^ I16.unwrap(y)); }
+function bitnot(I16 x) pure returns (I16) { return I16.wrap(~I16.unwrap(x)); }
+
+function add(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) + I16.unwrap(y)); }
+function sub(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) - I16.unwrap(y)); }
+function unsub(I16 x) pure returns (I16) { return I16.wrap(-I16.unwrap(x)); }
+function mul(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) * I16.unwrap(y)); }
+function div(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) / I16.unwrap(y)); }
+function mod(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) % I16.unwrap(y)); }
+
+function eq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) == I16.unwrap(y); }
+function noteq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) != I16.unwrap(y); }
+function lt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) < I16.unwrap(y); }
+function gt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) > I16.unwrap(y); }
+function leq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) <= I16.unwrap(y); }
+function geq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) >= I16.unwrap(y); }
+
+contract C {
+    I16 constant MINUS_TWO = I16.wrap(-2);
+    I16 constant ZERO = I16.wrap(0);
+    I16 constant ONE = I16.wrap(1);
+    I16 constant TWO = I16.wrap(2);
+    I16 constant THREE = I16.wrap(3);
+    I16 constant FOUR = I16.wrap(4);
+
+    function testBitwise() public pure {
+        assert(ONE | TWO == THREE);
+        assert(ONE & THREE == ONE);
+        assert(TWO ^ TWO == ZERO);
+        assert(~ONE == MINUS_TWO);
+    }
+
+    function testArithmetic() public pure {
+        assert(TWO + TWO == FOUR);
+        assert(TWO - TWO == ZERO);
+        assert(-TWO == MINUS_TWO);
+        assert(TWO * TWO == FOUR);
+        assert(TWO / TWO == ONE);
+        assert(TWO % TWO == ZERO);
+    }
+
+    function testComparison() public pure {
+        assert(TWO == TWO);
+        assert(!(TWO != TWO));
+        assert(!(TWO < TWO));
+        assert(!(TWO > TWO));
+        assert(TWO <= TWO);
+        assert(TWO >= TWO);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 21 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants_fail.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants_fail.sol
new file mode 100644
index 00000000..25674513
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operations_on_constants_fail.sol
@@ -0,0 +1,79 @@
+type I16 is int16;
+using {
+    bitor as |, bitand as &, bitxor as ^, bitnot as ~,
+    add as +, sub as -, unsub as -, mul as *, div as /, mod as %,
+    eq as ==, noteq as !=, lt as <, gt as >, leq as <=, geq as >=
+} for I16 global;
+
+function bitor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) | I16.unwrap(y)); }
+function bitand(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) & I16.unwrap(y)); }
+function bitxor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) ^ I16.unwrap(y)); }
+function bitnot(I16 x) pure returns (I16) { return I16.wrap(~I16.unwrap(x)); }
+
+function add(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) + I16.unwrap(y)); }
+function sub(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) - I16.unwrap(y)); }
+function unsub(I16 x) pure returns (I16) { return I16.wrap(-I16.unwrap(x)); }
+function mul(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) * I16.unwrap(y)); }
+function div(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) / I16.unwrap(y)); }
+function mod(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) % I16.unwrap(y)); }
+
+function eq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) == I16.unwrap(y); }
+function noteq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) != I16.unwrap(y); }
+function lt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) < I16.unwrap(y); }
+function gt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) > I16.unwrap(y); }
+function leq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) <= I16.unwrap(y); }
+function geq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) >= I16.unwrap(y); }
+
+contract C {
+    I16 constant MINUS_TWO = I16.wrap(-2);
+    I16 constant ZERO = I16.wrap(0);
+    I16 constant ONE = I16.wrap(1);
+    I16 constant TWO = I16.wrap(2);
+    I16 constant THREE = I16.wrap(3);
+    I16 constant FOUR = I16.wrap(4);
+
+    function testBitwise() public pure {
+        assert(ONE | TWO == FOUR); // should fail
+        assert(ONE & THREE == FOUR); // should fail
+        assert(TWO ^ TWO == FOUR); // should fail
+        assert(~ONE == FOUR); // should fail
+    }
+
+    function testArithmetic() public pure {
+        assert(TWO + THREE == FOUR); // should fail
+        assert(TWO - TWO == FOUR); // should fail
+        assert(-TWO == FOUR); // should fail
+        assert(TWO * THREE == FOUR); // should fail
+        assert(TWO / TWO == FOUR); // should fail
+        assert(TWO % TWO == FOUR); // should fail
+    }
+
+    function testComparison() public pure {
+        assert(!(TWO == TWO)); // should fail
+        assert(TWO != TWO); // should fail
+        assert(TWO < TWO); // should fail
+        assert(TWO > TWO); // should fail
+        assert(!(TWO <= TWO)); // should fail
+        assert(!(TWO >= TWO)); // should fail
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (2012-2037): CHC: Assertion violation happens here.
+// Warning 6328: (2062-2089): CHC: Assertion violation happens here.
+// Warning 6328: (2114-2139): CHC: Assertion violation happens here.
+// Warning 6328: (2164-2184): CHC: Assertion violation happens here.
+// Warning 6328: (2260-2287): CHC: Assertion violation happens here.
+// Warning 6328: (2312-2337): CHC: Assertion violation happens here.
+// Warning 6328: (2362-2382): CHC: Assertion violation happens here.
+// Warning 6328: (2407-2434): CHC: Assertion violation happens here.
+// Warning 6328: (2459-2484): CHC: Assertion violation happens here.
+// Warning 6328: (2509-2534): CHC: Assertion violation happens here.
+// Warning 6328: (2610-2631): CHC: Assertion violation happens here.
+// Warning 6328: (2656-2674): CHC: Assertion violation happens here.
+// Warning 6328: (2699-2716): CHC: Assertion violation happens here.
+// Warning 6328: (2741-2758): CHC: Assertion violation happens here.
+// Warning 6328: (2783-2804): CHC: Assertion violation happens here.
+// Warning 6328: (2829-2850): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operator_matches_equivalent_function_call.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operator_matches_equivalent_function_call.sol
new file mode 100644
index 00000000..b734079c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_operator_matches_equivalent_function_call.sol
@@ -0,0 +1,77 @@
+type I16 is int16;
+using {
+    bitor as |, bitand as &, bitxor as ^, bitnot as ~,
+    add as +, sub as -, unsub as -, mul as *, div as /, mod as %,
+    eq as ==, noteq as !=, lt as <, gt as >, leq as <=, geq as >=
+} for I16 global;
+
+function bitor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) | I16.unwrap(y)); }
+function bitand(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) & I16.unwrap(y)); }
+function bitxor(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) ^ I16.unwrap(y)); }
+function bitnot(I16 x) pure returns (I16) { return I16.wrap(~I16.unwrap(x)); }
+
+function add(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) + I16.unwrap(y)); }
+function sub(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) - I16.unwrap(y)); }
+function unsub(I16 x) pure returns (I16) { return I16.wrap(-I16.unwrap(x)); }
+function mul(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) * I16.unwrap(y)); }
+function div(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) / I16.unwrap(y)); }
+function mod(I16 x, I16 y) pure returns (I16) { return I16.wrap(I16.unwrap(x) % I16.unwrap(y)); }
+
+
+function eq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) == I16.unwrap(y); }
+function noteq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) != I16.unwrap(y); }
+function lt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) < I16.unwrap(y); }
+function gt(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) > I16.unwrap(y); }
+function leq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) <= I16.unwrap(y); }
+function geq(I16 x, I16 y) pure returns (bool) { return I16.unwrap(x) >= I16.unwrap(y); }
+
+contract C {
+    function testBitwise(I16 x, I16 y) public pure {
+        assert(x | y == bitor(x, y)); // should hold
+        assert(x & y == bitand(x, y)); // should hold
+        assert(x ^ y == bitxor(x, y)); // should hold
+        assert(~x == bitnot(x)); // should hold
+    }
+
+    function testArithmetic(I16 x, I16 y) public pure {
+        assert(x + y == add(x, y));
+        assert(x - y == sub(x, y));
+        assert(-x == unsub(x));
+        assert(x * y == mul(x, y));
+        assert(x / y == div(x, y));
+        assert(x % y == mod(x, y));
+    }
+
+    function testComparison(I16 x, I16 y) public pure {
+        assert((x == y) == eq(x, y)); // should hold
+        assert((x != y) == noteq(x, y)); // should hold
+        assert((x < y) == lt(x, y)); // should hold
+        assert((x > y) == gt(x, y)); // should hold
+        assert((x <= y) == leq(x, y)); // should hold
+        assert((x >= y) == geq(x, y)); // should hold
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 3944: (679-708): CHC: Underflow (resulting value less than -32768) might happen here.
+// Warning 4984: (679-708): CHC: Overflow (resulting value larger than 32767) might happen here.
+// Warning 3944: (777-806): CHC: Underflow (resulting value less than -32768) happens here.
+// Warning 4984: (777-806): CHC: Overflow (resulting value larger than 32767) might happen here.
+// Warning 3944: (953-982): CHC: Underflow (resulting value less than -32768) might happen here.
+// Warning 4984: (953-982): CHC: Overflow (resulting value larger than 32767) might happen here.
+// Warning 4984: (1051-1080): CHC: Overflow (resulting value larger than 32767) might happen here.
+// Warning 4281: (1051-1080): CHC: Division by zero might happen here.
+// Warning 4281: (1149-1178): CHC: Division by zero might happen here.
+// Warning 6328: (2069-2095): CHC: Assertion violation might happen here.
+// Warning 6328: (2105-2131): CHC: Assertion violation might happen here.
+// Warning 6328: (2141-2163): CHC: Assertion violation might happen here.
+// Warning 6328: (2173-2199): CHC: Assertion violation might happen here.
+// Warning 6328: (2209-2235): CHC: Assertion violation might happen here.
+// Warning 6328: (2245-2271): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 3046: (1051-1080): BMC: Division by zero happens here.
+// Warning 3046: (1149-1178): BMC: Division by zero happens here.
+// Warning 7812: (2245-2271): BMC: Assertion violation might happen here.
+// Info 6002: BMC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_overflow.sol
new file mode 100644
index 00000000..82113252
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/operators/userDefined/user_defined_overflow.sol
@@ -0,0 +1,24 @@
+type U8 is uint8;
+using {add as +} for U8 global;
+
+function add(U8 x, U8 y) pure returns (U8) {
+    return U8.wrap(U8.unwrap(x) + U8.unwrap(y)); // overflow detected
+}
+
+contract C {
+    U8 x = U8.wrap(255);
+
+    function inc() public {
+        x = x + U8.wrap(1);
+    }
+
+    function check() view public {
+        U8 y = x;
+        assert(U8.unwrap(y) < 256);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (115-142): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_1.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_1.sol
new file mode 100644
index 00000000..bc37a313
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_1.sol
@@ -0,0 +1,28 @@
+contract C {
+	uint[] a;
+	uint l;
+	function p() public {
+		require(a.length < type(uint).max - 1);
+		a.push();
+		++l;
+	}
+	function q() public {
+		require(a.length > 0);
+		a.pop();
+		--l;
+	}
+	function r() public view returns (uint) {
+		require(l > 0);
+		return a[l]; // oob access
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 4984: (112-115): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 3944: (181-184): CHC: Underflow (resulting value less than 0) might happen here.
+// Warning 6368: (259-263): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (112-115): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4144: (181-184): BMC: Underflow (resulting value less than 0) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2.sol
new file mode 100644
index 00000000..77f4548f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint[] a;
+	uint l;
+	function p() public {
+		require(a.length < type(uint).max - 1);
+		require(l < type(uint).max - 1);
+		a.push();
+		++l;
+	}
+	function q() public {
+		require(a.length > 0);
+		require(l > 0);
+		a.pop();
+		--l;
+	}
+	function r() public view returns (uint) {
+		require(l > 0);
+		return a[l - 1]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_1.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_1.sol
new file mode 100644
index 00000000..a52707c5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_1.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint[][] a;
+	function p() public { a.push(); }
+	function q(uint i) public {
+		require(i < a.length);
+		a[i].push();
+	}
+	function r(uint i, uint j) public view returns (uint) {
+		require(i < a.length);
+		require(j < a[i].length);
+		return a[i][j]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_2.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_2.sol
new file mode 100644
index 00000000..63fa1cf7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_2.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint[][] a;
+	function p() public { a.push(); }
+	function q(uint i) public {
+		require(i < a.length);
+		a[i].push();
+	}
+	function r(uint i, uint j) public view returns (uint) {
+		require(i < a.length);
+		return a[i][j]; // unsafe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (224-231): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_3.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_3.sol
new file mode 100644
index 00000000..8fad49b8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_3.sol
@@ -0,0 +1,17 @@
+contract C {
+	uint[][] a;
+	function p() public { a.push(); }
+	function q(uint i) public {
+		require(i < a.length);
+		a[i].push();
+	}
+	function r() public view {
+		for (uint i = 0; i < a.length; ++i)
+			for (uint j = 0; j < a[i].length; ++j)
+				a[i][j]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_4.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_4.sol
new file mode 100644
index 00000000..2a9f39d1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_2d_4.sol
@@ -0,0 +1,27 @@
+contract C {
+	uint[][] a;
+	function p() public { a.push(); }
+	function q(uint i) public {
+		require(i < a.length);
+		a[i].push();
+	}
+	function r() public view {
+		for (uint i = 0; i < a.length + 10; ++i)
+			for (uint j = 0; j < a[i].length + 20; ++j)
+				a[i][j]; // oob access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (184-197): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 4984: (199-202): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 6368: (228-232): CHC: Out of bounds access happens here.
+// Warning 4984: (228-244): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 4984: (246-249): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Warning 6368: (255-259): CHC: Out of bounds access happens here.
+// Warning 6368: (255-262): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (184-197): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 2661: (228-244): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_4.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_4.sol
new file mode 100644
index 00000000..ab895696
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/array_4.sol
@@ -0,0 +1,12 @@
+contract C {
+	uint[] a;
+	function p() public { a.push(); }
+	function r(uint i) public view returns (uint) {
+		require(i < a.length);
+		return a[i]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_1.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_1.sol
new file mode 100644
index 00000000..46418844
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_1.sol
@@ -0,0 +1,9 @@
+contract C {
+	function r(bytes4 x) public pure returns (bytes1) {
+		return x[0]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_2.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_2.sol
new file mode 100644
index 00000000..d51685f3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_2.sol
@@ -0,0 +1,10 @@
+contract C {
+	function r(bytes4 x, uint y) public pure returns (bytes1) {
+		return x[y]; // oob access
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6368: (83-87): CHC: Out of bounds access happens here.\nCounterexample:\n\nx = 0x0\ny = 4\n = 0x0\n\nTransaction trace:\nC.constructor()\nC.r(0x0, 4)
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_3.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_3.sol
new file mode 100644
index 00000000..5d0dd95f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_3.sol
@@ -0,0 +1,11 @@
+contract C {
+	function r(bytes32 x, uint y) public pure {
+		require(y <= 31);
+		x[0]; // safe access
+		x[y]; // safe access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_4.sol b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_4.sol
new file mode 100644
index 00000000..fd94acfe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/out_of_bounds/fixed_bytes_4.sol
@@ -0,0 +1,12 @@
+contract C {
+	function r(bytes32 x, uint y) public pure {
+		x[0]; // safe access
+		// Disabled because of Spacer nondeterminism.
+		//x[y]; // oob access
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (36-42): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_constant_bound.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_constant_bound.sol
new file mode 100644
index 00000000..c5e7ecf3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_constant_bound.sol
@@ -0,0 +1,18 @@
+contract DepositContract {
+    uint constant MAX_DEPOSIT_COUNT = 2**32 - 1;
+
+    uint256 deposit_count;
+    uint256 deposit_count_2;
+
+    function deposit() external {
+        require(deposit_count < MAX_DEPOSIT_COUNT);
+        deposit_count += 1;
+        deposit_count_2 += 10; // should fail
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (256-277): CHC: Overflow (resulting value larger than 2**256 - 1) might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 2661: (256-277): BMC: Overflow (resulting value larger than 2**256 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul.sol
new file mode 100644
index 00000000..c43aba43
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint8 x) public pure returns (uint8) {
+		x = 100;
+		uint8 y = x * 3;
+		assert(y == 44);
+		x = 128;
+		y = x * 4;
+		assert(y == 0);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (87-92): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_cex_with_array.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_cex_with_array.sol
new file mode 100644
index 00000000..3dd28c7a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_cex_with_array.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bytes calldata x, uint y) external pure {
+		require(x.length > 10);
+		x[8][0];
+		x[8][5*y];
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (111-114): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 6368: (106-115): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_signed.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_signed.sol
new file mode 100644
index 00000000..16e7d0a2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_mul_signed.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(int8 x) public pure returns (int8) {
+		x = 100;
+		int8 y;
+		unchecked { y = x * 2; }
+		assert(y == -56);
+		y = x * 100;
+		assert(y == 16);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (136-143): CHC: Overflow (resulting value larger than 127) happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum.sol
new file mode 100644
index 00000000..100c4bfc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f(uint8 x) public pure returns (uint8) {
+		uint8 y;
+		unchecked { y = x + 255; }
+		require(y >= x);
+		x = 255;
+		unchecked { y = x + 1; }
+		assert(y == 0);
+		y = x + 255;
+		assert(y == 254);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (185-192): CHC: Overflow (resulting value larger than 255) happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum_signed.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum_signed.sol
new file mode 100644
index 00000000..b26189f5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/overflow_sum_signed.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f(int8 x) public pure {
+		x = 127;
+		int8 y;
+		unchecked { y = x + 1; }
+		assert(y == -128);
+		unchecked { y = x + 127; }
+		assert(y == -2);
+		x = -127;
+		unchecked { y = x + -127; }
+		assert(y == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_div_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_div_overflow.sol
new file mode 100644
index 00000000..1e55eb97
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_div_overflow.sol
@@ -0,0 +1,11 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		return x / y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 4984: (77-82): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
+// Warning 4281: (77-82): CHC: Division by zero happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sub_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sub_overflow.sol
new file mode 100644
index 00000000..65bf721d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sub_overflow.sol
@@ -0,0 +1,12 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		require(x >= y);
+		return x - y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 4984: (96-101): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sum_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sum_overflow.sol
new file mode 100644
index 00000000..7704e2d7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_guard_sum_overflow.sol
@@ -0,0 +1,13 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		require(x + y >= x);
+		return x + y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 3944: (78-83): CHC: Underflow (resulting value less than -2**255) happens here.
+// Warning 4984: (78-83): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_mul_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_mul_overflow.sol
new file mode 100644
index 00000000..c91b15da
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_mul_overflow.sol
@@ -0,0 +1,11 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		return x * y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 3944: (77-82): CHC: Underflow (resulting value less than -2**255) happens here.
+// Warning 4984: (77-82): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sub_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sub_overflow.sol
new file mode 100644
index 00000000..000acfae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sub_overflow.sol
@@ -0,0 +1,11 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		return x - y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 3944: (77-82): CHC: Underflow (resulting value less than -2**255) happens here.
+// Warning 4984: (77-82): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sum_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sum_overflow.sol
new file mode 100644
index 00000000..998944a5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/signed_sum_overflow.sol
@@ -0,0 +1,11 @@
+contract C  {
+	function f(int x, int y) public pure returns (int) {
+		return x + y;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 3944: (77-82): CHC: Underflow (resulting value less than -2**255) happens here.
+// Warning 4984: (77-82): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/simple_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/simple_overflow.sol
new file mode 100644
index 00000000..e8cf49a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/simple_overflow.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(uint a, uint b) public pure returns (uint) { return a + b; }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (80-85): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.\nCounterexample:\n\na = 1\nb = 115792089237316195423570985008687907853269984665640564039457584007913129639935\n = 0\n\nTransaction trace:\nC.constructor()\nC.f(1, 115792089237316195423570985008687907853269984665640564039457584007913129639935)
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub.sol
new file mode 100644
index 00000000..aadeff53
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint8 x) public pure returns (uint) {
+		x = 0;
+		uint8 y;
+		unchecked { y = x - 1; }
+		assert(y == 255);
+		unchecked { y = x - 255; }
+		assert(y == 1);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub_signed.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub_signed.sol
new file mode 100644
index 00000000..c6219810
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/underflow_sub_signed.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f(int8 x) public pure returns (int8) {
+		x = -2;
+		int8 y;
+		unchecked { y = x - 127; }
+		assert(y == 127);
+		x = -128;
+		unchecked { y = x - 127; }
+		assert(y == 1);
+		x = 127;
+		unchecked { y = x - (-127); }
+		assert(y == -2);
+		return y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/overflow/unsigned_guard_sub_overflow.sol b/compiler/test/libsolidity/smtCheckerTests/overflow/unsigned_guard_sub_overflow.sol
new file mode 100644
index 00000000..afc0c268
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/overflow/unsigned_guard_sub_overflow.sol
@@ -0,0 +1,10 @@
+contract C  {
+	function f(uint x, uint y) public pure returns (uint) {
+		require(x >= y);
+		return x - y;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/simple/cex_smoke_test.sol b/compiler/test/libsolidity/smtCheckerTests/simple/cex_smoke_test.sol
new file mode 100644
index 00000000..a5923310
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/simple/cex_smoke_test.sol
@@ -0,0 +1,12 @@
+contract C {
+
+    function f() public pure {
+        uint x = 1;
+        assert(x == 2);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (73-87): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 1\n\nTransaction trace:\nC.constructor()\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_memory_v2_value_types.sol b/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_memory_v2_value_types.sol
new file mode 100644
index 00000000..25bd93f5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_memory_v2_value_types.sol
@@ -0,0 +1,15 @@
+pragma abicoder v2;
+
+contract C {
+	function f(bytes memory data) public pure {
+		(uint x1, bool b1) = abi.decode(data, (uint, bool));
+		(uint x2, bool b2) = abi.decode(data, (uint, bool));
+		assert(x1 == x2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2072: (91-98): Unused local variable.
+// Warning 2072: (146-153): Unused local variable.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_simple.sol b/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_simple.sol
new file mode 100644
index 00000000..57672836
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/abi_decode_simple.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f(bytes memory data) public pure {
+		(uint a1, bytes32 b1, C c1) = abi.decode(data, (uint, bytes32, C));
+		(uint a2, bytes32 b2, C c2) = abi.decode(data, (uint, bytes32, C));
+		assert(a1 == a2);
+		assert(a1 != a2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2072: (70-80): Unused local variable.
+// Warning 2072: (82-86): Unused local variable.
+// Warning 2072: (140-150): Unused local variable.
+// Warning 2072: (152-156): Unused local variable.
+// Warning 6328: (220-236): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/block_vars_bmc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/block_vars_bmc_internal.sol
new file mode 100644
index 00000000..6d367b5c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/block_vars_bmc_internal.sol
@@ -0,0 +1,46 @@
+contract C {
+	address coin;
+	uint dif;
+	uint prevrandao;
+	uint gas;
+	uint number;
+	uint timestamp;
+	function f() public {
+		coin = block.coinbase;
+		dif = block.difficulty;
+		prevrandao = block.prevrandao;
+		gas = block.gaslimit;
+		number = block.number;
+		timestamp = block.timestamp;
+
+		g();
+	}
+	function g() internal view {
+		assert(uint160(coin) >= 0); // should hold
+		assert(dif >= 0); // should hold
+		assert(prevrandao > 2**64); // should hold
+		assert(gas >= 0); // should hold
+		assert(number >= 0); // should hold
+		assert(timestamp >= 0); // should hold
+
+		assert(coin == block.coinbase); // should fail with BMC
+		assert(dif == block.difficulty); // should fail with BMC
+		assert(prevrandao == block.prevrandao); // should fail with BMC
+		assert(gas == block.gaslimit); // should fail with BMC
+		assert(number == block.number); // should fail with BMC
+		assert(timestamp == block.timestamp); // should fail with BMC
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 8417: (155-171): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (641-657): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 4661: (409-435): BMC: Assertion violation happens here.
+// Warning 4661: (569-599): BMC: Assertion violation happens here.
+// Warning 4661: (627-658): BMC: Assertion violation happens here.
+// Warning 4661: (686-724): BMC: Assertion violation happens here.
+// Warning 4661: (752-781): BMC: Assertion violation happens here.
+// Warning 4661: (809-839): BMC: Assertion violation happens here.
+// Warning 4661: (867-903): BMC: Assertion violation happens here.
+// Info 6002: BMC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/block_vars_chc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/block_vars_chc_internal.sol
new file mode 100644
index 00000000..71e21aa4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/block_vars_chc_internal.sol
@@ -0,0 +1,43 @@
+contract C {
+	address coin;
+	uint dif;
+	uint prevrandao;
+	uint gas;
+	uint number;
+	uint timestamp;
+	function f() public {
+		coin = block.coinbase;
+		dif = block.difficulty;
+		prevrandao = block.prevrandao;
+		gas = block.gaslimit;
+		number = block.number;
+		timestamp = block.timestamp;
+
+		g();
+	}
+	function g() internal view {
+		assert(uint160(coin) >= 0); // should hold
+		assert(dif >= 0); // should hold
+		assert(prevrandao > 2**64); // should hold
+		assert(gas >= 0); // should hold
+		assert(number >= 0); // should hold
+		assert(timestamp >= 0); // should hold
+
+		assert(coin == block.coinbase); // should hold with CHC
+		assert(dif == block.difficulty); // should hold with CHC
+		assert(prevrandao == block.prevrandao); // should hold with CHC
+		assert(gas == block.gaslimit); // should hold with CHC
+		assert(number == block.number); // should hold with CHC
+		assert(timestamp == block.timestamp); // should hold with CHC
+
+		assert(coin == address(this)); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTIgnoreOS: macos
+// ----
+// Warning 8417: (155-171): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (641-657): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 6328: (932-961): CHC: Assertion violation happens here.
+// Info 1391: CHC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/blockhash.sol b/compiler/test/libsolidity/smtCheckerTests/special/blockhash.sol
new file mode 100644
index 00000000..65432370
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/blockhash.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint x) public payable {
+		assert(blockhash(x) > 0);
+		assert(blockhash(2) > 0);
+		uint y = x;
+		assert(blockhash(x) == blockhash(y));
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (52-76): CHC: Assertion violation happens here.
+// Warning 6328: (80-104): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/chainid.sol b/compiler/test/libsolidity/smtCheckerTests/special/chainid.sol
new file mode 100644
index 00000000..3cb4003d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/chainid.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.chainid + 0; // Overflow not possible!
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/ether_units.sol b/compiler/test/libsolidity/smtCheckerTests/special/ether_units.sol
new file mode 100644
index 00000000..9c0e8ea7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/ether_units.sol
@@ -0,0 +1,17 @@
+contract D {
+	function f() public pure {
+		assert(1000000000000000000 wei == 1 ether);
+		assert(100000000000000000 wei == 1 ether);
+		assert(1000000000 wei == 1 gwei);
+		assert(100000000 wei == 1 gwei);
+		assert(1000000000 gwei == 1 ether);
+		assert(100000000 gwei == 1 ether);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (89-130): CHC: Assertion violation happens here.
+// Warning 6328: (170-201): CHC: Assertion violation happens here.
+// Warning 6328: (243-276): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/event.sol b/compiler/test/libsolidity/smtCheckerTests/special/event.sol
new file mode 100644
index 00000000..a5ddafc5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/event.sol
@@ -0,0 +1,31 @@
+contract C {
+	event Nudge();
+	event SomeArgs(uint, uint);
+	event Caller(address, uint);
+	function f() payable external {
+		emit Nudge();
+		emit SomeArgs(134, 567);
+		emit Caller(msg.sender, msg.value);
+	}
+	function g_data() pure internal returns (uint) {
+		assert(true);
+	}
+	function g() external {
+		emit SomeArgs(g_data(), g_data());
+	}
+	bool x = true;
+	function h_data() view internal returns (uint) {
+		assert(x);
+	}
+	function h() external {
+		x = false;
+		emit SomeArgs(h_data(), h_data());
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (247-251): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6321: (397-401): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (407-416): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/gasleft.sol b/compiler/test/libsolidity/smtCheckerTests/special/gasleft.sol
new file mode 100644
index 00000000..29b8e0dc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/gasleft.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f() public view {
+		assert(gasleft() > 0);
+		uint g = gasleft();
+		assert(g < gasleft());
+		assert(g >= gasleft());
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (43-64): CHC: Assertion violation happens here.
+// Warning 6328: (90-111): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/many.sol b/compiler/test/libsolidity/smtCheckerTests/special/many.sol
new file mode 100644
index 00000000..247eec98
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/many.sol
@@ -0,0 +1,30 @@
+contract C
+{
+	function f() public payable {
+		assert(msg.sender == block.coinbase);
+		assert(block.difficulty == block.gaslimit);
+		assert(block.prevrandao == block.gaslimit);
+		assert(block.number == block.timestamp);
+		assert(tx.gasprice == msg.value);
+		assert(tx.origin == msg.sender);
+		uint x = block.number;
+		unchecked { x += 2; }
+		assert(x > block.number);
+		assert(block.timestamp > 10);
+		assert(gasleft() > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 8417: (93-109): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 6328: (46-82): CHC: Assertion violation happens here.
+// Warning 6328: (86-128): CHC: Assertion violation happens here.
+// Warning 6328: (132-174): CHC: Assertion violation happens here.
+// Warning 6328: (178-217): CHC: Assertion violation happens here.
+// Warning 6328: (221-253): CHC: Assertion violation happens here.
+// Warning 6328: (257-288): CHC: Assertion violation happens here.
+// Warning 6328: (341-365): CHC: Assertion violation happens here.
+// Warning 6328: (369-397): CHC: Assertion violation happens here.
+// Warning 6328: (401-424): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/many_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/many_internal.sol
new file mode 100644
index 00000000..cf9c61ae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/many_internal.sol
@@ -0,0 +1,33 @@
+contract C
+{
+	function f() public payable {
+		g();
+	}
+	function g() internal {
+		assert(msg.sender == block.coinbase);
+		assert(block.difficulty == block.gaslimit);
+		assert(block.prevrandao == block.gaslimit);
+		assert(block.number == block.timestamp);
+		assert(tx.gasprice == msg.value);
+		assert(tx.origin == msg.sender);
+		uint x = block.number;
+		unchecked { x += 2; }
+		assert(x > block.number);
+		assert(block.timestamp > 10);
+		assert(gasleft() > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 8417: (128-144): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 6328: (81-117): CHC: Assertion violation happens here.
+// Warning 6328: (121-163): CHC: Assertion violation happens here.
+// Warning 6328: (167-209): CHC: Assertion violation happens here.
+// Warning 6328: (213-252): CHC: Assertion violation happens here.
+// Warning 6328: (256-288): CHC: Assertion violation happens here.
+// Warning 6328: (292-323): CHC: Assertion violation happens here.
+// Warning 6328: (376-400): CHC: Assertion violation happens here.
+// Warning 6328: (404-432): CHC: Assertion violation happens here.
+// Warning 6328: (436-459): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_data.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_data.sol
new file mode 100644
index 00000000..37552a2b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_data.sol
@@ -0,0 +1,28 @@
+contract C
+{
+	function f() public payable {
+		assert(msg.data.length > 0);
+		// Fails since calldata size should be 4
+		assert(msg.data.length > 4);
+		// f's sig is 0x26121ff0
+		assert(msg.data[0] == 0x26);
+		assert(msg.data[1] == 0x12);
+		assert(msg.data[2] == 0x1f);
+		assert(msg.data[3] == 0xf0);
+	}
+	function g() public payable {
+		// g's sig is 0xe2179b8e
+		assert(msg.data[0] == 0xe2);
+		assert(msg.data[1] == 0x17);
+		assert(msg.data[2] == 0x9b);
+		// Fails
+		assert(msg.data[3] == 0x8f);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (120-147): CHC: Assertion violation happens here.
+// Warning 6328: (467-494): CHC: Assertion violation happens here.
+// Info 1391: CHC: 16 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_parens_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_parens_1.sol
new file mode 100644
index 00000000..6368eb2d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_parens_1.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public payable {
+		assert((msg).value == 10);
+		assert((true ? msg : msg).value == 12);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// SMTIgnoreCex: yes
+// ----
+// TypeError 9717: (90-93): Invalid mobile type in true expression.
+// TypeError 3703: (96-99): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_1.sol
new file mode 100644
index 00000000..af6d7902
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f() public view {
+		address a = msg.sender;
+		address b = msg.sender;
+		assert(a == b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_2.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_2.sol
new file mode 100644
index 00000000..71cb0e12
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_2.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	function f() public view {
+		require(msg.sender != address(0));
+		address a = msg.sender;
+		address b = msg.sender;
+		assert(a == b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_3.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_3.sol
new file mode 100644
index 00000000..4ca48fb4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_3.sol
@@ -0,0 +1,23 @@
+contract C {
+	address owner;
+
+	constructor() {
+		owner = msg.sender;
+		assert(owner >= address(0)); // should hold
+	}
+}
+
+contract D {
+	address owner;
+
+	constructor() {
+		unchecked {
+			owner = msg.sender;
+			assert(owner >= address(0)); // should hold
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_fail_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_fail_1.sol
new file mode 100644
index 00000000..e285f97d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_fail_1.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(address c) public view {
+		address a = msg.sender;
+		address b = msg.sender;
+		assert(a == b);
+		assert(c == msg.sender);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (122-145): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_range.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_range.sol
new file mode 100644
index 00000000..f78200cd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sender_range.sol
@@ -0,0 +1,11 @@
+contract C {
+
+	function f() public view {
+		assert(msg.sender >= address(0)); // should hold
+		assert(msg.sender <= address(2**160-1)); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_sig.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_sig.sol
new file mode 100644
index 00000000..45fa0543
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_sig.sol
@@ -0,0 +1,31 @@
+contract C
+{
+	function f() public pure {
+		assert(msg.sig == 0x00000000);
+		assert(msg.sig == 0x26121ff0);
+		fi();
+		gi();
+	}
+	function fi() internal pure {
+		assert(msg.sig == 0x26121ff0);
+	}
+	function g() public pure {
+		assert(msg.sig == 0xe2179b8e);
+		gi();
+	}
+	function gi() internal pure {
+		// Fails since f can also call gi in which case msg.sig == 0x26121ff0
+		assert(msg.sig == 0xe2179b8e);
+	}
+	function h() public pure {
+		// Fails since gi can also call h in which case msg.sig can be f() or g()
+		assert(msg.sig == 0xe2179b8e);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (43-72): CHC: Assertion violation happens here.
+// Warning 6328: (370-399): CHC: Assertion violation happens here.
+// Warning 6328: (510-539): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_1.sol
new file mode 100644
index 00000000..3f8b50ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_1.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f() public payable {
+		assert ((5 + msg.value + msg.value) - (4 + msg.value) > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (55-68): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Warning 4984: (55-80): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_3.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_3.sol
new file mode 100644
index 00000000..4035dffa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_3.sol
@@ -0,0 +1,16 @@
+contract C {
+	bool lock = true;
+	function f() public {
+		lock = false;
+		g();
+		lock = true;
+	}
+	function g() public payable {
+		require(lock == false);
+		assert(msg.value == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_4.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_4.sol
new file mode 100644
index 00000000..cab8c0aa
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_4.sol
@@ -0,0 +1,17 @@
+contract A {
+    uint x = msg.value;
+    constructor() {
+        assert(x == 0); // should hold
+    }
+}
+
+contract B {
+    constructor() payable {
+        assert(msg.value == 0); // should fail
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (154-176): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_1.sol
new file mode 100644
index 00000000..07a2bb35
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_1.sol
@@ -0,0 +1,18 @@
+contract A {
+	uint public x = msg.value;
+	constructor() payable {
+		assert(x == 0); // should fail, A can be constructed with any msg.value
+	}
+}
+
+contract C is A {
+	uint public v = msg.value;
+	constructor() A() {
+		assert(v == 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (68-82): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_2.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_2.sol
new file mode 100644
index 00000000..942607bd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_2.sol
@@ -0,0 +1,19 @@
+contract A {
+	uint public x = msg.value;
+	constructor() {
+		assert(x == 0); // should fail, if A is constructed as part of C, it can have any msg.value
+	}
+}
+
+contract C is A {
+	uint public v = msg.value; // 1
+	constructor() A() payable {
+		assert(v == 0); // should fail, C can be constructed with any msg.value
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (60-74): CHC: Assertion violation happens here.
+// Warning 6328: (240-254): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_3.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_3.sol
new file mode 100644
index 00000000..fc8d6e08
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_value_inheritance_3.sol
@@ -0,0 +1,22 @@
+contract A {
+	uint public x = msg.value;
+	constructor() {
+		assert(x == 0); // can fail when A is constructed as part of C
+	}
+}
+
+contract B {
+	constructor() payable {
+		assert(msg.value >= 0); // should hold
+	}
+}
+contract C is A, B {
+	constructor() A() B() payable {
+		assert(msg.value >= 0); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (60-74): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_bmc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_bmc_internal.sol
new file mode 100644
index 00000000..f96f5880
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_bmc_internal.sol
@@ -0,0 +1,33 @@
+contract C {
+	bytes data;
+	address sender;
+	bytes4 sig;
+	uint value;
+	function f() public payable {
+		data = msg.data;
+		sender = msg.sender;
+		sig = msg.sig;
+		value = msg.value;
+
+		g();
+	}
+	function g() internal view {
+		assert(data.length >= 0); // should hold
+		assert(uint160(sender) >= 0); // should hold
+		assert(uint32(sig) >= 0); // should hold
+		assert(value >= 0); // should hold
+
+		assert(data.length == msg.data.length); // should fail with BMC
+		assert(sender == msg.sender); // should fail with BMC
+		assert(sig == msg.sig); // should fail with BMC
+		assert(value == msg.value); // should fail with BMC
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (394-432): BMC: Assertion violation happens here.
+// Warning 4661: (460-488): BMC: Assertion violation happens here.
+// Warning 4661: (516-538): BMC: Assertion violation happens here.
+// Warning 4661: (566-592): BMC: Assertion violation happens here.
+// Info 6002: BMC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_chc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_chc_internal.sol
new file mode 100644
index 00000000..2a39b5de
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/msg_vars_chc_internal.sol
@@ -0,0 +1,33 @@
+contract C {
+	bytes data;
+	address sender;
+	bytes4 sig;
+	uint value;
+	function f() public payable {
+		data = msg.data;
+		sender = msg.sender;
+		sig = msg.sig;
+		value = msg.value;
+		require(value == 42);
+
+		g();
+	}
+	function g() internal view {
+		assert(data.length >= 0); // should hold
+		assert(uint160(sender) >= 0); // should hold
+		assert(uint32(sig) >= 0); // should hold
+		assert(value >= 0); // should hold
+
+		assert(data.length == msg.data.length); // should hold with CHC
+		assert(sender == msg.sender); // should hold with CHC
+		assert(sig == msg.sig); // should hold with CHC
+		assert(value == msg.value); // should hold with CHC
+
+		assert(msg.value == 10); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// ----
+// Warning 6328: (645-668): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/prevrandao.sol b/compiler/test/libsolidity/smtCheckerTests/special/prevrandao.sol
new file mode 100644
index 00000000..4bc818ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/prevrandao.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(uint prevrandao) public view {
+		assert(block.prevrandao == prevrandao); // should fail
+		assert(block.difficulty == prevrandao); // should fail
+		assert(block.difficulty == block.prevrandao); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 8417: (122-138): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (179-195): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 6328: (58-96): CHC: Assertion violation happens here.
+// Warning 6328: (115-153): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/range_check.sol b/compiler/test/libsolidity/smtCheckerTests/special/range_check.sol
new file mode 100644
index 00000000..8880a68a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/range_check.sol
@@ -0,0 +1,65 @@
+contract C {
+	constructor() payable {
+		assert(tx.origin >= address(0));
+		assert(tx.origin <= address(2**160 - 1));
+		assert(tx.gasprice >= 0);
+		assert(tx.gasprice <= 2**256 - 1);
+		assert(msg.sender >= address(0));
+		assert(msg.sender <= address(2**160 - 1));
+		assert(msg.value >= 0);
+		assert(msg.value <= 2**256 - 1);
+
+		assert(block.coinbase >= address(0));
+		assert(block.coinbase <= address(2**160 - 1));
+		assert(block.timestamp >= 0);
+		assert(block.timestamp <= 2**256 - 1);
+		assert(block.chainid >= 0);
+		assert(block.chainid <= 2**256 - 1);
+		assert(block.difficulty >= 0);
+		assert(block.difficulty <= 2**256 - 1);
+		assert(block.prevrandao > 2**64);
+		assert(block.prevrandao <= 2**256 - 1);
+		assert(block.gaslimit >= 0);
+		assert(block.gaslimit <= 2**256 - 1);
+		assert(block.number >= 0);
+		assert(block.number <= 2**256 - 1);
+	}
+}
+
+contract D {
+	constructor() payable {
+		unchecked {
+			assert(tx.origin >= address(0));
+			assert(tx.origin <= address(2**160 - 1));
+			assert(tx.gasprice >= 0);
+			assert(tx.gasprice <= 2**256 - 1);
+			assert(msg.sender >= address(0));
+			assert(msg.sender <= address(2**160 - 1));
+			assert(msg.value >= 0);
+			assert(msg.value <= 2**256 - 1);
+
+			assert(block.coinbase >= address(0));
+			assert(block.coinbase <= address(2**160 - 1));
+			assert(block.timestamp >= 0);
+			assert(block.timestamp <= 2**256 - 1);
+			assert(block.chainid >= 0);
+			assert(block.chainid <= 2**256 - 1);
+			assert(block.difficulty >= 0);
+			assert(block.difficulty <= 2**256 - 1);
+			assert(block.prevrandao > 2**64);
+			assert(block.prevrandao <= 2**256 - 1);
+			assert(block.gaslimit >= 0);
+			assert(block.gaslimit <= 2**256 - 1);
+			assert(block.number >= 0);
+			assert(block.number <= 2**256 - 1);
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8417: (565-581): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (598-614): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1447-1463): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1481-1497): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Info 1391: CHC: 44 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/shadowing_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/shadowing_1.sol
new file mode 100644
index 00000000..27fb60ba
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/shadowing_1.sol
@@ -0,0 +1,25 @@
+contract C {
+	struct S {
+		uint value;
+		address origin;
+		uint number;
+	}
+	function f() public payable {
+		S memory msg = S(42, address(0), 666);
+		S memory tx = S(42, address(0), 666);
+		S memory block = S(42, address(0), 666);
+		assert(msg.value == 42); // should hold
+		assert(msg.value == 41); // should fail
+		assert(tx.origin == address(0)); // should hold
+		assert(block.number == 666); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2319: (108-120): This declaration shadows a builtin symbol.
+// Warning 2319: (149-160): This declaration shadows a builtin symbol.
+// Warning 2319: (189-203): This declaration shadows a builtin symbol.
+// Warning 6328: (274-297): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/this_state.sol b/compiler/test/libsolidity/smtCheckerTests/special/this_state.sol
new file mode 100644
index 00000000..703488db
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/this_state.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	address thisAddr;
+	function f(address a) public {
+		require(a == address(this));
+		thisAddr = a;
+		assert(thisAddr == address(this));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/time_units.sol b/compiler/test/libsolidity/smtCheckerTests/special/time_units.sol
new file mode 100644
index 00000000..922fb402
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/time_units.sol
@@ -0,0 +1,23 @@
+contract D {
+	function f() public pure {
+		assert(1 == 1 seconds);
+		assert(2 == 1 seconds);
+		assert(2 minutes == 120 seconds);
+		assert(3 minutes == 120 seconds);
+		assert(2 hours == 120 minutes);
+		assert(3 hours == 120 minutes);
+		assert(2 days == 48 hours);
+		assert(4 days == 48 hours);
+		assert(2 weeks == 14 days);
+		assert(25 weeks == 14 days);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (69-91): CHC: Assertion violation happens here.
+// Warning 6328: (131-163): CHC: Assertion violation happens here.
+// Warning 6328: (201-231): CHC: Assertion violation happens here.
+// Warning 6328: (265-291): CHC: Assertion violation happens here.
+// Warning 6328: (325-352): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/timestamp.sol b/compiler/test/libsolidity/smtCheckerTests/special/timestamp.sol
new file mode 100644
index 00000000..31bd0969
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/timestamp.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public view returns (uint) {
+        uint b = block.timestamp;
+        uint a = b + 0; // Overflow not possible!
+        return a;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/timestamp_2.sol b/compiler/test/libsolidity/smtCheckerTests/special/timestamp_2.sol
new file mode 100644
index 00000000..c9520840
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/timestamp_2.sol
@@ -0,0 +1,13 @@
+contract C {
+	uint x;
+
+	constructor() {
+		x = block.timestamp + 0; // No overflow should be reported
+		x = block.timestamp + 1; // Overflow should be reported here
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4984: (107-126): CHC: Overflow (resulting value larger than 2**256 - 1) happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_data_gasleft_changes.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_gasleft_changes.sol
new file mode 100644
index 00000000..a30f25b7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_gasleft_changes.sol
@@ -0,0 +1,23 @@
+contract C {
+	uint gleft;
+
+	function f() public payable {
+		gleft = gasleft();
+
+		fi();
+
+		assert(gleft == gasleft());
+		assert(gleft >= gasleft());
+	}
+
+	function fi() internal view {
+		assert(gleft == gasleft());
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (91-117): CHC: Assertion violation happens here.
+// Warning 6328: (186-212): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable.sol
new file mode 100644
index 00000000..c66ce565
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable.sol
@@ -0,0 +1,70 @@
+contract C {
+	bytes32 bhash;
+	address coin;
+	uint dif;
+	uint prevrandao;
+	uint glimit;
+	uint number;
+	uint tstamp;
+	bytes mdata;
+	address sender;
+	bytes4 sig;
+	uint value;
+	uint gprice;
+	address origin;
+
+	function f() public payable {
+		bhash = blockhash(12);
+		coin = block.coinbase;
+		dif = block.difficulty;
+		prevrandao = block.prevrandao;
+		glimit = block.gaslimit;
+		number = block.number;
+		tstamp = block.timestamp;
+		mdata = msg.data;
+		sender = msg.sender;
+		sig = msg.sig;
+		value = msg.value;
+		gprice = tx.gasprice;
+		origin = tx.origin;
+
+		fi();
+
+		assert(bhash == blockhash(12));
+		assert(coin == block.coinbase);
+		assert(dif == block.difficulty);
+		assert(prevrandao == block.prevrandao);
+		assert(glimit == block.gaslimit);
+		assert(number == block.number);
+		assert(tstamp == block.timestamp);
+		assert(mdata.length == msg.data.length);
+		assert(sender == msg.sender);
+		assert(sig == msg.sig);
+		assert(value == msg.value);
+		assert(gprice == tx.gasprice);
+		assert(origin == tx.origin);
+	}
+
+	function fi() internal view {
+		assert(bhash == blockhash(12));
+		assert(coin == block.coinbase);
+		assert(dif == block.difficulty);
+		assert(prevrandao == block.prevrandao);
+		assert(glimit == block.gaslimit);
+		assert(number == block.number);
+		assert(tstamp == block.timestamp);
+		assert(mdata.length == msg.data.length);
+		assert(sender == msg.sender);
+		assert(sig == msg.sig);
+		assert(value == msg.value);
+		assert(gprice == tx.gasprice);
+		assert(origin == tx.origin);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8417: (293-309): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (645-661): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1127-1143): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Info 1391: CHC: 26 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable_fail.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable_fail.sol
new file mode 100644
index 00000000..2b16f2d1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_data_immutable_fail.sol
@@ -0,0 +1,96 @@
+contract C {
+	bytes32 bhash;
+	address coin;
+	uint dif;
+	uint prevrandao;
+	uint glimit;
+	uint number;
+	uint tstamp;
+	bytes mdata;
+	address sender;
+	bytes4 sig;
+	uint value;
+	uint gprice;
+	address origin;
+
+	function f() public payable {
+		bhash = blockhash(12);
+		coin = block.coinbase;
+		dif = block.difficulty;
+		prevrandao = block.prevrandao;
+		glimit = block.gaslimit;
+		number = block.number;
+		tstamp = block.timestamp;
+		mdata = msg.data;
+		sender = msg.sender;
+		sig = msg.sig;
+		value = msg.value;
+		gprice = tx.gasprice;
+		origin = tx.origin;
+
+		fi();
+
+		assert(bhash == blockhash(122));
+		assert(coin != block.coinbase);
+		assert(dif != block.difficulty);
+		assert(prevrandao != block.prevrandao);
+		assert(glimit != block.gaslimit);
+		assert(number != block.number);
+		assert(tstamp != block.timestamp);
+		assert(mdata.length != msg.data.length);
+		assert(sender != msg.sender);
+		assert(sig != msg.sig);
+		assert(value != msg.value);
+		assert(gprice != tx.gasprice);
+		assert(origin != tx.origin);
+	}
+
+	function fi() internal view {
+		assert(bhash == blockhash(122));
+		assert(coin != block.coinbase);
+		assert(dif != block.difficulty);
+		assert(prevrandao != block.prevrandao);
+		assert(glimit != block.gaslimit);
+		assert(number != block.number);
+		assert(tstamp != block.timestamp);
+		assert(mdata.length != msg.data.length);
+		assert(sender != msg.sender);
+		assert(sig != msg.sig);
+		assert(value != msg.value);
+		assert(gprice != tx.gasprice);
+		assert(origin != tx.origin);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 8417: (293-309): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (646-662): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 8417: (1129-1145): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
+// Warning 6328: (563-594): CHC: Assertion violation happens here.
+// Warning 6328: (598-628): CHC: Assertion violation happens here.
+// Warning 6328: (632-663): CHC: Assertion violation happens here.
+// Warning 6328: (667-705): CHC: Assertion violation happens here.
+// Warning 6328: (709-741): CHC: Assertion violation happens here.
+// Warning 6328: (745-775): CHC: Assertion violation happens here.
+// Warning 6328: (779-812): CHC: Assertion violation happens here.
+// Warning 6328: (816-855): CHC: Assertion violation happens here.
+// Warning 6328: (859-887): CHC: Assertion violation happens here.
+// Warning 6328: (891-913): CHC: Assertion violation happens here.
+// Warning 6328: (917-943): CHC: Assertion violation happens here.
+// Warning 6328: (947-976): CHC: Assertion violation happens here.
+// Warning 6328: (980-1007): CHC: Assertion violation happens here.
+// Warning 6328: (1046-1077): CHC: Assertion violation happens here.
+// Warning 6328: (1081-1111): CHC: Assertion violation happens here.
+// Warning 6328: (1115-1146): CHC: Assertion violation happens here.
+// Warning 6328: (1150-1188): CHC: Assertion violation happens here.
+// Warning 6328: (1192-1224): CHC: Assertion violation happens here.
+// Warning 6328: (1228-1258): CHC: Assertion violation happens here.
+// Warning 6328: (1262-1295): CHC: Assertion violation happens here.
+// Warning 6328: (1299-1338): CHC: Assertion violation happens here.
+// Warning 6328: (1342-1370): CHC: Assertion violation happens here.
+// Warning 6328: (1374-1396): CHC: Assertion violation happens here.
+// Warning 6328: (1400-1426): CHC: Assertion violation happens here.
+// Warning 6328: (1430-1459): CHC: Assertion violation happens here.
+// Warning 6328: (1463-1490): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_bmc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_bmc_internal.sol
new file mode 100644
index 00000000..03db677c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_bmc_internal.sol
@@ -0,0 +1,23 @@
+contract C {
+	uint gas;
+	address origin;
+	function f() public {
+		gas = tx.gasprice;
+		origin = tx.origin;
+
+		g();
+	}
+	function g() internal view {
+		assert(gas >= 0); // should hold
+		assert(uint160(origin) >= 0); // should hold
+
+		assert(gas == tx.gasprice); // should fail with BMC
+		assert(origin == tx.origin); // should fail with BMC
+	}
+}
+// ====
+// SMTEngine: bmc
+// ----
+// Warning 4661: (233-259): BMC: Assertion violation happens here.
+// Warning 4661: (287-314): BMC: Assertion violation happens here.
+// Info 6002: BMC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_chc_internal.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_chc_internal.sol
new file mode 100644
index 00000000..6aa66403
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_chc_internal.sol
@@ -0,0 +1,25 @@
+contract C {
+	uint gas;
+	address origin;
+	function f() public {
+		gas = tx.gasprice;
+		origin = tx.origin;
+
+		g();
+	}
+	function g() internal view {
+		assert(gas >= 0); // should hold
+		assert(uint160(origin) >= 0); // should hold
+
+		assert(gas == tx.gasprice); // should hold with CHC
+		assert(origin == tx.origin); // should hold with CHC
+
+		assert(tx.origin == address(this)); // should fail
+	}
+}
+// ====
+// SMTEngine: chc
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (343-377): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_1.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_1.sol
new file mode 100644
index 00000000..7af8c96c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_1.sol
@@ -0,0 +1,17 @@
+interface I {
+	function f() external;
+}
+
+contract C {
+	function g(I _i) public payable {
+		uint x = address(this).balance;
+		_i.f();
+		assert(x == address(this).balance); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (135-169): CHC: Assertion violation happens here.\nCounterexample:\n\n_i = 0\nx = 5892\n\nTransaction trace:\nC.constructor()\nC.g(0){ msg.value: 11 }\n    _i.f() -- untrusted external call, synthesized as:\n        C.g(0){ msg.value: 32278 } -- reentrant call\n            _i.f() -- untrusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_2.sol b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_2.sol
new file mode 100644
index 00000000..81de958b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/special/tx_vars_reentrancy_2.sol
@@ -0,0 +1,16 @@
+interface I {
+	function f() external payable;
+}
+
+contract C {
+	function g(I _i) public payable {
+		uint x = address(this).balance;
+		_i.f{ value: 100 }();
+		assert(x == address(this).balance); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (157-191): CHC: Assertion violation happens here.\nCounterexample:\n\n_i = 0\nx = 101\n\nTransaction trace:\nC.constructor()\nC.g(0){ msg.value: 83 }\n    _i.f{ value: 100 }() -- untrusted external call
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_1.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_1.sol
new file mode 100644
index 00000000..b1500256
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_1.sol
@@ -0,0 +1,24 @@
+contract C {
+	int x;
+
+	function g() public  {
+		x = 42;
+	}
+
+	function f() public {
+		x = 0;
+		bool success = false;
+		try this.g() {
+			success = true;
+		} catch (bytes memory s) {
+			assert(x == 0); // should hold
+		}
+		assert(success); // fails for now, since external call is over-approximated (both success and fail are considered possible) for now even for known code
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (163-177): Unused try/catch parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (221-236): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_2.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_2.sol
new file mode 100644
index 00000000..724d7b74
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_2.sol
@@ -0,0 +1,21 @@
+contract C {
+	int x;
+
+	function g() public  {
+		x = 42;
+	}
+
+	function f() public {
+		x = 0;
+		try this.g() {
+			assert(x == 42); // should hold
+		} catch (bytes memory s) {
+			assert(x == 0); // should hold
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (155-169): Unused try/catch parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_3.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_3.sol
new file mode 100644
index 00000000..7698eed0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_3.sol
@@ -0,0 +1,28 @@
+contract C {
+	int x;
+
+	function g(int y) public pure returns (int) {
+		return y;
+	}
+
+	function postinc() internal returns (int) {
+		x += 1;
+		return x;
+	}
+
+	function f() public {
+		x = 0;
+		try this.g(postinc()) {
+			assert(x == 1); // should hold
+		} catch (bytes memory s) {
+			assert(x == 0); // should fail - state is reverted to the state after postinc(), but before the call to this.g()
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 5667: (259-273): Unused try/catch parameter. Remove or comment out the variable name to silence this warning.
+// Warning 6328: (280-294): CHC: Assertion violation happens here.\nCounterexample:\nx = 1\ns = []\n\nTransaction trace:\nC.constructor()\nState: x = 0\nC.f()\n    C.postinc() -- internal call
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_4.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_4.sol
new file mode 100644
index 00000000..9090e71f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_4.sol
@@ -0,0 +1,29 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+
+	int x;
+	D d;
+
+	function set(int n) public {
+		x = n;
+	}
+
+	function f() public {
+		x = 0;
+		try d.d() {
+			//assert(x == 0); // should fail, x can be anything here
+		} catch {
+			assert(x == 0); // should hold, all changes to x has been reverted
+			assert(x == 1); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (320-334): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_5.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_5.sol
new file mode 100644
index 00000000..163a879d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_5.sol
@@ -0,0 +1,29 @@
+abstract contract D {
+	function d() external virtual;
+}
+
+contract C {
+
+	int x;
+	D d;
+
+	function set(int n) public {
+		require(n < 100);
+		x = n;
+	}
+
+	function f() public {
+		x = 0;
+		try d.d() {
+			assert(x < 100); // should hold
+		} catch {
+			assert(x == 0); // should hold, all changes to x has been reverted
+			assert(x == 1); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (315-329): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_if.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_if.sol
new file mode 100644
index 00000000..4a65bd9a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_if.sol
@@ -0,0 +1,14 @@
+contract C {
+  function g(bool b) public {}
+  function f(bool b) public returns (bytes memory txt) {
+    if (0==1)
+      try this.g(b) {}
+      catch (bytes memory s) {
+        txt = s;
+      }
+  }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6838: (109-113): BMC: Condition is always false.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_while.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_while.sol
new file mode 100644
index 00000000..63976d59
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_inside_while.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public returns (uint) {
+		while(1==1)
+			try this.f() returns (uint b) {
+				b = 2;
+			} catch {
+			}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (43-47): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses.sol
new file mode 100644
index 00000000..4605aee8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses.sol
@@ -0,0 +1,27 @@
+contract C {
+	int x;
+
+	function g() public  {
+		x = 42;
+	}
+
+	function f() public {
+		x = 1;
+		bool success = false;
+		try this.g() {
+			success = true;
+			assert(x == 42); // should hold
+		} catch Error (string memory /*reason*/) {
+			assert(x == 1); // should hold
+		} catch (bytes memory /*reason*/) {
+			assert(x == 1); // should hold
+		}
+		assert((success && x == 42) || (!success && x == 1)); // should hold
+		assert(success); // can fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (415-430): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses_2.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses_2.sol
new file mode 100644
index 00000000..b7b5de64
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_catch_clauses_2.sol
@@ -0,0 +1,25 @@
+contract C {
+
+	function g() public pure {}
+
+	function f() public view {
+		uint x = 0;
+		bool success = false;
+		try this.g() {
+			success = true;
+			x = 1;
+		} catch Error (string memory /*reason*/) {
+			x = 2;
+		} catch (bytes memory /*reason*/) {
+			x = 3;
+		}
+		assert(x > 0 && x < 4); // should hold
+		assert(x == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (306-320): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values.sol
new file mode 100644
index 00000000..a53f0c13
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values.sol
@@ -0,0 +1,28 @@
+abstract contract D {
+	function d() external virtual returns (uint x, bool b);
+}
+
+contract C {
+
+	int x;
+	D d;
+
+	function f() public {
+		x = 0;
+		try d.d() returns (uint x, bool c) {
+			assert(x == 0); // should fail, x is the local variable shadowing the state variable
+			assert(!c); // should fail, c can be anything
+		} catch {
+			assert(x == 0); // should hold, x is the state variable
+			assert(x == 1); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2519: (164-170): This declaration shadows an existing declaration.
+// Warning 6328: (185-199): CHC: Assertion violation happens here.
+// Warning 6328: (273-283): CHC: Assertion violation happens here.
+// Warning 6328: (393-407): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values_with_tuple.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values_with_tuple.sol
new file mode 100644
index 00000000..ccbd4442
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_multiple_returned_values_with_tuple.sol
@@ -0,0 +1,28 @@
+contract C {
+
+	struct S {
+		uint x;
+		int y;
+	}
+
+	function g() public pure returns (bool b, S memory s) {
+		b = true;
+		s.x = 42;
+		s.y = -1;
+	}
+
+	function f() public view {
+		bool success = false;
+		try this.g() returns (bool b, S memory s) {
+			success = true;
+			assert(b && s.x == 42 && s.y == -1);
+		} catch {
+		}
+		assert(success); // fails, not guaranteed that there will be no error
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (321-336): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_1.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_1.sol
new file mode 100644
index 00000000..2407d893
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_1.sol
@@ -0,0 +1,24 @@
+contract C {
+	int public x;
+
+	function f() public view {
+		int y = 42;
+		bool success = false;
+		try this.x() returns (int v) {
+			y = v;
+			try this.x() returns (int w) {
+				success = true;
+				y = w;
+			}
+			catch {}
+		} catch {}
+		assert(!success || y == x); // should hold
+		assert(y == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (280-295): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_2.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_2.sol
new file mode 100644
index 00000000..e1935cf9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_2.sol
@@ -0,0 +1,25 @@
+contract C {
+	function g() public pure returns (uint, uint) {
+	}
+	function f() public view {
+		uint choice = 42;
+		try this.g() returns (uint, uint) {
+			choice = 10;
+			try this.g() returns (uint, uint) {
+				choice = 1;
+			} catch {
+				choice = 2;
+			}
+		} catch {
+			choice = 3;
+		}
+		assert(choice >= 1 && choice <= 3); // should hold
+		assert(choice == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (342-362): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_3.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_3.sol
new file mode 100644
index 00000000..7ce761a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_nested_3.sol
@@ -0,0 +1,24 @@
+contract C {
+	function g() public pure returns (uint) {
+	}
+	function f() public view {
+		uint choice = 42;
+		try this.g() returns (uint) {
+			choice = 1;
+		} catch{
+			choice = 10;
+			try this.g() returns (uint) {
+				choice = 2;
+			} catch {
+				choice = 3;
+			}
+		}
+		assert(choice >= 1 && choice <= 3); // should hold
+		assert(choice == 42); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (323-343): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_new.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_new.sol
new file mode 100644
index 00000000..5c98c279
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_new.sol
@@ -0,0 +1,32 @@
+contract Reverts {
+    constructor(uint) { revert("test message."); }
+}
+contract Succeeds {
+    constructor(uint) { }
+}
+
+contract C {
+    function f() public returns (Reverts x, string memory txt) {
+        uint i = 3;
+        try new Reverts(i) returns (Reverts r) {
+            x = r;
+            txt = "success";
+        } catch Error(string memory s) {
+            txt = s;
+        }
+    }
+    function g() public returns (Succeeds x, string memory txt) {
+        uint i = 8;
+        try new Succeeds(i) returns (Succeeds r) {
+            x = r;
+            txt = "success";
+        } catch Error(string memory s) {
+            txt = s;
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8729: (231-245): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
+// Warning 8729: (492-507): Contract deployment is only supported in the trusted mode for external calls with the CHC engine.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var.sol
new file mode 100644
index 00000000..23c2a7b6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var.sol
@@ -0,0 +1,16 @@
+contract C {
+	int public x;
+
+	function f() public view {
+		try this.x() returns (int v) {
+			assert(x == v); // should hold
+		} catch {
+			assert(false); // this fails, because we over-approximate every external call in the way that it can both succeed and fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (139-152): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var_mapping.sol
new file mode 100644
index 00000000..ae38765c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_public_var_mapping.sol
@@ -0,0 +1,25 @@
+contract C {
+	mapping (uint => uint[]) public m;
+
+	constructor() {
+		m[0].push();
+		m[0].push();
+		m[0][1] = 42;
+	}
+
+	function f() public view {
+		try this.m(0,1) returns (uint y) {
+			assert(y == m[0][1]); // should hold
+		}
+		catch {
+			assert(m[0][1] == 42); // should hold
+			assert(m[0][1] == 1); // should fail
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (280-300): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_bytes_array.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_bytes_array.sol
new file mode 100644
index 00000000..93f1a347
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_bytes_array.sol
@@ -0,0 +1,19 @@
+contract C {
+
+	function g() public pure returns (bytes memory) {
+		return hex"ffff";
+	}
+
+	function f() public view {
+		try this.g() returns (bytes memory b) {
+			assert(b[0] == bytes1(uint8(255)) && b[1] == bytes1(uint8(255))); // should hold
+			// Disabled because of Spacer seg fault
+			//assert(b[0] == bytes1(uint8(0)) || b[1] == bytes1(uint8(0))); // should fail
+		} catch {
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_fixed_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_fixed_bytes.sol
new file mode 100644
index 00000000..e84b0f6a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/try_catch/try_string_literal_to_fixed_bytes.sol
@@ -0,0 +1,20 @@
+contract C {
+
+	function g() public pure returns (bytes2) {
+		return hex"ffff";
+	}
+
+	function f() public view {
+		try this.g() returns (bytes2 b) {
+			assert(uint8(b[0]) == 255 && uint8(b[1]) == 255); // should hold
+			assert(uint8(b[0]) == 0 || uint8(b[1]) == 0); // should fail
+		} catch {
+		}
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (218-262): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/address_literal.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/address_literal.sol
new file mode 100644
index 00000000..5189b45e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/address_literal.sol
@@ -0,0 +1,26 @@
+contract C {
+  address x; // We know that this is "zero initialised".
+  function f() public view {
+    address a = address(0);
+    assert(x == address(0));
+    assert(x == a);
+  }
+
+  function g() public pure {
+    address a = address(0);
+    address b = address(1);
+    address c = address(0);
+    address d = a;
+    address e = address(0x12345678);
+    assert(c == d);
+    assert(a == c);
+    assert(e == address(305419896));
+    // This is untrue.
+    assert(a == b);
+  }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (454-468): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/bytes_to_fixed_bytes_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/bytes_to_fixed_bytes_1.sol
new file mode 100644
index 00000000..bc3d92b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/bytes_to_fixed_bytes_1.sol
@@ -0,0 +1,18 @@
+contract C {
+	function f() external pure {
+		bytes memory b = hex"00010203040506070809000102030405060708090001020304050607080900010203040506070809";
+		bytes8 c = bytes8(b);
+		assert(c == 0x0001020304050607); // should hold
+		bytes16 d = bytes16(b);
+		assert(d == 0x00010203040506070809000102030405);
+		bytes24 e = bytes24(b);
+		assert(e == 0x000102030405060708090001020304050607080900010203); // should hold
+		bytes32 g = bytes32(b);
+		assert(g == 0x0001020304050607080900010203040506070809000102030405060708090001); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_address_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_address_1.sol
new file mode 100644
index 00000000..c106dfc1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_address_1.sol
@@ -0,0 +1,11 @@
+contract C
+{
+	function f(address a) public pure {
+		require(a != address(0));
+		assert(a != address(0));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_different_size_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_different_size_1.sol
new file mode 100644
index 00000000..2e0d6332
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_different_size_1.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f() public pure {
+		bytes2 a = 0x1234;
+		uint32 b = uint16(a); // b will be 0x00001234
+		assert(b == 0x1234);
+		uint32 c = uint32(bytes4(a)); // c will be 0x12340000
+		assert(c == 0x12340000);
+		uint8 d = uint8(uint16(a)); // d will be 0x34
+		assert(d == 0x34);
+		uint8 e = uint8(bytes1(a)); // e will be 0x12
+		assert(e == 0x12);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_1.sol
new file mode 100644
index 00000000..05383eb3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(uint8 x) public pure {
+		uint16 y = uint16(x);
+		// True because of x's type
+		assert(y < 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_2.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_2.sol
new file mode 100644
index 00000000..a608372d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_2.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	function f() public pure {
+		uint16 a = 0x1234;
+		uint32 b = uint32(a); // b will be 0x00001234 now
+		// This is correct (left padding).
+		assert(a == b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_3.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_3.sol
new file mode 100644
index 00000000..fca18d82
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_larger_3.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		bytes2 a = 0x1234;
+		bytes4 b = bytes4(a); // b will be 0x12340000
+		// False positive since right padding is not supported yet.
+		assert(b == 0x12340000);
+		// This should fail (right padding).
+		assert(a == b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (240-254): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_1.sol
new file mode 100644
index 00000000..05c8756d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(uint16 x) public pure {
+		uint8 y = uint8(x);
+		// True because of y's type
+		assert(y < 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_2.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_2.sol
new file mode 100644
index 00000000..66782a49
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_2.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f() public pure {
+		uint32 a = 0x12345678;
+		uint16 b = uint16(a); // b will be 0x5678 now
+		assert(b == 0x5678);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_3.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_3.sol
new file mode 100644
index 00000000..c524f21b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/cast_smaller_3.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f() public pure {
+		bytes2 a = 0x1234;
+		bytes1 b = bytes1(a); // b will be 0x12
+		assert(b == 0x12);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/downcast.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/downcast.sol
new file mode 100644
index 00000000..bba3585f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/downcast.sol
@@ -0,0 +1,49 @@
+contract C {
+	function f1() public pure {
+		// signed <- signed
+		int8 z = int8(-1);
+		assert(z == -1);
+		z = int8(int(0) - 1);
+		assert(z == -1);
+		z = int8(int(0) - 1);
+		assert(z == -1);
+		z = int8(int(0) - 2);
+		assert(z == -2);
+		z = int8(int(0) - 1);
+		assert(z == -1);
+
+		// unsigned <= unsigned
+		uint8 x = uint8(type(uint256).max);
+		assert(x == 255);
+		x = uint8(type(uint256).max);
+		assert(x == 255);
+
+		// signed <- unsigned
+		int8 y = int8(uint8(type(uint16).max));
+		assert(y == -1);
+		y = int8(uint8(uint16(100)));
+		assert(y == 100);
+		y = int8(uint8(uint16(200)));
+		assert(y == -56);
+
+		// unsigned <- signed
+		uint8 v = uint8(type(uint16).max);
+		assert(v == 255);
+		v = uint8(int8(int16(300)));
+		assert(v == 44);
+		v = uint8(int8(int16(200)));
+		assert(v == 200);
+
+		// fixed bytes
+		bytes2 b = bytes2(bytes4(0xcafeffff));
+		assert(b == 0xcafe);
+		b = bytes2(bytes4(bytes8(0xaaaabbbbccccdddd)));
+		assert(b == 0xaaaa);
+		b = bytes2(bytes8(0xaaaabbbbccccdddd));
+		assert(b == 0xaaaa);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 20 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/enum_from_uint.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/enum_from_uint.sol
new file mode 100644
index 00000000..c051db01
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/enum_from_uint.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	enum D { Left, Right }
+	function f(uint x) public pure {
+		require(x == 0);
+		D _a = D(x);
+		assert(_a == D.Left);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/enum_to_uint_max_value.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/enum_to_uint_max_value.sol
new file mode 100644
index 00000000..e65cf683
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/enum_to_uint_max_value.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	enum D { Left, Right }
+	function f(D _a) public pure {
+		uint x = uint(_a);
+		assert(x < 10);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/function_type_to_function_type_internal.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/function_type_to_function_type_internal.sol
new file mode 100644
index 00000000..2aba4b28
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/function_type_to_function_type_internal.sol
@@ -0,0 +1,23 @@
+contract C {
+	function(uint) returns (uint) a;
+	function(uint) returns (uint) b;
+	function f(function(uint) returns (uint) g, function(uint) returns (uint) h) internal {
+		assert(g(2) == h(2));
+		assert(g == h);
+	}
+	function g() public {
+		f(a, b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 2519: (93-124): This declaration shadows an existing declaration.
+// Warning 3075: (203-209): Comparison of internal function pointers can yield unexpected results in the legacy pipeline with the optimizer enabled, and will be disallowed entirely in the next breaking release.
+// Warning 6031: (179-183): Internal error: Expression undefined for SMT solver.
+// Warning 6031: (187-191): Internal error: Expression undefined for SMT solver.
+// Warning 7229: (203-209): Assertion checker does not yet implement the type function (uint256) returns (uint256) for comparisons
+// Warning 5729: (179-183): BMC does not yet implement this type of function call.
+// Warning 5729: (187-191): BMC does not yet implement this type of function call.
+// Warning 6328: (172-192): CHC: Assertion violation happens here.\nCounterexample:\na = 0, b = 0\n\nTransaction trace:\nC.constructor()\nState: a = 0, b = 0\nC.g()\n    C.f(0, 0) -- internal call
+// Warning 6328: (196-210): CHC: Assertion violation happens here.\nCounterexample:\na = 0, b = 0\n\nTransaction trace:\nC.constructor()\nState: a = 0, b = 0\nC.g()\n    C.f(0, 0) -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/implicit_cast_string_literal_byte.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/implicit_cast_string_literal_byte.sol
new file mode 100644
index 00000000..b98c518a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/implicit_cast_string_literal_byte.sol
@@ -0,0 +1,17 @@
+contract C {
+	mapping (bytes1 => uint) map;
+	function f() public {
+		map[""] = 2;
+		uint x = map[""];
+		g("");
+		bytes1 b = "";
+		assert(x == map[b]);
+		assert(x == map["x"]);
+	}
+	function g(bytes1 b) internal pure {}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (153-174): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/number_literal.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/number_literal.sol
new file mode 100644
index 00000000..af7da87d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/number_literal.sol
@@ -0,0 +1,33 @@
+contract C {
+  function f() public pure {
+    uint x = 1234;
+    uint y = 0;
+    assert(x != y);
+    assert(x == uint(1234));
+    assert(y == uint(0));
+  }
+  function g() public pure {
+    uint a = uint(0);
+    uint b = type(uint256).max;
+    uint c = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
+    int d = -1;
+    uint e = uint(d);
+    assert(a != b);
+    assert(b == c);
+    assert(b == e);
+  }
+  function h() public pure {
+    uint32 a = uint32(0);
+    uint32 b = type(uint32).max;
+    uint32 c = 4294967295;
+    int32 d = -1;
+    uint32 e = uint32(d);
+    assert(a != b);
+    assert(b == c);
+    assert(b == e);
+  }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/same_size.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/same_size.sol
new file mode 100644
index 00000000..b55e2606
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/same_size.sol
@@ -0,0 +1,74 @@
+abstract contract D {}
+
+enum E {A, B}
+
+contract C {
+	function f1() public pure {
+		// signed <- unsigned
+		int8 x = int8(uint8(200));
+		assert(x == -56);
+		int256 y = int256(uint256(2**255 + 10));
+		assert(y == -(2**255) + 10);
+		int256 z = int256(uint(2**255 + 10));
+		assert(z == -(2**255) + 10);
+		int256 t = int256(uint256(bytes32(uint256(200))));
+		assert(t == 200);
+		int256 v = int256(uint256(bytes32(uint256(2**255 + 10))));
+		assert(v == -(2**255) + 10);
+		int160 a = int160(uint160(address(type(uint160).max)));
+		assert(a == -1);
+		int160 b = int160(uint160(address(uint160(uint(2**159 + 10)))));
+		assert(b == -(2**159) + 10);
+		D d;
+		int160 e = int160(uint160(address(d)));
+		assert(e == 0);
+	}
+
+	function f2() public pure {
+		// unsigned <- signed
+		uint8 x = uint8(int8(100));
+		assert(x == 100);
+		uint16 y = uint16(int16(200));
+		assert(y == 200);
+		uint8 z = uint8(int8(-100));
+		assert(z == 156);
+		uint16 t = uint16(int16(-200));
+		assert(t == type(uint16).max - 200 + 1);
+		uint256 v = uint256(int256(-200));
+		assert(v == 2**256 - 200);
+		uint256 w = uint256(type(uint256).max - 1);
+		assert(w == 2**256 - 2);
+		bytes4 b = bytes4(uint32(type(uint256).max - 1));
+		assert(uint32(b) == uint32(2**32 - 2));
+		address a = address(type(uint160).max);
+		assert(uint160(a) == uint160(2**160 - 1));
+		address c = address(0);
+		assert(uint160(c) == 0);
+		D d;
+		address e = address(d);
+		assert(uint160(e) == 0);
+		E f = E(1);
+		assert(uint(f) == 1);
+	}
+
+	function f3() public pure {
+		// unsigned <- unsigned
+		uint8 x = uint8(bytes1(uint8(100)));
+		assert(x == 100);
+		address a = address(0);
+		assert(a == address(uint160(0)));
+		D d;
+		assert(a == address(d));
+	}
+
+	function f4() public pure {
+		// signed <- signed
+		int8 x = -10;
+		int8 y = int8(x);
+		assert(y == -10);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 27 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_dynamic_bytes.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_dynamic_bytes.sol
new file mode 100644
index 00000000..d4e7615e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_dynamic_bytes.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		bytes memory b = bytes(hex"ffff");
+		assert(b.length == 2); // should hold
+		assert(b[0] == bytes1(uint8(255))); // should hold
+		assert(b[1] == bytes1(uint8(100))); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (173-207): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_constant_initialization_2.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_constant_initialization_2.sol
new file mode 100644
index 00000000..013f8155
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_constant_initialization_2.sol
@@ -0,0 +1,11 @@
+contract MockContract {
+	bytes4 public constant SENTINEL_ANY_MOCKS = hex"01";
+
+	constructor() {
+		assert(SENTINEL_ANY_MOCKS >= 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_modifier.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_modifier.sol
new file mode 100644
index 00000000..fb98c506
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_modifier.sol
@@ -0,0 +1,13 @@
+contract B {
+    function f() mod2("0123456") pure public { }
+    modifier mod2(bytes7 a) {
+		assert(a == "0123456");
+		assert(a == "1234567");
+		_;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (120-142): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return.sol
new file mode 100644
index 00000000..ecdc253e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return.sol
@@ -0,0 +1,14 @@
+contract C {
+    function g() public pure returns (bytes32 val) { return "abc"; }
+    function f1() public pure returns (bytes32 val) { return g(); }
+
+	function a() public pure {
+		assert(f1() == "abc");
+		assert(f1() == "cde");
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (206-227): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return_multi.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return_multi.sol
new file mode 100644
index 00000000..4ba6ba2e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_return_multi.sol
@@ -0,0 +1,17 @@
+contract C {
+    function h() public pure returns (bytes32 val, bytes3 val2) { return ("abc", "def"); }
+    function g() public pure returns (bytes32 val) { return "abc"; }
+    function f1() public pure returns (bytes32 val) { return g(); }
+    function f2() public pure returns (bytes32 val, bytes3 val2) { return h(); }
+
+	function a() public pure {
+		(bytes32 v1, bytes3 v2) = f2();
+		assert(v1 == "abc");
+		assert(v2 == "cde");
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (410-429): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_upcast.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_upcast.sol
new file mode 100644
index 00000000..be1af11c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_literal_to_fixed_bytes_upcast.sol
@@ -0,0 +1,11 @@
+contract C {
+	function f() public pure {
+		assert(bytes4(hex"0000ffff") == bytes4(hex"ffff")); // should fail
+		assert(bytes4(hex"ffff0000") == bytes4(hex"ffff")); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (43-93): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_1.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_1.sol
new file mode 100644
index 00000000..01027e2b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_1.sol
@@ -0,0 +1,15 @@
+contract C {
+	string x;
+
+	function s() public {
+		x = "abc";
+		bytes(x).push("a");
+		assert(bytes(x).length == 4); // should hold
+		assert(bytes(x).length == 3); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (132-160): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_2.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_2.sol
new file mode 100644
index 00000000..827c6e11
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/string_to_bytes_push_2.sol
@@ -0,0 +1,16 @@
+contract C {
+	string x;
+
+	function s() public {
+		x = "abc";
+		((bytes(((x))))).push("a");
+		assert(bytes(x).length == 4); // should hold
+		assert(bytes(x).length == 3); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (140-168): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/typecast/upcast.sol b/compiler/test/libsolidity/smtCheckerTests/typecast/upcast.sol
new file mode 100644
index 00000000..db9e90df
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/typecast/upcast.sol
@@ -0,0 +1,70 @@
+abstract contract D {}
+
+contract C {
+	function f1() public pure {
+		// unsigned <- signed
+		uint16 x = type(uint16).max;
+		assert(x == 65535);
+		int8 i = int8(-1);
+		assert(i == -1);
+		x = uint16(uint8(int8(-1)));
+		assert(x == 255);
+		x = uint16(int16(i));
+		assert(x == 65535);
+		uint z = uint(uint8(i));
+		assert(z == 255);
+	}
+
+	function f2() public pure {
+		// signed <- unsigned
+		int16 y = int16(uint16(uint8(uint(65535))));
+		assert(y == 255);
+		int z = int(uint(uint8(type(uint).max)));
+		assert(z == 255);
+		z = int(uint(uint8(255)));
+		assert(z == 255);
+	}
+
+	function f3() public pure {
+		// signed <- signed
+		int16 y = int16(uint16(uint8(int8(int(uint(65535))))));
+		assert(y == 255);
+		int z = int(int8(-1));
+		assert(z == -1);
+		z = int(int8(int(255)));
+		assert(z == -1);
+		z = int(int16(5000));
+		assert(z == 5000);
+	}
+
+	function f4() public pure {
+		// unsigned <- unsigned
+		uint x = uint(uint8(type(uint).max));
+		assert(x == 255);
+		x = uint(uint16(type(uint).max));
+		assert(x == 65535);
+		x = uint(uint16(5000));
+		assert(x == 5000);
+		uint16 y = uint16(type(uint).max);
+		assert(y == 65535);
+		y = uint16(uint8(type(uint16).max));
+		assert(y == 255);
+		address a = address(uint160(uint8(0)));
+		assert(a == address(0));
+		D d = D(address(uint160(uint8(0))));
+		assert(a == address(d));
+		bytes2 b1 = 0xcafe;
+		bytes4 b2 = bytes4(b1);
+		assert(b2 == 0xcafe0000);
+		bytes16 b3 = bytes16(b1);
+		assert(b3 == 0xcafe0000000000000000000000000000);
+		bytes4 b4 = bytes4(uint32(0xcafe));
+		assert(b4 == 0x0000cafe);
+		bytes4 b5 = bytes4(uint32(0xcafe0000));
+		assert(b5 == 0xcafe0000);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 23 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/abi_type_type_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/abi_type_type_1.sol
new file mode 100644
index 00000000..2341b7c8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/abi_type_type_1.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(bytes memory d) public pure {
+		(bool a, uint x) = abi.decode(d, (bool, uint));
+		assert(a == (x == 2)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (107-128): CHC: Assertion violation happens here.\nCounterexample:\n\na = false\nx = 2\n\nTransaction trace:\nC.constructor()\nC.f(d)
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/address_call.sol b/compiler/test/libsolidity/smtCheckerTests/types/address_call.sol
new file mode 100644
index 00000000..063909f8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/address_call.sol
@@ -0,0 +1,28 @@
+contract C
+{
+	uint x;
+	mapping (uint => uint) map;
+	function f(address a, bytes memory data) public {
+		x = 0;
+		map[0] = 0;
+		mapping (uint => uint) storage localMap = map;
+		(bool success, bytes memory ret) = a.call(data);
+		assert(success);
+		assert(x == 0);
+		// Disabled because of Spacer nondeterminism.
+		//assert(map[0] == 0);
+		// Disabled because of Spacer nondeterminism.
+		//assert(localMap[0] == 0);
+	}
+}
+// ====
+// EVMVersion: >spuriousDragon
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreInv: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 2072: (127-166): Unused local variable.
+// Warning 2072: (191-207): Unused local variable.
+// Warning 6328: (227-242): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/address_staticcall.sol b/compiler/test/libsolidity/smtCheckerTests/types/address_staticcall.sol
new file mode 100644
index 00000000..3479a38b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/address_staticcall.sol
@@ -0,0 +1,25 @@
+contract C
+{
+	uint x;
+	mapping (uint => uint) map;
+	function f(address a, bytes memory data) public {
+		x = 0;
+		map[0] = 0;
+		mapping (uint => uint) storage localMap = map;
+		(bool success, bytes memory ret) = a.staticcall(data);
+		assert(success);
+		assert(x == 0);
+		assert(map[0] == 0);
+		// Disabled because of Spacer's seg fault
+		//assert(localMap[0] == 0);
+	}
+}
+// ====
+// EVMVersion: >spuriousDragon
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2072: (127-166): Unused local variable.
+// Warning 2072: (191-207): Unused local variable.
+// Warning 6328: (233-248): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/address_transfer.sol b/compiler/test/libsolidity/smtCheckerTests/types/address_transfer.sol
new file mode 100644
index 00000000..89e8ae10
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/address_transfer.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(address payable a) public {
+		uint x = 100;
+		require(x == a.balance);
+		a.transfer(600);
+		// This fails since a == this is possible.
+		assert(a.balance == 700);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (162-186): CHC: Assertion violation happens here.
+// Warning 1236: (98-113): BMC: Insufficient funds happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/address_transfer_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/address_transfer_3.sol
new file mode 100644
index 00000000..02d20c4f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/address_transfer_3.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	function f(address payable a) public {
+		require(1000 == address(this).balance);
+		require(100 == a.balance);
+		a.transfer(600);
+		// a == this is not possible because address(this).balance == 1000
+		// and a.balance == 100,
+		// so this should hold in CHC, ignoring the transfer revert.
+		assert(a.balance == 700);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Info 6002: BMC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol
new file mode 100644
index 00000000..07f0c9c1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_1.sol
@@ -0,0 +1,54 @@
+pragma abicoder               v2;
+
+contract C
+{
+	function f(
+		uint[] memory a,
+		uint[] memory b,
+		uint[][] memory cc,
+		uint8[][] memory dd,
+		uint[][][] memory eee
+	) public pure {
+		require(a.length > 0);
+		require(b.length > 0);
+		require(cc.length > 0);
+		require(cc[0].length > 0);
+		require(dd.length > 0);
+		require(dd[0].length > 0);
+		require(eee.length > 0);
+		require(eee[0].length > 0);
+		require(eee[0][0].length > 0);
+		a[0] = 2;
+		// The accesses below are safe but oob is reported because of aliasing.
+		cc[0][0] = 50;
+		dd[0][0] = 10;
+		eee[0][0][0] = 50;
+		b[0] = 1;
+		// Fails because
+		// b == a is possible
+		// b == cc[0] is possible
+		// b == ee[0][0] is possible
+		assert(a[0] == 2 || cc[0][0] == 50 || eee[0][0][0] == 50);
+		// Should not fail since knowledge is erased only for uint[].
+		assert(dd[0][0] == 10);
+		assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (523-528): CHC: Out of bounds access happens here.
+// Warning 6368: (523-531): CHC: Out of bounds access happens here.
+// Warning 6368: (557-563): CHC: Out of bounds access happens here.
+// Warning 6368: (557-566): CHC: Out of bounds access happens here.
+// Warning 6368: (557-569): CHC: Out of bounds access happens here.
+// Warning 6368: (578-582): CHC: Out of bounds access happens here.
+// Warning 6368: (699-703): CHC: Out of bounds access happens here.
+// Warning 6368: (712-717): CHC: Out of bounds access happens here.
+// Warning 6368: (712-720): CHC: Out of bounds access happens here.
+// Warning 6368: (730-736): CHC: Out of bounds access happens here.
+// Warning 6368: (730-739): CHC: Out of bounds access happens here.
+// Warning 6368: (730-742): CHC: Out of bounds access happens here.
+// Warning 6328: (692-749): CHC: Assertion violation happens here.
+// Warning 6368: (850-854): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol
new file mode 100644
index 00000000..e90d4fbf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_2.sol
@@ -0,0 +1,34 @@
+pragma abicoder               v2;
+
+contract C
+{
+	uint[] array;
+	function p() public {
+		array.push();
+	}
+	function f(uint[] memory a, uint[] memory b) public {
+		require(a.length > 0);
+		require(b.length > 0);
+		require(array.length > 0);
+		array[0] = 42;
+		a[0] = 2;
+		// Access is safe but oob is reported due of aliasing.
+		b[0] = 1;
+		// Erasing knowledge about memory references should not
+		// erase knowledge about state variables.
+		// Removed because current Spacer seg faults.
+		//assert(array[0] == 42);
+		// Accesses are safe but oob is reported due of aliasing.
+		assert(a[0] == 2);
+		assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (327-331): CHC: Out of bounds access happens here.
+// Warning 6368: (584-588): CHC: Out of bounds access happens here.
+// Warning 6328: (577-594): CHC: Assertion violation happens here.
+// Warning 6368: (605-609): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol
new file mode 100644
index 00000000..c2307456
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_memory_3.sol
@@ -0,0 +1,31 @@
+pragma abicoder               v2;
+
+contract C
+{
+	uint[] array;
+	constructor() {
+		array.push();
+	}
+	function f(uint[] memory a, uint[] memory b) public {
+		require(a.length > 0);
+		array[0] = 42;
+		uint[] storage c = array;
+		a[0] = 2;
+		require(b.length > 0);
+		b[0] = 1;
+		// Erasing knowledge about memory references should not
+		// erase knowledge about state variables.
+		assert(array[0] == 42);
+		// Erasing knowledge about memory references should not
+		// erase knowledge about storage references.
+		assert(c[0] == 42);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(a[0] == 2);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_1.sol
new file mode 100644
index 00000000..199ccbc1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_1.sol
@@ -0,0 +1,56 @@
+contract C
+{
+	uint[] array;
+	uint[][] array2d;
+	uint[][][][] array4d;
+	uint8[] tinyArray;
+	uint8[][][] tinyArray3d;
+	function f(
+		uint[] storage a,
+		uint[] storage b,
+		uint[][] storage cc,
+		uint8[][] storage dd,
+		uint[][][] storage eee
+	) internal {
+		a[0] = 2;
+		array[0] = 42;
+		array2d[0][0] = 42;
+		tinyArray[0] = 42;
+		cc[0][0] = 42;
+		dd[0][0] = 42;
+		eee[0][0][0] = 42;
+		b[0] = 1;
+		// Fails because b == a is possible.
+		assert(a[0] == 2);
+		// Fails because b == array is possible.
+		assert(array[0] == 42);
+		// Fails because b == array2d[0] is possible.
+		assert(array2d[0][0] == 42);
+		// Should not fail since knowledge is erased only for uint[].
+		assert(tinyArray[0] == 42);
+		// Fails because b == cc[0] is possible.
+		assert(cc[0][0] == 42);
+		// Should not fail since knowledge is erased only for uint[].
+		assert(dd[0][0] == 42);
+		// Fails because b == ee[0][0] is possible.
+		assert(eee[0][0][0] == 42);
+		assert(b[0] == 1);
+	}
+
+	function g(uint a, uint b, uint c, uint d, uint e) public {
+		require(a < array2d.length);
+		require(b < array2d.length);
+		require(c < array4d.length);
+		require(c < array4d[c].length);
+		require(d < tinyArray3d.length);
+		require(e < array4d.length);
+		// Disabled because of Spacer seg fault.
+		//f(array2d[a], array2d[b], array4d[c][c], tinyArray3d[d], array4d[e]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2018: (957-1329): Function state mutability can be restricted to view
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_2.sol
new file mode 100644
index 00000000..b9e726d9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_2.sol
@@ -0,0 +1,38 @@
+contract C
+{
+	uint[][] array2d;
+	function p() public {
+		array2d.push().push();
+	}
+	function g(uint x, uint y, uint[] memory c) public {
+		require(x < array2d.length);
+		require(y < array2d.length);
+		f(array2d[x], array2d[y], c);
+	}
+
+	function f(uint[] storage a, uint[] storage b, uint[] memory c) internal {
+		require(a.length > 0);
+		require(b.length > 0);
+		require(c.length > 0);
+		c[0] = 42;
+		a[0] = 2;
+		// Access is safe but oob is reported because of aliasing.
+		b[0] = 1;
+		// Erasing knowledge about storage references should not
+		// erase knowledge about memory references.
+		assert(c[0] == 42);
+		// Fails because b == a is possible.
+		assert(a[0] == 2);
+		// Access is safe but oob is reported because of aliasing.
+		assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (474-478): CHC: Out of bounds access happens here.
+// Warning 6368: (659-663): CHC: Out of bounds access happens here.
+// Warning 6328: (652-669): CHC: Assertion violation happens here.
+// Warning 6368: (741-745): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_3.sol
new file mode 100644
index 00000000..3d8dbc05
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_aliasing_storage_3.sol
@@ -0,0 +1,42 @@
+contract C
+{
+	uint[][] array2d;
+	function p() public { array2d.push().push(); }
+	function g(uint x, uint y, uint[] memory c) public {
+		require(x < array2d.length);
+		require(y < array2d.length);
+		f(array2d[x], array2d[y], c);
+	}
+	function f(uint[] storage a, uint[] storage b, uint[] memory c) internal {
+		require(a.length > 0);
+		require(b.length > 0);
+		require(c.length > 0);
+		uint[] memory d = c;
+		c[0] = 42;
+		a[0] = 2;
+		// Access is safe but oob is reported due of aliasing.
+		b[0] = 1;
+		// Erasing knowledge about storage references should not
+		// erase knowledge about memory references.
+		// Disabled because of Spacer's seg fault.
+		//assert(c[0] == 42);
+		// Erasing knowledge about storage references should not
+		// erase knowledge about memory references.
+		// Disabled because of Spacer's seg fault.
+		//assert(d[0] == 42);
+		// Fails because b == a is possible.
+		// Accesses are safe but oob is reported due of aliasing.
+		assert(a[0] == 2);
+		assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2072: (384-399): Unused local variable.
+// Warning 6368: (489-493): CHC: Out of bounds access happens here.
+// Warning 6368: (955-959): CHC: Out of bounds access happens here.
+// Warning 6328: (948-965): CHC: Assertion violation happens here.
+// Warning 6368: (976-980): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branch_1d.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branch_1d.sol
new file mode 100644
index 00000000..43b6cc0d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branch_1d.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(bool b, uint[] memory c) public pure {
+		require(c.length >= 1 && c.length <= 2);
+		c[0] = 0;
+		if (b)
+			c[0] = 1;
+		assert(c[0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (143-159): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branch_3d.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branch_3d.sol
new file mode 100644
index 00000000..8ba3f013
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branch_3d.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint[][][] c;
+	constructor() {
+		c.push();
+		c[0].push();
+		c[0][0].push();
+	}
+	function f(bool b) public {
+		c[0][0][0] = 0;
+		if (b)
+			c[0][0][0] = 1;
+		assert(c[0][0][0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (124-131): CHC: Out of bounds access might happen here.
+// Warning 6368: (124-134): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-159): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-162): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-184): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-187): CHC: Out of bounds access might happen here.
+// Warning 6328: (170-192): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branches_1d.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_1d.sol
new file mode 100644
index 00000000..61abb418
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_1d.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(bool b, uint[] memory c) public pure {
+		require(c.length > 0);
+		c[0] = 0;
+		if (b)
+			c[0] = 1;
+		else
+			c[0] = 2;
+		assert(c[0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branches_2d.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_2d.sol
new file mode 100644
index 00000000..f4743dcc
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_2d.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	uint[][] c;
+	function p() public {
+		c.push().push();
+	}
+	function f(bool b) public {
+		require(c.length > 0);
+		require(c[0].length > 0);
+		c[0][0] = 0;
+		if (b)
+			c[0][0] = 1;
+		else
+			c[0][0] = 2;
+		assert(c[0][0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d.sol
new file mode 100644
index 00000000..ecd419ee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d.sol
@@ -0,0 +1,25 @@
+contract C
+{
+	uint[][][] c;
+	constructor() {
+		c.push();
+		c[0].push();
+		c[0][0].push();
+	}
+	function f(bool b) public {
+		c[0][0][0] = 0;
+		if (b)
+			c[0][0][0] = 1;
+		assert(c[0][0][0] < 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (124-131): CHC: Out of bounds access might happen here.
+// Warning 6368: (124-134): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-159): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-162): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-184): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-187): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d_show_unproved.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d_show_unproved.sol
new file mode 100644
index 00000000..acd57447
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_branches_3d_show_unproved.sol
@@ -0,0 +1,26 @@
+contract C
+{
+	uint[][][] c;
+	constructor() {
+		c.push();
+		c[0].push();
+		c[0][0].push();
+	}
+	function f(bool b) public {
+		c[0][0][0] = 0;
+		if (b)
+			c[0][0][0] = 1;
+		assert(c[0][0][0] < 2);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTShowUnproved: yes
+// ----
+// Warning 6368: (124-131): CHC: Out of bounds access might happen here.
+// Warning 6368: (124-134): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-159): CHC: Out of bounds access might happen here.
+// Warning 6368: (152-162): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-184): CHC: Out of bounds access might happen here.
+// Warning 6368: (177-187): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1.sol
new file mode 100644
index 00000000..2aba2bbe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint[] array;
+	constructor() {
+		array.push();
+		array.push();
+		array.push();
+		array.push();
+	}
+	function f(uint x, uint y) public {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1_fail.sol
new file mode 100644
index 00000000..bc512b55
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_1_fail.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint[] array;
+	function p() public { array.push(); }
+	function f(uint x, uint y) public {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (172-194): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2.sol
new file mode 100644
index 00000000..5e421cf4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	uint[][] array;
+	function f(uint x, uint y, uint z, uint t) public view {
+		require(array[x][y] == 200);
+		require(x == z && y == t);
+		assert(array[z][t] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6368: (98-106): CHC: Out of bounds access happens here.
+// Warning 6368: (98-109): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2_fail.sol
new file mode 100644
index 00000000..fa55bd7f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_2_fail.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	uint[][] array;
+	function a() public {
+		array.push().push();
+	}
+	function f(uint x, uint y, uint z, uint t) public {
+		require(x < array.length);
+		require(y < array[x].length);
+		array[x][y] = 200;
+		require(x == z && y == t);
+		assert(array[z][t] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (245-270): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3.sol
new file mode 100644
index 00000000..ae90faa4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint[][][] array;
+	function f(uint x, uint y, uint z, uint t, uint w, uint v) public view {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(z < array[x][y].length);
+		require(array[x][y][z] == 200);
+		require(x == t && y == w && z == v);
+		assert(array[t][w][v] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3_fail.sol
new file mode 100644
index 00000000..76732c14
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_3_fail.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	uint[][][] array;
+	function p() public {
+		array.push().push().push();
+	}
+	function f(uint x, uint y, uint z, uint t, uint w, uint v) public {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(z < array[x][y].length);
+		array[x][y][z] = 200;
+		require(x == t && y == w && z == v);
+		assert(array[t][w][v] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (318-346): CHC: Assertion violation happens here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1.sol
new file mode 100644
index 00000000..7387e812
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	function f(uint[] memory array, uint x, uint y) public pure {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1_fail.sol
new file mode 100644
index 00000000..004bab44
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_dynamic_parameter_1_fail.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f(uint[] memory array, uint x, uint y) public pure {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (144-166): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_1.sol
new file mode 100644
index 00000000..79a1d08a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_1.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	function f() public pure {
+		uint[3] memory array = [uint(1), 2, 3];
+		assert(array[0] == 1);
+		assert(array[1] == 2);
+		assert(array[2] == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_2.sol
new file mode 100644
index 00000000..d48644c2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_2.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f() public pure {
+		uint[3] memory a = [uint(1), 2, 3];
+		uint[3] memory b = [uint(1), 2, 4];
+		assert(a[0] == b[0]);
+		assert(a[1] == b[1]);
+		assert(a[2] == b[2]); // fails
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (167-187): CHC: Assertion violation happens here.\nCounterexample:\n\na = [1, 2, 3]\nb = [1, 2, 4]\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_3.sol
new file mode 100644
index 00000000..cdaff2bf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_3.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function f() public pure {
+		(uint[3] memory a, uint[3] memory b) = ([uint(1), 2, 3], [uint(1), 2, 4]);
+		assert(a[0] == b[0]);
+		assert(a[1] == b[1]);
+		assert(a[2] == b[2]); // fails
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (168-188): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_4.sol
new file mode 100644
index 00000000..1c95ea98
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_4.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function f(bool c) public pure {
+		uint[3] memory a = c ? [uint(1), 2, 3] : [uint(1), 2, 4];
+		uint[3] memory b = [uint(1), 2, c ? 3 : 4];
+		assert(a[0] == b[0]);
+		assert(a[1] == b[1]);
+		assert(a[2] == b[2]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_5.sol
new file mode 100644
index 00000000..0a6fe02b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_5.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	uint[] s;
+	function f() public {
+		uint[3] memory a = [uint(1), 2, 3];
+		s = a;
+		assert(s.length == a.length);
+		assert(s[0] == a[0]);
+		assert(s[1] == a[1]);
+		assert(s[2] != a[2]); // fails
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (176-196): CHC: Assertion violation happens here.\nCounterexample:\ns = [1, 2, 3]\na = [1, 2, 3]\n\nTransaction trace:\nC.constructor()\nState: s = []\nC.f()
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_6.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_6.sol
new file mode 100644
index 00000000..b017aa93
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_6.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f() public pure {
+		uint[3] memory a = [uint(1), 2, 3];
+		uint[4] memory b = [uint(1), 2, 4, 3];
+		uint[4] memory c = b;
+		assert(a.length == c.length); // fails
+		assert(a[0] == c[0]);
+		assert(a[1] == c[1]);
+		assert(a[2] == c[2]); // fails
+		assert(a[2] == c[3]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (146-174): CHC: Assertion violation happens here.\nCounterexample:\n\na = [1, 2, 3]\nb = [1, 2, 4, 3]\nc = [1, 2, 4, 3]\n\nTransaction trace:\nC.constructor()\nC.f()
+// Warning 6328: (235-255): CHC: Assertion violation happens here.\nCounterexample:\n\na = [1, 2, 3]\nb = [1, 2, 4, 3]\nc = [1, 2, 4, 3]\n\nTransaction trace:\nC.constructor()\nC.f()
+// Info 1391: CHC: 11 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_literal_7.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_7.sol
new file mode 100644
index 00000000..21e34502
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_literal_7.sol
@@ -0,0 +1,25 @@
+contract C
+{
+	uint[] s;
+	function f() public {
+		uint[3] memory a = [uint(1), 2, 3];
+		uint[4] memory b = [uint(1), 2, 4, 3];
+		uint[4] memory c = b;
+		assert(c.length == b.length);
+		s = a;
+		assert(s.length == a.length);
+
+		assert(s.length == c.length); // fails
+		assert(s[0] == c[0]);
+		assert(s[1] == c[1]);
+		assert(s[2] == c[2]); // fails
+		assert(s[2] == c[3]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (226-254): CHC: Assertion violation happens here.
+// Warning 6328: (315-335): CHC: Assertion violation happens here.
+// Info 1391: CHC: 13 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_1.sol
new file mode 100644
index 00000000..3f9c8973
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_1.sol
@@ -0,0 +1,41 @@
+contract C
+{
+	mapping (uint => uint) singleMap;
+	mapping (uint => uint)[] severalMaps;
+	mapping (uint => uint8)[] severalMaps8;
+	mapping (uint => uint)[][] severalMaps3d;
+	function p() public {
+		severalMaps.push();
+		severalMaps8.push();
+		severalMaps3d.push().push();
+	}
+	function f(mapping (uint => uint) storage map) internal {
+		require(severalMaps.length > 0);
+		require(severalMaps8.length > 0);
+		require(severalMaps3d.length > 0);
+		require(severalMaps3d[0].length > 0);
+		severalMaps[0][0] = 42;
+		severalMaps8[0][0] = 42;
+		severalMaps3d[0][0][0] = 42;
+		map[0] = 2;
+		// Should fail since map == severalMaps[0] is possible.
+		// Access is safe but oob is reported because of aliasing.
+		assert(severalMaps[0][0] == 42);
+		// Should not fail since knowledge is erased only for mapping (uint => uint).
+		assert(severalMaps8[0][0] == 42);
+		// Should fail since map == severalMaps3d[0][0] is possible.
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(severalMaps3d[0][0][0] == 42);
+	}
+	function g(uint x) public {
+		require(x < severalMaps.length);
+		f(severalMaps[x]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (706-720): CHC: Out of bounds access happens here.
+// Warning 6328: (699-730): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_2.sol
new file mode 100644
index 00000000..fce58698
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_mapping_aliasing_2.sol
@@ -0,0 +1,49 @@
+contract C
+{
+	mapping (uint => uint) singleMap;
+	mapping (uint => uint)[] severalMaps;
+	mapping (uint => uint8)[] severalMaps8;
+	mapping (uint => uint)[][] severalMaps3d;
+	constructor() {
+		severalMaps.push();
+		severalMaps8.push();
+		severalMaps3d.push().push();
+	}
+	function f(mapping (uint => uint) storage map) internal {
+		map[0] = 42;
+		// Index accesses are safe but the assignment above makes
+		// them fail because of aliasing.
+		severalMaps[0][0] = 42;
+		severalMaps8[0][0] = 42;
+		severalMaps3d[0][0][0] = 42;
+		singleMap[0] = 2;
+		// Should not fail since singleMap == severalMaps[0] is not possible.
+		assert(severalMaps[0][0] == 42);
+		// Should not fail since knowledge is erased only for mapping (uint => uint).
+		assert(severalMaps8[0][0] == 42);
+		// Should not fail since singleMap == severalMaps3d[0][0] is not possible.
+		assert(severalMaps3d[0][0][0] == 42);
+		// Should fail since singleMap == map is possible.
+		assert(map[0] == 42);
+	}
+	function g(uint x) public {
+		require(x < severalMaps.length);
+		f(severalMaps[x]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (439-453): CHC: Out of bounds access happens here.
+// Warning 6368: (465-480): CHC: Out of bounds access might happen here.
+// Warning 6368: (492-508): CHC: Out of bounds access happens here.
+// Warning 6368: (492-511): CHC: Out of bounds access happens here.
+// Warning 6368: (622-636): CHC: Out of bounds access happens here.
+// Warning 6368: (737-752): CHC: Out of bounds access might happen here.
+// Warning 6368: (850-866): CHC: Out of bounds access happens here.
+// Warning 6368: (850-869): CHC: Out of bounds access happens here.
+// Warning 6328: (936-956): CHC: Assertion violation happens here.
+// Warning 6368: (1029-1043): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_1.sol
new file mode 100644
index 00000000..3d33caa4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_1.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	uint[10] array;
+	function f(uint x, uint y) public {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_1_fail.sol
new file mode 100644
index 00000000..0ab524c7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_1_fail.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	uint[10] array;
+	function f(uint x, uint y) public {
+		require(x < array.length);
+		array[x] = 200;
+		require(x == y);
+		assert(array[y] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (135-157): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_2.sol
new file mode 100644
index 00000000..c90d4a29
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_2.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	uint[10][20] array;
+	function f(uint x, uint y, uint z, uint t) public view {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(array[x][y] == 200);
+		require(x == z && y == t);
+		assert(array[z][t] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_2_fail.sol
new file mode 100644
index 00000000..e0146c85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_2_fail.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint[10][20] array;
+	function f(uint x, uint y, uint z, uint t) public view {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(array[x][y] < 200);
+		require(x == z && y == t);
+		assert(array[z][t] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (214-239): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_3.sol
new file mode 100644
index 00000000..a1ca13a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_3.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	uint[10][20][30] array;
+	function f(uint x, uint y, uint z, uint t, uint w, uint v) public view {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(z < array[x][y].length);
+		require(array[x][y][z] == 200);
+		require(x == t && y == w && z == v);
+		assert(array[t][w][v] > 100);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_3_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_3_fail.sol
new file mode 100644
index 00000000..b299de21
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_3_fail.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint[10][20][30] array;
+	function f(uint x, uint y, uint z, uint t, uint w, uint v) public {
+		require(x < array.length);
+		require(y < array[x].length);
+		require(z < array[x][y].length);
+		array[x][y][z] = 200;
+		require(x == t && y == w && z == v);
+		assert(array[t][w][v] > 300);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (268-296): CHC: Assertion violation happens here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_memory_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_memory_5.sol
new file mode 100644
index 00000000..8e6d23ab
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_memory_5.sol
@@ -0,0 +1,20 @@
+contract C
+{
+	function f(uint[2] memory a, uint[2] memory b, uint[2] memory c) public pure {
+		require(c[0] == 42);
+		require(a[0] == 2);
+		b[0] = 1;
+		// Should fail since b == c is possible.
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(c[0] == 42);
+		// Should fail since b == a is possible.
+		// Access is safe but oob is reported due of aliasing.
+		assert(a[0] == 2);
+		assert(b[0] == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (385-402): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_storage_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_storage_5.sol
new file mode 100644
index 00000000..73863078
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_aliasing_storage_5.sol
@@ -0,0 +1,27 @@
+contract C
+{
+	uint[2] b1;
+	uint[2] b2;
+	function f(uint[2] storage a, uint[2] memory c) internal {
+		// Accesses are safe but oob is reported because of aliasing.
+		c[0] = 42;
+		a[0] = 2;
+		b1[0] = 1;
+		// Erasing knowledge about storage variables should not
+		// erase knowledge about memory references.
+		assert(c[0] == 42);
+		// Fails because b1 == a is possible.
+		// Disabled because Spacer seg faults.
+		//assert(a[0] == 2);
+		assert(b1[0] == 1);
+	}
+	function g(bool x, uint[2] memory c) public {
+		if (x) f(b1, c);
+		else f(b2, c);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_1.sol
new file mode 100644
index 00000000..7ee1acf4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_1.sol
@@ -0,0 +1,31 @@
+contract C
+{
+	mapping (uint => uint) singleMap;
+	mapping (uint => uint)[2] severalMaps;
+	mapping (uint => uint8)[2] severalMaps8;
+	mapping (uint => uint)[2][2] severalMaps3d;
+	function f(mapping (uint => uint) storage map) internal {
+		// Accesses are safe but oob is reported because of aliasing.
+		severalMaps[0][0] = 42;
+		severalMaps8[0][0] = 42;
+		severalMaps3d[0][0][0] = 42;
+		map[0] = 2;
+		// Should fail since map == severalMaps[0] is possible.
+		assert(severalMaps[0][0] == 42);
+		// Should not fail since knowledge is erased only for mapping (uint => uint).
+		assert(severalMaps8[0][0] == 42);
+		// Should fail since map == severalMaps3d[0][0] is possible.
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(severalMaps3d[0][0][0] == 42);
+	}
+	function g(uint x) public {
+		require(x < severalMaps.length);
+		f(severalMaps[x]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (456-487): CHC: Assertion violation happens here.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_2.sol
new file mode 100644
index 00000000..1f167b85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/array_static_mapping_aliasing_2.sol
@@ -0,0 +1,37 @@
+contract C
+{
+	mapping (uint => uint) singleMap;
+	mapping (uint => uint)[2] severalMaps;
+	mapping (uint => uint8)[2] severalMaps8;
+	mapping (uint => uint)[2][2] severalMaps3d;
+	function f(mapping (uint => uint) storage map) internal {
+		// Accesses are safe but reported as unsafe due to aliasing.
+		map[0] = 42;
+		severalMaps[0][0] = 42;
+		severalMaps8[0][0] = 42;
+		severalMaps3d[0][0][0] = 42;
+		singleMap[0] = 2;
+		// Should not fail since singleMap == severalMaps[0] is not possible.
+		assert(severalMaps[0][0] == 42);
+		// Should not fail since knowledge is erased only for mapping (uint => uint).
+		assert(severalMaps8[0][0] == 42);
+		// Should not fail since singleMap == severalMaps3d[0][0] is not possible.
+		// Removed because of Spacer nondeterminism.
+		//assert(severalMaps3d[0][0][0] == 42);
+		// Should fail since singleMap == map is possible.
+		assert(map[0] == 42);
+	}
+	function g(uint x) public {
+		require(x < 2);
+		f(severalMaps3d[x][0]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6368: (340-355): CHC: Out of bounds access might happen here.
+// Warning 6368: (612-627): CHC: Out of bounds access might happen here.
+// Warning 6328: (860-880): CHC: Assertion violation happens here.
+// Warning 6368: (936-952): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_1.sol
new file mode 100644
index 00000000..2e75ad33
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_1.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(bool x) public pure {
+        uint a;
+        if(x)
+            a = 1;
+        assert(!x || a > 0);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_2.sol
new file mode 100644
index 00000000..ac6dd87e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_2.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(bool x, uint a) public pure {
+        require(!x || a > 0);
+        uint b = a;
+        assert(!x || b > 0);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_3.sol
new file mode 100644
index 00000000..7039ae1b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_int_mixed_3.sol
@@ -0,0 +1,24 @@
+contract C {
+    function f(bool x, bool y) public pure {
+        uint a;
+        if (x) {
+            if (y) {
+                a = 0;
+            } else {
+                a = 1;
+            }
+        } else {
+            if (y) {
+                a = 1;
+            } else {
+                a = 0;
+            }
+        }
+        bool xor_x_y = (x && !y) || (!x && y);
+        assert(!xor_x_y || a > 0);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_1.sol
new file mode 100644
index 00000000..a9ea6c7f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_1.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(bool x) public pure {
+        assert(x);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (58-67): CHC: Assertion violation happens here.\nCounterexample:\n\nx = false\n\nTransaction trace:\nC.constructor()\nC.f(false)
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_2.sol
new file mode 100644
index 00000000..7e23d77d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_2.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(bool x, bool y) public pure {
+        assert(x == y);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (66-80): CHC: Assertion violation happens here.\nCounterexample:\n\nx = true\ny = false\n\nTransaction trace:\nC.constructor()\nC.f(true, false)
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_3.sol
new file mode 100644
index 00000000..fdc08d44
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_3.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(bool x, bool y) public pure {
+        bool z = x || y;
+        assert(!(x && y) || z);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_4.sol
new file mode 100644
index 00000000..cafb34c2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_4.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f(bool x) public pure {
+        if(x) {
+            assert(x);
+        } else {
+            assert(!x);
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_5.sol
new file mode 100644
index 00000000..c19a5fa1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_5.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f(bool x) public pure {
+        bool y = x;
+        assert(x == y);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_6.sol b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_6.sol
new file mode 100644
index 00000000..eab6282f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bool_simple_6.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f(bool x) public pure {
+        require(x);
+        bool y;
+        y = false;
+        assert(x || y);
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bytes_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/bytes_2.sol
new file mode 100644
index 00000000..5b27d56b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bytes_2.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(bytes memory b1, bytes memory b2) public pure {
+		require(b2.length > 2);
+		b1 = b2;
+		// Knowledge about b2 is lost because of potential aliasing, so we re-add the length constraint.
+		require(b2.length > 2);
+		assert(b1[1] == b2[1]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (237-259): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bytes_2_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/bytes_2_fail.sol
new file mode 100644
index 00000000..66fa8ae3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bytes_2_fail.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function f(bytes memory b1, bytes memory b2) public pure {
+		b1 = b2;
+		require(b1.length > 2 && b2.length > 2);
+		assert(b1[1] == b2[2]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (129-151): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/bytes_length.sol b/compiler/test/libsolidity/smtCheckerTests/types/bytes_length.sol
new file mode 100644
index 00000000..ea69bc3a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/bytes_length.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f() public pure {
+		bytes memory x = hex"0123";
+		assert(x.length == 2);
+	}
+	function g() public pure {
+		bytes memory x = bytes(hex"0123");
+		assert(x.length == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/contract_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/contract_3.sol
new file mode 100644
index 00000000..657999c0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/contract_3.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function f(C c, C d, C e) public pure {
+		require(c == d);
+		require(d == e);
+		assert(c == e);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/contract_address_conversion_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/contract_address_conversion_2.sol
new file mode 100644
index 00000000..0b395c18
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/contract_address_conversion_2.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	function f(C c, C d) public pure {
+		assert(address(c) == address(c));
+		address a = address(c);
+		require(c == d);
+		assert(a == address(d));
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/enum_explicit_values.sol b/compiler/test/libsolidity/smtCheckerTests/types/enum_explicit_values.sol
new file mode 100644
index 00000000..0d297354
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/enum_explicit_values.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	enum D { Left, Right }
+	D d;
+	function f(D _a) public {
+		require(_a == D.Left);
+		d = D.Right;
+		assert(d != _a);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/enum_in_library.sol b/compiler/test/libsolidity/smtCheckerTests/types/enum_in_library.sol
new file mode 100644
index 00000000..57e6d7b4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/enum_in_library.sol
@@ -0,0 +1,17 @@
+library L
+{
+	enum D { Left, Right }
+}
+
+contract C
+{
+	enum E { Left, Right }
+	function f(E _d) public pure {
+		_d = E.Left;
+		assert(_d == E.Left);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol b/compiler/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol
new file mode 100644
index 00000000..d46c120d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/enum_in_struct.sol
@@ -0,0 +1,15 @@
+pragma abicoder               v2;
+
+contract C
+{
+	enum D { Left, Right }
+	struct S { uint x; D d; }
+	function f(S memory s) public pure {
+		s.d = D.Left;
+		assert(s.d == D.Left);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/enum_range.sol b/compiler/test/libsolidity/smtCheckerTests/types/enum_range.sol
new file mode 100644
index 00000000..403743e0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/enum_range.sol
@@ -0,0 +1,11 @@
+contract C
+{
+	enum D { Left, Right }
+	function f(D a) public pure {
+		assert(a == D.Left || a == D.Right);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/enum_transitivity.sol b/compiler/test/libsolidity/smtCheckerTests/types/enum_transitivity.sol
new file mode 100644
index 00000000..1f1811ea
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/enum_transitivity.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	enum D { Left, Right }
+	D d;
+	function f(D _a, D _b) public view {
+		require(_a == _b);
+		require(_a == d);
+		assert(d == _b);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_2.sol
new file mode 100644
index 00000000..c9ce9f14
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_2.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	bytes32 x;
+	function f(bytes8 y) public view {
+		assert(x == g());
+		assert(x != y);
+	}
+	function g() public view returns (bytes32) {
+		return x;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (83-97): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_1.sol
new file mode 100644
index 00000000..30d61718
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_1.sol
@@ -0,0 +1,10 @@
+contract c {
+	bytes10[6] data2;
+	function test() public view returns (bytes10 r2) {
+		r2 = data2[4][5];
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_2.sol
new file mode 100644
index 00000000..33ce3ca2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_2.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bytes calldata x, uint y) external pure {
+		require(x.length > 10);
+		x[8][0];
+		// Disabled because of Spacer nondeterminism.
+		//x[8][5%y];
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 5667: (43-49): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_3.sol
new file mode 100644
index 00000000..bb4ef034
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_3.sol
@@ -0,0 +1,36 @@
+contract C {
+	bytes16[][] a;
+	constructor() {
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+		a.push();
+		a[2].push();
+		a[2].push();
+		a[2].push();
+		a[3].push();
+		a[3].push();
+		a[3].push();
+		a[3].push();
+		a[3].push();
+	}
+	function g() internal view returns (bytes16[] storage) {
+		return a[2];
+	}
+	function h() internal view returns (bytes16) {
+		return a[2][2];
+	}
+	function f() external view {
+		// Reports oob because of aliasing.
+		g()[3][4];
+		h()[5];
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (456-462): CHC: Out of bounds access happens here.
+// Info 1391: CHC: 13 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_4.sol
new file mode 100644
index 00000000..b6701711
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_4.sol
@@ -0,0 +1,16 @@
+contract C {
+	function f() public pure {
+		bytes32 x = 0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff;
+		bytes1 z = 0x00;
+		bytes1 o = 0xff;
+		assert(x[0] == z);
+		assert(x[31] == o);
+		assert(x[0] == x[22]);
+		assert(x[0] == x[23]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (231-252): CHC: Assertion violation happens here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_5.sol
new file mode 100644
index 00000000..122979fe
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_5.sol
@@ -0,0 +1,17 @@
+contract C {
+	function f() public pure {
+		bytes4 x = 0x01020304;
+		bytes1 b = 0x02;
+		assert(x[0] == b); // fails
+		assert(x[1] == b);
+		assert(x[2] == b); // fails
+		assert(x[3] == b); // fails
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (87-104): CHC: Assertion violation happens here.
+// Warning 6328: (138-155): CHC: Assertion violation happens here.
+// Warning 6328: (168-185): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_6.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_6.sol
new file mode 100644
index 00000000..e506b945
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_access_6.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure {
+		bytes4 x = 0x01020304;
+		bytes1 b = x[3];
+		assert(b == b[0]);
+		assert(b == b[0][0]);
+		assert(b == b[0][0][0][0][0][0][0][0][0][0][0]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 18 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_range.sol b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_range.sol
new file mode 100644
index 00000000..b4168dc9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/fixed_bytes_range.sol
@@ -0,0 +1,12 @@
+contract C {
+
+	function f(bytes1 b) public pure {
+		bytes1 c = hex"7f";
+		require(b > c);
+		assert(uint8(b) > 127); // should hold
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/function_type_arrays.sol b/compiler/test/libsolidity/smtCheckerTests/types/function_type_arrays.sol
new file mode 100644
index 00000000..1cc490d2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/function_type_arrays.sol
@@ -0,0 +1,16 @@
+contract C {
+    function(uint) external returns (uint)[] public x;
+    function(uint) internal returns (uint)[10] y;
+    function f() view public {
+        function(uint) returns (uint)[10] memory a;
+        function(uint) returns (uint)[10] storage b = y;
+        function(uint) external returns (uint)[] memory c;
+        c = new function(uint) external returns (uint)[](200);
+        assert(c.length == 200);
+        a; b;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_1.sol
new file mode 100644
index 00000000..c8d6c4ca
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x) public {
+		map[2] = x;
+		assert(x == map[2]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_1_fail.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_1_fail.sol
new file mode 100644
index 00000000..7e9669ea
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_1_fail.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x) public {
+		map[2] = x;
+		map[2] = 3;
+		assert(x != map[2]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (101-120): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 3\n\nTransaction trace:\nC.constructor()\nC.f(3)
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_2d_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_2d_1.sol
new file mode 100644
index 00000000..9bab80f2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_2d_1.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	mapping (uint => mapping (uint => uint)) map;
+	function f(uint x) public {
+		x = 42;
+		map[13][14] = 42;
+		assert(x == map[13][14]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_3.sol
new file mode 100644
index 00000000..654f0622
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_3.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f() public {
+		map[1] = 111;
+		uint x = map[2];
+		map[1] = 112;
+		assert(map[2] == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_3d_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_3d_1.sol
new file mode 100644
index 00000000..824e4721
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_3d_1.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	mapping (uint => mapping (uint => mapping (uint => uint))) map;
+	function f(uint x) public {
+		x = 42;
+		map[13][14][15] = 42;
+		assert(x == map[13][14][15]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_4.sol
new file mode 100644
index 00000000..cdaf3fec
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_4.sol
@@ -0,0 +1,13 @@
+contract C
+{
+	mapping (bool => bool) map;
+	function f(bool x) public view {
+		require(x);
+		assert(x != map[x]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTSolvers: z3
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_1.sol
new file mode 100644
index 00000000..be126d16
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_1.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	mapping (uint => uint) a;
+	mapping (uint => uint) b;
+
+	function f(uint x) public {
+		a[1] = x;
+		b[1] = x;
+		a[1] = 2;
+		mapping (uint => uint) storage c = a;
+		assert(c[1] == 2);
+		// False negative! Needs aliasing.
+		assert(a[1] == b[1]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (233-253): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_2.sol
new file mode 100644
index 00000000..54b69b38
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_aliasing_2.sol
@@ -0,0 +1,37 @@
+contract C
+{
+	mapping (uint => uint) a;
+	mapping (uint => mapping (uint => uint)) maps;
+	mapping (uint => mapping (uint => uint8)) maps8;
+	function f(mapping (uint => uint) storage map1, mapping (uint => uint) storage map2) internal {
+		map1[0] = 2;
+		a[0] = 42;
+		maps[0][0] = 42;
+		maps8[0][0] = 42;
+		map2[0] = 1;
+		// Fails because map2 == map1 is possible.
+		assert(map1[0] == 2);
+		// Fails because map2 == a is possible.
+		assert(a[0] == 42);
+		// Fails because map2 == maps[0] is possible.
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(maps[0][0] == 42);
+		// Should not fail since knowledge is erased only for mapping (uint => uint).
+		assert(maps8[0][0] == 42);
+		assert(map2[0] == 1);
+	}
+
+	function g(bool b, uint x, uint y) public {
+		if (b)
+			f(a, maps[y]);
+		else
+			f(maps[x], maps[y]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (364-384): CHC: Assertion violation happens here.
+// Warning 6328: (430-448): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_1.sol
new file mode 100644
index 00000000..746b6778
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x, uint y) public view {
+		require(x == y);
+		assert(map[x] == map[y]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_2.sol
new file mode 100644
index 00000000..a246974e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_equal_keys_2.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	mapping (uint => uint) map;
+	function f(uint x, uint y) public view {
+		assert(x == y);
+		assert(map[x] == map[y]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (86-100): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/mapping_unsupported_key_type_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/mapping_unsupported_key_type_1.sol
new file mode 100644
index 00000000..17f67b8a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/mapping_unsupported_key_type_1.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	mapping (string => uint) map;
+	function f(string memory s, uint x) public {
+		map[s] = x;
+		assert(x == map[s]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/rational_large_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/rational_large_1.sol
new file mode 100644
index 00000000..0a011b44
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/rational_large_1.sol
@@ -0,0 +1,13 @@
+contract c {
+	function f() public pure returns (uint) {
+		uint x = 8e130%9;
+		assert(x == 8);
+		assert(x != 8);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (48-52): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (96-110): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_2.sol
new file mode 100644
index 00000000..1040f7ca
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_2.sol
@@ -0,0 +1,11 @@
+contract C {
+	uint[][] a;
+	function f(uint[1][] memory x) public {
+		require(x.length > 2);
+		a.push(x[2]);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_3.sol
new file mode 100644
index 00000000..37ef3158
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_3.sol
@@ -0,0 +1,10 @@
+contract D {
+	bytes16[] inner;
+	bytes32[][] data;
+	function t() public {
+		data.push(inner);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_4.sol
new file mode 100644
index 00000000..f0049b3f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_implicit_push_4.sol
@@ -0,0 +1,10 @@
+contract D {
+	int16[] inner;
+	int[][] data;
+	function t() public {
+		data.push(inner);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_1.sol
new file mode 100644
index 00000000..f8f27898
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(address[2] memory a) public pure {
+		assert(a.length == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (102-122): CHC: Assertion violation happens here.
+// Warning 6328: (141-161): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_2.sol
new file mode 100644
index 00000000..bf643100
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_2.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f() public pure returns (address[2] memory a) {
+		assert(a.length == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (113-133): CHC: Assertion violation happens here.
+// Warning 6328: (152-172): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_3.sol
new file mode 100644
index 00000000..c2d26b45
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_3.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f() public pure {
+		address[2] memory a;
+		assert(a.length == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (106-126): CHC: Assertion violation happens here.
+// Warning 6328: (145-165): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_4.sol
new file mode 100644
index 00000000..28700776
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_4.sol
@@ -0,0 +1,24 @@
+contract C {
+	uint[2] a;
+	uint x = f();
+	constructor() {
+		assert(a.length == 2); // should hold
+		assert(x == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+	}
+	function f() internal view returns (uint) {
+		assert(a.length == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+		return a.length;
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (132-152): CHC: Assertion violation happens here.
+// Warning 6328: (171-191): CHC: Assertion violation happens here.
+// Warning 6328: (298-318): CHC: Assertion violation happens here.
+// Warning 6328: (337-357): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_5.sol
new file mode 100644
index 00000000..1319ca10
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/static_array_length_5.sol
@@ -0,0 +1,14 @@
+contract C {
+	uint[2] a;
+	function f() public view {
+		assert(a.length == 2); // should hold
+		assert(a.length < 2); // should fail
+		assert(a.length > 2); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (95-115): CHC: Assertion violation happens here.
+// Warning 6328: (134-154): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/storage_value_vars_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/storage_value_vars_3.sol
new file mode 100644
index 00000000..4fa60963
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/storage_value_vars_3.sol
@@ -0,0 +1,28 @@
+contract C
+{
+    function f(uint x) public {
+        if (x == 0)
+        {
+            a = 0x0000000000000000000000000000000000000100;
+            b = true;
+        }
+        else
+        {
+            a = 0x0000000000000000000000000000000000000200;
+            b = false;
+        }
+        assert(b == (a < 0x0000000000000000000000000000000000000200));
+    }
+
+    function g() public view {
+        require(a < 0x0000000000000000000000000000000000000100);
+        assert(c >= 0);
+    }
+    address a;
+    bool b;
+    uint c;
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_length.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_length.sol
new file mode 100644
index 00000000..c6a1e804
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_length.sol
@@ -0,0 +1,19 @@
+contract C {
+	function f() public pure {
+		string memory x = "Hello World";
+		assert(bytes(x).length == 11);
+	}
+	function g() public pure {
+		string memory x = unicode"Hello World";
+		assert(bytes(x).length == 11);
+	}
+	function h() public pure {
+		bytes memory x = unicode"Hello World";
+		string memory y = string(x);
+		assert(bytes(y).length == 11);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_1.sol
new file mode 100644
index 00000000..0289de4b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		bytes32 y = "test";
+		bytes16 z = "testz";
+		assert(_x == y);
+		assert(_x == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (142-157): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_2.sol
new file mode 100644
index 00000000..65dc7cb2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_2.sol
@@ -0,0 +1,13 @@
+contract C {
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		(bytes32 y, bytes16 z) = ("test", "testz");
+		assert(_x == y);
+		assert(_x == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (143-158): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_3.sol
new file mode 100644
index 00000000..1c25ccb6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_3.sol
@@ -0,0 +1,15 @@
+contract C {
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		bytes32 y;
+		bytes16 z;
+		(y, z) = ("test", "testz");
+		assert(_x == y);
+		assert(_x == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (153-168): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_4.sol
new file mode 100644
index 00000000..647c3ae2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_4.sol
@@ -0,0 +1,19 @@
+contract C {
+	function g() internal pure returns (bytes32, bytes16) {
+		return ("test", "testz");
+	}
+
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		bytes32 y;
+		bytes16 z;
+		(y, z) = g();
+		assert(_x == y);
+		assert(_x == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (228-243): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_5.sol
new file mode 100644
index 00000000..70ad2f57
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_assignment_5.sol
@@ -0,0 +1,17 @@
+contract C {
+	function g() internal pure returns (bytes32, bytes16) {
+		return ("test", "testz");
+	}
+
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		(bytes32 y, bytes16 z) = g();
+		assert(_x == y);
+		assert(_x == z);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (218-233): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/string_literal_comparison_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_comparison_1.sol
new file mode 100644
index 00000000..daec90a4
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/string_literal_comparison_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f(bytes32 _x) public pure {
+		require(_x == "test");
+		bytes32 y = _x;
+		bytes32 z = _x;
+		assert(z == "test");
+		assert(y == "testx");
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (137-157): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol
new file mode 100644
index 00000000..bc5ddf49
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_safe.sol
@@ -0,0 +1,36 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	function f() public pure {
+		S[] memory s1 = new S[](3);
+		assert(s1.length == 3);
+		s1[0].x = 2;
+		assert(s1[0].x == 2);
+		s1[1].t.y = 3;
+		assert(s1[1].t.y == 3);
+		s1[2].a = new uint[](3);
+		s1[2].a[2] = 4;
+		assert(s1[2].a[2] == 4);
+		s1[0].ts = new T[](6);
+		s1[0].ts[3].y = 5;
+		assert(s1[0].ts[3].y == 5);
+		s1[1].ts = new T[](6);
+		s1[1].ts[4].a = new uint[](6);
+		s1[1].ts[4].a[5] = 6;
+		assert(s1[1].ts[4].a[5] == 6);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 29 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol
new file mode 100644
index 00000000..504d3ea5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_memory_unsafe.sol
@@ -0,0 +1,38 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	function f(S memory s2) public pure {
+		S[] memory s1 = new S[](3);
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1.length == 3);
+		s1[0].x = 2;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1[0].x == s2.x);
+		s1[1].t.y = 3;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1[1].t.y == s2.t.y);
+		s1[2].a = new uint[](3);
+		s1[2].a[2] = 4;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1[2].a[2] == s2.a[2]);
+		s1[0].ts = new T[](4);
+		s1[0].ts[3].y = 5;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1[0].ts[3].y == s2.ts[3].y);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (151-162): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 8 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol
new file mode 100644
index 00000000..b2f7b982
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/array_struct_array_struct_storage_safe.sol
@@ -0,0 +1,56 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	S[] s1;
+	function f() public {
+		s1.push();
+		s1.push();
+		s1.push();
+		s1[0].x = 2;
+		assert(s1[0].x == 2);
+		s1[1].t.y = 3;
+		assert(s1[1].t.y == 3);
+		s1[2].a.push();
+		s1[2].a.push();
+		s1[2].a.push();
+		s1[2].a[2] = 4;
+		assert(s1[2].a[2] == 4);
+		s1[0].ts.push();
+		s1[0].ts.push();
+		s1[0].ts.push();
+		s1[0].ts.push();
+		s1[0].ts.push();
+		s1[0].ts[3].y = 5;
+		assert(s1[0].ts[3].y == 5);
+		s1[1].ts.push();
+		s1[1].ts.push();
+		s1[1].ts.push();
+		s1[1].ts.push();
+		s1[1].ts.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a.push();
+		s1[1].ts[4].a[5] = 6;
+		assert(s1[1].ts[4].a[5] == 6);
+		s1.pop();
+		s1.pop();
+		s1.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 51 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol
new file mode 100644
index 00000000..007c451d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_memory.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	function f(S memory s1, S memory s2, bool b) public pure {
+		S memory s3 = b ? s1 : s2;
+		assert(s3.x == s1.x);
+		assert(s3.x == s2.x);
+		// This is safe.
+		assert(s3.x == s1.x || s3.x == s2.x);
+		// This fails as false positive because of lack of support to aliasing.
+		s3.x = 42;
+		assert(s3.x == s1.x || s3.x == s2.x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (176-196): CHC: Assertion violation happens here.
+// Warning 6328: (200-220): CHC: Assertion violation happens here.
+// Warning 6328: (370-406): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_1.sol
new file mode 100644
index 00000000..df99f8a8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_1.sol
@@ -0,0 +1,25 @@
+contract C {
+    struct S {
+        mapping(address => uint) innerM;
+		uint sum;
+    }
+
+	function f(S storage m, address i, uint v) internal {
+		m.innerM[i] = v;
+		m.sum += v;
+	}
+
+	S s;
+
+	constructor(uint amt) {
+		f(s, msg.sender, amt);
+	}
+	function g() public view {
+		assert(s.sum == 0); // should hold but no aliasing support means it fails for now
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (270-288): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_2.sol
new file mode 100644
index 00000000..69826238
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_2.sol
@@ -0,0 +1,23 @@
+contract C {
+    struct S {
+        mapping(address => uint) innerM;
+		uint sum;
+    }
+
+	function f(mapping(address => uint) storage innerM, address i, uint v) internal {
+		innerM[i] = v;
+	}
+
+	S s;
+
+	constructor(uint amt) {
+		f(s.innerM, msg.sender, amt);
+	}
+	function g() public view {
+		assert(s.innerM[msg.sender] == 0); // should hold but no aliasing support means it fails for now
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (289-322): CHC: Assertion violation happens here.\nCounterexample:\ns = {innerM, sum: 11}\n\nTransaction trace:\nC.constructor(0){ msg.sender: 0x6dc4 }\nState: s = {innerM, sum: 11}\nC.g(){ msg.sender: 0x0985 }
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_3.sol
new file mode 100644
index 00000000..416bd610
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_3.sol
@@ -0,0 +1,31 @@
+contract C {
+    struct S {
+        mapping(address => uint) innerM;
+		uint sum;
+    }
+
+	struct T {
+		uint x;
+		S s;
+	}
+
+	function f(T storage m, address i, uint v) internal {
+		m.s.innerM[i] = v;
+		m.s.sum += v;
+	}
+
+	T t;
+
+	constructor(uint amt) {
+		f(t, msg.sender, amt);
+	}
+	function g() public view {
+		assert(t.s.sum == 0); // should hold but no aliasing support means it fails for now
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (307-327): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_4.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_4.sol
new file mode 100644
index 00000000..480753e2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_parameter_storage_4.sol
@@ -0,0 +1,31 @@
+contract C {
+    struct S {
+        mapping(address => uint) innerM;
+		uint sum;
+    }
+
+	struct T {
+		uint x;
+		S s;
+	}
+
+	function f(S storage m, address i, uint v) internal {
+		m.innerM[i] = v;
+		m.sum += v;
+	}
+
+	T t;
+
+	constructor(uint amt) {
+		f(t.s, msg.sender, amt);
+	}
+	function g() public view {
+		assert(t.s.sum == 0); // should hold but no aliasing support means it fails for now
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (305-325): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_storage.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_storage.sol
new file mode 100644
index 00000000..3a8699bd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_aliasing_storage.sol
@@ -0,0 +1,31 @@
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	S s1;
+	S s2;
+	function f(bool b) public {
+		S storage s3 = b ? s1 : s2;
+		// Disabled because Spacer 4.8.9 seg fauts.
+		//assert(s3.x == s1.x);
+		//assert(s3.x == s2.x);
+		// This is safe.
+		assert(s3.x == s1.x || s3.x == s2.x);
+		// This fails as false positive because of lack of support to aliasing.
+		s3.x = 42;
+		assert(s3.x == s1.x || s3.x == s2.x);
+	}
+	function g(bool b, uint _x) public {
+		if (b)
+			s1.x = _x;
+		else
+			s2.x = _x;
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (369-405): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol
new file mode 100644
index 00000000..3bcd573e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_safe.sol
@@ -0,0 +1,34 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	function f() public pure {
+		S memory s1;
+		s1.x = 2;
+		assert(s1.x == 2);
+		s1.t.y = 3;
+		assert(s1.t.y == 3);
+		s1.a = new uint[](3);
+		s1.a[2] = 4;
+		assert(s1.a[2] == 4);
+		s1.ts = new T[](6);
+		s1.ts[3].y = 5;
+		assert(s1.ts[3].y == 5);
+		s1.ts[4].a = new uint[](6);
+		s1.ts[4].a[5] = 6;
+		assert(s1.ts[4].a[5] == 6);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 14 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol
new file mode 100644
index 00000000..d4acec19
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_1.sol
@@ -0,0 +1,39 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	function f() public pure {
+		S memory s1;
+		s1.x = 2;
+		assert(s1.x != 2);
+		s1.t.y = 3;
+		assert(s1.t.y != 3);
+		s1.a = new uint[](3);
+		s1.a[2] = 4;
+		assert(s1.a[2] != 4);
+		s1.ts = new T[](6);
+		s1.ts[3].y = 5;
+		assert(s1.ts[3].y != 5);
+		s1.ts[4].a = new uint[](6);
+		s1.ts[4].a[5] = 6;
+		assert(s1.ts[4].a[5] != 6);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (196-213): CHC: Assertion violation happens here.
+// Warning 6328: (231-250): CHC: Assertion violation happens here.
+// Warning 6328: (293-313): CHC: Assertion violation happens here.
+// Warning 6328: (357-380): CHC: Assertion violation happens here.
+// Warning 6328: (435-461): CHC: Assertion violation happens here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol
new file mode 100644
index 00000000..50c3f1d7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_memory_unsafe_2.sol
@@ -0,0 +1,42 @@
+pragma abicoder               v2;
+
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	function f(S memory s2) public pure {
+		S memory s1;
+		s1.x = 2;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1.x == s2.x);
+		s1.t.y = 3;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1.t.y == s2.t.y);
+		s1.a = new uint[](3);
+		s1.a[2] = 4;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1.a[2] == s2.a[2]);
+		s1.ts = new T[](6);
+		s1.ts[3].y = 5;
+		// Removed because current Spacer seg faults in cex generation.
+		//assert(s1.ts[3].y == s2.ts[3].y);
+		s1.ts[4].a = new uint[](6);
+		s1.ts[4].a[5] = 6;
+		require(s2.ts.length > 4);
+		require(s2.ts[4].a.length > 6);
+		assert(s1.ts[4].a[5] == s2.ts[4].a[5]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (804-842): CHC: Assertion violation happens here.
+// Info 1391: CHC: 10 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_safe.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_safe.sol
new file mode 100644
index 00000000..86db5aee
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_safe.sol
@@ -0,0 +1,43 @@
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	S s1;
+	function f() public {
+		s1.x = 2;
+		assert(s1.x == 2);
+		s1.t.y = 3;
+		assert(s1.t.y == 3);
+		s1.a.push();
+		s1.a.push();
+		s1.a.push();
+		s1.a[2] = 4;
+		assert(s1.a[2] == 4);
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts[3].y = 5;
+		assert(s1.ts[3].y == 5);
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a[5] = 6;
+		assert(s1.ts[4].a[5] == 6);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 19 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_unsafe_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_unsafe_1.sol
new file mode 100644
index 00000000..cafc6275
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_array_struct_array_storage_unsafe_1.sol
@@ -0,0 +1,50 @@
+contract C {
+	struct T {
+		uint y;
+		uint[] a;
+	}
+	struct S {
+		uint x;
+		T t;
+		uint[] a;
+		T[] ts;
+	}
+	S s1;
+	function f() public {
+		s1.x = 2;
+		assert(s1.x != 2);
+		s1.t.y = 3;
+		assert(s1.t.y != 3);
+		s1.a.push();
+		s1.a.push();
+		s1.a.push();
+		s1.a[2] = 4;
+		assert(s1.a[2] != 4);
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts.push();
+		s1.ts[3].y = 5;
+		assert(s1.ts[3].y != 5);
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a.push();
+		s1.ts[4].a[5] = 6;
+		assert(s1.ts[4].a[5] != 6);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (148-165): CHC: Assertion violation happens here.
+// Warning 6328: (183-202): CHC: Assertion violation happens here.
+// Warning 6328: (266-286): CHC: Assertion violation happens here.
+// Warning 6328: (404-427): CHC: Assertion violation happens here.
+// Warning 6328: (578-604): CHC: Assertion violation happens here.
+// Info 1391: CHC: 14 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_fixed_bytes_from_string_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_fixed_bytes_from_string_1.sol
new file mode 100644
index 00000000..30d6da4a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_fixed_bytes_from_string_1.sol
@@ -0,0 +1,15 @@
+pragma experimental SMTChecker;
+contract C {
+  struct S {
+    int a;
+    bytes5 b;
+  }
+  function f() public pure {
+    assert(S({a:2, b:""}).b == bytes5(0)); // should hold
+    assert(S({a:2, b:""}).a == 0); // should fail
+  }
+}
+// ----
+// Warning 5523: (0-31): The SMTChecker pragma has been deprecated and will be removed in the future. Please use the "model checker engine" compiler setting to activate the SMTChecker instead. If the pragma is enabled, all engines will be used.
+// Warning 6328: (178-207): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args.sol
new file mode 100644
index 00000000..d52a7169
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args.sol
@@ -0,0 +1,25 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+
+	struct T {
+		S s;
+		uint y;
+	}
+
+	function test() pure public {
+		S memory inner = S({x: 43});
+		T memory outer = T({y: 512, s: inner});
+		assert(outer.y == 512);
+		assert(outer.s.x == 43);
+		assert(outer.s.x == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (232-255): CHC: Assertion violation happens here.\nCounterexample:\n\ninner = {x: 43}\nouter = {s: {x: 43}, y: 512}\n\nTransaction trace:\nC.constructor()\nC.test()
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args_2.sol
new file mode 100644
index 00000000..8383ef6d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_constructor_named_args_2.sol
@@ -0,0 +1,21 @@
+contract C {
+
+	struct S {
+		uint x;
+		uint y;
+		uint z;
+	}
+
+	function test() pure public {
+		S memory s = S({z: 1, y: 2, x: 3});
+		assert(s.x == 3);
+		assert(s.y == 2);
+		assert(s.z == 1);
+		assert(s.x == 0 || s.y == 0 || s.z == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (191-231): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol
new file mode 100644
index 00000000..3653fa85
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_memory.sol
@@ -0,0 +1,21 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	function f(S memory s1, S memory s2) public pure {
+		delete s1;
+		assert(s1.x == s2.x);
+		assert(s1.a.length == s2.a.length);
+		assert(s1.a.length == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (152-172): CHC: Assertion violation happens here.
+// Warning 6328: (176-210): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol
new file mode 100644
index 00000000..12e38a41
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_delete_storage.sol
@@ -0,0 +1,26 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	S s1;
+	function g(S memory s2) public {
+		s1.x = s2.x;
+		s1.a = s2.a;
+	}
+	function f(S memory s2) public {
+		delete s1;
+		assert(s1.x == s2.x);
+		assert(s1.a.length == s2.a.length);
+		assert(s1.a.length == 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (208-228): CHC: Assertion violation happens here.
+// Warning 6328: (232-266): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_external_function_pointer.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_external_function_pointer.sol
new file mode 100644
index 00000000..494d2dcf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_external_function_pointer.sol
@@ -0,0 +1,33 @@
+struct S {
+    function() external returns (uint) x;
+}
+contract C {
+
+    function X() public pure returns (uint) {
+        return 1;
+    }
+
+    uint y;
+    uint z;
+
+    function setZ(uint _z) public {
+        z = _z;
+    }
+
+
+    function f() public returns (uint) {
+        S memory s;
+        s.x = this.X;
+        require(y == 0);
+        require(z == 0);
+        uint ret = s.x();
+        assert(y == 0); // should hold
+        assert(z == 0); // can report violation due to overapproximation after externall call s.x()
+        return ret;
+    }
+}
+
+
+// ----
+// Warning 6328: (431-445): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor.sol
new file mode 100644
index 00000000..0b04379f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor.sol
@@ -0,0 +1,24 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+
+	struct T {
+		S s;
+		uint y;
+	}
+
+	function test() pure public {
+		S memory inner = S(43);
+		T memory outer = T(inner, 512);
+		assert(outer.y == 512);
+		assert(outer.s.x == 43);
+		assert(outer.s.x == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (219-242): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor_named_args.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor_named_args.sol
new file mode 100644
index 00000000..03bc6661
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_constructor_named_args.sol
@@ -0,0 +1,12 @@
+contract C {
+	struct B { uint b1; }
+	struct A { uint a1; B a2; }
+	function f() public pure {
+		A memory a = A({ a1: 1, a2: B({b1: 2}) });
+		assert(a.a1 == 1 && a.a2.b1 == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_temporary.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_temporary.sol
new file mode 100644
index 00000000..848b9904
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_nested_temporary.sol
@@ -0,0 +1,19 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+
+	struct T {
+		S s;
+		uint y;
+	}
+
+	function test() pure public {
+		assert(T(S(42), 1).s.x == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_recursive_5.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_recursive_5.sol
new file mode 100644
index 00000000..ca7aee8f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_recursive_5.sol
@@ -0,0 +1,30 @@
+contract C {
+	struct S {
+		uint x;
+		S[] a;
+	}
+	S[] sa;
+	S[][] sa2;
+	function f() public {
+		sa.push();
+		sa2.push();
+		sa2[0].push();
+		sa2[0][0].a.push();
+		assert(sa2[0][0].a.length == sa[0].a.length);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 8364: (93-102): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 8364: (120-133): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 7650: (137-148): Assertion checker does not yet support this expression.
+// Warning 8364: (137-146): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 8364: (137-155): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 4375: (137-148): Assertion checker does not support recursive structs.
+// Warning 7650: (166-177): Assertion checker does not yet support this expression.
+// Warning 8364: (166-175): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 7650: (188-195): Assertion checker does not yet support this expression.
+// Warning 8364: (188-193): Assertion checker does not yet implement type struct C.S storage ref
+// Warning 6328: (159-203): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_return.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_return.sol
new file mode 100644
index 00000000..200289f2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_return.sol
@@ -0,0 +1,22 @@
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	function s() internal pure returns (S memory s1) {
+		s1.x = 42;
+		s1.a = new uint[](5);
+		s1.a[2] = 43;
+	}
+	function f() public pure {
+		S memory s2 = s();
+		assert(s2.x == 42);
+		assert(s2.a[2] == 43);
+		assert(s2.a[3] == 43);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (256-277): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_constructor.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_constructor.sol
new file mode 100644
index 00000000..7569a411
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_constructor.sol
@@ -0,0 +1,16 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+
+	S s = S(42);
+
+	function test() view public {
+		assert(s.x == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var.sol
new file mode 100644
index 00000000..a0dcde7c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var.sol
@@ -0,0 +1,20 @@
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	S s;
+	function p() public { s.a.push(); }
+	function f(uint _x) public {
+		require(s.a.length >= 2);
+		s.x = _x;
+		s.a[0] = _x;
+		assert(s.a[1] == s.a[0]);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (180-204): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_1.sol
new file mode 100644
index 00000000..73e8e4e5
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_1.sol
@@ -0,0 +1,27 @@
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	S s;
+	function f(uint _x) public {
+		s.a.pop();
+		s.a.length;
+		s.a.push();
+		s.x = _x;
+		s.a.pop();
+		s.a.push();
+		s.a.push();
+		s.a[0] = _x;
+		assert(s.a[1] == s.a[0]);
+		s.a.pop();
+		s.a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2529: (88-97): CHC: Empty array "pop" happens here.
+// Warning 6328: (197-221): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_2.sol
new file mode 100644
index 00000000..1478e452
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_state_var_array_pop_2.sol
@@ -0,0 +1,24 @@
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	S s;
+	function f(uint _x) public {
+		s.x = _x;
+		s.a.pop();
+		s.a.push();
+		s.a.push();
+		s.a[0] = _x;
+		assert(s.a[1] == s.a[0]);
+		s.a.pop();
+		s.a.pop();
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 2529: (100-109): CHC: Empty array "pop" happens here.
+// Warning 6328: (156-180): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_temporary.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_temporary.sol
new file mode 100644
index 00000000..342efc4b
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_temporary.sol
@@ -0,0 +1,14 @@
+contract C {
+
+	struct S {
+		uint x;
+	}
+
+	function test() pure public {
+		assert(S(42).x == 42);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol
new file mode 100644
index 00000000..99314c39
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_add.sol
@@ -0,0 +1,21 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	function f(S memory s1, S memory s2) public pure {
+		delete s1;
+		s1.x++;
+		++s1.x;
+		assert(s1.x == 2);
+		assert(s1.x == s2.x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (193-213): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol
new file mode 100644
index 00000000..f5892520
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct/struct_unary_sub.sol
@@ -0,0 +1,22 @@
+pragma abicoder               v2;
+
+contract C {
+	struct S {
+		uint x;
+		uint[] a;
+	}
+	function f(S memory s1, S memory s2) public pure {
+		delete s1;
+		s1.x = 100;
+		s1.x--;
+		--s1.x;
+		assert(s1.x == 98);
+		assert(s1.x == s2.x);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (208-228): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct_1.sol
new file mode 100644
index 00000000..84ad5004
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct_1.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	struct S {
+		uint x;
+	}
+
+	mapping (uint => S) smap;
+
+	function f(uint y, uint v) public {
+		smap[y] = S(v);
+		S memory smem = S(v);
+		assert(smap[y].x == smem.x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_1d.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_1d.sol
new file mode 100644
index 00000000..979a72db
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_1d.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	struct S { uint[] a; }
+	function f(bool b) public pure {
+		S memory c;
+		c.a = new uint[](2);
+		c.a[0] = 0;
+		if (b)
+			c.a[0] = 1;
+		else
+			c.a[0] = 2;
+		assert(c.a[0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_2d.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_2d.sol
new file mode 100644
index 00000000..0d45aee1
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_2d.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	struct S { uint[][] a; }
+	function f(bool b) public pure {
+		S memory c;
+		c.a = new uint[][](1);
+		c.a[0] = new uint[](1);
+		c.a[0][0] = 0;
+		if (b)
+			c.a[0][0] = 1;
+		else
+			c.a[0][0] = 2;
+		assert(c.a[0][0] > 0);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreOS: macos
+// ----
+// Warning 6368: (216-225): CHC: Out of bounds access might happen here.
+// Info 1391: CHC: 9 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_3d.sol b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_3d.sol
new file mode 100644
index 00000000..2d46a846
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/struct_array_branches_3d.sol
@@ -0,0 +1,27 @@
+contract C
+{
+	struct S { uint[][][] a; }
+	function f(bool b) public pure {
+		S memory c;
+		c.a = new uint[][][](2);
+		assert(c.a.length == 2);
+		assert(c.a[0].length == 0);
+		c.a[0] = new uint[][](2);
+		assert(c.a[0].length == 2);
+		assert(c.a[0][0].length == 0);
+		c.a[0][0] = new uint[](2);
+		// Disabled because of Spacer's seg fault.
+		/*
+		if (b)
+			c.a[0][0][0] = 1;
+		else
+			c.a[0][0][0] = 2;
+		assert(c.a[0][0][0] > 0);
+		*/
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 5667: (53-59): Unused function parameter. Remove or comment out the variable name to silence this warning.
+// Info 1391: CHC: 11 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_1.sol
new file mode 100644
index 00000000..bc1b0141
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_1.sol
@@ -0,0 +1,12 @@
+contract C {
+	function i() public pure returns (uint d) {
+		if (0==0)
+			(d) = 13;
+		assert(d == 13);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (64-68): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_2.sol
new file mode 100644
index 00000000..0f3c4534
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_2.sol
@@ -0,0 +1,12 @@
+contract C {
+	function i() public pure returns (uint d) {
+		if (0==0)
+			((d)) = 13;
+		assert(d == 13);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (64-68): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_n.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_n.sol
new file mode 100644
index 00000000..103eccc9
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_1_chain_n.sol
@@ -0,0 +1,12 @@
+contract C {
+	function i() public pure returns (uint d) {
+		if (0==0)
+			(((((d))))) = 13;
+		assert(d == 13);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 6838: (64-68): BMC: Condition is always true.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment.sol
new file mode 100644
index 00000000..9c8f8a4e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function g() public pure {
+		uint x;
+		uint y;
+		(x, y) = (2, 4);
+		assert(x == 2);
+		assert(y == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array.sol
new file mode 100644
index 00000000..69ef8ee7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array.sol
@@ -0,0 +1,17 @@
+contract C
+{
+	uint[] a;
+	function p() public { a.push(); }
+	function g(uint x, uint y) public {
+		require(x < a.length);
+		require(y < a.length);
+		require(x != y);
+		(a[x], a[y]) = (2, 4);
+		assert(a[x] == 2);
+		assert(a[y] == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array_empty.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array_empty.sol
new file mode 100644
index 00000000..79be48b3
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_array_empty.sol
@@ -0,0 +1,21 @@
+contract C
+{
+	uint[] a;
+	function f(uint x) public {
+		a.push(x);
+	}
+	function g(uint x, uint y) public {
+		require(x < a.length);
+		require(y < a.length);
+		require(x != y);
+		(, a[y]) = (2, 4);
+		assert(a[x] == 2);
+		assert(a[y] == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (198-215): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_compound.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_compound.sol
new file mode 100644
index 00000000..214c20d2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_compound.sol
@@ -0,0 +1,14 @@
+contract C
+{
+	function f() public pure {
+		uint a = 1;
+		uint b = 3;
+		a += ((((b))));
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (89-103): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_empty.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_empty.sol
new file mode 100644
index 00000000..e9dd360c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_empty.sol
@@ -0,0 +1,15 @@
+contract C
+{
+	function g() public pure {
+		uint x;
+		uint y;
+		(x, ) = (2, 4);
+		assert(x == 2);
+		assert(y == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (99-113): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_multiple_calls.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_multiple_calls.sol
new file mode 100644
index 00000000..574eb9e8
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_assignment_multiple_calls.sol
@@ -0,0 +1,16 @@
+contract C
+{
+	function f(uint x) public pure returns (uint, uint) {
+		return (x, x);
+	}
+
+	function g() public pure {
+		(uint a, uint b) = f(0);
+		(uint c, uint d) = f(0);
+		assert(a == c && b == d);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations.sol
new file mode 100644
index 00000000..e3bb8584
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations.sol
@@ -0,0 +1,12 @@
+contract C
+{
+	function g() public pure {
+		(uint x, uint y) = (2, 4);
+		assert(x == 2);
+		assert(y == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_empty.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_empty.sol
new file mode 100644
index 00000000..206b201d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_empty.sol
@@ -0,0 +1,11 @@
+contract C
+{
+	function g() public pure {
+		(uint x, ) = (2, 4);
+		assert(x == 2);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function.sol
new file mode 100644
index 00000000..a28269eb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() internal pure returns (uint, bool, uint) {
+		uint x = 3;
+		bool b = true;
+		uint y = 999;
+		return (x, b, y);
+	}
+	function g() public pure {
+		(uint x, bool b, uint y) = f();
+		assert(x == 3);
+		assert(b);
+		assert(y == 999);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function_2.sol
new file mode 100644
index 00000000..459fd6e2
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_declarations_function_2.sol
@@ -0,0 +1,18 @@
+contract C
+{
+	function f(uint x) internal pure returns (uint, bool, uint) {
+		bool b = true;
+		uint y = 999;
+		return (x * 2, b, y);
+	}
+	function g() public pure {
+		(uint x, bool b, uint y) = f(7);
+		assert(x == 14);
+		assert(b);
+		assert(y == 999);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_1.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_1.sol
new file mode 100644
index 00000000..f6541bc7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_1.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f() public pure returns(int) {
+		int a;
+		(,, a) = ((((((1, 3, (((((2)))))))))));
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (47-50): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (125-139): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_2.sol
new file mode 100644
index 00000000..7806cb60
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_different_count_assignment_2.sol
@@ -0,0 +1,14 @@
+contract C {
+	function f() public pure returns(int) {
+		int a;
+		((,, a)) = ((((((1, 3, (((((2)))))))))));
+		assert(a == 2);
+		assert(a == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6321: (47-50): Unnamed return variable can remain unassigned. Add an explicit return with value to all non-reverting code paths or name the variable.
+// Warning 6328: (127-141): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_extra_parens_7.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_extra_parens_7.sol
new file mode 100644
index 00000000..7defe2cd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_extra_parens_7.sol
@@ -0,0 +1,15 @@
+contract C {
+	function g() internal pure returns (uint, uint) {
+		return (2, 3);
+	}
+	function f() public {
+		(address(1).call(""));
+		(uint x, uint y) = ((g()));
+		assert(x == 2);
+		assert(y == 3);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_function.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function.sol
new file mode 100644
index 00000000..97156f5c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() internal pure returns (uint, uint) {
+		return (2, 3);
+	}
+	function g() public pure {
+		uint x;
+		uint y;
+		(x,y) = f();
+		assert(x == 1);
+		assert(y == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (149-163): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 2\ny = 3\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f() -- internal call
+// Warning 6328: (167-181): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 2\ny = 3\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f() -- internal call
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_2.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_2.sol
new file mode 100644
index 00000000..62b73e90
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_2.sol
@@ -0,0 +1,19 @@
+contract C
+{
+	function f() internal pure returns (uint, uint) {
+		return (2, 3);
+	}
+	function g() public pure {
+		uint x;
+		uint y;
+		(x,) = f();
+		assert(x == 2);
+		assert(y == 4);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (166-180): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 2\ny = 0\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_3.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_3.sol
new file mode 100644
index 00000000..0e0c7bde
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_function_3.sol
@@ -0,0 +1,22 @@
+contract C
+{
+	function f() internal pure returns (uint, bool, uint) {
+		return (2, false, 3);
+	}
+	function g() public pure {
+		uint x;
+		uint y;
+		bool b;
+		(,b,) = f();
+		assert(x == 2);
+		assert(y == 4);
+		assert(!b);
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (172-186): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\ny = 0\nb = false\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f() -- internal call
+// Warning 6328: (190-204): CHC: Assertion violation happens here.\nCounterexample:\n\nx = 0\ny = 0\nb = false\n\nTransaction trace:\nC.constructor()\nC.g()\n    C.f() -- internal call
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/tuple_return_branch.sol b/compiler/test/libsolidity/smtCheckerTests/types/tuple_return_branch.sol
new file mode 100644
index 00000000..33369756
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/tuple_return_branch.sol
@@ -0,0 +1,19 @@
+contract C {
+	struct S { uint x; }
+
+	function g() internal pure returns (uint, S memory) {
+		return (2, S(3));
+	}
+	function f(uint a) public pure {
+		uint x;
+		S memory y;
+		if (a > 100) {
+			(x, y) = g();
+			assert(y.x == 3);
+		 }
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/type_interfaceid.sol b/compiler/test/libsolidity/smtCheckerTests/types/type_interfaceid.sol
new file mode 100644
index 00000000..cd0d5650
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/type_interfaceid.sol
@@ -0,0 +1,33 @@
+interface I1 {
+}
+
+interface I2 {
+	function f() external;
+}
+
+interface I3 {
+	function f() external;
+	function g(uint, address) external;
+}
+
+contract C {
+	function f() public pure {
+		assert(type(I1).interfaceId == 0);
+		assert(type(I2).interfaceId != 0);
+		assert(type(I2).interfaceId == 0x26121ff0);
+		assert(type(I2).interfaceId != 0);
+		assert(type(I3).interfaceId == 0x822b51c6);
+	}
+	function g() public pure {
+		assert(type(I1).interfaceId == type(I2).interfaceId);
+	}
+	function h() public pure {
+		assert(type(I2).interfaceId == type(I3).interfaceId);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (416-468): CHC: Assertion violation happens here.
+// Warning 6328: (503-555): CHC: Assertion violation happens here.
+// Info 1391: CHC: 5 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/type_minmax.sol b/compiler/test/libsolidity/smtCheckerTests/types/type_minmax.sol
new file mode 100644
index 00000000..da9bb1b6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/type_minmax.sol
@@ -0,0 +1,85 @@
+contract C {
+	function f(uint a) public pure {
+		assert(a <= type(uint).max);
+		assert(a >= type(uint).min);
+		require(a <= type(uint64).max);
+		assert(a <= type(uint64).max);
+		assert(a <= type(uint32).max);
+	}
+
+	function int_min() public pure {
+		int8 int8_min = type(int8).min;
+		assert(int8_min == -2**7);
+
+		int16 int16_min = type(int16).min;
+		assert(int16_min == -2**15);
+
+		int24 int24_min = type(int24).min;
+		assert(int24_min == -2**23);
+
+		int32 int32_min = type(int32).min;
+		assert(int32_min == -2**31);
+
+		int64 int64_min = type(int64).min;
+		assert(int64_min == -2**63);
+
+		int256 int256_min = type(int256).min;
+		assert(int256_min == -2**255);
+	}
+
+	function int_max() public pure {
+		int8 int8_max = type(int8).max;
+		assert(int8_max == 2**7-1);
+
+		int16 int16_max = type(int16).max;
+		assert(int16_max == 2**15-1);
+
+		int24 int24_max = type(int24).max;
+		assert(int24_max == 2**23-1);
+
+		int32 int32_max = type(int32).max;
+		assert(int32_max == 2**31-1);
+
+		int256 int256_max = type(int256).max;
+		assert(int256_max == 2**255-1);
+	}
+
+	function uint_min() public pure {
+		uint8 uint8_min = type(uint8).min;
+		assert(uint8_min == 0);
+
+		uint16 uint16_min = type(uint16).min;
+		assert(uint16_min == 0);
+
+		uint24 uint24_min = type(uint24).min;
+		assert(uint24_min == 0);
+
+		uint32 uint32_min = type(uint32).min;
+		assert(uint32_min == 0);
+
+		uint256 uint256_min = type(uint256).min;
+		assert(uint256_min == 0);
+	}
+
+	function uint_max() public pure {
+		uint8 uint8_max = type(uint8).max;
+		assert(uint8_max == 2**8-1);
+
+		uint16 uint16_max = type(uint16).max;
+		assert(uint16_max == 2**16-1);
+
+		uint24 uint24_max = type(uint24).max;
+		assert(uint24_max == 2**24-1);
+
+		uint32 uint32_max = type(uint32).max;
+		assert(uint32_max == 2**32-1);
+
+		uint256 uint256_max = type(uint256).max;
+		assert(uint256_max == 2**256-1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (178-207): CHC: Assertion violation happens here.
+// Info 1391: CHC: 24 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/types/unused_mapping.sol b/compiler/test/libsolidity/smtCheckerTests/types/unused_mapping.sol
new file mode 100644
index 00000000..889cf78a
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/types/unused_mapping.sol
@@ -0,0 +1,20 @@
+contract C {
+	uint x;
+	uint y;
+	mapping (address => bool) public never_used;
+
+	function inc() public {
+		require(x < 10);
+		require(y < 10);
+
+		if(x == 0) x = 0; // noop state var read
+		x++;
+		y++;
+		// Commented out because of nondeterminism in Spacer in Z3 4.8.9
+		//assert(y == x);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/unchecked/block_inside_unchecked.sol b/compiler/test/libsolidity/smtCheckerTests/unchecked/block_inside_unchecked.sol
new file mode 100644
index 00000000..e9321b46
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unchecked/block_inside_unchecked.sol
@@ -0,0 +1,14 @@
+contract C {
+  function f() public pure returns (uint y) {
+    unchecked{{
+        uint max = type(uint).max;
+        uint x = max + 1; // overflow not reported
+        y = x;
+    }}
+	assert(y == 0);
+  }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/unchecked/flipping_sign_tests.sol b/compiler/test/libsolidity/smtCheckerTests/unchecked/flipping_sign_tests.sol
new file mode 100644
index 00000000..96b41501
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unchecked/flipping_sign_tests.sol
@@ -0,0 +1,13 @@
+contract test {
+    function f() public pure returns (bool) {
+        int256 x = -2**255;
+        unchecked { assert(-x == x); }
+        assert(-x == x); // CHC apparently does not create an underflow target for unary minus
+        return true;
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (110-125): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/unchecked/inc_dec.sol b/compiler/test/libsolidity/smtCheckerTests/unchecked/inc_dec.sol
new file mode 100644
index 00000000..5af2a6d7
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unchecked/inc_dec.sol
@@ -0,0 +1,29 @@
+contract C {
+	function o() public pure {
+		uint x = type(uint).max;
+		unchecked { ++x; }
+		assert(x == type(uint).min);
+	}
+
+	function u() public pure {
+		uint x = type(uint).min;
+		unchecked { --x; }
+		assert(x == type(uint).max);
+	}
+
+	function o_int() public pure {
+		int x = type(int).max;
+		unchecked { ++x; }
+		assert(x == type(int).min);
+	}
+
+	function u_int() public pure {
+		int x = type(int).min;
+		unchecked { --x; }
+		assert(x == type(int).max);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/unchecked/signed_mod.sol b/compiler/test/libsolidity/smtCheckerTests/unchecked/signed_mod.sol
new file mode 100644
index 00000000..9d04f9ed
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unchecked/signed_mod.sol
@@ -0,0 +1,19 @@
+contract C {
+    function f(int a, int b) public pure returns (int) {
+        return a % b; // can div by 0
+    }
+    function g(bool _check) public pure returns (int) {
+        int x = type(int).min;
+        if (_check) {
+            return x / -1; // can overflow
+        } else {
+            unchecked { return x / -1; } // overflow not reported
+        }
+    }
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 4281: (85-90): CHC: Division by zero happens here.
+// Warning 4984: (242-248): CHC: Overflow (resulting value larger than 2**255 - 1) happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/unchecked/unchecked_double_with_modifier.sol b/compiler/test/libsolidity/smtCheckerTests/unchecked/unchecked_double_with_modifier.sol
new file mode 100644
index 00000000..5db44309
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unchecked/unchecked_double_with_modifier.sol
@@ -0,0 +1,16 @@
+contract C {
+
+	modifier m() {
+		unchecked{}
+		_;
+	}
+
+	function t() m internal pure {}
+
+	function f() public pure {
+		unchecked { t(); }
+	}
+}
+// ====
+// SMTEngine: all
+// ----
diff --git a/compiler/test/libsolidity/smtCheckerTests/unsupported/assembly_1.sol b/compiler/test/libsolidity/smtCheckerTests/unsupported/assembly_1.sol
new file mode 100644
index 00000000..4c7ded31
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/unsupported/assembly_1.sol
@@ -0,0 +1,18 @@
+contract C {
+    function f(uint x, uint y) public pure {
+        assembly {}
+        assert(x < y);
+    }
+
+    function g(uint x, uint y) public pure {
+        assembly {}
+        assert(x < y);
+    }
+}
+// ====
+// SMTEngine: all
+// SMTShowUnsupported: no
+// ----
+// Warning 5724: SMTChecker: 2 unsupported language feature(s). Enable the model checker option "show unsupported" to see all of them.
+// Warning 6328: (86-99): CHC: Assertion violation happens here.
+// Warning 6328: (181-194): CHC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/constant.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/constant.sol
new file mode 100644
index 00000000..baba50d0
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/constant.sol
@@ -0,0 +1,20 @@
+type T is int224;
+pragma solidity >= 0.0.0;
+contract C {
+	T constant public s = T.wrap(int224(165521356710917456517261742455526507355687727119203895813322792776));
+	T constant public t = s;
+	int224 constant public u = T.unwrap(t);
+
+	function f() public pure {
+		assert(T.unwrap(s) == 165521356710917456517261742455526507355687727119203895813322792776);
+		assert(T.unwrap(t) == 165521356710917456517261742455526507355687727119203895813322792776);
+		assert(u == 165521356710917456517261742455526507355687727119203895813322792776);
+		assert(T.unwrap(s) == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: no
+// ----
+// Warning 6328: (531-555): CHC: Assertion violation happens here.\nCounterexample:\nu = 165521356710917456517261742455526507355687727119203895813322792776\n\nTransaction trace:\nC.constructor()\nState: u = 165521356710917456517261742455526507355687727119203895813322792776\nC.f()
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_1.sol
new file mode 100644
index 00000000..8aa3d9ae
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_1.sol
@@ -0,0 +1,35 @@
+pragma abicoder v2;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+	function f(uint a) internal pure returns(MyUInt8) {
+		return MyUInt8.wrap(uint8(a));
+	}
+	function g(uint a) internal pure returns(MyInt8) {
+		return MyInt8.wrap(int8(int(a)));
+	}
+
+	function p() public pure {
+		assert(MyUInt8.unwrap(f(1)) == 1);
+		assert(MyUInt8.unwrap(f(2)) == 2);
+		assert(MyUInt8.unwrap(f(257)) == 1);
+		assert(MyUInt8.unwrap(f(257)) == 257); // should fail
+	}
+
+	function q() public pure {
+		assert(MyInt8.unwrap(g(1)) == 1);
+		assert(MyInt8.unwrap(g(2)) == 2);
+		assert(MyInt8.unwrap(g(255)) == -1);
+		assert(MyInt8.unwrap(g(257)) == 1);
+		assert(MyInt8.unwrap(g(257)) == -1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (428-465): CHC: Assertion violation happens here.
+// Warning 6328: (665-700): CHC: Assertion violation happens here.
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_2.sol
new file mode 100644
index 00000000..cfc68b59
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_2.sol
@@ -0,0 +1,32 @@
+pragma abicoder v2;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+	function h(MyUInt8 a) internal pure returns (MyInt8) {
+		return MyInt8.wrap(int8(MyUInt8.unwrap(a)));
+	}
+	function i(MyUInt8 a) internal pure returns(MyUInt16) {
+		return MyUInt16.wrap(MyUInt8.unwrap(a));
+	}
+
+	function r() public pure {
+		assert(MyInt8.unwrap(h(MyUInt8.wrap(1))) == 1);
+		assert(MyInt8.unwrap(h(MyUInt8.wrap(2))) == 2);
+		assert(MyInt8.unwrap(h(MyUInt8.wrap(255))) == -1);
+		assert(MyInt8.unwrap(h(MyUInt8.wrap(255))) == 1); // should fail
+	}
+
+	function s() public pure {
+		assert(MyUInt16.unwrap(i(MyUInt8.wrap(250))) == 250);
+		assert(MyUInt16.unwrap(i(MyUInt8.wrap(250))) == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (497-545): CHC: Assertion violation happens here.
+// Warning 6328: (652-702): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_3.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_3.sol
new file mode 100644
index 00000000..ac70c806
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_3.sol
@@ -0,0 +1,34 @@
+pragma abicoder v2;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+	function j(MyUInt8 a) internal pure returns (uint) {
+		return MyUInt8.unwrap(a);
+	}
+	function k(MyUInt8 a) internal pure returns (MyUInt16) {
+		return MyUInt16.wrap(MyUInt8.unwrap(a));
+	}
+
+	function t() public pure {
+		assert(j(MyUInt8.wrap(1)) == 1);
+		assert(j(MyUInt8.wrap(2)) == 2);
+		assert(j(MyUInt8.wrap(255)) == 0xff);
+		assert(j(MyUInt8.wrap(255)) == 1); // should fail
+	}
+
+	function v() public pure {
+		assert(MyUInt16.unwrap(k(MyUInt8.wrap(1))) == 1);
+		assert(MyUInt16.unwrap(k(MyUInt8.wrap(2))) == 2);
+		assert(MyUInt16.unwrap(k(MyUInt8.wrap(255))) == 0xff);
+		assert(MyUInt16.unwrap(k(MyUInt8.wrap(255))) == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (434-467): CHC: Assertion violation happens here.
+// Warning 6328: (679-729): CHC: Assertion violation happens here.
+// Info 1391: CHC: 6 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_4.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_4.sol
new file mode 100644
index 00000000..891148c6
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/conversion_4.sol
@@ -0,0 +1,24 @@
+pragma abicoder v2;
+
+type MyUInt8 is uint8;
+type MyInt8 is int8;
+type MyUInt16 is uint16;
+
+contract C {
+	function m(MyUInt16 a) internal pure returns (MyUInt8) {
+		return MyUInt8.wrap(uint8(MyUInt16.unwrap(a)));
+	}
+
+	function w() public pure {
+		assert(MyUInt8.unwrap(m(MyUInt16.wrap(1))) == 1);
+		assert(MyUInt8.unwrap(m(MyUInt16.wrap(2))) == 2);
+		assert(MyUInt8.unwrap(m(MyUInt16.wrap(255))) == 0xff);
+		assert(MyUInt8.unwrap(m(MyUInt16.wrap(255))) == 1); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (407-457): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/fixedpoint.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/fixedpoint.sol
new file mode 100644
index 00000000..763a1196
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/fixedpoint.sol
@@ -0,0 +1,76 @@
+// Represent a 18 decimal, 256 bit wide fixed point type using a user defined value type.
+type UFixed256x18 is uint256;
+
+/// A minimal library to do fixed point operations on UFixed256x18.
+library FixedMath {
+	uint constant multiplier = 10**18;
+	/// Adds two UFixed256x18 numbers. Reverts on overflow, relying on checked arithmetic on
+	/// uint256.
+	function add(UFixed256x18 a, UFixed256x18 b) internal pure returns (UFixed256x18) {
+		return UFixed256x18.wrap(UFixed256x18.unwrap(a) + UFixed256x18.unwrap(b));
+	}
+	/// Multiplies UFixed256x18 and uint256. Reverts on overflow, relying on checked arithmetic on
+	/// uint256.
+	function mul(UFixed256x18 a, uint256 b) internal pure returns (UFixed256x18) {
+		return UFixed256x18.wrap(UFixed256x18.unwrap(a) * b);
+	}
+	/// Take the floor of a UFixed256x18 number.
+	/// @return the largest integer that does not exceed `a`.
+	function floor(UFixed256x18 a) internal pure returns (uint256) {
+		return UFixed256x18.unwrap(a) / multiplier;
+	}
+	/// Turns a uint256 into a UFixed256x18 of the same value.
+	/// Reverts if the integer is too large.
+	function toUFixed256x18(uint256 a) internal pure returns (UFixed256x18) {
+		return UFixed256x18.wrap(a * multiplier);
+	}
+}
+
+contract TestFixedMath {
+	function add(UFixed256x18 a, UFixed256x18 b) internal pure returns (UFixed256x18) {
+		return FixedMath.add(a, b);
+	}
+	function mul(UFixed256x18 a, uint256 b) internal pure returns (UFixed256x18) {
+		return FixedMath.mul(a, b);
+	}
+	function floor(UFixed256x18 a) internal pure returns (uint256) {
+		return FixedMath.floor(a);
+	}
+	function toUFixed256x18(uint256 a) internal pure returns (UFixed256x18) {
+		return FixedMath.toUFixed256x18(a);
+	}
+
+	function f() public pure {
+		assert(UFixed256x18.unwrap(add(UFixed256x18.wrap(0), UFixed256x18.wrap(0))) == 0);
+		assert(UFixed256x18.unwrap(add(UFixed256x18.wrap(25), UFixed256x18.wrap(45))) == 0x46);
+		assert(UFixed256x18.unwrap(add(UFixed256x18.wrap(25), UFixed256x18.wrap(45))) == 46); // should fail
+	}
+
+	function g() public pure {
+		assert(UFixed256x18.unwrap(mul(UFixed256x18.wrap(340282366920938463463374607431768211456), 20)) == 6805647338418769269267492148635364229120);
+		assert(UFixed256x18.unwrap(mul(UFixed256x18.wrap(340282366920938463463374607431768211456), 20)) == 0); // should fail
+	}
+
+	function h() public pure {
+		assert(floor(UFixed256x18.wrap(11579208923731619542357098500868790785326998665640564039457584007913129639930)) == 11579208923731619542357098500868790785326998665640564039457);
+		assert(floor(UFixed256x18.wrap(115792089237316195423570985008687907853269984665640564039457584007913129639935)) == 115792089237316195423570985008687907853269984665640564039457);
+		assert(floor(UFixed256x18.wrap(11579208923731619542357098500868790785326998665640564039457584007913129639930)) == 0); // should fail
+	}
+
+	function i() public pure {
+		assert(UFixed256x18.unwrap(toUFixed256x18(0)) == 0);
+		assert(UFixed256x18.unwrap(toUFixed256x18(5)) == 5000000000000000000);
+		assert(UFixed256x18.unwrap(toUFixed256x18(115792089237316195423570985008687907853269984665640564039457)) == 115792089237316195423570985008687907853269984665640564039457000000000000000000);
+		assert(UFixed256x18.unwrap(toUFixed256x18(5)) == 5); // should fail
+	}
+
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (1886-1970): CHC: Assertion violation happens here.
+// Warning 6328: (2165-2266): CHC: Assertion violation happens here.
+// Warning 6328: (2675-2791): CHC: Assertion violation happens here.
+// Warning 6328: (3161-3212): CHC: Assertion violation happens here.
+// Info 1391: CHC: 12 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis.sol
new file mode 100644
index 00000000..ad406318
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis.sol
@@ -0,0 +1,20 @@
+type MyInt is int;
+contract C {
+	function f() public pure returns (MyInt a) {
+		a = MyInt.wrap(5);
+		assert(MyInt.unwrap(a) == 5);
+		assert(MyInt.unwrap(a) == 6); // should fail
+	}
+
+	function g() public pure {
+		MyInt x = f();
+		assert(MyInt.unwrap(x) == 5);
+		assert(MyInt.unwrap(x) == 6); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (133-161): CHC: Assertion violation happens here.
+// Warning 6328: (261-289): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis_2.sol
new file mode 100644
index 00000000..713eb8dd
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/in_parenthesis_2.sol
@@ -0,0 +1,27 @@
+type MyInt is int;
+contract C {
+	function f() public pure returns (MyInt a, int b) {
+		(MyInt).wrap;
+		a = (MyInt).wrap(5);
+		(MyInt).unwrap;
+		b = (MyInt).unwrap((MyInt).wrap(10));
+	}
+
+	function g() public pure {
+		(MyInt x, int y) = f();
+		assert(MyInt.unwrap(x) == 5);
+		assert(MyInt.unwrap(x) == 6); // should fail
+		assert(y == 10);
+		assert(y == 11); // should fail
+	}
+
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6133: (87-99): Statement has no effect.
+// Warning 6133: (126-140): Statement has no effect.
+// Warning 6328: (274-302): CHC: Assertion violation happens here.
+// Warning 6328: (340-355): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/mapping_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/mapping_1.sol
new file mode 100644
index 00000000..100448cb
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/mapping_1.sol
@@ -0,0 +1,14 @@
+type MyInt is int;
+contract C {
+    mapping(MyInt => int) m;
+	function f(MyInt a) public view {
+		assert(m[a] == 0); // should hold
+		assert(m[a] != 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreInv: yes
+// ----
+// Warning 6328: (134-151): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/modifier_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/modifier_1.sol
new file mode 100644
index 00000000..8ff82e51
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/modifier_1.sol
@@ -0,0 +1,19 @@
+type T1 is uint;
+type T2 is uint;
+
+contract C {
+	modifier m(T1 x, T2 y) {
+		require(T1.unwrap(x) == T2.unwrap(y));
+		_;
+	}
+
+	function f(uint x, uint y) m(T1.wrap(x), T2.wrap(y)) public pure {
+		assert(x == y);
+		assert(x != y); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (212-226): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource.sol
new file mode 100644
index 00000000..3e7ff133
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource.sol
@@ -0,0 +1,22 @@
+==== Source: A ====
+type MyInt is int;
+type MyAddress is address;
+==== Source: B ====
+import {MyInt, MyAddress as OurAddress} from "A";
+contract A {
+	function f(int x) internal pure returns(MyInt) { return MyInt.wrap(x); }
+	function f(address x) internal pure returns(OurAddress) { return OurAddress.wrap(x); }
+
+	function g() public pure {
+		assert(MyInt.unwrap(f(int(5))) == 5);
+		assert(MyInt.unwrap(f(int(5))) == 0); // should fail
+		assert(OurAddress.unwrap(f(address(5))) == address(5));
+		assert(OurAddress.unwrap(f(address(5))) == address(0)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (B:296-332): CHC: Assertion violation happens here.
+// Warning 6328: (B:409-463): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource_module.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource_module.sol
new file mode 100644
index 00000000..f4300d25
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/multisource_module.sol
@@ -0,0 +1,23 @@
+==== Source: s1.sol ====
+type MyInt is int;
+==== Source: s2.sol ====
+import "s1.sol" as M;
+contract C {
+	function f(int x) public pure returns (M.MyInt) { return M.MyInt.wrap(x); }
+	function g(M.MyInt x) public pure returns (int) { return M.MyInt.unwrap(x); }
+
+	function h() public pure {
+		assert(M.MyInt.unwrap(f(5)) == 5);
+		assert(M.MyInt.unwrap(f(5)) == 6); // should fail
+		assert(g(M.MyInt.wrap(1)) == 1);
+		assert(g(M.MyInt.wrap(1)) == 0); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (s2.sol:259-292): CHC: Assertion violation happens here.
+// Warning 6328: (s2.sol:346-377): CHC: Assertion violation happens here.
+// Info 1391: CHC: 2 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/simple.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/simple.sol
new file mode 100644
index 00000000..1b0f6e1f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/simple.sol
@@ -0,0 +1,24 @@
+type MyInt is int;
+contract C {
+	function f() internal pure returns (MyInt a) {
+	}
+	function g() internal pure returns (MyInt b, MyInt c) {
+		b = MyInt.wrap(int(1));
+		c = MyInt.wrap(1);
+	}
+
+	function h() public pure {
+		assert(MyInt.unwrap(f()) == 0);
+		assert(MyInt.unwrap(f()) == 1); // should fail
+		(MyInt x, MyInt y) = g();
+		assert(MyInt.unwrap(x) == 1);
+		assert(MyInt.unwrap(x) == 0); // should fail
+		assert(MyInt.unwrap(y) == 1);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (255-285): CHC: Assertion violation happens here.
+// Warning 6328: (364-392): CHC: Assertion violation happens here.
+// Info 1391: CHC: 3 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_1.sol
new file mode 100644
index 00000000..39584360
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_1.sol
@@ -0,0 +1,15 @@
+type T is uint;
+
+contract C {
+	function f(bytes memory data) public pure {
+		T x = abi.decode(data, (T));
+		uint y = abi.decode(data, (uint));
+		assert(T.unwrap(x) == y); // should hold
+		assert(T.unwrap(x) != y); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (188-212): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_2.sol
new file mode 100644
index 00000000..e41c7653
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_abi_2.sol
@@ -0,0 +1,15 @@
+type T is uint;
+
+contract C {
+	function f(bytes memory data) public pure {
+		T x = abi.decode(data, (T));
+		T y = abi.decode(data, (T));
+		assert(T.unwrap(x) == T.unwrap(y)); // should hold
+		assert(T.unwrap(x) != T.unwrap(y)); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Warning 6328: (192-226): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_1.sol
new file mode 100644
index 00000000..5336f752
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_1.sol
@@ -0,0 +1,19 @@
+contract C {
+    type T is address;
+    T[] arr;
+
+    function p() public {
+        arr.push(T.wrap(address(42)));
+    }
+
+    function inv(uint i) external view {
+        require(i < arr.length);
+        assert(T.unwrap(arr[i]) == address(42)); // should hold
+    }
+}
+// ====
+// SMTIgnoreOS: macos
+// ----
+// Warning 6328: (204-243): CHC: Assertion violation might happen here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
+// Warning 4661: (204-243): BMC: Assertion violation happens here.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_2.sol
new file mode 100644
index 00000000..84202b69
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_array_elem_2.sol
@@ -0,0 +1,17 @@
+contract C {
+    type T is address;
+    T[] arr;
+
+    function p() public {
+        arr.push(T.wrap(address(42)));
+    }
+
+    function inv2() external view {
+        if (arr.length > 0) {
+            assert(T.unwrap(arr[0]) == address(0)); // should fail
+        }
+    }
+}
+// ----
+// Warning 6328: (200-238): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_1.sol
new file mode 100644
index 00000000..64a89d1f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_1.sol
@@ -0,0 +1,27 @@
+type T is bool;
+library L{
+    T constant c = T.wrap(true);
+    uint constant z = 42;
+}
+T constant g = T.wrap(true);
+
+contract C {
+    T constant b = T.wrap(true);
+    uint constant X = 42;
+
+    function f() external pure {
+        T x = T.wrap(true);
+        assert(T.unwrap(x)); // should hold
+
+        assert(L.z == 42); // should hold
+        assert(T.unwrap(L.c)); // should hold
+
+        assert(T.unwrap(g)); // should hold
+
+        assert(C.X == 42); // should hold
+        assert(T.unwrap(b)); // should hold
+        assert(T.unwrap(C.b)); // should hold
+    }
+}
+// ----
+// Info 1391: CHC: 7 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_2.sol
new file mode 100644
index 00000000..5b7ebe25
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_library_constant_2.sol
@@ -0,0 +1,33 @@
+type T is bool;
+library L{
+    T constant c = T.wrap(false);
+    uint constant z = 43;
+}
+T constant g = T.wrap(false);
+
+contract C {
+    T constant b = T.wrap(false);
+    uint constant X = 43;
+
+    function f() external pure {
+        T x = T.wrap(false);
+        assert(T.unwrap(x)); // should fail
+
+        assert(L.z == 42); // should fail
+        assert(T.unwrap(L.c)); // should fail
+
+        assert(T.unwrap(g)); // should fail
+
+        assert(C.X == 42); // should fail
+        assert(T.unwrap(b)); // should fail
+        assert(T.unwrap(C.b)); // should fail
+    }
+}
+// ----
+// Warning 6328: (264-283): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (309-326): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (351-372): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (398-417): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (443-460): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (485-504): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
+// Warning 6328: (529-550): CHC: Assertion violation happens here.\nCounterexample:\nX = 43\n\nTransaction trace:\nC.constructor()\nState: X = 43\nC.f()
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_1.sol
new file mode 100644
index 00000000..6761ca6f
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_1.sol
@@ -0,0 +1,21 @@
+contract C {
+    type T is bool;
+    mapping (T => uint) s;
+
+    constructor() {
+        s[C.T.wrap(true)] = 42;
+        s[C.T.wrap(false)] = 2;
+    }
+
+    function f(bool b) external view {
+        assert(s[C.T.wrap(b)] > 0); // should hold
+    }
+
+    function g(T b) external view {
+        require(C.T.unwrap(b));
+        assert(s[b] == 2); // should fail
+    }
+}
+// ----
+// Warning 6328: (325-342): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_2.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_2.sol
new file mode 100644
index 00000000..11e0212c
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_mapping_index_2.sol
@@ -0,0 +1,21 @@
+contract C {
+    type T is address;
+    mapping (T => uint) s;
+
+    constructor() {
+        s[T.wrap(address(0))] = 42;
+    }
+
+    function f(address a) external view {
+        require(a != address(0));
+        assert(s[C.T.wrap(a)] == 0); // should hold
+    }
+
+    function g(T a) external view {
+        require(C.T.unwrap(a) == address(0));
+        assert(s[a] != 42); // should fail
+    }
+}
+// ----
+// Warning 6328: (352-370): CHC: Assertion violation happens here.
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_struct_member_1.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_struct_member_1.sol
new file mode 100644
index 00000000..8d2b990d
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/user_type_as_struct_member_1.sol
@@ -0,0 +1,27 @@
+contract C {
+    type T is address;
+
+    struct S {
+        T a;
+        uint x;
+    }
+
+    mapping (T => S) m;
+
+    constructor() {
+        m[T.wrap(address(0))] = S(T.wrap(address(0)), 0);
+    }
+
+    function set(address _a) external {
+        m[T.wrap(_a)] = S(T.wrap(_a), 0);
+    }
+
+    function inv(T t) external view {
+        assert( // should hold
+            T.unwrap(m[t].a) == T.unwrap(t) ||
+            T.unwrap(m[t].a) == address(0)
+        );
+    }
+}
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/userTypes/wrap_unwrap_via_contract_name.sol b/compiler/test/libsolidity/smtCheckerTests/userTypes/wrap_unwrap_via_contract_name.sol
new file mode 100644
index 00000000..1747c352
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/userTypes/wrap_unwrap_via_contract_name.sol
@@ -0,0 +1,37 @@
+contract C {
+	type T is uint;
+}
+contract D {
+	function f(C.T x) internal pure returns(uint) {
+		return C.T.unwrap(x);
+	}
+	function g(uint x) internal pure returns(C.T) {
+		return C.T.wrap(x);
+	}
+	function h(uint x) internal pure returns(uint) {
+		return f(g(x));
+	}
+	function i(C.T x) internal pure returns(C.T) {
+		return g(f(x));
+	}
+
+	function m() public pure {
+		assert(f(C.T.wrap(0x42)) == 0x42);
+		assert(f(C.T.wrap(0x42)) == 0x43); // should fail
+		assert(C.T.unwrap(g(0x42)) == 0x42);
+		assert(C.T.unwrap(g(0x42)) == 0x43); // should fail
+		assert(h(0x42) == 0x42);
+		assert(h(0x42) == 0x43); // should fail
+		assert(C.T.unwrap(i(C.T.wrap(0x42))) == 0x42);
+		assert(C.T.unwrap(i(C.T.wrap(0x42))) == 0x43); // should fail
+	}
+}
+// ====
+// SMTEngine: all
+// SMTIgnoreCex: yes
+// ----
+// Warning 6328: (403-436): CHC: Assertion violation happens here.
+// Warning 6328: (494-529): CHC: Assertion violation happens here.
+// Warning 6328: (575-598): CHC: Assertion violation happens here.
+// Warning 6328: (666-711): CHC: Assertion violation happens here.
+// Info 1391: CHC: 4 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require.sol b/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require.sol
new file mode 100644
index 00000000..980cab8e
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(uint a) public pure { require(a < 10); assert(a < 20); }
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require_message.sol b/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require_message.sol
new file mode 100644
index 00000000..b63801cf
--- /dev/null
+++ b/compiler/test/libsolidity/smtCheckerTests/verification_target/simple_assert_with_require_message.sol
@@ -0,0 +1,10 @@
+contract C {
+	function f(uint a) public pure {
+		require(a < 10, "Input number is too large.");
+		assert(a < 20);
+	}
+}
+// ====
+// SMTEngine: all
+// ----
+// Info 1391: CHC: 1 verification condition(s) proved safe! Enable the model checker option "show proved safe" to see all of them.
diff --git a/compiler/test/libsolidity/syntaxTests/abiEncoder/abi_encodeCall_tuple_from_invalid_operator.sol b/compiler/test/libsolidity/syntaxTests/abiEncoder/abi_encodeCall_tuple_from_invalid_operator.sol
new file mode 100644
index 00000000..f6035dd0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/abiEncoder/abi_encodeCall_tuple_from_invalid_operator.sol
@@ -0,0 +1,23 @@
+contract C {
+    event Ev();
+    error Er();
+
+    function g0() internal pure {}
+    function g2() internal pure returns (uint, uint) { return (2, 3); }
+
+    function f0() public {}
+    function f2(uint, uint) public {}
+
+    function h() public view {
+        abi.encodeCall(this.f2, (1, 1) + (2, 2));
+        abi.encodeCall(this.f0, Ev() / Er());
+        abi.encodeCall(this.f0, !());
+    }
+}
+// ----
+// TypeError 2271: (284-299): Built-in binary operator + cannot be applied to types tuple(int_const 1,int_const 1) and tuple(int_const 2,int_const 2).
+// TypeError 9062: (284-299): Expected an inline tuple, not an expression of a tuple type.
+// TypeError 2271: (334-345): Built-in binary operator / cannot be applied to types tuple() and tuple().
+// TypeError 9062: (334-345): Expected an inline tuple, not an expression of a tuple type.
+// TypeError 4907: (380-383): Built-in unary operator ! cannot be applied to type tuple().
+// TypeError 9062: (380-383): Expected an inline tuple, not an expression of a tuple type.
diff --git a/compiler/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_attached_function_returning_struct.sol b/compiler/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_attached_function_returning_struct.sol
new file mode 100644
index 00000000..bb3651d4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/abiEncoder/v1_call_to_v2_library_attached_function_returning_struct.sol
@@ -0,0 +1,23 @@
+==== Source: A ====
+pragma abicoder               v2;
+
+library L {
+    struct Item {
+        uint x;
+    }
+
+    function f(uint) external view returns (Item memory) {}
+}
+==== Source: B ====
+pragma abicoder v1;
+import "A";
+
+contract D {
+    using L for uint;
+
+    function test() public {
+        uint(1).f();
+    }
+}
+// ----
+// TypeError 2428: (B:106-117): The type of return parameter 1, struct L.Item memory, is only supported in ABI coder v2. Use "pragma abicoder v2;" to enable the feature.
diff --git a/compiler/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol b/compiler/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol
new file mode 100644
index 00000000..2d2e7568
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/abiEncoder/v2_call_to_v2_library_function_pointer_accepting_struct.sol
@@ -0,0 +1,25 @@
+==== Source: A ====
+pragma abicoder               v2;
+
+library L {
+    struct Item {
+        uint x;
+    }
+
+    function get(Item memory _item) external {}
+}
+==== Source: B ====
+pragma abicoder               v2;
+
+import "A";
+
+contract Test {
+    function foo() public {
+        // NOTE: This test checks a case that is currently not possible (pointer to an external
+        // library function) but it might become possible in the future.
+        function(L.Item memory) external ptr = L.get;
+        ptr(L.Item(5));
+    }
+}
+// ----
+// TypeError 9574: (B:269-313): Type function (struct L.Item memory) is not implicitly convertible to expected type function (struct L.Item memory) external. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/constants/constant_cyclic_via_user_operators.sol b/compiler/test/libsolidity/syntaxTests/constants/constant_cyclic_via_user_operators.sol
new file mode 100644
index 00000000..e0af337c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constants/constant_cyclic_via_user_operators.sol
@@ -0,0 +1,10 @@
+type Type is uint;
+using {f as +} for Type global;
+function f(Type, Type) pure returns (Type) {}
+
+Type constant t = Type.wrap(1);
+Type constant u = v + t;
+Type constant v = u + t;
+// ----
+// TypeError 8349: (148-153): Initial value for constant variable has to be compile-time constant.
+// TypeError 8349: (173-178): Initial value for constant variable has to be compile-time constant.
diff --git a/compiler/test/libsolidity/syntaxTests/constants/file_level_multiple_constant_keywords.sol b/compiler/test/libsolidity/syntaxTests/constants/file_level_multiple_constant_keywords.sol
new file mode 100644
index 00000000..1ca07c66
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constants/file_level_multiple_constant_keywords.sol
@@ -0,0 +1,4 @@
+uint constant constant x;
+// ----
+// ParserError 3109: (14-22): Mutability already set to "constant"
+
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/abstract_creation_forward_reference.sol b/compiler/test/libsolidity/syntaxTests/constructor/abstract_creation_forward_reference.sol
new file mode 100644
index 00000000..144b3141
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/abstract_creation_forward_reference.sol
@@ -0,0 +1,15 @@
+// This used to cause an internal error because of the visitation order.
+contract Test {
+    function createChild() public {
+       Child asset = new Child();
+    }
+}
+
+contract Parent {
+    constructor(address _address) {}
+}
+
+contract Child is Parent {
+}
+// ----
+// TypeError 3415: (226-254): No arguments passed to the base constructor. Specify the arguments or mark "Child" as abstract.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments.sol
new file mode 100644
index 00000000..5a005c16
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments.sol
@@ -0,0 +1,30 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C() {}
+contract E is C() { constructor() {} }
+contract F is C() { constructor() C {} }
+contract G is C() { constructor() C() {} }
+
+contract H is C {}
+contract I is C { constructor() {} }
+contract J is C { constructor() C {} }
+contract K is C { constructor() C() {} }
+// ----
+// TypeError 3415: (47-67): No arguments passed to the base constructor. Specify the arguments or mark "D" as abstract.
+// TypeError 3415: (68-106): No arguments passed to the base constructor. Specify the arguments or mark "E" as abstract.
+// DeclarationError 1563: (141-142): Modifier-style base constructor call without arguments.
+// TypeError 3415: (107-147): No arguments passed to the base constructor. Specify the arguments or mark "F" as abstract.
+// TypeError 3415: (192-210): No arguments passed to the base constructor. Specify the arguments or mark "H" as abstract.
+// TypeError 3415: (211-247): No arguments passed to the base constructor. Specify the arguments or mark "I" as abstract.
+// DeclarationError 1563: (280-281): Modifier-style base constructor call without arguments.
+// TypeError 3415: (248-286): No arguments passed to the base constructor. Specify the arguments or mark "J" as abstract.
+// TypeError 7927: (61-64): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 7927: (82-85): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 7927: (121-124): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (141-142): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
+// TypeError 7927: (162-165): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (182-185): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
+// TypeError 2973: (280-281): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
+// TypeError 2973: (319-322): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_inheritance_list_empty_parens.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_inheritance_list_empty_parens.sol
new file mode 100644
index 00000000..42ba9886
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_inheritance_list_empty_parens.sol
@@ -0,0 +1,16 @@
+abstract contract C {
+    constructor(uint, bool) {}
+}
+
+abstract contract D is C() {}
+abstract contract E is C() { constructor() {} }
+abstract contract F is C() { constructor() C {} }
+abstract contract G is C() { constructor() C() {} }
+// ----
+// DeclarationError 1563: (177-178): Modifier-style base constructor call without arguments.
+// TypeError 7927: (79-82): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 7927: (109-112): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 7927: (157-160): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (177-178): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
+// TypeError 7927: (207-210): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (227-230): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_lists_omitted.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_lists_omitted.sol
new file mode 100644
index 00000000..ad934d7e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_lists_omitted.sol
@@ -0,0 +1,6 @@
+abstract contract C {
+    constructor(uint, bool) {}
+}
+
+abstract contract D is C {}
+abstract contract E is C { constructor() {} }
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init.sol
new file mode 100644
index 00000000..7cf33c0e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init.sol
@@ -0,0 +1,8 @@
+abstract contract C {
+    constructor(uint, bool) {}
+}
+
+abstract contract D is C { constructor() C {} }
+// ----
+// DeclarationError 1563: (97-98): Modifier-style base constructor call without arguments.
+// TypeError 2973: (97-98): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init_empty_list.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init_empty_list.sol
new file mode 100644
index 00000000..43c68a7e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_missing_arguments_abstract_modifier_init_empty_list.sol
@@ -0,0 +1,7 @@
+abstract contract C {
+    constructor(uint, bool) {}
+}
+
+abstract contract D is C { constructor() C() {} }
+// ----
+// TypeError 2973: (97-100): Wrong argument count for modifier invocation: 0 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_and_modifier_lists.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_and_modifier_lists.sol
new file mode 100644
index 00000000..08193b6d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_and_modifier_lists.sol
@@ -0,0 +1,13 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C(1, true, "a") { constructor() C(1, true, "a") {} }
+contract E is C(1) { constructor() C(1) {} }
+// ----
+// DeclarationError 3364: (93-108): Base constructor arguments given twice.
+// DeclarationError 3364: (149-153): Base constructor arguments given twice.
+// TypeError 7927: (61-76): Wrong argument count for constructor call: 3 arguments given but expected 2
+// TypeError 2973: (93-108): Wrong argument count for modifier invocation: 3 arguments given but expected 2.
+// TypeError 7927: (128-132): Wrong argument count for constructor call: 1 arguments given but expected 2
+// TypeError 2973: (149-153): Wrong argument count for modifier invocation: 1 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list.sol
new file mode 100644
index 00000000..f2046248
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list.sol
@@ -0,0 +1,9 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C(1, true, "a") {}
+contract E is C(1) {}
+// ----
+// TypeError 7927: (61-76): Wrong argument count for constructor call: 3 arguments given but expected 2
+// TypeError 7927: (94-98): Wrong argument count for constructor call: 1 arguments given but expected 2
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_abstract.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_abstract.sol
new file mode 100644
index 00000000..b7b619d8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_abstract.sol
@@ -0,0 +1,9 @@
+abstract contract C {
+    constructor(uint, bool) {}
+}
+
+abstract contract D is C(1, true, "a") {}
+abstract contract E is C(1) {}
+// ----
+// TypeError 7927: (79-94): Wrong argument count for constructor call: 3 arguments given but expected 2
+// TypeError 7927: (121-125): Wrong argument count for constructor call: 1 arguments given but expected 2
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_empty_parens_and_modifier_list.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_empty_parens_and_modifier_list.sol
new file mode 100644
index 00000000..5bf9d123
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_empty_parens_and_modifier_list.sol
@@ -0,0 +1,11 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C() { constructor() C(1, true, "a") {} }
+contract E is C() { constructor() C(1) {} }
+// ----
+// TypeError 7927: (61-64): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (81-96): Wrong argument count for modifier invocation: 3 arguments given but expected 2.
+// TypeError 7927: (116-119): Wrong argument count for constructor call: 0 arguments given but expected 2. Remove parentheses if you do not want to provide arguments here.
+// TypeError 2973: (136-140): Wrong argument count for modifier invocation: 1 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_with_derived_constructor.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_with_derived_constructor.sol
new file mode 100644
index 00000000..ff8a0f93
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_inheritance_list_with_derived_constructor.sol
@@ -0,0 +1,9 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C(1, true, "a") { constructor() {} }
+contract E is C(1) { constructor() {} }
+// ----
+// TypeError 7927: (61-76): Wrong argument count for constructor call: 3 arguments given but expected 2
+// TypeError 7927: (112-116): Wrong argument count for constructor call: 1 arguments given but expected 2
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_modifier_list.sol b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_modifier_list.sol
new file mode 100644
index 00000000..8fe486e1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/base_constructor_wrong_arg_count_modifier_list.sol
@@ -0,0 +1,9 @@
+contract C {
+    constructor(uint, bool) {}
+}
+
+contract D is C { constructor() C(1, true, "a") {} }
+contract E is C { constructor() C(1) {} }
+// ----
+// TypeError 2973: (79-94): Wrong argument count for modifier invocation: 3 arguments given but expected 2.
+// TypeError 2973: (132-136): Wrong argument count for modifier invocation: 1 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/constructor_function_parameter_disallowed_conversion.sol b/compiler/test/libsolidity/syntaxTests/constructor/constructor_function_parameter_disallowed_conversion.sol
new file mode 100644
index 00000000..e22462da
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/constructor_function_parameter_disallowed_conversion.sol
@@ -0,0 +1,59 @@
+contract D {
+    constructor(function() external pure returns (uint) ) {
+    }
+}
+
+library L {
+    function f() public pure returns (uint) {
+        return 5;
+    }
+}
+
+contract C {
+    function f() public returns (uint r) {
+        // An assert used to fail if the function types are not exactly equal (pure, view) v/s
+        // default
+        // ok
+        new D(this.testPure);
+        // not okay
+        new D(this.testView);
+        // not okay
+        new D(this.testDefault);
+        // not okay
+        new D(this.testDifferentSignature);
+        // not okay
+        new D(gasleft);
+        // not okay
+        new D(L.f);
+        // not okay
+        new D(testInternalFunction);
+        // not okay
+        new D(this.testInternalFunction);
+    }
+
+    function testPure() public pure returns (uint) {
+    }
+
+    function testView() public view returns (uint) {
+        block.timestamp;
+    }
+
+    function testDefault() public returns (uint) {
+        selfdestruct(payable(address(this)));
+    }
+
+    function testDifferentSignature(uint a) public pure returns (uint) {
+    }
+
+    function testInternalFunction() internal pure returns (uint) {
+        return 10;
+    }
+}
+// ----
+// TypeError 9553: (415-428): Invalid type for argument in function call. Invalid implicit conversion from function () view external returns (uint256) to function () pure external returns (uint256) requested.
+// TypeError 9553: (465-481): Invalid type for argument in function call. Invalid implicit conversion from function () external returns (uint256) to function () pure external returns (uint256) requested.
+// TypeError 9553: (518-545): Invalid type for argument in function call. Invalid implicit conversion from function (uint256) pure external returns (uint256) to function () pure external returns (uint256) requested.
+// TypeError 9553: (582-589): Invalid type for argument in function call. Invalid implicit conversion from function () view returns (uint256) to function () pure external returns (uint256) requested. Special functions cannot be converted to function types.
+// TypeError 9553: (626-629): Invalid type for argument in function call. Invalid implicit conversion from function () pure returns (uint256) to function () pure external returns (uint256) requested. Special functions cannot be converted to function types.
+// TypeError 9553: (666-686): Invalid type for argument in function call. Invalid implicit conversion from function () pure returns (uint256) to function () pure external returns (uint256) requested. Special functions cannot be converted to function types.
+// TypeError 9582: (723-748): Member "testInternalFunction" not found or not visible after argument-dependent lookup in contract C.
diff --git a/compiler/test/libsolidity/syntaxTests/constructor/constructor_visibility.sol b/compiler/test/libsolidity/syntaxTests/constructor/constructor_visibility.sol
new file mode 100644
index 00000000..5992dfa4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/constructor/constructor_visibility.sol
@@ -0,0 +1,13 @@
+// The constructor of a base class should not be visible in the derived class
+contract A { constructor(string memory) { } }
+contract B is A {
+  function f() pure public {
+    A x = A(address(0)); // convert from address
+    string memory y = "ab";
+    A(y); // call as a function is invalid
+    x;
+  }
+}
+// ----
+// TypeError 3415: (124-303): No arguments passed to the base constructor. Specify the arguments or mark "B" as abstract.
+// TypeError 9640: (252-256): Explicit type conversion not allowed from "string memory" to "contract A".
diff --git a/compiler/test/libsolidity/syntaxTests/controlFlow/localStorageVariables/ternary_assignment_fine.sol b/compiler/test/libsolidity/syntaxTests/controlFlow/localStorageVariables/ternary_assignment_fine.sol
new file mode 100644
index 00000000..10e9a679
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/controlFlow/localStorageVariables/ternary_assignment_fine.sol
@@ -0,0 +1,9 @@
+contract C {
+    uint256[] s;
+    function f() public view {
+        uint256[] storage x;
+        uint256[] storage y = (x = s)[0] > 0 ? x : x;
+        y;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/binary_operator_udvt.sol b/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/binary_operator_udvt.sol
new file mode 100644
index 00000000..d0a0b6ea
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/binary_operator_udvt.sol
@@ -0,0 +1,17 @@
+type X is uint24;
+type Y is uint16;
+
+using {addX as +} for X global;
+using {addY as +} for Y global;
+
+function addX(X, X) pure returns (X) {}
+function addY(Y, Y) pure returns (Y) { revert(); }
+
+contract C {
+    function f() public pure {
+        X.wrap(1) + X.wrap(Y.unwrap(Y.wrap(2) + Y.wrap(3)));
+        X.wrap(4) + X.wrap(5); // Unreachable
+    }
+}
+// ----
+// Warning 5740: (307-328): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/unary_operator_udvt.sol b/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/unary_operator_udvt.sol
new file mode 100644
index 00000000..12b0f03b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/controlFlow/userDefinedOperators/unary_operator_udvt.sol
@@ -0,0 +1,17 @@
+type X is uint24;
+type Y is uint16;
+
+using {unsubX as -} for X global;
+using {unsubY as -} for Y global;
+
+function unsubX(X) pure returns (X) {}
+function unsubY(Y) pure returns (Y) { revert(); }
+
+contract C {
+    function f() public pure {
+        -X.wrap(Y.unwrap(-Y.wrap(1)));
+        -X.wrap(Y.unwrap(Y.wrap(2))); // Unreachable
+    }
+}
+// ----
+// Warning 5740: (287-315): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_comparison.sol b/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_comparison.sol
new file mode 100644
index 00000000..708713b6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_comparison.sol
@@ -0,0 +1,27 @@
+contract D {}
+
+contract C {
+    C c;
+    D d;
+
+    function foo() public {
+        // Current instance of the current contract vs super
+        super != this;
+        this != super;
+
+        // Different instance of the current contract vs super
+        super != c;
+        c != super;
+
+        // Instance of an unrelated contract vs super
+        super != d;
+        d != super;
+    }
+}
+// ----
+// TypeError 2271: (144-157): Built-in binary operator != cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (167-180): Built-in binary operator != cannot be applied to types contract C and type(contract super C).
+// TypeError 2271: (254-264): Built-in binary operator != cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (274-284): Built-in binary operator != cannot be applied to types contract C and type(contract super C).
+// TypeError 2271: (349-359): Built-in binary operator != cannot be applied to types type(contract super C) and contract D.
+// TypeError 2271: (369-379): Built-in binary operator != cannot be applied to types contract D and type(contract super C).
diff --git a/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_operators.sol b/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_operators.sol
new file mode 100644
index 00000000..234657a2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/conversion/implicit_conversion_of_super_in_operators.sol
@@ -0,0 +1,56 @@
+contract C {
+    function foo() public {
+        super << this;
+        super >> this;
+        super ^ this;
+        super | this;
+        super & this;
+
+        super * this;
+        super / this;
+        super % this;
+        super - this;
+        super + this;
+        super ** this;
+
+        super == this;
+        super != this;
+        super >= this;
+        super <= this;
+        super < this;
+        super > this;
+
+        super || this;
+        super && this;
+
+        super -= this;
+        super += this;
+
+        true ? super : this;
+    }
+}
+// ----
+// TypeError 2271: (49-62): Built-in binary operator << cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (72-85): Built-in binary operator >> cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (95-107): Built-in binary operator ^ cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (117-129): Built-in binary operator | cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (139-151): Built-in binary operator & cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (162-174): Built-in binary operator * cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (184-196): Built-in binary operator / cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (206-218): Built-in binary operator % cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (228-240): Built-in binary operator - cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (250-262): Built-in binary operator + cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (272-285): Built-in binary operator ** cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (296-309): Built-in binary operator == cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (319-332): Built-in binary operator != cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (342-355): Built-in binary operator >= cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (365-378): Built-in binary operator <= cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (388-400): Built-in binary operator < cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (410-422): Built-in binary operator > cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (433-446): Built-in binary operator || cannot be applied to types type(contract super C) and contract C.
+// TypeError 2271: (456-469): Built-in binary operator && cannot be applied to types type(contract super C) and contract C.
+// TypeError 4247: (480-485): Expression has to be an lvalue.
+// TypeError 7366: (480-493): Operator -= not compatible with types type(contract super C) and contract C.
+// TypeError 4247: (503-508): Expression has to be an lvalue.
+// TypeError 7366: (503-516): Operator += not compatible with types type(contract super C) and contract C.
+// TypeError 9717: (534-539): Invalid mobile type in true expression.
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/denominations_in_array_sizes.sol b/compiler/test/libsolidity/syntaxTests/denominations/denominations_in_array_sizes.sol
new file mode 100644
index 00000000..46c7a0d8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/denominations_in_array_sizes.sol
@@ -0,0 +1,12 @@
+contract C {
+    uint[42 wei] a;
+    uint[42 gwei] b;
+    uint[42 ether] c;
+    uint[42 seconds] d;
+    uint[42 minutes] e;
+    uint[42 hours] f;
+    uint[42 days] g;
+    uint[42 weeks] h;
+}
+// ----
+// Warning 7325: (58-72): Type uint256[42000000000000000000] covers a large part of storage and thus makes collisions likely. Either use mappings or dynamic arrays and allow their size to be increased only in small quantities per transaction.
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/finney_invalid.sol b/compiler/test/libsolidity/syntaxTests/denominations/finney_invalid.sol
new file mode 100644
index 00000000..0974cde1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/finney_invalid.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        uint x = 1 finney;
+    }
+}
+// ----
+// ParserError 2314: (58-64): Expected ';' but got identifier
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_address.sol b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_address.sol
new file mode 100644
index 00000000..8eec22de
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_address.sol
@@ -0,0 +1,5 @@
+contract C {
+	address a = 0x11111122222333334444455555666667777788888 wei;
+}
+// ----
+// TypeError 5145: (26-73): Hexadecimal numbers cannot be used with unit denominations. You can use an expression of the form "0x1234 * 1 day" instead.
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_no_whitespace.sol b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_no_whitespace.sol
new file mode 100644
index 00000000..f67fde89
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_no_whitespace.sol
@@ -0,0 +1,5 @@
+contract C {
+	uint constant y = 1wei;
+}
+// ----
+// ParserError 8936: (32-33): Identifier-start is not allowed at end of a number.
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_bool.sol b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_bool.sol
new file mode 100644
index 00000000..58d7d205
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_bool.sol
@@ -0,0 +1,5 @@
+contract C {
+	bool constant x = true ether;
+}
+// ----
+// ParserError 2314: (37-42): Expected ';' but got 'ether'
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_string.sol b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_string.sol
new file mode 100644
index 00000000..9d27c5d3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/invalid_denomination_on_string.sol
@@ -0,0 +1,5 @@
+contract C {
+	string s = "abc" ether;
+}
+// ----
+// ParserError 2314: (31-36): Expected ';' but got 'ether'
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/szabo_invalid.sol b/compiler/test/libsolidity/syntaxTests/denominations/szabo_invalid.sol
new file mode 100644
index 00000000..d0e3eb3f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/szabo_invalid.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        uint x = 1 szabo;
+    }
+}
+// ----
+// ParserError 2314: (58-63): Expected ';' but got identifier
diff --git a/compiler/test/libsolidity/syntaxTests/denominations/two_denominations_same_literal.sol b/compiler/test/libsolidity/syntaxTests/denominations/two_denominations_same_literal.sol
new file mode 100644
index 00000000..8583e1d4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/denominations/two_denominations_same_literal.sol
@@ -0,0 +1,5 @@
+contract C {
+	uint constant y = 8 gwei ether;
+}
+// ----
+// ParserError 2314: (39-44): Expected ';' but got 'ether'
diff --git a/compiler/test/libsolidity/syntaxTests/errors/elementary_non_address_state_mutability_error_argument.sol b/compiler/test/libsolidity/syntaxTests/errors/elementary_non_address_state_mutability_error_argument.sol
new file mode 100644
index 00000000..110af7e3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/elementary_non_address_state_mutability_error_argument.sol
@@ -0,0 +1,85 @@
+contract C {
+    error a(bool payable);
+    error b(string payable);
+    error c(int payable);
+    error d(int256 payable);
+    error e(uint payable);
+    error f(uint256 payable);
+    error g(bytes1 payable);
+    error h(bytes payable);
+    error i(bytes32 payable);
+    error j(fixed payable);
+    error k(fixed80x80 payable);
+    error l(ufixed payable);
+    error m(ufixed80x80 payable);
+}
+contract C2 {
+    error a(bool view);
+    error b(string view);
+    error c(int view);
+    error d(int256 view);
+    error e(uint view);
+    error f(uint256 view);
+    error g(bytes1 view);
+    error h(bytes view);
+    error i(bytes32 view);
+    error j(fixed view);
+    error k(fixed80x80 view);
+    error l(ufixed view);
+    error m(ufixed80x80 view);
+}
+contract C3 {
+    error a(bool pure);
+    error b(string pure);
+    error c(int pure);
+    error d(int256 pure);
+    error e(uint pure);
+    error f(uint256 pure);
+    error g(bytes1 pure);
+    error h(bytes pure);
+    error i(bytes32 pure);
+    error j(fixed pure);
+    error k(fixed80x80 pure);
+    error l(ufixed pure);
+    error m(ufixed80x80 pure);
+}
+// ----
+// ParserError 9106: (30-37): State mutability can only be specified for address types.
+// ParserError 9106: (59-66): State mutability can only be specified for address types.
+// ParserError 9106: (85-92): State mutability can only be specified for address types.
+// ParserError 9106: (114-121): State mutability can only be specified for address types.
+// ParserError 9106: (141-148): State mutability can only be specified for address types.
+// ParserError 9106: (171-178): State mutability can only be specified for address types.
+// ParserError 9106: (200-207): State mutability can only be specified for address types.
+// ParserError 9106: (228-235): State mutability can only be specified for address types.
+// ParserError 9106: (258-265): State mutability can only be specified for address types.
+// ParserError 9106: (286-293): State mutability can only be specified for address types.
+// ParserError 9106: (319-326): State mutability can only be specified for address types.
+// ParserError 9106: (348-355): State mutability can only be specified for address types.
+// ParserError 9106: (382-389): State mutability can only be specified for address types.
+// ParserError 9106: (425-429): State mutability can only be specified for address types.
+// ParserError 9106: (451-455): State mutability can only be specified for address types.
+// ParserError 9106: (474-478): State mutability can only be specified for address types.
+// ParserError 9106: (500-504): State mutability can only be specified for address types.
+// ParserError 9106: (524-528): State mutability can only be specified for address types.
+// ParserError 9106: (551-555): State mutability can only be specified for address types.
+// ParserError 9106: (577-581): State mutability can only be specified for address types.
+// ParserError 9106: (602-606): State mutability can only be specified for address types.
+// ParserError 9106: (629-633): State mutability can only be specified for address types.
+// ParserError 9106: (654-658): State mutability can only be specified for address types.
+// ParserError 9106: (684-688): State mutability can only be specified for address types.
+// ParserError 9106: (710-714): State mutability can only be specified for address types.
+// ParserError 9106: (741-745): State mutability can only be specified for address types.
+// ParserError 9106: (781-785): State mutability can only be specified for address types.
+// ParserError 9106: (807-811): State mutability can only be specified for address types.
+// ParserError 9106: (830-834): State mutability can only be specified for address types.
+// ParserError 9106: (856-860): State mutability can only be specified for address types.
+// ParserError 9106: (880-884): State mutability can only be specified for address types.
+// ParserError 9106: (907-911): State mutability can only be specified for address types.
+// ParserError 9106: (933-937): State mutability can only be specified for address types.
+// ParserError 9106: (958-962): State mutability can only be specified for address types.
+// ParserError 9106: (985-989): State mutability can only be specified for address types.
+// ParserError 9106: (1010-1014): State mutability can only be specified for address types.
+// ParserError 9106: (1040-1044): State mutability can only be specified for address types.
+// ParserError 9106: (1066-1070): State mutability can only be specified for address types.
+// ParserError 9106: (1097-1101): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/error_as_function_param.sol b/compiler/test/libsolidity/syntaxTests/errors/error_as_function_param.sol
new file mode 100644
index 00000000..79f28a00
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/error_as_function_param.sol
@@ -0,0 +1,4 @@
+error E(uint);
+function f(E x) pure returns (uint) {}
+// ----
+// TypeError 5172: (26-27): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_binary_ops.sol b/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_binary_ops.sol
new file mode 100644
index 00000000..3a54c1c1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_binary_ops.sol
@@ -0,0 +1,47 @@
+error MyCustomError(uint, bool);
+
+contract C {
+    function f() pure public {
+        MyCustomError << MyCustomError;
+        MyCustomError >> MyCustomError;
+        MyCustomError ^ MyCustomError;
+        MyCustomError | MyCustomError;
+        MyCustomError & MyCustomError;
+
+        MyCustomError * MyCustomError;
+        MyCustomError / MyCustomError;
+        MyCustomError % MyCustomError;
+        MyCustomError + MyCustomError;
+        MyCustomError - MyCustomError;
+
+        MyCustomError == MyCustomError;
+        MyCustomError != MyCustomError;
+        MyCustomError >= MyCustomError;
+        MyCustomError <= MyCustomError;
+        MyCustomError < MyCustomError;
+        MyCustomError > MyCustomError;
+
+        MyCustomError || MyCustomError;
+        MyCustomError && MyCustomError;
+    }
+}
+
+// ----
+// TypeError 2271: (86-116): Built-in binary operator << cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (126-156): Built-in binary operator >> cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (166-195): Built-in binary operator ^ cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (205-234): Built-in binary operator | cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (244-273): Built-in binary operator & cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (284-313): Built-in binary operator * cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (323-352): Built-in binary operator / cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (362-391): Built-in binary operator % cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (401-430): Built-in binary operator + cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (440-469): Built-in binary operator - cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (480-510): Built-in binary operator == cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (520-550): Built-in binary operator != cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (560-590): Built-in binary operator >= cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (600-630): Built-in binary operator <= cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (640-669): Built-in binary operator < cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (679-708): Built-in binary operator > cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (719-749): Built-in binary operator || cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
+// TypeError 2271: (759-789): Built-in binary operator && cannot be applied to types error MyCustomError(uint256,bool) and error MyCustomError(uint256,bool).
diff --git a/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_unary_operator.sol b/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_unary_operator.sol
new file mode 100644
index 00000000..147d2a3e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/error_incompatible_unary_operator.sol
@@ -0,0 +1,11 @@
+error MyCustomError(uint, bool);
+
+contract C {
+    function f() pure public {
+        MyCustomError++;
+    }
+}
+
+// ----
+// TypeError 4247: (86-99): Expression has to be an lvalue.
+// TypeError 9767: (86-101): Built-in unary operator ++ cannot be applied to type error MyCustomError(uint256,bool).
diff --git a/compiler/test/libsolidity/syntaxTests/errors/error_ternary_operator.sol b/compiler/test/libsolidity/syntaxTests/errors/error_ternary_operator.sol
new file mode 100644
index 00000000..c4600a85
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/error_ternary_operator.sol
@@ -0,0 +1,11 @@
+error MyCustomError(uint, bool);
+
+contract C {
+    function f() pure public {
+        true ? MyCustomError : MyCustomError;
+    }
+}
+
+// ----
+// TypeError 9717: (93-106): Invalid mobile type in true expression.
+// TypeError 3703: (109-122): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/error_to_function_conversion.sol b/compiler/test/libsolidity/syntaxTests/errors/error_to_function_conversion.sol
new file mode 100644
index 00000000..6b2350cd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/error_to_function_conversion.sol
@@ -0,0 +1,7 @@
+error E();
+
+contract C {
+    function() internal pure x = E;
+}
+// ----
+// TypeError 7407: (58-59): Type error E() is not implicitly convertible to expected type function () pure. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_indexed.sol b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_indexed.sol
new file mode 100644
index 00000000..99b629cd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_indexed.sol
@@ -0,0 +1,5 @@
+contract C {
+    error e1(uint indexed x);
+}
+// ----
+// ParserError 2314: (31-38): Expected ',' but got 'indexed'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_location.sol b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_location.sol
new file mode 100644
index 00000000..a116188d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_location.sol
@@ -0,0 +1,16 @@
+==== Source: A ====
+contract test {
+    error e1(string storage a);
+}
+==== Source: B ====
+contract test {
+    error e1(string memory a);
+}
+==== Source: C ====
+contract test {
+    error e1(string calldata a);
+}
+// ----
+// ParserError 2314: (A:36-43): Expected ',' but got 'storage'
+// ParserError 2314: (B:36-42): Expected ',' but got 'memory'
+// ParserError 2314: (C:36-44): Expected ',' but got 'calldata'
diff --git a/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_mutability.sol b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_mutability.sol
new file mode 100644
index 00000000..fc5b4609
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_mutability.sol
@@ -0,0 +1,7 @@
+contract C {
+    error e1(uint constant x);
+    error e2(uint immutable x);
+}
+// ----
+// DeclarationError 1788: (26-41): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 8297: (57-73): The "immutable" keyword can only be used for state variables.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_visibility.sol b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_visibility.sol
new file mode 100644
index 00000000..c35e759d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/invalid_parameter_visibility.sol
@@ -0,0 +1,21 @@
+==== Source: A ====
+contract C {
+    error e1(uint external x);
+}
+==== Source: B ====
+contract C {
+    error e1(uint internal x);
+}
+==== Source: C ====
+contract C {
+    error e1(uint public x);
+}
+==== Source: D ====
+contract C {
+    error e1(uint private x);
+}
+// ----
+// ParserError 2314: (A:31-39): Expected ',' but got 'external'
+// ParserError 2314: (B:31-39): Expected ',' but got 'internal'
+// ParserError 2314: (C:31-37): Expected ',' but got 'public'
+// ParserError 2314: (D:31-38): Expected ',' but got 'private'
diff --git a/compiler/test/libsolidity/syntaxTests/errors/using_2.sol b/compiler/test/libsolidity/syntaxTests/errors/using_2.sol
new file mode 100644
index 00000000..6942513a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/using_2.sol
@@ -0,0 +1,12 @@
+error E(uint);
+library L {
+    function f(uint) internal {}
+}
+contract C {
+    using L for E;
+    function f() public pure {
+        E.f();
+    }
+}
+// ----
+// TypeError 5172: (91-92): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/weird3.sol b/compiler/test/libsolidity/syntaxTests/errors/weird3.sol
new file mode 100644
index 00000000..a059339c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/weird3.sol
@@ -0,0 +1,7 @@
+error E();
+
+contract C {
+    E x;
+}
+// ----
+// TypeError 5172: (29-30): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/errors/weird4.sol b/compiler/test/libsolidity/syntaxTests/errors/weird4.sol
new file mode 100644
index 00000000..c4fff374
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/errors/weird4.sol
@@ -0,0 +1,9 @@
+error E();
+
+contract C {
+    function f() public pure {
+        E x;
+    }
+}
+// ----
+// TypeError 5172: (64-65): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/events/anonymous_event_multiple_anonymous_specifiers.sol b/compiler/test/libsolidity/syntaxTests/events/anonymous_event_multiple_anonymous_specifiers.sol
new file mode 100644
index 00000000..fd3e317b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/anonymous_event_multiple_anonymous_specifiers.sol
@@ -0,0 +1,5 @@
+contract c {
+    event e(uint a) anonymous anonymous;
+}
+// ----
+// ParserError 2314: (43-52): Expected ';' but got 'anonymous'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/events/elementary_non_address_state_mutability_event_argument.sol b/compiler/test/libsolidity/syntaxTests/events/elementary_non_address_state_mutability_event_argument.sol
new file mode 100644
index 00000000..a3e08411
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/elementary_non_address_state_mutability_event_argument.sol
@@ -0,0 +1,85 @@
+contract C {
+    event a(bool payable);
+    event b(string payable);
+    event c(int payable);
+    event d(int256 payable);
+    event e(uint payable);
+    event f(uint256 payable);
+    event g(bytes1 payable);
+    event h(bytes payable);
+    event i(bytes32 payable);
+    event j(fixed payable);
+    event k(fixed80x80 payable);
+    event l(ufixed payable);
+    event m(ufixed80x80 payable);
+}
+contract C2 {
+    event a(bool view);
+    event b(string view);
+    event c(int view);
+    event d(int256 view);
+    event e(uint view);
+    event f(uint256 view);
+    event g(bytes1 view);
+    event h(bytes view);
+    event i(bytes32 view);
+    event j(fixed view);
+    event k(fixed80x80 view);
+    event l(ufixed view);
+    event m(ufixed80x80 view);
+}
+contract C3 {
+    event a(bool pure);
+    event b(string pure);
+    event c(int pure);
+    event d(int256 pure);
+    event e(uint pure);
+    event f(uint256 pure);
+    event g(bytes1 pure);
+    event h(bytes pure);
+    event i(bytes32 pure);
+    event j(fixed pure);
+    event k(fixed80x80 pure);
+    event l(ufixed pure);
+    event m(ufixed80x80 pure);
+}
+// ----
+// ParserError 9106: (30-37): State mutability can only be specified for address types.
+// ParserError 9106: (59-66): State mutability can only be specified for address types.
+// ParserError 9106: (85-92): State mutability can only be specified for address types.
+// ParserError 9106: (114-121): State mutability can only be specified for address types.
+// ParserError 9106: (141-148): State mutability can only be specified for address types.
+// ParserError 9106: (171-178): State mutability can only be specified for address types.
+// ParserError 9106: (200-207): State mutability can only be specified for address types.
+// ParserError 9106: (228-235): State mutability can only be specified for address types.
+// ParserError 9106: (258-265): State mutability can only be specified for address types.
+// ParserError 9106: (286-293): State mutability can only be specified for address types.
+// ParserError 9106: (319-326): State mutability can only be specified for address types.
+// ParserError 9106: (348-355): State mutability can only be specified for address types.
+// ParserError 9106: (382-389): State mutability can only be specified for address types.
+// ParserError 9106: (425-429): State mutability can only be specified for address types.
+// ParserError 9106: (451-455): State mutability can only be specified for address types.
+// ParserError 9106: (474-478): State mutability can only be specified for address types.
+// ParserError 9106: (500-504): State mutability can only be specified for address types.
+// ParserError 9106: (524-528): State mutability can only be specified for address types.
+// ParserError 9106: (551-555): State mutability can only be specified for address types.
+// ParserError 9106: (577-581): State mutability can only be specified for address types.
+// ParserError 9106: (602-606): State mutability can only be specified for address types.
+// ParserError 9106: (629-633): State mutability can only be specified for address types.
+// ParserError 9106: (654-658): State mutability can only be specified for address types.
+// ParserError 9106: (684-688): State mutability can only be specified for address types.
+// ParserError 9106: (710-714): State mutability can only be specified for address types.
+// ParserError 9106: (741-745): State mutability can only be specified for address types.
+// ParserError 9106: (781-785): State mutability can only be specified for address types.
+// ParserError 9106: (807-811): State mutability can only be specified for address types.
+// ParserError 9106: (830-834): State mutability can only be specified for address types.
+// ParserError 9106: (856-860): State mutability can only be specified for address types.
+// ParserError 9106: (880-884): State mutability can only be specified for address types.
+// ParserError 9106: (907-911): State mutability can only be specified for address types.
+// ParserError 9106: (933-937): State mutability can only be specified for address types.
+// ParserError 9106: (958-962): State mutability can only be specified for address types.
+// ParserError 9106: (985-989): State mutability can only be specified for address types.
+// ParserError 9106: (1010-1014): State mutability can only be specified for address types.
+// ParserError 9106: (1040-1044): State mutability can only be specified for address types.
+// ParserError 9106: (1066-1070): State mutability can only be specified for address types.
+// ParserError 9106: (1097-1101): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_emit_qualified_file_level.sol b/compiler/test/libsolidity/syntaxTests/events/event_emit_qualified_file_level.sol
new file mode 100644
index 00000000..6d1cc65d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_emit_qualified_file_level.sol
@@ -0,0 +1,8 @@
+==== Source: M.sol ====
+event E();
+==== Source: A.sol ====
+import "M.sol" as M;
+
+function f() {
+    emit M.E();
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_emit_simple_file_level.sol b/compiler/test/libsolidity/syntaxTests/events/event_emit_simple_file_level.sol
new file mode 100644
index 00000000..46fda33b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_emit_simple_file_level.sol
@@ -0,0 +1,7 @@
+event E();
+
+contract C {
+    function f() public {
+        emit E();
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_incompatible_binary_ops.sol b/compiler/test/libsolidity/syntaxTests/events/event_incompatible_binary_ops.sol
new file mode 100644
index 00000000..bf04c6a3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_incompatible_binary_ops.sol
@@ -0,0 +1,46 @@
+contract C {
+    event MyCustomEvent(uint);
+    function f() pure public {
+        MyCustomEvent << MyCustomEvent;
+        MyCustomEvent >> MyCustomEvent;
+        MyCustomEvent ^ MyCustomEvent;
+        MyCustomEvent | MyCustomEvent;
+        MyCustomEvent & MyCustomEvent;
+
+        MyCustomEvent * MyCustomEvent;
+        MyCustomEvent / MyCustomEvent;
+        MyCustomEvent % MyCustomEvent;
+        MyCustomEvent + MyCustomEvent;
+        MyCustomEvent - MyCustomEvent;
+
+        MyCustomEvent == MyCustomEvent;
+        MyCustomEvent != MyCustomEvent;
+        MyCustomEvent >= MyCustomEvent;
+        MyCustomEvent <= MyCustomEvent;
+        MyCustomEvent < MyCustomEvent;
+        MyCustomEvent > MyCustomEvent;
+
+        MyCustomEvent || MyCustomEvent;
+        MyCustomEvent && MyCustomEvent;
+    }
+}
+
+// ----
+// TypeError 2271: (83-113): Built-in binary operator << cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (123-153): Built-in binary operator >> cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (163-192): Built-in binary operator ^ cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (202-231): Built-in binary operator | cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (241-270): Built-in binary operator & cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (281-310): Built-in binary operator * cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (320-349): Built-in binary operator / cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (359-388): Built-in binary operator % cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (398-427): Built-in binary operator + cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (437-466): Built-in binary operator - cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (477-507): Built-in binary operator == cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (517-547): Built-in binary operator != cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (557-587): Built-in binary operator >= cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (597-627): Built-in binary operator <= cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (637-666): Built-in binary operator < cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (676-705): Built-in binary operator > cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (716-746): Built-in binary operator || cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
+// TypeError 2271: (756-786): Built-in binary operator && cannot be applied to types event MyCustomEvent(uint256) and event MyCustomEvent(uint256).
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_incompatible_unary_operator.sol b/compiler/test/libsolidity/syntaxTests/events/event_incompatible_unary_operator.sol
new file mode 100644
index 00000000..751be213
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_incompatible_unary_operator.sol
@@ -0,0 +1,10 @@
+contract C {
+    event MyCustomEvent(uint);
+    function f() pure public {
+        MyCustomEvent++;
+    }
+}
+
+// ----
+// TypeError 4247: (83-96): Expression has to be an lvalue.
+// TypeError 9767: (83-98): Built-in unary operator ++ cannot be applied to type event MyCustomEvent(uint256).
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_library_function.sol b/compiler/test/libsolidity/syntaxTests/events/event_library_function.sol
new file mode 100644
index 00000000..7a1b793f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_library_function.sol
@@ -0,0 +1,35 @@
+library L {
+	function f() public {
+		int x = 1;
+	}
+}
+
+contract C {
+	event Test(function() external indexed);
+
+	function g() public {
+		Test(L.f);
+	}
+}
+
+contract D {
+	event Test(function() external);
+
+	function f() public {
+		Test(L.f);
+	}
+}
+
+contract E {
+	event Test(function() external indexed);
+
+	using L for D;
+
+	function k() public {
+		Test(D.f);
+	}
+}
+// ----
+// TypeError 9553: (140-143): Invalid type for argument in function call. Invalid implicit conversion from function () to function () external requested. Special functions cannot be converted to function types.
+// TypeError 9553: (230-233): Invalid type for argument in function call. Invalid implicit conversion from function () to function () external requested. Special functions cannot be converted to function types.
+// TypeError 9553: (345-348): Invalid type for argument in function call. Invalid implicit conversion from function D.f() to function () external requested. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_multiple_indexed_of_one_parameter.sol b/compiler/test/libsolidity/syntaxTests/events/event_multiple_indexed_of_one_parameter.sol
new file mode 100644
index 00000000..dd6edd82
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_multiple_indexed_of_one_parameter.sol
@@ -0,0 +1,9 @@
+contract c {
+    event e(uint indexed a, bytes3 indexed indexed s, bool indexed indexed indexed b);
+    event e2(uint indexed indexed a, bytes3 indexed s);
+}
+// ----
+// ParserError 5399: (56-63): Indexed already specified.
+// ParserError 5399: (80-87): Indexed already specified.
+// ParserError 5399: (88-95): Indexed already specified.
+// ParserError 5399: (126-133): Indexed already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_selector_access_file_level.sol b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_file_level.sol
new file mode 100644
index 00000000..1131e00b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_file_level.sol
@@ -0,0 +1,7 @@
+event E();
+
+contract C {
+    function f() external pure returns (bytes32) {
+        return E.selector;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_selector_access_foreign_contract.sol b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_foreign_contract.sol
new file mode 100644
index 00000000..ccc2b199
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_foreign_contract.sol
@@ -0,0 +1,10 @@
+contract D {
+    event E();
+}
+
+contract C {
+    function f() external pure returns (bytes32) {
+        return D.E.selector;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_selector_access_interface.sol b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_interface.sol
new file mode 100644
index 00000000..2b4cd4e9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_selector_access_interface.sol
@@ -0,0 +1,10 @@
+interface I {
+    event E();
+}
+
+contract C {
+    function f() external pure returns (bytes32) {
+        return I.E.selector;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_selector_syntax.sol b/compiler/test/libsolidity/syntaxTests/events/event_selector_syntax.sol
new file mode 100644
index 00000000..fec21b55
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_selector_syntax.sol
@@ -0,0 +1,35 @@
+library L {
+    event E(bytes32, bool, bytes indexed);
+}
+
+interface I {
+    event E(bytes32, bool, bytes indexed);
+}
+
+contract A {
+    event E(bytes32, bool, bytes indexed);
+}
+
+contract B {
+    event E(bytes32, bool, bytes indexed);
+}
+
+contract C is B {
+    bytes32 public librarySelector = L.E.selector;
+    bytes32 public interfaceSelector = I.E.selector;
+    bytes32 public foreignContractSelector = A.E.selector;
+    bytes32 inheritedSelector = E.selector;
+
+    function f() public {
+        assert(librarySelector == L.E.selector);
+        assert(interfaceSelector == I.E.selector);
+        assert(foreignContractSelector == A.E.selector);
+        assert(E.selector == B.E.selector);
+
+        emit E(E.selector, true, "123");
+        emit I.E((B.E.selector), true, "123");
+        emit A.E((B.E.selector), true, "123");
+        emit L.E((B.E.selector), true, "123");
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_ternary_operator.sol b/compiler/test/libsolidity/syntaxTests/events/event_ternary_operator.sol
new file mode 100644
index 00000000..0ba77324
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_ternary_operator.sol
@@ -0,0 +1,10 @@
+contract C {
+    event MyCustomEvent(uint);
+    function f() pure public {
+        true ? MyCustomEvent : MyCustomEvent;
+    }
+}
+
+// ----
+// TypeError 9717: (90-103): Invalid mobile type in true expression.
+// TypeError 3703: (106-119): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/events/event_to_function_conversion.sol b/compiler/test/libsolidity/syntaxTests/events/event_to_function_conversion.sol
new file mode 100644
index 00000000..76d0edc7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/event_to_function_conversion.sol
@@ -0,0 +1,7 @@
+
+contract C {
+    event E(uint);
+    function() internal pure x = E;
+}
+// ----
+// TypeError 7407: (66-67): Type event E(uint256) is not implicitly convertible to expected type function () pure. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event.sol
new file mode 100644
index 00000000..33d4378f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event.sol
@@ -0,0 +1,11 @@
+event E1();
+event E2(uint);
+event E3(uint, string indexed, bytes, bool);
+event E4(int, int, int) anonymous;
+
+function f() {
+    emit E1();
+    emit E2(1);
+    emit E3(1, "abc", "abc", true);
+    emit E4(1, 2, 3);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition.sol
new file mode 100644
index 00000000..30d3594e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition.sol
@@ -0,0 +1,4 @@
+event E();
+event E();
+// ----
+// DeclarationError 5883: (0-10): Event with same name and parameter types defined twice.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition_via_import.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition_via_import.sol
new file mode 100644
index 00000000..0cd9c8c2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_duplicate_definition_via_import.sol
@@ -0,0 +1,8 @@
+==== Source: A.sol ====
+event E();
+==== Source: B.sol ====
+import "A.sol";
+
+event E();
+// ----
+// DeclarationError 5883: (B.sol:17-27): Event with same name and parameter types defined twice.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_import.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_import.sol
new file mode 100644
index 00000000..c2591a18
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_import.sol
@@ -0,0 +1,12 @@
+==== Source: A.sol ====
+event EA();
+==== Source: B.sol ====
+event EB();
+==== Source: C.sol ====
+import "A.sol";
+import {EB} from "B.sol";
+
+function f() {
+    emit EA();
+    emit EB();
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading.sol
new file mode 100644
index 00000000..1f4ac338
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading.sol
@@ -0,0 +1,11 @@
+event E();
+event E(uint);
+event E(uint, string indexed, bytes, bool);
+event E(int, int, int) anonymous;
+
+function f() {
+    emit E();
+    emit E(1);
+    emit E(1, "abc", "abc", true);
+    emit E(1, 2, 3);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading_vs_shadowing.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading_vs_shadowing.sol
new file mode 100644
index 00000000..f6268b28
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_overloading_vs_shadowing.sol
@@ -0,0 +1,13 @@
+event E();
+
+contract C {
+    event E(uint);
+
+    function f() public {
+        emit E();
+        emit E(1);
+    }
+}
+// ----
+// Warning 2519: (29-43): This declaration shadows an existing declaration.
+// TypeError 6160: (84-87): Wrong argument count for function call: 0 arguments given but expected 1.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract.sol
new file mode 100644
index 00000000..1408e543
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract.sol
@@ -0,0 +1,17 @@
+event E();
+
+contract C {
+    event E();
+}
+
+library L {
+    event E();
+}
+
+interface I {
+    event E();
+}
+// ----
+// Warning 2519: (29-39): This declaration shadows an existing declaration.
+// Warning 2519: (59-69): This declaration shadows an existing declaration.
+// Warning 2519: (91-101): This declaration shadows an existing declaration.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract_adds_anonymous.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract_adds_anonymous.sol
new file mode 100644
index 00000000..1b95ac7d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowed_inside_contract_adds_anonymous.sol
@@ -0,0 +1,17 @@
+event E();
+
+contract C {
+    event E() anonymous;
+}
+
+library L {
+    event E() anonymous;
+}
+
+interface I {
+    event E() anonymous;
+}
+// ----
+// Warning 2519: (29-49): This declaration shadows an existing declaration.
+// Warning 2519: (69-89): This declaration shadows an existing declaration.
+// Warning 2519: (111-131): This declaration shadows an existing declaration.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_contract.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_contract.sol
new file mode 100644
index 00000000..1ebe600e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_contract.sol
@@ -0,0 +1,4 @@
+event E();
+contract E {}
+// ----
+// DeclarationError 2333: (11-24): Identifier already declared.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_error.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_error.sol
new file mode 100644
index 00000000..c6ba8e9c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_shadowing_error.sol
@@ -0,0 +1,4 @@
+event E();
+error E();
+// ----
+// DeclarationError 2333: (11-21): Identifier already declared.
diff --git a/compiler/test/libsolidity/syntaxTests/events/file_level_event_using.sol b/compiler/test/libsolidity/syntaxTests/events/file_level_event_using.sol
new file mode 100644
index 00000000..99827d0b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/file_level_event_using.sol
@@ -0,0 +1,6 @@
+event E();
+
+type T is uint;
+using {E} for T;
+// ----
+// TypeError 8187: (35-36): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/events/illegal_names_exception_file_level.sol b/compiler/test/libsolidity/syntaxTests/events/illegal_names_exception_file_level.sol
new file mode 100644
index 00000000..48b23dc3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/illegal_names_exception_file_level.sol
@@ -0,0 +1,4 @@
+// Exception for the illegal name list. External interface events
+event this();
+event super();
+event _();
diff --git a/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_location.sol b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_location.sol
new file mode 100644
index 00000000..04ee9b7b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_location.sol
@@ -0,0 +1,16 @@
+==== Source: A ====
+contract test {
+    event e1(string storage a);
+}
+==== Source: B ====
+contract test {
+    event e1(string memory a);
+}
+==== Source: C ====
+contract test {
+    event e1(string calldata a);
+}
+// ----
+// ParserError 2314: (A:36-43): Expected ',' but got 'storage'
+// ParserError 2314: (B:36-42): Expected ',' but got 'memory'
+// ParserError 2314: (C:36-44): Expected ',' but got 'calldata'
diff --git a/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_mutability.sol b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_mutability.sol
new file mode 100644
index 00000000..f7314e6f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_mutability.sol
@@ -0,0 +1,7 @@
+contract test {
+    event e1(uint constant a);
+    event e2(uint immutable a);
+}
+// ----
+// DeclarationError 1788: (29-44): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 8297: (60-76): The "immutable" keyword can only be used for state variables.
diff --git a/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_visibility.sol b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_visibility.sol
new file mode 100644
index 00000000..bcb6d430
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/events/invalid_parameter_visibility.sol
@@ -0,0 +1,21 @@
+==== Source: A ====
+contract test {
+    event e1(uint external a);
+}
+==== Source: B ====
+contract test {
+    event e1(uint internal a);
+}
+==== Source: C ====
+contract test {
+    event e1(uint public a);
+}
+==== Source: D ====
+contract test {
+    event e1(uint private a);
+}
+// ----
+// ParserError 2314: (A:34-42): Expected ',' but got 'external'
+// ParserError 2314: (B:34-42): Expected ',' but got 'internal'
+// ParserError 2314: (C:34-40): Expected ',' but got 'public'
+// ParserError 2314: (D:34-41): Expected ',' but got 'private'
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol
new file mode 100644
index 00000000..fc4783ce
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition.sol
@@ -0,0 +1,92 @@
+pragma experimental solidity;
+
+type void = __builtin("void");
+
+type bool = __builtin("bool");
+type word = __builtin("word");
+type integer = __builtin("integer");
+type unit = __builtin("unit");
+
+type fun(T, U) = __builtin("fun");
+type pair(T, U) = __builtin("pair");
+
+contract C {
+    fallback() external {
+        let v: void;
+
+        let b: bool;
+        bool.abs(bool.rep(b));
+
+        let w: word;
+        let i: integer;
+        let u: unit;
+
+        let f: fun(word, bool);
+        b = f(w);
+
+        let p: pair(bool, word);
+        pair.first(p);
+        pair.second(p);
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// UnimplementedFeatureError: No support for calling functions pointers yet.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (31-61): Inferred type: void
+// Info 4164: (63-93): Inferred type: bool
+// Info 4164: (94-124): Inferred type: word
+// Info 4164: (125-161): Inferred type: integer
+// Info 4164: (162-192): Inferred type: ()
+// Info 4164: (194-228): Inferred type: tfun(('u:type, 'v:type), 'u:type -> 'v:type)
+// Info 4164: (202-208): Inferred type: ('s:type, 't:type)
+// Info 4164: (203-204): Inferred type: 's:type
+// Info 4164: (206-207): Inferred type: 't:type
+// Info 4164: (229-265): Inferred type: tfun(('y:type, 'z:type), ('y:type, 'z:type))
+// Info 4164: (238-244): Inferred type: ('w:type, 'x:type)
+// Info 4164: (239-240): Inferred type: 'w:type
+// Info 4164: (242-243): Inferred type: 'x:type
+// Info 4164: (284-584): Inferred type: () -> ()
+// Info 4164: (292-294): Inferred type: ()
+// Info 4164: (318-325): Inferred type: void
+// Info 4164: (321-325): Inferred type: void
+// Info 4164: (340-347): Inferred type: bool
+// Info 4164: (343-347): Inferred type: bool
+// Info 4164: (357-378): Inferred type: bool
+// Info 4164: (357-365): Inferred type: word -> bool
+// Info 4164: (357-361): Inferred type: bool
+// Info 4164: (366-377): Inferred type: word
+// Info 4164: (366-374): Inferred type: bool -> word
+// Info 4164: (366-370): Inferred type: bool
+// Info 4164: (375-376): Inferred type: bool
+// Info 4164: (393-400): Inferred type: word
+// Info 4164: (396-400): Inferred type: word
+// Info 4164: (414-424): Inferred type: integer
+// Info 4164: (417-424): Inferred type: integer
+// Info 4164: (438-445): Inferred type: ()
+// Info 4164: (441-445): Inferred type: ()
+// Info 4164: (460-478): Inferred type: word -> bool
+// Info 4164: (463-478): Inferred type: word -> bool
+// Info 4164: (463-466): Inferred type: tfun((word, bool), word -> bool)
+// Info 4164: (467-471): Inferred type: word
+// Info 4164: (473-477): Inferred type: bool
+// Info 4164: (488-496): Inferred type: bool
+// Info 4164: (488-489): Inferred type: bool
+// Info 4164: (492-496): Inferred type: bool
+// Info 4164: (492-493): Inferred type: word -> bool
+// Info 4164: (494-495): Inferred type: word
+// Info 4164: (511-530): Inferred type: (bool, word)
+// Info 4164: (514-530): Inferred type: (bool, word)
+// Info 4164: (514-518): Inferred type: tfun((bool, word), (bool, word))
+// Info 4164: (519-523): Inferred type: bool
+// Info 4164: (525-529): Inferred type: word
+// Info 4164: (540-553): Inferred type: bool
+// Info 4164: (540-550): Inferred type: (bool, word) -> bool
+// Info 4164: (540-544): Inferred type: ('bl:type, 'bm:type)
+// Info 4164: (551-552): Inferred type: (bool, word)
+// Info 4164: (563-577): Inferred type: word
+// Info 4164: (563-574): Inferred type: (bool, word) -> word
+// Info 4164: (563-567): Inferred type: ('bq:type, 'br:type)
+// Info 4164: (575-576): Inferred type: (bool, word)
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_duplicate.sol b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_duplicate.sol
new file mode 100644
index 00000000..28f6c39f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_duplicate.sol
@@ -0,0 +1,17 @@
+pragma experimental solidity;
+
+type void1 = __builtin("void");
+type void2 = __builtin("void");
+
+type word1 = __builtin("word");
+type word2 = __builtin("word");
+
+type fun1(T, U) = __builtin("fun");
+type fun2(T, U) = __builtin("fun");
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 9609: (63-94): Duplicate builtin type definition.
+// TypeError 9609: (128-159): Duplicate builtin type definition.
+// TypeError 9609: (197-232): Duplicate builtin type definition.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_unknown.sol b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_unknown.sol
new file mode 100644
index 00000000..90072f19
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/builtin/builtin_type_definition_unknown.sol
@@ -0,0 +1,8 @@
+pragma experimental solidity;
+
+type someUnknownType = __builtin("someUnknownType");
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 7758: (31-81): Expected the name of a built-in primitive type.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity.sol
new file mode 100644
index 00000000..a84ac0e7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity.sol
@@ -0,0 +1,6 @@
+pragma experimental solidity;
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_multisource_not_all_enable.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_multisource_not_all_enable.sol
new file mode 100644
index 00000000..fe4125e8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_multisource_not_all_enable.sol
@@ -0,0 +1,26 @@
+==== Source: A.sol ====
+contract A {}
+==== Source: B.sol ====
+pragma experimental solidity;
+import "A.sol";
+contract B {
+    A a;
+}
+==== Source: C.sol ====
+pragma experimental solidity;
+import "A.sol";
+contract C {
+    A a;
+}
+==== Source: D.sol ====
+pragma experimental solidity;
+import "A.sol";
+contract D {
+    A a;
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// ParserError 2141: (B.sol:0-29): File declares "pragma experimental solidity". If you want to enable the experimental mode, all source units must include the pragma.
+// ParserError 2141: (C.sol:0-29): File declares "pragma experimental solidity". If you want to enable the experimental mode, all source units must include the pragma.
+// ParserError 2141: (D.sol:0-29): File declares "pragma experimental solidity". If you want to enable the experimental mode, all source units must include the pragma.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_1.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_1.sol
new file mode 100644
index 00000000..d6741b0d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_1.sol
@@ -0,0 +1,7 @@
+contract A {}
+
+pragma experimental solidity;
+// ====
+// EVMVersion: >=constantinople
+// ----
+// ParserError 8185: (45-45): Experimental pragma "solidity" can only be set at the beginning of the source unit.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_2.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_2.sol
new file mode 100644
index 00000000..940bd3fb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_out_of_order_2.sol
@@ -0,0 +1,15 @@
+function f() pure returns (uint)
+{
+    return 1;
+}
+
+pragma experimental solidity;
+
+struct A
+{
+    uint256 x;
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// ParserError 8185: (83-89): Experimental pragma "solidity" can only be set at the beginning of the source unit.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_wrong_evm_version.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_wrong_evm_version.sol
new file mode 100644
index 00000000..3e070535
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/experimental_solidity_wrong_evm_version.sol
@@ -0,0 +1,8 @@
+pragma experimental solidity;
+
+contract C {}
+
+// ====
+// EVMVersion: <constantinople
+// ----
+// ParserError 7637: (31-39): Experimental solidity requires Constantinople EVM version at the minimum.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_1.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_1.sol
new file mode 100644
index 00000000..5628a588
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_1.sol
@@ -0,0 +1,11 @@
+pragma experimental solidity;
+
+import std.stub;
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (std.stub:63-92): Experimental features are turned on. Do not use experimental features on live deployments.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (std.stub:94-117): Inferred type: () -> ()
+// Info 4164: (std.stub:111-113): Inferred type: ()
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_2.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_2.sol
new file mode 100644
index 00000000..bdc66e4a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_2.sol
@@ -0,0 +1,11 @@
+pragma experimental solidity;
+
+import std.stub as stub;
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (std.stub:63-92): Experimental features are turned on. Do not use experimental features on live deployments.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (std.stub:94-117): Inferred type: () -> ()
+// Info 4164: (std.stub:111-113): Inferred type: ()
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_3.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_3.sol
new file mode 100644
index 00000000..1bb34053
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_3.sol
@@ -0,0 +1,12 @@
+pragma experimental solidity;
+
+import { identity } from std.stub;
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (std.stub:63-92): Experimental features are turned on. Do not use experimental features on live deployments.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (std.stub:94-117): Inferred type: () -> ()
+// Info 4164: (std.stub:111-113): Inferred type: ()
+// Info 4164: (40-48): Inferred type: () -> ()
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_4.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_4.sol
new file mode 100644
index 00000000..64a67fe6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_4.sol
@@ -0,0 +1,11 @@
+pragma experimental solidity;
+
+import * as stub from std.stub;
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (std.stub:63-92): Experimental features are turned on. Do not use experimental features on live deployments.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (std.stub:94-117): Inferred type: () -> ()
+// Info 4164: (std.stub:111-113): Inferred type: ()
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_1.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_1.sol
new file mode 100644
index 00000000..0106846f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_1.sol
@@ -0,0 +1,3 @@
+import std.stub;
+// ----
+// ParserError 9478: (7-10): Expected string literal (path), "*" or alias list.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_2.sol b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_2.sol
new file mode 100644
index 00000000..3a6c1848
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/import/parsing_stdlib_import_without_pragma_2.sol
@@ -0,0 +1,3 @@
+import { identity } from std.stub;
+// ----
+// ParserError 6845: (25-28): Expected import path.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/experimental_keywords.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/experimental_keywords.sol
new file mode 100644
index 00000000..b5920aed
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/experimental_keywords.sol
@@ -0,0 +1,4 @@
+function f() pure {
+	uint word; word;
+	uint static_assert; static_assert;
+}
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol
new file mode 100644
index 00000000..fc75e859
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/import_and_call_stdlib_function.sol
@@ -0,0 +1,25 @@
+pragma experimental solidity;
+
+import { identity as id } from std.stub;
+
+contract C
+{
+    fallback() external
+    {
+        id();
+    }
+}
+
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (std.stub:63-92): Experimental features are turned on. Do not use experimental features on live deployments.
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (std.stub:94-117): Inferred type: () -> ()
+// Info 4164: (std.stub:111-113): Inferred type: ()
+// Info 4164: (40-48): Inferred type: () -> ()
+// Info 4164: (90-135): Inferred type: () -> ()
+// Info 4164: (98-100): Inferred type: ()
+// Info 4164: (124-128): Inferred type: ()
+// Info 4164: (124-126): Inferred type: () -> ()
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/invalid_type_referenced.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/invalid_type_referenced.sol
new file mode 100644
index 00000000..ac097bf3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/invalid_type_referenced.sol
@@ -0,0 +1,13 @@
+pragma experimental solidity;
+
+function f() {}
+
+class Self: C
+{
+    function g(self: Self, x: f);
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 2217: (94-95): Attempt to type identifier referring to unexpected node.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/monomorphic_function_call_type_mismatch.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/monomorphic_function_call_type_mismatch.sol
new file mode 100644
index 00000000..e7af573a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/monomorphic_function_call_type_mismatch.sol
@@ -0,0 +1,16 @@
+pragma experimental solidity;
+
+type T;
+type U;
+
+function f(x: T, y: U) {}
+
+function run(a: U, b: T) {
+    f(a, b);
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 8456: (106-113): Cannot unify T and U.
+// TypeError 8456: (106-113): Cannot unify U and T.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call.sol
new file mode 100644
index 00000000..eacc8952
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call.sol
@@ -0,0 +1,53 @@
+pragma experimental solidity;
+
+type T;
+type U(A);
+
+function f(x, y: X, z: U(Y)) {}
+
+function run(a: T, b: U(T), c: U(U(T))) {
+    f(a, a, b);
+    f(b, b, c);
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (31-38): Inferred type: T
+// Info 4164: (39-49): Inferred type: tfun('u:type, U('u:type))
+// Info 4164: (45-48): Inferred type: 't:type
+// Info 4164: (46-47): Inferred type: 't:type
+// Info 4164: (51-82): Inferred type: ('x:type, 'y:type, U('ba:type)) -> ()
+// Info 4164: (61-79): Inferred type: ('x:type, 'y:type, U('ba:type))
+// Info 4164: (62-63): Inferred type: 'x:type
+// Info 4164: (65-69): Inferred type: 'y:type
+// Info 4164: (68-69): Inferred type: 'y:type
+// Info 4164: (71-78): Inferred type: U('ba:type)
+// Info 4164: (74-78): Inferred type: U('ba:type)
+// Info 4164: (74-75): Inferred type: tfun('ba:type, U('ba:type))
+// Info 4164: (76-77): Inferred type: 'ba:type
+// Info 4164: (84-159): Inferred type: (T, U(T), U(U(T))) -> ()
+// Info 4164: (96-123): Inferred type: (T, U(T), U(U(T)))
+// Info 4164: (97-101): Inferred type: T
+// Info 4164: (100-101): Inferred type: T
+// Info 4164: (103-110): Inferred type: U(T)
+// Info 4164: (106-110): Inferred type: U(T)
+// Info 4164: (106-107): Inferred type: tfun(T, U(T))
+// Info 4164: (108-109): Inferred type: T
+// Info 4164: (112-122): Inferred type: U(U(T))
+// Info 4164: (115-122): Inferred type: U(U(T))
+// Info 4164: (115-116): Inferred type: tfun(U(T), U(U(T)))
+// Info 4164: (117-121): Inferred type: U(T)
+// Info 4164: (117-118): Inferred type: tfun(T, U(T))
+// Info 4164: (119-120): Inferred type: T
+// Info 4164: (130-140): Inferred type: ()
+// Info 4164: (130-131): Inferred type: (T, T, U(T)) -> ()
+// Info 4164: (132-133): Inferred type: T
+// Info 4164: (135-136): Inferred type: T
+// Info 4164: (138-139): Inferred type: U(T)
+// Info 4164: (146-156): Inferred type: ()
+// Info 4164: (146-147): Inferred type: (U(T), U(T), U(U(T))) -> ()
+// Info 4164: (148-149): Inferred type: U(T)
+// Info 4164: (151-152): Inferred type: U(T)
+// Info 4164: (154-155): Inferred type: U(U(T))
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_let_polymorphism.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_let_polymorphism.sol
new file mode 100644
index 00000000..1a43d080
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_let_polymorphism.sol
@@ -0,0 +1,19 @@
+pragma experimental solidity;
+
+type T;
+type U;
+
+function f(x) {}
+
+function run(a: T, b: U) {
+    // NOTE: The type of f is polymorphic but the inferred type of g is not - this would be
+    // let-polymorphism, which we decided not to support.
+    let g = f;
+    g(a);
+    g(b);
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 8456: (272-276): Cannot unify T and U.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_type_mismatch.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_type_mismatch.sol
new file mode 100644
index 00000000..74f102a8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_function_call_type_mismatch.sol
@@ -0,0 +1,16 @@
+pragma experimental solidity;
+
+type T(A);
+type U;
+type V;
+
+function f(x: T(U)) {}
+
+function run(a: T(V)) {
+    f(a);
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// TypeError 8456: (111-115): Cannot unify U and V.
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type.sol
new file mode 100644
index 00000000..b597a5b2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type.sol
@@ -0,0 +1,47 @@
+pragma experimental solidity;
+
+type T(P, Q, R);
+type U;
+type V;
+
+class Self: C {}
+class Self: D {}
+
+function run() {
+    let x: T(U, X, Z: C);
+    let y: T(V, Y, Z: D);
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (31-47): Inferred type: tfun(('ba:type, 'bb:type, 'bc:type), T('ba:type, 'bb:type, 'bc:type))
+// Info 4164: (37-46): Inferred type: ('x:type, 'y:type, 'z:type)
+// Info 4164: (38-39): Inferred type: 'x:type
+// Info 4164: (41-42): Inferred type: 'y:type
+// Info 4164: (44-45): Inferred type: 'z:type
+// Info 4164: (48-55): Inferred type: U
+// Info 4164: (56-63): Inferred type: V
+// Info 4164: (65-81): Inferred type: C
+// Info 4164: (71-75): Inferred type: 'be:(type, C)
+// Info 4164: (82-98): Inferred type: D
+// Info 4164: (88-92): Inferred type: 'bg:(type, D)
+// Info 4164: (100-170): Inferred type: () -> ()
+// Info 4164: (112-114): Inferred type: ()
+// Info 4164: (125-141): Inferred type: T(U, 'bm:type, 'bo:(type, C))
+// Info 4164: (128-141): Inferred type: T(U, 'bm:type, 'bo:(type, C))
+// Info 4164: (128-129): Inferred type: tfun((U, 'bm:type, 'bo:(type, C)), T(U, 'bm:type, 'bo:(type, C)))
+// Info 4164: (130-131): Inferred type: U
+// Info 4164: (133-134): Inferred type: 'bm:type
+// Info 4164: (136-140): Inferred type: 'bo:(type, C)
+// Info 4164: (136-137): Inferred type: 'bo:(type, C)
+// Info 4164: (139-140): Inferred type: 'bo:(type, C)
+// Info 4164: (151-167): Inferred type: T(V, 'bt:type, 'bv:(type, D))
+// Info 4164: (154-167): Inferred type: T(V, 'bt:type, 'bv:(type, D))
+// Info 4164: (154-155): Inferred type: tfun((V, 'bt:type, 'bv:(type, D)), T(V, 'bt:type, 'bv:(type, D)))
+// Info 4164: (156-157): Inferred type: V
+// Info 4164: (159-160): Inferred type: 'bt:type
+// Info 4164: (162-166): Inferred type: 'bv:(type, D)
+// Info 4164: (162-163): Inferred type: 'bv:(type, D)
+// Info 4164: (165-166): Inferred type: 'bv:(type, D)
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_abs_and_rep.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_abs_and_rep.sol
new file mode 100644
index 00000000..89f3f5f1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_abs_and_rep.sol
@@ -0,0 +1,69 @@
+pragma experimental solidity;
+
+type uint;
+type string;
+
+type T(A);
+type U(B) = T(B);
+
+function fun() {
+    let w: U(uint);
+    let v: T(uint);
+    U.rep(w);
+    U.abs(v);
+
+    let s: U(string);
+    let t: T(string);
+    U.rep(s);
+    U.abs(t);
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (31-41): Inferred type: uint
+// Info 4164: (42-54): Inferred type: string
+// Info 4164: (56-66): Inferred type: tfun('v:type, T('v:type))
+// Info 4164: (62-65): Inferred type: 'u:type
+// Info 4164: (63-64): Inferred type: 'u:type
+// Info 4164: (67-84): Inferred type: tfun('x:type, U('x:type))
+// Info 4164: (73-76): Inferred type: 'w:type
+// Info 4164: (74-75): Inferred type: 'w:type
+// Info 4164: (79-83): Inferred type: T('w:type)
+// Info 4164: (79-80): Inferred type: tfun('w:type, T('w:type))
+// Info 4164: (81-82): Inferred type: 'w:type
+// Info 4164: (86-245): Inferred type: () -> ()
+// Info 4164: (98-100): Inferred type: ()
+// Info 4164: (111-121): Inferred type: U(uint)
+// Info 4164: (114-121): Inferred type: U(uint)
+// Info 4164: (114-115): Inferred type: tfun(uint, U(uint))
+// Info 4164: (116-120): Inferred type: uint
+// Info 4164: (131-141): Inferred type: T(uint)
+// Info 4164: (134-141): Inferred type: T(uint)
+// Info 4164: (134-135): Inferred type: tfun(uint, T(uint))
+// Info 4164: (136-140): Inferred type: uint
+// Info 4164: (147-155): Inferred type: T('bi:type)
+// Info 4164: (147-152): Inferred type: U(uint) -> T('bi:type)
+// Info 4164: (147-148): Inferred type: U('bg:type)
+// Info 4164: (153-154): Inferred type: U(uint)
+// Info 4164: (161-169): Inferred type: U('bm:type)
+// Info 4164: (161-166): Inferred type: T(uint) -> U('bm:type)
+// Info 4164: (161-162): Inferred type: U('bk:type)
+// Info 4164: (167-168): Inferred type: T(uint)
+// Info 4164: (180-192): Inferred type: U(string)
+// Info 4164: (183-192): Inferred type: U(string)
+// Info 4164: (183-184): Inferred type: tfun(string, U(string))
+// Info 4164: (185-191): Inferred type: string
+// Info 4164: (202-214): Inferred type: T(string)
+// Info 4164: (205-214): Inferred type: T(string)
+// Info 4164: (205-206): Inferred type: tfun(string, T(string))
+// Info 4164: (207-213): Inferred type: string
+// Info 4164: (220-228): Inferred type: T('bu:type)
+// Info 4164: (220-225): Inferred type: U(string) -> T('bu:type)
+// Info 4164: (220-221): Inferred type: U('bs:type)
+// Info 4164: (226-227): Inferred type: U(string)
+// Info 4164: (234-242): Inferred type: U('by:type)
+// Info 4164: (234-239): Inferred type: T(string) -> U('by:type)
+// Info 4164: (234-235): Inferred type: U('bw:type)
+// Info 4164: (240-241): Inferred type: T(string)
diff --git a/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_instantiation_and_operators.sol b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_instantiation_and_operators.sol
new file mode 100644
index 00000000..25ab330f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/experimental/inference/polymorphic_type_instantiation_and_operators.sol
@@ -0,0 +1,168 @@
+pragma experimental solidity;
+
+type bool = __builtin("bool");
+
+type T(A);
+type int;
+type str;
+
+class Self: C {
+    function foo(a: Self, b: Self) -> Self;
+}
+
+class Self: P1 {}
+class Self: P2 {}
+class Self: P3 {}
+class Self: P4 {}
+
+instantiation int: P1 {}
+instantiation int: P2 {}
+instantiation int: P3 {}
+
+instantiation str: P1 {}
+instantiation str: P2 {}
+instantiation str: P4 {}
+
+instantiation T(A: P1): + {
+    function add(x: T(A), y: T(A)) -> T(A) {}
+}
+
+instantiation T(A: P2): == {
+    function eq(x: T(A), y: T(A)) -> bool {}
+}
+
+instantiation T(A: (P1, P2)): C {
+    function foo(x: T(A), y: T(A)) -> T(A) {}
+}
+
+function fun(a: T(int: P3), b: T(str: P4)) {
+    a + a;
+    b + b;
+
+    a == a;
+    b == b;
+
+    C.foo(a, a);
+    C.foo(b, b);
+}
+// ====
+// EVMVersion: >=constantinople
+// compileViaYul: true
+// ----
+// Warning 2264: (0-29): Experimental features are turned on. Do not use experimental features on live deployments.
+// Info 4164: (31-61): Inferred type: bool
+// Info 4164: (63-73): Inferred type: tfun('z:type, T('z:type))
+// Info 4164: (69-72): Inferred type: 'y:type
+// Info 4164: (70-71): Inferred type: 'y:type
+// Info 4164: (74-83): Inferred type: int
+// Info 4164: (84-93): Inferred type: str
+// Info 4164: (95-156): Inferred type: C
+// Info 4164: (101-105): Inferred type: 'bd:(type, C)
+// Info 4164: (115-154): Inferred type: ('bd:(type, C), 'bd:(type, C)) -> 'bd:(type, C)
+// Info 4164: (127-145): Inferred type: ('bd:(type, C), 'bd:(type, C))
+// Info 4164: (128-135): Inferred type: 'bd:(type, C)
+// Info 4164: (131-135): Inferred type: 'bd:(type, C)
+// Info 4164: (137-144): Inferred type: 'bd:(type, C)
+// Info 4164: (140-144): Inferred type: 'bd:(type, C)
+// Info 4164: (149-153): Inferred type: 'bd:(type, C)
+// Info 4164: (158-175): Inferred type: P1
+// Info 4164: (164-168): Inferred type: 'bg:(type, P1)
+// Info 4164: (176-193): Inferred type: P2
+// Info 4164: (182-186): Inferred type: 'bj:(type, P2)
+// Info 4164: (194-211): Inferred type: P3
+// Info 4164: (200-204): Inferred type: 'bw:(type, P3)
+// Info 4164: (212-229): Inferred type: P4
+// Info 4164: (218-222): Inferred type: 'by:(type, P4)
+// Info 4164: (231-255): Inferred type: void
+// Info 4164: (256-280): Inferred type: void
+// Info 4164: (281-305): Inferred type: void
+// Info 4164: (307-331): Inferred type: void
+// Info 4164: (332-356): Inferred type: void
+// Info 4164: (357-381): Inferred type: void
+// Info 4164: (383-458): Inferred type: void
+// Info 4164: (398-405): Inferred type: 'ca:(type, P1)
+// Info 4164: (399-404): Inferred type: 'ca:(type, P1)
+// Info 4164: (402-404): Inferred type: 'ca:(type, P1)
+// Info 4164: (415-456): Inferred type: (T('ca:(type, P1)), T('ca:(type, P1))) -> T('ca:(type, P1))
+// Info 4164: (427-445): Inferred type: (T('ca:(type, P1)), T('ca:(type, P1)))
+// Info 4164: (428-435): Inferred type: T('ca:(type, P1))
+// Info 4164: (431-435): Inferred type: T('ca:(type, P1))
+// Info 4164: (431-432): Inferred type: tfun('ca:(type, P1), T('ca:(type, P1)))
+// Info 4164: (433-434): Inferred type: 'ca:(type, P1)
+// Info 4164: (437-444): Inferred type: T('ca:(type, P1))
+// Info 4164: (440-444): Inferred type: T('ca:(type, P1))
+// Info 4164: (440-441): Inferred type: tfun('ca:(type, P1), T('ca:(type, P1)))
+// Info 4164: (442-443): Inferred type: 'ca:(type, P1)
+// Info 4164: (449-453): Inferred type: T('ca:(type, P1))
+// Info 4164: (449-450): Inferred type: tfun('ca:(type, P1), T('ca:(type, P1)))
+// Info 4164: (451-452): Inferred type: 'ca:(type, P1)
+// Info 4164: (460-535): Inferred type: void
+// Info 4164: (475-482): Inferred type: 'ck:(type, P2)
+// Info 4164: (476-481): Inferred type: 'ck:(type, P2)
+// Info 4164: (479-481): Inferred type: 'ck:(type, P2)
+// Info 4164: (493-533): Inferred type: (T('ck:(type, P2)), T('ck:(type, P2))) -> bool
+// Info 4164: (504-522): Inferred type: (T('ck:(type, P2)), T('ck:(type, P2)))
+// Info 4164: (505-512): Inferred type: T('ck:(type, P2))
+// Info 4164: (508-512): Inferred type: T('ck:(type, P2))
+// Info 4164: (508-509): Inferred type: tfun('ck:(type, P2), T('ck:(type, P2)))
+// Info 4164: (510-511): Inferred type: 'ck:(type, P2)
+// Info 4164: (514-521): Inferred type: T('ck:(type, P2))
+// Info 4164: (517-521): Inferred type: T('ck:(type, P2))
+// Info 4164: (517-518): Inferred type: tfun('ck:(type, P2), T('ck:(type, P2)))
+// Info 4164: (519-520): Inferred type: 'ck:(type, P2)
+// Info 4164: (526-530): Inferred type: bool
+// Info 4164: (537-618): Inferred type: void
+// Info 4164: (552-565): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (553-564): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (556-564): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (557-559): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (561-563): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (575-616): Inferred type: (T('bm:(type, P1, P2)), T('bm:(type, P1, P2))) -> T('bm:(type, P1, P2))
+// Info 4164: (587-605): Inferred type: (T('bm:(type, P1, P2)), T('bm:(type, P1, P2)))
+// Info 4164: (588-595): Inferred type: T('bm:(type, P1, P2))
+// Info 4164: (591-595): Inferred type: T('bm:(type, P1, P2))
+// Info 4164: (591-592): Inferred type: tfun('bm:(type, P1, P2), T('bm:(type, P1, P2)))
+// Info 4164: (593-594): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (597-604): Inferred type: T('bm:(type, P1, P2))
+// Info 4164: (600-604): Inferred type: T('bm:(type, P1, P2))
+// Info 4164: (600-601): Inferred type: tfun('bm:(type, P1, P2), T('bm:(type, P1, P2)))
+// Info 4164: (602-603): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (609-613): Inferred type: T('bm:(type, P1, P2))
+// Info 4164: (609-610): Inferred type: tfun('bm:(type, P1, P2), T('bm:(type, P1, P2)))
+// Info 4164: (611-612): Inferred type: 'bm:(type, P1, P2)
+// Info 4164: (620-748): Inferred type: (T(int), T(str)) -> ()
+// Info 4164: (632-662): Inferred type: (T(int), T(str))
+// Info 4164: (633-646): Inferred type: T(int)
+// Info 4164: (636-646): Inferred type: T(int)
+// Info 4164: (636-637): Inferred type: tfun(int, T(int))
+// Info 4164: (638-645): Inferred type: int
+// Info 4164: (638-641): Inferred type: int
+// Info 4164: (643-645): Inferred type: int
+// Info 4164: (648-661): Inferred type: T(str)
+// Info 4164: (651-661): Inferred type: T(str)
+// Info 4164: (651-652): Inferred type: tfun(str, T(str))
+// Info 4164: (653-660): Inferred type: str
+// Info 4164: (653-656): Inferred type: str
+// Info 4164: (658-660): Inferred type: str
+// Info 4164: (669-674): Inferred type: T(int)
+// Info 4164: (669-670): Inferred type: T(int)
+// Info 4164: (673-674): Inferred type: T(int)
+// Info 4164: (680-685): Inferred type: T(str)
+// Info 4164: (680-681): Inferred type: T(str)
+// Info 4164: (684-685): Inferred type: T(str)
+// Info 4164: (692-698): Inferred type: bool
+// Info 4164: (692-693): Inferred type: T(int)
+// Info 4164: (697-698): Inferred type: T(int)
+// Info 4164: (704-710): Inferred type: bool
+// Info 4164: (704-705): Inferred type: T(str)
+// Info 4164: (709-710): Inferred type: T(str)
+// Info 4164: (717-728): Inferred type: T(int)
+// Info 4164: (717-722): Inferred type: (T(int), T(int)) -> T(int)
+// Info 4164: (717-718): Inferred type: C
+// Info 4164: (723-724): Inferred type: T(int)
+// Info 4164: (726-727): Inferred type: T(int)
+// Info 4164: (734-745): Inferred type: T(str)
+// Info 4164: (734-739): Inferred type: (T(str), T(str)) -> T(str)
+// Info 4164: (734-735): Inferred type: C
+// Info 4164: (740-741): Inferred type: T(str)
+// Info 4164: (743-744): Inferred type: T(str)
diff --git a/compiler/test/libsolidity/syntaxTests/freeFunctions/invalid_function_named_unicode.sol b/compiler/test/libsolidity/syntaxTests/freeFunctions/invalid_function_named_unicode.sol
new file mode 100644
index 00000000..889d7df2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/freeFunctions/invalid_function_named_unicode.sol
@@ -0,0 +1,4 @@
+function unicode() returns {}
+
+// ----
+// ParserError 2314: (9-16): Expected identifier but got 'ILLEGAL'
diff --git a/compiler/test/libsolidity/syntaxTests/freeFunctions/named_fallback_warning.sol b/compiler/test/libsolidity/syntaxTests/freeFunctions/named_fallback_warning.sol
new file mode 100644
index 00000000..8f0c0ea3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/freeFunctions/named_fallback_warning.sol
@@ -0,0 +1,3 @@
+function fallback() {}
+// ----
+// Warning 3445: (9-17): This function is named "fallback" but is not the fallback function of the contract. If you intend this to be a fallback function, use "fallback(...) { ... }" without the "function" keyword to define it.
diff --git a/compiler/test/libsolidity/syntaxTests/freeFunctions/named_receive_warning.sol b/compiler/test/libsolidity/syntaxTests/freeFunctions/named_receive_warning.sol
new file mode 100644
index 00000000..25c86024
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/freeFunctions/named_receive_warning.sol
@@ -0,0 +1,3 @@
+function receive() {}
+// ----
+// Warning 3445: (9-16): This function is named "receive" but is not the receive function of the contract. If you intend this to be a receive function, use "receive(...) { ... }" without the "function" keyword to define it.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/enum_value_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/enum_value_not_callable.sol
new file mode 100644
index 00000000..f2d7cd1b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/enum_value_not_callable.sol
@@ -0,0 +1,7 @@
+enum E { A, B, C }
+
+contract C {
+    uint a = E.B(1000);
+}
+// ----
+// TypeError 5704: (46-55): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/int_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/int_not_callable.sol
new file mode 100644
index 00000000..e1ddbc7d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/int_not_callable.sol
@@ -0,0 +1,8 @@
+contract C
+{
+    function f ( ) public {
+        ( ( 1 ( 3 ) ) , 2 );
+    }
+}
+// ----
+// TypeError 5704: (53-60): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/magic_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/magic_not_callable.sol
new file mode 100644
index 00000000..c93f0bb8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/magic_not_callable.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint a = msg(1000);
+}
+// ----
+// TypeError 5704: (26-35): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/mapping_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/mapping_not_callable.sol
new file mode 100644
index 00000000..e5258b62
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/mapping_not_callable.sol
@@ -0,0 +1,6 @@
+contract C {
+    mapping (uint => uint) m;
+    uint a = m(1000);
+}
+// ----
+// TypeError 5704: (56-63): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/modifier_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/modifier_not_callable.sol
new file mode 100644
index 00000000..0f41072e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/modifier_not_callable.sol
@@ -0,0 +1,7 @@
+contract C {
+    uint a = m(1000);
+
+    modifier m(uint) { _; }
+}
+// ----
+// TypeError 5704: (26-33): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/module_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/module_not_callable.sol
new file mode 100644
index 00000000..1415810a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/module_not_callable.sol
@@ -0,0 +1,9 @@
+==== Source: A.sol ====
+==== Source: B.sol ====
+import "A.sol" as A;
+
+contract C {
+    uint a = A(1000);
+}
+// ----
+// TypeError 5704: (B.sol:48-55): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionCalls/this_not_callable.sol b/compiler/test/libsolidity/syntaxTests/functionCalls/this_not_callable.sol
new file mode 100644
index 00000000..8de5683b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionCalls/this_not_callable.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public returns (uint, uint) {
+        try this() {
+        } catch Error(string memory) {
+        }
+    }
+}
+// ----
+// TypeError 5704: (72-78): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function.sol
new file mode 100644
index 00000000..fd60adce
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function.sol
@@ -0,0 +1,15 @@
+library L {
+    function foo(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+}
+contract C {
+    using L for uint256;
+
+    function bar() public {
+        uint256 x;
+        function (uint256, uint256) internal pure returns (uint256) ptr = x.foo;
+    }
+}
+// ----
+// TypeError 9574: (209-280): Type function (uint256,uint256) pure returns (uint256) is not implicitly convertible to expected type function (uint256,uint256) pure returns (uint256). Attached functions cannot be converted into unattached functions.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function_storage_arg.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function_storage_arg.sol
new file mode 100644
index 00000000..277880b9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_attached_library_function_storage_arg.sol
@@ -0,0 +1,13 @@
+library D { struct s { uint a; } function mul(s storage self, uint x) public returns (uint) { return self.a *= x; } }
+contract C {
+    using D for D.s;
+    D.s x;
+    function f(uint a) public returns (uint) {
+        function (D.s storage, uint) returns (uint) g = x.mul;
+        g(x, a);
+        g(a);
+    }
+}
+// ----
+// TypeError 9574: (218-271): Type function (struct D.s storage pointer,uint256) returns (uint256) is not implicitly convertible to expected type function (struct D.s storage pointer,uint256) returns (uint256). Attached functions cannot be converted into unattached functions.
+// TypeError 6160: (298-302): Wrong argument count for function call: 1 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/assign_builtin.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_builtin.sol
new file mode 100644
index 00000000..32cc005d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/assign_builtin.sol
@@ -0,0 +1,7 @@
+contract C {
+  function f() public {
+     function (uint) view returns (bytes32) _blockhash = blockhash;
+  }
+}
+// ----
+// TypeError 9574: (42-103): Type function (uint256) view returns (bytes32) is not implicitly convertible to expected type function (uint256) view returns (bytes32). Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_external_eq.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_external_eq.sol
new file mode 100644
index 00000000..2181fa99
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_external_eq.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (bool ret) {
+        return this.f == this.f;
+    }
+    function g() public view returns (bool ret) {
+        return this.f != this.f;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_1.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_1.sol
new file mode 100644
index 00000000..b88c257a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_1.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bool ret) {
+        return this.f > this.f;
+    }
+}
+// ----
+// TypeError 2271: (73-88): Built-in binary operator > cannot be applied to types function () external returns (bool) and function () external returns (bool).
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_2.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_2.sol
new file mode 100644
index 00000000..000aea87
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_gt_2.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bool ret) {
+        return f > f;
+    }
+}
+// ----
+// TypeError 2271: (73-78): Built-in binary operator > cannot be applied to types function () returns (bool) and function () returns (bool).
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_1.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_1.sol
new file mode 100644
index 00000000..44da7f0d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_1.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure returns (bool ret) {
+        return f == f;
+    }
+    function g() public pure returns (bool ret) {
+        return f != f;
+    }
+}
+// ----
+// Warning 3075: (78-84): Comparison of internal function pointers can yield unexpected results in the legacy pipeline with the optimizer enabled, and will be disallowed entirely in the next breaking release.
+// Warning 3075: (157-163): Comparison of internal function pointers can yield unexpected results in the legacy pipeline with the optimizer enabled, and will be disallowed entirely in the next breaking release.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_2.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_2.sol
new file mode 100644
index 00000000..4be35a23
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_internal_eq_2.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() internal {}
+    function g() internal {}
+
+    function test() public pure returns (bool) {
+        function () internal ptr = C.f;
+        return ptr == C.g;
+    }
+}
+// ----
+// Warning 3075: (176-186): Comparison of internal function pointers can yield unexpected results in the legacy pipeline with the optimizer enabled, and will be disallowed entirely in the next breaking release.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_1.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_1.sol
new file mode 100644
index 00000000..ea1c55d3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_1.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bool ret) {
+        return this.f < this.f;
+    }
+}
+// ----
+// TypeError 2271: (73-88): Built-in binary operator < cannot be applied to types function () external returns (bool) and function () external returns (bool).
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_2.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_2.sol
new file mode 100644
index 00000000..dc973ff6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_of_function_types_lt_2.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (bool ret) {
+        return f < f;
+    }
+}
+// ----
+// TypeError 2271: (73-78): Built-in binary operator < cannot be applied to types function () returns (bool) and function () returns (bool).
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol
new file mode 100644
index 00000000..12cbe293
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operator_for_external_functions_with_extra_gas_slots.sol
@@ -0,0 +1,12 @@
+contract C {
+    function external_test_function() external {}
+    function comparison_operator_for_external_function_with_extra_slots() external returns (bool) {
+        return (
+            (this.external_test_function{gas: 4} == this.external_test_function) &&
+            (this.external_test_function{gas: 4} == this.external_test_function{gas: 4})
+        );
+    }
+}
+// ----
+// TypeError 2271: (193-259): Built-in binary operator == cannot be applied to types function () external and function () external.
+// TypeError 2271: (277-351): Built-in binary operator == cannot be applied to types function () external and function () external.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_between_internal_and_external_function_pointers.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_between_internal_and_external_function_pointers.sol
new file mode 100644
index 00000000..358b9c62
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_between_internal_and_external_function_pointers.sol
@@ -0,0 +1,24 @@
+contract C {
+    function external_test_function() external {}
+    function internal_test_function() internal {}
+
+    function comparison_operator_between_internal_and_external_function_pointers() external returns (bool) {
+        function () external external_function_pointer_local = this.external_test_function;
+        function () internal internal_function_pointer_local = internal_test_function;
+
+        assert(
+            this.external_test_function == external_function_pointer_local &&
+            internal_function_pointer_local == internal_test_function
+        );
+        assert(
+            internal_function_pointer_local != external_function_pointer_local &&
+            internal_test_function != this.external_test_function
+        );
+
+        return true;
+    }
+}
+// ----
+// Warning 3075: (509-566): Comparison of internal function pointers can yield unexpected results in the legacy pipeline with the optimizer enabled, and will be disallowed entirely in the next breaking release.
+// TypeError 2271: (606-672): Built-in binary operator != cannot be applied to types function () and function () external.
+// TypeError 2271: (688-741): Built-in binary operator != cannot be applied to types function () and function () external.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_external_functions_with_different_parameters.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_external_functions_with_different_parameters.sol
new file mode 100644
index 00000000..599e9286
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/comparison_operators_external_functions_with_different_parameters.sol
@@ -0,0 +1,26 @@
+contract C {
+    function external_test_function1(uint num) external {}
+    function external_test_function2(bool val) external {}
+
+    function comparison_operator_between_internal_and_external_function_pointers() external returns (bool) {
+        function () external external_function_pointer_local1 = this.external_test_function1;
+        function () external external_function_pointer_local2 = this.external_test_function2;
+
+        assert(
+            this.external_test_function1 == external_function_pointer_local1 &&
+            this.external_test_function2 == external_function_pointer_local2
+        );
+        assert(
+            external_function_pointer_local2 != external_function_pointer_local1 &&
+            this.external_test_function2 != this.external_test_function1
+        );
+
+        return true;
+    }
+}
+// ----
+// TypeError 9574: (249-333): Type function (uint256) external is not implicitly convertible to expected type function () external.
+// TypeError 9574: (343-427): Type function (bool) external is not implicitly convertible to expected type function () external.
+// TypeError 2271: (458-522): Built-in binary operator == cannot be applied to types function (uint256) external and function () external.
+// TypeError 2271: (538-602): Built-in binary operator == cannot be applied to types function (bool) external and function () external.
+// TypeError 2271: (726-786): Built-in binary operator != cannot be applied to types function (bool) external and function (uint256) external.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion.sol
new file mode 100644
index 00000000..c31c49ae
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion.sol
@@ -0,0 +1,12 @@
+contract D {
+	function f() external {}
+	function g() external {}
+}
+contract C {
+	function f(bool c) public pure {
+		(c ? D.f : D.g);
+	}
+}
+// ----
+// TypeError 9717: (121-124): Invalid mobile type in true expression.
+// TypeError 3703: (127-130): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion_internal_base.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion_internal_base.sol
new file mode 100644
index 00000000..210211b2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/declaration_type_conversion_internal_base.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() internal {}
+    function g() internal {}
+}
+
+contract D is C {
+    function h(bool b) public pure {
+        (b ? C.f : C.g);
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol
new file mode 100644
index 00000000..b5bacb69
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f(function (string calldata) external) external {}
+    function g(string calldata) external {}
+
+    function main() external {
+        function (string calldata) external ptr = this.g;
+        abi.encodeCall(this.f, (this.g));
+        this.f(this.g);
+    }
+}
+// ----
+// TypeError 9574: (161-209): Type function (string memory) external is not implicitly convertible to expected type function (string calldata) external.
+// TypeError 5407: (242-250): Cannot implicitly convert component at position 0 from "function (string memory) external" to "function (string calldata) external".
+// TypeError 9553: (268-274): Invalid type for argument in function call. Invalid implicit conversion from function (string memory) external to function (string calldata) external requested.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol
new file mode 100644
index 00000000..8aab9fd1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol
@@ -0,0 +1,9 @@
+contract C {
+    function g(string calldata) external {}
+
+    function main() view external {
+        function (string memory) external ptr = this.g;
+        ptr;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/external_library_function_to_external_function_type.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/external_library_function_to_external_function_type.sol
new file mode 100644
index 00000000..c9c87a2c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/external_library_function_to_external_function_type.sol
@@ -0,0 +1,14 @@
+library L {
+    function f(uint256 _a) external returns (uint256) {}
+}
+
+contract C {
+    function run(function(uint256) external returns (uint256) _operation) internal returns (uint256) {}
+    function test() public {
+        run(L.f);
+        function(uint256) external returns (uint256) _operation = L.f;
+    }
+}
+// ----
+// TypeError 9553: (230-233): Invalid type for argument in function call. Invalid implicit conversion from function (uint256) returns (uint256) to function (uint256) external returns (uint256) requested. Special functions cannot be converted to function types.
+// TypeError 9574: (244-305): Type function (uint256) returns (uint256) is not implicitly convertible to expected type function (uint256) external returns (uint256). Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/from_ternary_expression.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/from_ternary_expression.sol
new file mode 100644
index 00000000..62ad8aa9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/from_ternary_expression.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() public pure returns (uint x) {
+        x = (true ? addmod : addmod)(3, 4, 5);
+    }
+}
+// ----
+// TypeError 9717: (81-87): Invalid mobile type in true expression.
+// TypeError 3703: (90-96): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/function_type_variable_external_internal.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/function_type_variable_external_internal.sol
new file mode 100644
index 00000000..cd0800c3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/function_type_variable_external_internal.sol
@@ -0,0 +1,6 @@
+contract test {
+    function fa(bytes memory) public { }
+    function(bytes memory) external internal a = fa;
+}
+// ----
+// TypeError 7407: (106-108): Type function (bytes memory) is not implicitly convertible to expected type function (bytes memory) external. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function.sol
new file mode 100644
index 00000000..4e5ae761
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function.sol
@@ -0,0 +1,13 @@
+library L {
+    function f(uint a) internal pure {}
+    function g(uint a) internal pure {}
+}
+contract C {
+    using L for *;
+    function f() pure public {
+        uint t = 8;
+        [t.f, t.g][0]();
+    }
+}
+// ----
+// TypeError 9563: (186-189): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function_mixed.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function_mixed.sol
new file mode 100644
index 00000000..be98f2be
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/inline_array_with_attached_function_mixed.sol
@@ -0,0 +1,13 @@
+library L {
+    function f(uint a) internal pure {}
+}
+contract C {
+    using L for *;
+    function f() pure public {
+        uint t;
+        function() pure x;
+        [t.f, x][0]({a: 8});
+    }
+}
+// ----
+// TypeError 9563: (169-172): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/internal_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/internal_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol
new file mode 100644
index 00000000..5e9014ad
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/internal_functions_with_calldata_args_assigned_to_function_pointers_of_same_type.sol
@@ -0,0 +1,9 @@
+contract C {
+    function g(bytes calldata b) pure internal {}
+
+    function main() pure external {
+        function (bytes calldata) internal ptr = g;
+        ptr;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_contract_external_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_contract_external_function.sol
new file mode 100644
index 00000000..847caad0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_contract_external_function.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() external pure { }
+    function g() external pure { }
+    function test(bool b) public returns(bytes4) {
+        (b ? C.f : C.g).selector;
+    }
+}
+// ----
+// TypeError 9717: (147-150): Invalid mobile type in true expression.
+// TypeError 3703: (153-156): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contract_public_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contract_public_function.sol
new file mode 100644
index 00000000..5f5edfa9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contract_public_function.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure { }
+    function g() public pure { }
+}
+
+contract A {
+    function test(bool b) public returns(bytes4) {
+        (b ? C.f : C.g).selector;
+    }
+}
+// ----
+// TypeError 9717: (159-162): Invalid mobile type in true expression.
+// TypeError 3703: (165-168): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contracts_external_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contracts_external_function.sol
new file mode 100644
index 00000000..e015f431
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_contracts_external_function.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() external pure { }
+}
+
+contract D {
+    function g() external pure { }
+}
+
+contract A {
+    function test(bool b) public returns(bytes4) {
+        (b ? C.f : D.g).selector;
+    }
+}
+// ----
+// TypeError 9717: (179-182): Invalid mobile type in true expression.
+// TypeError 3703: (185-188): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_interface_external_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_interface_external_function.sol
new file mode 100644
index 00000000..4109a14c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/selector_ternary_different_interface_external_function.sol
@@ -0,0 +1,16 @@
+interface I1 {
+    function f() external pure;
+}
+
+interface I2 {
+    function g() external pure;
+}
+
+contract C {
+    function test(bool b) public returns(bytes4) {
+        (b ? I1.f : I2.g).selector;
+    }
+}
+// ----
+// TypeError 9717: (177-181): Invalid mobile type in true expression.
+// TypeError 3703: (184-188): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_contract_delegate_function.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_contract_delegate_function.sol
new file mode 100644
index 00000000..810f5eb2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_contract_delegate_function.sol
@@ -0,0 +1,12 @@
+library L {
+    function f() external {}
+}
+
+contract C {
+    function test() public {
+        (true ? L.f : L.f).selector;
+    }
+}
+
+// ----
+// TypeError 9582: (94-121): Member "selector" not found or not visible after argument-dependent lookup in function ().
diff --git a/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_with_attached_functions.sol b/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_with_attached_functions.sol
new file mode 100644
index 00000000..2e12e4d2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/functionTypes/ternary_with_attached_functions.sol
@@ -0,0 +1,14 @@
+library L {
+    function f(uint a) internal pure {}
+    function g(uint a) internal pure {}
+}
+contract C {
+    using L for *;
+    function f(bool x) pure public {
+        uint t = 8;
+        (x ? t.f : t.g)();
+    }
+}
+// ----
+// TypeError 9717: (196-199): Invalid mobile type in true expression.
+// TypeError 3703: (202-205): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_pre_cancun.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_pre_cancun.sol
new file mode 100644
index 00000000..e5904f4e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_pre_cancun.sol
@@ -0,0 +1,11 @@
+contract C {
+    function blobhash(uint256 index) public pure returns(bytes32) {
+        return bytes32(index);
+    }
+    function f() public pure returns(bytes32) {
+        return blobhash(2);
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_shadow_warning.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_shadow_warning.sol
new file mode 100644
index 00000000..5469df9e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_function_shadow_warning.sol
@@ -0,0 +1,12 @@
+contract C {
+    function blobhash(uint256 index) public pure returns(bytes32) {
+        return bytes32(index);
+    }
+    function f() public pure returns(bytes32) {
+        return blobhash(2);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2319: (17-117): This declaration shadows a builtin symbol.
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_no_call.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_no_call.sol
new file mode 100644
index 00000000..369ea047
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_no_call.sol
@@ -0,0 +1,10 @@
+contract C
+{
+    function f() public pure {
+        blobhash;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 6133: (52-60): Statement has no effect.
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_not_declared_pre_cancun.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_not_declared_pre_cancun.sol
new file mode 100644
index 00000000..a62f8301
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_not_declared_pre_cancun.sol
@@ -0,0 +1,10 @@
+contract C
+{
+    function f() public pure {
+        blobhash;
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
+// DeclarationError 7576: (52-60): Undeclared identifier. Did you mean "blockhash"?
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_pre_cancun.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_pre_cancun.sol
new file mode 100644
index 00000000..42b54dc6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_pre_cancun.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (bool) {
+        bool blobhash = true;
+        return blobhash;
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_shadow_warning.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_shadow_warning.sol
new file mode 100644
index 00000000..f60378e8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/blobhash_var_shadow_warning.sol
@@ -0,0 +1,11 @@
+contract C
+{
+    function f() public pure returns (bool) {
+        bool blobhash = true;
+        return blobhash;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2319: (67-80): This declaration shadows a builtin symbol.
diff --git a/compiler/test/libsolidity/syntaxTests/globalFunctions/selfdestruct_no_call.sol b/compiler/test/libsolidity/syntaxTests/globalFunctions/selfdestruct_no_call.sol
new file mode 100644
index 00000000..e8a657bd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/globalFunctions/selfdestruct_no_call.sol
@@ -0,0 +1,6 @@
+contract C {
+    function f() pure public { selfdestruct; }
+}
+// ----
+// Warning 5159: (44-56): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// Warning 6133: (44-56): Statement has no effect.
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_dec_tuple.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_dec_tuple.sol
new file mode 100644
index 00000000..9398ef47
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_dec_tuple.sol
@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        int x = --(,);
+    }
+}
+// ----
+// TypeError 9767: (59-64): Built-in unary operator -- cannot be applied to type tuple(,).
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_delete_tuple.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_delete_tuple.sol
new file mode 100644
index 00000000..649eae56
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_delete_tuple.sol
@@ -0,0 +1,10 @@
+contract C
+{
+    function f() public
+    {
+        int x = delete (,0);
+    }
+}
+// ----
+// TypeError 4247: (68-69): Expression has to be an lvalue.
+// TypeError 9767: (59-70): Built-in unary operator delete cannot be applied to type tuple(,int_const 0).
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_inc_tuple.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_inc_tuple.sol
new file mode 100644
index 00000000..2f20a621
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_inc_tuple.sol
@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        (int x) = ++(,);
+    }
+}
+// ----
+// TypeError 9767: (61-66): Built-in unary operator ++ cannot be applied to type tuple(,).
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_plus_tuple.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_plus_tuple.sol
new file mode 100644
index 00000000..a0621ebf
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_plus_tuple.sol
@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        int x = +(0, 0);
+    }
+}
+// ----
+// ParserError 9636: (59-60): Use of unary + is disallowed.
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_tuple.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_tuple.sol
new file mode 100644
index 00000000..a0ed75c9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_tuple.sol
@@ -0,0 +1,16 @@
+contract C
+{
+    function f() public
+    {
+        int y = -(0, 0);
+        (int z) = ~(0, 0);
+        (int t) = !(0, 0);
+    }
+}
+// ----
+// TypeError 4907: (59-66): Built-in unary operator - cannot be applied to type tuple(int_const 0,int_const 0).
+// TypeError 7364: (51-66): Different number of components on the left hand side (1) than on the right hand side (2).
+// TypeError 4907: (86-93): Built-in unary operator ~ cannot be applied to type tuple(int_const 0,int_const 0).
+// TypeError 7364: (76-93): Different number of components on the left hand side (1) than on the right hand side (2).
+// TypeError 4907: (113-120): Built-in unary operator ! cannot be applied to type tuple(int_const 0,int_const 0).
+// TypeError 7364: (103-120): Different number of components on the left hand side (1) than on the right hand side (2).
diff --git a/compiler/test/libsolidity/syntaxTests/iceRegressionTests/identifier_collision_return_declare.sol b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/identifier_collision_return_declare.sol
new file mode 100644
index 00000000..aa5aeec4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/iceRegressionTests/identifier_collision_return_declare.sol
@@ -0,0 +1,5 @@
+contract C {
+        function ( uint ) external returns ( a [ ] calldata ) public a = ( 1 / 2 ) ;
+}
+// ----
+// TypeError 5172: (58-59): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/conditional_return_uninitialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/conditional_return_uninitialized.sol
new file mode 100644
index 00000000..d2c473fb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/conditional_return_uninitialized.sol
@@ -0,0 +1,9 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        if (false)
+            return;
+
+        x = 1;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/conditionally_initialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/conditionally_initialized.sol
new file mode 100644
index 00000000..312a7608
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/conditionally_initialized.sol
@@ -0,0 +1,7 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        if (false)
+            x = 1;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_indirect_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_indirect_reading.sol
new file mode 100644
index 00000000..b23d161c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_indirect_reading.sol
@@ -0,0 +1,8 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        x = f();
+    }
+
+    function f() public view returns (uint) { return 3 + x; }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_reading.sol
new file mode 100644
index 00000000..5df8d162
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/ctor_initialization_reading.sol
@@ -0,0 +1,6 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        x = 3 + x;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_args.sol b/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_args.sol
new file mode 100644
index 00000000..09c3aefa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_args.sol
@@ -0,0 +1,11 @@
+contract C {
+    uint immutable x;
+    constructor() readX(x = 3) { }
+
+    modifier readX(uint _x) {
+        _; f(_x);
+    }
+
+    function f(uint a) internal pure {}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_reading.sol
new file mode 100644
index 00000000..113cda75
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/ctor_modifier_reading.sol
@@ -0,0 +1,12 @@
+contract C {
+    uint immutable x;
+    constructor() readX {
+        x = 3;
+    }
+
+    modifier readX() {
+        _; f(x);
+    }
+
+    function f(uint a) internal pure {}
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/decrement.sol b/compiler/test/libsolidity/syntaxTests/immutable/decrement.sol
new file mode 100644
index 00000000..4931b5f9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/decrement.sol
@@ -0,0 +1,6 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        x--;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/function_initialization_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/function_initialization_reading.sol
new file mode 100644
index 00000000..e276ba78
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/function_initialization_reading.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint immutable x = f();
+
+    function f() public view returns (uint) { return 3 + x; }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_initializing.sol b/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_initializing.sol
new file mode 100644
index 00000000..cc175d08
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_initializing.sol
@@ -0,0 +1,13 @@
+abstract contract B {
+    uint immutable x;
+
+    constructor(function() internal returns(uint) fp) {
+        x = fp();
+    }
+}
+
+contract C is B(C.f) {
+    function f() internal returns(uint) { return x = 2; }
+}
+// ----
+// TypeError 1581: (200-201): Cannot write to immutable here: Immutable variables can only be initialized inline or assigned directly in the constructor.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_reading.sol
new file mode 100644
index 00000000..2658d35d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/function_pointer_reading.sol
@@ -0,0 +1,12 @@
+abstract contract B {
+    uint immutable x;
+
+    constructor(function() internal returns(uint) fp) {
+        x = fp();
+    }
+}
+
+contract C is B(C.f) {
+    function f() internal view returns(uint) { return x + 2; }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/increment.sol b/compiler/test/libsolidity/syntaxTests/immutable/increment.sol
new file mode 100644
index 00000000..62506d88
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/increment.sol
@@ -0,0 +1,6 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        x++;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/indirect_reading_during_statevar_init.sol b/compiler/test/libsolidity/syntaxTests/immutable/indirect_reading_during_statevar_init.sol
new file mode 100644
index 00000000..985e5d0b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/indirect_reading_during_statevar_init.sol
@@ -0,0 +1,7 @@
+contract C {
+    uint immutable x = 0;
+    uint y = f();
+
+    function f() internal pure returns(uint) { return x; }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_argument.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_argument.sol
new file mode 100644
index 00000000..025f5616
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_argument.sol
@@ -0,0 +1,12 @@
+contract B {
+    uint immutable x;
+
+    constructor(uint _x) {
+        x = _x;
+    }
+}
+
+contract C is B {
+    uint immutable y;
+    constructor() B(y = 3) { }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_init.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_init.sol
new file mode 100644
index 00000000..f1787ab4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_init.sol
@@ -0,0 +1,11 @@
+contract B {
+    uint immutable x;
+
+    constructor(uint _x) {
+        x = _x;
+    }
+}
+
+contract C is B(C.y = 3) {
+    uint immutable y;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_reading.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_reading.sol
new file mode 100644
index 00000000..0ac37261
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_ctor_inherit_specifier_argument_reading.sol
@@ -0,0 +1,14 @@
+contract B {
+    uint immutable x;
+
+    constructor(uint _x) {
+        x = _x;
+    }
+}
+
+contract C is B(C.y) {
+    uint immutable y;
+    constructor() {
+        y = 3;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_functions.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_functions.sol
new file mode 100644
index 00000000..addd3249
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_functions.sol
@@ -0,0 +1,18 @@
+contract B {
+    uint immutable x;
+
+    constructor() {
+        x = xInit();
+    }
+
+    function xInit() internal view virtual returns(uint) {
+        return 3;
+    }
+}
+
+contract C is B {
+    function xInit() internal view override returns(uint) {
+        return x;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_modifiers.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_modifiers.sol
new file mode 100644
index 00000000..31f510dc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_virtual_modifiers.sol
@@ -0,0 +1,19 @@
+contract B {
+    uint immutable x;
+
+    constructor() readX {
+        x = 3;
+    }
+
+    modifier readX() virtual {
+        _; f(3);
+    }
+
+    function f(uint a) internal pure {}
+}
+
+contract C is B {
+    modifier readX() override {
+        _; f(x);
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/inheritance_wrong_ctor.sol b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_wrong_ctor.sol
new file mode 100644
index 00000000..d7586c43
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/inheritance_wrong_ctor.sol
@@ -0,0 +1,9 @@
+contract B {
+    uint immutable x = 4;
+}
+
+contract C is B {
+    constructor() {
+        x = 3;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_constructor_modifier_param.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_constructor_modifier_param.sol
new file mode 100644
index 00000000..f638ae7b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_constructor_modifier_param.sol
@@ -0,0 +1,6 @@
+contract D {
+    uint immutable t;
+    modifier m(uint) { _; }
+    constructor() m(t = 2) {}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_ctor_param.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_ctor_param.sol
new file mode 100644
index 00000000..63c6057d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_ctor_param.sol
@@ -0,0 +1,5 @@
+contract C { constructor(uint) {} }
+contract D is C {
+  uint immutable t;
+  constructor() C(t=2) {}
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_modifier_param.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_modifier_param.sol
new file mode 100644
index 00000000..b4294395
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_modifier_param.sol
@@ -0,0 +1,7 @@
+contract D {
+    uint immutable t;
+    modifier m(uint) { _; }
+    function f() public m(t = 2) {}
+}
+// ----
+// TypeError 1581: (89-90): Cannot write to immutable here: Immutable variables can only be initialized inline or assigned directly in the constructor.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_contract_name.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_contract_name.sol
new file mode 100644
index 00000000..01163f2f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_contract_name.sol
@@ -0,0 +1,11 @@
+contract B {
+    uint immutable x;
+}
+
+contract C is B {
+    function f() public {
+        B.x = 42;
+    }
+}
+// ----
+// TypeError 1581: (90-93): Cannot write to immutable here: Immutable variables can only be initialized inline or assigned directly in the constructor.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_super.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_super.sol
new file mode 100644
index 00000000..941b5e51
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_function_via_super.sol
@@ -0,0 +1,13 @@
+contract B {
+    uint immutable x;
+
+    function g() public {}
+}
+
+contract C is B {
+    function f() public {
+        super.x = 42;
+    }
+}
+// ----
+// TypeError 9582: (118-125): Member "x" not found or not visible after argument-dependent lookup in type(contract super C).
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/init_in_inheritance_specifier_param.sol b/compiler/test/libsolidity/syntaxTests/immutable/init_in_inheritance_specifier_param.sol
new file mode 100644
index 00000000..f80c238e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/init_in_inheritance_specifier_param.sol
@@ -0,0 +1,4 @@
+contract C { constructor(uint) {} }
+contract D is C(D.t = 2) {
+    uint immutable t;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/loop_initialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/loop_initialized.sol
new file mode 100644
index 00000000..1cbe9add
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/loop_initialized.sol
@@ -0,0 +1,7 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        while (true)
+            x = 1;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions.sol b/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions.sol
new file mode 100644
index 00000000..a87ec768
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions.sol
@@ -0,0 +1,28 @@
+contract A {
+    function f() internal virtual returns(uint) { return 3; }
+}
+
+contract B {
+    uint immutable x;
+
+    constructor() {
+        x = xInit();
+    }
+
+    function xInit() internal virtual returns(uint) {
+        return f();
+    }
+
+    function f() internal view virtual returns(uint) { return 3; }
+}
+
+contract C is A, B {
+    function xInit() internal override returns(uint) {
+        return B.xInit();
+    }
+
+    function f() internal view override(A, B) returns(uint) {
+        return x;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions_with_super.sol b/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions_with_super.sol
new file mode 100644
index 00000000..8b8c5dd2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/multiple_inheritance_virtual_functions_with_super.sol
@@ -0,0 +1,28 @@
+contract A {
+    function f() internal virtual returns(uint) { return 3; }
+}
+
+contract B {
+    uint immutable x;
+
+    constructor() {
+        x = xInit();
+    }
+
+    function xInit() internal virtual returns(uint) {
+        return f();
+    }
+
+    function f() internal view virtual returns(uint) { return 3; }
+}
+
+contract C is A, B {
+    function xInit() internal override returns(uint) {
+        return super.xInit();
+    }
+
+    function f() internal view override(A, B) returns(uint) {
+        return x;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/multiple_initializations.sol b/compiler/test/libsolidity/syntaxTests/immutable/multiple_initializations.sol
new file mode 100644
index 00000000..8fe5ddcf
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/multiple_initializations.sol
@@ -0,0 +1,7 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        x = 1;
+        x = 4;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/private_state_var.sol b/compiler/test/libsolidity/syntaxTests/immutable/private_state_var.sol
new file mode 100644
index 00000000..cce1ca0f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/private_state_var.sol
@@ -0,0 +1,18 @@
+contract B {
+    uint immutable private x = f();
+
+    constructor() {
+    }
+
+    function f() internal view virtual returns(uint) { return 1; }
+    function readX() internal view returns(uint) { return x; }
+}
+
+contract C is B {
+    uint immutable y;
+    constructor() {
+        y = 3;
+    }
+    function f() internal view override returns(uint) { return readX(); }
+
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init.sol b/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init.sol
new file mode 100644
index 00000000..b4f56a26
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init.sol
@@ -0,0 +1,10 @@
+abstract contract A {
+	uint public t;
+	constructor() { t = f(); }
+
+	function f() virtual pure internal returns (uint);
+}
+contract B is A {
+	uint immutable x = 2;
+	function f() override pure internal returns (uint) { return x; }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init2.sol b/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init2.sol
new file mode 100644
index 00000000..7234e0ef
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/read_in_function_before_init2.sol
@@ -0,0 +1,5 @@
+contract C {
+  uint immutable t = 2;
+  uint x = f();
+  function f() internal pure returns (uint) { return t; }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/reading_after_initialization_function.sol b/compiler/test/libsolidity/syntaxTests/immutable/reading_after_initialization_function.sol
new file mode 100644
index 00000000..618ad36f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/reading_after_initialization_function.sol
@@ -0,0 +1,15 @@
+contract C {
+	uint immutable x;
+
+	constructor()
+	{
+		readX();
+		x = 3;
+		readX();
+	}
+
+	function readX() public view returns(uint) {
+		return x;
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/reading_during_statevar_init.sol b/compiler/test/libsolidity/syntaxTests/immutable/reading_during_statevar_init.sol
new file mode 100644
index 00000000..755de648
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/reading_during_statevar_init.sol
@@ -0,0 +1,4 @@
+contract C {
+    uint immutable x = 0;
+    uint y = x;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/return_uninitialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/return_uninitialized.sol
new file mode 100644
index 00000000..3a0b3f43
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/return_uninitialized.sol
@@ -0,0 +1,10 @@
+contract C {
+    uint immutable x;
+    constructor() {
+        return;
+
+        x = 1;
+    }
+}
+// ----
+// Warning 5740: (80-85): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_read.sol b/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_read.sol
new file mode 100644
index 00000000..64b24b06
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_read.sol
@@ -0,0 +1,13 @@
+contract C {
+    uint immutable public x = 42;
+
+    function g() external view returns (uint) {}
+
+    function f() public view returns (uint) {
+        return this.x();
+    }
+
+    function h() public view returns (function () external view returns (uint)) {
+        return this.x;
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_write.sol b/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_write.sol
new file mode 100644
index 00000000..4baa743c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/state_var_external_access_write.sol
@@ -0,0 +1,11 @@
+contract C {
+    uint immutable public x = 42;
+
+    function g() external view returns (uint) {}
+
+    function f() public view {
+        this.x = this.g;
+    }
+}
+// ----
+// TypeError 4247: (137-143): Expression has to be an lvalue.
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/try_catch_initialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/try_catch_initialized.sol
new file mode 100644
index 00000000..fe969a20
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/try_catch_initialized.sol
@@ -0,0 +1,35 @@
+contract A
+{
+    uint256 public immutable variable;
+
+    constructor()
+    {
+        B b;
+        try b.foo(variable = 1)
+        {
+            variable = 2;
+        }
+        catch Panic(uint)
+        {
+            variable = 3;
+        }
+        catch Error(string memory)
+        {
+            variable = 4;
+        }
+        catch
+        {
+            variable = 5;
+        }
+    }
+}
+
+contract B
+{
+    function foo(uint256) external pure
+    {
+        revert();
+    }
+}
+// ====
+// EVMVersion: >=byzantium
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/uninitialized.sol b/compiler/test/libsolidity/syntaxTests/immutable/uninitialized.sol
new file mode 100644
index 00000000..bf7c68a8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/uninitialized.sol
@@ -0,0 +1,3 @@
+contract C {
+    uint immutable x;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/uninitialized_private_state_var.sol b/compiler/test/libsolidity/syntaxTests/immutable/uninitialized_private_state_var.sol
new file mode 100644
index 00000000..70bd1448
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/uninitialized_private_state_var.sol
@@ -0,0 +1,18 @@
+contract B {
+    uint immutable private x;
+
+    constructor() {
+    }
+
+    function f() internal view virtual returns(uint) { return 1; }
+    function readX() internal view returns(uint) { return x; }
+}
+
+contract C is B {
+    uint immutable y;
+    constructor() {
+        y = 3;
+    }
+    function f() internal view override returns(uint) { return readX(); }
+
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_already.sol b/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_already.sol
new file mode 100644
index 00000000..2917f276
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_already.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint immutable z = 2;
+    uint immutable x = z = y = 3;
+    uint immutable y = 5;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_value.sol b/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_value.sol
new file mode 100644
index 00000000..6451c8e2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/immutable/variable_declaration_value.sol
@@ -0,0 +1,3 @@
+contract C {
+    int immutable x = x = 5;
+}
diff --git a/compiler/test/libsolidity/syntaxTests/imports/module_function_from_ternary_expression.sol b/compiler/test/libsolidity/syntaxTests/imports/module_function_from_ternary_expression.sol
new file mode 100644
index 00000000..d97bbee3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/imports/module_function_from_ternary_expression.sol
@@ -0,0 +1,19 @@
+==== Source: A ====
+function f() pure returns (uint) {
+    return 42;
+}
+==== Source: B ====
+function f() pure returns (uint) {
+    return 24;
+}
+==== Source: C ====
+import "A" as A;
+import "B" as B;
+
+contract C {
+    function f(bool b) public pure returns (uint) {
+        return (b ? A : B).f();
+    }
+}
+// ----
+// TypeError 1080: (C:116-125): True expression's type module "A" does not match false expression's type module "B".
diff --git a/compiler/test/libsolidity/syntaxTests/inheritance/too_few_base_arguments.sol b/compiler/test/libsolidity/syntaxTests/inheritance/too_few_base_arguments.sol
new file mode 100644
index 00000000..4042e008
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inheritance/too_few_base_arguments.sol
@@ -0,0 +1,10 @@
+contract Base {
+  constructor(uint, uint) {}
+}
+contract Derived is Base(2) { }
+contract Derived2 is Base {
+  constructor() Base(2) { }
+}
+// ----
+// TypeError 7927: (67-74): Wrong argument count for constructor call: 1 arguments given but expected 2
+// TypeError 2973: (123-130): Wrong argument count for modifier invocation: 1 arguments given but expected 2.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobbasefee_reserved_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobbasefee_reserved_cancun.sol
new file mode 100644
index 00000000..0bab7e36
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobbasefee_reserved_cancun.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            let blobbasefee := sload(0)
+            ret := blobbasefee
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (98-109): Cannot use builtin function name "blobbasefee" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash.sol
new file mode 100644
index 00000000..06eefc8a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public view returns (bytes32 ret) {
+        assembly {
+            ret := blobhash(1)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_declared.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_declared.sol
new file mode 100644
index 00000000..c0284b33
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_declared.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() pure external returns (bytes32 ret) {
+        assembly {
+            ret := blobhash()
+        }
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
+// DeclarationError 4619: (106-114): Function "blobhash" not found.
+// DeclarationError 8678: (99-116): Variable count for assignment to "ret" does not match number of values (1 vs. 0)
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_reserved.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_reserved.sol
new file mode 100644
index 00000000..1ac24cc6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_pre_cancun_not_reserved.sol
@@ -0,0 +1,19 @@
+contract C {
+    function f() public pure returns (uint ret) {
+        assembly {
+            let blobhash := 1
+            ret := blobhash
+        }
+    }
+    function g() public pure returns (uint ret) {
+        assembly {
+            function blobhash() -> r {
+                r := 1000
+            }
+            ret := blobhash()
+        }
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_reserved_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_reserved_cancun.sol
new file mode 100644
index 00000000..39bd68e1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/blobhash_reserved_cancun.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public pure returns (uint ret) {
+        assembly {
+            function blobhash() -> r {
+                r := 1000
+            }
+            ret := blobhash()
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (103-111): Cannot use builtin function name "blobhash" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_builtin_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_builtin_pre_paris.sol
new file mode 100644
index 00000000..13ea92c5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_builtin_pre_paris.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public view returns (uint256) {
+        return block.difficulty;
+    }
+
+    function g() public view returns (uint256 ret) {
+        assembly {
+            ret := difficulty()
+        }
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_disallowed_function_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_disallowed_function_pre_paris.sol
new file mode 100644
index 00000000..a177e8f6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_disallowed_function_pre_paris.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public view returns (uint256 ret) {
+        assembly {
+            let difficulty := sload(0)
+            ret := difficulty
+        }
+    }
+
+    function g() public pure returns (uint256 ret) {
+        assembly {
+            function difficulty() -> r {
+                r := 1000
+            }
+            ret := difficulty()
+        }
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// ParserError 5568: (101-111): Cannot use builtin function name "difficulty" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_magic_block_warn_post_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_magic_block_warn_post_paris.sol
new file mode 100644
index 00000000..8fb75340
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_magic_block_warn_post_paris.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (uint256) {
+        return block.difficulty;
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// Warning 8417: (77-93): Since the VM version paris, "difficulty" was replaced by "prevrandao", which now returns a random number based on the beacon chain.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_nobuiltin_post_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_nobuiltin_post_paris.sol
new file mode 100644
index 00000000..65fe4c15
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_nobuiltin_post_paris.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public {
+        assembly {
+            pop(difficulty())
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// DeclarationError 4619: (74-84): Function "difficulty" not found.
+// TypeError 3950: (74-86): Expected expression to evaluate to one value, but got 0 values instead.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_reserved_post_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_reserved_post_paris.sol
new file mode 100644
index 00000000..5121a110
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/difficulty_reserved_post_paris.sol
@@ -0,0 +1,22 @@
+contract C {
+    function f() public view returns (uint256 ret) {
+        assembly {
+            let difficulty := sload(0)
+            ret := difficulty
+        }
+    }
+
+    function g() public pure returns (uint256 ret) {
+        assembly {
+            function difficulty() -> r {
+                r := 1000
+            }
+            ret := difficulty()
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// DeclarationError 5017: (101-111): The identifier "difficulty" is reserved and can not be used.
+// DeclarationError 5017: (255-323): The identifier "difficulty" is reserved and can not be used.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy.sol
new file mode 100644
index 00000000..c300160e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public pure {
+        assembly {
+            mcopy(0, 0, 0)
+            mcopy(0x1000, 0x2000, 100)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_pre_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_pre_cancun.sol
new file mode 100644
index 00000000..090e2f62
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_pre_cancun.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        assembly {
+            mcopy()
+        }
+    }
+}
+// ====
+// EVMVersion: <cancun
+// ----
+// DeclarationError 4619: (75-80): Function "mcopy" not found.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_reserved_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_reserved_cancun.sol
new file mode 100644
index 00000000..b31bbffd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/mcopy_reserved_cancun.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public pure returns (uint result) {
+        assembly {
+            let mcopy := 1
+            result := mcopy
+        }
+    }
+
+    function g() public pure returns (uint result) {
+        assembly {
+            function mcopy() -> r {
+                r := 1000
+            }
+            result := mcopy()
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (101-106): Cannot use builtin function name "mcopy" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_allowed_function_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_allowed_function_pre_paris.sol
new file mode 100644
index 00000000..d85e77a4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_allowed_function_pre_paris.sol
@@ -0,0 +1,20 @@
+contract C {
+    function f() public view returns (uint256 ret) {
+        assembly {
+            let prevrandao := sload(0)
+            ret := prevrandao
+        }
+    }
+
+    function g() public pure returns (uint256 ret) {
+        assembly {
+            function prevrandao() -> r {
+                r := 1000
+            }
+            ret := prevrandao()
+        }
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_builtin_post_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_builtin_post_paris.sol
new file mode 100644
index 00000000..66dbc110
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_builtin_post_paris.sol
@@ -0,0 +1,14 @@
+contract C {
+    function f() public view returns (uint256) {
+        return block.prevrandao;
+    }
+
+    function g() public view returns (uint256 ret) {
+        assembly {
+            ret := prevrandao()
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_disallowed_function_post_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_disallowed_function_post_paris.sol
new file mode 100644
index 00000000..6c284a00
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_disallowed_function_post_paris.sol
@@ -0,0 +1,21 @@
+contract C {
+    function f() public view returns (uint256 ret) {
+        assembly {
+            let prevrandao := sload(0)
+            ret := prevrandao
+        }
+    }
+
+    function g() public pure returns (uint256 ret) {
+        assembly {
+            function prevrandao() -> r {
+                r := 1000
+            }
+            ret := prevrandao()
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// ParserError 5568: (101-111): Cannot use builtin function name "prevrandao" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_magic_block_warn_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_magic_block_warn_pre_paris.sol
new file mode 100644
index 00000000..2086892b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_magic_block_warn_pre_paris.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public view returns (uint256) {
+        return block.prevrandao;
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// Warning 9432: (77-93): "prevrandao" is not supported by the VM version and will be treated as "difficulty".
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_nobuitin_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_nobuitin_pre_paris.sol
new file mode 100644
index 00000000..34e77639
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/prevrandao_nobuitin_pre_paris.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public {
+        assembly {
+            pop(prevrandao())
+        }
+    }
+}
+// ====
+// EVMVersion: <paris
+// ----
+// DeclarationError 4619: (74-84): Function "prevrandao" not found.
+// TypeError 3950: (74-86): Expected expression to evaluate to one value, but got 0 values instead.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/push0_disallowed.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/push0_disallowed.sol
new file mode 100644
index 00000000..b1471ac5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/push0_disallowed.sol
@@ -0,0 +1,19 @@
+// Ok
+contract push0 {}
+
+contract A {
+    // Ok, warning about shadowing
+    function push0() external {}
+}
+
+contract C {
+    function f() external {
+        assembly {
+            // Not okay
+            push0()
+        }
+    }
+}
+// ----
+// Warning 2519: (77-105): This declaration shadows an existing declaration.
+// DeclarationError 4619: (205-210): Function "push0" not found.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/tload_reserved_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/tload_reserved_cancun.sol
new file mode 100644
index 00000000..77c98857
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/tload_reserved_cancun.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            let tload := sload(0)
+            ret := tload
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (98-103): Cannot use builtin function name "tload" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_invalid_pre_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_invalid_pre_cancun.sol
new file mode 100644
index 00000000..25ae9e9d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_invalid_pre_cancun.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        assembly {
+            tstore(0, 13)
+            tload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: <cancun
+// ----
+// DeclarationError 4619: (70-76): Function "tstore" not found.
+// DeclarationError 4619: (96-101): Function "tload" not found.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_opcodes.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_opcodes.sol
new file mode 100644
index 00000000..2009cdca
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/transient_storage_opcodes.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() external returns(uint a) {
+        assembly {
+            tstore(0, 13)
+            a := tload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2394: (88-94): Transient storage as defined by EIP-1153 can break the composability of smart contracts: Since transient storage is cleared only at the end of the transaction and not at the end of the outermost call frame to the contract within a transaction, your contract may unintentionally misbehave when invoked multiple times in a complex transaction. To avoid this, be sure to clear all transient storage at the end of any call to your contract. The use of transient storage for reentrancy guards that are cleared at the end of the call is safe.
diff --git a/compiler/test/libsolidity/syntaxTests/inlineAssembly/tstore_reserved_cancun.sol b/compiler/test/libsolidity/syntaxTests/inlineAssembly/tstore_reserved_cancun.sol
new file mode 100644
index 00000000..9f08d985
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inlineAssembly/tstore_reserved_cancun.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() public view returns (uint ret) {
+        assembly {
+            let tstore := sload(0)
+            ret := tstore
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (98-104): Cannot use builtin function name "tstore" as identifier name.
diff --git a/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_type_tuple_in_inline_array.sol b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_type_tuple_in_inline_array.sol
new file mode 100644
index 00000000..21f112c5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_type_tuple_in_inline_array.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        [(1, 2, 3), (4, 5, 6)];
+    }
+}
+// ----
+// TypeError 9656: (47-69): Unable to deduce nameable type for array elements. Try adding explicit type conversion for the first element.
diff --git a/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_1.sol b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_1.sol
new file mode 100644
index 00000000..b848b7b1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_1.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        [msg];
+    }
+}
+// ----
+// TypeError 9563: (48-51): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_2.sol b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_2.sol
new file mode 100644
index 00000000..7f659209
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_2.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        [type(C)];
+    }
+}
+// ----
+// TypeError 9563: (48-55): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_3.sol b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_3.sol
new file mode 100644
index 00000000..78c5493e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/inline_arrays/unnamed_types_in_inline_array_3.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public pure {
+        [uint];
+    }
+}
+// ----
+// TypeError 9563: (53-57): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero.sol b/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero.sol
new file mode 100644
index 00000000..5685084d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint constant a = 1 / 0;
+}
+// ----
+// TypeError 2271: (35-40): Built-in binary operator / cannot be applied to types int_const 1 and int_const 0.
diff --git a/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero_complex.sol b/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero_complex.sol
new file mode 100644
index 00000000..195336e2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literalOperations/division_by_zero_complex.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint constant a = 1 / ((1+3)-4);
+}
+// ----
+// TypeError 2271: (35-48): Built-in binary operator / cannot be applied to types int_const 1 and int_const 0.
diff --git a/compiler/test/libsolidity/syntaxTests/literalOperations/exponent.sol b/compiler/test/libsolidity/syntaxTests/literalOperations/exponent.sol
new file mode 100644
index 00000000..72dc5ecd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literalOperations/exponent.sol
@@ -0,0 +1,10 @@
+contract C {
+    function g() public pure {
+        int a;
+        a ** 1E1233;
+        a ** (1/2);
+    }
+}
+// ----
+// TypeError 2271: (67-78): Built-in binary operator ** cannot be applied to types int256 and int_const 1000...(1226 digits omitted)...0000. Exponent too large.
+// TypeError 2271: (88-98): Built-in binary operator ** cannot be applied to types int256 and rational_const 1 / 2. Exponent is fractional.
diff --git a/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero.sol b/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero.sol
new file mode 100644
index 00000000..b4ca4d27
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint constant b3 = 1 % 0;
+}
+// ----
+// TypeError 2271: (36-41): Built-in binary operator % cannot be applied to types int_const 1 and int_const 0.
diff --git a/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero_complex.sol b/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero_complex.sol
new file mode 100644
index 00000000..73cbd71f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literalOperations/mod_zero_complex.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint constant b3 = 1 % (-4+((2)*2));
+}
+// ----
+// TypeError 2271: (36-52): Built-in binary operator % cannot be applied to types int_const 1 and int_const 0.
diff --git a/compiler/test/libsolidity/syntaxTests/literals/invalid_hex_number.sol b/compiler/test/libsolidity/syntaxTests/literals/invalid_hex_number.sol
new file mode 100644
index 00000000..1cc7e0ec
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literals/invalid_hex_number.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint x = 0x1000abcdefgh;
+}
+// ----
+// ParserError 8936: (26-38): Identifier-start is not allowed at end of a number.
diff --git a/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_denomination_no_whitespace.sol b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_denomination_no_whitespace.sol
new file mode 100644
index 00000000..a4ec101c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_denomination_no_whitespace.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint y = 01gwei;
+}
+// ----
+// ParserError 8936: (26-27): Octal numbers not allowed.
diff --git a/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_digits.sol b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_digits.sol
new file mode 100644
index 00000000..8565377a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_digits.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint y = 098;
+}
+// ----
+// ParserError 8936: (26-27): Octal numbers not allowed.
diff --git a/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_number.sol b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_number.sol
new file mode 100644
index 00000000..668913be
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/literals/invalid_octal_number.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint x = 0100;
+}
+// ----
+// ParserError 8936: (26-27): Octal numbers not allowed.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/array_type_from_ternary.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/array_type_from_ternary.sol
new file mode 100644
index 00000000..b4f11310
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/array_type_from_ternary.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(bool c) public {
+        (c ? uint[2] : uint[2])[3];
+    }
+}
+// ----
+// TypeError 9717: (58-65): Invalid mobile type in true expression.
+// TypeError 3703: (68-75): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/contract_from_ternary.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/contract_from_ternary.sol
new file mode 100644
index 00000000..7f4f1755
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/contract_from_ternary.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure { }
+    function g(bool c) public {
+        (c ? C : C).f();
+    }
+}
+// ----
+// TypeError 9717: (91-92): Invalid mobile type in true expression.
+// TypeError 3703: (95-96): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/explicit_type_conversion.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/explicit_type_conversion.sol
new file mode 100644
index 00000000..3afd4d29
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/explicit_type_conversion.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(bool c) pure public returns (int) {
+        return (c ? int : int)(0);
+    }
+}
+// ----
+// TypeError 9717: (84-87): Invalid mobile type in true expression.
+// TypeError 3703: (90-93): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/integer_err.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/integer_err.sol
new file mode 100644
index 00000000..7e703b72
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/integer_err.sol
@@ -0,0 +1,15 @@
+contract Test {
+    function assignment() public {
+        uint8 uint8Min = type(int).min;
+        uint uintMin = type(int).min;
+
+        if (type(int).min == 2**256 - 1) {
+            uintMin;
+        }
+
+    }
+}
+// ----
+// TypeError 9574: (59-89): Type int256 is not implicitly convertible to expected type uint8.
+// TypeError 9574: (99-127): Type int256 is not implicitly convertible to expected type uint256.
+// TypeError 2271: (142-169): Built-in binary operator == cannot be applied to types int256 and int_const 1157...(70 digits omitted)...9935.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/library_from_ternary.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/library_from_ternary.sol
new file mode 100644
index 00000000..e1e147a1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/library_from_ternary.sol
@@ -0,0 +1,12 @@
+library L {
+    function f() public pure { }
+}
+
+contract C {
+    function g(bool c) public {
+        (c ? L : L).f();
+    }
+}
+// ----
+// TypeError 9717: (106-107): Invalid mobile type in true expression.
+// TypeError 3703: (110-111): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/max_keyword_from_ternary_with_type_expression.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/max_keyword_from_ternary_with_type_expression.sol
new file mode 100644
index 00000000..ce4a1262
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/max_keyword_from_ternary_with_type_expression.sol
@@ -0,0 +1,8 @@
+contract C {
+    function max(bool isUint) pure public returns (uint8) {
+        return (isUint ? type(uint8) : type(int8)).max;
+    }
+}
+// ----
+// TypeError 9717: (98-109): Invalid mobile type in true expression.
+// TypeError 3703: (112-122): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/runtimeCode_from_ternary_with_type_expression.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/runtimeCode_from_ternary_with_type_expression.sol
new file mode 100644
index 00000000..b2b9b2ad
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/runtimeCode_from_ternary_with_type_expression.sol
@@ -0,0 +1,16 @@
+contract A {
+    function f() public {}
+}
+
+contract B {
+    function g() public {}
+}
+
+contract C {
+    function ab(bool getA) pure public returns (bytes memory) {
+        return (getA ? type(A) : type(B)).runtimeCode;
+    }
+}
+// ----
+// TypeError 9717: (186-193): Invalid mobile type in true expression.
+// TypeError 3703: (196-203): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/struct_from_ternary.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/struct_from_ternary.sol
new file mode 100644
index 00000000..5d531d23
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/struct_from_ternary.sol
@@ -0,0 +1,14 @@
+struct S {
+    uint x;
+    uint y;
+    uint z;
+}
+
+contract C {
+    function f(bool c) public pure {
+        S memory s = (c ? S : S)(0, 1, 2);
+    }
+}
+// ----
+// TypeError 9717: (126-127): Invalid mobile type in true expression.
+// TypeError 3703: (130-131): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_nested_ternary_max_keyword.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_nested_ternary_max_keyword.sol
new file mode 100644
index 00000000..9e926738
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_nested_ternary_max_keyword.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(bool b) public pure returns (uint) {
+        return type(b ? uint : uint).max;
+    }
+}
+// ----
+// TypeError 9717: (89-93): Invalid mobile type in true expression.
+// TypeError 3703: (96-100): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_tuple_max.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_tuple_max.sol
new file mode 100644
index 00000000..c5a5e82c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_expression_tuple_max.sol
@@ -0,0 +1,6 @@
+contract C {
+    function max() public pure returns (uint8) {
+        return (type(uint8)).max;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_from_ternary_condition.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_from_ternary_condition.sol
new file mode 100644
index 00000000..b0156417
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_from_ternary_condition.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(bool c) pure public {
+        type(c ? uint : uint);
+    }
+}
+// ----
+// TypeError 9717: (67-71): Invalid mobile type in true expression.
+// TypeError 3703: (74-78): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_max.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_max.sol
new file mode 100644
index 00000000..4d3b5886
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_max.sol
@@ -0,0 +1,6 @@
+contract C {
+    function max() public pure returns (uint8) {
+        return type(uint8).max;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_max_from_ternary_expression.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_max_from_ternary_expression.sol
new file mode 100644
index 00000000..873b2e67
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_max_from_ternary_expression.sol
@@ -0,0 +1,8 @@
+contract C {
+    function max(bool isUint) public returns (uint8) {
+        return (isUint ? type(uint8) : type(int8)).max;
+    }
+}
+// ----
+// TypeError 9717: (93-104): Invalid mobile type in true expression.
+// TypeError 3703: (107-117): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol
new file mode 100644
index 00000000..6b054b4d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode.sol
@@ -0,0 +1,9 @@
+contract A {
+}
+
+contract C {
+    function f() public pure returns (bytes memory) {
+        return type(A).runtimeCode;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol b/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol
new file mode 100644
index 00000000..8fcf6548
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/metaTypes/type_runtimecode_from_ternary_expression_.sol
@@ -0,0 +1,14 @@
+contract A {
+}
+
+contract B {
+}
+
+contract C {
+    function f(bool getA) public returns (bytes memory) {
+        return (getA ? type(A) : type(B)).runtimeCode;
+    }
+}
+// ----
+// TypeError 9717: (126-133): Invalid mobile type in true expression.
+// TypeError 3703: (136-143): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/modifiers/elementary_non_address_state_mutability_modifier_argument.sol b/compiler/test/libsolidity/syntaxTests/modifiers/elementary_non_address_state_mutability_modifier_argument.sol
new file mode 100644
index 00000000..568743b3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/modifiers/elementary_non_address_state_mutability_modifier_argument.sol
@@ -0,0 +1,85 @@
+contract C {
+    modifier a(bool payable) {}
+    modifier b(string payable) {}
+    modifier c(int payable) {}
+    modifier d(int256 payable) {}
+    modifier e(uint payable) {}
+    modifier f(uint256 payable) {}
+    modifier g(bytes1 payable) {}
+    modifier h(bytes payable) {}
+    modifier i(bytes32 payable) {}
+    modifier j(fixed payable) {}
+    modifier k(fixed80x80 payable) {}
+    modifier l(ufixed payable) {}
+    modifier m(ufixed80x80 payable) {}
+}
+contract C2 {
+    modifier a(bool view) {}
+    modifier b(string view) {}
+    modifier c(int view) {}
+    modifier d(int256 view) {}
+    modifier e(uint view) {}
+    modifier f(uint256 view) {}
+    modifier g(bytes1 view) {}
+    modifier h(bytes view) {}
+    modifier i(bytes32 view) {}
+    modifier j(fixed view) {}
+    modifier k(fixed80x80 view) {}
+    modifier l(ufixed view) {}
+    modifier m(ufixed80x80 view) {}
+}
+contract C3 {
+    modifier a(bool pure) {}
+    modifier b(string pure) {}
+    modifier c(int pure) {}
+    modifier d(int256 pure) {}
+    modifier e(uint pure) {}
+    modifier f(uint256 pure) {}
+    modifier g(bytes1 pure) {}
+    modifier h(bytes pure) {}
+    modifier i(bytes32 pure) {}
+    modifier j(fixed pure) {}
+    modifier k(fixed80x80 pure) {}
+    modifier l(ufixed pure) {}
+    modifier m(ufixed80x80 pure) {}
+}
+// ----
+// ParserError 9106: (33-40): State mutability can only be specified for address types.
+// ParserError 9106: (67-74): State mutability can only be specified for address types.
+// ParserError 9106: (98-105): State mutability can only be specified for address types.
+// ParserError 9106: (132-139): State mutability can only be specified for address types.
+// ParserError 9106: (164-171): State mutability can only be specified for address types.
+// ParserError 9106: (199-206): State mutability can only be specified for address types.
+// ParserError 9106: (233-240): State mutability can only be specified for address types.
+// ParserError 9106: (266-273): State mutability can only be specified for address types.
+// ParserError 9106: (301-308): State mutability can only be specified for address types.
+// ParserError 9106: (334-341): State mutability can only be specified for address types.
+// ParserError 9106: (372-379): State mutability can only be specified for address types.
+// ParserError 9106: (406-413): State mutability can only be specified for address types.
+// ParserError 9106: (445-452): State mutability can only be specified for address types.
+// ParserError 9106: (493-497): State mutability can only be specified for address types.
+// ParserError 9106: (524-528): State mutability can only be specified for address types.
+// ParserError 9106: (552-556): State mutability can only be specified for address types.
+// ParserError 9106: (583-587): State mutability can only be specified for address types.
+// ParserError 9106: (612-616): State mutability can only be specified for address types.
+// ParserError 9106: (644-648): State mutability can only be specified for address types.
+// ParserError 9106: (675-679): State mutability can only be specified for address types.
+// ParserError 9106: (705-709): State mutability can only be specified for address types.
+// ParserError 9106: (737-741): State mutability can only be specified for address types.
+// ParserError 9106: (767-771): State mutability can only be specified for address types.
+// ParserError 9106: (802-806): State mutability can only be specified for address types.
+// ParserError 9106: (833-837): State mutability can only be specified for address types.
+// ParserError 9106: (869-873): State mutability can only be specified for address types.
+// ParserError 9106: (914-918): State mutability can only be specified for address types.
+// ParserError 9106: (945-949): State mutability can only be specified for address types.
+// ParserError 9106: (973-977): State mutability can only be specified for address types.
+// ParserError 9106: (1004-1008): State mutability can only be specified for address types.
+// ParserError 9106: (1033-1037): State mutability can only be specified for address types.
+// ParserError 9106: (1065-1069): State mutability can only be specified for address types.
+// ParserError 9106: (1096-1100): State mutability can only be specified for address types.
+// ParserError 9106: (1126-1130): State mutability can only be specified for address types.
+// ParserError 9106: (1158-1162): State mutability can only be specified for address types.
+// ParserError 9106: (1188-1192): State mutability can only be specified for address types.
+// ParserError 9106: (1223-1227): State mutability can only be specified for address types.
+// ParserError 9106: (1254-1258): State mutability can only be specified for address types.
+// ParserError 9106: (1290-1294): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_indexed.sol b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_indexed.sol
new file mode 100644
index 00000000..a19d7beb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_indexed.sol
@@ -0,0 +1,5 @@
+contract B {
+    modifier mod1(uint indexed a) { _; }
+}
+// ----
+// ParserError 2314: (36-43): Expected ',' but got 'indexed'
diff --git a/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_mutability.sol b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_mutability.sol
new file mode 100644
index 00000000..f23861eb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_mutability.sol
@@ -0,0 +1,7 @@
+contract A {
+    modifier mod1(uint constant a) { _; }
+    modifier mod2(uint immutable a) { _; }
+}
+// ----
+// DeclarationError 1788: (31-46): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 8297: (73-89): The "immutable" keyword can only be used for state variables.
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_visibility.sol b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_visibility.sol
new file mode 100644
index 00000000..0ef9e5c0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/modifiers/invalid_parameter_visibility.sol
@@ -0,0 +1,21 @@
+==== Source: A ====
+contract A {
+    modifier mod(uint internal a) { _; }
+}
+==== Source: B ====
+contract A {
+    modifier mod(uint external a) { _; }
+}
+==== Source: C ====
+contract A {
+    modifier mod(uint public a) { _; }
+}
+==== Source: D ====
+contract A {
+    modifier mod(uint private a) { _; }
+}
+// ----
+// ParserError 2314: (A:35-43): Expected ',' but got 'internal'
+// ParserError 2314: (B:35-43): Expected ',' but got 'external'
+// ParserError 2314: (C:35-41): Expected ',' but got 'public'
+// ParserError 2314: (D:35-42): Expected ',' but got 'private'
diff --git a/compiler/test/libsolidity/syntaxTests/modifiers/multiple_parameter_location.sol b/compiler/test/libsolidity/syntaxTests/modifiers/multiple_parameter_location.sol
new file mode 100644
index 00000000..e264a593
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/modifiers/multiple_parameter_location.sol
@@ -0,0 +1,21 @@
+contract A {
+    modifier mod1(string storage storage a) { _; }
+    modifier mod2(string storage memory a) { _; }
+    modifier mod3(string storage calldata a) { _; }
+    modifier mod4(string memory storage a) { _; }
+    modifier mod5(string memory memory a) { _; }
+    modifier mod6(string memory calldata a) { _; }
+    modifier mod7(string calldata storage a) { _; }
+    modifier mod8(string calldata memory a) { _; }
+    modifier mod9(string calldata calldata a) { _; }
+}
+// ----
+// ParserError 3548: (46-53): Location already specified.
+// ParserError 3548: (97-103): Location already specified.
+// ParserError 3548: (147-155): Location already specified.
+// ParserError 3548: (198-205): Location already specified.
+// ParserError 3548: (248-254): Location already specified.
+// ParserError 3548: (297-305): Location already specified.
+// ParserError 3548: (350-357): Location already specified.
+// ParserError 3548: (402-408): Location already specified.
+// ParserError 3548: (453-461): Location already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/011_type_conversion_for_comparison_invalid.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/011_type_conversion_for_comparison_invalid.sol
new file mode 100644
index 00000000..f191d447
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/011_type_conversion_for_comparison_invalid.sol
@@ -0,0 +1,5 @@
+contract test {
+    function f() public { int32(2) == uint64(2); }
+}
+// ----
+// TypeError 2271: (42-63): Built-in binary operator == cannot be applied to types int32 and uint64.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/025_comparison_of_mapping_types.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/025_comparison_of_mapping_types.sol
new file mode 100644
index 00000000..d31f5fa3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/025_comparison_of_mapping_types.sol
@@ -0,0 +1,9 @@
+contract C {
+    mapping(uint => uint) x;
+    function f() public returns (bool ret) {
+        mapping(uint => uint) storage y = x;
+        return x == y;
+    }
+}
+// ----
+// TypeError 2271: (147-153): Built-in binary operator == cannot be applied to types mapping(uint256 => uint256) and mapping(uint256 => uint256).
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/061_missing_base_constructor_arguments.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/061_missing_base_constructor_arguments.sol
new file mode 100644
index 00000000..83119653
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/061_missing_base_constructor_arguments.sol
@@ -0,0 +1,4 @@
+contract A { constructor(uint a) { } }
+contract B is A { }
+// ----
+// TypeError 3415: (39-58): No arguments passed to the base constructor. Specify the arguments or mark "B" as abstract.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/062_base_constructor_arguments_override.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/062_base_constructor_arguments_override.sol
new file mode 100644
index 00000000..bdca8fdd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/062_base_constructor_arguments_override.sol
@@ -0,0 +1,4 @@
+contract A { constructor(uint a) { } }
+contract B is A { constructor(bytes4 a, bytes28 b) { } }
+// ----
+// TypeError 3415: (39-95): No arguments passed to the base constructor. Specify the arguments or mark "B" as abstract.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/112_exp_operator_exponent_too_big.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/112_exp_operator_exponent_too_big.sol
new file mode 100644
index 00000000..ea571b72
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/112_exp_operator_exponent_too_big.sol
@@ -0,0 +1,5 @@
+contract test {
+    function f() public returns (uint d) { return 2 ** 10000000000; }
+}
+// ----
+// TypeError 2271: (66-82): Built-in binary operator ** cannot be applied to types int_const 2 and int_const 10000000000.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/196_integer_boolean_or.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/196_integer_boolean_or.sol
new file mode 100644
index 00000000..e3e0dd2a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/196_integer_boolean_or.sol
@@ -0,0 +1,3 @@
+contract test { fallback() external { uint x = 1; uint y = 2; x || y; } }
+// ----
+// TypeError 2271: (62-68): Built-in binary operator || cannot be applied to types uint256 and uint256.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/197_integer_boolean_and.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/197_integer_boolean_and.sol
new file mode 100644
index 00000000..d8141a2a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/197_integer_boolean_and.sol
@@ -0,0 +1,3 @@
+contract test { fallback() external { uint x = 1; uint y = 2; x && y; } }
+// ----
+// TypeError 2271: (62-68): Built-in binary operator && cannot be applied to types uint256 and uint256.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/198_integer_boolean_not.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/198_integer_boolean_not.sol
new file mode 100644
index 00000000..83c39fbd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/198_integer_boolean_not.sol
@@ -0,0 +1,3 @@
+contract test { fallback() external { uint x = 1; !x; } }
+// ----
+// TypeError 4907: (50-52): Built-in unary operator ! cannot be applied to type uint256.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/199_integer_unsigned_exp_signed.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/199_integer_unsigned_exp_signed.sol
new file mode 100644
index 00000000..5f5e8209
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/199_integer_unsigned_exp_signed.sol
@@ -0,0 +1,3 @@
+contract test { fallback() external { uint x = 3; int y = -4; x ** y; } }
+// ----
+// TypeError 2271: (62-68): Built-in binary operator ** cannot be applied to types uint256 and int256. Exponentiation power is not allowed to be a signed integer type.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/201_integer_signed_exp_signed.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/201_integer_signed_exp_signed.sol
new file mode 100644
index 00000000..f7f3df91
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/201_integer_signed_exp_signed.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f() public { int x = 3; int y = 4; x ** y; }
+    function h() public { uint8 x = 3; int16 y = 4; x ** y; }
+    function i() public { int16 x = 4; x ** -3; }
+}
+// ----
+// TypeError 2271: (64-70): Built-in binary operator ** cannot be applied to types int256 and int256. Exponentiation power is not allowed to be a signed integer type.
+// TypeError 2271: (126-132): Built-in binary operator ** cannot be applied to types uint8 and int16. Exponentiation power is not allowed to be a signed integer type.
+// Warning 3149: (126-132): The result type of the exponentiation operation is equal to the type of the first operand (uint8) ignoring the (larger) type of the second operand (int16) which might be unexpected. Silence this warning by either converting the first or the second operand to the type of the other.
+// TypeError 2271: (175-182): Built-in binary operator ** cannot be applied to types int16 and int_const -3. Exponentiation power is not allowed to be a negative integer literal.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/202_bytes_reference_compare_operators.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/202_bytes_reference_compare_operators.sol
new file mode 100644
index 00000000..064afd46
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/202_bytes_reference_compare_operators.sol
@@ -0,0 +1,3 @@
+contract test { bytes a; bytes b; fallback() external { a == b; } }
+// ----
+// TypeError 2271: (56-62): Built-in binary operator == cannot be applied to types bytes storage ref and bytes storage ref.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/203_struct_reference_compare_operators.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/203_struct_reference_compare_operators.sol
new file mode 100644
index 00000000..1cf46ac8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/203_struct_reference_compare_operators.sol
@@ -0,0 +1,10 @@
+contract test {
+  struct s {uint a;}
+  s x;
+  s y;
+  fallback() external {
+    x == y;
+  }
+}
+// ----
+// TypeError 2271: (79-85): Built-in binary operator == cannot be applied to types struct test.s storage ref and struct test.s storage ref. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/213_no_delete_on_storage_pointers.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/213_no_delete_on_storage_pointers.sol
new file mode 100644
index 00000000..7d452197
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/213_no_delete_on_storage_pointers.sol
@@ -0,0 +1,9 @@
+contract C {
+    uint[] data;
+    function f() public {
+        uint[] storage x = data;
+        delete x;
+    }
+}
+// ----
+// TypeError 9767: (97-105): Built-in unary operator delete cannot be applied to type uint256[] storage pointer.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/259_using_for_not_used.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/259_using_for_not_used.sol
new file mode 100644
index 00000000..819ef969
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/259_using_for_not_used.sol
@@ -0,0 +1,11 @@
+library D { function double(uint self) public returns (uint) { return 2; } }
+contract C {
+    using D for uint;
+    function f(uint16 a) public returns (uint) {
+        // This is an error because the function is only attached to uint.
+        // Had it been attached to *, it would have worked.
+        return a.double();
+    }
+}
+// ----
+// TypeError 9582: (311-319): Member "double" not found or not visible after argument-dependent lookup in uint16.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/261_using_for_arbitrary_mismatch.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/261_using_for_arbitrary_mismatch.sol
new file mode 100644
index 00000000..f0076a15
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/261_using_for_arbitrary_mismatch.sol
@@ -0,0 +1,10 @@
+library D { function double(bytes32 self) public returns (uint) { return 2; } }
+contract C {
+    using D for *;
+    function f(uint a) public returns (uint) {
+        // Attached to a, but self type does not match.
+        return a.double();
+    }
+}
+// ----
+// TypeError 9582: (230-238): Member "double" not found or not visible after argument-dependent lookup in uint256.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/291_modifier_is_not_a_valid_typename.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/291_modifier_is_not_a_valid_typename.sol
new file mode 100644
index 00000000..30f240c1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/291_modifier_is_not_a_valid_typename.sol
@@ -0,0 +1,9 @@
+contract test {
+    modifier mod() { _; }
+
+    function f() public {
+        mod g;
+    }
+}
+// ----
+// TypeError 5172: (77-80): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/292_modifier_is_not_a_valid_typename_is_not_fatal.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/292_modifier_is_not_a_valid_typename_is_not_fatal.sol
new file mode 100644
index 00000000..92d77755
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/292_modifier_is_not_a_valid_typename_is_not_fatal.sol
@@ -0,0 +1,10 @@
+contract test {
+    modifier mod() { _; }
+
+    function f() public {
+        mod g;
+        g = f;
+    }
+}
+// ----
+// TypeError 5172: (77-80): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/293_function_is_not_a_valid_typename.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/293_function_is_not_a_valid_typename.sol
new file mode 100644
index 00000000..66ff7cf3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/293_function_is_not_a_valid_typename.sol
@@ -0,0 +1,10 @@
+contract test {
+    function foo() public {
+    }
+
+    function f() public {
+        foo g;
+    }
+}
+// ----
+// TypeError 5172: (85-88): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/308_rational_unary_plus_operation.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/308_rational_unary_plus_operation.sol
new file mode 100644
index 00000000..29d29b46
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/308_rational_unary_plus_operation.sol
@@ -0,0 +1,9 @@
+contract test {
+    function f() pure public {
+        ufixed16x2 a = +3.25;
+        fixed16x2 b = -3.25;
+        a; b;
+    }
+}
+// ----
+// ParserError 9636: (70-71): Use of unary + is disallowed.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/329_rational_as_exponent_value_signed.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/329_rational_as_exponent_value_signed.sol
new file mode 100644
index 00000000..d604ac7b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/329_rational_as_exponent_value_signed.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        fixed g = 2 ** -2.2;
+    }
+}
+// ----
+// TypeError 2271: (60-69): Built-in binary operator ** cannot be applied to types int_const 2 and rational_const -11 / 5.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/330_rational_as_exponent_value_unsigned.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/330_rational_as_exponent_value_unsigned.sol
new file mode 100644
index 00000000..80039752
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/330_rational_as_exponent_value_unsigned.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        ufixed b = 3 ** 2.5;
+    }
+}
+// ----
+// TypeError 2271: (61-69): Built-in binary operator ** cannot be applied to types int_const 3 and rational_const 5 / 2.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/331_rational_as_exponent_half.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/331_rational_as_exponent_half.sol
new file mode 100644
index 00000000..e2843d34
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/331_rational_as_exponent_half.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        2 ** (1/2);
+    }
+}
+// ----
+// TypeError 2271: (50-60): Built-in binary operator ** cannot be applied to types int_const 2 and rational_const 1 / 2.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/332_rational_as_exponent_value_neg_quarter.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/332_rational_as_exponent_value_neg_quarter.sol
new file mode 100644
index 00000000..5b84f1a5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/332_rational_as_exponent_value_neg_quarter.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        42 ** (-1/4);
+    }
+}
+// ----
+// TypeError 2271: (50-62): Built-in binary operator ** cannot be applied to types int_const 42 and rational_const -1 / 4.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/333_fixed_point_casting_exponents_15.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/333_fixed_point_casting_exponents_15.sol
new file mode 100644
index 00000000..3c7082f1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/333_fixed_point_casting_exponents_15.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        ufixed a = 3 ** ufixed(1.5);
+    }
+}
+// ----
+// TypeError 2271: (61-77): Built-in binary operator ** cannot be applied to types int_const 3 and ufixed128x18. Exponent is fractional.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/334_fixed_point_casting_exponents_neg.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/334_fixed_point_casting_exponents_neg.sol
new file mode 100644
index 00000000..c462d501
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/334_fixed_point_casting_exponents_neg.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        ufixed c = 42 ** fixed(-1/4);
+    }
+}
+// ----
+// TypeError 2271: (61-78): Built-in binary operator ** cannot be applied to types int_const 42 and fixed128x18. Exponent is fractional.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/338_rational_bitnot_unary_operation.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/338_rational_bitnot_unary_operation.sol
new file mode 100644
index 00000000..46cda0a1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/338_rational_bitnot_unary_operation.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        ~fixed(3.5);
+    }
+}
+// ----
+// TypeError 4907: (50-61): Built-in unary operator ~ cannot be applied to type fixed128x18.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/339_rational_bitor_binary_operation.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/339_rational_bitor_binary_operation.sol
new file mode 100644
index 00000000..93cbd9ce
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/339_rational_bitor_binary_operation.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        fixed(1.5) | 3;
+    }
+}
+// ----
+// TypeError 2271: (50-64): Built-in binary operator | cannot be applied to types fixed128x18 and int_const 3.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/340_rational_bitxor_binary_operation.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/340_rational_bitxor_binary_operation.sol
new file mode 100644
index 00000000..d8792c6b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/340_rational_bitxor_binary_operation.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        fixed(1.75) ^ 3;
+    }
+}
+// ----
+// TypeError 2271: (50-65): Built-in binary operator ^ cannot be applied to types fixed128x18 and int_const 3.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/341_rational_bitand_binary_operation.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/341_rational_bitand_binary_operation.sol
new file mode 100644
index 00000000..0cd2d7f2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/341_rational_bitand_binary_operation.sol
@@ -0,0 +1,7 @@
+contract test {
+    function f() public {
+        fixed(1.75) & 3;
+    }
+}
+// ----
+// TypeError 2271: (50-65): Built-in binary operator & cannot be applied to types fixed128x18 and int_const 3.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/368_shift_constant_left_negative_rvalue.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/368_shift_constant_left_negative_rvalue.sol
new file mode 100644
index 00000000..6cbf0582
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/368_shift_constant_left_negative_rvalue.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint public a = 0x42 << -8;
+}
+// ----
+// TypeError 2271: (33-43): Built-in binary operator << cannot be applied to types int_const 66 and int_const -8.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/369_shift_constant_right_negative_rvalue.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/369_shift_constant_right_negative_rvalue.sol
new file mode 100644
index 00000000..b7eca3d2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/369_shift_constant_right_negative_rvalue.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint public a = 0x42 >> -8;
+}
+// ----
+// TypeError 2271: (33-43): Built-in binary operator >> cannot be applied to types int_const 66 and int_const -8.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/370_shift_constant_left_excessive_rvalue.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/370_shift_constant_left_excessive_rvalue.sol
new file mode 100644
index 00000000..4272c357
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/370_shift_constant_left_excessive_rvalue.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint public a = 0x42 << 0x100000000;
+}
+// ----
+// TypeError 2271: (33-52): Built-in binary operator << cannot be applied to types int_const 66 and int_const 4294967296.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/371_shift_constant_right_excessive_rvalue.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/371_shift_constant_right_excessive_rvalue.sol
new file mode 100644
index 00000000..2c3cec95
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/371_shift_constant_right_excessive_rvalue.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint public a = 0x42 >> 0x100000000;
+}
+// ----
+// TypeError 2271: (33-52): Built-in binary operator >> cannot be applied to types int_const 66 and int_const 4294967296.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/372_shift_constant_right_fractional.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/372_shift_constant_right_fractional.sol
new file mode 100644
index 00000000..913572d4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/372_shift_constant_right_fractional.sol
@@ -0,0 +1,5 @@
+contract C {
+    uint public a = 0x42 >> (1 / 2);
+}
+// ----
+// TypeError 2271: (33-48): Built-in binary operator >> cannot be applied to types int_const 66 and rational_const 1 / 2.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/462_callable_crash.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/462_callable_crash.sol
new file mode 100644
index 00000000..1f9e7a1a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/462_callable_crash.sol
@@ -0,0 +1,9 @@
+contract C {
+    struct S { uint a; bool x; }
+    S public s;
+    constructor() {
+        3({a: 1, x: true});
+    }
+}
+// ----
+// TypeError 5704: (90-108): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/492_do_not_crash_on_not_lvalue.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/492_do_not_crash_on_not_lvalue.sol
new file mode 100644
index 00000000..d46920d1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/492_do_not_crash_on_not_lvalue.sol
@@ -0,0 +1,9 @@
+// This checks for a bug that caused a crash because of continued analysis.
+contract C {
+    mapping (uint => uint) m;
+    function f() public {
+        m(1) = 2;
+    }
+}
+// ----
+// TypeError 5704: (153-157): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/525_reject_interface_constructors.sol b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/525_reject_interface_constructors.sol
new file mode 100644
index 00000000..88396f8c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/nameAndTypeResolution/525_reject_interface_constructors.sol
@@ -0,0 +1,4 @@
+interface I {}
+contract C is I(2) {}
+// ----
+// TypeError 7927: (29-33): Wrong argument count for constructor call: 1 arguments given but expected 0
diff --git a/compiler/test/libsolidity/syntaxTests/negation.sol b/compiler/test/libsolidity/syntaxTests/negation.sol
new file mode 100644
index 00000000..c5805f4f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/negation.sol
@@ -0,0 +1,9 @@
+contract test {
+    function f() public pure {
+        int x;
+        uint y = uint(-x);
+        -y;
+    }
+}
+// ----
+// TypeError 4907: (97-99): Built-in unary operator - cannot be applied to type uint256. Unary negation is only allowed for signed integers.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/calling_operator_binary_user_defined_not_available.sol b/compiler/test/libsolidity/syntaxTests/operators/calling_operator_binary_user_defined_not_available.sol
new file mode 100644
index 00000000..ea0c8f9d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/calling_operator_binary_user_defined_not_available.sol
@@ -0,0 +1,11 @@
+type Int is int256;
+
+function f() pure {
+    Int a = Int.wrap(0);
+    a + a;
+    a >>> a;
+}
+
+// ----
+// TypeError 2271: (70-75): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 2271: (81-88): Built-in binary operator >>> cannot be applied to types Int and Int.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/calling_operator_unary_user_defined_not_available.sol b/compiler/test/libsolidity/syntaxTests/operators/calling_operator_unary_user_defined_not_available.sol
new file mode 100644
index 00000000..29273852
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/calling_operator_unary_user_defined_not_available.sol
@@ -0,0 +1,11 @@
+type Int is int256;
+
+function f() pure {
+    Int a = Int.wrap(0);
+    -a;
+    a++;
+}
+
+// ----
+// TypeError 4907: (70-72): Built-in unary operator - cannot be applied to type Int. No matching user-defined operator found.
+// TypeError 9767: (78-81): Built-in unary operator ++ cannot be applied to type Int.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator.sol
new file mode 100644
index 00000000..a00eb2ce
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator.sol
@@ -0,0 +1,11 @@
+type Int is int;
+using {add as +} for Int global;
+using {unsub as -} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+function f() pure {
+    Int.wrap(0) + Int.wrap(0);
+    -Int.wrap(0);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_function_name.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_function_name.sol
new file mode 100644
index 00000000..6c1baa4b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_function_name.sol
@@ -0,0 +1,12 @@
+type Int is int16;
+
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+
+function f() {
+    Int a;
+    a.add(a);
+}
+// ----
+// TypeError 9582: (130-135): Member "add" not found or not visible after argument-dependent lookup in Int.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_operator_name.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_operator_name.sol
new file mode 100644
index 00000000..62c53cb8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_as_attached_function_via_operator_name.sol
@@ -0,0 +1,12 @@
+type Int is int16;
+
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+
+function f() {
+    Int a;
+    a.+(a);
+}
+// ----
+// ParserError 2314: (132-133): Expected identifier but got '+'
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type.sol
new file mode 100644
index 00000000..82785393
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type.sol
@@ -0,0 +1,23 @@
+==== Source: definition.sol ====
+import "type-and-binding.sol";
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+==== Source: type-and-binding.sol ====
+import "definition.sol";
+
+type Int is int;
+
+using {add as +} for Int global;
+using {unsub as -} for Int global;
+
+==== Source: use.sol ====
+import "type-and-binding.sol";
+
+contract C {
+    function f() pure public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type_and_binding.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type_and_binding.sol
new file mode 100644
index 00000000..d7a9ed05
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_defined_separately_from_type_and_binding.sol
@@ -0,0 +1,30 @@
+==== Source: binding.sol ====
+import "definition.sol";
+import "type.sol";
+
+using {add as +} for Int global;
+using {unsub as -} for Int global;
+
+==== Source: definition.sol ====
+import "type.sol";
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+==== Source: type.sol ====
+type Int is int;
+
+==== Source: use.sol ====
+import "type.sol";
+
+contract C {
+    function f() pure public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
+// ----
+// TypeError 4117: (binding.sol:45-77): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (binding.sol:78-112): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 2271: (use.sol:72-97): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 4907: (use.sol:107-119): Built-in unary operator - cannot be applied to type Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported.sol
new file mode 100644
index 00000000..7c56bd6d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported.sol
@@ -0,0 +1,17 @@
+==== Source: s1.sol ====
+type Int is int;
+using {add as +} for Int global;
+using {unsub as -} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+==== Source: s2.sol ====
+import "s1.sol";
+
+contract C {
+    function f() pure public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_non_global.sol
new file mode 100644
index 00000000..ab2a8379
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_non_global.sol
@@ -0,0 +1,22 @@
+==== Source: s1.sol ====
+type Int is int;
+using {add as +} for Int;
+using {unsub as -} for Int;
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+==== Source: s2.sol ====
+import "s1.sol";
+
+contract C {
+    function f() pure public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
+// ----
+// TypeError 3320: (s1.sol:24-27): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (s1.sol:50-55): Operators can only be defined in a global 'using for' directive.
+// TypeError 2271: (s2.sol:70-95): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 4907: (s2.sol:105-117): Built-in unary operator - cannot be applied to type Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively.sol
new file mode 100644
index 00000000..86e4c2f4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively.sol
@@ -0,0 +1,35 @@
+==== Source: s0.sol ====
+type Int is int;
+
+==== Source: s1.sol ====
+import "s0.sol";
+using {add1 as +} for Int global;
+using {unsub1 as -} for Int global;
+
+function add1(Int, Int) pure returns (Int) {}
+function unsub1(Int) pure returns (Int) {}
+
+==== Source: s2.sol ====
+import "s0.sol";
+using {add2 as +} for Int global;
+using {unsub2 as -} for Int global;
+
+function add2(Int, Int) pure returns (Int) {}
+function unsub2(Int) pure returns (Int) {}
+
+==== Source: s3.sol ====
+import "s1.sol";
+import "s2.sol";
+contract C {
+    function f() public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
+// ----
+// TypeError 4117: (s1.sol:17-50): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (s1.sol:51-86): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (s2.sol:17-50): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (s2.sol:51-86): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 2271: (s3.sol:81-106): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 4907: (s3.sol:116-128): Built-in unary operator - cannot be applied to type Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively_non_global.sol
new file mode 100644
index 00000000..7bd3fa14
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_imported_transitively_non_global.sol
@@ -0,0 +1,35 @@
+==== Source: s0.sol ====
+type Int is int;
+
+==== Source: s1.sol ====
+import "s0.sol";
+using {add1 as +} for Int;
+using {unsub1 as -} for Int;
+
+function add1(Int, Int) pure returns (Int) {}
+function unsub1(Int) pure returns (Int) {}
+
+==== Source: s2.sol ====
+import "s0.sol";
+using {add2 as +} for Int;
+using {unsub2 as -} for Int;
+
+function add2(Int, Int) pure returns (Int) {}
+function unsub2(Int) pure returns (Int) {}
+
+==== Source: s3.sol ====
+import "s1.sol";
+import "s2.sol";
+contract C {
+    function f() public {
+        Int.wrap(0) + Int.wrap(0);
+        -Int.wrap(0);
+    }
+}
+// ----
+// TypeError 3320: (s1.sol:24-28): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (s1.sol:51-57): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (s2.sol:24-28): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (s2.sol:51-57): Operators can only be defined in a global 'using for' directive.
+// TypeError 2271: (s3.sol:81-106): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 4907: (s3.sol:116-128): Built-in unary operator - cannot be applied to type Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_in_constant_initialization.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_in_constant_initialization.sol
new file mode 100644
index 00000000..f05655b6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_in_constant_initialization.sol
@@ -0,0 +1,24 @@
+type B4 is bytes4;
+using {bitor as |, bitnot as ~} for B4 global;
+
+function bitor(B4, B4) pure returns (B4) {}
+function bitnot(B4) pure returns (B4) {}
+
+B4 constant X = B4.wrap(0x12345678) | B4.wrap(0xaabbccdd);
+
+contract C {
+    B4 constant Y = B4.wrap(0x12345678) | B4.wrap(0xaabbccdd);
+}
+
+library L {
+    B4 constant Z = ~B4.wrap(0x12345678);
+}
+
+interface I {
+    B4 constant W = ~B4.wrap(0x12345678);
+}
+// ----
+// TypeError 8349: (169-210): Initial value for constant variable has to be compile-time constant.
+// TypeError 8349: (246-287): Initial value for constant variable has to be compile-time constant.
+// TypeError 8349: (324-344): Initial value for constant variable has to be compile-time constant.
+// TypeError 8349: (383-403): Initial value for constant variable has to be compile-time constant.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_non_global.sol
new file mode 100644
index 00000000..5af79ad4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_non_global.sol
@@ -0,0 +1,14 @@
+type Int is int;
+using {add as +} for Int;
+using {unsub as -} for Int;
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+function f() pure {
+    Int.wrap(0) + Int.wrap(0);
+    -Int.wrap(0);
+}
+// ----
+// TypeError 3320: (24-27): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (50-55): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_deploys_contract.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_deploys_contract.sol
new file mode 100644
index 00000000..08e9e68d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_deploys_contract.sol
@@ -0,0 +1,24 @@
+type Int is int16;
+
+using {add as +} for Int global;
+
+function add(Int, Int) returns (Int) {
+    B b = new B();
+    return b.f();
+}
+
+contract B {
+    Int s;
+    function f() external returns (Int) {
+        s = Int.wrap(3);
+        return s;
+    }
+}
+
+contract C {
+    function test() public returns (Int) {
+        return Int.wrap(0) + Int.wrap(0);
+    }
+}
+// ----
+// TypeError 7775: (27-30): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_external_call.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_external_call.sol
new file mode 100644
index 00000000..02c5d655
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_external_call.sol
@@ -0,0 +1,20 @@
+type Int is int16;
+using {add as +, unsub as -} for Int global;
+
+IAdder constant ADDER = IAdder(address(0));
+
+function add(Int x, Int y) pure returns (Int) {
+    return ADDER.mul(x, y);
+}
+
+function unsub(Int x) pure returns (Int) {
+    return ADDER.inc(x);
+}
+
+interface IAdder {
+    function mul(Int, Int) external returns (Int);
+    function inc(Int) external returns (Int);
+}
+// ----
+// TypeError 8961: (169-184): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (243-255): Function cannot be declared as pure because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_pure_external_call.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_pure_external_call.sol
new file mode 100644
index 00000000..37a8add5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_pure_external_call.sol
@@ -0,0 +1,17 @@
+type Int is int16;
+using {add as +, unsub as -} for Int global;
+
+IAdder constant ADDER = IAdder(address(0));
+
+function add(Int x, Int y) pure returns (Int) {
+    return ADDER.mul(x, y);
+}
+
+function unsub(Int x) pure returns (Int) {
+    return ADDER.inc(x);
+}
+
+interface IAdder {
+    function mul(Int, Int) external pure returns (Int);
+    function inc(Int) external pure returns (Int);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_view_external_call.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_view_external_call.sol
new file mode 100644
index 00000000..f45f7a30
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_that_makes_view_external_call.sol
@@ -0,0 +1,20 @@
+type Int is int16;
+using {add as +, unsub as -} for Int global;
+
+IAdder constant ADDER = IAdder(address(0));
+
+function add(Int x, Int y) pure returns (Int) {
+    return ADDER.mul(x, y);
+}
+
+function unsub(Int x) pure returns (Int) {
+    return ADDER.inc(x);
+}
+
+interface IAdder {
+    function mul(Int, Int) external view returns (Int);
+    function inc(Int) external view returns (Int);
+}
+// ----
+// TypeError 2527: (169-184): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (243-255): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_with_implicit_conversion.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_with_implicit_conversion.sol
new file mode 100644
index 00000000..afe4e46e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/calling_operator_with_implicit_conversion.sol
@@ -0,0 +1,32 @@
+using {add as +, unsub as -} for U global;
+
+type U is uint;
+
+function add(U, U) pure returns (U) {}
+function unsub(U) pure returns (U) {}
+
+contract C {
+    function fromBool() public {
+        U u;
+
+        u + true;
+        true + u;
+        -true;
+    }
+
+    function fromUint() public {
+        U u;
+        uint32 u32;
+
+        u + u32;
+        u32 + u;
+        -u32;
+    }
+}
+// ----
+// TypeError 5653: (207-215): The type of the second operand of this user-defined binary operator + does not match the type of the first operand, which is U.
+// TypeError 2271: (225-233): Built-in binary operator + cannot be applied to types bool and U.
+// TypeError 4907: (243-248): Built-in unary operator - cannot be applied to type bool.
+// TypeError 5653: (332-339): The type of the second operand of this user-defined binary operator + does not match the type of the first operand, which is U.
+// TypeError 2271: (349-356): Built-in binary operator + cannot be applied to types uint32 and U.
+// TypeError 4907: (366-370): Built-in unary operator - cannot be applied to type uint32. Unary negation is only allowed for signed integers.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_builtin_types.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_builtin_types.sol
new file mode 100644
index 00000000..8bdcd510
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_builtin_types.sol
@@ -0,0 +1,18 @@
+using {f as +} for uint global;
+using {f as +} for uint[2] global;
+using {f as +} for mapping(uint => uint) global;
+using {f as +} for function (uint) pure returns (uint) global;
+using {f as +} for string global;
+
+function f(uint, uint) pure returns (uint) {}
+// ----
+// TypeError 8841: (0-31): Can only use "global" with user-defined types.
+// TypeError 5332: (7-8): Operators can only be implemented for user-defined value types.
+// TypeError 8841: (32-66): Can only use "global" with user-defined types.
+// TypeError 5332: (39-40): Operators can only be implemented for user-defined value types.
+// TypeError 8841: (67-115): Can only use "global" with user-defined types.
+// TypeError 5332: (74-75): Operators can only be implemented for user-defined value types.
+// TypeError 8841: (116-178): Can only use "global" with user-defined types.
+// TypeError 5332: (123-124): Operators can only be implemented for user-defined value types.
+// TypeError 8841: (179-212): Can only use "global" with user-defined types.
+// TypeError 5332: (186-187): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_contract.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_contract.sol
new file mode 100644
index 00000000..55418f57
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_contract.sol
@@ -0,0 +1,13 @@
+using {fc as +} for C global;
+using {fa as +} for A global;
+
+function fc(C, C) pure returns (C) {}
+function fa(A, A) pure returns (A) {}
+
+contract C {}
+abstract contract A {}
+// ----
+// TypeError 8841: (0-29): Can only use "global" with user-defined types.
+// TypeError 5332: (7-9): Operators can only be implemented for user-defined value types.
+// TypeError 8841: (30-59): Can only use "global" with user-defined types.
+// TypeError 5332: (37-39): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_enum.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_enum.sol
new file mode 100644
index 00000000..dce10099
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_enum.sol
@@ -0,0 +1,10 @@
+using {add as +} for E global;
+
+enum E {
+    E1,
+    E2
+}
+
+function add(E, E) pure returns (E) {}
+// ----
+// TypeError 5332: (7-10): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_error.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_error.sol
new file mode 100644
index 00000000..0dcab966
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_error.sol
@@ -0,0 +1,10 @@
+using {add as +} for E global;
+
+error E();
+
+function add(E, E) pure returns (E) {
+    return E.E1;
+}
+
+// ----
+// TypeError 5172: (21-22): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_event.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_event.sol
new file mode 100644
index 00000000..5dd5fbce
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_event.sol
@@ -0,0 +1,10 @@
+using {add as +} for C.Event global;
+
+contract C {
+    event Event();
+}
+
+function add(C.Event, C.Event) pure returns (C.Event) {}
+
+// ----
+// TypeError 5172: (21-28): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_interface.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_interface.sol
new file mode 100644
index 00000000..9db33819
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_interface.sol
@@ -0,0 +1,8 @@
+using {f as +} for I global;
+
+function f(I, I) pure returns (I) {}
+
+interface I {}
+// ----
+// TypeError 8841: (0-28): Can only use "global" with user-defined types.
+// TypeError 5332: (7-8): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_library.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_library.sol
new file mode 100644
index 00000000..210cb300
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_library.sol
@@ -0,0 +1,6 @@
+using {f as +} for L global;
+
+function f() pure {}
+library L {}
+// ----
+// TypeError 1130: (19-20): Invalid use of a library name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_struct.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_struct.sol
new file mode 100644
index 00000000..0244f731
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_struct.sol
@@ -0,0 +1,9 @@
+using {add as +} for S global;
+
+struct S {
+    uint x;
+}
+
+function add(S memory, S memory) pure returns (S memory) {}
+// ----
+// TypeError 5332: (7-10): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_contract_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_contract_level.sol
new file mode 100644
index 00000000..1e3c9e77
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_contract_level.sol
@@ -0,0 +1,16 @@
+type Int is int;
+
+function add(Int, Int) pure returns (Int) {}
+
+contract C {
+    using {add as +} for *;
+}
+
+contract D {
+    using {add as +} for * global;
+}
+// ----
+// SyntaxError 3349: (81-104): The type has to be specified explicitly when attaching specific functions.
+// SyntaxError 3349: (125-155): The type has to be specified explicitly when attaching specific functions.
+// SyntaxError 2854: (125-155): Can only globally attach functions to specific types.
+// SyntaxError 3367: (125-155): "global" can only be used at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_file_level.sol
new file mode 100644
index 00000000..25325f75
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/defining_operator_for_wildcard_type_at_file_level.sol
@@ -0,0 +1,6 @@
+using {add as +} for * global;
+
+function add(int, int) returns (int) {}
+// ----
+// SyntaxError 8118: (0-30): The type has to be specified explicitly at file level (cannot use '*').
+// SyntaxError 2854: (0-30): Can only globally attach functions to specific types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_attached_free_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_attached_free_function.sol
new file mode 100644
index 00000000..a04e81c3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_attached_free_function.sol
@@ -0,0 +1,9 @@
+type Int is uint;
+using {f} for Int;
+
+Int constant v;
+using {v.f as +} for Int global;
+
+function f(Int) pure returns (Int) {}
+// ----
+// DeclarationError 9589: (61-64): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_abi_encode.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_abi_encode.sol
new file mode 100644
index 00000000..00889bc0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_abi_encode.sol
@@ -0,0 +1,8 @@
+type Int is int16;
+
+using {abi.encode as +} for Int global;
+
+function f(Int, Int) pure returns (Int) {}
+
+// ----
+// DeclarationError 9589: (27-37): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_keccak256.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_keccak256.sol
new file mode 100644
index 00000000..ee088624
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_keccak256.sol
@@ -0,0 +1,5 @@
+type Int is int16;
+
+using {keccak256 as +} for Int global;
+// ----
+// TypeError 8187: (27-36): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_revert.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_revert.sol
new file mode 100644
index 00000000..daf4cab6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_builtin_revert.sol
@@ -0,0 +1,5 @@
+type Int is int16;
+
+using {revert as +} for Int global;
+// ----
+// DeclarationError 9589: (27-33): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_contract_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_contract_level.sol
new file mode 100644
index 00000000..309ea955
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_contract_level.sol
@@ -0,0 +1,9 @@
+type Int is int;
+
+contract C {
+    using {add as +} for Int;
+
+    function add(Int, Int) public pure returns (Int) {}
+}
+// ----
+// TypeError 4167: (42-45): Only file-level functions and library functions can be attached to a type in a "using" statement
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_file_level.sol
new file mode 100644
index 00000000..969dd809
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_contract_function_at_file_level.sol
@@ -0,0 +1,11 @@
+type Int is int;
+
+using {C.add as +} for Int global;
+
+contract C {
+    function add(Int, Int) public pure returns (Int) {
+        return 0;
+    }
+}
+// ----
+// TypeError 4167: (25-30): Only file-level functions and library functions can be attached to a type in a "using" statement
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_error.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_error.sol
new file mode 100644
index 00000000..1bec8b44
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_error.sol
@@ -0,0 +1,7 @@
+type Int is int16;
+
+using {IntError as +} for Int global;
+
+error IntError(Int a, Int b);
+// ----
+// TypeError 8187: (27-35): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_event.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_event.sol
new file mode 100644
index 00000000..3a7b6423
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_event.sol
@@ -0,0 +1,9 @@
+type Int is int16;
+
+using {C.IntEvent as +} for Int global;
+
+contract C {
+    event IntEvent(Int a, Int b);
+}
+// ----
+// TypeError 8187: (27-37): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_pointer.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_pointer.sol
new file mode 100644
index 00000000..834fe2d7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_pointer.sol
@@ -0,0 +1,8 @@
+type Int is int8;
+
+contract C {
+    function(Int, Int) external pure returns (Int) ptr;
+    using {ptr as +} for Int;
+}
+// ----
+// TypeError 8187: (99-102): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_shadowing_builtin_keccak256.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_shadowing_builtin_keccak256.sol
new file mode 100644
index 00000000..52f4e362
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_function_shadowing_builtin_keccak256.sol
@@ -0,0 +1,9 @@
+type Int is int16;
+
+using {keccak256 as +} for Int global;
+
+function keccak256(Int, Int) pure returns (Int) {
+    return Int.wrap(0);
+}
+// ----
+// Warning 2319: (60-135): This declaration shadows a builtin symbol.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library.sol
new file mode 100644
index 00000000..a6460da1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library.sol
@@ -0,0 +1,7 @@
+type Int is int16;
+
+using {L as +} for Int global;
+
+library L {}
+// ----
+// TypeError 8187: (27-28): Expected function name.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_contract_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_contract_level.sol
new file mode 100644
index 00000000..889fc0eb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_contract_level.sol
@@ -0,0 +1,113 @@
+==== Source: external.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) external pure returns (Int) {}
+    function unaryOperator(Int) external pure returns (Int) {}
+
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+contract C {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+library X {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+==== Source: internal.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) internal pure returns (Int) {}
+    function unaryOperator(Int) internal pure returns (Int) {}
+
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+contract C {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+library X {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+==== Source: private.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) private pure returns (Int) {}
+    function unaryOperator(Int) private pure returns (Int) {}
+
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+==== Source: public.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) public pure returns (Int) {}
+    function unaryOperator(Int) public pure returns (Int) {}
+
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+contract C {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+library X {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+// ----
+// TypeError 3320: (external.sol:177-193): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:177-193): Only pure free functions can be used to define operators.
+// TypeError 3320: (external.sol:220-235): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:220-235): Only pure free functions can be used to define operators.
+// TypeError 3320: (external.sol:278-294): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:278-294): Only pure free functions can be used to define operators.
+// TypeError 3320: (external.sol:321-336): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:321-336): Only pure free functions can be used to define operators.
+// TypeError 3320: (external.sol:378-394): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:378-394): Only pure free functions can be used to define operators.
+// TypeError 3320: (external.sol:421-436): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (external.sol:421-436): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:177-193): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:177-193): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:220-235): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:220-235): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:278-294): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:278-294): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:321-336): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:321-336): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:378-394): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:378-394): Only pure free functions can be used to define operators.
+// TypeError 3320: (internal.sol:421-436): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (internal.sol:421-436): Only pure free functions can be used to define operators.
+// TypeError 3320: (private.sol:175-191): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (private.sol:175-191): Only pure free functions can be used to define operators.
+// TypeError 3320: (private.sol:218-233): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (private.sol:218-233): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:173-189): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:173-189): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:216-231): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:216-231): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:274-290): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:274-290): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:317-332): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:317-332): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:374-390): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:374-390): Only pure free functions can be used to define operators.
+// TypeError 3320: (public.sol:417-432): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (public.sol:417-432): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_file_level.sol
new file mode 100644
index 00000000..1e3c13ae
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_at_file_level.sol
@@ -0,0 +1,39 @@
+==== Source: external.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) external pure returns (Int) {}
+    function unaryOperator(Int) external pure returns (Int) {}
+}
+
+using {L.binaryOperator as +} for Int global;
+using {L.unaryOperator as -} for Int global;
+
+==== Source: internal.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) internal pure returns (Int) {}
+    function unaryOperator(Int) internal pure returns (Int) {}
+}
+
+using {L.binaryOperator as +} for Int global;
+using {L.unaryOperator as -} for Int global;
+
+==== Source: public.sol ====
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) public pure returns (Int) {}
+    function unaryOperator(Int) public pure returns (Int) {}
+}
+
+using {L.binaryOperator as +} for Int global;
+using {L.unaryOperator as -} for Int global;
+// ----
+// TypeError 7775: (external.sol:175-191): Only pure free functions can be used to define operators.
+// TypeError 7775: (external.sol:221-236): Only pure free functions can be used to define operators.
+// TypeError 7775: (internal.sol:175-191): Only pure free functions can be used to define operators.
+// TypeError 7775: (internal.sol:221-236): Only pure free functions can be used to define operators.
+// TypeError 7775: (public.sol:171-187): Only pure free functions can be used to define operators.
+// TypeError 7775: (public.sol:217-232): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_private_outside_of_library.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_private_outside_of_library.sol
new file mode 100644
index 00000000..077330ba
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_library_function_private_outside_of_library.sol
@@ -0,0 +1,36 @@
+type Int is int128;
+
+library L {
+    function binaryOperator(Int, Int) private pure returns (Int) {}
+    function unaryOperator(Int) private pure returns (Int) {}
+}
+
+using {L.binaryOperator as +} for Int global;
+using {L.unaryOperator as -} for Int global;
+
+contract C {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+
+library X {
+    using {L.binaryOperator as *} for Int;
+    using {L.unaryOperator as ~} for Int;
+}
+// ----
+// TypeError 6772: (173-189): Function "L.binaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 7775: (173-189): Only pure free functions can be used to define operators.
+// TypeError 6772: (219-234): Function "L.unaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 7775: (219-234): Only pure free functions can be used to define operators.
+// TypeError 6772: (282-298): Function "L.binaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 3320: (282-298): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (282-298): Only pure free functions can be used to define operators.
+// TypeError 6772: (325-340): Function "L.unaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 3320: (325-340): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (325-340): Only pure free functions can be used to define operators.
+// TypeError 6772: (382-398): Function "L.binaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 3320: (382-398): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (382-398): Only pure free functions can be used to define operators.
+// TypeError 6772: (425-440): Function "L.unaryOperator" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 3320: (425-440): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (425-440): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function.sol
new file mode 100644
index 00000000..e009fa03
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function.sol
@@ -0,0 +1,12 @@
+using {add as +, sub as -, mul as *} for A global;
+
+function add(A, A) view returns (A) {}
+function sub(A, A) returns (A) {}
+function mul(A, A) payable returns (A) {}
+
+type A is address payable;
+// ----
+// TypeError 7775: (7-10): Only pure free functions can be used to define operators.
+// TypeError 7775: (17-20): Only pure free functions can be used to define operators.
+// TypeError 7775: (27-30): Only pure free functions can be used to define operators.
+// TypeError 9559: (125-166): Free functions cannot be payable.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function_on_built_in_type_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function_on_built_in_type_non_global.sol
new file mode 100644
index 00000000..15581a1c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_non_pure_function_on_built_in_type_non_global.sol
@@ -0,0 +1,8 @@
+// This should point out all 3 errors, rather than give up after the first one.
+using {add as +} for address;
+
+function add(address, address) view returns (address) {}
+// ----
+// TypeError 3320: (87-90): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (87-90): Only pure free functions can be used to define operators.
+// TypeError 5332: (87-90): Operators can only be implemented for user-defined value types.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_overloaded_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_overloaded_function.sol
new file mode 100644
index 00000000..ccddd3fa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_overloaded_function.sol
@@ -0,0 +1,10 @@
+using {add as +} for A global;
+using {add as +} for AP global;
+
+function add(A, A) pure returns (A) {}
+function add(AP, AP) pure returns (AP) {}
+
+type A is address;
+type AP is address payable;
+// ----
+// DeclarationError 9589: (7-10): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_privately_overloaded_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_privately_overloaded_function.sol
new file mode 100644
index 00000000..d41db77d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_privately_overloaded_function.sol
@@ -0,0 +1,12 @@
+using {L.add as +} for A global;
+using {L.add as +} for AP global;
+
+library L {
+    function add(A, A) private pure returns (A) {}
+    function add(AP, AP) internal pure returns (AP) {}
+}
+
+type A is address;
+type AP is address payable;
+// ----
+// DeclarationError 9589: (7-12): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_at_file_level.sol
new file mode 100644
index 00000000..80793f68
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_at_file_level.sol
@@ -0,0 +1,9 @@
+type B32 is bytes32;
+
+library L {
+    function publicOperator(B32, B32) public pure returns (B32) {}
+}
+
+using {publicOperator as +} for B32 global;
+// ----
+// DeclarationError 9589: (111-125): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_in_library.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_in_library.sol
new file mode 100644
index 00000000..565aa6dc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/implementing_operator_with_unqualified_library_function_in_library.sol
@@ -0,0 +1,22 @@
+type B32 is bytes32;
+
+library L {
+    using {externalOperator as +} for B32;
+    using {publicOperator as -} for B32;
+    using {internalOperator as *} for B32;
+    using {privateOperator as /} for B32;
+
+    function externalOperator(B32, B32) external pure returns (B32) {}
+    function publicOperator(B32, B32) public pure returns (B32) {}
+    function internalOperator(B32, B32) internal pure returns (B32) {}
+    function privateOperator(B32, B32) private pure returns (B32) {}
+}
+// ----
+// TypeError 3320: (45-61): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (45-61): Only pure free functions can be used to define operators.
+// TypeError 3320: (88-102): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (88-102): Only pure free functions can be used to define operators.
+// TypeError 3320: (129-145): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (129-145): Only pure free functions can be used to define operators.
+// TypeError 3320: (172-187): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (172-187): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_and_non_global_different_files.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_and_non_global_different_files.sol
new file mode 100644
index 00000000..94769ee1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_and_non_global_different_files.sol
@@ -0,0 +1,20 @@
+==== Source: Int.sol ====
+type Int is int;
+
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+
+==== Source: test.sol ====
+import "Int.sol";
+
+using {anotherAdd as +} for Int;
+
+function anotherAdd(Int, Int) pure returns (Int) {}
+
+function test() pure returns (Int) {
+    return Int.wrap(0) + Int.wrap(0);
+}
+// ----
+// TypeError 3320: (test.sol:26-36): Operators can only be defined in a global 'using for' directive.
+// TypeError 4705: (test.sol:26-36): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_non_global.sol
new file mode 100644
index 00000000..0b30e06b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_global_non_global.sol
@@ -0,0 +1,26 @@
+type Int is int;
+
+using {add as +} for Int global;
+using {add2 as +} for Int;
+using {unsub as -} for Int global;
+using {unsub2 as -} for Int;
+
+function add(Int, Int) pure returns (Int) {}
+function add2(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+function unsub2(Int) pure returns (Int) {}
+
+function testBinary() pure returns (Int) {
+    return Int.wrap(1) + Int.wrap(2);
+}
+
+function testUnary() pure returns (Int) {
+    return -Int.wrap(2);
+}
+// ----
+// TypeError 4705: (25-28): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 3320: (58-62): Operators can only be defined in a global 'using for' directive.
+// TypeError 4705: (58-62): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 4705: (85-90): User-defined unary operator - has more than one definition matching the operand type visible in the current scope.
+// TypeError 3320: (120-126): Operators can only be defined in a global 'using for' directive.
+// TypeError 4705: (120-126): User-defined unary operator - has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_non_global_and_global_different_files.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_non_global_and_global_different_files.sol
new file mode 100644
index 00000000..2d6e47a8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_non_global_and_global_different_files.sol
@@ -0,0 +1,20 @@
+==== Source: Int.sol ====
+type Int is int;
+
+using {add as +} for Int;
+
+function add(Int, Int) pure returns (Int) {}
+
+==== Source: test.sol ====
+import "Int.sol";
+
+using {anotherAdd as +} for Int global;
+
+function anotherAdd(Int, Int) pure returns (Int) {}
+
+function test() pure returns (Int) {
+    return Int.wrap(0) + Int.wrap(0);
+}
+// ----
+// TypeError 3320: (Int.sol:25-28): Operators can only be defined in a global 'using for' directive.
+// TypeError 4117: (test.sol:19-58): Can only use "global" with types defined in the same source unit at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive.sol
new file mode 100644
index 00000000..4972deef
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive.sol
@@ -0,0 +1,13 @@
+type Int is uint128;
+
+using {add as +, sub as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+function sub(Int, Int) pure returns (Int) {}
+
+function test() {
+    Int.wrap(0) + Int.wrap(1);
+}
+// ----
+// TypeError 4705: (29-32): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 4705: (39-42): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive_operator_not_used.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive_operator_not_used.sol
new file mode 100644
index 00000000..ec4274c7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_different_functions_same_directive_operator_not_used.sol
@@ -0,0 +1,15 @@
+type Int is uint128;
+
+// Still an error, even if the operator is not actually used
+using {add1 as +, add2 as +} for Int global;
+using {unsub1 as -, unsub2 as -} for Int global;
+
+function add1(Int, Int) pure returns (Int) {}
+function add2(Int, Int) pure returns (Int) {}
+function unsub1(Int) pure returns (Int) {}
+function unsub2(Int) pure returns (Int) {}
+// ----
+// TypeError 4705: (90-94): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 4705: (101-105): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 4705: (135-141): User-defined unary operator - has more than one definition matching the operand type visible in the current scope.
+// TypeError 4705: (148-154): User-defined unary operator - has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_on_file_and_contract_level.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_on_file_and_contract_level.sol
new file mode 100644
index 00000000..bb517ca7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_on_file_and_contract_level.sol
@@ -0,0 +1,23 @@
+type Int is int;
+
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+function another_add(Int, Int) pure returns (Int) {}
+
+contract B {
+    using {another_add as +} for Int;
+
+    function f() public {
+        Int.wrap(0) + Int.wrap(0);
+    }
+}
+
+contract C is B {
+    function g() public {
+        Int.wrap(0) + Int.wrap(0);
+    }
+}
+// ----
+// TypeError 3320: (175-186): Operators can only be defined in a global 'using for' directive.
+// TypeError 4705: (175-186): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_free_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_free_function.sol
new file mode 100644
index 00000000..4cd956ba
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_free_function.sol
@@ -0,0 +1,19 @@
+type Int is int;
+
+function add(Int, Int) pure returns (Int) {}
+function unsub(Int) pure returns (Int) {}
+
+using {add as +, unsub as -} for Int global;
+
+contract C {
+    using {add as +, unsub as -} for Int;
+}
+
+library X {
+    using {add as +, unsub as -} for Int;
+}
+// ----
+// TypeError 3320: (176-179): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (186-191): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (233-236): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (243-248): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_library_function.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_library_function.sol
new file mode 100644
index 00000000..9fd4c733
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_different_levels_library_function.sol
@@ -0,0 +1,38 @@
+type Int is int;
+
+library L {
+    using {add as +, unsub as -} for Int;
+    using {L.add as +, L.unsub as -} for Int;
+
+    function add(Int, Int) internal pure returns (Int) {}
+    function unsub(Int) internal pure returns (Int) {}
+}
+
+using {L.add as +, L.unsub as -} for Int global;
+
+contract C {
+    using {L.add as +, L.unsub as -} for Int;
+}
+
+library X {
+    using {L.add as +, L.unsub as -} for Int;
+}
+// ----
+// TypeError 3320: (41-44): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (41-44): Only pure free functions can be used to define operators.
+// TypeError 3320: (51-56): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (51-56): Only pure free functions can be used to define operators.
+// TypeError 3320: (83-88): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (83-88): Only pure free functions can be used to define operators.
+// TypeError 3320: (95-102): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (95-102): Only pure free functions can be used to define operators.
+// TypeError 7775: (242-247): Only pure free functions can be used to define operators.
+// TypeError 7775: (254-261): Only pure free functions can be used to define operators.
+// TypeError 3320: (309-314): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (309-314): Only pure free functions can be used to define operators.
+// TypeError 3320: (321-328): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (321-328): Only pure free functions can be used to define operators.
+// TypeError 3320: (370-375): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (370-375): Only pure free functions can be used to define operators.
+// TypeError 3320: (382-389): Operators can only be defined in a global 'using for' directive.
+// TypeError 7775: (382-389): Only pure free functions can be used to define operators.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_same_directive.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_same_directive.sol
new file mode 100644
index 00000000..9bb4d623
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_same_directive.sol
@@ -0,0 +1,9 @@
+type Int is int32;
+
+using {add as +, add as +} for Int global;
+
+function add(Int, Int) pure returns(Int) {}
+
+function f(int32 a, int32 b) pure {
+    Int.wrap(a) + Int.wrap(b);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_separate_directives.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_separate_directives.sol
new file mode 100644
index 00000000..d2a648e7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/multiple_operator_definitions_same_function_separate_directives.sol
@@ -0,0 +1,10 @@
+type Int is int32;
+
+using {add as +} for Int global;
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns(Int) {}
+
+function f(int32 a, int32 b) pure {
+    Int.wrap(a) + Int.wrap(b);
+}
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_overloading.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_overloading.sol
new file mode 100644
index 00000000..e7b0a764
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_overloading.sol
@@ -0,0 +1,14 @@
+type Int is uint128;
+
+using {add as +, add128 as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+function add128(Int, int128) pure returns (Int) {}
+
+function test() {
+    Int.wrap(0) + Int.wrap(1);
+}
+// ----
+// TypeError 4705: (29-32): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
+// TypeError 1884: (129-142): Wrong parameters in operator definition. The function "add128" needs to have two parameters of type Int and the same data location to be used for the operator +.
+// TypeError 4705: (39-45): User-defined binary operator + has more than one definition matching the operand type visible in the current scope.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_function_name_missing.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_function_name_missing.sol
new file mode 100644
index 00000000..5911fc65
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_function_name_missing.sol
@@ -0,0 +1,3 @@
+using {as -} for uint global;
+// ----
+// ParserError 2314: (7-9): Expected identifier but got 'as'
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_no_brace.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_no_brace.sol
new file mode 100644
index 00000000..1a1be262
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_no_brace.sol
@@ -0,0 +1,3 @@
+using f as - for uint global;
+// ----
+// ParserError 2314: (8-10): Expected 'for' but got 'as'
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_non_user_definable.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_non_user_definable.sol
new file mode 100644
index 00000000..ed4fb13a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_non_user_definable.sol
@@ -0,0 +1,45 @@
+using {
+    f as new,
+    f as delete,
+    f as **,
+    f as <<,
+    f as >>,
+    f as &&,
+    f as ||,
+    f as !,
+    f as =,
+    f as |=,
+    f as ^=,
+    f as &=,
+    f as <<=,
+    f as >>=,
+    f as +=,
+    f as -=,
+    f as *=,
+    f as /=,
+    f as %=,
+    f as ++,
+    f as --
+} for int256 global;
+// ----
+// ParserError 4403: (17-20): Not a user-definable operator: new. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (31-37): Not a user-definable operator: delete. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (48-50): Not a user-definable operator: **. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (61-63): Not a user-definable operator: <<. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (74-76): Not a user-definable operator: >>. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (87-89): Not a user-definable operator: &&. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (100-102): Not a user-definable operator: ||. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (113-114): Not a user-definable operator: !. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (125-126): Not a user-definable operator: =. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (137-139): Not a user-definable operator: |=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (150-152): Not a user-definable operator: ^=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (163-165): Not a user-definable operator: &=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (176-179): Not a user-definable operator: <<=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (190-193): Not a user-definable operator: >>=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (204-206): Not a user-definable operator: +=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (217-219): Not a user-definable operator: -=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (230-232): Not a user-definable operator: *=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (243-245): Not a user-definable operator: /=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (256-258): Not a user-definable operator: %=. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (269-271): Not a user-definable operator: ++. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (282-284): Not a user-definable operator: --. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_not_an_operator.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_not_an_operator.sol
new file mode 100644
index 00000000..7fa8c5ee
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_not_an_operator.sol
@@ -0,0 +1,14 @@
+using {
+    f as x,
+    f as operator,
+    f as as,
+    f as 123,
+    f as ()
+} for int256 global;
+// ----
+// ParserError 4403: (17-18): Not a user-definable operator: x. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (29-37): Not a user-definable operator: operator. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (48-50): Not a user-definable operator: as. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (61-64): Not a user-definable operator: 123. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (75-76): Not a user-definable operator: (. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 2314: (76-77): Expected '}' but got ')'
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_empty_string.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_empty_string.sol
new file mode 100644
index 00000000..8435de6d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_empty_string.sol
@@ -0,0 +1,7 @@
+using {f as ''} for uint;
+using {f as ""} for int;
+using {f as hex""} for address;
+// ----
+// ParserError 4403: (12-14): Not a user-definable operator: . Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (38-40): Not a user-definable operator: . Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 4403: (63-68): Not a user-definable operator: . Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_missing.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_missing.sol
new file mode 100644
index 00000000..a6970a9b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_name_missing.sol
@@ -0,0 +1,4 @@
+using {f as} for uint global;
+// ----
+// ParserError 4403: (11-12): Not a user-definable operator: }. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
+// ParserError 2314: (13-16): Expected '}' but got 'for'
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_named_as.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_named_as.sol
new file mode 100644
index 00000000..52669318
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_parsing_operator_named_as.sol
@@ -0,0 +1,3 @@
+using {f as as} for uint global;
+// ----
+// ParserError 4403: (12-14): Not a user-definable operator: as. Only the following operators can be user-defined: |, &, ^, ~, +, -, *, /, %, ==, !=, <, >, <=, >=
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_returning_wrong_types.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_returning_wrong_types.sol
new file mode 100644
index 00000000..676f2c47
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_returning_wrong_types.sol
@@ -0,0 +1,33 @@
+type Int is int256;
+
+using {
+    add as +,
+    div as /,
+    unsub as -,
+    bitnot as ~,
+    gt as >,
+    lt as <
+} for Int global;
+
+function add(Int x, Int y) pure returns (int256) {}
+function div(Int x, Int y) pure {}
+function unsub(Int) pure returns (Int, Int) {}
+function bitnot(Int) pure returns (int256) {}
+function gt(Int, Int) pure returns (Int) {}
+function lt(Int, Int) pure returns (bool, Int) {}
+
+function f() pure {
+    Int.wrap(0) + Int.wrap(1);
+    Int.wrap(0) / Int.wrap(0);
+    -Int.wrap(0);
+    ~Int.wrap(0);
+    Int.wrap(0) < Int.wrap(0);
+    Int.wrap(0) > Int.wrap(0);
+}
+// ----
+// TypeError 7743: (174-182): Wrong return parameters in operator definition. The function "add" needs to return exactly one value of type Int to be used for the operator +.
+// TypeError 7743: (218-218): Wrong return parameters in operator definition. The function "div" needs to return exactly one value of type Int to be used for the operator /.
+// TypeError 7743: (254-264): Wrong return parameters in operator definition. The function "unsub" needs to return exactly one value of type Int to be used for the operator -.
+// TypeError 7743: (302-310): Wrong return parameters in operator definition. The function "bitnot" needs to return exactly one value of type Int to be used for the operator ~.
+// TypeError 7743: (349-354): Wrong return parameters in operator definition. The function "gt" needs to return exactly one value of type bool to be used for the operator >.
+// TypeError 7743: (393-404): Wrong return parameters in operator definition. The function "lt" needs to return exactly one value of type bool to be used for the operator <.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_and_returning_types_not_matching_using_for.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_and_returning_types_not_matching_using_for.sol
new file mode 100644
index 00000000..1d034c8e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_and_returning_types_not_matching_using_for.sol
@@ -0,0 +1,26 @@
+type Int is int256;
+
+using {
+    add as +,
+    sub as -,
+    div as /
+} for Int global;
+
+function add(Int) pure returns (Int) {}
+function sub(Int, Int, Int) pure returns (Int) {}
+function div(int256, int256) pure returns (Int) {}
+
+function f() pure {
+    Int.wrap(0) + Int.wrap(1);
+    Int.wrap(0) - Int.wrap(0);
+    Int.wrap(0) / Int.wrap(0);
+}
+
+// ----
+// TypeError 1884: (101-106): Wrong parameters in operator definition. The function "add" needs to have two parameters of type Int and the same data location to be used for the operator +.
+// TypeError 1884: (141-156): Wrong parameters in operator definition. The function "sub" needs to have one or two parameters of type Int and the same data location to be used for the operator -.
+// TypeError 1884: (191-207): Wrong parameters in operator definition. The function "div" needs to have one or two parameters of type Int and the same data location to be used for the operator /.
+// TypeError 7743: (221-226): Wrong return parameters in operator definition. The function "div" needs to return a value of the same type and data location as its parameters to be used for the operator /.
+// TypeError 2271: (255-280): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 2271: (286-311): Built-in binary operator - cannot be applied to types Int and Int. No matching user-defined operator found.
+// TypeError 2271: (317-342): Built-in binary operator / cannot be applied to types Int and Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_binary.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_binary.sol
new file mode 100644
index 00000000..ffd35cc1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_binary.sol
@@ -0,0 +1,11 @@
+type Int is int;
+
+using {
+    f as +
+} for Int global;
+
+function f() returns (Int) {
+    return Int.wrap(0);
+}
+// ----
+// TypeError 4731: (30-31): The function "f" does not have any parameters, and therefore cannot be attached to the type "Int".
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_unary.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_unary.sol
new file mode 100644
index 00000000..323b5644
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_no_parameters_unary.sol
@@ -0,0 +1,11 @@
+type Int is int;
+
+using {
+    f as ~
+} for Int global;
+
+function f() returns (Int) {
+    return Int.wrap(0);
+}
+// ----
+// TypeError 4731: (30-31): The function "f" does not have any parameters, and therefore cannot be attached to the type "Int".
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_or_returning_different_types.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_or_returning_different_types.sol
new file mode 100644
index 00000000..c254ad04
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_or_returning_different_types.sol
@@ -0,0 +1,20 @@
+type Int is int128;
+
+using {
+    add as +,
+    sub as -,
+    mul as *,
+    div as /
+} for Int global;
+
+function add(Int, int128) pure returns (Int) {}
+function sub(int128, Int) pure returns (int128) {}
+function mul(int128, int256) pure returns (Int) {}
+function div(Int, Int) pure returns (int256) {}
+// ----
+// TypeError 1884: (115-128): Wrong parameters in operator definition. The function "add" needs to have two parameters of type Int and the same data location to be used for the operator +.
+// TypeError 1884: (163-176): Wrong parameters in operator definition. The function "sub" needs to have one or two parameters of type Int and the same data location to be used for the operator -.
+// TypeError 7743: (190-198): Wrong return parameters in operator definition. The function "sub" needs to return exactly one value of type Int to be used for the operator -.
+// TypeError 1884: (214-230): Wrong parameters in operator definition. The function "mul" needs to have two parameters of type Int and the same data location to be used for the operator *.
+// TypeError 7743: (244-249): Wrong return parameters in operator definition. The function "mul" needs to return a value of the same type and data location as its parameters to be used for the operator *.
+// TypeError 7743: (289-297): Wrong return parameters in operator definition. The function "div" needs to return exactly one value of type Int to be used for the operator /.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_two_parameters_unary.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_two_parameters_unary.sol
new file mode 100644
index 00000000..81d45462
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/operator_taking_two_parameters_unary.sol
@@ -0,0 +1,14 @@
+type Int is int128;
+
+using {bitnot as ~} for Int global;
+
+function bitnot(Int, Int) pure returns (Int) {}
+
+contract C {
+    function test() public pure {
+        ~Int.wrap(1);
+    }
+}
+// ----
+// TypeError 1884: (73-83): Wrong parameters in operator definition. The function "bitnot" needs to have exactly one parameter of type Int to be used for the operator ~.
+// TypeError 4907: (162-174): Built-in unary operator ~ cannot be applied to type Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_attaching_functions_and_defining_operators_same_directive.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_attaching_functions_and_defining_operators_same_directive.sol
new file mode 100644
index 00000000..612c377e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_attaching_functions_and_defining_operators_same_directive.sol
@@ -0,0 +1,10 @@
+type AP is address payable;
+
+function sub(AP, AP) pure returns (AP) {}
+function unsub(AP) pure returns (AP) {}
+
+function attachedPure(AP, uint, address) pure {}
+function attachedView(AP) view {}
+function attached(AP, function(AP)) {}
+
+using {sub as -, attachedPure, attachedView, unsub as -, attached} for AP global;
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_for_contract_level_type.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_for_contract_level_type.sol
new file mode 100644
index 00000000..9b7f8005
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_for_contract_level_type.sol
@@ -0,0 +1,19 @@
+library L {
+    type FixedBytes is bytes10;
+}
+
+function add(L.FixedBytes, L.FixedBytes) pure returns (L.FixedBytes) {}
+function unsub(L.FixedBytes, L.FixedBytes) pure returns (L.FixedBytes) {}
+
+library LX {
+    using {add as +, unsub as -} for L.FixedBytes;
+}
+
+contract CX {
+    using {add as +, unsub as -} for L.FixedBytes;
+}
+// ----
+// TypeError 3320: (218-221): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (228-233): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (286-289): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (296-301): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global.sol
new file mode 100644
index 00000000..c99fd0e6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global.sol
@@ -0,0 +1,13 @@
+type Int is int16;
+
+function add(Int, Int) pure returns (Int) {}
+
+contract C {
+    using {add as +} for Int global;
+
+    function test() pure public {
+        Int.wrap(0) + Int.wrap(0);
+    }
+}
+// ----
+// SyntaxError 3367: (83-115): "global" can only be used at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global_different_file.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global_different_file.sol
new file mode 100644
index 00000000..d4f9d9ac
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_global_different_file.sol
@@ -0,0 +1,13 @@
+==== Source: s1.sol ====
+type Int is int;
+
+==== Source: s2.sol ====
+import "s1.sol";
+
+function bitnot(Int) pure returns (Int) {}
+
+contract C {
+    using {bitnot as ~} for Int global;
+}
+// ----
+// SyntaxError 3367: (s2.sol:79-114): "global" can only be used at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_base_contract.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_base_contract.sol
new file mode 100644
index 00000000..17351599
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_base_contract.sol
@@ -0,0 +1,30 @@
+type Int is int128;
+
+function add(Int, Int) pure returns (Int) {}
+function another_add(Int, Int) pure returns (Int) {}
+
+contract B {
+    using {add as +} for Int;
+
+    function f() pure public returns (Int) {
+        return Int.wrap(0) + Int.wrap(0);
+    }
+}
+
+contract C is B {
+    using {another_add as +} for Int;
+
+    function g() pure public returns (Int) {
+        return Int.wrap(0) + Int.wrap(0);
+    }
+}
+
+contract D is B {
+    function h() pure public returns (Int) {
+        return Int.wrap(0) + Int.wrap(0);
+    }
+}
+// ----
+// TypeError 3320: (144-147): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (289-300): Operators can only be defined in a global 'using for' directive.
+// TypeError 2271: (491-516): Built-in binary operator + cannot be applied to types Int and Int. No matching user-defined operator found.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_interface.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_interface.sol
new file mode 100644
index 00000000..46dbee97
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_contract_level_in_interface.sol
@@ -0,0 +1,10 @@
+type Int is int;
+
+function add(Int, Int) pure returns (Int) {}
+
+interface I {
+    using {add as +} for Int;
+}
+// ----
+// SyntaxError 9088: (82-107): The "using for" directive is not allowed inside interfaces.
+// TypeError 3320: (89-92): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type.sol
new file mode 100644
index 00000000..6efae72f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type.sol
@@ -0,0 +1,27 @@
+library L {
+    type FixedBytes is bytes1;
+}
+
+contract C {
+    type FixedBytes is bytes2;
+}
+
+interface I {
+    type FixedBytes is bytes3;
+}
+
+function addL(L.FixedBytes, L.FixedBytes) pure returns (L.FixedBytes) {}
+function addC(C.FixedBytes, C.FixedBytes) pure returns (C.FixedBytes) {}
+function addI(I.FixedBytes, I.FixedBytes) pure returns (I.FixedBytes) {}
+
+function unsubL(L.FixedBytes) pure returns (L.FixedBytes) {}
+function unsubC(C.FixedBytes) pure returns (C.FixedBytes) {}
+function unsubI(I.FixedBytes) pure returns (I.FixedBytes) {}
+
+using {addL as +, unsubL as -} for L.FixedBytes global;
+using {addC as +, unsubC as -} for C.FixedBytes global;
+using {addI as +, unsubI as -} for I.FixedBytes global;
+// ----
+// TypeError 4117: (545-600): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (601-656): Can only use "global" with types defined in the same source unit at file level.
+// TypeError 4117: (657-712): Can only use "global" with types defined in the same source unit at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type_non_global.sol
new file mode 100644
index 00000000..fa0e467e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_for_contract_level_type_non_global.sol
@@ -0,0 +1,30 @@
+library L {
+    type FixedBytes is bytes1;
+}
+
+contract C {
+    type FixedBytes is bytes2;
+}
+
+interface I {
+    type FixedBytes is bytes3;
+}
+
+function addL(L.FixedBytes, L.FixedBytes) pure returns (L.FixedBytes) {}
+function addC(C.FixedBytes, C.FixedBytes) pure returns (C.FixedBytes) {}
+function addI(I.FixedBytes, I.FixedBytes) pure returns (I.FixedBytes) {}
+
+function unsubL(L.FixedBytes) pure returns (L.FixedBytes) {}
+function unsubC(C.FixedBytes) pure returns (C.FixedBytes) {}
+function unsubI(I.FixedBytes) pure returns (I.FixedBytes) {}
+
+using {addL as +, unsubL as -} for L.FixedBytes;
+using {addC as +, unsubC as -} for C.FixedBytes;
+using {addI as +, unsubI as -} for I.FixedBytes;
+// ----
+// TypeError 3320: (552-556): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (563-569): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (601-605): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (612-618): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (650-654): Operators can only be defined in a global 'using for' directive.
+// TypeError 3320: (661-667): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_and_non_global.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_and_non_global.sol
new file mode 100644
index 00000000..b04934d9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_and_non_global.sol
@@ -0,0 +1,23 @@
+==== Source: s1.sol ====
+type Int is int;
+
+using {add as +} for Int global;
+using {add as +} for Int;
+
+function add(Int a, Int b) pure returns (Int) {}
+function test_add() pure returns (Int) {}
+
+==== Source: s2.sol ====
+import "s1.sol";
+
+contract C2 {
+    function test1() pure public returns (Int) {
+        return test_add();
+    }
+
+    function test2() pure public returns (Int) {
+        return Int.wrap(3) + Int.wrap(4);
+    }
+}
+// ----
+// TypeError 3320: (s1.sol:58-61): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_different_file.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_different_file.sol
new file mode 100644
index 00000000..7eda376e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_different_file.sol
@@ -0,0 +1,11 @@
+==== Source: s1.sol ====
+type Int is int;
+
+==== Source: s2.sol ====
+import "s1.sol";
+
+function bitnot(Int) pure returns (Int) {}
+
+using {bitnot as ~} for Int global;
+// ----
+// TypeError 4117: (s2.sol:62-97): Can only use "global" with types defined in the same source unit at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_unary_and_non_global_binary_same_file.sol b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_unary_and_non_global_binary_same_file.sol
new file mode 100644
index 00000000..68f61988
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/operators/userDefined/using_for_with_operator_at_file_level_global_unary_and_non_global_binary_same_file.sol
@@ -0,0 +1,20 @@
+type Int is int16;
+
+using {unsub as -} for Int global;
+using {sub as -} for Int;
+
+function sub(Int a, Int b) pure returns (Int) {}
+
+function unsub(Int a) pure returns (Int) {}
+
+contract C {
+    function test_sub() public pure returns (Int) {
+        return Int.wrap(7) - Int.wrap(2);
+    }
+
+    function test_unsub() public pure returns (Int) {
+        return -Int.wrap(4);
+    }
+}
+// ----
+// TypeError 3320: (62-65): Operators can only be defined in a global 'using for' directive.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/address_invalid_state_mutability.sol b/compiler/test/libsolidity/syntaxTests/parsing/address_invalid_state_mutability.sol
new file mode 100644
index 00000000..2aa4dd34
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/address_invalid_state_mutability.sol
@@ -0,0 +1,50 @@
+contract C {
+    address view m_a;
+    address pure m_b;
+    address view[] m_c;
+    mapping(uint => address view) m_d;
+    function f() public pure {
+        address view a;
+        address pure b;
+        a; b;
+    }
+    function g(address view) public pure {}
+    function h(address pure) public pure {}
+    function i() public pure returns (address view) {}
+    function j() public pure returns (address pure) {}
+    modifier m1(address view) {_;}
+    modifier m2(address pure) {_;}
+    event e1(address view);
+    event e2(address pure);
+    error err1(address view);
+    error err2(address pure);
+    function f2() public pure returns (address) {
+        try this.f2() returns (address view res) {} catch {}
+    }
+    function f3() public pure returns (address) {
+        try this.f3() returns (address pure res) {} catch {}
+    }
+}
+address view constant f_a;
+address pure constant f_b;
+// ----
+// TypeError 2311: (17-29): Address types can only be payable or non-payable.
+// TypeError 2311: (39-51): Address types can only be payable or non-payable.
+// TypeError 2311: (61-73): Address types can only be payable or non-payable.
+// TypeError 2311: (101-113): Address types can only be payable or non-payable.
+// TypeError 2311: (159-171): Address types can only be payable or non-payable.
+// TypeError 2311: (183-195): Address types can only be payable or non-payable.
+// TypeError 2311: (234-246): Address types can only be payable or non-payable.
+// TypeError 2311: (278-290): Address types can only be payable or non-payable.
+// TypeError 2311: (345-357): Address types can only be payable or non-payable.
+// TypeError 2311: (400-412): Address types can only be payable or non-payable.
+// TypeError 2311: (433-445): Address types can only be payable or non-payable.
+// TypeError 2311: (468-480): Address types can only be payable or non-payable.
+// TypeError 2311: (500-512): Address types can only be payable or non-payable.
+// TypeError 2311: (528-540): Address types can only be payable or non-payable.
+// TypeError 2311: (558-570): Address types can only be payable or non-payable.
+// TypeError 2311: (588-600): Address types can only be payable or non-payable.
+// TypeError 2311: (684-696): Address types can only be payable or non-payable.
+// TypeError 2311: (801-813): Address types can only be payable or non-payable.
+// TypeError 2311: (839-851): Address types can only be payable or non-payable.
+// TypeError 2311: (866-878): Address types can only be payable or non-payable.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_argument.sol b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_argument.sol
new file mode 100644
index 00000000..aefb4748
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_argument.sol
@@ -0,0 +1,85 @@
+contract C {
+    function a(bool payable) public pure {}
+    function b(string payable) public pure {}
+    function c(int payable) public pure {}
+    function d(int256 payable) public pure {}
+    function e(uint payable) public pure {}
+    function f(uint256 payable) public pure {}
+    function g(bytes1 payable) public pure {}
+    function h(bytes payable) public pure {}
+    function i(bytes32 payable) public pure {}
+    function j(fixed payable) public pure {}
+    function k(fixed80x80 payable) public pure {}
+    function l(ufixed payable) public pure {}
+    function m(ufixed80x80 payable) public pure {}
+}
+contract C1 {
+    function a(bool view) public pure {}
+    function b(string view) public pure {}
+    function c(int view) public pure {}
+    function d(int256 view) public pure {}
+    function e(uint view) public pure {}
+    function f(uint256 view) public pure {}
+    function g(bytes1 view) public pure {}
+    function h(bytes view) public pure {}
+    function i(bytes32 view) public pure {}
+    function j(fixed view) public pure {}
+    function k(fixed80x80 view) public pure {}
+    function l(ufixed view) public pure {}
+    function m(ufixed80x80 view) public pure {}
+}
+contract C2 {
+    function a(bool pure) public pure {}
+    function b(string pure) public pure {}
+    function c(int pure) public pure {}
+    function d(int256 pure) public pure {}
+    function e(uint pure) public pure {}
+    function f(uint256 pure) public pure {}
+    function g(bytes1 pure) public pure {}
+    function h(bytes pure) public pure {}
+    function i(bytes32 pure) public pure {}
+    function j(fixed pure) public pure {}
+    function k(fixed80x80 pure) public pure {}
+    function l(ufixed pure) public pure {}
+    function m(ufixed80x80 pure) public pure {}
+}
+// ----
+// ParserError 9106: (33-40): State mutability can only be specified for address types.
+// ParserError 9106: (79-86): State mutability can only be specified for address types.
+// ParserError 9106: (122-129): State mutability can only be specified for address types.
+// ParserError 9106: (168-175): State mutability can only be specified for address types.
+// ParserError 9106: (212-219): State mutability can only be specified for address types.
+// ParserError 9106: (259-266): State mutability can only be specified for address types.
+// ParserError 9106: (305-312): State mutability can only be specified for address types.
+// ParserError 9106: (350-357): State mutability can only be specified for address types.
+// ParserError 9106: (397-404): State mutability can only be specified for address types.
+// ParserError 9106: (442-449): State mutability can only be specified for address types.
+// ParserError 9106: (492-499): State mutability can only be specified for address types.
+// ParserError 9106: (538-545): State mutability can only be specified for address types.
+// ParserError 9106: (589-596): State mutability can only be specified for address types.
+// ParserError 9106: (649-653): State mutability can only be specified for address types.
+// ParserError 9106: (692-696): State mutability can only be specified for address types.
+// ParserError 9106: (732-736): State mutability can only be specified for address types.
+// ParserError 9106: (775-779): State mutability can only be specified for address types.
+// ParserError 9106: (816-820): State mutability can only be specified for address types.
+// ParserError 9106: (860-864): State mutability can only be specified for address types.
+// ParserError 9106: (903-907): State mutability can only be specified for address types.
+// ParserError 9106: (945-949): State mutability can only be specified for address types.
+// ParserError 9106: (989-993): State mutability can only be specified for address types.
+// ParserError 9106: (1031-1035): State mutability can only be specified for address types.
+// ParserError 9106: (1078-1082): State mutability can only be specified for address types.
+// ParserError 9106: (1121-1125): State mutability can only be specified for address types.
+// ParserError 9106: (1169-1173): State mutability can only be specified for address types.
+// ParserError 9106: (1226-1230): State mutability can only be specified for address types.
+// ParserError 9106: (1269-1273): State mutability can only be specified for address types.
+// ParserError 9106: (1309-1313): State mutability can only be specified for address types.
+// ParserError 9106: (1352-1356): State mutability can only be specified for address types.
+// ParserError 9106: (1393-1397): State mutability can only be specified for address types.
+// ParserError 9106: (1437-1441): State mutability can only be specified for address types.
+// ParserError 9106: (1480-1484): State mutability can only be specified for address types.
+// ParserError 9106: (1522-1526): State mutability can only be specified for address types.
+// ParserError 9106: (1566-1570): State mutability can only be specified for address types.
+// ParserError 9106: (1608-1612): State mutability can only be specified for address types.
+// ParserError 9106: (1655-1659): State mutability can only be specified for address types.
+// ParserError 9106: (1698-1702): State mutability can only be specified for address types.
+// ParserError 9106: (1746-1750): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_file_var.sol b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_file_var.sol
new file mode 100644
index 00000000..25b9acc9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_file_var.sol
@@ -0,0 +1,81 @@
+bool payable a;
+string payable b;
+int payable c;
+int256 payable d;
+uint payable e;
+uint256 payable f;
+bytes1 payable g;
+bytes payable h;
+bytes32 payable i;
+fixed payable j;
+fixed80x80 payable k;
+ufixed payable l;
+ufixed80x80 payable m;
+
+bool view a2;
+string view b2;
+int view c2;
+int256 view d2;
+uint view e2;
+uint256 view f2;
+bytes1 view g2;
+bytes view h2;
+bytes32 view i2;
+fixed view j2;
+fixed80x80 view k2;
+ufixed view l2;
+ufixed80x80 view m2;
+
+bool pure a3;
+string pure b3;
+int pure c3;
+int256 pure d3;
+uint pure e3;
+uint256 pure f3;
+bytes1 pure g3;
+bytes pure h3;
+bytes32 pure i3;
+fixed pure j3;
+fixed80x80 pure k3;
+ufixed pure l3;
+ufixed80x80 pure m3;
+// ----
+// ParserError 9106: (5-12): State mutability can only be specified for address types.
+// ParserError 9106: (23-30): State mutability can only be specified for address types.
+// ParserError 9106: (38-45): State mutability can only be specified for address types.
+// ParserError 9106: (56-63): State mutability can only be specified for address types.
+// ParserError 9106: (72-79): State mutability can only be specified for address types.
+// ParserError 9106: (91-98): State mutability can only be specified for address types.
+// ParserError 9106: (109-116): State mutability can only be specified for address types.
+// ParserError 9106: (126-133): State mutability can only be specified for address types.
+// ParserError 9106: (145-152): State mutability can only be specified for address types.
+// ParserError 9106: (162-169): State mutability can only be specified for address types.
+// ParserError 9106: (184-191): State mutability can only be specified for address types.
+// ParserError 9106: (202-209): State mutability can only be specified for address types.
+// ParserError 9106: (225-232): State mutability can only be specified for address types.
+// ParserError 9106: (242-246): State mutability can only be specified for address types.
+// ParserError 9106: (258-262): State mutability can only be specified for address types.
+// ParserError 9106: (271-275): State mutability can only be specified for address types.
+// ParserError 9106: (287-291): State mutability can only be specified for address types.
+// ParserError 9106: (301-305): State mutability can only be specified for address types.
+// ParserError 9106: (318-322): State mutability can only be specified for address types.
+// ParserError 9106: (334-338): State mutability can only be specified for address types.
+// ParserError 9106: (349-353): State mutability can only be specified for address types.
+// ParserError 9106: (366-370): State mutability can only be specified for address types.
+// ParserError 9106: (381-385): State mutability can only be specified for address types.
+// ParserError 9106: (401-405): State mutability can only be specified for address types.
+// ParserError 9106: (417-421): State mutability can only be specified for address types.
+// ParserError 9106: (438-442): State mutability can only be specified for address types.
+// ParserError 9106: (453-457): State mutability can only be specified for address types.
+// ParserError 9106: (469-473): State mutability can only be specified for address types.
+// ParserError 9106: (482-486): State mutability can only be specified for address types.
+// ParserError 9106: (498-502): State mutability can only be specified for address types.
+// ParserError 9106: (512-516): State mutability can only be specified for address types.
+// ParserError 9106: (529-533): State mutability can only be specified for address types.
+// ParserError 9106: (545-549): State mutability can only be specified for address types.
+// ParserError 9106: (560-564): State mutability can only be specified for address types.
+// ParserError 9106: (577-581): State mutability can only be specified for address types.
+// ParserError 9106: (592-596): State mutability can only be specified for address types.
+// ParserError 9106: (612-616): State mutability can only be specified for address types.
+// ParserError 9106: (628-632): State mutability can only be specified for address types.
+// ParserError 9106: (649-653): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_local.sol b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_local.sol
new file mode 100644
index 00000000..d0b25a53
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_local.sol
@@ -0,0 +1,91 @@
+contract C {
+    function f() public pure {
+        bool payable a;
+        string payable b;
+        int payable c;
+        int256 payable d;
+        uint payable e;
+        uint256 payable f;
+        bytes1 payable g;
+        bytes payable h;
+        bytes32 payable i;
+        fixed payable j;
+        fixed80x80 payable k;
+        ufixed payable l;
+        ufixed80x80 payable m;
+    }
+}
+contract C2 {
+    function f() public pure {
+        bool view a;
+        string view b;
+        int view c;
+        int256 view d;
+        uint view e;
+        uint256 view f;
+        bytes1 view g;
+        bytes view h;
+        bytes32 view i;
+        fixed view j;
+        fixed80x80 view k;
+        ufixed view l;
+        ufixed80x80 view m;
+    }
+}
+contract C3 {
+    function f() public pure {
+        bool pure a;
+        string pure b;
+        int pure c;
+        int256 pure d;
+        uint pure e;
+        uint256 pure f;
+        bytes1 pure g;
+        bytes pure h;
+        bytes32 pure i;
+        fixed pure j;
+        fixed80x80 pure k;
+        ufixed pure l;
+        ufixed80x80 pure m;
+    }
+}
+// ----
+// ParserError 9106: (57-64): State mutability can only be specified for address types.
+// ParserError 9106: (83-90): State mutability can only be specified for address types.
+// ParserError 9106: (106-113): State mutability can only be specified for address types.
+// ParserError 9106: (132-139): State mutability can only be specified for address types.
+// ParserError 9106: (156-163): State mutability can only be specified for address types.
+// ParserError 9106: (183-190): State mutability can only be specified for address types.
+// ParserError 9106: (209-216): State mutability can only be specified for address types.
+// ParserError 9106: (234-241): State mutability can only be specified for address types.
+// ParserError 9106: (261-268): State mutability can only be specified for address types.
+// ParserError 9106: (286-293): State mutability can only be specified for address types.
+// ParserError 9106: (316-323): State mutability can only be specified for address types.
+// ParserError 9106: (342-349): State mutability can only be specified for address types.
+// ParserError 9106: (373-380): State mutability can only be specified for address types.
+// ParserError 9106: (450-454): State mutability can only be specified for address types.
+// ParserError 9106: (473-477): State mutability can only be specified for address types.
+// ParserError 9106: (493-497): State mutability can only be specified for address types.
+// ParserError 9106: (516-520): State mutability can only be specified for address types.
+// ParserError 9106: (537-541): State mutability can only be specified for address types.
+// ParserError 9106: (561-565): State mutability can only be specified for address types.
+// ParserError 9106: (584-588): State mutability can only be specified for address types.
+// ParserError 9106: (606-610): State mutability can only be specified for address types.
+// ParserError 9106: (630-634): State mutability can only be specified for address types.
+// ParserError 9106: (652-656): State mutability can only be specified for address types.
+// ParserError 9106: (679-683): State mutability can only be specified for address types.
+// ParserError 9106: (702-706): State mutability can only be specified for address types.
+// ParserError 9106: (730-734): State mutability can only be specified for address types.
+// ParserError 9106: (804-808): State mutability can only be specified for address types.
+// ParserError 9106: (827-831): State mutability can only be specified for address types.
+// ParserError 9106: (847-851): State mutability can only be specified for address types.
+// ParserError 9106: (870-874): State mutability can only be specified for address types.
+// ParserError 9106: (891-895): State mutability can only be specified for address types.
+// ParserError 9106: (915-919): State mutability can only be specified for address types.
+// ParserError 9106: (938-942): State mutability can only be specified for address types.
+// ParserError 9106: (960-964): State mutability can only be specified for address types.
+// ParserError 9106: (984-988): State mutability can only be specified for address types.
+// ParserError 9106: (1006-1010): State mutability can only be specified for address types.
+// ParserError 9106: (1033-1037): State mutability can only be specified for address types.
+// ParserError 9106: (1056-1060): State mutability can only be specified for address types.
+// ParserError 9106: (1084-1088): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_return.sol b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_return.sol
new file mode 100644
index 00000000..9e428fa9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_return.sol
@@ -0,0 +1,85 @@
+contract C {
+    function a() public pure returns (bool payable) {}
+    function b() public pure returns (string payable) {}
+    function c() public pure returns (int payable) {}
+    function d() public pure returns (int256 payable) {}
+    function e() public pure returns (uint payable) {}
+    function f() public pure returns (uint256 payable) {}
+    function g() public pure returns (bytes1 payable) {}
+    function h() public pure returns (bytes payable) {}
+    function i() public pure returns (bytes32 payable) {}
+    function j() public pure returns (fixed payable) {}
+    function k() public pure returns (fixed80x80 payable) {}
+    function l() public pure returns (ufixed payable) {}
+    function m() public pure returns (ufixed80x80 payable) {}
+}
+contract C1 {
+    function a() public pure returns (bool view) {}
+    function b() public pure returns (string view) {}
+    function c() public pure returns (int view) {}
+    function d() public pure returns (int256 view) {}
+    function e() public pure returns (uint view) {}
+    function f() public pure returns (uint256 view) {}
+    function g() public pure returns (bytes1 view) {}
+    function h() public pure returns (bytes view) {}
+    function i() public pure returns (bytes32 view) {}
+    function j() public pure returns (fixed view) {}
+    function k() public pure returns (fixed80x80 view) {}
+    function l() public pure returns (ufixed view) {}
+    function m() public pure returns (ufixed80x80 view) {}
+}
+contract C2 {
+    function a() public pure returns (bool pure) {}
+    function b() public pure returns (string pure) {}
+    function c() public pure returns (int pure) {}
+    function d() public pure returns (int256 pure) {}
+    function e() public pure returns (uint pure) {}
+    function f() public pure returns (uint256 pure) {}
+    function g() public pure returns (bytes1 pure) {}
+    function h() public pure returns (bytes pure) {}
+    function i() public pure returns (bytes32 pure) {}
+    function j() public pure returns (fixed pure) {}
+    function k() public pure returns (fixed80x80 pure) {}
+    function l() public pure returns (ufixed pure) {}
+    function m() public pure returns (ufixed80x80 pure) {}
+}
+// ----
+// ParserError 9106: (56-63): State mutability can only be specified for address types.
+// ParserError 9106: (113-120): State mutability can only be specified for address types.
+// ParserError 9106: (167-174): State mutability can only be specified for address types.
+// ParserError 9106: (224-231): State mutability can only be specified for address types.
+// ParserError 9106: (279-286): State mutability can only be specified for address types.
+// ParserError 9106: (337-344): State mutability can only be specified for address types.
+// ParserError 9106: (394-401): State mutability can only be specified for address types.
+// ParserError 9106: (450-457): State mutability can only be specified for address types.
+// ParserError 9106: (508-515): State mutability can only be specified for address types.
+// ParserError 9106: (564-571): State mutability can only be specified for address types.
+// ParserError 9106: (625-632): State mutability can only be specified for address types.
+// ParserError 9106: (682-689): State mutability can only be specified for address types.
+// ParserError 9106: (744-751): State mutability can only be specified for address types.
+// ParserError 9106: (815-819): State mutability can only be specified for address types.
+// ParserError 9106: (869-873): State mutability can only be specified for address types.
+// ParserError 9106: (920-924): State mutability can only be specified for address types.
+// ParserError 9106: (974-978): State mutability can only be specified for address types.
+// ParserError 9106: (1026-1030): State mutability can only be specified for address types.
+// ParserError 9106: (1081-1085): State mutability can only be specified for address types.
+// ParserError 9106: (1135-1139): State mutability can only be specified for address types.
+// ParserError 9106: (1188-1192): State mutability can only be specified for address types.
+// ParserError 9106: (1243-1247): State mutability can only be specified for address types.
+// ParserError 9106: (1296-1300): State mutability can only be specified for address types.
+// ParserError 9106: (1354-1358): State mutability can only be specified for address types.
+// ParserError 9106: (1408-1412): State mutability can only be specified for address types.
+// ParserError 9106: (1467-1471): State mutability can only be specified for address types.
+// ParserError 9106: (1535-1539): State mutability can only be specified for address types.
+// ParserError 9106: (1589-1593): State mutability can only be specified for address types.
+// ParserError 9106: (1640-1644): State mutability can only be specified for address types.
+// ParserError 9106: (1694-1698): State mutability can only be specified for address types.
+// ParserError 9106: (1746-1750): State mutability can only be specified for address types.
+// ParserError 9106: (1801-1805): State mutability can only be specified for address types.
+// ParserError 9106: (1855-1859): State mutability can only be specified for address types.
+// ParserError 9106: (1908-1912): State mutability can only be specified for address types.
+// ParserError 9106: (1963-1967): State mutability can only be specified for address types.
+// ParserError 9106: (2016-2020): State mutability can only be specified for address types.
+// ParserError 9106: (2074-2078): State mutability can only be specified for address types.
+// ParserError 9106: (2128-2132): State mutability can only be specified for address types.
+// ParserError 9106: (2187-2191): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_state_variable.sol b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_state_variable.sol
new file mode 100644
index 00000000..960929f9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/elementary_non_address_state_mutability_state_variable.sol
@@ -0,0 +1,85 @@
+contract C {
+    bool payable a;
+    string payable b;
+    int payable c;
+    int256 payable d;
+    uint payable e;
+    uint256 payable f;
+    bytes1 payable g;
+    bytes payable h;
+    bytes32 payable i;
+    fixed payable j;
+    fixed80x80 payable k;
+    ufixed payable l;
+    ufixed80x80 payable m;
+}
+contract C2 {
+    bool view a;
+    string view b;
+    int view c;
+    int256 view d;
+    uint view e;
+    uint256 view f;
+    bytes1 view g;
+    bytes view h;
+    bytes32 view i;
+    fixed view j;
+    fixed80x80 view k;
+    ufixed view l;
+    ufixed80x80 view m;
+}
+contract C3 {
+    bool pure a;
+    string pure b;
+    int pure c;
+    int256 pure d;
+    uint pure e;
+    uint256 pure f;
+    bytes1 pure g;
+    bytes pure h;
+    bytes32 pure i;
+    fixed pure j;
+    fixed80x80 pure k;
+    ufixed pure l;
+    ufixed80x80 pure m;
+}
+// ----
+// ParserError 9106: (22-29): State mutability can only be specified for address types.
+// ParserError 9106: (44-51): State mutability can only be specified for address types.
+// ParserError 9106: (63-70): State mutability can only be specified for address types.
+// ParserError 9106: (85-92): State mutability can only be specified for address types.
+// ParserError 9106: (105-112): State mutability can only be specified for address types.
+// ParserError 9106: (128-135): State mutability can only be specified for address types.
+// ParserError 9106: (150-157): State mutability can only be specified for address types.
+// ParserError 9106: (171-178): State mutability can only be specified for address types.
+// ParserError 9106: (194-201): State mutability can only be specified for address types.
+// ParserError 9106: (215-222): State mutability can only be specified for address types.
+// ParserError 9106: (241-248): State mutability can only be specified for address types.
+// ParserError 9106: (263-270): State mutability can only be specified for address types.
+// ParserError 9106: (290-297): State mutability can only be specified for address types.
+// ParserError 9106: (326-330): State mutability can only be specified for address types.
+// ParserError 9106: (345-349): State mutability can only be specified for address types.
+// ParserError 9106: (361-365): State mutability can only be specified for address types.
+// ParserError 9106: (380-384): State mutability can only be specified for address types.
+// ParserError 9106: (397-401): State mutability can only be specified for address types.
+// ParserError 9106: (417-421): State mutability can only be specified for address types.
+// ParserError 9106: (436-440): State mutability can only be specified for address types.
+// ParserError 9106: (454-458): State mutability can only be specified for address types.
+// ParserError 9106: (474-478): State mutability can only be specified for address types.
+// ParserError 9106: (492-496): State mutability can only be specified for address types.
+// ParserError 9106: (515-519): State mutability can only be specified for address types.
+// ParserError 9106: (534-538): State mutability can only be specified for address types.
+// ParserError 9106: (558-562): State mutability can only be specified for address types.
+// ParserError 9106: (591-595): State mutability can only be specified for address types.
+// ParserError 9106: (610-614): State mutability can only be specified for address types.
+// ParserError 9106: (626-630): State mutability can only be specified for address types.
+// ParserError 9106: (645-649): State mutability can only be specified for address types.
+// ParserError 9106: (662-666): State mutability can only be specified for address types.
+// ParserError 9106: (682-686): State mutability can only be specified for address types.
+// ParserError 9106: (701-705): State mutability can only be specified for address types.
+// ParserError 9106: (719-723): State mutability can only be specified for address types.
+// ParserError 9106: (739-743): State mutability can only be specified for address types.
+// ParserError 9106: (757-761): State mutability can only be specified for address types.
+// ParserError 9106: (780-784): State mutability can only be specified for address types.
+// ParserError 9106: (799-803): State mutability can only be specified for address types.
+// ParserError 9106: (823-827): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_indexed.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_indexed.sol
new file mode 100644
index 00000000..0dd79bae
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_indexed.sol
@@ -0,0 +1,11 @@
+==== Source: A ====
+contract test {
+    function f1(uint indexed a) public returns (uint) { }
+}
+==== Source: B ====
+contract test {
+    function f1(uint a) public returns (uint indexed) { }
+}
+// ----
+// ParserError 2314: (A:37-44): Expected ',' but got 'indexed'
+// ParserError 2314: (B:61-68): Expected ',' but got 'indexed'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_mutability.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_mutability.sol
new file mode 100644
index 00000000..60241419
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_function_parameter_and_return_var_mutability.sol
@@ -0,0 +1,9 @@
+contract test {
+    function f1(uint immutable a) public returns (uint immutable) { }
+    function f2(uint constant a) public returns (uint constant) { }
+}
+// ----
+// DeclarationError 8297: (32-48): The "immutable" keyword can only be used for state variables.
+// DeclarationError 8297: (66-80): The "immutable" keyword can only be used for state variables.
+// DeclarationError 1788: (102-117): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 1788: (135-148): The "constant" keyword can only be used for state variables or variables at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_state_variable_location.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_state_variable_location.sol
new file mode 100644
index 00000000..b5b3439f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_state_variable_location.sol
@@ -0,0 +1,11 @@
+==== Source: A ====
+contract test {
+    string memory a;
+}
+==== Source: B ====
+contract test {
+    string calldata a;
+}
+// ----
+// ParserError 2314: (A:27-33): Expected identifier but got 'memory'
+// ParserError 2314: (B:27-35): Expected identifier but got 'calldata'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_indexed.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_indexed.sol
new file mode 100644
index 00000000..9508e795
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_indexed.sol
@@ -0,0 +1,16 @@
+==== Source: A ====
+uint indexed a;
+==== Source: B ====
+contract test {
+    function f(uint a) public {
+        uint indexed a;
+    }
+}
+==== Source: C ====
+contract test {
+    uint indexed a;
+}
+// ----
+// ParserError 2314: (A:5-12): Expected identifier but got 'indexed'
+// ParserError 2314: (B:61-68): Expected ';' but got 'indexed'
+// ParserError 2314: (C:25-32): Expected identifier but got 'indexed'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_mutablity.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_mutablity.sol
new file mode 100644
index 00000000..874a1851
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_mutablity.sol
@@ -0,0 +1,15 @@
+==== Source: A ====
+contract test {
+    function f(uint a) public {
+        uint constant a;
+    }
+}
+==== Source: B ====
+contract test {
+    function f(uint a) public {
+        uint immutable a;
+    }
+}
+// ----
+// ParserError 2314: (A:61-69): Expected ';' but got 'constant'
+// ParserError 2314: (B:61-70): Expected ';' but got 'immutable'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_named_unicode.sol b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_named_unicode.sol
new file mode 100644
index 00000000..0180ebf7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/invalid_variable_named_unicode.sol
@@ -0,0 +1,6 @@
+contract C
+{
+    string unicode = "abc";
+}
+// ----
+// ParserError 2314: (24-31): Expected identifier but got 'ILLEGAL'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_file_level_var.sol b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_file_level_var.sol
new file mode 100644
index 00000000..c7b1558e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_file_level_var.sol
@@ -0,0 +1,10 @@
+==== Source: A ====
+uint[] storage a;
+==== Source: B ====
+uint[] memory b;
+==== Source: C ====
+uint[] calldata c;
+// ----
+// ParserError 2314: (A:7-14): Expected identifier but got 'storage'
+// ParserError 2314: (B:7-13): Expected identifier but got 'memory'
+// ParserError 2314: (C:7-15): Expected identifier but got 'calldata'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_fn_returns_multi.sol b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_fn_returns_multi.sol
new file mode 100644
index 00000000..06627bd6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_fn_returns_multi.sol
@@ -0,0 +1,21 @@
+contract Foo {
+    function f1() returns (string calldata calldata) {}
+    function f2() returns (string calldata memory) {}
+    function f3() returns (string calldata storage) {}
+    function f4() returns (string memory calldata) {}
+    function f5() returns (string memory memory) {}
+    function f6() returns (string memory storage) {}
+    function f7() returns (string storage calldata) {}
+    function f8() returns (string storage memory) {}
+    function f9() returns (string storage storage) {}
+}
+// ----
+// ParserError 3548: (58-66): Location already specified.
+// ParserError 3548: (114-120): Location already specified.
+// ParserError 3548: (168-175): Location already specified.
+// ParserError 3548: (221-229): Location already specified.
+// ParserError 3548: (275-281): Location already specified.
+// ParserError 3548: (327-334): Location already specified.
+// ParserError 3548: (381-389): Location already specified.
+// ParserError 3548: (436-442): Location already specified.
+// ParserError 3548: (489-496): Location already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_locals_multi.sol b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_locals_multi.sol
new file mode 100644
index 00000000..f61cd949
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_locals_multi.sol
@@ -0,0 +1,28 @@
+contract Foo {
+    uint[] m_x;
+    function f() public view {
+        uint[] storage memory x = m_x;
+        uint[] memory storage calldata y;
+        uint[] storage calldata x2;
+        uint[] storage storage x3;
+        uint[] calldata memory x4;
+        uint[] calldata calldata x5;
+        uint[] calldata storage x6;
+        uint[] storage memory x4;
+        uint[] storage calldata x5;
+        uint[] storage storage x6;
+        x; y;
+    }
+}
+// ----
+// ParserError 3548: (85-91): Location already specified.
+// ParserError 3548: (123-130): Location already specified.
+// ParserError 3548: (131-139): Location already specified.
+// ParserError 3548: (166-174): Location already specified.
+// ParserError 3548: (202-209): Location already specified.
+// ParserError 3548: (238-244): Location already specified.
+// ParserError 3548: (273-281): Location already specified.
+// ParserError 3548: (310-317): Location already specified.
+// ParserError 3548: (345-351): Location already specified.
+// ParserError 3548: (379-387): Location already specified.
+// ParserError 3548: (415-422): Location already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_params_multi.sol b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_params_multi.sol
new file mode 100644
index 00000000..8d1985cd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_params_multi.sol
@@ -0,0 +1,20 @@
+contract Foo {
+    function f(uint[] storage memory constant x, uint[] memory calldata y) internal { }
+    function f2(uint[] storage storage x) internal { }
+    function f3(uint[] storage calldata x) internal { }
+    function f4(uint[] memory storage x) internal { }
+    function f5(uint[] memory memory x) internal { }
+    function f6(uint[] calldata storage x) internal { }
+    function f7(uint[] calldata memory x) internal { }
+    function f8(uint[] calldata calldata x) internal { }
+}
+// ----
+// ParserError 3548: (45-51): Location already specified.
+// ParserError 3548: (78-86): Location already specified.
+// ParserError 3548: (134-141): Location already specified.
+// ParserError 3548: (189-197): Location already specified.
+// ParserError 3548: (244-251): Location already specified.
+// ParserError 3548: (298-304): Location already specified.
+// ParserError 3548: (353-360): Location already specified.
+// ParserError 3548: (409-415): Location already specified.
+// ParserError 3548: (464-472): Location already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_state_variables_multi.sol b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_state_variables_multi.sol
new file mode 100644
index 00000000..d53f2475
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/location_specifiers_for_state_variables_multi.sol
@@ -0,0 +1,11 @@
+==== Source: A ====
+contract Foo {
+	uint[] memory storage calldata x;
+}
+==== Source: B ====
+contract Foo {
+	uint[] storage storage x;
+}
+// ----
+// ParserError 2314: (A:23-29): Expected identifier but got 'memory'
+// ParserError 2314: (B:23-30): Expected identifier but got 'storage'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_1.sol
new file mode 100644
index 00000000..2cdcb419
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_1.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address user => bytes32 ipfs) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_2.sol
new file mode 100644
index 00000000..63be7cae
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_2.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address => bytes32 ipfs) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_3.sol
new file mode 100644
index 00000000..c2458c39
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_3.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address user => bytes32) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_5.sol
new file mode 100644
index 00000000..e2e510ac
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_5.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address owner => mapping(address spender => bytes32[] notes)) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_6.sol
new file mode 100644
index 00000000..ed3b1107
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_6.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address uint => bytes32 ipfs) names;
+}
+// ----
+// ParserError 2314: (36-40): Expected '=>' but got 'uint'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_7.sol
new file mode 100644
index 00000000..548129d0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_7.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address owner => bytes32[] note) notes;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_8.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_8.sol
new file mode 100644
index 00000000..881b2850
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_8.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address => mapping(address => address) hello) world;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_1.sol
new file mode 100644
index 00000000..551bad67
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_1.sol
@@ -0,0 +1,5 @@
+contract test {
+    address owner;
+    mapping(address owner => bytes32 ipfs) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_2.sol
new file mode 100644
index 00000000..c8db8325
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_2.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address owner => address owner) owner;
+}
+// ----
+// DeclarationError 1809: (20-59): Conflicting parameter name "owner" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_3.sol
new file mode 100644
index 00000000..172accec
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_3.sol
@@ -0,0 +1,7 @@
+contract test {
+    mapping(address owner => mapping(address owner => address owner)) owner;
+}
+// ----
+// DeclarationError 1809: (45-84): Conflicting parameter name "owner" in mapping.
+// DeclarationError 1809: (20-85): Conflicting parameter name "owner" in mapping.
+// DeclarationError 1809: (20-85): Conflicting parameter name "owner" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_4.sol
new file mode 100644
index 00000000..4e4a8589
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_4.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address owner => mapping(address owner => address hello)) world;
+}
+// ----
+// DeclarationError 1809: (20-85): Conflicting parameter name "owner" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_5.sol
new file mode 100644
index 00000000..f2ea8315
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_5.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address owner => mapping(address hello => address owner)) world;
+}
+// ----
+// DeclarationError 1809: (20-85): Conflicting parameter name "owner" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_6.sol
new file mode 100644
index 00000000..56b3de07
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_conflict_6.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address hello => mapping(address owner => address owner)) world;
+}
+// ----
+// DeclarationError 1809: (45-84): Conflicting parameter name "owner" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_1.sol
new file mode 100644
index 00000000..aaf0d4ed
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_1.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint name1 => uint name2) storage map) internal {
+        map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_2.sol
new file mode 100644
index 00000000..de3e1468
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_2.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint name1 => uint) storage map) internal {
+        map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_3.sol
new file mode 100644
index 00000000..d0edd59d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_3.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint => uint name2) storage map) internal {
+        map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_4.sol
new file mode 100644
index 00000000..896a5fdc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_4.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint name1 => mapping(uint name2 => uint name3) name4) storage map) internal {
+        map[1][2] = 3;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_5.sol
new file mode 100644
index 00000000..40f4a44b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_5.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint name1 => uint[] name2) storage map) internal {
+        map[1].push(2);
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_6.sol
new file mode 100644
index 00000000..660f6990
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_6.sol
@@ -0,0 +1,7 @@
+contract test {
+    function _main(mapping(uint nameSame => mapping(uint name2 => mapping(uint nameSame => uint name3) name4) name5) storage map) internal {
+        map[1][2][3] = 4;
+    }
+}
+// ----
+// DeclarationError 1809: (35-132): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_7.sol
new file mode 100644
index 00000000..5234e246
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_param_7.sol
@@ -0,0 +1,6 @@
+contract test {
+    function _main(mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) storage map) internal {
+        map[1][2][3] = 4;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_1.sol
new file mode 100644
index 00000000..c59ab1f1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_1.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint name1 => uint name2) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_2.sol
new file mode 100644
index 00000000..ce5d6e20
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_2.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint name1 => uint) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_3.sol
new file mode 100644
index 00000000..8e441133
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_3.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint => uint name2) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_4.sol
new file mode 100644
index 00000000..22922611
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_4.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint name1 => mapping(uint name2 => uint name3) name4) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_5.sol
new file mode 100644
index 00000000..38b9c6b1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_5.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint name1 => uint[] name2) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_6.sol
new file mode 100644
index 00000000..daf9adc5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_6.sol
@@ -0,0 +1,5 @@
+contract test {
+    function(mapping(uint nameSame => mapping(uint name2 => mapping(uint nameSame => uint name3) name4) name5) storage) internal stateVariableName;
+}
+// ----
+// DeclarationError 1809: (29-126): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_7.sol
new file mode 100644
index 00000000..78e3a513
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_func_type_param_7.sol
@@ -0,0 +1,4 @@
+contract test {
+    function(mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) storage) internal stateVariableName;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_1.sol
new file mode 100644
index 00000000..dad80d59
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_1.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint name1 => uint name2) map;
+
+    function main() external {
+        mapping(uint name3 => uint name4) storage _map = map;
+        _map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_2.sol
new file mode 100644
index 00000000..ee61e084
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_2.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint name1 => uint) map;
+
+    function main() external {
+        mapping(uint => uint name4) storage _map = map;
+        _map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_3.sol
new file mode 100644
index 00000000..963ff82b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_3.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint => uint name2) map;
+
+    function main() external {
+        mapping(uint name3 => uint) storage _map = map;
+        _map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_4.sol
new file mode 100644
index 00000000..e4ebf16a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_4.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint name1 => mapping(uint name2 => uint name3) name4) map;
+
+    function main() external {
+        mapping(uint name5 => uint name6) storage _map = map[1];
+        _map[1] = 2;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_5.sol
new file mode 100644
index 00000000..75582741
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_5.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint name1 => uint[] name4) map;
+
+    function main() external {
+        mapping(uint name5 => uint[] name6) storage _map = map;
+        _map[1].push(2);
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_6.sol
new file mode 100644
index 00000000..d1bda36f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_6.sol
@@ -0,0 +1,10 @@
+contract test {
+    mapping(uint name1 => mapping(uint name2 => uint name3) name4) map;
+
+    function main() external {
+        mapping(uint nameSame => mapping(uint name2 => uint nameSame) name4) storage _map = map;
+        _map[1][2] = 3;
+    }
+}
+// ----
+// DeclarationError 1809: (128-196): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_7.sol
new file mode 100644
index 00000000..ccb44f86
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_7.sol
@@ -0,0 +1,11 @@
+contract test {
+    mapping(uint nameSame => mapping(uint name1 => mapping(uint nameSame => uint name3) name6) name4) map;
+
+    function main() external {
+        mapping(uint nameSame => mapping(uint name1 => mapping(uint nameSame => uint name3) name6) name4) storage _map = map;
+        _map[1][2][3] = 4;
+    }
+}
+// ----
+// DeclarationError 1809: (20-117): Conflicting parameter name "nameSame" in mapping.
+// DeclarationError 1809: (163-260): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_8.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_8.sol
new file mode 100644
index 00000000..08bb80c9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_local_8.sol
@@ -0,0 +1,9 @@
+contract test {
+    mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) map;
+
+    function main() external {
+        mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) storage _map = map;
+        _map[1][2][3] = 4;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_1.sol
new file mode 100644
index 00000000..b5b2bc55
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_1.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address owner => mapping(address spender => bytes32 note)) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_2.sol
new file mode 100644
index 00000000..e65e3be2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_2.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address => mapping(address spender => bytes32 note)) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_3.sol
new file mode 100644
index 00000000..c0a7472a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_3.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address owner => mapping(address => bytes32 note)) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_4.sol
new file mode 100644
index 00000000..011ab97f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_4.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(address owner => mapping(address spender => bytes32)) names;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_5.sol
new file mode 100644
index 00000000..30e37bfa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_5.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(address owner => mapping(address spender => bytes32 note));
+}
+// ----
+// ParserError 2314: (86-87): Expected identifier but got ';'
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_6.sol
new file mode 100644
index 00000000..a31c8d4c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_6.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(uint nameSame => mapping(uint name1 => mapping(uint nameSame => uint name2) name3) name4) name5;
+}
+// ----
+// DeclarationError 1809: (20-117): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_7.sol
new file mode 100644
index 00000000..848f2b5e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_7.sol
@@ -0,0 +1,5 @@
+contract test {
+    mapping(uint nameSame => mapping(uint name1 => mapping(uint nameSame => uint name3) name6) name4) public name5;
+}
+// ----
+// DeclarationError 1809: (20-117): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_8.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_8.sol
new file mode 100644
index 00000000..a3d839a5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_nested_8.sol
@@ -0,0 +1,4 @@
+contract test {
+    mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) public name7;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_1.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_1.sol
new file mode 100644
index 00000000..ce3d8881
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_1.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint phone => uint calls) friends;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_2.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_2.sol
new file mode 100644
index 00000000..69c73300
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_2.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint phone => uint) friends;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_3.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_3.sol
new file mode 100644
index 00000000..ec078ab2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_3.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint => uint calls) friends;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_4.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_4.sol
new file mode 100644
index 00000000..d3ee618a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_4.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint phone => mapping(uint call => uint time) callTimes) friends;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_5.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_5.sol
new file mode 100644
index 00000000..ccc6d1a5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_5.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint phone => uint[] calls) friends;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_6.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_6.sol
new file mode 100644
index 00000000..8b65f281
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_6.sol
@@ -0,0 +1,7 @@
+contract test {
+    struct Person {
+        mapping(uint nameSame => mapping(uint name1 => mapping(uint nameSame => uint name2) name3) name4) name5;
+    }
+}
+// ----
+// DeclarationError 1809: (44-141): Conflicting parameter name "nameSame" in mapping.
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_7.sol b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_7.sol
new file mode 100644
index 00000000..08ce99da
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/mapping_with_names_struct_member_7.sol
@@ -0,0 +1,6 @@
+contract test {
+    struct Person {
+        mapping(uint name1 => mapping(uint name2 => mapping(uint name3 => uint name4) name5) name6) name7;
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/multiple_mutability_specifiers.sol b/compiler/test/libsolidity/syntaxTests/parsing/multiple_mutability_specifiers.sol
new file mode 100644
index 00000000..50579054
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/multiple_mutability_specifiers.sol
@@ -0,0 +1,11 @@
+contract C {
+    uint constant constant a;
+    uint immutable immutable b;
+    uint constant immutable c;
+    uint immutable constant d;
+}
+// ----
+// ParserError 3109: (31-39): Mutability already set to "constant"
+// ParserError 3109: (62-71): Mutability already set to "immutable"
+// ParserError 3109: (93-102): Mutability already set to "constant"
+// ParserError 3109: (125-133): Mutability already set to "immutable"
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/multiple_state_mutability_specifiers.sol b/compiler/test/libsolidity/syntaxTests/parsing/multiple_state_mutability_specifiers.sol
new file mode 100644
index 00000000..e9c44010
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/multiple_state_mutability_specifiers.sol
@@ -0,0 +1,103 @@
+==== Source: A ====
+contract c1 {
+    function f() payable payable {}
+}
+contract c2 {
+    function f() view view {}
+}
+contract c3 {
+    function f() pure pure {}
+}
+contract c4 {
+    function f() pure view {}
+}
+contract c5 {
+    function f() payable view {}
+}
+contract c6 {
+    function f() pure payable {}
+}
+contract c7 {
+    function f() view payable {}
+}
+contract c8 {
+    function f() payable pure {}
+}
+contract c9 {
+    function f() view pure {}
+}
+==== Source: B ====
+contract c {
+    address payable payable v;
+}
+==== Source: C ====
+contract c {
+    function fn(address payable payable) public { }
+}
+==== Source: D ====
+contract c {
+    function fn() public returns (address payable payable) { }
+}
+==== Source: E ====
+contract c {
+    function fn() public {
+        address payable payable v;
+    }
+}
+==== Source: F ====
+contract c {
+    function fn(address payable payable v) public { }
+}
+==== Source: G ====
+contract c {
+    function fn() public returns (address payable payable res) { }
+}
+==== Source: H ====
+address payable payable v;
+==== Source: I ====
+contract c {
+    modifier m(address payable payable x)  { _; }
+}
+==== Source: J ====
+contract c {
+    event e(address payable payable x);
+}
+==== Source: K ====
+contract c {
+    error e1(address payable payable x);
+}
+==== Source: L ====
+contract c {
+    function f() public returns (address payable) {
+        try this.f() returns (address payable payable) { } catch { }
+    }
+}
+==== Source: M ====
+contract c {
+    function f() public returns (address payable) {
+        try this.f() returns (address payable) { } catch Error(address payable payable) { }
+    }
+}
+// ----
+// ParserError 9680: (A:39-46): State mutability already specified as "payable".
+// ParserError 9680: (A:88-92): State mutability already specified as "view".
+// ParserError 9680: (A:134-138): State mutability already specified as "pure".
+// ParserError 9680: (A:180-184): State mutability already specified as "pure".
+// ParserError 9680: (A:229-233): State mutability already specified as "payable".
+// ParserError 9680: (A:275-282): State mutability already specified as "pure".
+// ParserError 9680: (A:324-331): State mutability already specified as "view".
+// ParserError 9680: (A:376-380): State mutability already specified as "payable".
+// ParserError 9680: (A:422-426): State mutability already specified as "view".
+// ParserError 2314: (B:33-40): Expected identifier but got 'payable'
+// ParserError 2314: (C:45-52): Expected ',' but got 'payable'
+// ParserError 2314: (D:63-70): Expected ',' but got 'payable'
+// ParserError 2314: (E:64-71): Expected identifier but got 'payable'
+// ParserError 2314: (F:45-52): Expected ',' but got 'payable'
+// ParserError 2314: (G:63-70): Expected ',' but got 'payable'
+// ParserError 2314: (H:16-23): Expected identifier but got 'payable'
+// ParserError 2314: (I:44-51): Expected ',' but got 'payable'
+// ParserError 2314: (J:41-48): Expected ',' but got 'payable'
+// ParserError 2314: (K:42-49): Expected ',' but got 'payable'
+// ParserError 2314: (L:111-118): Expected ',' but got 'payable'
+// ParserError 2314: (M:144-151): Expected ',' but got 'payable'
+
diff --git a/compiler/test/libsolidity/syntaxTests/parsing/unary_plus_expression.sol b/compiler/test/libsolidity/syntaxTests/parsing/unary_plus_expression.sol
new file mode 100644
index 00000000..527c9450
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/parsing/unary_plus_expression.sol
@@ -0,0 +1,8 @@
+contract test {
+    function f(uint x) pure public {
+        uint y = +x;
+        y;
+    }
+}
+// ----
+// ParserError 9636: (70-71): Use of unary + is disallowed.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/blank_space_version.sol b/compiler/test/libsolidity/syntaxTests/pragma/blank_space_version.sol
new file mode 100644
index 00000000..d4c6eadc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/blank_space_version.sol
@@ -0,0 +1,3 @@
+pragma solidity ;
+// ----
+// ParserError 1684: (0-17): Invalid version pragma. Empty version pragma.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/broken_version_2.sol b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_2.sol
new file mode 100644
index 00000000..67c37fe6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_2.sol
@@ -0,0 +1,3 @@
+pragma solidity pragma;
+// ----
+// ParserError 1684: (0-23): Invalid version pragma. Expected the start of a version number but instead found character 'p'. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/broken_version_4.sol b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_4.sol
new file mode 100644
index 00000000..ab9faa17
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_4.sol
@@ -0,0 +1,3 @@
+pragma solidity (8.0.0);
+// ----
+// ParserError 1684: (0-24): Invalid version pragma. Expected the start of a version number but instead found character '('. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/broken_version_5.sol b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_5.sol
new file mode 100644
index 00000000..d858fdfa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_5.sol
@@ -0,0 +1,3 @@
+pragma solidity 88_;
+// ----
+// ParserError 1684: (0-20): Invalid version pragma. Expected the start of a version number but instead found character '_'. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/broken_version_6.sol b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_6.sol
new file mode 100644
index 00000000..ee47523a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_6.sol
@@ -0,0 +1,3 @@
+pragma solidity v1.2.3;
+// ----
+// ParserError 1684: (0-23): Invalid version pragma. Expected the start of a version number but instead found character 'v'. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/broken_version_7.sol b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_7.sol
new file mode 100644
index 00000000..88fad9c9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/broken_version_7.sol
@@ -0,0 +1,3 @@
+pragma solidity >0.5.0<;
+// ----
+// ParserError 1684: (0-24): Invalid version pragma. Expected version number but reached end of pragma.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/empty_version.sol b/compiler/test/libsolidity/syntaxTests/pragma/empty_version.sol
new file mode 100644
index 00000000..b3042838
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/empty_version.sol
@@ -0,0 +1,3 @@
+pragma solidity;
+// ----
+// ParserError 1684: (0-16): Invalid version pragma. Empty version pragma.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/experimental_multiple_experimental.sol b/compiler/test/libsolidity/syntaxTests/pragma/experimental_multiple_experimental.sol
new file mode 100644
index 00000000..49fe597e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/experimental_multiple_experimental.sol
@@ -0,0 +1,4 @@
+pragma experimental experimental __test;
+// ----
+// SyntaxError 6022: (0-40): Stray arguments.
+
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_first.sol b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_first.sol
new file mode 100644
index 00000000..235549c4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_first.sol
@@ -0,0 +1,3 @@
+pragma solidity 0.4.1 - 0.6.2 0.8.17;
+// ----
+// ParserError 1684: (0-37): Invalid version pragma. You can only combine version ranges using the || operator.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_second.sol b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_second.sol
new file mode 100644
index 00000000..00c6aff6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_range_second.sol
@@ -0,0 +1,3 @@
+pragma solidity 0.8.17 0.4.1 - 0.6.2;
+// ----
+// ParserError 1684: (0-37): Invalid version pragma. Expected the start of a version number but instead found character '-'. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_two_ranges.sol b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_two_ranges.sol
new file mode 100644
index 00000000..a5cb07a1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/invalid_range_conjunction_two_ranges.sol
@@ -0,0 +1,3 @@
+pragma solidity 0.4.0 - 0.4.1 0.4.1 - 0.6.2;
+// ----
+// ParserError 1684: (0-44): Invalid version pragma. You can only combine version ranges using the || operator.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/unterminated_version.sol b/compiler/test/libsolidity/syntaxTests/pragma/unterminated_version.sol
new file mode 100644
index 00000000..2515a967
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/unterminated_version.sol
@@ -0,0 +1,4 @@
+pragma solidity 0.4.3
+pragma abicoder v2;
+// ----
+// ParserError 1684: (0-41): Invalid version pragma. Expected the start of a version number but instead found character 'p'. Version number is invalid or the pragma is not terminated with a semicolon.
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_range_second.sol b/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_range_second.sol
new file mode 100644
index 00000000..f318ec6f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_range_second.sol
@@ -0,0 +1,2 @@
+pragma solidity 0.8.17 || 0.4.1 - 0.9.0;
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_two_ranges.sol b/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_two_ranges.sol
new file mode 100644
index 00000000..6bf3a243
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/valid_range_disjunction_two_ranges.sol
@@ -0,0 +1,2 @@
+pragma solidity 0.4.0 - 0.9.0 || 0.4.1 - 0.6.2;
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/pragma/version_number_too_large.sol b/compiler/test/libsolidity/syntaxTests/pragma/version_number_too_large.sol
new file mode 100644
index 00000000..bde5a9aa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/pragma/version_number_too_large.sol
@@ -0,0 +1,3 @@
+pragma solidity 4294967296;
+// ----
+// ParserError 1684: (0-27): Invalid version pragma. Integer too large to be used in a version number.
diff --git a/compiler/test/libsolidity/syntaxTests/scoping/external_library_function_inside_scope.sol b/compiler/test/libsolidity/syntaxTests/scoping/external_library_function_inside_scope.sol
new file mode 100644
index 00000000..647e5b41
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/scoping/external_library_function_inside_scope.sol
@@ -0,0 +1,9 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function f() public pure {
+        uint x;
+        externalFunction(x);
+    }
+}
+// ----
+// DeclarationError 7576: (120-136): Undeclared identifier. "externalFunction" is not (or not yet) visible at this point.
diff --git a/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_parameter_vs_struct_enum.sol b/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_parameter_vs_struct_enum.sol
new file mode 100644
index 00000000..5c63f652
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_parameter_vs_struct_enum.sol
@@ -0,0 +1,20 @@
+contract C {
+    enum EnumType {A, B, C}
+
+    struct StructType {
+        uint x;
+    }
+
+    function f(StructType memory StructType) external {}
+    function g(EnumType EnumType) external {}
+    function h(EnumType StructType, StructType memory EnumType) external {}
+
+    function z(EnumType e) external returns (uint EnumType) {}
+}
+// ----
+// Warning 2519: (104-132): This declaration shadows an existing declaration.
+// Warning 2519: (161-178): This declaration shadows an existing declaration.
+// Warning 2519: (207-226): This declaration shadows an existing declaration.
+// Warning 2519: (228-254): This declaration shadows an existing declaration.
+// Warning 2519: (314-327): This declaration shadows an existing declaration.
+// TypeError 5172: (104-114): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_return_parameter_vs_struct_enum.sol b/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_return_parameter_vs_struct_enum.sol
new file mode 100644
index 00000000..8afde695
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/scoping/name_shadowing_function_return_parameter_vs_struct_enum.sol
@@ -0,0 +1,20 @@
+contract C {
+    enum EnumType {A, B, C}
+
+    struct StructType {
+        uint x;
+    }
+
+    function f() external returns (StructType memory StructType) {}
+    function g() external returns (EnumType EnumType) {}
+    function h() external returns (EnumType StructType, StructType memory EnumType) {}
+
+    function z(uint EnumType) external returns (EnumType e) {}
+}
+// ----
+// Warning 2519: (124-152): This declaration shadows an existing declaration.
+// Warning 2519: (192-209): This declaration shadows an existing declaration.
+// Warning 2519: (249-268): This declaration shadows an existing declaration.
+// Warning 2519: (270-296): This declaration shadows an existing declaration.
+// Warning 2519: (317-330): This declaration shadows an existing declaration.
+// TypeError 5172: (124-134): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/scoping/state_variable_function_conflict_former_crash.sol b/compiler/test/libsolidity/syntaxTests/scoping/state_variable_function_conflict_former_crash.sol
new file mode 100644
index 00000000..f44ca63f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/scoping/state_variable_function_conflict_former_crash.sol
@@ -0,0 +1,14 @@
+// This used to crash with some compiler versions.
+contract SomeContract {
+
+  uint public balance = 0;
+
+  function balance(uint number) public {}
+
+  function doSomething() public {
+    balance(3);
+  }
+}
+// ----
+// DeclarationError 2333: (106-145): Identifier already declared.
+// TypeError 5704: (185-195): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/shifts/shift_signed_rvalue.sol b/compiler/test/libsolidity/syntaxTests/shifts/shift_signed_rvalue.sol
new file mode 100644
index 00000000..1ca57bdc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/shifts/shift_signed_rvalue.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f(int256 a, int256 b) public returns (int256) {
+        return a >> b;
+    }
+    function g(int256 a, int256 b) public returns (int256) {
+        return a >> (256 - b);
+    }
+}
+// ----
+// TypeError 2271: (89-95): Built-in binary operator >> cannot be applied to types int256 and int256.
+// TypeError 2271: (179-193): Built-in binary operator >> cannot be applied to types int256 and int256.
diff --git a/compiler/test/libsolidity/syntaxTests/signed_rational_modulus.sol b/compiler/test/libsolidity/syntaxTests/signed_rational_modulus.sol
new file mode 100644
index 00000000..a3acf182
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/signed_rational_modulus.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f() public pure {
+        fixed a = 0.42578125 % -0.4271087646484375;
+        fixed b = .5 % a;
+        fixed c = a % b;
+        a; b; c;
+    }
+}
+// ----
+// TypeError 2271: (117-123): Built-in binary operator % cannot be applied to types rational_const 1 / 2 and fixed128x18. Fractional literals not supported.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol
new file mode 100644
index 00000000..21c48cc4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large.sol
@@ -0,0 +1,12 @@
+pragma abicoder v2;
+
+contract test {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// Warning 5574: (21-27154): Contract code size is 27187 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol
new file mode 100644
index 00000000..a0c7267d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_abiencoder_v1.sol
@@ -0,0 +1,12 @@
+pragma abicoder v1;
+
+contract test {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// Warning 5574: (21-27154): Contract code size is 27205 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_byzantium.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_byzantium.sol
new file mode 100644
index 00000000..67dee4ca
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_byzantium.sol
@@ -0,0 +1,10 @@
+contract test {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+// ====
+// EVMVersion: =byzantium
+// ----
+// Warning 5574: (0-27133): Contract code size is 27221 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_homestead.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_homestead.sol
new file mode 100644
index 00000000..946f5e8b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/bytecode_too_large_homestead.sol
@@ -0,0 +1,9 @@
+contract test {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+// ====
+// EVMVersion: =homestead
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_paris.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_paris.sol
new file mode 100644
index 00000000..0a97c87d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_paris.sol
@@ -0,0 +1,31 @@
+contract A {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+
+contract B is A {
+    function g() public pure returns (bool) {
+        return true;
+    }
+}
+
+contract C is A {
+    function g() public pure returns (bool) {
+        return false;
+    }
+}
+
+contract test {
+    constructor() {
+        new B();
+        new C();
+    }
+}
+// ====
+// EVMVersion: =paris
+// ----
+// Warning 5574: (0-27130): Contract code size is 27193 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
+// Warning 5574: (27132-27224): Contract code size is 27219 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
+// Warning 5574: (27226-27319): Contract code size is 27219 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_shanghai.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_shanghai.sol
new file mode 100644
index 00000000..3fc466db
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/combined_too_large_shanghai.sol
@@ -0,0 +1,32 @@
+contract A {
+    function f() public pure returns (string memory ret) {
+        // 27000 bytes long data
+        ret = "........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+
+contract B is A {
+    function g() public pure returns (bool) {
+        return true;
+    }
+}
+
+contract C is A {
+    function g() public pure returns (bool) {
+        return false;
+    }
+}
+
+contract test {
+    constructor() {
+        new B();
+        new C();
+    }
+}
+// ====
+// EVMVersion: =shanghai
+// ----
+// Warning 5574: (0-27130): Contract code size is 27187 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
+// Warning 5574: (27132-27224): Contract code size is 27213 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
+// Warning 5574: (27226-27319): Contract code size is 27212 bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
+// Warning 3860: (27321-27398): Contract initcode size is 54628 bytes and exceeds 49152 bytes (a limit introduced in Shanghai). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_paris.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_paris.sol
new file mode 100644
index 00000000..cbfa9446
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_paris.sol
@@ -0,0 +1,29 @@
+contract A {
+    function f() public pure returns (string memory ret) {
+        // 20000 bytes long data
+        ret = "................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+
+contract B is A {
+    function g() public pure returns (bool) {
+        return true;
+    }
+}
+
+contract C is A {
+    function g() public pure returns (bool) {
+        return false;
+    }
+}
+
+contract test {
+    constructor() {
+        new A();
+        new B();
+        new C();
+    }
+}
+// ====
+// EVMVersion: =paris
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_shanghai.sol b/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_shanghai.sol
new file mode 100644
index 00000000..f82434d5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/sizeLimits/initcode_too_large_shanghai.sol
@@ -0,0 +1,30 @@
+contract A {
+    function f() public pure returns (string memory ret) {
+        // 20000 bytes long data
+        ret = "................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................";
+    }
+}
+
+contract B is A {
+    function g() public pure returns (bool) {
+        return true;
+    }
+}
+
+contract C is A {
+    function g() public pure returns (bool) {
+        return false;
+    }
+}
+
+contract test {
+    constructor() {
+        new A();
+        new B();
+        new C();
+    }
+}
+// ====
+// EVMVersion: =shanghai
+// ----
+// Warning 3860: (20321-20415): Contract initcode size is 60896 bytes and exceeds 49152 bytes (a limit introduced in Shanghai). This contract may not be deployable on Mainnet. Consider enabling the optimizer (with a low "runs" value!), turning off revert strings, or using libraries.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_array_of_unitary_tuples.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_array_of_unitary_tuples.sol
new file mode 100644
index 00000000..1f12fcf3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_array_of_unitary_tuples.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() pure public {
+        abi.decode("", ((uint)[2]));
+        abi.decode("", ((uint)[]));
+        abi.decode("", ((uint)[][3]));
+        abi.decode("", ((uint)[4][]));
+        abi.decode("", ((uint)[5][6]));
+        abi.decode("", (((uint))[5][6]));
+    }
+}
+// ----
+// Warning 6133: (52-79): Statement has no effect.
+// Warning 6133: (89-115): Statement has no effect.
+// Warning 6133: (125-154): Statement has no effect.
+// Warning 6133: (164-193): Statement has no effect.
+// Warning 6133: (203-233): Statement has no effect.
+// Warning 6133: (243-275): Statement has no effect.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_enum.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_enum.sol
new file mode 100644
index 00000000..a44a6573
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_enum.sol
@@ -0,0 +1,8 @@
+contract C {
+    enum Color { red, green, blue }
+    function f() pure public {
+        abi.decode("", (Color));
+    }
+}
+// ----
+// Warning 6133: (88-111): Statement has no effect.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_length_ternary_with_max_keyword.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_length_ternary_with_max_keyword.sol
new file mode 100644
index 00000000..f958f74f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_length_ternary_with_max_keyword.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() pure public {
+        bool x;
+        abi.decode("", (uint[type(x = true ? uint8 : uint8).max]));
+    }
+}
+// ----
+// TypeError 9717: (105-110): Invalid mobile type in true expression.
+// TypeError 3703: (113-118): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_of_tuples.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_of_tuples.sol
new file mode 100644
index 00000000..3b5dc905
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_array_of_tuples.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() pure public {
+        abi.decode("", ((uint, int)[5][6]));
+    }
+}
+// ----
+// TypeError 2614: (68-79): Indexed expression has to be a type, mapping or array (is tuple(type(uint256),type(int256)))
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_array_literal.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_array_literal.sol
new file mode 100644
index 00000000..6f481e0d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_array_literal.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() pure public {
+        abi.decode("", ([uint][2]));
+    }
+}
+// ----
+// TypeError 9563: (69-73): Invalid mobile type.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_ternary_expression.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_ternary_expression.sol
new file mode 100644
index 00000000..97b15f4b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_indexed_ternary_expression.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() pure public {
+        bool x;
+        abi.decode("", ((x = true ? uint : uint)[0]));
+    }
+}
+// ----
+// TypeError 9717: (96-100): Invalid mobile type in true expression.
+// TypeError 3703: (103-107): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_condition_expression.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_condition_expression.sol
new file mode 100644
index 00000000..6e64de72
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_condition_expression.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() pure public {
+        abi.decode("", (true ? uint : uint));
+    }
+}
+// ----
+// TypeError 9717: (75-79): Invalid mobile type in true expression.
+// TypeError 3703: (82-86): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_expression_inside_parentheses.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_expression_inside_parentheses.sol
new file mode 100644
index 00000000..89116481
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_expression_inside_parentheses.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f() pure public {
+        abi.decode("", ((true ? uint : uint)));
+    }
+}
+// ----
+// TypeError 9717: (76-80): Invalid mobile type in true expression.
+// TypeError 3703: (83-87): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_with_side_effect.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_with_side_effect.sol
new file mode 100644
index 00000000..62592e42
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_ternary_with_side_effect.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() pure public {
+        int x;
+        abi.decode("", ((x = 1) > 0 ? int : int));
+    }
+}
+// ----
+// TypeError 9717: (97-100): Invalid mobile type in true expression.
+// TypeError 3703: (103-106): Invalid mobile type in false expression.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_tuple_type.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_tuple_type.sol
new file mode 100644
index 00000000..317244a0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_tuple_type.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() pure public {
+        abi.decode("", ((uint, int)));
+    }
+}
+// ----
+// TypeError 1039: (68-79): Argument has to be a type name.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_type_expression.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_type_expression.sol
new file mode 100644
index 00000000..84640abd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_invalid_argument_type_expression.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() pure public {
+        abi.decode("", (type(uint)));
+    }
+}
+// ----
+// TypeError 1039: (68-78): Argument has to be a type name.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_member_acess.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_member_acess.sol
new file mode 100644
index 00000000..5078fcde
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_member_acess.sol
@@ -0,0 +1,19 @@
+library L {
+    struct S { int a; }
+    enum State { idle, running, blocked }
+}
+
+contract D {
+    struct X { uint b; }
+    enum Color { red, green, blue }
+}
+
+contract C {
+    function f() pure public {
+        abi.decode("", (L.S));
+        abi.decode("", (L.State));
+        abi.decode("", (D.X));
+        abi.decode("", (D.Color));
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_unitary_nested_tuple.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_unitary_nested_tuple.sol
new file mode 100644
index 00000000..8da0f0a0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/abidecode/abi_decode_unitary_nested_tuple.sol
@@ -0,0 +1,13 @@
+struct S { int a; }
+
+contract C {
+    function f() pure public {
+        abi.decode("", (((uint))));
+        abi.decode("", ((((uint)))));
+        abi.decode("", (((S))));
+    }
+}
+// ----
+// Warning 6133: (73-99): Statement has no effect.
+// Warning 6133: (109-137): Statement has no effect.
+// Warning 6133: (147-170): Statement has no effect.
diff --git a/compiler/test/libsolidity/syntaxTests/specialFunctions/encodeCall_fail_funType.sol b/compiler/test/libsolidity/syntaxTests/specialFunctions/encodeCall_fail_funType.sol
new file mode 100644
index 00000000..9ac254c9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/specialFunctions/encodeCall_fail_funType.sol
@@ -0,0 +1,78 @@
+interface I {
+	function fExternal(uint256 p, string memory t) external;
+}
+
+contract Other {
+	function fExternal(uint) external pure {}
+	function fPublic(uint) public pure {}
+	function fInternal(uint) internal pure {}
+}
+
+library L {
+	function fExternal(uint256 p, string memory t) external {}
+	function fInternal(uint256 p, string memory t) internal {}
+}
+
+contract Base {
+	function baseFunctionInternal(uint) internal pure {}
+	function baseFunctionPublic(uint) public pure {}
+}
+
+function fileLevel(uint) pure {}
+
+contract C is Base {
+	using L for uint256;
+
+	function fPublic(int a) public {}
+	function fInternal(uint256 p, string memory t) internal {}
+
+	function failFunctionPtrMissing() public returns(bytes memory) {
+		return abi.encodeCall(1, this.fPublic);
+	}
+	function failFunctionPtrWrongType() public returns(bytes memory) {
+		return abi.encodeCall(abi.encodeCall, (1, 2, 3, "test"));
+	}
+	function failFunctionInternal() public returns(bytes memory) {
+		return abi.encodeCall(fInternal, (1, "123"));
+	}
+	function failFunctionInternalFromVariable() public returns(bytes memory) {
+		function(uint256, string memory) internal localFunctionPointer = fInternal;
+		return abi.encodeCall(localFunctionPointer, (1, "123"));
+	}
+	function failLibraryPointerCall() public {
+		abi.encodeCall(L.fInternal, (1, "123"));
+		abi.encodeCall(L.fExternal, (1, "123"));
+	}
+	function failAttachedLibraryPointerCall() public returns (bytes memory) {
+		uint256 x = 1;
+		return abi.encodeCall(x.fExternal, (1, "123"));
+	}
+	function viaBaseDeclaration() public pure returns (bytes memory) {
+		return abi.encodeCall(C.fPublic, (2));
+	}
+	function viaBaseDeclaration2() public pure returns (bytes memory) {
+		return bytes.concat(
+			abi.encodeCall(Base.baseFunctionPublic, (1)),
+			abi.encodeCall(Base.baseFunctionInternal, (1))
+		);
+	}
+	function fileLevelFunction() public pure returns (bytes memory) {
+		return abi.encodeCall(fileLevel, (2));
+	}
+	function createFunction() public pure returns (bytes memory) {
+		return abi.encodeCall(new Other, (2));
+	}
+}
+// ----
+// TypeError 5511: (742-743): Expected first argument to be a function pointer, not "int_const 1".
+// TypeError 3509: (855-869): Expected regular external function type, or external view on public function. Cannot use special function.
+// TypeError 3509: (982-991): Expected regular external function type, or external view on public function. Provided internal function.
+// TypeError 3509: (1187-1207): Expected regular external function type, or external view on public function. Provided internal function.
+// TypeError 3509: (1286-1297): Expected regular external function type, or external view on public function. Provided internal function.
+// TypeError 3509: (1329-1340): Expected regular external function type, or external view on public function. Cannot use library functions for abi.encodeCall.
+// TypeError 3509: (1474-1485): Expected regular external function type, or external view on public function. Cannot use library functions for abi.encodeCall.
+// TypeError 3509: (1595-1604): Expected regular external function type, or external view on public function. Provided internal function. Did you forget to prefix "this."?
+// TypeError 3509: (1725-1748): Expected regular external function type, or external view on public function. Provided internal function. Functions from base contracts have to be external.
+// TypeError 3509: (1774-1799): Expected regular external function type, or external view on public function. Provided internal function. Functions from base contracts have to be external.
+// TypeError 3509: (1905-1914): Expected regular external function type, or external view on public function. Provided internal function.
+// TypeError 3509: (2013-2022): Expected regular external function type, or external view on public function. Provided creation function.
diff --git a/compiler/test/libsolidity/syntaxTests/structs/member_type_func.sol b/compiler/test/libsolidity/syntaxTests/structs/member_type_func.sol
new file mode 100644
index 00000000..dca3086f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/structs/member_type_func.sol
@@ -0,0 +1,7 @@
+contract C {
+  function f() public {}
+  struct S {f x;}
+  function g(function(S memory) external) public {}
+}
+// ----
+// TypeError 5172: (50-51): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_catch.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_catch.sol
new file mode 100644
index 00000000..edb3c530
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_catch.sol
@@ -0,0 +1,31 @@
+contract C {
+    function a() public pure {
+        try this.a() {} catch (string payable memory) {}
+    }
+    function c() public pure {
+        try this.c() {} catch (bytes payable memory) {}
+    }
+}
+contract C2 {
+    function a() public pure {
+        try this.a() {} catch (string view memory) {}
+    }
+    function c() public pure {
+        try this.c() {} catch (bytes view memory) {}
+    }
+}
+contract C3 {
+    function a() public pure {
+        try this.a() {} catch (string pure memory) {}
+    }
+    function c() public pure {
+        try this.c() {} catch (bytes pure memory) {}
+    }
+}
+// ----
+// ParserError 9106: (82-89): State mutability can only be specified for address types.
+// ParserError 9106: (175-182): State mutability can only be specified for address types.
+// ParserError 9106: (285-289): State mutability can only be specified for address types.
+// ParserError 9106: (375-379): State mutability can only be specified for address types.
+// ParserError 9106: (482-486): State mutability can only be specified for address types.
+// ParserError 9106: (572-576): State mutability can only be specified for address types.
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_try_returns.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_try_returns.sol
new file mode 100644
index 00000000..bc16f19c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/elementary_non_address_state_mutability_try_returns.sol
@@ -0,0 +1,163 @@
+contract C {
+    function a() public pure returns (bool) {
+        try this.a() returns (bool payable res) {} catch {}
+    }
+    function b() public pure returns (string) {
+        try this.b() returns (string payable res) {} catch {}
+    }
+    function c() public pure returns (int) {
+        try this.c() returns (int payable res) {} catch {}
+    }
+    function d() public pure returns (int256) {
+        try this.d() returns (int256 payable res) {} catch {}
+    }
+    function e() public pure returns (uint) {
+        try this.e() returns (uint payable res) {} catch {}
+    }
+    function f() public pure returns (uint256) {
+        try this.f() returns (uint256 payable res) {} catch {}
+    }
+    function g() public pure returns (bytes1) {
+        try this.g() returns (bytes1 payable res) {} catch {}
+    }
+    function h() public pure returns (bytes) {
+        try this.h() returns (bytes payable res) {} catch {}
+    }
+    function i() public pure returns (bytes32) {
+        try this.i() returns (bytes32 payable res) {} catch {}
+    }
+    function j() public pure returns (fixed) {
+        try this.j() returns (fixed payable res) {} catch {}
+    }
+    function k() public pure returns (fixed80x80) {
+        try this.k() returns (fixed80x80 payable res) {} catch {}
+    }
+    function l() public pure returns (ufixed) {
+        try this.l() returns (ufixed payable res) {} catch {}
+    }
+    function m() public pure returns (ufixed80x80) {
+        try this.m() returns (ufixed80x80 payable res) {} catch {}
+    }
+}
+contract C1 {
+    function a() public pure returns (bool) {
+        try this.a() returns (bool view res) {} catch {}
+    }
+    function b() public pure returns (string) {
+        try this.b() returns (string view res) {} catch {}
+    }
+    function c() public pure returns (int) {
+        try this.c() returns (int view res) {} catch {}
+    }
+    function d() public pure returns (int256) {
+        try this.d() returns (int256 view res) {} catch {}
+    }
+    function e() public pure returns (uint) {
+        try this.e() returns (uint view res) {} catch {}
+    }
+    function f() public pure returns (uint256) {
+        try this.f() returns (uint256 view res) {} catch {}
+    }
+    function g() public pure returns (bytes1) {
+        try this.g() returns (bytes1 view res) {} catch {}
+    }
+    function h() public pure returns (bytes) {
+        try this.h() returns (bytes view res) {} catch {}
+    }
+    function i() public pure returns (bytes32) {
+        try this.i() returns (bytes32 view res) {} catch {}
+    }
+    function j() public pure returns (fixed) {
+        try this.j() returns (fixed view res) {} catch {}
+    }
+    function k() public pure returns (fixed80x80) {
+        try this.k() returns (fixed80x80 view res) {} catch {}
+    }
+    function l() public pure returns (ufixed) {
+        try this.l() returns (ufixed view res) {} catch {}
+    }
+    function m() public pure returns (ufixed80x80) {
+        try this.m() returns (ufixed80x80 view res) {} catch {}
+    }
+}
+contract C2 {
+    function a() public pure returns (bool) {
+        try this.a() returns (bool pure res) {} catch {}
+    }
+    function b() public pure returns (string) {
+        try this.b() returns (string pure res) {} catch {}
+    }
+    function c() public pure returns (int) {
+        try this.c() returns (int pure res) {} catch {}
+    }
+    function d() public pure returns (int256) {
+        try this.d() returns (int256 pure res) {} catch {}
+    }
+    function e() public pure returns (uint) {
+        try this.e() returns (uint pure res) {} catch {}
+    }
+    function f() public pure returns (uint256) {
+        try this.f() returns (uint256 pure res) {} catch {}
+    }
+    function g() public pure returns (bytes1) {
+        try this.g() returns (bytes1 pure res) {} catch {}
+    }
+    function h() public pure returns (bytes) {
+        try this.h() returns (bytes pure res) {} catch {}
+    }
+    function i() public pure returns (bytes32) {
+        try this.i() returns (bytes32 pure res) {} catch {}
+    }
+    function j() public pure returns (fixed) {
+        try this.j() returns (fixed pure res) {} catch {}
+    }
+    function k() public pure returns (fixed80x80) {
+        try this.k() returns (fixed80x80 pure res) {} catch {}
+    }
+    function l() public pure returns (ufixed) {
+        try this.l() returns (ufixed pure res) {} catch {}
+    }
+    function m() public pure returns (ufixed80x80) {
+        try this.m() returns (ufixed80x80 pure res) {} catch {}
+    }
+}
+// ----
+// ParserError 9106: (94-101): State mutability can only be specified for address types.
+// ParserError 9106: (210-217): State mutability can only be specified for address types.
+// ParserError 9106: (320-327): State mutability can only be specified for address types.
+// ParserError 9106: (436-443): State mutability can only be specified for address types.
+// ParserError 9106: (548-555): State mutability can only be specified for address types.
+// ParserError 9106: (666-673): State mutability can only be specified for address types.
+// ParserError 9106: (782-789): State mutability can only be specified for address types.
+// ParserError 9106: (896-903): State mutability can only be specified for address types.
+// ParserError 9106: (1014-1021): State mutability can only be specified for address types.
+// ParserError 9106: (1128-1135): State mutability can only be specified for address types.
+// ParserError 9106: (1252-1259): State mutability can only be specified for address types.
+// ParserError 9106: (1368-1375): State mutability can only be specified for address types.
+// ParserError 9106: (1494-1501): State mutability can only be specified for address types.
+// ParserError 9106: (1622-1626): State mutability can only be specified for address types.
+// ParserError 9106: (1735-1739): State mutability can only be specified for address types.
+// ParserError 9106: (1842-1846): State mutability can only be specified for address types.
+// ParserError 9106: (1955-1959): State mutability can only be specified for address types.
+// ParserError 9106: (2064-2068): State mutability can only be specified for address types.
+// ParserError 9106: (2179-2183): State mutability can only be specified for address types.
+// ParserError 9106: (2292-2296): State mutability can only be specified for address types.
+// ParserError 9106: (2403-2407): State mutability can only be specified for address types.
+// ParserError 9106: (2518-2522): State mutability can only be specified for address types.
+// ParserError 9106: (2629-2633): State mutability can only be specified for address types.
+// ParserError 9106: (2750-2754): State mutability can only be specified for address types.
+// ParserError 9106: (2863-2867): State mutability can only be specified for address types.
+// ParserError 9106: (2986-2990): State mutability can only be specified for address types.
+// ParserError 9106: (3111-3115): State mutability can only be specified for address types.
+// ParserError 9106: (3224-3228): State mutability can only be specified for address types.
+// ParserError 9106: (3331-3335): State mutability can only be specified for address types.
+// ParserError 9106: (3444-3448): State mutability can only be specified for address types.
+// ParserError 9106: (3553-3557): State mutability can only be specified for address types.
+// ParserError 9106: (3668-3672): State mutability can only be specified for address types.
+// ParserError 9106: (3781-3785): State mutability can only be specified for address types.
+// ParserError 9106: (3892-3896): State mutability can only be specified for address types.
+// ParserError 9106: (4007-4011): State mutability can only be specified for address types.
+// ParserError 9106: (4118-4122): State mutability can only be specified for address types.
+// ParserError 9106: (4239-4243): State mutability can only be specified for address types.
+// ParserError 9106: (4352-4356): State mutability can only be specified for address types.
+// ParserError 9106: (4475-4479): State mutability can only be specified for address types.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_calldata.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_calldata.sol
new file mode 100644
index 00000000..d9302ef1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_calldata.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        try this.f() {} catch (string calldata a) { }
+    }
+}
+// ----
+// TypeError 6651: (70-87): Data location must be "memory" for parameter in function, but "calldata" was given.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_storage.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_storage.sol
new file mode 100644
index 00000000..066b1ebf
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_catch_parameter_location_storage.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public {
+        try this.f() {} catch (string storage a) { }
+    }
+}
+// ----
+// TypeError 6651: (70-86): Data location must be "memory" for parameter in function, but "storage" was given.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_var_location.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_var_location.sol
new file mode 100644
index 00000000..c9980026
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_var_location.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string storage a) {} catch { }
+    }
+}
+// ----
+// TypeError 6651: (93-109): Data location must be "memory" for parameter in function, but "storage" was given.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_indexed.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_indexed.sol
new file mode 100644
index 00000000..43e04583
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_indexed.sol
@@ -0,0 +1,27 @@
+==== Source: A ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint indexed a) {
+        } catch { }
+    }
+}
+==== Source: E ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch Error(string memory indexed x) {
+        }
+    }
+}
+==== Source: I ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch (bytes memory indexed x) {
+        }
+    }
+}
+// ----
+// ParserError 2314: (A:89-96): Expected ',' but got 'indexed'
+// ParserError 2314: (E:128-135): Expected ',' but got 'indexed'
+// ParserError 2314: (I:122-129): Expected ',' but got 'indexed'
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_mutability.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_mutability.sol
new file mode 100644
index 00000000..bbc267f8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_mutability.sol
@@ -0,0 +1,30 @@
+contract C {
+    function f() public returns (uint, uint) {
+        try this.f() returns (uint constant a, uint immutable b) {
+        } catch Error(string memory immutable x) {
+            x;
+        }
+
+        try this.f() returns (uint a, uint b) {
+        } catch (bytes memory immutable x) {
+            x;
+        }
+
+        try this.f() returns (uint a, uint b) {
+        } catch Error(string memory constant x) {
+            x;
+        }
+
+        try this.f() returns (uint a, uint b) {
+        } catch (bytes memory constant x) {
+            x;
+        }
+    }
+}
+// ----
+// DeclarationError 1788: (90-105): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 8297: (107-123): The "immutable" keyword can only be used for state variables.
+// DeclarationError 8297: (149-174): The "immutable" keyword can only be used for state variables.
+// DeclarationError 8297: (269-293): The "immutable" keyword can only be used for state variables.
+// DeclarationError 1788: (393-417): The "constant" keyword can only be used for state variables or variables at file level.
+// DeclarationError 1788: (512-535): The "constant" keyword can only be used for state variables or variables at file level.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_visibility.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_visibility.sol
new file mode 100644
index 00000000..1828f25d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/invalid_returns_vars_and_catch_parameter_visibility.sol
@@ -0,0 +1,105 @@
+==== Source: A ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint public a) {
+        } catch { }
+    }
+}
+==== Source: B ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint private a) {
+        } catch { }
+    }
+}
+==== Source: C ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint external a) {
+        } catch { }
+    }
+}
+==== Source: D ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint internal a) {
+        } catch { }
+    }
+}
+==== Source: E ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch Error(string memory public x) {
+        }
+    }
+}
+==== Source: F ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch Error(string memory private x) {
+        }
+    }
+}
+==== Source: G ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch Error(string memory external x) {
+        }
+    }
+}
+==== Source: H ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch Error(string memory internal x) {
+        }
+    }
+}
+==== Source: I ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch (bytes memory public x) {
+        }
+    }
+}
+==== Source: J ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch (bytes memory private x) {
+        }
+    }
+}
+==== Source: K ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch (bytes memory external x) {
+        }
+    }
+}
+==== Source: L ====
+contract C {
+    function f() public returns (uint) {
+        try this.f() returns (uint) {
+        } catch (bytes memory internal x) {
+        }
+    }
+}
+// ----
+// ParserError 2314: (A:89-95): Expected ',' but got 'public'
+// ParserError 2314: (B:89-96): Expected ',' but got 'private'
+// ParserError 2314: (C:89-97): Expected ',' but got 'external'
+// ParserError 2314: (D:89-97): Expected ',' but got 'internal'
+// ParserError 2314: (E:128-134): Expected ',' but got 'public'
+// ParserError 2314: (F:128-135): Expected ',' but got 'private'
+// ParserError 2314: (G:128-136): Expected ',' but got 'external'
+// ParserError 2314: (H:128-136): Expected ',' but got 'internal'
+// ParserError 2314: (I:122-128): Expected ',' but got 'public'
+// ParserError 2314: (J:122-129): Expected ',' but got 'private'
+// ParserError 2314: (K:122-130): Expected ',' but got 'external'
+// ParserError 2314: (L:122-130): Expected ',' but got 'internal'
\ No newline at end of file
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_homestead.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_homestead.sol
new file mode 100644
index 00000000..1588301b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_homestead.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch (bytes memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =homestead
+// ----
+// TypeError 9908: (73-106): This catch clause type cannot be used on the selected EVM version (homestead). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_spuriousDragon.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_spuriousDragon.sol
new file mode 100644
index 00000000..19728ca2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_spuriousDragon.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch (bytes memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =spuriousDragon
+// ----
+// TypeError 9908: (73-106): This catch clause type cannot be used on the selected EVM version (spuriousDragon). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_tangerineWhistle.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_tangerineWhistle.sol
new file mode 100644
index 00000000..33d17d84
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/low_level_tangerineWhistle.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch (bytes memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =tangerineWhistle
+// ----
+// TypeError 9908: (73-106): This catch clause type cannot be used on the selected EVM version (tangerineWhistle). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/multiple_returns_vars_and_catch_parameter_location.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/multiple_returns_vars_and_catch_parameter_location.sol
new file mode 100644
index 00000000..88df3f5b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/multiple_returns_vars_and_catch_parameter_location.sol
@@ -0,0 +1,132 @@
+==== Source: A1 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string memory memory a) { } catch { }
+    }
+}
+==== Source: A2 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string memory storage a) { } catch { }
+    }
+}
+==== Source: A3 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string memory calldata a) { } catch { }
+    }
+}
+
+==== Source: B1 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string calldata memory a) { } catch { }
+    }
+}
+==== Source: B2 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string calldata storage a) { } catch { }
+    }
+}
+==== Source: B3 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string calldata calldata a) { } catch { }
+    }
+}
+
+==== Source: C1 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string storage memory a) { } catch { }
+    }
+}
+==== Source: C2 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string storage storage a) { } catch { }
+    }
+}
+==== Source: C3 ====
+contract C {
+    function f() public returns (string memory) {
+        try this.f() returns (string storage calldata a) { } catch { }
+    }
+}
+
+==== Source: D1 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string memory memory x) { }
+    }
+}
+==== Source: D2 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string memory calldata x) { }
+    }
+}
+==== Source: D3 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string memory storage x) { }
+    }
+}
+
+==== Source: E1 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string calldata memory x) { }
+    }
+}
+==== Source: E2 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string calldata calldata x) { }
+    }
+}
+==== Source: E3 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string calldata storage x) { }
+    }
+}
+
+==== Source: G1 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string storage memory x) { }
+    }
+}
+==== Source: G2 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string storage calldata x) { }
+    }
+}
+==== Source: G3 ====
+contract C {
+    function f() public {
+        try this.f() {}  catch (string storage storage x) { }
+    }
+}
+// ----
+// ParserError 3548: (A1:107-113): Location already specified.
+// ParserError 3548: (A2:107-114): Location already specified.
+// ParserError 3548: (A3:107-115): Location already specified.
+// ParserError 3548: (B1:109-115): Location already specified.
+// ParserError 3548: (B2:109-116): Location already specified.
+// ParserError 3548: (B3:109-117): Location already specified.
+// ParserError 3548: (C1:108-114): Location already specified.
+// ParserError 3548: (C2:108-115): Location already specified.
+// ParserError 3548: (C3:108-116): Location already specified.
+// ParserError 3548: (D1:85-91): Location already specified.
+// ParserError 3548: (D2:85-93): Location already specified.
+// ParserError 3548: (D3:85-92): Location already specified.
+// ParserError 3548: (E1:87-93): Location already specified.
+// ParserError 3548: (E2:87-95): Location already specified.
+// ParserError 3548: (E3:87-94): Location already specified.
+// ParserError 3548: (G1:86-92): Location already specified.
+// ParserError 3548: (G2:86-94): Location already specified.
+// ParserError 3548: (G3:86-93): Location already specified.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/structured_homestead.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_homestead.sol
new file mode 100644
index 00000000..b77e6b4e
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_homestead.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch Error(string memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =homestead
+// ----
+// TypeError 1812: (73-112): This catch clause type cannot be used on the selected EVM version (homestead). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/structured_spuriousDragon.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_spuriousDragon.sol
new file mode 100644
index 00000000..64863d58
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_spuriousDragon.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch Error(string memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =spuriousDragon
+// ----
+// TypeError 1812: (73-112): This catch clause type cannot be used on the selected EVM version (spuriousDragon). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tryCatch/structured_tangerineWhistle.sol b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_tangerineWhistle.sol
new file mode 100644
index 00000000..c57d1d66
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tryCatch/structured_tangerineWhistle.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public {
+        try this.f() {
+
+        } catch Error(string memory) {
+
+        }
+    }
+}
+// ====
+// EVMVersion: =tangerineWhistle
+// ----
+// TypeError 1812: (73-112): This catch clause type cannot be used on the selected EVM version (tangerineWhistle). You need at least a Byzantium-compatible EVM or use `catch { ... }`.
diff --git a/compiler/test/libsolidity/syntaxTests/tupleAssignments/double_storage_crash.sol b/compiler/test/libsolidity/syntaxTests/tupleAssignments/double_storage_crash.sol
new file mode 100644
index 00000000..b4bbb736
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/tupleAssignments/double_storage_crash.sol
@@ -0,0 +1,10 @@
+// This used to crash in certain compiler versions.
+contract CrashContract {
+       struct S { uint a; }
+       S x;
+       function f() public {
+               (x, x) = 1(x, x);
+       }
+}
+// ----
+// TypeError 5704: (170-177): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/types/address/address_binary_operators.sol b/compiler/test/libsolidity/syntaxTests/types/address/address_binary_operators.sol
new file mode 100644
index 00000000..7535e6da
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/address/address_binary_operators.sol
@@ -0,0 +1,15 @@
+contract C {
+    address a;
+    function f() public pure returns(bool) {
+        a = address(0) + address(0);
+        a = address(0) - address(0);
+        a = address(0) * address(0);
+        a = address(0) / address(0);
+        return address(0) == address(0);
+    }
+}
+// ----
+// TypeError 2271: (85-108): Built-in binary operator + cannot be applied to types address and address. Arithmetic operations on addresses are not supported. Convert to integer first before using them.
+// TypeError 2271: (122-145): Built-in binary operator - cannot be applied to types address and address. Arithmetic operations on addresses are not supported. Convert to integer first before using them.
+// TypeError 2271: (159-182): Built-in binary operator * cannot be applied to types address and address. Arithmetic operations on addresses are not supported. Convert to integer first before using them.
+// TypeError 2271: (196-219): Built-in binary operator / cannot be applied to types address and address. Arithmetic operations on addresses are not supported. Convert to integer first before using them.
diff --git a/compiler/test/libsolidity/syntaxTests/types/address/address_nonpayable_selfdestruct.sol b/compiler/test/libsolidity/syntaxTests/types/address/address_nonpayable_selfdestruct.sol
new file mode 100644
index 00000000..0a467757
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/address/address_nonpayable_selfdestruct.sol
@@ -0,0 +1,8 @@
+contract C {
+    function f(address a) public {
+        selfdestruct(a);
+    }
+}
+// ----
+// Warning 5159: (56-68): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// TypeError 9553: (69-70): Invalid type for argument in function call. Invalid implicit conversion from address to address payable requested.
diff --git a/compiler/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol b/compiler/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol
new file mode 100644
index 00000000..754ff2c6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/address/address_payable_selfdestruct.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(address payable a) public {
+        selfdestruct(a);
+    }
+}
+// ----
+// Warning 5159: (64-76): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
diff --git a/compiler/test/libsolidity/syntaxTests/types/bool_ops.sol b/compiler/test/libsolidity/syntaxTests/types/bool_ops.sol
new file mode 100644
index 00000000..08501ff5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/bool_ops.sol
@@ -0,0 +1,53 @@
+contract C {
+    function f(bool a, bool b) public pure {
+        bool c;
+        // OK
+        c = !a;
+        c = !b;
+        c = a == b;
+        c = a != b;
+        c = a || b;
+        c = a && b;
+
+        // Not OK
+        c = a > b;
+        c = a < b;
+        c = a >= b;
+        c = a <= b;
+        c = a & b;
+        c = a | b;
+        c = a ^ b;
+        c = ~a;
+        c = ~b;
+        c = a + b;
+        c = a - b;
+        c = -a;
+        c = -b;
+        c = a * b;
+        c = a / b;
+        c = a ** b;
+        c = a % b;
+        c = a << b;
+        c = a >> b;
+    }
+}
+// ----
+// TypeError 2271: (231-236): Built-in binary operator > cannot be applied to types bool and bool.
+// TypeError 2271: (250-255): Built-in binary operator < cannot be applied to types bool and bool.
+// TypeError 2271: (269-275): Built-in binary operator >= cannot be applied to types bool and bool.
+// TypeError 2271: (289-295): Built-in binary operator <= cannot be applied to types bool and bool.
+// TypeError 2271: (309-314): Built-in binary operator & cannot be applied to types bool and bool.
+// TypeError 2271: (328-333): Built-in binary operator | cannot be applied to types bool and bool.
+// TypeError 2271: (347-352): Built-in binary operator ^ cannot be applied to types bool and bool.
+// TypeError 4907: (366-368): Built-in unary operator ~ cannot be applied to type bool.
+// TypeError 4907: (382-384): Built-in unary operator ~ cannot be applied to type bool.
+// TypeError 2271: (398-403): Built-in binary operator + cannot be applied to types bool and bool.
+// TypeError 2271: (417-422): Built-in binary operator - cannot be applied to types bool and bool.
+// TypeError 4907: (436-438): Built-in unary operator - cannot be applied to type bool.
+// TypeError 4907: (452-454): Built-in unary operator - cannot be applied to type bool.
+// TypeError 2271: (468-473): Built-in binary operator * cannot be applied to types bool and bool.
+// TypeError 2271: (487-492): Built-in binary operator / cannot be applied to types bool and bool.
+// TypeError 2271: (506-512): Built-in binary operator ** cannot be applied to types bool and bool.
+// TypeError 2271: (526-531): Built-in binary operator % cannot be applied to types bool and bool.
+// TypeError 2271: (545-551): Built-in binary operator << cannot be applied to types bool and bool.
+// TypeError 2271: (565-571): Built-in binary operator >> cannot be applied to types bool and bool.
diff --git a/compiler/test/libsolidity/syntaxTests/types/constant_of_invalid_function_type.sol b/compiler/test/libsolidity/syntaxTests/types/constant_of_invalid_function_type.sol
new file mode 100644
index 00000000..c3e58284
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/constant_of_invalid_function_type.sol
@@ -0,0 +1,7 @@
+contract C {
+	// Used to cause internal compiler error.
+	function() returns (x) constant x = x;
+
+}
+// ----
+// TypeError 5172: (77-78): Name has to refer to a user-defined type.
diff --git a/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_base_name_to_var.sol b/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_base_name_to_var.sol
new file mode 100644
index 00000000..72c09455
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_base_name_to_var.sol
@@ -0,0 +1,14 @@
+contract A {
+    function f() external {}
+    function g() external pure {}
+}
+
+contract B is A {
+    function h() external {
+        function() external f = A.f;
+        function() external pure g = A.g;
+    }
+}
+// ----
+// TypeError 9574: (133-160): Type function A.f() is not implicitly convertible to expected type function () external. Special functions cannot be converted to function types.
+// TypeError 9574: (170-202): Type function A.g() pure is not implicitly convertible to expected type function () pure external. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_contract_name_to_var.sol b/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_contract_name_to_var.sol
new file mode 100644
index 00000000..6dcce143
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/contractTypeType/members/assign_function_via_contract_name_to_var.sol
@@ -0,0 +1,14 @@
+contract A {
+    function f() external {}
+    function g() external pure {}
+}
+
+contract B {
+    function h() external {
+        function() external f = A.f;
+        function() external pure g = A.g;
+    }
+}
+// ----
+// TypeError 9574: (128-155): Type function A.f() is not implicitly convertible to expected type function () external. Special functions cannot be converted to function types.
+// TypeError 9574: (165-197): Type function A.g() pure is not implicitly convertible to expected type function () pure external. Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/types/function_call_fail.sol b/compiler/test/libsolidity/syntaxTests/types/function_call_fail.sol
new file mode 100644
index 00000000..67631bc2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/function_call_fail.sol
@@ -0,0 +1,7 @@
+contract C {
+    function f(uint y) public pure {
+        (4(y)) = 2;
+    }
+}
+// ----
+// TypeError 5704: (59-63): This expression is not callable.
diff --git a/compiler/test/libsolidity/syntaxTests/types/hex_literal_bitnot.sol b/compiler/test/libsolidity/syntaxTests/types/hex_literal_bitnot.sol
new file mode 100644
index 00000000..5b24153c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/hex_literal_bitnot.sol
@@ -0,0 +1,5 @@
+contract C {
+    bytes32 b = ~hex"00ff11";
+}
+// ----
+// TypeError 4907: (29-41): Built-in unary operator ~ cannot be applied to type literal_string hex"00ff11".
diff --git a/compiler/test/libsolidity/syntaxTests/types/magic_block_basefee_error.sol b/compiler/test/libsolidity/syntaxTests/types/magic_block_basefee_error.sol
new file mode 100644
index 00000000..3e1650ad
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/magic_block_basefee_error.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.basefee;
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            ret := basefee()
+        }
+    }
+}
+// ====
+// EVMVersion: =berlin
+// ----
+// TypeError 5921: (74-87): "basefee" is not supported by the VM version.
+// TypeError 5430: (183-190): The "basefee" instruction is only available for London-compatible VMs (you are currently compiling for "berlin").
+// DeclarationError 8678: (176-192): Variable count for assignment to "ret" does not match number of values (1 vs. 0)
diff --git a/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_cancun.sol b/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_cancun.sol
new file mode 100644
index 00000000..a639abda
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_cancun.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.blobbasefee;
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            ret := blobbasefee()
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_error.sol b/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_error.sol
new file mode 100644
index 00000000..11a5bd99
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/magic_block_blobbasefee_error.sol
@@ -0,0 +1,16 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.blobbasefee;
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            ret := blobbasefee()
+        }
+    }
+}
+// ====
+// EVMVersion: =shanghai
+// ----
+// TypeError 1006: (74-91): "blobbasefee" is not supported by the VM version.
+// DeclarationError 4619: (187-198): Function "blobbasefee" not found.
+// DeclarationError 8678: (180-200): Variable count for assignment to "ret" does not match number of values (1 vs. 0)
diff --git a/compiler/test/libsolidity/syntaxTests/types/magic_block_istanbul.sol b/compiler/test/libsolidity/syntaxTests/types/magic_block_istanbul.sol
new file mode 100644
index 00000000..62ac0e1f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/magic_block_istanbul.sol
@@ -0,0 +1,17 @@
+contract C {
+    function f() public view returns (address payable) {
+        return block.coinbase;
+    }
+    function g() public view returns (uint) {
+        return block.gaslimit;
+    }
+    function h() public view returns (uint) {
+        return block.timestamp;
+    }
+    function i() public view returns (uint) {
+        return block.chainid;
+    }
+}
+// ====
+// EVMVersion: >=istanbul
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/types/magic_block_paris.sol b/compiler/test/libsolidity/syntaxTests/types/magic_block_paris.sol
new file mode 100644
index 00000000..7875d9b0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/magic_block_paris.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public view returns (uint) {
+        return block.prevrandao;
+    }
+    function g() public view returns (uint ret) {
+        assembly {
+            ret := prevrandao()
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/types/rational_number_bitshift_limit.sol b/compiler/test/libsolidity/syntaxTests/types/rational_number_bitshift_limit.sol
new file mode 100644
index 00000000..801773db
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/rational_number_bitshift_limit.sol
@@ -0,0 +1,13 @@
+contract c {
+    function f() public pure {
+        int a;
+        a = 1 << 4095; // shift is fine, but result too large
+        a = 1 << 4096; // too large
+        a = (1E1233) << 2; // too large
+    }
+}
+// ----
+// TypeError 7407: (71-80): Type int_const 5221...(1225 digits omitted)...5168 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (133-142): Built-in binary operator << cannot be applied to types int_const 1 and int_const 4096.
+// TypeError 2271: (169-182): Built-in binary operator << cannot be applied to types int_const 1000...(1226 digits omitted)...0000 and int_const 2.
+// TypeError 7407: (169-182): Type int_const 1000...(1226 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
diff --git a/compiler/test/libsolidity/syntaxTests/types/rational_number_div_limit.sol b/compiler/test/libsolidity/syntaxTests/types/rational_number_div_limit.sol
new file mode 100644
index 00000000..ae42d5e5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/rational_number_div_limit.sol
@@ -0,0 +1,9 @@
+contract c {
+    function f() public pure {
+        int a;
+        a = 1/(2<<4094)/(2<<4094);
+    }
+}
+// ----
+// TypeError 2271: (71-92): Built-in binary operator / cannot be applied to types rational_const 1 / 5221...(1225 digits omitted)...5168 and int_const 5221...(1225 digits omitted)...5168. Precision of rational constants is limited to 4096 bits.
+// TypeError 2326: (71-92): Type rational_const 1 / 5221...(1225 digits omitted)...5168 is not implicitly convertible to expected type int256. Try converting to type ufixed8x80 or use an explicit conversion.
diff --git a/compiler/test/libsolidity/syntaxTests/types/rational_number_exp_limit_fail.sol b/compiler/test/libsolidity/syntaxTests/types/rational_number_exp_limit_fail.sol
new file mode 100644
index 00000000..fb029202
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/rational_number_exp_limit_fail.sol
@@ -0,0 +1,47 @@
+contract c {
+    function f() public pure {
+        int a;
+        a = (((((4 ** 4) ** 2) ** 4) ** 4) ** 4) ** 4;
+        a = -(((4 ** 4 ** 2 ** 4 ** 4) ** 4) ** 4) ** 4;
+        a = 4 ** (-(2 ** 4 ** 4 ** 4 ** 4 ** 4));
+        a = 2 ** 1E1233;
+        a = -2 ** 1E1233;
+        a = 2 ** -1E1233;
+        a = -2 ** -1E1233;
+        a = 1E1233 ** 2;
+        a = -1E1233 ** 2;
+        a = 1E1233 ** -2;
+        a = -1E1233 ** -2;
+        a = 1E1233 ** 1E1233;
+        a = 1E1233 ** -1E1233;
+        a = -1E1233 ** 1E1233;
+        a = -1E1233 ** -1E1233;
+    }
+}
+// ----
+// TypeError 2271: (71-112): Built-in binary operator ** cannot be applied to types int_const 1797...(301 digits omitted)...7216 and int_const 4.
+// TypeError 7407: (71-112): Type int_const 1797...(301 digits omitted)...7216 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (135-151): Built-in binary operator ** cannot be applied to types int_const 4 and int_const 1157...(70 digits omitted)...9936.
+// TypeError 7407: (126-169): Type int_const 1340...(147 digits omitted)...4096 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (201-217): Built-in binary operator ** cannot be applied to types int_const 4 and int_const 1340...(147 digits omitted)...4096.
+// TypeError 2271: (183-219): Built-in binary operator ** cannot be applied to types int_const 4 and int_const -115...(71 digits omitted)...9936.
+// TypeError 2271: (233-244): Built-in binary operator ** cannot be applied to types int_const 2 and int_const 1000...(1226 digits omitted)...0000.
+// TypeError 2271: (258-270): Built-in binary operator ** cannot be applied to types int_const -2 and int_const 1000...(1226 digits omitted)...0000.
+// TypeError 2271: (284-296): Built-in binary operator ** cannot be applied to types int_const 2 and int_const -100...(1227 digits omitted)...0000.
+// TypeError 2271: (310-323): Built-in binary operator ** cannot be applied to types int_const -2 and int_const -100...(1227 digits omitted)...0000.
+// TypeError 2271: (337-348): Built-in binary operator ** cannot be applied to types int_const 1000...(1226 digits omitted)...0000 and int_const 2.
+// TypeError 7407: (337-348): Type int_const 1000...(1226 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (362-374): Built-in binary operator ** cannot be applied to types int_const -100...(1227 digits omitted)...0000 and int_const 2.
+// TypeError 7407: (362-374): Type int_const -100...(1227 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (388-400): Built-in binary operator ** cannot be applied to types int_const 1000...(1226 digits omitted)...0000 and int_const -2.
+// TypeError 7407: (388-400): Type int_const 1000...(1226 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (414-427): Built-in binary operator ** cannot be applied to types int_const -100...(1227 digits omitted)...0000 and int_const -2.
+// TypeError 7407: (414-427): Type int_const -100...(1227 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (441-457): Built-in binary operator ** cannot be applied to types int_const 1000...(1226 digits omitted)...0000 and int_const 1000...(1226 digits omitted)...0000.
+// TypeError 7407: (441-457): Type int_const 1000...(1226 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (471-488): Built-in binary operator ** cannot be applied to types int_const 1000...(1226 digits omitted)...0000 and int_const -100...(1227 digits omitted)...0000.
+// TypeError 7407: (471-488): Type int_const 1000...(1226 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (502-519): Built-in binary operator ** cannot be applied to types int_const -100...(1227 digits omitted)...0000 and int_const 1000...(1226 digits omitted)...0000.
+// TypeError 7407: (502-519): Type int_const -100...(1227 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
+// TypeError 2271: (533-551): Built-in binary operator ** cannot be applied to types int_const -100...(1227 digits omitted)...0000 and int_const -100...(1227 digits omitted)...0000.
+// TypeError 7407: (533-551): Type int_const -100...(1227 digits omitted)...0000 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
diff --git a/compiler/test/libsolidity/syntaxTests/types/rational_number_mul_limit.sol b/compiler/test/libsolidity/syntaxTests/types/rational_number_mul_limit.sol
new file mode 100644
index 00000000..c23569c9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/types/rational_number_mul_limit.sol
@@ -0,0 +1,9 @@
+contract c {
+    function f() public pure {
+        int a;
+        a = (1<<4095)*(1<<4095);
+    }
+}
+// ----
+// TypeError 2271: (71-90): Built-in binary operator * cannot be applied to types int_const 5221...(1225 digits omitted)...5168 and int_const 5221...(1225 digits omitted)...5168. Precision of rational constants is limited to 4096 bits.
+// TypeError 7407: (71-90): Type int_const 5221...(1225 digits omitted)...5168 is not implicitly convertible to expected type int256. Literal is too large to fit in int256.
diff --git a/compiler/test/libsolidity/syntaxTests/userDefinedValueType/all_value_types.sol b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/all_value_types.sol
new file mode 100644
index 00000000..e1d45300
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/all_value_types.sol
@@ -0,0 +1,13 @@
+type MyAddress is address;
+type MyAddressPayable is address payable;
+type MyInt is int;
+type MyUInt is uint;
+type MyInt128 is int128;
+type MyUInt128 is uint128;
+type MyFixed is fixed;
+type MyUfixed is ufixed;
+type MyFixedBytes32 is bytes32;
+type MyFixedBytes1 is bytes1;
+type MyBool is bool;
+/// test to see if having NatSpec causes issues
+type redundantNatSpec is bytes2;
diff --git a/compiler/test/libsolidity/syntaxTests/userDefinedValueType/mapping_key.sol b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/mapping_key.sol
new file mode 100644
index 00000000..d2d5585c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/mapping_key.sol
@@ -0,0 +1,5 @@
+type MyInt is int;
+contract C {
+    mapping(MyInt => int) m;
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/userDefinedValueType/non_value_type_enum_err.sol b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/non_value_type_enum_err.sol
new file mode 100644
index 00000000..f143bc50
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/non_value_type_enum_err.sol
@@ -0,0 +1,5 @@
+enum E {A, B, C}
+
+type MyType is E;
+// ----
+// TypeError 8657: (33-34): The underlying type for a user defined value type has to be an elementary value type.
diff --git a/compiler/test/libsolidity/syntaxTests/userDefinedValueType/wrap_unwrap_assign_err.sol b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/wrap_unwrap_assign_err.sol
new file mode 100644
index 00000000..30955f31
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/userDefinedValueType/wrap_unwrap_assign_err.sol
@@ -0,0 +1,8 @@
+type MyInt is int;
+function test() pure {
+    function (MyInt) returns (int) f = MyInt.unwrap;
+    function (int) returns (MyInt) g = MyInt.wrap;
+}
+// ----
+// TypeError 9574: (46-93): Type function (MyInt) pure returns (int256) is not implicitly convertible to expected type function (MyInt) returns (int256). Special functions cannot be converted to function types.
+// TypeError 9574: (99-144): Type function (int256) pure returns (MyInt) is not implicitly convertible to expected type function (int256) returns (MyInt). Special functions cannot be converted to function types.
diff --git a/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_accepting_calldata.sol b/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_accepting_calldata.sol
new file mode 100644
index 00000000..a03ffbe8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_accepting_calldata.sol
@@ -0,0 +1,15 @@
+struct S {
+    uint x;
+}
+
+library L {
+    function f(S calldata) internal pure {}
+}
+
+contract C {
+    using L for S;
+
+    function run(S calldata _s) external pure {
+        _s.f();
+    }
+}
diff --git a/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_not_accepting_memory.sol b/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_not_accepting_memory.sol
new file mode 100644
index 00000000..ea03a3bd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/bound_calldata_parameter_not_accepting_memory.sol
@@ -0,0 +1,9 @@
+library D { function f(bytes calldata) internal pure {} }
+contract C {
+	using D for bytes;
+	function f(bytes memory _x) public pure {
+		_x.f();
+	}
+}
+// ----
+// TypeError 9582: (136-140): Member "f" not found or not visible after argument-dependent lookup in bytes memory.
diff --git a/compiler/test/libsolidity/syntaxTests/using/external_function_qualified_with_this.sol b/compiler/test/libsolidity/syntaxTests/using/external_function_qualified_with_this.sol
new file mode 100644
index 00000000..2f400760
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/external_function_qualified_with_this.sol
@@ -0,0 +1,7 @@
+contract C {
+    using {this.contractFunction} for uint;
+
+    function contractFunction(uint) external view {}
+}
+// ----
+// DeclarationError 9589: (24-45): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/free_functions_implicit_conversion_err.sol b/compiler/test/libsolidity/syntaxTests/using/free_functions_implicit_conversion_err.sol
new file mode 100644
index 00000000..32a49bbb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/free_functions_implicit_conversion_err.sol
@@ -0,0 +1,14 @@
+struct S {
+    uint8 x;
+}
+
+function id(uint16 x) pure returns(uint16) {
+    return x;
+}
+contract C {
+    using {id} for uint256;
+    using {id} for S;
+}
+// ----
+// TypeError 3100: (112-114): The function "id" cannot be attached to the type "uint256" because the type cannot be implicitly converted to the first argument of the function ("uint16").
+// TypeError 3100: (140-142): The function "id" cannot be attached to the type "struct S" because the type cannot be implicitly converted to the first argument of the function ("uint16").
diff --git a/compiler/test/libsolidity/syntaxTests/using/free_functions_non_unique_err.sol b/compiler/test/libsolidity/syntaxTests/using/free_functions_non_unique_err.sol
new file mode 100644
index 00000000..7404b0d9
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/free_functions_non_unique_err.sol
@@ -0,0 +1,12 @@
+function id(int8 x) pure returns(int8) {
+    return x;
+}
+function id(uint256 x) pure returns(uint256) {
+    return x;
+}
+
+contract C {
+    using {id} for uint256;
+}
+// ----
+// DeclarationError 9589: (145-147): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/free_overloads.sol b/compiler/test/libsolidity/syntaxTests/using/free_overloads.sol
new file mode 100644
index 00000000..e05580d5
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/free_overloads.sol
@@ -0,0 +1,10 @@
+function f(uint8 x) pure returns (uint) {
+    return x;
+}
+function f(int8 storage x) pure returns (int) {
+    return x[0];
+}
+using {f} for uint8;
+using {f} for int;
+// ----
+// DeclarationError 9589: (132-133): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/free_overloads_array.sol b/compiler/test/libsolidity/syntaxTests/using/free_overloads_array.sol
new file mode 100644
index 00000000..cab3eccf
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/free_overloads_array.sol
@@ -0,0 +1,9 @@
+function f(uint x, uint[] y) pure returns (uint) {
+    return x;
+}
+function f(uint x, uint y) pure returns (int) {
+    return x;
+}
+using {f} for uint;
+// ----
+// DeclarationError 9589: (138-139): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/function_from_base_contract_qualified_with_super.sol b/compiler/test/libsolidity/syntaxTests/using/function_from_base_contract_qualified_with_super.sol
new file mode 100644
index 00000000..a162912c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/function_from_base_contract_qualified_with_super.sol
@@ -0,0 +1,9 @@
+contract C {
+    function baseFunction(uint) public pure {}
+}
+
+contract D is C {
+    using {super.baseFunction} for uint;
+}
+// ----
+// DeclarationError 9589: (92-110): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_at_file_level_err.sol b/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_at_file_level_err.sol
new file mode 100644
index 00000000..85d591fd
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_at_file_level_err.sol
@@ -0,0 +1,11 @@
+function f(uint x) pure { }
+
+using f for uint;
+
+contract C {
+    function g(uint x) public pure {
+        x.f();
+    }
+}
+// ----
+// TypeError 4357: (35-36): Library name expected. If you want to attach a function, use '{...}'.
diff --git a/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_inside_contract_err.sol b/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_inside_contract_err.sol
new file mode 100644
index 00000000..00313738
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/function_name_without_braces_inside_contract_err.sol
@@ -0,0 +1,10 @@
+function f(uint x) pure { }
+
+contract C {
+    using f for uint;
+    function g(uint x) public pure {
+        x.f();
+    }
+}
+// ----
+// TypeError 4357: (52-53): Library name expected. If you want to attach a function, use '{...}'.
diff --git a/compiler/test/libsolidity/syntaxTests/using/global_for_asterisk.sol b/compiler/test/libsolidity/syntaxTests/using/global_for_asterisk.sol
new file mode 100644
index 00000000..a4ee65a3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/global_for_asterisk.sol
@@ -0,0 +1,5 @@
+using {f} for * global;
+function f(uint) pure{}
+// ----
+// SyntaxError 8118: (0-23): The type has to be specified explicitly at file level (cannot use '*').
+// SyntaxError 2854: (0-23): Can only globally attach functions to specific types.
diff --git a/compiler/test/libsolidity/syntaxTests/using/global_library_with_asterisk.sol b/compiler/test/libsolidity/syntaxTests/using/global_library_with_asterisk.sol
new file mode 100644
index 00000000..50860de4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/global_library_with_asterisk.sol
@@ -0,0 +1,5 @@
+using L for * global;
+library L {}
+// ----
+// SyntaxError 8118: (0-21): The type has to be specified explicitly at file level (cannot use '*').
+// SyntaxError 2854: (0-21): Can only globally attach functions to specific types.
diff --git a/compiler/test/libsolidity/syntaxTests/using/global_local_clash.sol b/compiler/test/libsolidity/syntaxTests/using/global_local_clash.sol
new file mode 100644
index 00000000..5d5d8ae2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/global_local_clash.sol
@@ -0,0 +1,21 @@
+==== Source: A ====
+using {f} for S global;
+struct S { uint x; }
+function gen() pure returns (S memory) {}
+function f(S memory _x) pure returns (uint) { return _x.x; }
+function f1(S memory _x) pure returns (uint) { return _x.x + 1; }
+==== Source: B ====
+contract C {
+    // Here, f points to f1, so we end up with two different functions
+    // attached as S.f
+    using {f} for S;
+
+    function test() pure public
+    {
+        uint p = g().f();
+    }
+}
+import {gen as g, f1 as f, S} from "A";
+import "A" as A;
+// ----
+// TypeError 6675: (B:184-189): Member "f" not unique after argument-dependent lookup in struct S memory.
diff --git a/compiler/test/libsolidity/syntaxTests/using/global_multiple_global_keywords.sol b/compiler/test/libsolidity/syntaxTests/using/global_multiple_global_keywords.sol
new file mode 100644
index 00000000..48ce7f11
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/global_multiple_global_keywords.sol
@@ -0,0 +1,5 @@
+using {f} for S global global;
+struct S { uint x; }
+function f(S memory _x) pure returns (uint) { return _x.x; }
+// ----
+// ParserError 2314: (23-29): Expected ';' but got identifier
diff --git a/compiler/test/libsolidity/syntaxTests/using/global_with_asterisk.sol b/compiler/test/libsolidity/syntaxTests/using/global_with_asterisk.sol
new file mode 100644
index 00000000..a4ee65a3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/global_with_asterisk.sol
@@ -0,0 +1,5 @@
+using {f} for * global;
+function f(uint) pure{}
+// ----
+// SyntaxError 8118: (0-23): The type has to be specified explicitly at file level (cannot use '*').
+// SyntaxError 2854: (0-23): Can only globally attach functions to specific types.
diff --git a/compiler/test/libsolidity/syntaxTests/using/interface_function_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/using/interface_function_at_file_level.sol
new file mode 100644
index 00000000..9a9ee26f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/interface_function_at_file_level.sol
@@ -0,0 +1,7 @@
+interface I {
+    function g() external pure;
+}
+
+using {I.g} for uint;
+// ----
+// TypeError 4167: (56-59): Only file-level functions and library functions can be attached to a type in a "using" statement
diff --git a/compiler/test/libsolidity/syntaxTests/using/interface_function_inside_contract.sol b/compiler/test/libsolidity/syntaxTests/using/interface_function_inside_contract.sol
new file mode 100644
index 00000000..f01788ff
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/interface_function_inside_contract.sol
@@ -0,0 +1,9 @@
+interface I {
+    function g() external pure;
+}
+
+contract C {
+    using {I.g} for uint;
+}
+// ----
+// TypeError 4167: (73-76): Only file-level functions and library functions can be attached to a type in a "using" statement
diff --git a/compiler/test/libsolidity/syntaxTests/using/interface_using_for.sol b/compiler/test/libsolidity/syntaxTests/using/interface_using_for.sol
new file mode 100644
index 00000000..41597101
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/interface_using_for.sol
@@ -0,0 +1,10 @@
+library L {
+    function f() public {}
+}
+
+interface I {
+    using L for int;
+    function g() external;
+}
+// ----
+// SyntaxError 9088: (60-76): The "using for" directive is not allowed inside interfaces.
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/using/library_at_file_level.sol
new file mode 100644
index 00000000..9cb1965a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_at_file_level.sol
@@ -0,0 +1,17 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+using L for uint;
+
+contract C {
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_function_attached_and_called.sol b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_and_called.sol
new file mode 100644
index 00000000..e2e4b570
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_and_called.sol
@@ -0,0 +1,8 @@
+library D { function double(uint self) internal pure returns (uint) { return 2*self; } }
+contract C {
+	using D for uint;
+	function f(uint a) public pure {
+		a.double();
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_function_attached_but_not_called.sol b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_but_not_called.sol
new file mode 100644
index 00000000..877ff8ea
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_but_not_called.sol
@@ -0,0 +1,8 @@
+library D { function double(uint self) public pure returns (uint) { return 2*self; } }
+contract C {
+	using D for uint;
+	function f(uint a) public pure {
+		a.double;
+	}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_function_attached_to_all_types.sol b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_to_all_types.sol
new file mode 100644
index 00000000..bcaac246
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_function_attached_to_all_types.sol
@@ -0,0 +1,11 @@
+library L {
+	function g(function() internal returns (uint) _t) internal returns (uint) { return _t(); }
+}
+contract C {
+	using L for *;
+	function f() public returns (uint) {
+		return t.g();
+	}
+	function t() public pure returns (uint)  { return 7; }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_functions_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/using/library_functions_at_file_level.sol
new file mode 100644
index 00000000..2876f591
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_functions_at_file_level.sol
@@ -0,0 +1,19 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+using {L.externalFunction} for uint;
+using {L.publicFunction} for uint;
+using {L.internalFunction} for uint;
+
+contract C {
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_at_file_level_used_inside_library.sol b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_at_file_level_used_inside_library.sol
new file mode 100644
index 00000000..21d30f55
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_at_file_level_used_inside_library.sol
@@ -0,0 +1,17 @@
+using {L.externalFunction, L.publicFunction, L.internalFunction} for uint;
+
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
+// TypeError 6700: (299-319): Libraries cannot call their own functions externally.
+// TypeError 6700: (329-347): Libraries cannot call their own functions externally.
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_at_file_level.sol b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_at_file_level.sol
new file mode 100644
index 00000000..bb191faa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_at_file_level.sol
@@ -0,0 +1,17 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+using {L.externalFunction, L.publicFunction, L.internalFunction} for uint;
+
+contract C {
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_inside_contract.sol b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_inside_contract.sol
new file mode 100644
index 00000000..300a3480
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_functions_attached_in_single_directive_inside_contract.sol
@@ -0,0 +1,17 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+contract C {
+    using {L.externalFunction, L.publicFunction, L.internalFunction} for uint;
+
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_functions_inside_contract.sol b/compiler/test/libsolidity/syntaxTests/using/library_functions_inside_contract.sol
new file mode 100644
index 00000000..46d4c571
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_functions_inside_contract.sol
@@ -0,0 +1,19 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+contract C {
+    using {L.externalFunction} for uint;
+    using {L.publicFunction} for uint;
+    using {L.internalFunction} for uint;
+
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_inside_contract.sol b/compiler/test/libsolidity/syntaxTests/using/library_inside_contract.sol
new file mode 100644
index 00000000..cd7f8fd1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_inside_contract.sol
@@ -0,0 +1,17 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+}
+
+contract C {
+    using L for uint;
+
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+    }
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/library_non_free_external_function_err.sol b/compiler/test/libsolidity/syntaxTests/using/library_non_free_external_function_err.sol
new file mode 100644
index 00000000..0a51043d
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/library_non_free_external_function_err.sol
@@ -0,0 +1,14 @@
+library L {
+    function id_ext(uint x) external returns(uint) {
+        return x;
+    }
+}
+
+contract C {
+    using L.id_ext for uint;
+    function f(uint x) external {
+        x.id_ext();
+    }
+}
+// ----
+// TypeError 4357: (115-123): Library name expected. If you want to attach a function, use '{...}'.
diff --git a/compiler/test/libsolidity/syntaxTests/using/module_identifier_not_found.sol b/compiler/test/libsolidity/syntaxTests/using/module_identifier_not_found.sol
new file mode 100644
index 00000000..2526d216
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/module_identifier_not_found.sol
@@ -0,0 +1,13 @@
+==== Source: A ====
+function id(uint x) pure returns (uint) {
+    return x;
+}
+
+==== Source: B ====
+import "A" as M;
+
+contract C {
+    using { id } for uint;
+}
+// ----
+// DeclarationError 9589: (B:43-45): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/private_library_function_inside_scope.sol b/compiler/test/libsolidity/syntaxTests/using/private_library_function_inside_scope.sol
new file mode 100644
index 00000000..1f036d83
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/private_library_function_inside_scope.sol
@@ -0,0 +1,5 @@
+library L {
+    using {L.privateFunction} for uint;
+    function privateFunction(uint) private pure {}
+}
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/using/private_library_function_outside_scope.sol b/compiler/test/libsolidity/syntaxTests/using/private_library_function_outside_scope.sol
new file mode 100644
index 00000000..2be2010c
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/private_library_function_outside_scope.sol
@@ -0,0 +1,12 @@
+library L {
+    function privateFunction(uint) private pure {}
+}
+
+using {L.privateFunction} for uint;
+
+contract C {
+    using {L.privateFunction} for uint;
+}
+// ----
+// TypeError 6772: (73-90): Function "L.privateFunction" is private and therefore cannot be attached to a type outside of the library where it is defined.
+// TypeError 6772: (127-144): Function "L.privateFunction" is private and therefore cannot be attached to a type outside of the library where it is defined.
diff --git a/compiler/test/libsolidity/syntaxTests/using/public_state_variable_getter.sol b/compiler/test/libsolidity/syntaxTests/using/public_state_variable_getter.sol
new file mode 100644
index 00000000..9223a92a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/public_state_variable_getter.sol
@@ -0,0 +1,11 @@
+contract A {
+    uint public data;
+}
+
+contract C {
+    A a = new A();
+
+    using {a.data} for uint;
+}
+// ----
+// DeclarationError 9589: (82-88): Identifier is not a function name or not unique.
diff --git a/compiler/test/libsolidity/syntaxTests/using/undeclared_library.sol b/compiler/test/libsolidity/syntaxTests/using/undeclared_library.sol
new file mode 100644
index 00000000..c2174cc6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/undeclared_library.sol
@@ -0,0 +1,3 @@
+using L for uint;
+// ----
+// DeclarationError 9589: (6-7): Identifier is not a library name.
diff --git a/compiler/test/libsolidity/syntaxTests/using/unqualified_library_functions_attached_in_single_directive_inside_library.sol b/compiler/test/libsolidity/syntaxTests/using/unqualified_library_functions_attached_in_single_directive_inside_library.sol
new file mode 100644
index 00000000..7403dcf2
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/unqualified_library_functions_attached_in_single_directive_inside_library.sol
@@ -0,0 +1,19 @@
+library L {
+    function externalFunction(uint) external pure {}
+    function publicFunction(uint) public pure {}
+    function internalFunction(uint) internal pure {}
+    function privateFunction(uint) private pure {}
+
+    using {externalFunction, publicFunction, internalFunction, privateFunction} for uint;
+
+    function f() public pure {
+        uint x;
+        x.externalFunction();
+        x.publicFunction();
+        x.internalFunction();
+        x.privateFunction();
+    }
+}
+// ----
+// TypeError 6700: (365-385): Libraries cannot call their own functions externally.
+// TypeError 6700: (395-413): Libraries cannot call their own functions externally.
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_for_enum.sol b/compiler/test/libsolidity/syntaxTests/using/using_for_enum.sol
new file mode 100644
index 00000000..e7c6b5c8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_for_enum.sol
@@ -0,0 +1,5 @@
+enum E {A, B, C}
+
+function f(E) {}
+
+using {f} for E;
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_err.sol b/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_err.sol
new file mode 100644
index 00000000..54fdd825
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_err.sol
@@ -0,0 +1,7 @@
+function one() pure returns(uint) {
+    return 1;
+}
+
+using {one} for uint;
+// ----
+// TypeError 4731: (60-63): The function "one" does not have any parameters, and therefore cannot be attached to the type "uint256".
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_struct_err.sol b/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_struct_err.sol
new file mode 100644
index 00000000..4e15a9d8
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_free_no_parameters_struct_err.sol
@@ -0,0 +1,5 @@
+struct S { uint8 x; }
+function f() {}
+using {f} for S;
+// ----
+// TypeError 4731: (45-46): The function "f" does not have any parameters, and therefore cannot be attached to the type "struct S".
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_library_for_library.sol b/compiler/test/libsolidity/syntaxTests/using/using_library_for_library.sol
new file mode 100644
index 00000000..8166e9c7
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_library_for_library.sol
@@ -0,0 +1,11 @@
+library L {}
+library M {}
+contract C {
+    using L for M;
+    using M for L;
+    using L for L;
+}
+// ----
+// TypeError 1130: (55-56): Invalid use of a library name.
+// TypeError 1130: (74-75): Invalid use of a library name.
+// TypeError 1130: (93-94): Invalid use of a library name.
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_non_free_function_err.sol b/compiler/test/libsolidity/syntaxTests/using/using_non_free_function_err.sol
new file mode 100644
index 00000000..fabfcd92
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_non_free_function_err.sol
@@ -0,0 +1,9 @@
+contract C {
+    using {f, g} for uint;
+
+    function f(uint) internal { }
+    function g(uint) public { }
+}
+// ----
+// TypeError 4167: (24-25): Only file-level functions and library functions can be attached to a type in a "using" statement
+// TypeError 4167: (27-28): Only file-level functions and library functions can be attached to a type in a "using" statement
diff --git a/compiler/test/libsolidity/syntaxTests/using/using_struct_for_struct.sol b/compiler/test/libsolidity/syntaxTests/using/using_struct_for_struct.sol
new file mode 100644
index 00000000..59c8e2aa
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/using/using_struct_for_struct.sol
@@ -0,0 +1,10 @@
+contract C {
+    struct S { uint t; }
+    function r() public {
+        S memory x;
+        x.d;
+    }
+    using S for S;
+}
+// ----
+// TypeError 4357: (113-114): Library name expected. If you want to attach a function, use '{...}'.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobbasefee_not_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobbasefee_not_pure.sol
new file mode 100644
index 00000000..3bace428
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobbasefee_not_pure.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        assembly { pop(blobbasefee()) }
+    }
+    function g() public pure returns (uint) {
+        return block.blobbasefee;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// TypeError 2527: (67-80): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (151-168): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash.sol
new file mode 100644
index 00000000..4de6929a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public view returns (bytes32 ret){
+        assembly {
+            ret := blobhash(0)
+        }
+    }
+    function g() public view returns (bytes32) {
+        return blobhash(0);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash_not_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash_not_pure.sol
new file mode 100644
index 00000000..d03e336a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/blobhash_not_pure.sol
@@ -0,0 +1,15 @@
+contract C {
+    function f() public pure returns (bytes32 ret){
+        assembly {
+            ret := blobhash(0)
+        }
+    }
+    function g() public pure returns (bytes32) {
+        return blobhash(0);
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// TypeError 2527: (103-114): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (195-206): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_blobhash_restrict_warning.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_blobhash_restrict_warning.sol
new file mode 100644
index 00000000..18a0f586
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_blobhash_restrict_warning.sol
@@ -0,0 +1,10 @@
+contract C {
+    function g() public {
+        bytes32 w = blobhash(0);
+        w;
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2018: (17-88): Function state mutability can be restricted to view
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol
new file mode 100644
index 00000000..4d1710a3
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions.sol
@@ -0,0 +1,22 @@
+contract C {
+    function f() public {
+        payable(this).transfer(1);
+        require(payable(this).send(2));
+        selfdestruct(payable(this));
+        (bool success,) = address(this).delegatecall("");
+        require(success);
+		(success,) = address(this).call("");
+        require(success);
+    }
+    function g() pure public {
+        bytes32 x = keccak256("abc");
+        bytes32 y = sha256("abc");
+        address z = ecrecover(bytes32(uint256(1)), uint8(2), bytes32(uint256(3)), bytes32(uint256(4)));
+        require(true);
+        assert(true);
+        x; y; z;
+    }
+    receive() payable external {}
+}
+// ----
+// Warning 5159: (122-134): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_view_fail.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_view_fail.sol
new file mode 100644
index 00000000..4f9efcdb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/builtin_functions_view_fail.sol
@@ -0,0 +1,28 @@
+contract C {
+    function f() view public {
+        payable(this).transfer(1);
+    }
+    function g() view public {
+        require(payable(this).send(2));
+    }
+    function h() view public {
+        selfdestruct(payable(this));
+    }
+    function i() view public {
+        (bool success,) = address(this).delegatecall("");
+        require(success);
+    }
+    function j() view public {
+        (bool success,) = address(this).call("");
+        require(success);
+    }
+    receive() payable external {
+    }
+}
+// ----
+// Warning 5159: (201-213): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// TypeError 8961: (52-77): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (132-153): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (201-228): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (293-323): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (414-436): Function cannot be declared as view because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol
new file mode 100644
index 00000000..886d6de0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed.sol
@@ -0,0 +1,93 @@
+contract C {
+    function f() public {
+        assembly {
+            stop()
+            pop(add(0, 1))
+            pop(sub(0, 1))
+            pop(mul(0, 1))
+            pop(div(0, 1))
+            pop(sdiv(0, 1))
+            pop(mod(0, 1))
+            pop(smod(0, 1))
+            pop(exp(0, 1))
+            pop(not(0))
+            pop(lt(0, 1))
+            pop(gt(0, 1))
+            pop(slt(0, 1))
+            pop(sgt(0, 1))
+            pop(eq(0, 1))
+            pop(iszero(0))
+            pop(and(0, 1))
+            pop(or(0, 1))
+            pop(xor(0, 1))
+            pop(byte(0, 1))
+            pop(shl(0, 1))
+            pop(shr(0, 1))
+            pop(sar(0, 1))
+            pop(addmod(0, 1, 2))
+            pop(mulmod(0, 1, 2))
+            pop(signextend(0, 1))
+            pop(keccak256(0, 1))
+            pop(0)
+            pop(mload(0))
+            mstore(0, 1)
+            mstore8(0, 1)
+            pop(sload(0))
+            sstore(0, 1)
+            pop(gas())
+            pop(address())
+            pop(balance(0))
+            pop(selfbalance())
+            pop(caller())
+            pop(callvalue())
+            pop(calldataload(0))
+            pop(calldatasize())
+            calldatacopy(0, 1, 2)
+            pop(codesize())
+            codecopy(0, 1, 2)
+            pop(extcodesize(0))
+            extcodecopy(0, 1, 2, 3)
+            pop(returndatasize())
+            returndatacopy(0, 1, 2)
+            pop(extcodehash(0))
+            pop(create(0, 1, 2))
+            pop(create2(0, 1, 2, 3))
+            pop(call(0, 1, 2, 3, 4, 5, 6))
+            pop(callcode(0, 1, 2, 3, 4, 5, 6))
+            pop(delegatecall(0, 1, 2, 3, 4, 5))
+            pop(staticcall(0, 1, 2, 3, 4, 5))
+            return(0, 1)
+            revert(0, 1)
+            selfdestruct(0)
+            invalid()
+            log0(0, 1)
+            log1(0, 1, 2)
+            log2(0, 1, 2, 3)
+            log3(0, 1, 2, 3, 4)
+            log4(0, 1, 2, 3, 4, 5)
+            pop(chainid())
+            pop(basefee())
+            pop(origin())
+            pop(gasprice())
+            pop(blockhash(0))
+            pop(coinbase())
+            pop(timestamp())
+            pop(number())
+            pop(prevrandao())
+            pop(gaslimit())
+
+            // NOTE: msize() is allowed only with optimizer disabled
+            //pop(msize())
+            //pop(pc())
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// Warning 1699: (1754-1766): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// Warning 5740: (89-1716): Unreachable code.
+// Warning 5740: (1729-1741): Unreachable code.
+// Warning 5740: (1754-1769): Unreachable code.
+// Warning 5740: (1782-1791): Unreachable code.
+// Warning 5740: (1804-2215): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_london.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_london.sol
new file mode 100644
index 00000000..be9f7281
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_london.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public {
+        assembly {
+            pop(difficulty())
+        }
+    }
+}
+// ====
+// EVMVersion: <=london
+// ----
+// Warning 2018: (17-103): Function state mutability can be restricted to view
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol
new file mode 100644
index 00000000..16c75d6f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure.sol
@@ -0,0 +1,89 @@
+contract C {
+    function f() public pure {
+        assembly {
+            stop()
+            pop(add(0, 1))
+            pop(sub(0, 1))
+            pop(mul(0, 1))
+            pop(div(0, 1))
+            pop(sdiv(0, 1))
+            pop(mod(0, 1))
+            pop(smod(0, 1))
+            pop(exp(0, 1))
+            pop(not(0))
+            pop(lt(0, 1))
+            pop(gt(0, 1))
+            pop(slt(0, 1))
+            pop(sgt(0, 1))
+            pop(eq(0, 1))
+            pop(iszero(0))
+            pop(and(0, 1))
+            pop(or(0, 1))
+            pop(xor(0, 1))
+            pop(byte(0, 1))
+            pop(shl(0, 1))
+            pop(shr(0, 1))
+            pop(sar(0, 1))
+            pop(addmod(0, 1, 2))
+            pop(mulmod(0, 1, 2))
+            pop(signextend(0, 1))
+            pop(keccak256(0, 1))
+            pop(0)
+            pop(mload(0))
+            mstore(0, 1)
+            mstore8(0, 1)
+            //pop(sload(0))
+            //sstore(0, 1)
+            //pop(gas())
+            //pop(address())
+            //pop(balance(0))
+            //pop(selfbalance())
+            //pop(caller())
+            //pop(callvalue())
+            pop(calldataload(0))
+            pop(calldatasize())
+            calldatacopy(0, 1, 2)
+            pop(codesize())
+            codecopy(0, 1, 2)
+            //pop(extcodesize(0))
+            //extcodecopy(0, 1, 2, 3)
+            pop(returndatasize())
+            returndatacopy(0, 1, 2)
+            //pop(extcodehash(0))
+            //pop(create(0, 1, 2))
+            //pop(create2(0, 1, 2, 3))
+            //pop(call(0, 1, 2, 3, 4, 5, 6))
+            //pop(callcode(0, 1, 2, 3, 4, 5, 6))
+            //pop(delegatecall(0, 1, 2, 3, 4, 5))
+            //pop(staticcall(0, 1, 2, 3, 4, 5))
+            return(0, 1)
+            revert(0, 1)
+            //selfdestruct(0)
+            invalid()
+            //log0(0, 1)
+            //log1(0, 1, 2)
+            //log2(0, 1, 2, 3)
+            //log3(0, 1, 2, 3, 4)
+            //log4(0, 1, 2, 3, 4, 5)
+            //pop(chainid())
+            //pop(basefee())
+            //pop(origin())
+            //pop(gasprice())
+            //pop(blockhash(0))
+            //pop(coinbase())
+            //pop(timestamp())
+            //pop(number())
+            //pop(gaslimit())
+
+            // NOTE: msize() is allowed only with optimizer disabled
+            //pop(msize())
+            //pop(pc())
+        }
+    }
+}
+// ====
+// EVMVersion: >=london
+// ----
+// Warning 5740: (94-1755): Unreachable code.
+// Warning 5740: (1768-1780): Unreachable code.
+// Warning 5740: (1823-1832): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure_cancun.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure_cancun.sol
new file mode 100644
index 00000000..23a7f4c4
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_pure_cancun.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure {
+        assembly {
+            mcopy(1, 2, 3)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol
new file mode 100644
index 00000000..0bb92c1f
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view.sol
@@ -0,0 +1,91 @@
+contract C {
+    function f() public view {
+        assembly {
+            stop()
+            pop(add(0, 1))
+            pop(sub(0, 1))
+            pop(mul(0, 1))
+            pop(div(0, 1))
+            pop(sdiv(0, 1))
+            pop(mod(0, 1))
+            pop(smod(0, 1))
+            pop(exp(0, 1))
+            pop(not(0))
+            pop(lt(0, 1))
+            pop(gt(0, 1))
+            pop(slt(0, 1))
+            pop(sgt(0, 1))
+            pop(eq(0, 1))
+            pop(iszero(0))
+            pop(and(0, 1))
+            pop(or(0, 1))
+            pop(xor(0, 1))
+            pop(byte(0, 1))
+            pop(shl(0, 1))
+            pop(shr(0, 1))
+            pop(sar(0, 1))
+            pop(addmod(0, 1, 2))
+            pop(mulmod(0, 1, 2))
+            pop(signextend(0, 1))
+            pop(keccak256(0, 1))
+            pop(0)
+            pop(mload(0))
+            mstore(0, 1)
+            mstore8(0, 1)
+            pop(sload(0))
+            //sstore(0, 1)
+            pop(gas())
+            pop(address())
+            pop(balance(0))
+            pop(selfbalance())
+            pop(caller())
+            pop(callvalue())
+            pop(calldataload(0))
+            pop(calldatasize())
+            calldatacopy(0, 1, 2)
+            pop(codesize())
+            codecopy(0, 1, 2)
+            pop(extcodesize(0))
+            extcodecopy(0, 1, 2, 3)
+            pop(returndatasize())
+            returndatacopy(0, 1, 2)
+            pop(extcodehash(0))
+            //pop(create(0, 1, 2))
+            //pop(create2(0, 1, 2, 3))
+            //pop(call(0, 1, 2, 3, 4, 5, 6))
+            //pop(callcode(0, 1, 2, 3, 4, 5, 6))
+            //pop(delegatecall(0, 1, 2, 3, 4, 5))
+            pop(staticcall(0, 1, 2, 3, 4, 5))
+            return(0, 1)
+            revert(0, 1)
+            //selfdestruct(0)
+            invalid()
+            //log0(0, 1)
+            //log1(0, 1, 2)
+            //log2(0, 1, 2, 3)
+            //log3(0, 1, 2, 3, 4)
+            //log4(0, 1, 2, 3, 4, 5)
+            pop(chainid())
+            pop(basefee())
+            pop(origin())
+            pop(gasprice())
+            pop(blockhash(0))
+            pop(coinbase())
+            pop(timestamp())
+            pop(number())
+            pop(prevrandao())
+            pop(gaslimit())
+
+            // NOTE: msize() is allowed only with optimizer disabled
+            //pop(msize())
+            //pop(pc())
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// Warning 5740: (94-1733): Unreachable code.
+// Warning 5740: (1746-1758): Unreachable code.
+// Warning 5740: (1801-1810): Unreachable code.
+// Warning 5740: (1978-2244): Unreachable code.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_cancun.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_cancun.sol
new file mode 100644
index 00000000..dcf6d6c6
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_cancun.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public view {
+        assembly {
+            pop(blobhash(0))
+            pop(blobbasefee())
+            mcopy(1, 2, 3)
+            pop(tload(0))
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_london.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_london.sol
new file mode 100644
index 00000000..ffc757a1
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_allowed_view_london.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() public view {
+        assembly {
+            pop(difficulty())
+        }
+    }
+}
+// ====
+// EVMVersion: <=london
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol
new file mode 100644
index 00000000..665a17ee
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure.sol
@@ -0,0 +1,65 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(sload(0))
+            sstore(0, 1)
+            pop(gas())
+            pop(address())
+            pop(balance(0))
+            pop(caller())
+            pop(callvalue())
+            pop(extcodesize(0))
+            extcodecopy(0, 1, 2, 3)
+            pop(create(0, 1, 2))
+            pop(call(0, 1, 2, 3, 4, 5, 6))
+            pop(callcode(0, 1, 2, 3, 4, 5, 6))
+            pop(delegatecall(0, 1, 2, 3, 4, 5))
+            selfdestruct(0)
+            log0(0, 1)
+            log1(0, 1, 2)
+            log2(0, 1, 2, 3)
+            log3(0, 1, 2, 3, 4)
+            log4(0, 1, 2, 3, 4, 5)
+            pop(origin())
+            pop(gasprice())
+            pop(blockhash(0))
+            pop(coinbase())
+            pop(timestamp())
+            pop(number())
+            pop(gaslimit())
+
+            // These two are disallowed too but the error suppresses other errors.
+            //pop(msize())
+            //pop(pc())
+        }
+    }
+}
+// ----
+// Warning 1699: (498-510): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// Warning 5740: (526-853): Unreachable code.
+// TypeError 2527: (79-87): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 8961: (101-113): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 2527: (130-135): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (153-162): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (180-190): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (208-216): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (234-245): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (263-277): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (291-314): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 8961: (331-346): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (364-389): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (407-436): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (454-484): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (498-513): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (526-536): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (549-562): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (575-591): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (604-623): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 8961: (636-658): Function cannot be declared as pure because this expression (potentially) modifies the state.
+// TypeError 2527: (675-683): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (701-711): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (729-741): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (759-769): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (787-798): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (816-824): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (842-852): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol
new file mode 100644
index 00000000..f0320d8b
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_byzantium.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(staticcall(0, 1, 2, 3, 4, 5))
+        }
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// TypeError 2527: (79-107): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_cancun.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_cancun.sol
new file mode 100644
index 00000000..b3d429f0
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_cancun.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(blobhash(0))
+            pop(blobbasefee())
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// TypeError 2527: (79-90): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (108-121): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol
new file mode 100644
index 00000000..30210efc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_constantinople.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(extcodehash(0))
+            pop(create2(0, 1, 2, 3))
+        }
+    }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// TypeError 2527: (79-93): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 8961: (111-130): Function cannot be declared as pure because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_istanbul.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_istanbul.sol
new file mode 100644
index 00000000..b4e02248
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_istanbul.sol
@@ -0,0 +1,13 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(selfbalance())
+            pop(chainid())
+        }
+    }
+}
+// ====
+// EVMVersion: >=istanbul
+// ----
+// TypeError 2527: (79-92): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
+// TypeError 2527: (110-119): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_london.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_london.sol
new file mode 100644
index 00000000..ba47d444
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_london.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(basefee())
+        }
+    }
+}
+// ====
+// EVMVersion: >=london
+// ----
+// TypeError 2527: (79-88): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_paris.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_paris.sol
new file mode 100644
index 00000000..e374522a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_paris.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(prevrandao())
+        }
+    }
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// TypeError 2527: (79-91): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_pre_paris.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_pre_paris.sol
new file mode 100644
index 00000000..e348fd98
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_pure_pre_paris.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() public pure {
+        assembly {
+            pop(difficulty())
+        }
+    }
+}
+// ====
+// EVMVersion: <=london
+// ----
+// TypeError 2527: (79-91): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol
new file mode 100644
index 00000000..b2f241ff
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/inline_assembly_instructions_disallowed_view.sol
@@ -0,0 +1,39 @@
+contract C {
+    function f() public view {
+        assembly {
+            sstore(0, 1)
+            pop(create(0, 1, 2))
+            pop(create2(0, 1, 2, 3))
+            pop(call(0, 1, 2, 3, 4, 5, 6))
+            pop(callcode(0, 1, 2, 3, 4, 5, 6))
+            pop(delegatecall(0, 1, 2, 3, 4, 5))
+            selfdestruct(0)
+            log0(0, 1)
+            log1(0, 1, 2)
+            log2(0, 1, 2, 3)
+            log3(0, 1, 2, 3, 4)
+            log4(0, 1, 2, 3, 4, 5)
+
+            // These two are disallowed too but the error suppresses other errors.
+            //pop(msize())
+            //pop(pc())
+        }
+    }
+}
+// ====
+// EVMVersion: >=london
+// ----
+// Warning 1699: (308-320): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
+// Warning 5740: (336-468): Unreachable code.
+// TypeError 8961: (75-87): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (104-119): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (137-156): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (174-199): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (217-246): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (264-294): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (308-323): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (336-346): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (359-372): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (385-401): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (414-433): Function cannot be declared as view because this expression (potentially) modifies the state.
+// TypeError 8961: (446-468): Function cannot be declared as view because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/mcopy_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/mcopy_pure.sol
new file mode 100644
index 00000000..e89209dc
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/mcopy_pure.sol
@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure {
+        assembly {
+            mcopy(0x1000, 0x2000, 100)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_not_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_not_pure.sol
new file mode 100644
index 00000000..13b44f19
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_not_pure.sol
@@ -0,0 +1,11 @@
+contract C {
+    function f() external pure {
+        assembly {
+            pop(tload(0))
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// TypeError 2527: (81-89): Function declared as pure, but this expression (potentially) reads from the environment or state and thus requires "view".
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_view.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_view.sol
new file mode 100644
index 00000000..c94bd867
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tload_view.sol
@@ -0,0 +1,10 @@
+contract C {
+    function f() external view returns (uint a) {
+        assembly {
+            a := tload(0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_pure.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_pure.sol
new file mode 100644
index 00000000..3cda8d08
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_pure.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() external pure {
+        assembly {
+            tstore(0, 0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2394: (77-83): Transient storage as defined by EIP-1153 can break the composability of smart contracts: Since transient storage is cleared only at the end of the transaction and not at the end of the outermost call frame to the contract within a transaction, your contract may unintentionally misbehave when invoked multiple times in a complex transaction. To avoid this, be sure to clear all transient storage at the end of any call to your contract. The use of transient storage for reentrancy guards that are cleared at the end of the call is safe.
+// TypeError 8961: (77-89): Function cannot be declared as pure because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_view.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_view.sol
new file mode 100644
index 00000000..5e02ef91
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/tstore_not_view.sol
@@ -0,0 +1,12 @@
+contract C {
+    function f() external view {
+        assembly {
+            tstore(0, 0)
+        }
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2394: (77-83): Transient storage as defined by EIP-1153 can break the composability of smart contracts: Since transient storage is cleared only at the end of the transaction and not at the end of the outermost call frame to the contract within a transaction, your contract may unintentionally misbehave when invoked multiple times in a complex transaction. To avoid this, be sure to clear all transient storage at the end of any call to your contract. The use of transient storage for reentrancy guards that are cleared at the end of the call is safe.
+// TypeError 8961: (77-89): Function cannot be declared as view because this expression (potentially) modifies the state.
diff --git a/compiler/test/libsolidity/syntaxTests/viewPureChecker/user_operator_with_pure_modifier_can_be_restricted.sol b/compiler/test/libsolidity/syntaxTests/viewPureChecker/user_operator_with_pure_modifier_can_be_restricted.sol
new file mode 100644
index 00000000..eb7ce354
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/viewPureChecker/user_operator_with_pure_modifier_can_be_restricted.sol
@@ -0,0 +1,20 @@
+type Int is uint8;
+
+using {add as +} for Int global;
+
+function add(Int, Int) pure returns (Int) {}
+
+function f() pure {
+    Int.wrap(0) + Int.wrap(1);
+}
+
+function g() view {
+    Int.wrap(0) + Int.wrap(1);
+}
+
+function h() {
+    Int.wrap(0) + Int.wrap(1);
+}
+// ----
+// Warning 2018: (154-206): Function state mutability can be restricted to pure
+// Warning 2018: (208-255): Function state mutability can be restricted to pure
diff --git a/compiler/test/libsolidity/syntaxTests/visibility/file_level_variable_visibility.sol b/compiler/test/libsolidity/syntaxTests/visibility/file_level_variable_visibility.sol
new file mode 100644
index 00000000..3de9f3ae
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/visibility/file_level_variable_visibility.sol
@@ -0,0 +1,13 @@
+==== Source: A ====
+uint external a;
+==== Source: B ====
+uint internal a;
+==== Source: C ====
+uint public a;
+==== Source: D ====
+uint private a;
+// ----
+// ParserError 2314: (A:5-13): Expected identifier but got 'external'
+// ParserError 2314: (B:5-13): Expected identifier but got 'internal'
+// ParserError 2314: (C:5-11): Expected identifier but got 'public'
+// ParserError 2314: (D:5-12): Expected identifier but got 'private'
diff --git a/compiler/test/libsolidity/syntaxTests/visibility/invalid_function_parameter_and_return_var_visibility.sol b/compiler/test/libsolidity/syntaxTests/visibility/invalid_function_parameter_and_return_var_visibility.sol
new file mode 100644
index 00000000..4f73e884
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/visibility/invalid_function_parameter_and_return_var_visibility.sol
@@ -0,0 +1,41 @@
+==== Source: A ====
+contract test {
+    function f(uint external a) public returns (uint) { }
+}
+==== Source: B ====
+contract test {
+    function f(uint internal a) public returns (uint) { }
+}
+==== Source: C ====
+contract test {
+    function f(uint public a) public returns (uint) { }
+}
+==== Source: D ====
+contract test {
+    function f(uint private a) public returns (uint) { }
+}
+==== Source: E ====
+contract test {
+    function f(uint a) public returns (uint external) { }
+}
+==== Source: F ====
+contract test {
+    function f(uint a) public returns (uint internal) { }
+}
+==== Source: G ====
+contract test {
+    function f(uint a) public returns (uint public) { }
+}
+==== Source: H ====
+contract test {
+    function f(uint a) public returns (uint private) { }
+}
+// ----
+// ParserError 2314: (A:36-44): Expected ',' but got 'external'
+// ParserError 2314: (B:36-44): Expected ',' but got 'internal'
+// ParserError 2314: (C:36-42): Expected ',' but got 'public'
+// ParserError 2314: (D:36-43): Expected ',' but got 'private'
+// ParserError 2314: (E:60-68): Expected ',' but got 'external'
+// ParserError 2314: (F:60-68): Expected ',' but got 'internal'
+// ParserError 2314: (G:60-66): Expected ',' but got 'public'
+// ParserError 2314: (H:60-67): Expected ',' but got 'private'
diff --git a/compiler/test/libsolidity/syntaxTests/visibility/invalid_variable_visibility.sol b/compiler/test/libsolidity/syntaxTests/visibility/invalid_variable_visibility.sol
new file mode 100644
index 00000000..4fc73dfb
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/visibility/invalid_variable_visibility.sol
@@ -0,0 +1,29 @@
+==== Source: A ====
+contract test {
+    function f(uint a) public {
+        uint public a;
+    }
+}
+==== Source: B ====
+contract test {
+    function f(uint a) public {
+        uint private a;
+    }
+}
+==== Source: C ====
+contract test {
+    function f(uint a) public {
+        uint external a;
+    }
+}
+==== Source: D ====
+contract test {
+    function f(uint a) public {
+        uint internal a;
+    }
+}
+// ----
+// ParserError 2314: (A:61-67): Expected ';' but got 'public'
+// ParserError 2314: (B:61-68): Expected ';' but got 'private'
+// ParserError 2314: (C:61-69): Expected ';' but got 'external'
+// ParserError 2314: (D:61-69): Expected ';' but got 'internal'
diff --git a/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers.sol b/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers.sol
new file mode 100644
index 00000000..5f3d6d68
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers.sol
@@ -0,0 +1,53 @@
+contract C {
+    uint private internal a;
+    uint private public b;
+    uint private private c;
+    uint internal internal e;
+    uint internal public f;
+    uint internal private g;
+    uint public internal h;
+    uint public public i;
+    uint public private j;
+    function f1() private external {}
+    function f2() private internal {}
+    function f3() private public {}
+    function f4() private private {}
+    function f5() external external {}
+    function f6() external internal {}
+    function f7() external public {}
+    function f8() external private {}
+    function f9() internal external {}
+    function f10() internal internal {}
+    function f11() internal public {}
+    function f12() internal private {}
+    function f13() public external {}
+    function f14() public internal {}
+    function f15() public public {}
+    function f16() public private {}
+}
+// ----
+// ParserError 4110: (30-38): Visibility already specified as "private".
+// ParserError 4110: (59-65): Visibility already specified as "private".
+// ParserError 4110: (86-93): Visibility already specified as "private".
+// ParserError 4110: (115-123): Visibility already specified as "internal".
+// ParserError 4110: (145-151): Visibility already specified as "internal".
+// ParserError 4110: (173-180): Visibility already specified as "internal".
+// ParserError 4110: (200-208): Visibility already specified as "public".
+// ParserError 4110: (228-234): Visibility already specified as "public".
+// ParserError 4110: (254-261): Visibility already specified as "public".
+// ParserError 9439: (291-299): Visibility already specified as "private".
+// ParserError 9439: (329-337): Visibility already specified as "private".
+// ParserError 9439: (367-373): Visibility already specified as "private".
+// ParserError 9439: (403-410): Visibility already specified as "private".
+// ParserError 9439: (441-449): Visibility already specified as "external".
+// ParserError 9439: (480-488): Visibility already specified as "external".
+// ParserError 9439: (519-525): Visibility already specified as "external".
+// ParserError 9439: (556-563): Visibility already specified as "external".
+// ParserError 9439: (594-602): Visibility already specified as "internal".
+// ParserError 9439: (634-642): Visibility already specified as "internal".
+// ParserError 9439: (674-680): Visibility already specified as "internal".
+// ParserError 9439: (712-719): Visibility already specified as "internal".
+// ParserError 9439: (749-757): Visibility already specified as "public".
+// ParserError 9439: (787-795): Visibility already specified as "public".
+// ParserError 9439: (825-831): Visibility already specified as "public".
+// ParserError 9439: (861-868): Visibility already specified as "public".
diff --git a/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers_external.sol b/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers_external.sol
new file mode 100644
index 00000000..b543e10a
--- /dev/null
+++ b/compiler/test/libsolidity/syntaxTests/visibility/multiple_visibility_specifiers_external.sol
@@ -0,0 +1,16 @@
+==== Source: A ====
+contract C {
+    uint external external x;
+}
+==== Source: B ====
+contract C {
+    uint internal external x;
+}
+==== Source: C ====
+contract C {
+    uint external internal x;
+}
+// ----
+// ParserError 2314: (A:22-30): Expected identifier but got 'external'
+// ParserError 2314: (B:31-39): Expected identifier but got 'external'
+// ParserError 2314: (C:22-30): Expected identifier but got 'external'
diff --git a/compiler/test/libsolidity/util/BytesUtils.cpp b/compiler/test/libsolidity/util/BytesUtils.cpp
new file mode 100644
index 00000000..fe519bf5
--- /dev/null
+++ b/compiler/test/libsolidity/util/BytesUtils.cpp
@@ -0,0 +1,442 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/util/BytesUtils.h>
+#include <test/libsolidity/util/ContractABIUtils.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <algorithm>
+#include <iterator>
+#include <iomanip>
+#include <memory>
+#include <regex>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+bytes BytesUtils::alignLeft(bytes _bytes)
+{
+	soltestAssert(_bytes.size() <= 32, "");
+	size_t size = _bytes.size();
+	return std::move(_bytes) + bytes(32 - size, 0);
+}
+
+bytes BytesUtils::alignRight(bytes _bytes)
+{
+	soltestAssert(_bytes.size() <= 32, "");
+	return bytes(32 - _bytes.size(), 0) + std::move(_bytes);
+}
+
+bytes BytesUtils::applyAlign(
+	Parameter::Alignment _alignment,
+	ABIType& _abiType,
+	bytes _bytes
+)
+{
+	if (_alignment != Parameter::Alignment::None)
+		_abiType.alignDeclared = true;
+
+	switch (_alignment)
+	{
+	case Parameter::Alignment::Left:
+		_abiType.align = ABIType::AlignLeft;
+		return alignLeft(std::move(_bytes));
+	case Parameter::Alignment::Right:
+	default:
+		_abiType.align = ABIType::AlignRight;
+		return alignRight(std::move(_bytes));
+	}
+}
+
+bytes BytesUtils::convertBoolean(std::string const& _literal)
+{
+	if (_literal == "true")
+		return bytes{true};
+	else if (_literal == "false")
+		return bytes{false};
+	else
+		BOOST_THROW_EXCEPTION(TestParserError("Boolean literal invalid."));
+}
+
+bytes BytesUtils::convertNumber(std::string const& _literal)
+{
+	try
+	{
+		return toCompactBigEndian(u256{_literal});
+	}
+	catch (std::exception const&)
+	{
+		BOOST_THROW_EXCEPTION(TestParserError("Number encoding invalid."));
+	}
+}
+
+bytes BytesUtils::convertFixedPoint(std::string const& _literal, size_t& o_fractionalDigits)
+{
+	size_t dotPos = _literal.find('.');
+	o_fractionalDigits = dotPos < _literal.size() ? _literal.size() - dotPos : 0;
+	bool negative = !_literal.empty() && _literal.at(0) == '-';
+	// remove decimal point
+	std::string valueInteger = _literal.substr(0, dotPos) + _literal.substr(dotPos + 1);
+	// erase leading zeros to avoid parsing as octal.
+	while (!valueInteger.empty() && (valueInteger.at(0) == '0' || valueInteger.at(0) == '-'))
+		valueInteger.erase(valueInteger.begin());
+	if (valueInteger.empty())
+		valueInteger = "0";
+	try
+	{
+		u256 value(valueInteger);
+		if (negative)
+			value = s2u(-u2s(value));
+		return toBigEndian(value);
+	}
+	catch (std::exception const&)
+	{
+		BOOST_THROW_EXCEPTION(TestParserError("Number encoding invalid."));
+	}
+}
+
+bytes BytesUtils::convertHexNumber(std::string const& _literal)
+{
+	try
+	{
+		return fromHex(_literal);
+	}
+	catch (std::exception const&)
+	{
+		BOOST_THROW_EXCEPTION(TestParserError("Hex number encoding invalid."));
+	}
+}
+
+bytes BytesUtils::convertString(std::string const& _literal)
+{
+	try
+	{
+		return asBytes(_literal);
+	}
+	catch (std::exception const&)
+	{
+		BOOST_THROW_EXCEPTION(TestParserError("String encoding invalid."));
+	}
+}
+
+std::string BytesUtils::formatUnsigned(bytes const& _bytes)
+{
+	std::stringstream os;
+
+	soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
+
+	return fromBigEndian<u256>(_bytes).str();
+}
+
+std::string BytesUtils::formatSigned(bytes const& _bytes)
+{
+	std::stringstream os;
+
+	soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
+
+	if (*_bytes.begin() & 0x80)
+		os << u2s(fromBigEndian<u256>(_bytes));
+	else
+		os << fromBigEndian<u256>(_bytes);
+
+	return os.str();
+}
+
+std::string BytesUtils::formatBoolean(bytes const& _bytes)
+{
+	std::stringstream os;
+	u256 result = fromBigEndian<u256>(_bytes);
+
+	if (result == 0)
+		os << "false";
+	else if (result == 1)
+		os << "true";
+	else
+		os << result;
+
+	return os.str();
+}
+
+std::string BytesUtils::formatHex(bytes const& _bytes, bool _shorten)
+{
+	soltestAssert(!_bytes.empty() && _bytes.size() <= 32, "");
+	u256 value = fromBigEndian<u256>(_bytes);
+	std::string output = toCompactHexWithPrefix(value);
+
+	if (_shorten)
+		return output.substr(0, output.size() - countRightPaddedZeros(_bytes) * 2);
+	return output;
+}
+
+std::string BytesUtils::formatHexString(bytes const& _bytes)
+{
+	std::stringstream os;
+
+	os << "hex\"" << util::toHex(_bytes) << "\"";
+
+	return os.str();
+}
+
+std::string BytesUtils::formatString(bytes const& _bytes, size_t _cutOff)
+{
+	std::stringstream os;
+
+	os << "\"";
+	for (size_t i = 0; i < std::min(_cutOff, _bytes.size()); ++i)
+	{
+		auto const v = _bytes[i];
+		switch (v)
+		{
+			case '\0':
+				os << "\\0";
+				break;
+			case '\n':
+				os << "\\n";
+				break;
+			default:
+				if (isPrint(static_cast<char>(v)))
+					os << v;
+				else
+					os << "\\x" << util::toHex(v, HexCase::Lower);
+		}
+	}
+	os << "\"";
+
+	return os.str();
+}
+
+std::string BytesUtils::formatFixedPoint(bytes const& _bytes, bool _signed, size_t _fractionalDigits)
+{
+	std::string decimal;
+	bool negative = false;
+	if (_signed)
+	{
+		s256 signedValue{u2s(fromBigEndian<u256>(_bytes))};
+		negative = (signedValue < 0);
+		decimal = signedValue.str();
+	}
+	else
+		decimal = fromBigEndian<u256>(_bytes).str();
+	if (_fractionalDigits > 0)
+	{
+		size_t numDigits = decimal.length() - (negative ? 1 : 0);
+		if (_fractionalDigits >= numDigits)
+			decimal.insert(negative ? 1 : 0, std::string(_fractionalDigits + 1 - numDigits, '0'));
+		decimal.insert(decimal.length() - _fractionalDigits, ".");
+	}
+	return decimal;
+}
+
+std::string BytesUtils::formatRawBytes(
+	bytes const& _bytes,
+	solidity::frontend::test::ParameterList const& _parameters,
+	std::string _linePrefix
+)
+{
+	std::stringstream os;
+	ParameterList parameters;
+	auto it = _bytes.begin();
+
+	if (_bytes.size() != ContractABIUtils::encodingSize(_parameters))
+	{
+		// Interpret all full 32-byte values as integers.
+		parameters = ContractABIUtils::defaultParameters(_bytes.size() / 32);
+
+		// We'd introduce trailing zero bytes if we interpreted the final bit as an integer.
+		// We want a right-aligned sequence of bytes instead.
+		if (_bytes.size() % 32 != 0)
+			parameters.push_back({
+				bytes(),
+				"",
+				ABIType{ABIType::HexString, ABIType::AlignRight, _bytes.size() % 32},
+				FormatInfo{},
+			});
+	}
+	else
+		parameters = _parameters;
+	soltestAssert(ContractABIUtils::encodingSize(parameters) >= _bytes.size());
+
+	for (auto const& parameter: parameters)
+	{
+		long actualSize = std::min(
+			distance(it, _bytes.end()),
+			static_cast<ParameterList::difference_type>(parameter.abiType.size)
+		);
+		bytes byteRange(parameter.abiType.size, 0);
+		copy(it, it + actualSize, byteRange.begin());
+
+		os << _linePrefix << byteRange;
+		if (&parameter != &parameters.back())
+			os << std::endl;
+
+		it += actualSize;
+	}
+
+	return os.str();
+}
+
+std::string BytesUtils::formatBytes(
+	bytes const& _bytes,
+	ABIType const& _abiType
+)
+{
+	std::stringstream os;
+
+	switch (_abiType.type)
+	{
+	case ABIType::UnsignedDec:
+		// Check if the detected type was wrong and if this could
+		// be signed. If an unsigned was detected in the expectations,
+		// but the actual result returned a signed, it would be formatted
+		// incorrectly.
+		if (*_bytes.begin() & 0x80)
+			os << formatSigned(_bytes);
+		else
+		{
+			std::string decimal(formatUnsigned(_bytes));
+			std::string hexadecimal(formatHex(_bytes));
+			unsigned int value = u256(_bytes).convert_to<unsigned int>();
+			if (value < 0x10)
+				os << decimal;
+			else if (value >= 0x10 && value <= 0xff) {
+				os << hexadecimal;
+			}
+			else
+			{
+				auto entropy = [](std::string const& str) -> double {
+					double result = 0;
+					std::map<char, double> frequencies;
+					for (char c: str)
+						frequencies[c]++;
+					for (auto p: frequencies)
+					{
+						double freq = p.second / double(str.length());
+						result -= freq * (log(freq) / log(2.0));
+					}
+					return result;
+				};
+				if (entropy(decimal) < entropy(hexadecimal.substr(2, hexadecimal.length())))
+					os << decimal;
+				else
+					os << hexadecimal;
+			}
+		}
+		break;
+	case ABIType::SignedDec:
+		os << formatSigned(_bytes);
+		break;
+	case ABIType::Boolean:
+		os << formatBoolean(_bytes);
+		break;
+	case ABIType::Hex:
+		os << formatHex(_bytes, _abiType.alignDeclared);
+		break;
+	case ABIType::HexString:
+		os << formatHexString(_bytes);
+		break;
+	case ABIType::String:
+		os << formatString(_bytes, _bytes.size() - countRightPaddedZeros(_bytes));
+		break;
+	case ABIType::UnsignedFixedPoint:
+	case ABIType::SignedFixedPoint:
+		os << formatFixedPoint(_bytes, _abiType.type == ABIType::SignedFixedPoint, _abiType.fractionalDigits);
+		break;
+	case ABIType::Failure:
+	case ABIType::None:
+		break;
+	}
+
+	if (_abiType.alignDeclared)
+		return (_abiType.align == ABIType::AlignLeft ? "left(" : "right(") + os.str() + ")";
+	return os.str();
+}
+
+std::string BytesUtils::formatBytesRange(
+	bytes _bytes,
+	solidity::frontend::test::ParameterList const& _parameters,
+	bool _highlight
+)
+{
+	std::stringstream os;
+	ParameterList parameters;
+	auto it = _bytes.begin();
+
+	if (_bytes.size() != ContractABIUtils::encodingSize(_parameters))
+	{
+		// Interpret all full 32-byte values as integers.
+		parameters = ContractABIUtils::defaultParameters(_bytes.size() / 32);
+
+		// We'd introduce trailing zero bytes if we interpreted the final bit as an integer.
+		// We want a right-aligned sequence of bytes instead.
+		if (_bytes.size() % 32 != 0)
+			parameters.push_back({
+				bytes(),
+				"",
+				ABIType{ABIType::HexString, ABIType::AlignRight, _bytes.size() % 32},
+				FormatInfo{},
+			});
+	}
+	else
+		parameters = _parameters;
+	soltestAssert(ContractABIUtils::encodingSize(parameters) >= _bytes.size());
+
+	for (auto const& parameter: parameters)
+	{
+		long actualSize = std::min(
+			distance(it, _bytes.end()),
+			static_cast<ParameterList::difference_type>(parameter.abiType.size)
+		);
+		bytes byteRange(parameter.abiType.size, 0);
+		copy(it, it + actualSize, byteRange.begin());
+
+		if (!parameter.matchesBytes(byteRange))
+			AnsiColorized(
+				os,
+				_highlight,
+				{util::formatting::RED_BACKGROUND}
+			) << formatBytes(byteRange, parameter.abiType);
+		else
+			os << parameter.rawString;
+
+		if (&parameter != &parameters.back())
+			os << ", ";
+
+		it += actualSize;
+	}
+
+	return os.str();
+}
+
+size_t BytesUtils::countRightPaddedZeros(bytes const& _bytes)
+{
+	return static_cast<size_t>(find_if(
+		_bytes.rbegin(),
+		_bytes.rend(),
+		[](uint8_t b) { return b != '\0'; }
+	) - _bytes.rbegin());
+}
+
diff --git a/compiler/test/libsolidity/util/BytesUtilsTests.cpp b/compiler/test/libsolidity/util/BytesUtilsTests.cpp
new file mode 100644
index 00000000..f5a15db3
--- /dev/null
+++ b/compiler/test/libsolidity/util/BytesUtilsTests.cpp
@@ -0,0 +1,81 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <boost/test/unit_test.hpp>
+
+#include <test/libsolidity/util/BytesUtils.h>
+
+#include <libsolutil/CommonData.h>
+
+using namespace solidity::util;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(BytesUtilsTest)
+
+BOOST_AUTO_TEST_CASE(format_fixed)
+{
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{0}), true, 2),
+		"0.00"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{1}), true, 2),
+		"0.01"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{123}), true, 2),
+		"1.23"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-1}), true, 2),
+		"-0.01"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-12}), true, 2),
+		"-0.12"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-123}), true, 2),
+		"-1.23"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-1234}), true, 2),
+		"-12.34"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-12345}), true, 2),
+		"-123.45"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-123456}), true, 2),
+		"-1234.56"
+	);
+	BOOST_CHECK_EQUAL(
+		BytesUtils::formatFixedPoint(toBigEndian(u256{-1234567}), true, 2),
+		"-12345.67"
+	);
+}
+
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/util/Common.cpp b/compiler/test/libsolidity/util/Common.cpp
new file mode 100644
index 00000000..6f96b7f6
--- /dev/null
+++ b/compiler/test/libsolidity/util/Common.cpp
@@ -0,0 +1,66 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/util/Common.h>
+
+#include <regex>
+
+using namespace solidity;
+using namespace solidity::frontend;
+
+std::string test::withPreamble(std::string const& _sourceCode, bool _addAbicoderV1Pragma)
+{
+	static std::string const versionPragma = "pragma solidity >=0.0;\n";
+	static std::string const licenseComment = "// SPDX-License-Identifier: GPL-3.0\n";
+	static std::string const abicoderPragma = "pragma abicoder v1;\n";
+
+	// NOTE: These checks are intentionally loose to match weird cases.
+	// We can manually adjust a test case where this causes problem.
+	bool licenseMissing = _sourceCode.find("SPDX-License-Identifier:") == std::string::npos;
+	bool abicoderMissing =
+		_sourceCode.find("pragma experimental ABIEncoderV2;") == std::string::npos &&
+		_sourceCode.find("pragma abicoder") == std::string::npos;
+
+	return
+		versionPragma +
+		(licenseMissing ? licenseComment : "") +
+		(abicoderMissing && _addAbicoderV1Pragma ? abicoderPragma : "") +
+		_sourceCode;
+}
+
+StringMap test::withPreamble(StringMap _sources, bool _addAbicoderV1Pragma)
+{
+	for (auto&& [sourceName, source]: _sources)
+		source = withPreamble(source, _addAbicoderV1Pragma);
+
+	return _sources;
+}
+
+std::string test::stripPreReleaseWarning(std::string const& _stderrContent)
+{
+	static std::regex const preReleaseWarningRegex{
+		R"(Warning( \(3805\))?: This is a pre-release compiler version, please do not use it in production\.\n)"
+		R"((\n)?)"
+	};
+	static std::regex const noOutputRegex{
+		R"(Compiler run successful, no output requested\.\n)"
+	};
+
+	std::string output = std::regex_replace(_stderrContent, preReleaseWarningRegex, "");
+	return std::regex_replace(std::move(output), noOutputRegex, "");
+}
diff --git a/compiler/test/libsolidity/util/Common.h b/compiler/test/libsolidity/util/Common.h
new file mode 100644
index 00000000..3f1750a6
--- /dev/null
+++ b/compiler/test/libsolidity/util/Common.h
@@ -0,0 +1,37 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Utilities shared by multiple libsolidity tests.
+
+#include <libsolidity/interface/CompilerStack.h>
+
+#include <string>
+
+namespace solidity::frontend::test
+{
+
+/// @returns @p _sourceCode prefixed with the version pragma and the SPDX license identifier.
+/// Can optionally also insert an abicoder pragma when missing.
+std::string withPreamble(std::string const& _sourceCode, bool _addAbicoderV1Pragma = false);
+
+/// @returns a copy of @p _sources with preamble prepended to all sources.
+StringMap withPreamble(StringMap _sources, bool _addAbicoderV1Pragma = false);
+
+std::string stripPreReleaseWarning(std::string const& _stderrContent);
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/libsolidity/util/ContractABIUtils.cpp b/compiler/test/libsolidity/util/ContractABIUtils.cpp
new file mode 100644
index 00000000..641c9107
--- /dev/null
+++ b/compiler/test/libsolidity/util/ContractABIUtils.cpp
@@ -0,0 +1,365 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libsolidity/util/ContractABIUtils.h>
+
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolidity/ast/Types.h>
+#include <libsolidity/ast/TypeProvider.h>
+#include <libsolutil/FunctionSelector.h>
+#include <libsolutil/CommonData.h>
+
+#include <liblangutil/Common.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/assign/list_of.hpp>
+#include <range/v3/view/zip.hpp>
+
+#include <fstream>
+#include <memory>
+#include <numeric>
+#include <regex>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend::test;
+
+namespace
+{
+
+using ParameterList = solidity::frontend::test::ParameterList;
+
+size_t arraySize(std::string const& _arrayType)
+{
+	auto leftBrack = _arrayType.find("[");
+	auto rightBrack = _arrayType.rfind("]");
+
+	soltestAssert(
+		leftBrack != std::string::npos &&
+		rightBrack != std::string::npos &&
+		rightBrack == _arrayType.size() - 1 &&
+		leftBrack < rightBrack,
+		""
+	);
+
+	std::string size = _arrayType.substr(leftBrack + 1, rightBrack - leftBrack - 1);
+
+	return static_cast<size_t>(stoi(size));
+}
+
+bool isBool(std::string const& _type)
+{
+	return _type == "bool";
+}
+
+bool isUint(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"uint\\d*"});
+}
+
+bool isInt(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"int\\d*"});
+}
+
+bool isFixedBytes(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"bytes\\d+"});
+}
+
+bool isBytes(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"\\bbytes\\b"});
+}
+
+bool isString(std::string const& _type)
+{
+	return _type == "string";
+}
+
+bool isFixedBoolArray(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"bool\\[\\d+\\]"});
+}
+
+bool isFixedUintArray(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"uint\\d*\\[\\d+\\]"});
+}
+
+bool isFixedIntArray(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"int\\d*\\[\\d+\\]"});
+}
+
+bool isFixedStringArray(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"string\\[\\d+\\]"});
+}
+
+bool isTuple(std::string const& _type)
+{
+	return _type == "tuple";
+}
+
+bool isFixedTupleArray(std::string const& _type)
+{
+	return regex_match(_type, std::regex{"tuple\\[\\d+\\]"});
+}
+
+std::optional<ABIType> isFixedPoint(std::string const& type)
+{
+	std::optional<ABIType> fixedPointType;
+	std::smatch matches;
+	if (regex_match(type, matches, std::regex{"(u?)fixed(\\d+)x(\\d+)"}))
+	{
+		ABIType abiType(ABIType::SignedFixedPoint);
+		if (matches[1].str() == "u")
+			abiType.type = ABIType::UnsignedFixedPoint;
+		abiType.fractionalDigits = static_cast<unsigned>(std::stoi(matches[3].str()));
+		fixedPointType = abiType;
+	}
+	return fixedPointType;
+}
+
+std::string functionSignatureFromABI(Json::Value const& _functionABI)
+{
+	auto inputs = _functionABI["inputs"];
+	std::string signature = {_functionABI["name"].asString() + "("};
+	size_t parameterCount = 0;
+
+	for (auto const& input: inputs)
+	{
+		parameterCount++;
+		signature += input["type"].asString();
+		if (parameterCount < inputs.size())
+			signature += ",";
+	}
+
+	return signature + ")";
+}
+
+}
+
+std::optional<solidity::frontend::test::ParameterList> ContractABIUtils::parametersFromJsonOutputs(
+	ErrorReporter& _errorReporter,
+	Json::Value const& _contractABI,
+	std::string const& _functionSignature
+)
+{
+	if (!_contractABI)
+		return std::nullopt;
+
+	for (auto const& function: _contractABI)
+		if (_functionSignature == functionSignatureFromABI(function))
+		{
+			ParameterList inplaceTypeParams;
+			ParameterList dynamicTypeParams;
+			ParameterList finalParams;
+
+			for (auto const& output: function["outputs"])
+			{
+				std::string type = output["type"].asString();
+
+				ABITypes inplaceTypes;
+				ABITypes dynamicTypes;
+
+				if (appendTypesFromName(output, inplaceTypes, dynamicTypes))
+				{
+					for (auto const& type: inplaceTypes)
+						inplaceTypeParams.push_back(Parameter{bytes(), "", type, FormatInfo{}});
+					for (auto const& type: dynamicTypes)
+						dynamicTypeParams.push_back(Parameter{bytes(), "", type, FormatInfo{}});
+				}
+				else
+				{
+					_errorReporter.warning(
+						"Could not convert \"" + type +
+						"\" to internal ABI type representation. Falling back to default encoding."
+					);
+					return std::nullopt;
+				}
+
+				finalParams += inplaceTypeParams;
+
+				inplaceTypeParams.clear();
+			}
+			return std::optional<ParameterList>(finalParams + dynamicTypeParams);
+		}
+
+	return std::nullopt;
+}
+
+bool ContractABIUtils::appendTypesFromName(
+	Json::Value const& _functionOutput,
+	ABITypes& _inplaceTypes,
+	ABITypes& _dynamicTypes,
+	bool _isCompoundType
+)
+{
+	std::string type = _functionOutput["type"].asString();
+	if (isBool(type))
+		_inplaceTypes.push_back(ABIType{ABIType::Boolean});
+	else if (isUint(type))
+		_inplaceTypes.push_back(ABIType{ABIType::UnsignedDec});
+	else if (isInt(type))
+		_inplaceTypes.push_back(ABIType{ABIType::SignedDec});
+	else if (isFixedBytes(type))
+		_inplaceTypes.push_back(ABIType{ABIType::Hex});
+	else if (isString(type))
+	{
+		_inplaceTypes.push_back(ABIType{ABIType::Hex});
+
+		if (_isCompoundType)
+			_dynamicTypes.push_back(ABIType{ABIType::Hex});
+
+		_dynamicTypes.push_back(ABIType{ABIType::UnsignedDec});
+		_dynamicTypes.push_back(ABIType{ABIType::String, ABIType::AlignLeft});
+	}
+	else if (isTuple(type))
+	{
+		ABITypes inplaceTypes;
+		ABITypes dynamicTypes;
+
+		for (auto const& component: _functionOutput["components"])
+			appendTypesFromName(component, inplaceTypes, dynamicTypes, true);
+		_dynamicTypes += inplaceTypes + dynamicTypes;
+	}
+	else if (isFixedBoolArray(type))
+		_inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::Boolean});
+	else if (isFixedUintArray(type))
+		_inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::UnsignedDec});
+	else if (isFixedIntArray(type))
+		_inplaceTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::SignedDec});
+	else if (isFixedStringArray(type))
+	{
+		_inplaceTypes.push_back(ABIType{ABIType::Hex});
+
+		_dynamicTypes += std::vector<ABIType>(arraySize(type), ABIType{ABIType::Hex});
+
+		for (size_t i = 0; i < arraySize(type); i++)
+		{
+			_dynamicTypes.push_back(ABIType{ABIType::UnsignedDec});
+			_dynamicTypes.push_back(ABIType{ABIType::String, ABIType::AlignLeft});
+		}
+	}
+	else if (std::optional<ABIType> fixedPointType = isFixedPoint(type))
+		_inplaceTypes.push_back(*fixedPointType);
+	else if (isBytes(type))
+		return false;
+	else if (isFixedTupleArray(type))
+		return false;
+	else
+		return false;
+
+	return true;
+}
+
+void ContractABIUtils::overwriteParameters(
+	ErrorReporter& _errorReporter,
+	solidity::frontend::test::ParameterList& _targetParameters,
+	solidity::frontend::test::ParameterList const& _sourceParameters
+)
+{
+	using namespace std::placeholders;
+	for (auto&& [source, target]: ranges::views::zip(_sourceParameters, _targetParameters))
+		if (
+				source.abiType.size != target.abiType.size ||
+				source.abiType.type != target.abiType.type ||
+				source.abiType.fractionalDigits != target.abiType.fractionalDigits
+			)
+			{
+				_errorReporter.warning("Type or size of parameter(s) does not match.");
+				target = source;
+			}
+}
+
+solidity::frontend::test::ParameterList ContractABIUtils::preferredParameters(
+	ErrorReporter& _errorReporter,
+	solidity::frontend::test::ParameterList const& _targetParameters,
+	solidity::frontend::test::ParameterList const& _sourceParameters,
+	bytes const& _bytes
+)
+{
+	if (_targetParameters.size() != _sourceParameters.size())
+	{
+		_errorReporter.warning(
+			"Encoding does not match byte range. The call returned " +
+			std::to_string(_bytes.size()) + " bytes, but " +
+			std::to_string(encodingSize(_targetParameters)) + " bytes were expected."
+		);
+		return _sourceParameters;
+	}
+	else
+		return _targetParameters;
+}
+
+solidity::frontend::test::ParameterList ContractABIUtils::defaultParameters(size_t count)
+{
+	ParameterList parameters;
+
+	fill_n(
+		back_inserter(parameters),
+		count,
+		Parameter{bytes(), "", ABIType{ABIType::UnsignedDec}, FormatInfo{}}
+	);
+
+	return parameters;
+}
+
+solidity::frontend::test::ParameterList ContractABIUtils::failureParameters(bytes const& _bytes)
+{
+	if (_bytes.empty())
+		return {};
+	else if (_bytes.size() < 4)
+		return {Parameter{bytes(), "", ABIType{ABIType::HexString, ABIType::AlignNone, _bytes.size()}, FormatInfo{}}};
+	else
+	{
+		ParameterList parameters;
+		parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::HexString, ABIType::AlignNone, 4}, FormatInfo{}});
+
+		uint64_t selector = fromBigEndian<uint64_t>(bytes{_bytes.begin(), _bytes.begin() + 4});
+		if (selector == selectorFromSignatureU32("Panic(uint256)"))
+			parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::Hex}, FormatInfo{}});
+		else if (selector == selectorFromSignatureU32("Error(string)"))
+		{
+			parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::Hex}, FormatInfo{}});
+			parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::UnsignedDec}, FormatInfo{}});
+			/// If _bytes contains at least a 1 byte message (function selector + tail pointer + message length + message)
+			/// append an additional string parameter to represent that message.
+			if (_bytes.size() > 68)
+				parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::String}, FormatInfo{}});
+		}
+		else
+			for (size_t i = 4; i < _bytes.size(); i += 32)
+				parameters.push_back(Parameter{bytes(), "", ABIType{ABIType::HexString, ABIType::AlignNone, 32}, FormatInfo{}});
+		return parameters;
+	}
+}
+
+size_t ContractABIUtils::encodingSize(
+	solidity::frontend::test::ParameterList const& _parameters
+)
+{
+	auto sizeFold = [](size_t const _a, Parameter const& _b) { return _a + _b.abiType.size; };
+
+	return accumulate(_parameters.begin(), _parameters.end(), size_t{0}, sizeFold);
+}
diff --git a/compiler/test/libsolidity/util/TestFileParser.cpp b/compiler/test/libsolidity/util/TestFileParser.cpp
new file mode 100644
index 00000000..3fba998a
--- /dev/null
+++ b/compiler/test/libsolidity/util/TestFileParser.cpp
@@ -0,0 +1,798 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+
+#include <libsolutil/StringUtils.h>
+
+#include <test/libsolidity/util/TestFileParser.h>
+
+#include <test/libsolidity/util/BytesUtils.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <test/Common.h>
+
+#include <liblangutil/Common.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+using Token = soltest::Token;
+
+char TestFileParser::Scanner::peek() const noexcept
+{
+	if (std::distance(m_char, m_source.end()) < 2)
+		return '\0';
+
+	auto next = m_char;
+	std::advance(next, 1);
+	return *next;
+}
+
+std::vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCalls(size_t _lineOffset)
+{
+	std::vector<FunctionCall> calls;
+	if (!accept(Token::EOS))
+	{
+		soltestAssert(m_scanner.currentToken() == Token::Unknown, "");
+		m_scanner.scanNextToken();
+
+		while (!accept(Token::EOS))
+		{
+			if (!accept(Token::Whitespace))
+			{
+				/// If this is not the first call in the test,
+				/// the last call to parseParameter could have eaten the
+				/// new line already. This could only be fixed with a one
+				/// token lookahead that checks parseParameter
+				/// if the next token is an identifier.
+				if (calls.empty())
+					expect(Token::Newline);
+				else
+					if (accept(Token::Newline, true))
+						m_lineNumber++;
+
+				try
+				{
+					if (accept(Token::Gas, true))
+					{
+						if (calls.empty())
+							BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter."));
+
+						std::string runType = m_scanner.currentLiteral();
+						if (std::set<std::string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0)
+						{
+							m_scanner.scanNextToken();
+							expect(Token::Colon);
+							if (calls.back().expectations.gasUsed.count(runType) > 0)
+								throw TestParserError("Gas usage expectation set multiple times.");
+							calls.back().expectations.gasUsed[runType] = u256(parseDecimalNumber());
+						}
+						else
+							BOOST_THROW_EXCEPTION(TestParserError(
+								"Expected \"ir\", \"irOptimized\", \"legacy\", or \"legacyOptimized\"."
+							));
+					}
+					else
+					{
+						FunctionCall call;
+						if (accept(Token::Library, true))
+						{
+							expect(Token::Colon);
+							std::string libraryName;
+							if (accept(Token::String))
+							{
+								call.libraryFile = m_scanner.currentLiteral();
+								expect(Token::String);
+								expect(Token::Colon);
+								libraryName += m_scanner.currentLiteral();
+								expect(Token::Identifier);
+							}
+							else if (accept(Token::Colon, true))
+							{
+								libraryName = m_scanner.currentLiteral();
+								expect(Token::Identifier);
+							}
+							else
+							{
+								libraryName = m_scanner.currentLiteral();
+								expect(Token::Identifier);
+							}
+							call.signature = libraryName;
+							call.kind = FunctionCall::Kind::Library;
+							call.expectations.failure = false;
+						}
+						else
+						{
+							bool lowLevelCall = false;
+							tie(call.signature, lowLevelCall) = parseFunctionSignature();
+							if (lowLevelCall)
+								call.kind = FunctionCall::Kind::LowLevel;
+							else if (isBuiltinFunction(call.signature))
+								call.kind = FunctionCall::Kind::Builtin;
+
+							if (accept(Token::Comma, true))
+								call.value = parseFunctionCallValue();
+
+							if (accept(Token::Colon, true))
+								call.arguments = parseFunctionCallArguments();
+
+							if (accept(Token::Newline, true))
+							{
+								call.displayMode = FunctionCall::DisplayMode::MultiLine;
+								m_lineNumber++;
+							}
+
+							call.arguments.comment = parseComment();
+
+							if (accept(Token::Newline, true))
+							{
+								call.displayMode = FunctionCall::DisplayMode::MultiLine;
+								m_lineNumber++;
+							}
+
+							if (accept(Token::Arrow, true))
+							{
+								call.omitsArrow = false;
+								call.expectations = parseFunctionCallExpectations();
+								if (accept(Token::Newline, true))
+									m_lineNumber++;
+							}
+							else
+							{
+								call.expectations.failure = false;
+								call.displayMode = FunctionCall::DisplayMode::SingleLine;
+							}
+
+							call.expectations.comment = parseComment();
+
+							if (call.signature == "constructor()")
+								call.kind = FunctionCall::Kind::Constructor;
+						}
+
+						accept(Token::Newline, true);
+						call.expectedSideEffects = parseFunctionCallSideEffects();
+
+						calls.emplace_back(std::move(call));
+					}
+				}
+				catch (TestParserError const& _e)
+				{
+					BOOST_THROW_EXCEPTION(
+						TestParserError("Line " + std::to_string(_lineOffset + m_lineNumber) + ": " + _e.what())
+					);
+				}
+			}
+		}
+	}
+	return calls;
+}
+
+std::vector<std::string> TestFileParser::parseFunctionCallSideEffects()
+{
+	std::vector<std::string> result;
+	while (accept(Token::Tilde, false))
+	{
+		std::string effect = m_scanner.currentLiteral();
+		result.emplace_back(effect);
+		soltestAssert(m_scanner.currentToken() == Token::Tilde, "");
+		m_scanner.scanNextToken();
+		if (m_scanner.currentToken() == Token::Newline)
+			m_scanner.scanNextToken();
+	}
+
+	return result;
+}
+
+bool TestFileParser::accept(Token _token, bool const _expect)
+{
+	if (m_scanner.currentToken() != _token)
+		return false;
+	if (_expect)
+		return expect(_token);
+	return true;
+}
+
+bool TestFileParser::expect(Token _token, bool const _advance)
+{
+	if (m_scanner.currentToken() != _token || m_scanner.currentToken() == Token::Invalid)
+		BOOST_THROW_EXCEPTION(TestParserError(
+			"Unexpected " + formatToken(m_scanner.currentToken()) + ": \"" +
+			m_scanner.currentLiteral() + "\". " +
+			"Expected \"" + formatToken(_token) + "\"."
+			)
+		);
+	if (_advance)
+		m_scanner.scanNextToken();
+	return true;
+}
+
+std::pair<std::string, bool> TestFileParser::parseFunctionSignature()
+{
+	std::string signature;
+	bool hasName = false;
+
+	if (accept(Token::Identifier, false))
+	{
+		hasName = true;
+		signature = m_scanner.currentLiteral();
+		expect(Token::Identifier);
+	}
+
+	if (isBuiltinFunction(signature) && m_scanner.currentToken() != Token::LParen)
+		return {signature, false};
+
+	signature += formatToken(Token::LParen);
+	expect(Token::LParen);
+
+	std::string parameters;
+	if (!accept(Token::RParen, false))
+		parameters = parseIdentifierOrTuple();
+
+	while (accept(Token::Comma))
+	{
+		parameters += formatToken(Token::Comma);
+		expect(Token::Comma);
+		parameters += parseIdentifierOrTuple();
+	}
+	if (accept(Token::Arrow, true))
+		BOOST_THROW_EXCEPTION(TestParserError("Invalid signature detected: " + signature));
+
+	if (!hasName && !parameters.empty())
+		BOOST_THROW_EXCEPTION(TestParserError("Signatures without a name cannot have parameters: " + signature));
+	else
+		signature += parameters;
+
+	expect(Token::RParen);
+	signature += formatToken(Token::RParen);
+
+	return {signature, !hasName};
+}
+
+FunctionValue TestFileParser::parseFunctionCallValue()
+{
+	try
+	{
+		u256 value{ parseDecimalNumber() };
+		Token token = m_scanner.currentToken();
+		if (token != Token::Ether && token != Token::Wei)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid value unit provided. Coins can be wei or ether."));
+
+		m_scanner.scanNextToken();
+
+		FunctionValueUnit unit = token == Token::Wei ? FunctionValueUnit::Wei : FunctionValueUnit::Ether;
+		return { (unit == FunctionValueUnit::Wei ? u256(1) : exp256(u256(10), u256(18))) * value, unit };
+	}
+	catch (std::exception const&)
+	{
+		BOOST_THROW_EXCEPTION(TestParserError("Ether value encoding invalid."));
+	}
+}
+
+FunctionCallArgs TestFileParser::parseFunctionCallArguments()
+{
+	FunctionCallArgs arguments;
+
+	auto param = parseParameter();
+	if (param.abiType.type == ABIType::None)
+		BOOST_THROW_EXCEPTION(TestParserError("No argument provided."));
+	arguments.parameters.emplace_back(param);
+
+	while (accept(Token::Comma, true))
+		arguments.parameters.emplace_back(parseParameter());
+	return arguments;
+}
+
+FunctionCallExpectations TestFileParser::parseFunctionCallExpectations()
+{
+	FunctionCallExpectations expectations;
+
+	auto param = parseParameter();
+	if (param.abiType.type == ABIType::None)
+	{
+		expectations.failure = false;
+		return expectations;
+	}
+	expectations.result.emplace_back(param);
+
+	while (accept(Token::Comma, true))
+		expectations.result.emplace_back(parseParameter());
+
+	/// We have always one virtual parameter in the parameter list.
+	/// If its type is FAILURE, the expected result is also a REVERT etc.
+	if (expectations.result.at(0).abiType.type != ABIType::Failure)
+		expectations.failure = false;
+	return expectations;
+}
+
+Parameter TestFileParser::parseParameter()
+{
+	Parameter parameter;
+	if (accept(Token::Newline, true))
+	{
+		parameter.format.newline = true;
+		m_lineNumber++;
+	}
+	parameter.abiType = ABIType{ABIType::None, ABIType::AlignNone, 0};
+
+	bool isSigned = false;
+	if (accept(Token::Left, true))
+	{
+		parameter.rawString += formatToken(Token::Left);
+		expect(Token::LParen);
+		parameter.rawString += formatToken(Token::LParen);
+		parameter.alignment = Parameter::Alignment::Left;
+	}
+	if (accept(Token::Right, true))
+	{
+		parameter.rawString += formatToken(Token::Right);
+		expect(Token::LParen);
+		parameter.rawString += formatToken(Token::LParen);
+		parameter.alignment = Parameter::Alignment::Right;
+	}
+
+	if (accept(Token::Sub, true))
+	{
+		parameter.rawString += formatToken(Token::Sub);
+		isSigned = true;
+	}
+	if (accept(Token::Boolean))
+	{
+		if (isSigned)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid boolean literal."));
+
+		parameter.abiType = ABIType{ABIType::Boolean, ABIType::AlignRight, 32};
+		std::string parsed = parseBoolean();
+		parameter.rawString += parsed;
+		parameter.rawBytes = BytesUtils::applyAlign(
+			parameter.alignment,
+			parameter.abiType,
+			BytesUtils::convertBoolean(parsed)
+		);
+	}
+	else if (accept(Token::HexNumber))
+	{
+		if (isSigned)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid hex number literal."));
+
+		parameter.abiType = ABIType{ABIType::Hex, ABIType::AlignRight, 32};
+		std::string parsed = parseHexNumber();
+		parameter.rawString += parsed;
+		parameter.rawBytes = BytesUtils::applyAlign(
+			parameter.alignment,
+			parameter.abiType,
+			BytesUtils::convertHexNumber(parsed)
+		);
+	}
+	else if (accept(Token::Hex, true))
+	{
+		if (isSigned)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid hex string literal."));
+		if (parameter.alignment != Parameter::Alignment::None)
+			BOOST_THROW_EXCEPTION(TestParserError("Hex string literals cannot be aligned or padded."));
+
+		std::string parsed = parseString();
+		parameter.rawString += "hex\"" + parsed + "\"";
+		parameter.rawBytes = BytesUtils::convertHexNumber(parsed);
+		parameter.abiType = ABIType{
+			ABIType::HexString, ABIType::AlignNone, parameter.rawBytes.size()
+		};
+	}
+	else if (accept(Token::String))
+	{
+		if (isSigned)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid string literal."));
+		if (parameter.alignment != Parameter::Alignment::None)
+			BOOST_THROW_EXCEPTION(TestParserError("String literals cannot be aligned or padded."));
+
+		std::string parsed = parseString();
+		parameter.abiType = ABIType{ABIType::String, ABIType::AlignLeft, parsed.size()};
+		parameter.rawString += "\"" + parsed + "\"";
+		parameter.rawBytes = BytesUtils::applyAlign(
+			Parameter::Alignment::Left,
+			parameter.abiType,
+			BytesUtils::convertString(parsed)
+		);
+	}
+	else if (accept(Token::Number))
+	{
+		auto type = isSigned ? ABIType::SignedDec : ABIType::UnsignedDec;
+
+		parameter.abiType = ABIType{type, ABIType::AlignRight, 32};
+		std::string parsed = parseDecimalNumber();
+		parameter.rawString += parsed;
+		if (isSigned)
+			parsed = "-" + parsed;
+
+		if (parsed.find('.') == std::string::npos)
+			parameter.rawBytes = BytesUtils::applyAlign(
+				parameter.alignment,
+				parameter.abiType,
+				BytesUtils::convertNumber(parsed)
+			);
+		else
+		{
+			parameter.abiType.type = isSigned ? ABIType::SignedFixedPoint : ABIType::UnsignedFixedPoint;
+			parameter.rawBytes = BytesUtils::convertFixedPoint(parsed, parameter.abiType.fractionalDigits);
+		}
+	}
+	else if (accept(Token::Failure, true))
+	{
+		if (isSigned)
+			BOOST_THROW_EXCEPTION(TestParserError("Invalid failure literal."));
+
+		parameter.abiType = ABIType{ABIType::Failure, ABIType::AlignRight, 0};
+		parameter.rawBytes = bytes{};
+	}
+	if (parameter.alignment != Parameter::Alignment::None)
+	{
+		expect(Token::RParen);
+		parameter.rawString += formatToken(Token::RParen);
+	}
+
+	return parameter;
+}
+
+std::string TestFileParser::parseIdentifierOrTuple()
+{
+	std::string identOrTuple;
+
+	auto parseArrayDimensions = [&]()
+	{
+		while (accept(Token::LBrack))
+		{
+			identOrTuple += formatToken(Token::LBrack);
+			expect(Token::LBrack);
+			if (accept(Token::Number))
+				identOrTuple += parseDecimalNumber();
+			identOrTuple += formatToken(Token::RBrack);
+			expect(Token::RBrack);
+		}
+	};
+
+	if (accept(Token::Identifier))
+	{
+		identOrTuple = m_scanner.currentLiteral();
+		expect(Token::Identifier);
+		parseArrayDimensions();
+		return identOrTuple;
+	}
+	expect(Token::LParen);
+	identOrTuple += formatToken(Token::LParen);
+	identOrTuple += parseIdentifierOrTuple();
+
+	while (accept(Token::Comma))
+	{
+		identOrTuple += formatToken(Token::Comma);
+		expect(Token::Comma);
+		identOrTuple += parseIdentifierOrTuple();
+	}
+	expect(Token::RParen);
+	identOrTuple += formatToken(Token::RParen);
+
+	parseArrayDimensions();
+	return identOrTuple;
+}
+
+std::string TestFileParser::parseBoolean()
+{
+	std::string literal = m_scanner.currentLiteral();
+	expect(Token::Boolean);
+	return literal;
+}
+
+std::string TestFileParser::parseComment()
+{
+	std::string comment = m_scanner.currentLiteral();
+	if (accept(Token::Comment, true))
+		return comment;
+	return std::string{};
+}
+
+std::string TestFileParser::parseDecimalNumber()
+{
+	std::string literal = m_scanner.currentLiteral();
+	expect(Token::Number);
+	return literal;
+}
+
+std::string TestFileParser::parseHexNumber()
+{
+	std::string literal = m_scanner.currentLiteral();
+	expect(Token::HexNumber);
+	return literal;
+}
+
+std::string TestFileParser::parseString()
+{
+	std::string literal = m_scanner.currentLiteral();
+	expect(Token::String);
+	return literal;
+}
+
+void TestFileParser::Scanner::readStream(std::istream& _stream)
+{
+	std::string line;
+	// TODO: std::getline(..) removes newlines '\n', if present. This could be improved.
+	while (std::getline(_stream, line))
+		m_source += line;
+	m_char = m_source.begin();
+}
+
+void TestFileParser::Scanner::scanNextToken()
+{
+	// Make code coverage happy.
+	soltestAssert(formatToken(Token::NUM_TOKENS).empty(), "");
+
+	auto detectKeyword = [](std::string const& _literal = "") -> std::pair<Token, std::string> {
+		if (_literal == "true") return {Token::Boolean, "true"};
+		if (_literal == "false") return {Token::Boolean, "false"};
+		if (_literal == "ether") return {Token::Ether, ""};
+		if (_literal == "wei") return {Token::Wei, ""};
+		if (_literal == "left") return {Token::Left, ""};
+		if (_literal == "library") return {Token::Library, ""};
+		if (_literal == "right") return {Token::Right, ""};
+		if (_literal == "hex") return {Token::Hex, ""};
+		if (_literal == "FAILURE") return {Token::Failure, ""};
+		if (_literal == "gas") return {Token::Gas, ""};
+		return {Token::Identifier, _literal};
+	};
+
+	auto selectToken = [this](Token _token, std::string const& _literal = "") {
+		advance();
+		m_currentToken = _token;
+		m_currentLiteral = _literal;
+	};
+
+	m_currentToken = Token::Unknown;
+	m_currentLiteral = "";
+	do
+	{
+		switch(current())
+		{
+		case '/':
+			advance();
+			if (current() == '/')
+				selectToken(Token::Newline);
+			else
+				selectToken(Token::Invalid);
+			break;
+		case '-':
+			if (peek() == '>')
+			{
+				advance();
+				selectToken(Token::Arrow);
+			}
+			else
+				selectToken(Token::Sub);
+			break;
+		case '~':
+			advance();
+			selectToken(Token::Tilde, readLine());
+			break;
+		case ':':
+			selectToken(Token::Colon);
+			break;
+		case '#':
+			selectToken(Token::Comment, scanComment());
+			break;
+		case ',':
+			selectToken(Token::Comma);
+			break;
+		case '(':
+			selectToken(Token::LParen);
+			break;
+		case ')':
+			selectToken(Token::RParen);
+			break;
+		case '[':
+			selectToken(Token::LBrack);
+			break;
+		case ']':
+			selectToken(Token::RBrack);
+			break;
+		case '\"':
+			selectToken(Token::String, scanString());
+			break;
+		default:
+			if (langutil::isIdentifierStart(current()))
+			{
+				std::tie(m_currentToken, m_currentLiteral) = detectKeyword(scanIdentifierOrKeyword());
+				advance();
+			}
+			else if (langutil::isDecimalDigit(current()))
+			{
+				if (current() == '0' && peek() == 'x')
+				{
+					advance();
+					advance();
+					selectToken(Token::HexNumber, "0x" + scanHexNumber());
+				}
+				else
+					selectToken(Token::Number, scanDecimalNumber());
+			}
+			else if (langutil::isWhiteSpace(current()))
+				selectToken(Token::Whitespace);
+			else if (isEndOfFile())
+			{
+				m_currentToken = Token::EOS;
+				m_currentLiteral = "";
+			}
+			else
+				BOOST_THROW_EXCEPTION(TestParserError("Unexpected character: '" + std::string{current()} + "'"));
+			break;
+		}
+	}
+	while (m_currentToken == Token::Whitespace);
+}
+
+std::string TestFileParser::Scanner::readLine()
+{
+	std::string line;
+	// Right now the scanner discards all (real) new-lines '\n' in TestFileParser::Scanner::readStream(..).
+	// Token::NewLine is defined as `//`, and NOT '\n'. We are just searching here for the next `/`.
+	// Note that `/` anywhere else than at the beginning of a line is currently forbidden (TODO: until we fix newline handling).
+	// Once the end of the file would be reached (or beyond), peek() will return '\0'.
+	while (peek() != '\0' && peek() != '/')
+	{
+		advance();
+		line += current();
+	}
+	return line;
+}
+
+std::string TestFileParser::Scanner::scanComment()
+{
+	std::string comment;
+	advance();
+
+	while (current() != '#')
+	{
+		comment += current();
+		advance();
+	}
+	return comment;
+}
+
+std::string TestFileParser::Scanner::scanIdentifierOrKeyword()
+{
+	std::string identifier;
+	identifier += current();
+	while (langutil::isIdentifierPart(peek()))
+	{
+		advance();
+		identifier += current();
+	}
+	return identifier;
+}
+
+std::string TestFileParser::Scanner::scanDecimalNumber()
+{
+	std::string number;
+	number += current();
+	while (langutil::isDecimalDigit(peek()) || '.' == peek())
+	{
+		advance();
+		number += current();
+	}
+	return number;
+}
+
+std::string TestFileParser::Scanner::scanHexNumber()
+{
+	std::string number;
+	number += current();
+	while (langutil::isHexDigit(peek()))
+	{
+		advance();
+		number += current();
+	}
+	return number;
+}
+
+std::string TestFileParser::Scanner::scanString()
+{
+	std::string str;
+	advance();
+
+	while (current() != '\"')
+	{
+		if (current() == '\\')
+		{
+			advance();
+			switch (current())
+			{
+				case '\\':
+					str += current();
+					advance();
+					break;
+				case 'n':
+					str += '\n';
+					advance();
+					break;
+				case 'r':
+					str += '\r';
+					advance();
+					break;
+				case 't':
+					str += '\t';
+					advance();
+					break;
+				case '0':
+					str += '\0';
+					advance();
+					break;
+				case 'x':
+					str += scanHexPart();
+					break;
+				default:
+					BOOST_THROW_EXCEPTION(TestParserError("Invalid or escape sequence found in string literal."));
+			}
+		}
+		else
+		{
+			str += current();
+			advance();
+		}
+	}
+	return str;
+}
+
+// TODO: use fromHex() from CommonData
+char TestFileParser::Scanner::scanHexPart()
+{
+	auto toLower = [](char _c) -> char { return tolower(_c, std::locale::classic()); };
+
+	advance(); // skip 'x'
+
+	int value{};
+	if (isDigit(current()))
+		value = current() - '0';
+	else if (toLower(current()) >= 'a' && toLower(current()) <= 'f')
+		value = toLower(current()) - 'a' + 10;
+	else
+		BOOST_THROW_EXCEPTION(TestParserError("\\x used with no following hex digits."));
+
+	advance();
+	if (current() == '"')
+		return static_cast<char>(value);
+
+	value <<= 4;
+	if (isDigit(current()))
+		value |= current() - '0';
+	else if (toLower(current()) >= 'a' && toLower(current()) <= 'f')
+		value |= toLower(current()) - 'a' + 10;
+
+	advance();
+
+	return static_cast<char>(value);
+}
+
+bool TestFileParser::isBuiltinFunction(std::string const& _signature)
+{
+	return m_builtins.count(_signature) > 0;
+}
diff --git a/compiler/test/libsolidity/util/TestFileParserTests.cpp b/compiler/test/libsolidity/util/TestFileParserTests.cpp
new file mode 100644
index 00000000..59934fdb
--- /dev/null
+++ b/compiler/test/libsolidity/util/TestFileParserTests.cpp
@@ -0,0 +1,1068 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for Solidity's test expectation parser.
+ */
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <boost/test/unit_test.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <liblangutil/Exceptions.h>
+#include <test/ExecutionFramework.h>
+
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <test/libsolidity/util/TestFileParser.h>
+
+using namespace solidity::util;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+using fmt = ExecutionFramework;
+using Mode = FunctionCall::DisplayMode;
+
+namespace
+{
+
+std::vector<FunctionCall> parse(std::string const& _source, std::map<std::string, Builtin> const& _builtins = {})
+{
+	std::istringstream stream{_source, std::ios_base::out};
+	return TestFileParser{stream, _builtins}.parseFunctionCalls(0);
+}
+
+void testFunctionCall(
+		FunctionCall const& _call,
+		FunctionCall::DisplayMode _mode,
+		std::string _signature = "",
+		bool _failure = true,
+		bytes _arguments = bytes{},
+		bytes _expectations = bytes{},
+		FunctionValue _value = { 0 },
+		std::string _argumentComment = "",
+		std::string _expectationComment = "",
+		std::vector<std::string> _rawArguments = std::vector<std::string>{},
+		bool _isConstructor = false,
+		bool _isLibrary = false
+)
+{
+	BOOST_REQUIRE_EQUAL(_call.expectations.failure, _failure);
+	BOOST_REQUIRE_EQUAL(_call.signature, _signature);
+	ABI_CHECK(_call.arguments.rawBytes(), _arguments);
+	ABI_CHECK(_call.expectations.rawBytes(), _expectations);
+	BOOST_REQUIRE_EQUAL(_call.displayMode, _mode);
+	BOOST_REQUIRE_EQUAL(_call.value.value, _value.value);
+	BOOST_REQUIRE_EQUAL(static_cast<size_t>(_call.value.unit), static_cast<size_t>(_value.unit));
+	BOOST_REQUIRE_EQUAL(_call.arguments.comment, _argumentComment);
+	BOOST_REQUIRE_EQUAL(_call.expectations.comment, _expectationComment);
+
+	if (!_rawArguments.empty())
+	{
+		BOOST_REQUIRE_EQUAL(_call.arguments.parameters.size(), _rawArguments.size());
+		size_t index = 0;
+		for (Parameter const& param: _call.arguments.parameters)
+		{
+			BOOST_REQUIRE_EQUAL(param.rawString, _rawArguments[index]);
+			++index;
+		}
+	}
+
+	BOOST_REQUIRE_EQUAL(_call.kind == FunctionCall::Kind::Constructor, _isConstructor);
+	BOOST_REQUIRE_EQUAL(_call.kind == FunctionCall::Kind::Library, _isLibrary);
+}
+
+}
+
+BOOST_AUTO_TEST_SUITE(TestFileParserTest)
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	char const* source = R"()";
+	BOOST_REQUIRE_EQUAL(parse(source).size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(call_success)
+{
+	char const* source = R"(
+		// success() ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "success()", false);
+}
+
+BOOST_AUTO_TEST_CASE(non_existent_call_revert_single_line)
+{
+	char const* source = R"(
+		// i_am_not_there() -> FAILURE
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "i_am_not_there()", true);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_success)
+{
+	char const* source = R"(
+		// f(uint256): 1
+		// ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::MultiLine, "f(uint256)", false, fmt::encodeArgs(u256{1}));
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_comments_success)
+{
+	char const* source = R"(
+		// f(uint256, uint256): 1, 1
+		// # Comment on the parameters. #
+		// ->
+		// # This call should not return a value, but still succeed. #
+		// f()
+		// # Comment on no parameters. #
+		// -> 1
+		// # This comment should be parsed. #
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(uint256,uint256)",
+		false,
+		fmt::encodeArgs(1, 1),
+		fmt::encodeArgs(),
+		{0},
+		" Comment on the parameters. ",
+		" This call should not return a value, but still succeed. "
+	);
+	testFunctionCall(
+		calls.at(1),
+		Mode::MultiLine,
+		"f()",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeArgs(1),
+		{0},
+		" Comment on no parameters. ",
+		" This comment should be parsed. "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(simple_single_line_call_comment_success)
+{
+	char const* source = R"(
+		// f(uint256): 1 -> # f(uint256) does not return a value. #
+		// f(uint256): 1 -> 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(uint256)",
+		false,
+		fmt::encodeArgs(1),
+		fmt::encodeArgs(),
+		{0},
+		"",
+		" f(uint256) does not return a value. "
+	);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f(uint256)", false, fmt::encode(1), fmt::encode(1));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_single_line)
+{
+	char const* source = R"(
+		// f(uint256): 1 -> 1
+		// g(uint256): 1 ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(1), fmt::encodeArgs(1));
+	testFunctionCall(calls.at(1), Mode::SingleLine, "g(uint256)", false, fmt::encodeArgs(1));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_single_line_swapped)
+{
+	char const* source = R"(
+		// f(uint256): 1 ->
+		// g(uint256): 1 -> 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(1));
+	testFunctionCall(calls.at(1), Mode::SingleLine, "g(uint256)", false, fmt::encodeArgs(1), fmt::encodeArgs(1));
+
+}
+
+BOOST_AUTO_TEST_CASE(non_existent_call_revert)
+{
+	char const* source = R"(
+		// i_am_not_there()
+		// -> FAILURE
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::MultiLine, "i_am_not_there()", true);
+}
+
+BOOST_AUTO_TEST_CASE(call_revert_message)
+{
+	char const* source = R"(
+		// f() -> FAILURE, hex"08c379a0", 0x20, 6, "Revert"
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		true,
+		fmt::encodeArgs(),
+		fromHex("08c379a0") + fmt::encodeDyn(std::string{"Revert"})
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_expectations_empty_single_line)
+{
+	char const* source = R"(
+		// _exp_() ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "_exp_()", false);
+}
+
+BOOST_AUTO_TEST_CASE(call_expectations_empty_multiline)
+{
+	char const* source = R"(
+		// _exp_()
+		// ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::MultiLine, "_exp_()", false);
+}
+
+BOOST_AUTO_TEST_CASE(call_comments)
+{
+	char const* source = R"(
+		// f() # Parameter comment # -> 1 # Expectation comment #
+		// f() # Parameter comment #
+		// -> 1 # Expectation comment #
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeArgs(1),
+		{0},
+		" Parameter comment ",
+		" Expectation comment "
+	);
+	testFunctionCall(
+		calls.at(1),
+		Mode::MultiLine,
+		"f()",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeArgs(1),
+		{0},
+		" Parameter comment ",
+		" Expectation comment "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments)
+{
+	char const* source = R"(
+		// f(uint256), 314 wei: 5 # optional wei value #
+		// -> 4
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(uint256)",
+		false,
+		fmt::encodeArgs(5),
+		fmt::encodeArgs(4),
+		{314},
+		" optional wei value "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_ether)
+{
+	char const* source = R"(
+		// f(uint256), 1 ether: 5 # optional ether value #
+		// -> 4
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(uint256)",
+		false,
+		fmt::encodeArgs(5),
+		fmt::encodeArgs(4),
+		{exp256(u256(10), u256(18)) , FunctionValueUnit::Ether},
+		" optional ether value "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_bool)
+{
+	char const* source = R"(
+		// f(bool): true -> false
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(bool)",
+		false,
+		fmt::encodeArgs(true),
+		fmt::encodeArgs(false)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(scanner_hex_values)
+{
+	char const* source = R"(
+		// f(uint256): "\x20\x00\xFf" ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(std::string("\x20\x00\xff", 3)));
+}
+
+BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid1)
+{
+	char const* source = R"(
+		// f(uint256): "\x" ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid2)
+{
+	char const* source = R"(
+		// f(uint256): "\x1" ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256)", false, fmt::encodeArgs(std::string("\x1", 1)));
+}
+
+BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid3)
+{
+	char const* source = R"(
+		// f(uint256): "\xZ" ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(scanner_hex_values_invalid4)
+{
+	char const* source = R"(
+		// f(uint256): "\xZZ" ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_hex_string)
+{
+	char const* source = R"(
+		// f(bytes): hex"4200ef" -> hex"ab0023"
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(bytes)",
+		false,
+		fromHex("4200ef"),
+		fromHex("ab0023")
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_hex_string_lowercase)
+{
+	char const* source = R"(
+		// f(bytes): hex"4200ef" -> hex"23ef00"
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(bytes)",
+		false,
+		fromHex("4200EF"),
+		fromHex("23EF00")
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_string)
+{
+	char const* source = R"(
+		// f(string): 0x20, 3, "any" ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(string)",
+		false,
+		fmt::encodeDyn(std::string{"any"})
+	);
+}
+
+
+BOOST_AUTO_TEST_CASE(call_hex_number)
+{
+	char const* source = R"(
+		// f(bytes32, bytes32): 0x616, 0x1042 -> 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(bytes32,bytes32)",
+		false,
+		fmt::encodeArgs(
+			fromHex("0x616"),
+			fromHex("0x1042")
+		),
+		fmt::encodeArgs(1)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_return_string)
+{
+	char const* source = R"(
+		// f() -> 0x20, 3, "any"
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeDyn(std::string{"any"})
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple)
+{
+	char const* source = R"(
+		// f((uint256, bytes32), uint256) ->
+		// f((uint8), uint8) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f((uint256,bytes32),uint256)", false);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f((uint8),uint8)", false);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_left_aligned)
+{
+	char const* source = R"(
+		// f(bytes32, bytes32): 0x6161, 0x420000EF -> 1
+		// g(bytes32, bytes32): 0x0616, 0x0042EF00 -> 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(bytes32,bytes32)",
+		false,
+		fmt::encodeArgs(
+			fromHex("0x6161"),
+			fromHex("0x420000EF")
+		),
+		fmt::encodeArgs(1)
+	);
+	testFunctionCall(
+		calls.at(1),
+		Mode::SingleLine,
+		"g(bytes32,bytes32)",
+		false,
+		fmt::encodeArgs(
+			fromHex("0x0616"),
+			fromHex("0x0042EF00")
+		),
+		fmt::encodeArgs(1)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_of_tuples)
+{
+	char const* source = R"(
+		// f(((uint256, bytes32), bytes32), uint256)
+		// # f(S memory s, uint256 b) #
+		// ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(((uint256,bytes32),bytes32),uint256)",
+		false,
+		fmt::encodeArgs(),
+		fmt::encodeArgs(),
+		{0},
+		" f(S memory s, uint256 b) "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_recursive_tuples)
+{
+	char const* source = R"(
+		// f(((((bytes, bytes, bytes), bytes), bytes), bytes), bytes) ->
+		// f(((((bytes, bytes, (bytes)), bytes), bytes), (bytes, bytes)), (bytes, bytes)) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f(((((bytes,bytes,bytes),bytes),bytes),bytes),bytes)",
+		false
+	);
+	testFunctionCall(
+		calls.at(1),
+		Mode::SingleLine,
+		"f(((((bytes,bytes,(bytes)),bytes),bytes),(bytes,bytes)),(bytes,bytes))",
+		false
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_mismatch)
+{
+	char const* source = R"(
+		// f(uint256):
+		// 1, 2
+		// # This only throws at runtime #
+		// -> 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"f(uint256)",
+		false,
+		fmt::encodeArgs(1, 2),
+		fmt::encodeArgs(1),
+		{0},
+		" This only throws at runtime "
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_multiple_arguments)
+{
+	char const* source = R"(
+		// test(uint256, uint256):
+		// 1,
+		// 2
+		// -> 1,
+		// 1
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"test(uint256,uint256)",
+		false,
+		fmt::encodeArgs(1, 2),
+		fmt::encodeArgs(1, 1)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_multiple_arguments_mixed_format)
+{
+	char const* source = R"(
+		// test(uint256, uint256), 314 wei:
+		// 1, -2
+		// -> -1, 2
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::MultiLine,
+		"test(uint256,uint256)",
+		false,
+		fmt::encodeArgs(1, -2),
+		fmt::encodeArgs(-1, 2),
+		{314}
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_signature_array)
+{
+	char const* source = R"(
+		// f(uint256[]) ->
+		// f(uint256[3]) ->
+		// f(uint256[3][][], uint8[9]) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 3);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256[])", false);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f(uint256[3])", false);
+	testFunctionCall(calls.at(2), Mode::SingleLine, "f(uint256[3][][],uint8[9])", false);
+}
+
+BOOST_AUTO_TEST_CASE(call_signature_struct_array)
+{
+	char const* source = R"(
+		// f((uint256)[]) ->
+		// f((uint256)[3]) ->
+		// f((uint256, uint8)[3]) ->
+		// f((uint256)[3][][], (uint8, bool)[9]) ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 4);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f((uint256)[])", false);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f((uint256)[3])", false);
+	testFunctionCall(calls.at(2), Mode::SingleLine, "f((uint256,uint8)[3])", false);
+	testFunctionCall(calls.at(3), Mode::SingleLine, "f((uint256)[3][][],(uint8,bool)[9])", false);
+
+}
+
+BOOST_AUTO_TEST_CASE(call_signature_valid)
+{
+	char const* source = R"(
+		// f(uint256, uint8, string) -> FAILURE
+		// f(invalid, xyz, foo) -> FAILURE
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 2);
+	testFunctionCall(calls.at(0), Mode::SingleLine, "f(uint256,uint8,string)", true);
+	testFunctionCall(calls.at(1), Mode::SingleLine, "f(invalid,xyz,foo)", true);
+}
+
+BOOST_AUTO_TEST_CASE(call_raw_arguments)
+{
+	char const* source = R"(
+		// f(): 1, -2, -3 ->
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		false,
+		fmt::encodeArgs(1, -2, -3),
+		fmt::encodeArgs(),
+		{0},
+		"",
+		"",
+		{"1", "-2", "-3"}
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_builtin_left_decimal)
+{
+	char const* source = R"(
+		// f(): left(1), left(0x20) -> left(-2), left(true)
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		false,
+		fmt::encodeArgs(
+			fmt::encode(toCompactBigEndian(u256{1}), false),
+			fmt::encode(fromHex("0x20"), false)
+		),
+		fmt::encodeArgs(
+			fmt::encode(toCompactBigEndian(u256{-2}), false),
+			fmt::encode(bytes{true}, false)
+		)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_builtin_right_decimal)
+{
+	char const* source = R"(
+		// f(): right(1), right(0x20) -> right(-2), right(true)
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"f()",
+		false,
+		fmt::encodeArgs(1, fromHex("0x20")),
+		fmt::encodeArgs(-2, true)
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_hex_string_left_align)
+{
+	char const* source = R"(
+		// f(bytes): left(hex"4200ef") ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_hex_string_right_align)
+{
+	char const* source = R"(
+		// f(bytes): right(hex"4200ef") ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_newline_invalid)
+{
+	char const* source = R"(
+		/
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_invalid)
+{
+	char const* source = R"(
+		/ f() ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_signature_invalid)
+{
+	char const* source = R"(
+		// f(uint8,) -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid)
+{
+	char const* source = R"(
+		// f((uint8,) -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid_empty)
+{
+	char const* source = R"(
+		// f(uint8, ()) -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_tuple_invalid_parantheses)
+{
+	char const* source = R"(
+		// f((uint8,() -> FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_ether_value_expectations_missing)
+{
+	char const* source = R"(
+		// f(), 0)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_invalid)
+{
+	char const* source = R"(
+		// f(uint256): abc -> 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_invalid_decimal)
+{
+	char const* source = R"(
+		// sig(): 0.h3 ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_ether_value_invalid)
+{
+	char const* source = R"(
+		// f(uint256), abc : 1 -> 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_ether_value_invalid_decimal)
+{
+	char const* source = R"(
+		// sig(): 0.1hd ether ->
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_ether_type_invalid)
+{
+	char const* source = R"(
+		// f(uint256), 2 btc : 1 -> 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_signed_bool_invalid)
+{
+	char const* source = R"(
+		// f() -> -true
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_signed_failure_invalid)
+{
+	char const* source = R"(
+		// f() -> -FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_signed_hex_number_invalid)
+{
+	char const* source = R"(
+		// f() -> -0x42
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_colon)
+{
+	char const* source = R"(
+		// h256():
+		// -> 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arguments_newline_colon)
+{
+	char const* source = R"(
+		// h256()
+		// :
+		// -> 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_arrow_missing)
+{
+	char const* source = R"(
+		// h256() FAILURE
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(call_unexpected_character)
+{
+	char const* source = R"(
+		// f() -> ??
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(constructor)
+{
+	char const* source = R"(
+		// constructor()
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"constructor()",
+		false,
+		{},
+		{},
+		{0},
+		"",
+		"",
+		{},
+		true
+	);
+}
+
+BOOST_AUTO_TEST_CASE(library)
+{
+	char const* source = R"(
+		// library: L
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	testFunctionCall(
+		calls.at(0),
+		Mode::SingleLine,
+		"L",
+		false,
+		{},
+		{},
+		{0},
+		"",
+		"",
+		{},
+		false,
+		true
+	);
+}
+
+BOOST_AUTO_TEST_CASE(call_effects)
+{
+	std::map<std::string, Builtin> builtins;
+	builtins["builtin_returning_call_effect"] = [](FunctionCall const&) -> std::optional<bytes>
+	{
+		return toBigEndian(u256(0x1234));
+	};
+	builtins["builtin_returning_call_effect_no_ret"] = [](FunctionCall const&) -> std::optional<bytes>
+	{
+		return {};
+	};
+
+	char const* source = R"(
+		// builtin_returning_call_effect -> 1
+		// ~ bla
+		// ~ bla bla
+		// ~ bla bla bla
+	)";
+	std::vector<FunctionCall> calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 3);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[1]), "bla bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[2]), "bla bla bla");
+	source = R"(
+		// builtin_returning_call_effect -> 1
+		// ~ bla
+		// ~ bla bla
+		// builtin_returning_call_effect -> 2
+		// ~ bla bla bla
+		// builtin_returning_call_effect -> 3
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 3);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 2);
+	BOOST_REQUIRE_EQUAL(calls[1].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[2].expectedSideEffects.size(), 0);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[1]), "bla bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[1].expectedSideEffects[0]), "bla bla bla");
+	source = R"(
+		// builtin_returning_call_effect -> 1
+		// ~ bla
+		// ~ bla bla bla
+		// ~ abc ~ def ~ ghi
+		// ~ ~ ~
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 4);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[1]), "bla bla bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[2]), "abc ~ def ~ ghi");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[3]), "~ ~");
+	source = R"(
+		// builtin_returning_call_effect_no_ret ->
+		// ~ hello world
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "hello world");
+	source = R"(
+		// builtin_returning_call_effect -> 1
+		// ~
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "");
+	source = R"(
+		// builtin_returning_call_effect -> 1 # a comment #
+		// ~ hello world
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "hello world");
+	source = R"(
+		// builtin_returning_call_effect_no_ret -> # another comment #
+		// ~ hello world
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "hello world");
+	source = R"(
+		// builtin_returning_call_effect_no_ret # another comment #
+		// ~ hello world
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectedSideEffects.size(), 1);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].expectedSideEffects[0]), "hello world");
+	source = R"(
+		// builtin_returning_call_effect_no_ret # another comment #
+		// ~ hello/world
+	)";
+	BOOST_CHECK_THROW(parse(source, builtins), std::exception);
+	source = R"(
+		// builtin_returning_call_effect_no_ret # another comment #
+		// ~ hello//world
+	)";
+	BOOST_CHECK_THROW(parse(source, builtins), std::exception);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolidity/util/TestFunctionCall.cpp b/compiler/test/libsolidity/util/TestFunctionCall.cpp
new file mode 100644
index 00000000..64dfbd98
--- /dev/null
+++ b/compiler/test/libsolidity/util/TestFunctionCall.cpp
@@ -0,0 +1,377 @@
+/*
+	This file is part of solidity.
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/libsolidity/util/TestFunctionCall.h>
+
+#include <test/libsolidity/util/BytesUtils.h>
+#include <test/libsolidity/util/ContractABIUtils.h>
+
+#include <libsolutil/AnsiColorized.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend::test;
+
+using Token = soltest::Token;
+
+std::string TestFunctionCall::format(
+	ErrorReporter& _errorReporter,
+	std::string const& _linePrefix,
+	RenderMode _renderMode,
+	bool const _highlight,
+	bool const _interactivePrint
+) const
+{
+	std::stringstream stream;
+
+	bool highlight = !matchesExpectation() && _highlight;
+
+	auto formatOutput = [&](bool const _singleLine)
+	{
+		std::string ws = " ";
+		std::string arrow = formatToken(Token::Arrow);
+		std::string colon = formatToken(Token::Colon);
+		std::string comma = formatToken(Token::Comma);
+		std::string comment = formatToken(Token::Comment);
+		std::string ether = formatToken(Token::Ether);
+		std::string wei = formatToken(Token::Wei);
+		std::string newline = formatToken(Token::Newline);
+		std::string failure = formatToken(Token::Failure);
+
+		if (m_call.kind == FunctionCall::Kind::Library)
+		{
+			stream << _linePrefix << newline << ws << "library:" << ws;
+			if (!m_call.libraryFile.empty())
+				stream << "\"" << m_call.libraryFile << "\":";
+			stream << m_call.signature;
+			return;
+		}
+
+		/// Formats the function signature. This is the same independent from the display-mode.
+		stream << _linePrefix << newline << ws << m_call.signature;
+		if (m_call.value.value > u256(0))
+		{
+			switch (m_call.value.unit)
+			{
+			case FunctionValueUnit::Ether:
+				stream << comma << ws << (m_call.value.value / exp256(10, 18)) << ws << ether;
+				break;
+			case FunctionValueUnit::Wei:
+				stream << comma << ws << m_call.value.value << ws << wei;
+				break;
+			default:
+				soltestAssert(false, "");
+			}
+		}
+		if (!m_call.arguments.rawBytes().empty())
+		{
+			std::string output = formatRawParameters(m_call.arguments.parameters, _linePrefix);
+			stream << colon;
+			if (!m_call.arguments.parameters.at(0).format.newline)
+				stream << ws;
+			stream << output;
+		}
+
+		/// Formats comments on the function parameters and the arrow taking
+		/// the display-mode into account.
+		if (_singleLine)
+		{
+			if (!m_call.arguments.comment.empty())
+				stream << ws << comment << m_call.arguments.comment << comment;
+
+			if (m_call.omitsArrow)
+			{
+				if (_renderMode == RenderMode::ActualValuesExpectedGas && (m_failure || !matchesExpectation()))
+					stream << ws << arrow;
+			}
+			else
+				stream << ws << arrow;
+		}
+		else
+		{
+			stream << std::endl << _linePrefix << newline << ws;
+			if (!m_call.arguments.comment.empty())
+			{
+				 stream << comment << m_call.arguments.comment << comment;
+				 stream << std::endl << _linePrefix << newline << ws;
+			}
+			stream << arrow;
+		}
+
+		/// Format either the expected output or the actual result output
+		std::string result;
+		if (_renderMode != RenderMode::ActualValuesExpectedGas)
+		{
+			bool const isFailure = m_call.expectations.failure;
+			result = isFailure ?
+				formatFailure(_errorReporter, m_call, m_rawBytes, /* _renderResult */ false, highlight) :
+				formatRawParameters(m_call.expectations.result);
+			if (!result.empty())
+				AnsiColorized(stream, highlight, {util::formatting::RED_BACKGROUND}) << ws << result;
+		}
+		else
+		{
+			if (m_calledNonExistingFunction)
+				_errorReporter.warning("The function \"" + m_call.signature + "\" is not known to the compiler.");
+
+			bytes output = m_rawBytes;
+			bool const isFailure = m_failure;
+			result = isFailure ?
+				formatFailure(_errorReporter, m_call, output, _renderMode == RenderMode::ActualValuesExpectedGas, highlight) :
+				matchesExpectation() ?
+					formatRawParameters(m_call.expectations.result) :
+					formatBytesParameters(
+						_errorReporter,
+						output,
+						m_call.signature,
+						m_call.expectations.result,
+						highlight
+					);
+
+			if (!matchesExpectation())
+			{
+				std::optional<ParameterList> abiParams;
+
+				if (isFailure)
+				{
+					if (!output.empty())
+						abiParams = ContractABIUtils::failureParameters(output);
+				}
+				else
+					abiParams = ContractABIUtils::parametersFromJsonOutputs(
+						_errorReporter,
+						m_contractABI,
+						m_call.signature
+					);
+
+				std::string bytesOutput = abiParams ?
+					BytesUtils::formatRawBytes(output, abiParams.value(), _linePrefix) :
+					BytesUtils::formatRawBytes(
+						output,
+						ContractABIUtils::defaultParameters((output.size() + 31) / 32),
+						_linePrefix
+					);
+
+				_errorReporter.warning(
+					"The call to \"" + m_call.signature + "\" returned \n" +
+					bytesOutput
+				);
+			}
+
+			if (isFailure)
+				AnsiColorized(stream, highlight, {util::formatting::RED_BACKGROUND}) << ws << result;
+			else
+				if (!result.empty())
+					stream << ws << result;
+
+		}
+
+		/// Format comments on expectations taking the display-mode into account.
+		if (_singleLine)
+		{
+			if (!m_call.expectations.comment.empty())
+				stream << ws << comment << m_call.expectations.comment << comment;
+		}
+		else
+		{
+			if (!m_call.expectations.comment.empty())
+			{
+				stream << std::endl << _linePrefix << newline << ws;
+				stream << comment << m_call.expectations.comment << comment;
+			}
+		}
+
+		std::vector<std::string> sideEffects;
+		if (_renderMode == RenderMode::ExpectedValuesExpectedGas || _renderMode == RenderMode::ExpectedValuesActualGas)
+			sideEffects = m_call.expectedSideEffects;
+		else
+			sideEffects = m_call.actualSideEffects;
+
+		if (!sideEffects.empty())
+		{
+			stream << std::endl;
+			size_t i = 0;
+			for (; i < sideEffects.size() - 1; ++i)
+				stream << _linePrefix << "// ~ " << sideEffects[i] << std::endl;
+			stream << _linePrefix << "// ~ " << sideEffects[i];
+		}
+
+		stream << formatGasExpectations(_linePrefix, _renderMode == RenderMode::ExpectedValuesActualGas, _interactivePrint);
+	};
+
+	formatOutput(m_call.displayMode == FunctionCall::DisplayMode::SingleLine);
+	return stream.str();
+}
+
+std::string TestFunctionCall::formatBytesParameters(
+	ErrorReporter& _errorReporter,
+	bytes const& _bytes,
+	std::string const& _signature,
+	solidity::frontend::test::ParameterList const& _parameters,
+	bool _highlight,
+	bool _failure
+) const
+{
+	using ParameterList = solidity::frontend::test::ParameterList;
+
+	std::stringstream os;
+
+	if (_bytes.empty())
+		return {};
+
+	if (_failure)
+	{
+		os << BytesUtils::formatBytesRange(
+			_bytes,
+			ContractABIUtils::failureParameters(_bytes),
+			_highlight
+		);
+
+		return os.str();
+	}
+	else
+	{
+		std::optional<ParameterList> abiParams = ContractABIUtils::parametersFromJsonOutputs(
+			_errorReporter,
+			m_contractABI,
+			_signature
+		);
+
+		if (abiParams)
+		{
+			std::optional<ParameterList> preferredParams = ContractABIUtils::preferredParameters(
+				_errorReporter,
+				_parameters,
+				abiParams.value(),
+				_bytes
+			);
+
+			if (preferredParams)
+			{
+				ContractABIUtils::overwriteParameters(_errorReporter, preferredParams.value(), abiParams.value());
+				os << BytesUtils::formatBytesRange(_bytes, preferredParams.value(), _highlight);
+			}
+		}
+		else
+		{
+			ParameterList defaultParameters = ContractABIUtils::defaultParameters((_bytes.size() + 31) / 32);
+
+			ContractABIUtils::overwriteParameters(_errorReporter, defaultParameters, _parameters);
+			os << BytesUtils::formatBytesRange(_bytes, defaultParameters, _highlight);
+		}
+		return os.str();
+	}
+}
+
+std::string TestFunctionCall::formatFailure(
+	ErrorReporter& _errorReporter,
+	solidity::frontend::test::FunctionCall const& _call,
+	bytes const& _output,
+	bool _renderResult,
+	bool _highlight
+) const
+{
+	std::stringstream os;
+
+	os << formatToken(Token::Failure);
+
+	if (!_output.empty())
+		os << ", ";
+
+	if (_renderResult)
+		os << formatBytesParameters(
+			_errorReporter,
+			_output,
+			_call.signature,
+			_call.expectations.result,
+			_highlight,
+			true
+		);
+	else
+		os << formatRawParameters(_call.expectations.result);
+
+	return os.str();
+}
+
+std::string TestFunctionCall::formatRawParameters(
+	solidity::frontend::test::ParameterList const& _params,
+	std::string const& _linePrefix
+) const
+{
+	std::stringstream os;
+	for (auto const& param: _params)
+		if (!param.rawString.empty())
+		{
+			if (param.format.newline)
+				os << std::endl << _linePrefix << "// ";
+			for (auto const c: param.rawString)
+				// NOTE: Even though we have a toHex() overload specifically for uint8_t, the compiler
+				// chooses the one for bytes if the second argument is omitted.
+				os << (c >= ' ' ? std::string(1, c) : "\\x" + util::toHex(static_cast<uint8_t>(c), HexCase::Lower));
+			if (&param != &_params.back())
+				os << ", ";
+		}
+	return os.str();
+}
+
+std::string TestFunctionCall::formatGasExpectations(
+	std::string const& _linePrefix,
+	bool _useActualCost,
+	bool _showDifference
+) const
+{
+	std::stringstream os;
+	for (auto const& [runType, gasUsed]: (_useActualCost ? m_gasCosts : m_call.expectations.gasUsed))
+		if (!runType.empty())
+		{
+			bool differentResults =
+				m_gasCosts.count(runType) > 0 &&
+				m_call.expectations.gasUsed.count(runType) > 0 &&
+				m_gasCosts.at(runType) != m_call.expectations.gasUsed.at(runType);
+
+			s256 difference = 0;
+			if (differentResults)
+				difference =
+					static_cast<s256>(m_gasCosts.at(runType)) -
+					static_cast<s256>(m_call.expectations.gasUsed.at(runType));
+			int percent = 0;
+			if (differentResults)
+				percent = static_cast<int>(
+					100.0 * (static_cast<double>(difference) / static_cast<double>(m_call.expectations.gasUsed.at(runType)))
+				);
+			os << std::endl << _linePrefix << "// gas " << runType << ": " << (gasUsed.str());
+			if (_showDifference && differentResults && _useActualCost)
+				os << " [" << std::showpos << difference << " (" << percent << "%)]";
+		}
+	return os.str();
+}
+
+void TestFunctionCall::reset()
+{
+	m_rawBytes = bytes{};
+	m_failure = true;
+	m_contractABI = Json::Value{};
+	m_calledNonExistingFunction = false;
+}
+
+bool TestFunctionCall::matchesExpectation() const
+{
+	return m_failure == m_call.expectations.failure && m_rawBytes == m_call.expectations.rawBytes();
+}
diff --git a/compiler/test/libsolidity/util/TestFunctionCallTests.cpp b/compiler/test/libsolidity/util/TestFunctionCallTests.cpp
new file mode 100644
index 00000000..fa3fe995
--- /dev/null
+++ b/compiler/test/libsolidity/util/TestFunctionCallTests.cpp
@@ -0,0 +1,255 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <boost/test/unit_test.hpp>
+#include <liblangutil/Exceptions.h>
+#include <test/ExecutionFramework.h>
+
+#include <test/libsolidity/util/TestFunctionCall.h>
+
+using namespace solidity::util;
+using namespace solidity::test;
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(TestFunctionCallTest)
+
+BOOST_AUTO_TEST_CASE(format_unsigned_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(uint8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(uint8): 1 -> 1");
+
+	test.setRawBytes(toBigEndian(u256{2}));
+	test.setFailure(false);
+
+	BOOST_REQUIRE_EQUAL(test.format("", TestFunctionCall::RenderMode::ActualValuesExpectedGas), "// f(uint8): 1 -> 2");
+}
+
+BOOST_AUTO_TEST_CASE(format_unsigned_singleline_signed_encoding)
+{
+	bytes expectedBytes = toBigEndian(u256{1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(uint8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(uint8): 1 -> 1");
+
+	test.setRawBytes(toBigEndian(u256{-1}));
+	test.setFailure(false);
+
+	BOOST_REQUIRE_EQUAL(test.format("", TestFunctionCall::RenderMode::ActualValuesExpectedGas), "// f(uint8): 1 -> -1");
+}
+
+BOOST_AUTO_TEST_CASE(format_unsigned_multiline)
+{
+	bytes expectedBytes = toBigEndian(u256{1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter result{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{result}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{}, std::string{}};
+	FunctionCall call{"f(uint8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	call.displayMode = FunctionCall::DisplayMode::MultiLine;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(),	"// f(uint8)\n// -> 1");
+}
+
+BOOST_AUTO_TEST_CASE(format_multiple_unsigned_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param, param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param, param}, std::string{}};
+	FunctionCall call{"f(uint8, uint8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(uint8, uint8): 1, 1 -> 1, 1");
+}
+
+BOOST_AUTO_TEST_CASE(format_signed_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{-1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "-1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(int8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(int8): -1 -> -1");
+
+	test.setRawBytes(toBigEndian(u256{-2}));
+	test.setFailure(false);
+
+	BOOST_REQUIRE_EQUAL(test.format("", TestFunctionCall::RenderMode::ActualValuesExpectedGas), "// f(int8): -1 -> -2");
+}
+
+BOOST_AUTO_TEST_CASE(format_hex_singleline)
+{
+	bytes result = fromHex("0x31");
+	bytes expectedBytes = result + bytes(32 - result.size(), 0);
+	ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "0x31", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(bytes32)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(bytes32): 0x31 -> 0x31");
+
+	bytes actualResult = fromHex("0x32");
+	bytes actualBytes = bytes(32 - actualResult.size(), 0) + actualResult;
+
+	test.setRawBytes(actualBytes);
+	test.setFailure(false);
+
+	BOOST_REQUIRE_EQUAL(test.format("", TestFunctionCall::RenderMode::ActualValuesExpectedGas), "// f(bytes32): 0x31 -> 0x32");
+}
+
+BOOST_AUTO_TEST_CASE(format_hex_string_singleline)
+{
+	bytes expectedBytes = fromHex("4200ef");
+	ABIType abiType{ABIType::HexString, ABIType::AlignLeft, 3};
+	Parameter param{expectedBytes, "hex\"4200ef\"", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(string)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(string): hex\"4200ef\" -> hex\"4200ef\"");
+}
+
+BOOST_AUTO_TEST_CASE(format_bool_true_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{true});
+	ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "true", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(bool)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(bool): true -> true");
+
+	bytes actualResult = bytes{false};
+	bytes actualBytes = actualResult + bytes(32 - actualResult.size(), 0);
+	test.setRawBytes(actualBytes);
+	test.setFailure(false);
+
+	BOOST_REQUIRE_EQUAL(test.format("", TestFunctionCall::RenderMode::ActualValuesExpectedGas), "// f(bool): true -> false");
+}
+
+BOOST_AUTO_TEST_CASE(format_bool_false_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{false});
+	ABIType abiType{ABIType::Boolean, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "false", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(bool)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(bool): false -> false");
+}
+
+BOOST_AUTO_TEST_CASE(format_bool_left_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{false});
+	ABIType abiType{ABIType::Boolean, ABIType::AlignLeft, 32};
+	Parameter param{expectedBytes, "left(false)", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(bool)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(bool): left(false) -> left(false)");
+}
+
+BOOST_AUTO_TEST_CASE(format_hex_number_right_singleline)
+{
+	bytes result = fromHex("0x42");
+	bytes expectedBytes = result + bytes(32 - result.size(), 0);
+	ABIType abiType{ABIType::Hex, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "right(0x42)", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(bool)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(bool): right(0x42) -> right(0x42)");
+}
+
+BOOST_AUTO_TEST_CASE(format_empty_byte_range)
+{
+	bytes expectedBytes;
+	ABIType abiType{ABIType::None, ABIType::AlignNone, 0};
+	Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{param}, false, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{}, std::string{}};
+	FunctionCall call{"f()", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f() -> 1");
+}
+
+BOOST_AUTO_TEST_CASE(format_failure_singleline)
+{
+	bytes expectedBytes = toBigEndian(u256{1});
+	ABIType abiType{ABIType::UnsignedDec, ABIType::AlignRight, 32};
+	Parameter param{expectedBytes, "1", abiType, FormatInfo{}};
+	FunctionCallExpectations expectations{std::vector<Parameter>{}, true, std::string{}, {}};
+	FunctionCallArgs arguments{std::vector<Parameter>{param}, std::string{}};
+	FunctionCall call{"f(uint8)", {0}, arguments, expectations};
+	call.omitsArrow = false;
+	TestFunctionCall test{call};
+
+	BOOST_REQUIRE_EQUAL(test.format(), "// f(uint8): 1 -> FAILURE");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/Checksum.cpp b/compiler/test/libsolutil/Checksum.cpp
new file mode 100644
index 00000000..c9987a8b
--- /dev/null
+++ b/compiler/test/libsolutil/Checksum.cpp
@@ -0,0 +1,115 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the address checksum.
+ */
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/Exceptions.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(Checksum)
+
+BOOST_AUTO_TEST_CASE(calculate)
+{
+	BOOST_CHECK(!getChecksummedAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed").empty());
+	BOOST_CHECK(!getChecksummedAddress("0x0123456789abcdefABCDEF0123456789abcdefAB").empty());
+	// too short
+	BOOST_CHECK_THROW(getChecksummedAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beae"), InvalidAddress);
+	BOOST_CHECK_THROW(getChecksummedAddress("5aaeb6053f3e94c9b9a09f33669435e7ef1beae"), InvalidAddress);
+	// too long
+	BOOST_CHECK_THROW(getChecksummedAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed1"), InvalidAddress);
+	BOOST_CHECK_THROW(getChecksummedAddress("5aaeb6053f3e94c9b9a09f33669435e7ef1beaed1"), InvalidAddress);
+	// non-hex character
+	BOOST_CHECK_THROW(getChecksummedAddress("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaeK"), InvalidAddress);
+
+	// the official test suite from EIP-55
+	std::vector<std::string> cases {
+		// all upper case
+		"0x52908400098527886E0F7030069857D2E4169EE7",
+		"0x8617E340B3D01FA5F11F306F4090FD50E238070D",
+		// all lower case
+		"0xde709f2102306220921060314715629080e2fb77",
+		"0x27b1fdb04752bbc536007a920d24acb045561c26",
+		// regular
+		"0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
+		"0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359",
+		"0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB",
+		"0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"
+	};
+
+	for (size_t i = 0; i < cases.size(); i++)
+		BOOST_REQUIRE_MESSAGE(getChecksummedAddress(cases[i]) == cases[i], cases[i]);
+}
+
+BOOST_AUTO_TEST_CASE(regular)
+{
+	BOOST_CHECK(passesAddressChecksum("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", true));
+	BOOST_CHECK(passesAddressChecksum("0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359", true));
+	BOOST_CHECK(passesAddressChecksum("0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB", true));
+	BOOST_CHECK(passesAddressChecksum("0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb", true));
+}
+
+BOOST_AUTO_TEST_CASE(regular_negative)
+{
+	BOOST_CHECK(!passesAddressChecksum("0x6aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", true));
+	BOOST_CHECK(!passesAddressChecksum("0xeB6916095ca1df60bB79Ce92cE3Ea74c37c5d359", true));
+	BOOST_CHECK(!passesAddressChecksum("0xebF03B407c01E7cD3CBea99509d93f8DDDC8C6FB", true));
+	BOOST_CHECK(!passesAddressChecksum("0xE1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb", true));
+}
+
+BOOST_AUTO_TEST_CASE(regular_invalid_length)
+{
+	BOOST_CHECK(passesAddressChecksum("0x9426cbfc57389778d313268E7F85F1CDc2fdad60", true));
+	BOOST_CHECK(!passesAddressChecksum("0x9426cbfc57389778d313268E7F85F1CDc2fdad6", true));
+	BOOST_CHECK(passesAddressChecksum("0x08A61851FFa4637dE289D630Ae8c5dFb0ff9171F", true));
+	BOOST_CHECK(!passesAddressChecksum("0x8A61851FFa4637dE289D630Ae8c5dFb0ff9171F", true));
+	BOOST_CHECK(passesAddressChecksum("0x00c40cC30cb4675673c9ee382de805c19734986A", true));
+	BOOST_CHECK(!passesAddressChecksum("0xc40cC30cb4675673c9ee382de805c19734986A", true));
+	BOOST_CHECK(passesAddressChecksum("0xC40CC30cb4675673C9ee382dE805c19734986a00", true));
+	BOOST_CHECK(!passesAddressChecksum("0xC40CC30cb4675673C9ee382dE805c19734986a", true));
+}
+
+BOOST_AUTO_TEST_CASE(homocaps_valid)
+{
+	BOOST_CHECK(passesAddressChecksum("0x52908400098527886E0F7030069857D2E4169EE7", true));
+	BOOST_CHECK(passesAddressChecksum("0x8617E340B3D01FA5F11F306F4090FD50E238070D", true));
+	BOOST_CHECK(passesAddressChecksum("0xde709f2102306220921060314715629080e2fb77", true));
+	BOOST_CHECK(passesAddressChecksum("0x27b1fdb04752bbc536007a920d24acb045561c26", true));
+}
+
+BOOST_AUTO_TEST_CASE(homocaps_invalid)
+{
+	std::string upper = "0x00AA0000000012400000000DDEEFF000000000BB";
+	BOOST_CHECK(passesAddressChecksum(upper, false));
+	BOOST_CHECK(!passesAddressChecksum(upper, true));
+	std::string lower = "0x11aa000000000000000d00cc00000000000000bb";
+	BOOST_CHECK(passesAddressChecksum(lower, false));
+	BOOST_CHECK(!passesAddressChecksum(lower, true));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/CommonData.cpp b/compiler/test/libsolutil/CommonData.cpp
new file mode 100644
index 00000000..b4b0351b
--- /dev/null
+++ b/compiler/test/libsolutil/CommonData.cpp
@@ -0,0 +1,142 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the CommonData routines.
+ */
+
+#include <libsolutil/Common.h>
+#include <libsolutil/CommonData.h>
+#include <libsolutil/FixedHash.h>
+#include <libsolidity/ast/Types.h> // for IntegerType
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::frontend;
+
+// TODO: Fix Boost...
+BOOST_TEST_DONT_PRINT_LOG_VALUE(solidity::bytes)
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(CommonData)
+
+BOOST_AUTO_TEST_CASE(fromhex_char)
+{
+	BOOST_CHECK_EQUAL(fromHex('0', WhenError::DontThrow), 0x0);
+	BOOST_CHECK_EQUAL(fromHex('a', WhenError::DontThrow), 0xa);
+	BOOST_CHECK_EQUAL(fromHex('x', WhenError::DontThrow), -1);
+	BOOST_CHECK_EQUAL(fromHex('x', static_cast<WhenError>(42)), -1);
+
+	BOOST_CHECK_EQUAL(fromHex('0', WhenError::Throw), 0x0);
+	BOOST_CHECK_EQUAL(fromHex('a', WhenError::Throw), 0xa);
+	BOOST_CHECK_THROW(fromHex('x', WhenError::Throw), BadHexCharacter);
+}
+
+BOOST_AUTO_TEST_CASE(fromhex_string)
+{
+	bytes expectation_even = {{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}};
+	bytes expectation_odd = {{0x00, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0}};
+
+	// Defaults to WhenError::DontThrow
+	BOOST_CHECK_EQUAL(fromHex(""), bytes());
+	BOOST_CHECK_EQUAL(fromHex("00112233445566778899aabbccddeeff"), expectation_even);
+	BOOST_CHECK_EQUAL(fromHex("0x00112233445566778899aabbccddeeff"), expectation_even);
+	BOOST_CHECK_EQUAL(fromHex("0x00112233445566778899aabbccddeeff0"), expectation_odd);
+	BOOST_CHECK_EQUAL(fromHex("gg"), bytes());
+	BOOST_CHECK_EQUAL(fromHex("0xgg"), bytes());
+
+	BOOST_CHECK_EQUAL(fromHex("", WhenError::Throw), bytes());
+	BOOST_CHECK_EQUAL(fromHex("00112233445566778899aabbccddeeff", WhenError::Throw), expectation_even);
+	BOOST_CHECK_EQUAL(fromHex("0x00112233445566778899aabbccddeeff", WhenError::Throw), expectation_even);
+	BOOST_CHECK_EQUAL(fromHex("0x00112233445566778899aabbccddeeff0", WhenError::Throw), expectation_odd);
+	BOOST_CHECK_THROW(fromHex("gg", WhenError::Throw), BadHexCharacter);
+	BOOST_CHECK_THROW(fromHex("0xgg", WhenError::Throw), BadHexCharacter);
+}
+
+BOOST_AUTO_TEST_CASE(tohex_uint8)
+{
+	BOOST_CHECK_EQUAL(toHex(0xaa), "aa");
+	BOOST_CHECK_EQUAL(toHex(0xaa, HexCase::Lower), "aa");
+	BOOST_CHECK_EQUAL(toHex(0xaa, HexCase::Upper), "AA");
+	BOOST_CHECK_THROW(toHex(0xaa, HexCase::Mixed), BadHexCase);
+	// Defaults to lower case on invalid setting.
+	BOOST_CHECK_EQUAL(toHex(0xaa, static_cast<HexCase>(42)), "aa");
+}
+
+BOOST_AUTO_TEST_CASE(tohex_bytes)
+{
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::DontAdd, HexCase::Lower), "00112233445566778899aabbccddeeff");
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::DontAdd, HexCase::Upper), "00112233445566778899AABBCCDDEEFF");
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::DontAdd, HexCase::Mixed), "00112233445566778899aabbCCDDeeff");
+	// Defaults to lower case on invalid setting.
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::DontAdd, static_cast<HexCase>(42)), "00112233445566778899aabbccddeeff");
+
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::Add, HexCase::Lower), "0x00112233445566778899aabbccddeeff");
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::Add, HexCase::Upper), "0x00112233445566778899AABBCCDDEEFF");
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899AaBbCcDdEeFf"), HexPrefix::Add, HexCase::Mixed), "0x00112233445566778899aabbCCDDeeff");
+	// Defaults to lower case on invalid setting.
+	BOOST_CHECK_EQUAL(toHex(fromHex("00112233445566778899aAbBcCdDeEfF"), HexPrefix::Add, static_cast<HexCase>(42)), "0x00112233445566778899aabbccddeeff");
+}
+
+BOOST_AUTO_TEST_CASE(test_format_number)
+{
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x8000000)), "0x08000000");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x80000000)), "0x80000000");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x800000000)), "0x0800000000");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x8000000000)), "0x8000000000");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x80000000000)), "0x080000000000");
+
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x7ffffff)), "0x07ffffff");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x7fffffff)), "0x7fffffff");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x7ffffffff)), "0x07ffffffff");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x7fffffffff)), "0x7fffffffff");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x7ffffffffff)), "0x07ffffffffff");
+
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x88000000)), "0x88000000");
+	BOOST_CHECK_EQUAL(formatNumber(u256(0x8888888888000000)), "0x8888888888000000");
+
+	u256 b = 0;
+	for (int i = 0; i < 32; i++)
+	{
+		b <<= 8;
+		b |= 0x55;
+	}
+	u256 c = u256(FixedHash<32>(
+		fromHex("0xabcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789")
+	));
+	u256 d = u256(0xAAAAaaaaAAAAaaaa) << 192 |
+		u256(0xFFFFffffFFFFffff) << 128 |
+		u256(0xFFFFffffFFFFffff) << 64 |
+		u256(0xFFFFffffFFFFffff);
+	BOOST_CHECK_EQUAL(formatNumber(b), "0x5555555555555555555555555555555555555555555555555555555555555555");
+	BOOST_CHECK_EQUAL(formatNumber(c), "0xabcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789");
+	BOOST_CHECK_EQUAL(formatNumber(d), "0xaaaaaaaaaaaaaaaaffffffffffffffffffffffffffffffffffffffffffffffff");
+
+	BOOST_CHECK_EQUAL(formatNumber(IntegerType(256).minValue()), "0");
+	BOOST_CHECK_EQUAL(
+		formatNumber(IntegerType(256).maxValue()),
+		"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+	);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/CommonIO.cpp b/compiler/test/libsolutil/CommonIO.cpp
new file mode 100644
index 00000000..d31c9a56
--- /dev/null
+++ b/compiler/test/libsolutil/CommonIO.cpp
@@ -0,0 +1,103 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for the CommonIO routines.
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <test/Common.h>
+#include <test/FilesystemUtils.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/filesystem.hpp>
+
+#include <fstream>
+#include <string>
+
+using namespace solidity::test;
+
+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(CommonIOTest)
+
+BOOST_AUTO_TEST_CASE(readFileAsString_regular_file)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");
+
+	BOOST_TEST(readFileAsString(tempDir.path() / "test.txt") == "ABC\ndef\n");
+}
+
+BOOST_AUTO_TEST_CASE(readFileAsString_directory)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	BOOST_CHECK_THROW(readFileAsString(tempDir), NotAFile);
+}
+
+BOOST_AUTO_TEST_CASE(readFileAsString_symlink)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	createFileWithContent(tempDir.path() / "test.txt", "ABC\ndef\n");
+
+	if (!createSymlinkIfSupportedByFilesystem("test.txt", tempDir.path() / "symlink.txt", false))
+		return;
+
+	BOOST_TEST(readFileAsString(tempDir.path() / "symlink.txt") == "ABC\ndef\n");
+}
+
+BOOST_AUTO_TEST_CASE(readUntilEnd_no_ending_newline)
+{
+	std::istringstream inputStream("ABC\ndef");
+	BOOST_TEST(readUntilEnd(inputStream) == "ABC\ndef");
+}
+
+BOOST_AUTO_TEST_CASE(readUntilEnd_with_ending_newline)
+{
+	std::istringstream inputStream("ABC\ndef\n");
+	BOOST_TEST(readUntilEnd(inputStream) == "ABC\ndef\n");
+}
+
+BOOST_AUTO_TEST_CASE(readUntilEnd_cr_lf_newline)
+{
+	std::istringstream inputStream("ABC\r\ndef");
+	BOOST_TEST(readUntilEnd(inputStream) == "ABC\r\ndef");
+}
+
+BOOST_AUTO_TEST_CASE(readUntilEnd_empty)
+{
+	std::istringstream inputStream("");
+	BOOST_TEST(readUntilEnd(inputStream) == "");
+}
+
+BOOST_AUTO_TEST_CASE(readBytes_past_end)
+{
+	std::istringstream inputStream("abc");
+	BOOST_CHECK_EQUAL(readBytes(inputStream, 0), "");
+	BOOST_CHECK_EQUAL(readBytes(inputStream, 1), "a");
+	BOOST_CHECK_EQUAL(readBytes(inputStream, 20), "bc");
+	BOOST_CHECK_EQUAL(readBytes(inputStream, 20), "");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::util::test
diff --git a/compiler/test/libsolutil/FixedHash.cpp b/compiler/test/libsolutil/FixedHash.cpp
new file mode 100644
index 00000000..3b20a505
--- /dev/null
+++ b/compiler/test/libsolutil/FixedHash.cpp
@@ -0,0 +1,263 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for FixedHash.
+ */
+
+#include <libsolutil/FixedHash.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <cstdint>
+#include <sstream>
+
+
+namespace solidity::util::test
+{
+
+static_assert(std::is_same<h160, FixedHash<20>>());
+static_assert(std::is_same<h256, FixedHash<32>>());
+
+BOOST_AUTO_TEST_SUITE(FixedHashTest)
+
+BOOST_AUTO_TEST_CASE(default_constructor)
+{
+	BOOST_CHECK_EQUAL(
+		FixedHash<1>{}.hex(),
+		"00"
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<1>{}.size,
+		1
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<8>{}.hex(),
+		"0000000000000000"
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<8>{}.size,
+		8
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<20>{}.hex(),
+		"0000000000000000000000000000000000000000"
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<20>{}.size,
+		20
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<32>{}.hex(),
+		"0000000000000000000000000000000000000000000000000000000000000000"
+	);
+	BOOST_CHECK_EQUAL(
+		FixedHash<32>{}.size,
+		32
+	);
+}
+
+BOOST_AUTO_TEST_CASE(bytes_constructor)
+{
+	FixedHash<8> a(bytes{});
+	BOOST_CHECK_EQUAL(a.size, 8);
+	BOOST_CHECK_EQUAL(a.hex(), "0000000000000000");
+
+	FixedHash<8> b(bytes{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88});
+	BOOST_CHECK_EQUAL(b.size, 8);
+	BOOST_CHECK_EQUAL(b.hex(), "1122334455667788");
+
+	// TODO: short input, this should fail
+	FixedHash<8> c(bytes{0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
+	BOOST_CHECK_EQUAL(c.size, 8);
+	BOOST_CHECK_EQUAL(c.hex(), "0000000000000000");
+
+	// TODO: oversized input, this should fail
+	FixedHash<8> d(bytes{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99});
+	BOOST_CHECK_EQUAL(d.size, 8);
+	BOOST_CHECK_EQUAL(d.hex(), "0000000000000000");
+}
+
+// TODO: add FixedHash(bytesConstRef) constructor
+
+BOOST_AUTO_TEST_CASE(string_constructor_fromhex)
+{
+	// TODO: this tests the default settings ConstructFromStringType::fromHex, ConstructFromHashType::FailIfDifferent
+	//       should test other options too
+
+	FixedHash<8> a("");
+	BOOST_CHECK_EQUAL(a.size, 8);
+	BOOST_CHECK_EQUAL(a.hex(), "0000000000000000");
+
+	FixedHash<8> b("1122334455667788");
+	BOOST_CHECK_EQUAL(b.size, 8);
+	BOOST_CHECK_EQUAL(b.hex(), "1122334455667788");
+
+	FixedHash<8> c("0x1122334455667788");
+	BOOST_CHECK_EQUAL(c.size, 8);
+	BOOST_CHECK_EQUAL(c.hex(), "1122334455667788");
+
+	// TODO: short input, this should fail
+	FixedHash<8> d("112233445566");
+	BOOST_CHECK_EQUAL(d.size, 8);
+	BOOST_CHECK_EQUAL(d.hex(), "0000000000000000");
+
+	// TODO: oversized input, this should fail
+	FixedHash<8> e("112233445566778899");
+	BOOST_CHECK_EQUAL(e.size, 8);
+	BOOST_CHECK_EQUAL(e.hex(), "0000000000000000");
+}
+
+BOOST_AUTO_TEST_CASE(string_constructor_frombytes)
+{
+
+	FixedHash<8> b("", FixedHash<8>::FromBinary);
+	BOOST_CHECK_EQUAL(b.size, 8);
+	BOOST_CHECK_EQUAL(b.hex(), "0000000000000000");
+
+	FixedHash<8> c("abcdefgh", FixedHash<8>::FromBinary);
+	BOOST_CHECK_EQUAL(c.size, 8);
+	BOOST_CHECK_EQUAL(c.hex(), "6162636465666768");
+
+	// TODO: short input, this should fail
+	FixedHash<8> d("abcdefg", FixedHash<8>::FromBinary);
+	BOOST_CHECK_EQUAL(d.size, 8);
+	BOOST_CHECK_EQUAL(d.hex(), "0000000000000000");
+
+	// TODO: oversized input, this should fail
+	FixedHash<8> e("abcdefghi", FixedHash<8>::FromBinary);
+	BOOST_CHECK_EQUAL(e.size, 8);
+	BOOST_CHECK_EQUAL(e.hex(), "0000000000000000");
+}
+
+BOOST_AUTO_TEST_CASE(converting_constructor)
+{
+	// Left-aligned truncation
+	FixedHash<8> a = FixedHash<8>(FixedHash<12>("112233445566778899001122"), FixedHash<8>::AlignLeft);
+	BOOST_CHECK_EQUAL(a.size, 8);
+	BOOST_CHECK_EQUAL(a.hex(), "1122334455667788");
+
+	// Right-aligned truncation
+	FixedHash<8> b = FixedHash<8>(FixedHash<12>("112233445566778899001122"), FixedHash<8>::AlignRight);
+	BOOST_CHECK_EQUAL(b.size, 8);
+	BOOST_CHECK_EQUAL(b.hex(), "5566778899001122");
+
+	// Left-aligned extension
+	FixedHash<12> c = FixedHash<12>(FixedHash<8>("1122334455667788"), FixedHash<12>::AlignLeft);
+	BOOST_CHECK_EQUAL(c.size, 12);
+	BOOST_CHECK_EQUAL(c.hex(), "112233445566778800000000");
+
+	// Right-aligned extension
+	FixedHash<12> d = FixedHash<12>(FixedHash<8>("1122334455667788"), FixedHash<12>::AlignRight);
+	BOOST_CHECK_EQUAL(d.size, 12);
+	BOOST_CHECK_EQUAL(d.hex(), "000000001122334455667788");
+
+	// FailIfDifferent setting
+	// TODO: Shouldn't this throw?
+	FixedHash<12> e = FixedHash<12>(FixedHash<8>("1122334455667788"), FixedHash<12>::FailIfDifferent);
+	BOOST_CHECK_EQUAL(e, c);
+}
+
+BOOST_AUTO_TEST_CASE(arith_constructor)
+{
+	FixedHash<32> b(u256(0x12340000));
+	BOOST_CHECK_EQUAL(
+		b.hex(),
+		"0000000000000000000000000000000000000000000000000000000012340000"
+	);
+
+	// NOTE: size-mismatched constructor is not available
+}
+
+BOOST_AUTO_TEST_CASE(to_arith)
+{
+	FixedHash<32> b("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+	BOOST_CHECK_EQUAL(u256(b), u256("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
+}
+
+BOOST_AUTO_TEST_CASE(comparison)
+{
+	FixedHash<32> a("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+	FixedHash<32> b("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+	FixedHash<32> c("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a471");
+	FixedHash<32> d("233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470c5d2460186f7");
+
+	BOOST_CHECK(a == a);
+	BOOST_CHECK(b == b);
+	BOOST_CHECK(a == b);
+	BOOST_CHECK(b == a);
+	BOOST_CHECK(a != c);
+	BOOST_CHECK(c != a);
+	BOOST_CHECK(a != d);
+	BOOST_CHECK(d != a);
+
+	// Only equal size comparison is supported.
+	BOOST_CHECK(FixedHash<8>{} == FixedHash<8>{});
+	BOOST_CHECK(FixedHash<32>{} != b);
+
+	// Only equal size less than comparison is supported.
+	BOOST_CHECK(!(a < b));
+	BOOST_CHECK(d < c);
+	BOOST_CHECK(FixedHash<32>{} < a);
+}
+
+BOOST_AUTO_TEST_CASE(indexing)
+{
+	// NOTE: uses std::array, so "Accessing a nonexistent element through this operator is undefined behavior."
+
+	FixedHash<32> a("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+	BOOST_CHECK_EQUAL(a[0], 0xc5);
+	BOOST_CHECK_EQUAL(a[1], 0xd2);
+	BOOST_CHECK_EQUAL(a[31], 0x70);
+	a[0] = 0xff;
+	a[31] = 0x54;
+	BOOST_CHECK_EQUAL(a[0], 0xff);
+	BOOST_CHECK_EQUAL(a[1], 0xd2);
+	BOOST_CHECK_EQUAL(a[31], 0x54);
+}
+
+BOOST_AUTO_TEST_CASE(misc)
+{
+	FixedHash<32> a("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+
+	uint8_t* mut_a = a.data();
+	uint8_t const* const_a = a.data();
+	BOOST_CHECK_EQUAL(mut_a, const_a);
+	BOOST_CHECK_EQUAL(memcmp(mut_a, const_a, a.size), 0);
+
+	bytes bytes_a = a.asBytes();
+	bytesRef bytesref_a = a.ref();
+	bytesConstRef bytesconstref_a = a.ref();
+
+	// There's no printing for bytesRef/bytesConstRef
+	BOOST_CHECK(bytes(a.data(), a.data() + a.size) == bytes_a);
+	BOOST_CHECK(bytesRef(a.data(), a.size) == bytesref_a);
+	BOOST_CHECK(bytesConstRef(a.data(), a.size) == bytesconstref_a);
+}
+
+BOOST_AUTO_TEST_CASE(tostream)
+{
+	std::ostringstream out;
+	out << FixedHash<4>("44114411");
+	out << FixedHash<32>{};
+	out << FixedHash<2>("f77f");
+	out << FixedHash<1>("1");
+	BOOST_CHECK_EQUAL(out.str(), "441144110000000000000000000000000000000000000000000000000000000000000000f77f01");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/FunctionSelector.cpp b/compiler/test/libsolutil/FunctionSelector.cpp
new file mode 100644
index 00000000..e8080df4
--- /dev/null
+++ b/compiler/test/libsolutil/FunctionSelector.cpp
@@ -0,0 +1,52 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for FunctionSelector.
+ */
+
+#include <libsolutil/FunctionSelector.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <cstdint>
+#include <sstream>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(FunctionSelectorTest)
+
+BOOST_AUTO_TEST_CASE(conversions)
+{
+	BOOST_CHECK_EQUAL(
+		util::selectorFromSignatureH32("test()"),
+		util::FixedHash<4>(0xf8a8fd6d)
+	);
+	BOOST_CHECK_EQUAL(
+		util::selectorFromSignatureU32("test()"),
+		0xf8a8fd6d
+	);
+	BOOST_CHECK_EQUAL(
+		util::selectorFromSignatureU256("test()"),
+		u256("0xf8a8fd6d00000000000000000000000000000000000000000000000000000000")
+	);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/IpfsHash.cpp b/compiler/test/libsolutil/IpfsHash.cpp
new file mode 100644
index 00000000..47fa120e
--- /dev/null
+++ b/compiler/test/libsolutil/IpfsHash.cpp
@@ -0,0 +1,110 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the ipfs hash computation routine.
+ */
+
+#include <libsolutil/IpfsHash.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(IpfsHash, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(test_small)
+{
+	BOOST_CHECK_EQUAL(ipfsHashBase58({}), "QmbFMke1KXqnYyBBWxB74N4c5SBnJMVAiMNRcGu6x1AwQH");
+	BOOST_CHECK_EQUAL(ipfsHashBase58("x"), "QmULKig5Fxrs2sC4qt9nNduucXfb92AFYQ6Hi3YRqDmrYC");
+	BOOST_CHECK_EQUAL(ipfsHashBase58("Solidity\n"), "QmSsm9M7PQRBnyiz1smizk8hZw3URfk8fSeHzeTo3oZidS");
+	BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(200ul, char(0))), "QmSXR1N23uWzsANi8wpxMPw5dmmhqBVUAb4hUrHVLpNaMr");
+	BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(10250ul, char(0))), "QmVJJBB3gKKBWYC9QTywpH8ZL1bDeTDJ17B63Af5kino9i");
+	BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(100000ul, char(0))), "QmYgKa25YqEGpQmmZtPPFMNK3kpqqneHk6nMSEUYryEX1C");
+	BOOST_CHECK_EQUAL(ipfsHashBase58(std::string(121071ul, char(0))), "QmdMdRshQmqvyc92N82r7AKYdUF5FRh4DJo6GtrmEk3wgj");
+}
+
+BOOST_AUTO_TEST_CASE(test_medium)
+{
+	size_t length = 131071;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmSxYSToKHsPqqRdRnsM9gmr3EYS6dakhVaHgbFdgYQWi6");
+}
+
+BOOST_AUTO_TEST_CASE(test_largest_unchunked)
+{
+	size_t length = 1024 * 256 - 1;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmbNDspMkzkMFKyS3eCJGedG7GWRQHSCzJCZLjxP7wyVAx");
+}
+
+BOOST_AUTO_TEST_CASE(test_smallest_chunked)
+{
+	size_t length = 1024 * 256 + 1;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmbVuw4C4vcmVKqxoWtgDVobvcHrSn51qsmQmyxjk4sB2Q");
+}
+
+BOOST_AUTO_TEST_CASE(test_large)
+{
+	size_t length = 1310710;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmNg7BJo8gEMDK8yGQbHEwPtycesnE6FUULX5iVd5TAL9f");
+}
+
+BOOST_AUTO_TEST_CASE(test_largest_one_level)
+{
+	size_t length = 45613056; // 1024 * 256 * 174;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmY4HSz1oVGdUzb8poVYPLsoqBZjH6LZrtgnme9wWn2Qko");
+}
+
+BOOST_AUTO_TEST_CASE(test_smallest_multi_level)
+{
+	size_t length = 45613057; // 1024 * 256 * 174 + 1;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmehMASWcBsX7VcEQqs6rpR5AHoBfKyBVEgmkJHjpPg8jq");
+}
+
+BOOST_AUTO_TEST_CASE(test_multi_level_tree)
+{
+	size_t length = 46661632;
+	std::string data;
+	data.resize(length, 0);
+	BOOST_REQUIRE_EQUAL(data.size(), length);
+	BOOST_CHECK_EQUAL(ipfsHashBase58(data), "QmaTb1sT9hrSXJLmf8bxJ9NuwndiHuMLsgNLgkS2eXu3Xj");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/IterateReplacing.cpp b/compiler/test/libsolutil/IterateReplacing.cpp
new file mode 100644
index 00000000..7b70f155
--- /dev/null
+++ b/compiler/test/libsolutil/IterateReplacing.cpp
@@ -0,0 +1,96 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the iterateReplacing function
+ */
+
+#include <libsolutil/CommonData.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(IterateReplacing, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(no_replacement)
+{
+	std::vector<std::string> v{"abc", "def", "ghi"};
+	std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string&) -> std::optional<std::vector<std::string>> { return {}; };
+	iterateReplacing(v, f);
+	std::vector<std::string> expectation{"abc", "def", "ghi"};
+	BOOST_CHECK(v == expectation);
+}
+
+BOOST_AUTO_TEST_CASE(empty_input)
+{
+	std::vector<std::string> v;
+	std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string&) -> std::optional<std::vector<std::string>> { return {}; };
+	iterateReplacing(v, f);
+	std::vector<std::string> expectation;
+	BOOST_CHECK(v == expectation);
+}
+
+BOOST_AUTO_TEST_CASE(delete_some)
+{
+	std::vector<std::string> v{"abc", "def", "ghi"};
+	std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
+		if (_s == "def")
+			return std::vector<std::string>();
+		else
+			return {};
+	};
+	iterateReplacing(v, f);
+	std::vector<std::string> expectation{"abc", "ghi"};
+	BOOST_CHECK(v == expectation);
+}
+
+BOOST_AUTO_TEST_CASE(inject_some_start)
+{
+	std::vector<std::string> v{"abc", "def", "ghi"};
+	std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
+		if (_s == "abc")
+			return std::vector<std::string>{"x", "y"};
+		else
+			return {};
+	};
+	iterateReplacing(v, f);
+	std::vector<std::string> expectation{"x", "y", "def", "ghi"};
+	BOOST_CHECK(v == expectation);
+}
+
+BOOST_AUTO_TEST_CASE(inject_some_end)
+{
+	std::vector<std::string> v{"abc", "def", "ghi"};
+	std::function<std::optional<std::vector<std::string>>(std::string&)> f = [](std::string& _s) -> std::optional<std::vector<std::string>> {
+		if (_s == "ghi")
+			return std::vector<std::string>{"x", "y"};
+		else
+			return {};
+	};
+	iterateReplacing(v, f);
+	std::vector<std::string> expectation{"abc", "def", "x", "y"};
+	BOOST_CHECK(v == expectation);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/JSON.cpp b/compiler/test/libsolutil/JSON.cpp
new file mode 100644
index 00000000..da10c0b3
--- /dev/null
+++ b/compiler/test/libsolutil/JSON.cpp
@@ -0,0 +1,313 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @date 2018
+ * Unit tests for JSON.h.
+ */
+
+#include <libsolutil/JSON.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(JsonTest, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(json_types)
+{
+	auto check = [](Json::Value value, std::string const& expectation) {
+		BOOST_CHECK(jsonCompactPrint(value) == expectation);
+	};
+
+	Json::Value value;
+	BOOST_CHECK(value.empty());
+	value = {};
+	BOOST_CHECK(value.empty());
+	value = Json::Value();
+	BOOST_CHECK(value.empty());
+	value = Json::nullValue;
+	BOOST_CHECK(value.empty());
+
+	check(value, "null");
+	check({}, "null");
+	check(Json::Value(), "null");
+	check(Json::nullValue, "null");
+	check(Json::objectValue, "{}");
+	check(Json::arrayValue, "[]");
+	check(Json::UInt(1), "1");
+	check(Json::UInt(-1), "4294967295");
+	check(Json::UInt64(1), "1");
+	check(Json::UInt64(-1), "18446744073709551615");
+	check(Json::LargestUInt(1), "1");
+	check(Json::LargestUInt(-1), "18446744073709551615");
+	check(Json::LargestUInt(0xffffffff), "4294967295");
+	check(Json::Value("test"), "\"test\"");
+	check("test", "\"test\"");
+	check(true, "true");
+
+	value = Json::objectValue;
+	value["key"] = "value";
+	check(value, "{\"key\":\"value\"}");
+
+	value = Json::arrayValue;
+	value.append(1);
+	value.append(2);
+	check(value, "[1,2]");
+}
+
+BOOST_AUTO_TEST_CASE(json_pretty_print)
+{
+	Json::Value json;
+	Json::Value jsonChild;
+
+	jsonChild["3.1"] = "3.1";
+	jsonChild["3.2"] = 2;
+	json["1"] = 1;
+	json["2"] = "2";
+	json["3"] = jsonChild;
+	json["4"] = "ऑ ऒ ओ औ क ख";
+	json["5"] = "\xff";
+
+	BOOST_CHECK(
+	"{\n"
+	"  \"1\": 1,\n"
+	"  \"2\": \"2\",\n"
+	"  \"3\":\n"
+	"  {\n"
+	"    \"3.1\": \"3.1\",\n"
+	"    \"3.2\": 2\n"
+	"  },\n"
+	"  \"4\": \"\\u0911 \\u0912 \\u0913 \\u0914 \\u0915 \\u0916\",\n"
+	"  \"5\": \"\\ufffd\"\n"
+	"}" == jsonPrettyPrint(json));
+}
+
+BOOST_AUTO_TEST_CASE(json_compact_print)
+{
+	Json::Value json;
+	Json::Value jsonChild;
+
+	jsonChild["3.1"] = "3.1";
+	jsonChild["3.2"] = 2;
+	json["1"] = 1;
+	json["2"] = "2";
+	json["3"] = jsonChild;
+	json["4"] = "ऑ ऒ ओ औ क ख";
+	json["5"] = "\xff";
+
+	BOOST_CHECK("{\"1\":1,\"2\":\"2\",\"3\":{\"3.1\":\"3.1\",\"3.2\":2},\"4\":\"\\u0911 \\u0912 \\u0913 \\u0914 \\u0915 \\u0916\",\"5\":\"\\ufffd\"}" == jsonCompactPrint(json));
+}
+
+BOOST_AUTO_TEST_CASE(parse_json_strict)
+{
+	// In this test we check conformance against JSON.parse (https://tc39.es/ecma262/multipage/structured-data.html#sec-json.parse)
+	// and ECMA-404 (https://www.ecma-international.org/publications-and-standards/standards/ecma-404/)
+
+	Json::Value json;
+	std::string errors;
+
+	// Just parse a valid json input
+	BOOST_CHECK(jsonParseStrict("{\"1\":1,\"2\":\"2\",\"3\":{\"3.1\":\"3.1\",\"3.2\":2}}", json, &errors));
+	BOOST_CHECK(json["1"] == 1);
+	BOOST_CHECK(json["2"] == "2");
+	BOOST_CHECK(json["3"]["3.1"] == "3.1");
+	BOOST_CHECK(json["3"]["3.2"] == 2);
+
+	// Trailing garbage is not allowed in ECMA-262
+	BOOST_CHECK(!jsonParseStrict("{\"1\":2,\"2\":\"2\",\"3\":{\"3.1\":\"3.1\",\"3.2\":3}}}}}}}}}}", json, &errors));
+
+	// Comments are not allowed in ECMA-262
+	// ... but JSONCPP allows them
+	BOOST_CHECK(jsonParseStrict(
+		"{\"1\":3, // awesome comment\n\"2\":\"2\",\"3\":{\"3.1\":\"3.1\",\"3.2\":5}}", json, &errors
+	));
+	BOOST_CHECK(json["1"] == 3);
+	BOOST_CHECK(json["2"] == "2");
+	BOOST_CHECK(json["3"]["3.1"] == "3.1");
+	BOOST_CHECK(json["3"]["3.2"] == 5);
+
+	// According to ECMA-404 object, array, number, string, true, false, null are allowed
+	// ... but JSONCPP disallows value types
+	BOOST_CHECK(jsonParseStrict("[]", json, &errors));
+	BOOST_CHECK(json.isArray());
+	BOOST_CHECK(jsonParseStrict("{}", json, &errors));
+	BOOST_CHECK(json.isObject());
+	BOOST_CHECK(!jsonParseStrict("1", json, &errors));
+	// BOOST_CHECK(json.isNumeric());
+	BOOST_CHECK(!jsonParseStrict("\"hello\"", json, &errors));
+	// BOOST_CHECK(json.isString());
+	BOOST_CHECK(!jsonParseStrict("true", json, &errors));
+	// BOOST_CHECK(json.isBool());
+	BOOST_CHECK(!jsonParseStrict("null", json, &errors));
+	// BOOST_CHECK(json.isNull());
+
+	// Single quotes are also disallowed by ECMA-404
+	BOOST_CHECK(!jsonParseStrict("'hello'", json, &errors));
+	// BOOST_CHECK(json.isString());
+
+	// Only string keys in objects are allowed in ECMA-404
+	BOOST_CHECK(!jsonParseStrict("{ 42: \"hello\" }", json, &errors));
+
+	// According to ECMA-404 hex escape sequences are not allowed, only unicode (\uNNNN) and
+	// a few control characters (\b, \f, \n, \r, \t)
+	//
+	// More lenient parsers allow hex escapes as long as they translate to a valid UTF-8 encoding.
+	//
+	// ... but JSONCPP allows any hex escapes
+	BOOST_CHECK(jsonParseStrict("[ \"\x80\xec\x80\" ]", json, &errors));
+	BOOST_CHECK(json.isArray());
+	BOOST_CHECK(json[0] == "\x80\xec\x80");
+
+	// This would be valid more lenient parsers.
+	BOOST_CHECK(jsonParseStrict("[ \"\xF0\x9F\x98\x8A\" ]", json, &errors));
+	BOOST_CHECK(json.isArray());
+	BOOST_CHECK(json[0] == "😊");
+}
+
+BOOST_AUTO_TEST_CASE(json_isOfType)
+{
+	Json::Value json;
+
+	json["float"] = 3.1f;
+	json["double"] = 3.1;
+	json["int"] = 2;
+	json["int64"] = Json::Int64{0x4000000000000000};
+	json["string"] = "Hello World!";
+
+	BOOST_CHECK(isOfType<float>(json["float"]));
+	BOOST_CHECK(isOfType<double>(json["double"]));
+	BOOST_CHECK(isOfType<int>(json["int"]));
+	BOOST_CHECK(isOfType<Json::Int>(json["int"]));
+	BOOST_CHECK(isOfType<Json::UInt>(json["int"]));
+	BOOST_CHECK(isOfType<Json::Int64>(json["int"]));
+	BOOST_CHECK(isOfType<Json::Int64>(json["int64"]));
+	BOOST_CHECK(isOfType<Json::UInt64>(json["int64"]));
+	BOOST_CHECK(isOfType<std::string>(json["string"]));
+	BOOST_CHECK(!isOfType<Json::Int>(json["int64"]));
+	BOOST_CHECK(!isOfType<int>(json["double"]));
+	BOOST_CHECK(!isOfType<float>(json["string"]));
+	BOOST_CHECK(!isOfType<double>(json["string"]));
+	BOOST_CHECK(!isOfType<Json::Int>(json["string"]));
+	BOOST_CHECK(!isOfType<Json::Int64>(json["string"]));
+	BOOST_CHECK(!isOfType<Json::UInt>(json["string"]));
+	BOOST_CHECK(!isOfType<Json::UInt64>(json["string"]));
+}
+
+BOOST_AUTO_TEST_CASE(json_isisOfTypeIfExists)
+{
+	Json::Value json;
+
+	json["float"] = 3.1f;
+	json["double"] = 3.1;
+	json["int"] = 2;
+	json["int64"] = Json::Int64{0x4000000000000000};
+	json["string"] = "Hello World!";
+
+	BOOST_CHECK(isOfTypeIfExists<float>(json, "float"));
+	BOOST_CHECK(isOfTypeIfExists<double>(json, "double"));
+	BOOST_CHECK(isOfTypeIfExists<int>(json, "int"));
+	BOOST_CHECK(isOfTypeIfExists<Json::Int>(json, "int"));
+	BOOST_CHECK(isOfTypeIfExists<Json::UInt>(json, "int"));
+	BOOST_CHECK(isOfTypeIfExists<Json::Int64>(json, "int"));
+	BOOST_CHECK(isOfTypeIfExists<Json::Int64>(json, "int64"));
+	BOOST_CHECK(isOfTypeIfExists<Json::UInt64>(json, "int64"));
+	BOOST_CHECK(isOfTypeIfExists<std::string>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<Json::Int>(json, "int64"));
+	BOOST_CHECK(!isOfTypeIfExists<int>(json, "double"));
+	BOOST_CHECK(!isOfTypeIfExists<float>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<double>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<Json::Int>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<Json::Int64>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<Json::UInt>(json, "string"));
+	BOOST_CHECK(!isOfTypeIfExists<Json::UInt64>(json, "string"));
+	BOOST_CHECK(isOfTypeIfExists<Json::UInt64>(json, "NOT_EXISTING"));
+}
+
+BOOST_AUTO_TEST_CASE(json_getOrDefault)
+{
+	Json::Value json;
+
+	json["float"] = 3.1f;
+	json["double"] = 3.1;
+	json["int"] = 2;
+	json["int64"] = Json::Int64{0x4000000000000000};
+	json["uint64"] = Json::UInt64{0x5000000000000000};
+	json["string"] = "Hello World!";
+
+	BOOST_CHECK(getOrDefault<float>(json["float"]) == 3.1f);
+	BOOST_CHECK(getOrDefault<float>(json["float"], -1.1f) == 3.1f);
+	BOOST_CHECK(getOrDefault<float>(json["no_float"], -1.1f) == -1.1f);
+	BOOST_CHECK(getOrDefault<double>(json["double"]) == 3.1);
+	BOOST_CHECK(getOrDefault<double>(json["double"], -1) == 3.1);
+	BOOST_CHECK(getOrDefault<double>(json["no_double"], -1.1) == -1.1);
+	BOOST_CHECK(getOrDefault<int>(json["int"]) == 2);
+	BOOST_CHECK(getOrDefault<int>(json["int"], -1) == 2);
+	BOOST_CHECK(getOrDefault<int>(json["no_int"], -1) == -1);
+	BOOST_CHECK(getOrDefault<Json::Int>(json["int"]) == 2);
+	BOOST_CHECK(getOrDefault<Json::Int>(json["int"], -1) == 2);
+	BOOST_CHECK(getOrDefault<Json::Int>(json["no_int"], -1) == -1);
+	BOOST_CHECK(getOrDefault<Json::UInt>(json["int"]) == 2);
+	BOOST_CHECK(getOrDefault<Json::UInt>(json["int"], 1) == 2);
+	BOOST_CHECK(getOrDefault<Json::UInt>(json["no_int"], 1) == 1);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["int"]) == 2);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["int"], -1) == 2);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["no_int"], -1) == -1);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["int64"]) == 0x4000000000000000);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["int64"], -1) == 0x4000000000000000);
+	BOOST_CHECK(getOrDefault<Json::Int64>(json["no_int64"], -1) == -1);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["int64"]) == 0x4000000000000000);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["int64"], 1) == 0x4000000000000000);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["no_int64"], 1) == 1);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["uint64"]) == 0x5000000000000000);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["uint64"], 1) == 0x5000000000000000);
+	BOOST_CHECK(getOrDefault<Json::UInt64>(json["no_uint64"], 1) == 1);
+	BOOST_CHECK(getOrDefault<std::string>(json["string"], "ERROR") == "Hello World!");
+	BOOST_CHECK(getOrDefault<std::string>(json["no_string"]).empty());
+	BOOST_CHECK(getOrDefault<std::string>(json["no_string"], "ERROR") == "ERROR");
+}
+
+BOOST_AUTO_TEST_CASE(json_get)
+{
+	Json::Value json;
+
+	json["float"] = 3.1f;
+	json["double"] = 3.1;
+	json["int"] = 2;
+	json["int64"] = Json::Int64{0x4000000000000000};
+	json["uint64"] = Json::UInt64{0x5000000000000000};
+	json["string"] = "Hello World!";
+
+	BOOST_CHECK(get<float>(json["float"]) == 3.1f);
+	BOOST_CHECK(get<double>(json["double"]) == 3.1);
+	BOOST_CHECK(get<int>(json["int"]) == 2);
+	BOOST_CHECK(get<Json::Int>(json["int"]) == 2);
+	BOOST_CHECK(get<Json::UInt>(json["int"]) == 2);
+	BOOST_CHECK(get<Json::Int64>(json["int"]) == 2);
+	BOOST_CHECK(get<Json::Int64>(json["int64"]) == 0x4000000000000000);
+	BOOST_CHECK(get<Json::UInt64>(json["int64"]) == 0x4000000000000000);
+	BOOST_CHECK(get<Json::UInt64>(json["uint64"]) == 0x5000000000000000);
+	BOOST_CHECK(get<std::string>(json["string"]) == "Hello World!");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/Keccak256.cpp b/compiler/test/libsolutil/Keccak256.cpp
new file mode 100644
index 00000000..066e909f
--- /dev/null
+++ b/compiler/test/libsolutil/Keccak256.cpp
@@ -0,0 +1,73 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for keccak256.
+ */
+#include <libsolutil/Keccak256.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(Keccak256, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(empty)
+{
+	BOOST_CHECK_EQUAL(
+		keccak256(bytes()),
+		FixedHash<32>("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")
+	);
+}
+
+BOOST_AUTO_TEST_CASE(zeros)
+{
+	BOOST_CHECK_EQUAL(
+		keccak256(bytes(1, '\0')),
+		FixedHash<32>("0xbc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a")
+	);
+	BOOST_CHECK_EQUAL(
+		keccak256(bytes(2, '\0')),
+		FixedHash<32>("0x54a8c0ab653c15bfb48b47fd011ba2b9617af01cb45cab344acd57c924d56798")
+	);
+	BOOST_CHECK_EQUAL(
+		keccak256(bytes(5, '\0')),
+		FixedHash<32>("0xc41589e7559804ea4a2080dad19d876a024ccb05117835447d72ce08c1d020ec")
+	);
+	BOOST_CHECK_EQUAL(
+		keccak256(bytes(10, '\0')),
+		FixedHash<32>("0x6bd2dd6bd408cbee33429358bf24fdc64612fbf8b1b4db604518f40ffd34b607")
+	);
+}
+
+BOOST_AUTO_TEST_CASE(strings)
+{
+	BOOST_CHECK_EQUAL(
+		keccak256("test"),
+		FixedHash<32>("0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658")
+	);
+	BOOST_CHECK_EQUAL(
+		keccak256("longer test string"),
+		FixedHash<32>("0x47bed17bfbbc08d6b5a0f603eff1b3e932c37c10b865847a7bc73d55b260f32a")
+	);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/LEB128.cpp b/compiler/test/libsolutil/LEB128.cpp
new file mode 100644
index 00000000..ccbacf13
--- /dev/null
+++ b/compiler/test/libsolutil/LEB128.cpp
@@ -0,0 +1,100 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for LEB128.
+ */
+
+#include <libsolutil/LEB128.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(LEB128Test)
+
+BOOST_AUTO_TEST_CASE(encode_unsigned)
+{
+	bytes zero = solidity::util::lebEncode(0);
+	BOOST_REQUIRE(zero.size() == 1);
+	BOOST_REQUIRE(zero[0] == 0x00);
+
+	bytes one = solidity::util::lebEncode(1);
+	BOOST_REQUIRE(one.size() == 1);
+	BOOST_REQUIRE(one[0] == 0x01);
+
+	bytes large = solidity::util::lebEncode(624485);
+	BOOST_REQUIRE(large.size() == 3);
+	BOOST_REQUIRE(large[0] == 0xE5);
+	BOOST_REQUIRE(large[1] == 0x8E);
+	BOOST_REQUIRE(large[2] == 0x26);
+
+	bytes larger = solidity::util::lebEncodeSigned(123456123456);
+	BOOST_REQUIRE(larger.size() == 6);
+	BOOST_REQUIRE(larger[0] == 0xC0);
+	BOOST_REQUIRE(larger[1] == 0xE4);
+	BOOST_REQUIRE(larger[2] == 0xBB);
+	BOOST_REQUIRE(larger[3] == 0xF4);
+	BOOST_REQUIRE(larger[4] == 0xCB);
+	BOOST_REQUIRE(larger[5] == 0x03);
+}
+
+BOOST_AUTO_TEST_CASE(encode_signed)
+{
+	bytes zero = solidity::util::lebEncodeSigned(0);
+	BOOST_REQUIRE(zero.size() == 1);
+	BOOST_REQUIRE(zero[0] == 0x00);
+
+	bytes one = solidity::util::lebEncodeSigned(1);
+	BOOST_REQUIRE(one.size() == 1);
+	BOOST_REQUIRE(one[0] == 0x01);
+
+	bytes negative_one = solidity::util::lebEncodeSigned(-1);
+	BOOST_REQUIRE(negative_one.size() == 1);
+	BOOST_REQUIRE(negative_one[0] == 0x7f);
+
+	bytes negative_two = solidity::util::lebEncodeSigned(-2);
+	BOOST_REQUIRE(negative_two.size() == 1);
+	BOOST_REQUIRE(negative_two[0] == 0x7e);
+
+	bytes large = solidity::util::lebEncodeSigned(624485);
+	BOOST_REQUIRE(large.size() == 3);
+	BOOST_REQUIRE(large[0] == 0xE5);
+	BOOST_REQUIRE(large[1] == 0x8E);
+	BOOST_REQUIRE(large[2] == 0x26);
+
+	bytes negative_large = solidity::util::lebEncodeSigned(-123456);
+	BOOST_REQUIRE(negative_large.size() == 3);
+	BOOST_REQUIRE(negative_large[0] == 0xC0);
+	BOOST_REQUIRE(negative_large[1] == 0xBB);
+	BOOST_REQUIRE(negative_large[2] == 0x78);
+
+	bytes negative_larger = solidity::util::lebEncodeSigned(-123456123456);
+	BOOST_REQUIRE(negative_larger.size() == 6);
+	BOOST_REQUIRE(negative_larger[0] == 0xC0);
+	BOOST_REQUIRE(negative_larger[1] == 0x9B);
+	BOOST_REQUIRE(negative_larger[2] == 0xC4);
+	BOOST_REQUIRE(negative_larger[3] == 0x8B);
+	BOOST_REQUIRE(negative_larger[4] == 0xB4);
+	BOOST_REQUIRE(negative_larger[5] == 0x7C);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/StringUtils.cpp b/compiler/test/libsolutil/StringUtils.cpp
new file mode 100644
index 00000000..589efa90
--- /dev/null
+++ b/compiler/test/libsolutil/StringUtils.cpp
@@ -0,0 +1,340 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the StringUtils routines.
+ */
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/StringUtils.h>
+
+#include <libsolidity/ast/Types.h>  // for IntegerType
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(StringUtils, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(test_similarity)
+{
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hello", 0), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hello", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hellw", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "helol", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "helo", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "helllo", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hlllo", 1), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hllllo", 1), false);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hllllo", 2), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("hello", "hlllo", 2), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("a", "", 2), false);
+	BOOST_CHECK_EQUAL(stringWithinDistance("abc", "ba", 2), false);
+	BOOST_CHECK_EQUAL(stringWithinDistance("abc", "abcdef", 2), false);
+	BOOST_CHECK_EQUAL(stringWithinDistance("abcd", "wxyz", 2), false);
+	BOOST_CHECK_EQUAL(stringWithinDistance("", "", 2), true);
+	BOOST_CHECK_EQUAL(stringWithinDistance("YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY", "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZ", 2, 6400), false);
+}
+
+BOOST_AUTO_TEST_CASE(test_dldistance)
+{
+	BOOST_CHECK_EQUAL(stringDistance("hello", "hellw"), 1);
+	BOOST_CHECK_EQUAL(stringDistance("hello", "helol"), 1);
+	BOOST_CHECK_EQUAL(stringDistance("hello", "helo"), 1);
+	BOOST_CHECK_EQUAL(stringDistance("hello", "helllo"), 1);
+	BOOST_CHECK_EQUAL(stringDistance("hello", "hlllo"), 1);
+	BOOST_CHECK_EQUAL(stringDistance("hello", "hllllo"), 2);
+	BOOST_CHECK_EQUAL(stringDistance("a", ""), 1);
+	BOOST_CHECK_EQUAL(stringDistance("abc", "ba"), 2);
+	BOOST_CHECK_EQUAL(stringDistance("abc", "abcdef"), 3);
+	BOOST_CHECK_EQUAL(stringDistance("abcd", "wxyz"), 4);
+	BOOST_CHECK_EQUAL(stringDistance("", ""), 0);
+	BOOST_CHECK_EQUAL(stringDistance("abcdefghijklmnopqrstuvwxyz", "abcabcabcabcabcabcabcabca"), 23);
+
+}
+
+BOOST_AUTO_TEST_CASE(test_alternatives_list)
+{
+	std::vector<std::string> strings;
+	BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "");
+	strings.emplace_back("a");
+	BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "\"a\"");
+	strings.emplace_back("b");
+	BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "\"a\" or \"b\"");
+	strings.emplace_back("c");
+	BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "\"a\", \"b\" or \"c\"");
+	strings.emplace_back("d");
+	BOOST_CHECK_EQUAL(quotedAlternativesList(strings), "\"a\", \"b\", \"c\" or \"d\"");
+}
+
+BOOST_AUTO_TEST_CASE(test_human_readable_join)
+{
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({})), "");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"})), "a");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"})), "a, b");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"})), "a, b, c");
+
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({}), "; "), "");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"}), "; "), "a");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"}), "; "), "a; b");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"}), "; "), "a; b; c");
+
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({}), "; ", " or "), "");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a"}), "; ", " or "), "a");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b"}), "; ", " or "), "a or b");
+	BOOST_CHECK_EQUAL(joinHumanReadable(std::vector<std::string>({"a", "b", "c"}), "; ", " or "), "a; b or c");
+}
+
+BOOST_AUTO_TEST_CASE(test_format_number_readable)
+{
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x10000000)), "2**28");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x100000000)), "2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x8000000)), "2**27");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x80000000)), "2**31");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x800000000)), "2**35");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x8000000000)), "2**39");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x80000000000)), "2**43");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x7ffffff)), "2**27 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x7fffffff)), "2**31 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x7ffffffff)), "2**35 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x7fffffffff)), "2**39 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x7ffffffffff)), "2**43 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xfffffff)), "2**28 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xffffffff)), "2**32 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x88000000)), "0x88 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x8888888888000000)), "0x8888888888 * 2**24");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x100000000)), "2**32");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xFFFFffff)), "2**32 - 1");
+
+	u256 b = 0;
+	for (int i = 0; i < 32; i++)
+	{
+		b <<= 8;
+		b |= 0x55;
+	}
+	u256 c = (u256)FixedHash<32>(
+		fromHex("0xabcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789")
+	);
+	u256 d = u256(0xAAAAaaaaAAAAaaaa) << 192;
+	u256 e = u256(0xAAAAaaaaAAAAaaaa) << 192 |
+		u256(0xFFFFffffFFFFffff) << 128 |
+		u256(0xFFFFffffFFFFffff) << 64 |
+		u256(0xFFFFffffFFFFffff);
+	BOOST_CHECK_EQUAL(formatNumberReadable(b, true), "0x5555...{+56 more}...5555");
+	BOOST_CHECK_EQUAL(formatNumberReadable(c, true), "0xABCD...{+56 more}...6789");
+	BOOST_CHECK_EQUAL(formatNumberReadable(d, true), "0xAAAAaaaaAAAAaaaa * 2**192");
+	BOOST_CHECK_EQUAL(formatNumberReadable(e, true), "0xAAAAaaaaAAAAaaab * 2**192 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x20000000)), "2**29");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x200000000)), "2**33");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x2000000000)), "2**37");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x20000000000)), "2**41");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x200000000000)), "2**45");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1FFFFFFF)), "2**29 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1FFFFFFFF)), "2**33 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1FFFFFFFFF)), "2**37 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1FFFFFFFFFF)), "2**41 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1FFFFFFFFFFF)), "2**45 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3000000)), "0x03 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x30000000)), "0x30 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x300000000)), "0x03 * 2**32");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3000000000)), "0x30 * 2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x2FFFFFF)), "0x03 * 2**24 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x2FFFFFFF)), "0x30 * 2**24 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x2FFFFFFFF)), "0x03 * 2**32 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x2FFFFFFFFF)), "0x30 * 2**32 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA3000000)), "0xa3 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA30000000)), "0x0a30 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA300000000)), "0xa3 * 2**32");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA3000000000)), "0x0a30 * 2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA2FFFFFF)), "0xa3 * 2**24 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA2FFFFFFF)), "0x0a30 * 2**24 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA2FFFFFFFF)), "0xa3 * 2**32 - 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xA2FFFFFFFFF)), "0x0a30 * 2**32 - 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 128, true), "0x03 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 129, true), "0x06 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 130, true), "0x0c * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 131, true), "0x18 * 2**128");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 248, true), "0x03 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 249, true), "0x06 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 250, true), "0x0c * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x3) << 251, true), "0x18 * 2**248");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 128, true), "0x09 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 129, true), "0x12 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 130, true), "0x24 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 131, true), "0x48 * 2**128");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 248, true), "0x09 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 249, true), "0x12 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 250, true), "0x24 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x9) << 251, true), "0x48 * 2**248");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0)), "0");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x10000)), "65536");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xFFFF)), "65535");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0x1000000)), "16777216");
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(0xFFFFFF)), "16777215");
+
+	//for codegen/ExpressionCompiler
+	BOOST_CHECK_EQUAL(formatNumberReadable(u256(-1)), "2**256 - 1");
+
+	// for formal/SMTChecker
+	BOOST_CHECK_EQUAL(
+			formatNumberReadable(frontend::IntegerType(256).minValue()), "0");
+	BOOST_CHECK_EQUAL(
+			formatNumberReadable(frontend::IntegerType(256).maxValue()), "2**256 - 1");
+}
+
+BOOST_AUTO_TEST_CASE(test_format_number_readable_signed)
+{
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x10000000)), "-2**28");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x100000000)), "-2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x8000000)), "-2**27");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x80000000)), "-2**31");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x800000000)), "-2**35");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x8000000000)), "-2**39");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x80000000000)), "-2**43");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x7ffffff)), "-2**27 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x7fffffff)), "-2**31 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x7ffffffff)), "-2**35 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x7fffffffff)), "-2**39 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x7ffffffffff)), "-2**43 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xfffffff)), "-2**28 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xffffffff)), "-2**32 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x88000000)), "-0x88 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x8888888888000000)), "-0x8888888888 * 2**24");
+
+	s256 b = 0;
+	for (int i = 0; i < 32; i++)
+	{
+		b <<= 8;
+		b |= 0x55;
+	}
+	b = b * (-1);
+
+	s256 c = (-1) * u2s((u256)FixedHash<32>(
+		fromHex("0x0bcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789")
+	));
+
+	s256 d = (-1) * u2s(
+		u256(0x5555555555555555) << 192 |
+		u256(0xFFFFffffFFFFffff) << 128 |
+		u256(0xFFFFffffFFFFffff) << 64 |
+		u256(0xFFFFffffFFFFffff)
+	);
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(b, true), "-0x5555...{+56 more}...5555");
+	BOOST_CHECK_EQUAL(formatNumberReadable(c, true), "-0x0BCD...{+56 more}...6789");
+	BOOST_CHECK_EQUAL(formatNumberReadable(d, true), "-0x5555555555555556 * 2**192 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x20000000)), "-2**29");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x200000000)), "-2**33");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x2000000000)), "-2**37");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x20000000000)), "-2**41");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x200000000000)), "-2**45");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1FFFFFFF)), "-2**29 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1FFFFFFFF)), "-2**33 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1FFFFFFFFF)), "-2**37 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1FFFFFFFFFF)), "-2**41 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1FFFFFFFFFFF)), "-2**45 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x3000000)), "-0x03 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x30000000)), "-0x30 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x300000000)), "-0x03 * 2**32");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x3000000000)), "-0x30 * 2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x2FFFFFF)), "-0x03 * 2**24 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x2FFFFFFF)), "-0x30 * 2**24 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x2FFFFFFFF)), "-0x03 * 2**32 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x2FFFFFFFFF)), "-0x30 * 2**32 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA3000000)), "-0xa3 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA30000000)), "-0x0a30 * 2**24");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA300000000)), "-0xa3 * 2**32");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA3000000000)), "-0x0a30 * 2**32");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA2FFFFFF)), "-0xa3 * 2**24 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA2FFFFFFF)), "-0x0a30 * 2**24 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA2FFFFFFFF)), "-0xa3 * 2**32 + 1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xA2FFFFFFFFF)), "-0x0a30 * 2**32 + 1");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 128, true), "-0x03 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 129, true), "-0x06 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 130, true), "-0x0c * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 131, true), "-0x18 * 2**128");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 248, true), "-0x03 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 249, true), "-0x06 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 250, true), "-0x0c * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x3)) << 251, true), "-0x18 * 2**248");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 128, true), "-0x09 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 129, true), "-0x12 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 130, true), "-0x24 * 2**128");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 131, true), "-0x48 * 2**128");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 248, true), "-0x09 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 249, true), "-0x12 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 250, true), "-0x24 * 2**248");
+	BOOST_CHECK_EQUAL(formatNumberReadable(((-1) * s256(0x9)) << 251, true), "-0x48 * 2**248");
+
+	BOOST_CHECK_EQUAL(formatNumberReadable(s256(-1)), "-1");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x10000)), "-65536");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xFFFF)), "-65535");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0x1000000)), "-16777216");
+	BOOST_CHECK_EQUAL(formatNumberReadable((-1) * s256(0xFFFFFF)), "-16777215");
+
+	BOOST_CHECK_EQUAL(
+		formatNumberReadable(
+			frontend::IntegerType(256, frontend::IntegerType::Modifier::Signed).minValue()
+		),
+		"-2**255"
+	);
+	BOOST_CHECK_EQUAL(
+		formatNumberReadable(
+			frontend::IntegerType(256, frontend::IntegerType::Modifier::Signed).maxValue()
+		),
+		"2**255 - 1"
+	);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/SwarmHash.cpp b/compiler/test/libsolutil/SwarmHash.cpp
new file mode 100644
index 00000000..25c6b77c
--- /dev/null
+++ b/compiler/test/libsolutil/SwarmHash.cpp
@@ -0,0 +1,107 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the swarm hash computation routine.
+ */
+
+#include <libsolutil/SwarmHash.h>
+
+#include <test/Common.h>
+
+#include <libsolutil/Keccak256.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(SwarmHash, *boost::unit_test::label("nooptions"))
+
+namespace
+{
+
+std::string bzzr0HashHex(std::string const& _input)
+{
+	return toHex(bzzr0Hash(_input).asBytes());
+}
+
+std::string bzzr1HashHex(bytes const& _input)
+{
+	return toHex(bzzr1Hash(_input).asBytes());
+}
+
+bytes sequence(size_t _length)
+{
+	bytes data;
+	for (size_t i = 0; i < _length; i++)
+		data.push_back(uint8_t((i % 255) & 0xff));
+	return data;
+}
+
+}
+
+BOOST_AUTO_TEST_CASE(test_zeros)
+{
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string()), std::string("011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000 - 1, 0)), std::string("32f0faabc4265ac238cd945087133ce3d7e9bb2e536053a812b5373c54043adb"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000, 0)), std::string("411dd45de7246e94589ff5888362c41e85bd3e582a92d0fda8f0e90b76439bec"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x1000 + 1, 0)), std::string("69754a0098432bbc2e84fe1205276870748a61a065ab6ef44d6a2e7b13ce044d"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000 - 1, 0)), std::string("69ad3c581043404f775ffa8d6f1b25ad4a9ee812971190e90209c0966116a321"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000, 0)), std::string("f00222373ff82d0a178dc6271c78953e9c88f74130a52d401f5ec51475f63c43"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x2000 + 1, 0)), std::string("86d6773e79e02fd8145ee1aedba89ace0c15f2566db1249654000039a9a134bf"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x80000, 0)), std::string("cc0854fe2c6b98e920d5c14b1a88e6d4223e55b8f78883f60939aa2485e361bf"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x80020, 0)), std::string("ee9ffca246e70d3704740ba4df450fa6988d14a1c2439c7e734c7a77a4eb6fd3"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(0x800020, 0)), std::string("78b90b20c90559fb904535181a7c28929ea2f30a2329dbc25232de579709f12f"));
+	BOOST_CHECK_EQUAL(bzzr0HashHex(std::string(2095104, 0)), std::string("a9958184589fc11b4027a4c233e777ebe2e99c66f96b74aef2a0638a94dd5439"));
+}
+
+BOOST_AUTO_TEST_CASE(bzz_hash_short)
+{
+	// Special case: 32 zero bytes
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes()), toHex(bytes(32, 0)));
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(1, 0)), "fe60ba40b87599ddfb9e8947c1c872a4a1a5b56f7d1b80f0a646005b38db52a5");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(31, 0)), "36fe2d14c5fe9ed380dc67afd9da6c5824bffcb01ac7972219c3cc3b1c8cd6b1");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(asBytes("hello world")), "92672a471f4419b255d7cb0cf313474a6f5856fb347c5ece85fb706d644b630f");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(64, 0)), "24090f674316c306ea2a98bdd08f042d6f776d0ae1c23b27fca52750a9c7d4e5");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(65, 0)), "6ab1eaa91095215e30cacf47131d06ce5e9fc01611e406409705e190ee4440c6");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4096, 0)), "09ae927d0f3aaa37324df178928d3826820f3dd3388ce4aaebfc3af410bde23a");
+}
+
+BOOST_AUTO_TEST_CASE(bzz_hash_large)
+{
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4097, 0)), "c082943c4cb8a97c67947f290f5421cf4c61d021eb303c8df77de6fe208df516");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4096 * 128, 0)), "392edbfc185187265cb5d50c2507965f2bb99ce8c255a24d3eb14257e40f2e33");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4096 * 128 * 2, 0)), "f89af84ac550cdaa79639d5f6a1591ff1c9b3cb5d1fc55651ca63d4f80375447");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4096 * 129, 0)), "8ab36734a15aef65221b024e47ee9a6bb727d8101eec42db364eef42285beb1d");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(bytes(4096 * 130, 0)), "21eafb87f2a2a7e51d96212296f8e970103add0527f2fc61fae99f244847a42d");
+}
+
+BOOST_AUTO_TEST_CASE(bzz_hash_nonzero)
+{
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(65)), "541552bae05e9a63a6cb561f69edf36ffe073e441667dbf7a0e9a3864bb744ea");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(4096)), "c10090961e7682a10890c334d759a28426647141213abda93b096b892824d2ef");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(4096 * 128 + 31)), "e5c76afa931e33ac94bce2e754b1bb6407d07f738f67856783d93934ca8fc576");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(4096 * 128 + 33)), "c2489aebad937b19384b61c7bd4ba494f9b14a710b2bcccce792856fb8fcfb3d");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(4096 * 129)), "b7e298f61b1bf23e21d8f45bf545eb1d6c0c4eaaca7d2c2690fb86038404a6d6");
+	BOOST_CHECK_EQUAL(bzzr1HashHex(sequence(4096 * 130)), "59de730bf6c67a941f3b2ffa2f920acfaa1713695ad5deea12b4a121e5f23fa1");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/TemporaryDirectoryTest.cpp b/compiler/test/libsolutil/TemporaryDirectoryTest.cpp
new file mode 100644
index 00000000..b5e6edee
--- /dev/null
+++ b/compiler/test/libsolutil/TemporaryDirectoryTest.cpp
@@ -0,0 +1,108 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <libsolidity/util/SoltestErrors.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <fstream>
+
+using namespace boost::test_tools;
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(TemporaryDirectoryTest)
+
+BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_and_delete_a_unique_and_empty_directory)
+{
+	boost::filesystem::path dirPath;
+	{
+		TemporaryDirectory tempDir("temporary-directory-test");
+		dirPath = tempDir.path();
+
+		BOOST_TEST(dirPath.stem().string().find("temporary-directory-test") == 0);
+		BOOST_TEST(boost::filesystem::equivalent(dirPath.parent_path(), boost::filesystem::temp_directory_path()));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath));
+		BOOST_TEST(boost::filesystem::is_empty(dirPath));
+	}
+	BOOST_TEST(!boost::filesystem::exists(dirPath));
+}
+
+BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_delete_its_directory_even_if_not_empty)
+{
+	boost::filesystem::path dirPath;
+	{
+		TemporaryDirectory tempDir("temporary-directory-test");
+		dirPath = tempDir.path();
+
+		BOOST_TEST(boost::filesystem::is_directory(dirPath));
+
+		{
+			std::ofstream tmpFile((dirPath / "test-file.txt").string());
+			tmpFile << "Delete me!" << std::endl;
+		}
+		soltestAssert(boost::filesystem::is_regular_file(dirPath / "test-file.txt"), "");
+	}
+	BOOST_TEST(!boost::filesystem::exists(dirPath / "test-file.txt"));
+}
+
+BOOST_AUTO_TEST_CASE(TemporaryDirectory_should_create_subdirectories)
+{
+	boost::filesystem::path dirPath;
+	{
+		TemporaryDirectory tempDir({"a", "a/", "a/b/c", "x.y/z"}, "temporary-directory-test");
+		dirPath = tempDir.path();
+
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "a"));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "a/b/c"));
+		BOOST_TEST(boost::filesystem::is_directory(dirPath / "x.y/z"));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(TemporaryWorkingDirectory_should_change_and_restore_working_directory)
+{
+	boost::filesystem::path originalWorkingDirectory = boost::filesystem::current_path();
+
+	try
+	{
+		{
+			TemporaryDirectory tempDir("temporary-directory-test");
+			soltestAssert(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory), "");
+			soltestAssert(!boost::filesystem::equivalent(tempDir.path(), originalWorkingDirectory), "");
+
+			TemporaryWorkingDirectory tempWorkDir(tempDir.path());
+
+			BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), tempDir.path()));
+		}
+		BOOST_TEST(boost::filesystem::equivalent(boost::filesystem::current_path(), originalWorkingDirectory));
+
+		boost::filesystem::current_path(originalWorkingDirectory);
+	}
+	catch (...)
+	{
+		boost::filesystem::current_path(originalWorkingDirectory);
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/UTF8.cpp b/compiler/test/libsolutil/UTF8.cpp
new file mode 100644
index 00000000..449f2219
--- /dev/null
+++ b/compiler/test/libsolutil/UTF8.cpp
@@ -0,0 +1,215 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for UTF-8 validation.
+ */
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/UTF8.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(UTF8, *boost::unit_test::label("nooptions"))
+
+namespace {
+
+bool isValidUTF8(std::string const& _value)
+{
+	size_t pos;
+	return validateUTF8(asString(fromHex(_value)), pos);
+}
+
+bool isInvalidUTF8(std::string const& _value, size_t _expectedPos)
+{
+	size_t pos;
+	if (validateUTF8(asString(fromHex(_value)), pos))
+		return false;
+	if (pos != _expectedPos)
+		return false;
+	return true;
+}
+
+}
+
+BOOST_AUTO_TEST_CASE(valid)
+{
+	BOOST_CHECK(isValidUTF8("00"));
+	BOOST_CHECK(isValidUTF8("20"));
+	BOOST_CHECK(isValidUTF8("7f"));
+	BOOST_CHECK(isValidUTF8("c281"));
+	BOOST_CHECK(isValidUTF8("df81"));
+	BOOST_CHECK(isValidUTF8("e0a081"));
+	BOOST_CHECK(isValidUTF8("e18081"));
+	BOOST_CHECK(isValidUTF8("ec8081"));
+	BOOST_CHECK(isValidUTF8("ed8081"));
+	BOOST_CHECK(isValidUTF8("ee8081"));
+	BOOST_CHECK(isValidUTF8("ef8081"));
+	BOOST_CHECK(isValidUTF8("f0908081"));
+	BOOST_CHECK(isValidUTF8("f3808081"));
+	BOOST_CHECK(isValidUTF8("f2808081"));
+	BOOST_CHECK(isValidUTF8("f3808081"));
+	BOOST_CHECK(isValidUTF8("f48e8081"));
+}
+
+BOOST_AUTO_TEST_CASE(invalid)
+{
+	// anything between 0x80 and 0xc0 is disallowed
+	BOOST_CHECK(isInvalidUTF8("80", 0)); // invalid per table 3.6
+	BOOST_CHECK(isInvalidUTF8("a0", 0)); // invalid per table 3.6
+	BOOST_CHECK(isInvalidUTF8("c0", 0)); // invalid per table 3.7
+	BOOST_CHECK(isInvalidUTF8("c1", 0)); // invalid per table 3.7
+	BOOST_CHECK(isInvalidUTF8("c2", 0)); // too short (position is reported as the first byte)
+	BOOST_CHECK(isInvalidUTF8("e08081", 2)); // e0 must be followed by >= a0
+	BOOST_CHECK(isInvalidUTF8("e180", 0)); // too short
+	BOOST_CHECK(isInvalidUTF8("ec80", 0)); // too short
+	BOOST_CHECK(isInvalidUTF8("f08f8001", 2)); // f0 must be followed by >= 90
+	BOOST_CHECK(isInvalidUTF8("f18080", 0)); // too short
+	BOOST_CHECK(isInvalidUTF8("f4908081", 2)); // f4 must be followed by < 90
+	// anything above 0xf7 is disallowed
+	BOOST_CHECK(isInvalidUTF8("f8", 0)); // invalid per table 3.7
+	BOOST_CHECK(isInvalidUTF8("f9", 0)); // invalid per table 3.7
+}
+
+BOOST_AUTO_TEST_CASE(corpus)
+{
+	std::string source = R"(
+κόσμε
+
+hélló
+
+Ā ā Ă ă Ą ą
+
+ƀ Ɓ Ƃ ƃ Ƅ ƅ
+
+ɐ ɑ ɒ ɓ ɔ ɕ
+
+ʰ ʱ ʲ ʳ ʴ ʵ
+
+̀ ́ ̂ ̃ ̄ ̅
+
+ϩ Ϫ ϫ Ϭ ϭ Ϯ
+
+Ё Ђ Ѓ Є Ѕ І
+
+Ա Բ Գ Դ Ե Զ
+
+ ק ר ש ת װ ױ
+
+ځ ڂ ڃ ڄ څ چ
+
+ऑ ऒ ओ औ क ख
+
+ও ঔ ক খ গ ঘ
+
+ਘ ਙ ਚ ਛ ਜ ਝ
+
+ઓ ઔ ક ખ ગ ઘ
+
+ଗ ଘ ଙ ଚ ଛ ଜ
+
+ஔ க ங ச ஜ ஞ
+
+ఎ ఏ ఐ ఒ ఓ ఔ
+
+ಓ ಔ ಕ ಖ ಗ ಘ
+
+ഐ ഒ ഓ ഔ ക
+
+ฒ ณ ด ต ถ ท
+
+ມ ຢ ຣ ລ ວ ສ
+
+༄ ༅ ༆ ༇ ༈ ༉
+
+Ⴑ Ⴒ Ⴓ Ⴔ Ⴕ Ⴖ
+
+ᄌ ᄍ ᄎ ᄏ ᄐ
+
+Ḕ ḕ Ḗ ḗ Ḙ ḙ Ḛ
+
+ἐ ἑ ἒ ἓ ἔ ἕ
+
+₠ ₡ ₢ ₣ ₤ ₥
+
+⃐ ⃑ ⃒ ⃓ ⃔ ⃕ ⃖ ⃗ ⃘ ⃙ ⃚
+
+ℋ ℌ ℍ ℎ ℏ ℐ ℑ
+
+⅓ ⅔ ⅕ ⅖ ⅗
+
+∬ ∭ ∮ ∯ ∰
+
+⌖ ⌗ ⌘ ⌙ ⌚ ⌛
+
+␀ ␁ ␂ ␃ ␄ ␅
+
+⑀ ⑁ ⑂ ⑃ ⑄
+
+① ② ③ ④ ⑤
+
+╘ ╙ ╚ ╛ ╜ ╝
+
+▁ ▂ ▃ ▄ ▅ ▆
+
+▤ ▥ ▦ ▧ ▨
+
+♔ ♕ ♖ ♗ ♘ ♙
+
+✈ ✉ ✌ ✍ ✎
+
+ぁ あ ぃ い ぅ
+
+ァ ア ィ イ ゥ
+
+ㄅ ㄆ ㄇ ㄈ ㄉ
+
+ㄱ ㄲ ㄳ ㄴ ㄵ
+
+㆚ ㆛ ㆜ ㆝ ㆞
+
+㈀ ㈁ ㈂ ㈃ ㈄
+
+㌀ ㌁ ㌂ ㌃ ㌄
+
+乺 乻 乼 乽 乾
+
+걺 걻 걼 걽 걾
+
+豈 更 車 賈 滑
+
+שּׁ שּׂ אַ אָ אּ
+
+ﮄ ﮅ ﮆ ﮇ ﮈ ﮉ
+
+ ﺵ ﺶ ﺷ ﺸ
+
+｢ ｣ ､ ･ ｦ ｧ ｨ ｩ
+	)";
+	size_t pos;
+	BOOST_CHECK(validateUTF8(source, pos));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libsolutil/Whiskers.cpp b/compiler/test/libsolutil/Whiskers.cpp
new file mode 100644
index 00000000..5bb4e3ad
--- /dev/null
+++ b/compiler/test/libsolutil/Whiskers.cpp
@@ -0,0 +1,245 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Unit tests for the mini moustache class.
+ */
+
+#include <libsolutil/Whiskers.h>
+
+#include <test/Common.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+namespace solidity::util::test
+{
+
+BOOST_AUTO_TEST_SUITE(WhiskersTest, *boost::unit_test::label("nooptions"))
+
+BOOST_AUTO_TEST_CASE(no_templates)
+{
+	std::string templ = "this text does not contain templates";
+	BOOST_CHECK_EQUAL(Whiskers(templ).render(), templ);
+}
+
+BOOST_AUTO_TEST_CASE(basic_replacement)
+{
+	std::string templ = "a <b> x <c> -> <d>.";
+	std::string result = Whiskers(templ)
+		("b", "BE")
+		("c", "CE")
+		("d", "DE")
+		.render();
+	BOOST_CHECK_EQUAL(result, "a BE x CE -> DE.");
+}
+
+BOOST_AUTO_TEST_CASE(tag_unavailable)
+{
+	std::string templ = "<b>";
+	Whiskers m(templ);
+	BOOST_CHECK_THROW(m.render(), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(list_unavailable)
+{
+	std::string templ = "<#b></b>";
+	Whiskers m(templ);
+	BOOST_CHECK_THROW(m.render(), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(name_type_collision)
+{
+	std::string templ = "<b><#b></b>";
+	Whiskers m(templ);
+	m("b", "x");
+	BOOST_CHECK_THROW(m("b", std::vector<std::map<std::string, std::string>>{}), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(conditional)
+{
+	std::string templ = "<?b>X</b>";
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", true).render(), "X");
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", false).render(), "");
+}
+
+BOOST_AUTO_TEST_CASE(conditional_with_else)
+{
+	std::string templ = "<?b>X<!b>Y</b>";
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", true).render(), "X");
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", false).render(), "Y");
+}
+
+BOOST_AUTO_TEST_CASE(broken_conditional_with_else)
+{
+	std::string templ = "<?b>X<!bY</b>";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+
+	templ = "<?bX<!b>Y</b>";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+
+	templ = "<?b>X<!b>Y</b";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(broken_conditional_value_with_else)
+{
+	std::string templ = "<?+b>X<!+bY</+b>";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+
+	templ = "<?+bX<!+b>Y</+b>";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+
+	templ = "<?+b>X<!+b>Y</+b";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(broken_list_parameter)
+{
+	std::string templ = "<#b><a></b";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+
+	templ = "<#b<a></b>";
+	BOOST_CHECK_THROW(Whiskers{templ}, WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(conditional_plus_params)
+{
+	std::string templ = " - <?b>_<r><!b>^<t></b> - ";
+	Whiskers m1(templ);
+	m1("b", true);
+	m1("r", "R");
+	m1("t", "T");
+	BOOST_CHECK_EQUAL(m1.render(), " - _R - ");
+
+	Whiskers m2(templ);
+	m2("b", false);
+	m2("r", "R");
+	m2("t", "T");
+	BOOST_CHECK_EQUAL(m2.render(), " - ^T - ");
+}
+
+BOOST_AUTO_TEST_CASE(conditional_plus_list)
+{
+	std::string templ = " - <?b>_<#l><x></l><!b><#l><y></l></b> - ";
+	Whiskers m(templ);
+	m("b", false);
+	std::vector<std::map<std::string, std::string>> list(2);
+	list[0]["x"] = "1";
+	list[0]["y"] = "a";
+	list[1]["x"] = "2";
+	list[1]["y"] = "b";
+	m("l", list);
+	BOOST_CHECK_EQUAL(m.render(), " - ab - ");
+}
+
+BOOST_AUTO_TEST_CASE(string_as_conditional)
+{
+	std::string templ = "<?+b>+<b><!+b>-</+b>";
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", "abc").render(), "+abc");
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", "").render(), "-");
+}
+
+BOOST_AUTO_TEST_CASE(string_as_conditional_wrong)
+{
+	std::string templ = "<?+b>+<b></b>";
+	BOOST_CHECK_EQUAL(Whiskers(templ)("b", "abc").render(), "<?+b>+abc</b>");
+}
+
+BOOST_AUTO_TEST_CASE(complicated_replacement)
+{
+	std::string templ = "a <b> x <complicated> \n <nested>>.";
+	std::string result = Whiskers(templ)
+		("b", "BE")
+		("complicated", "CO<M>PL")
+		("nested", "NEST")
+		.render();
+	BOOST_CHECK_EQUAL(result, "a BE x CO<M>PL \n NEST>.");
+}
+
+BOOST_AUTO_TEST_CASE(non_existing_list)
+{
+	std::string templ = "a <#b></b>";
+	Whiskers m(templ);
+	BOOST_CHECK_THROW(m.render(), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(empty_list)
+{
+	std::string templ = "a <#b></b>x";
+	std::string result = Whiskers(templ)("b", std::vector<Whiskers::StringMap>{}).render();
+	BOOST_CHECK_EQUAL(result, "a x");
+}
+
+BOOST_AUTO_TEST_CASE(list)
+{
+	std::string templ = "a<#b>( <g> - <h> )</b>x";
+	std::vector<std::map<std::string, std::string>> list(2);
+	list[0]["g"] = "GE";
+	list[0]["h"] = "H";
+	list[1]["g"] = "2GE";
+	list[1]["h"] = "2H";
+	std::string result = Whiskers(templ)("b", list).render();
+	BOOST_CHECK_EQUAL(result, "a( GE - H )( 2GE - 2H )x");
+}
+
+BOOST_AUTO_TEST_CASE(recursive_list)
+{
+	// Check that templates resulting from lists are not expanded again
+	std::string templ = "a<#b> 1<g>3 </b><x>";
+	std::vector<std::map<std::string, std::string>> list(1);
+	list[0]["g"] = "<x>";
+	std::string result = Whiskers(templ)("x", "X")("b", list).render();
+	BOOST_CHECK_EQUAL(result, "a 1<x>3 X");
+}
+
+BOOST_AUTO_TEST_CASE(list_can_access_upper)
+{
+	std::string templ = "<#b>(<a>)</b>";
+	std::vector<std::map<std::string, std::string>> list(2);
+	Whiskers m(templ);
+	std::string result = m("a", "A")("b", list).render();
+	BOOST_CHECK_EQUAL(result, "(A)(A)");
+}
+
+BOOST_AUTO_TEST_CASE(parameter_collision)
+{
+	std::string templ = "a <#b></b>";
+	std::vector<std::map<std::string, std::string>> list(1);
+	list[0]["a"] = "x";
+	Whiskers m(templ);
+	BOOST_CHECK_THROW(m("a", "X")("b", list), WhiskersError);
+	BOOST_CHECK_THROW(m.render(), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_param)
+{
+	std::string templ = "a <b >";
+	Whiskers m(templ);
+	BOOST_CHECK_THROW(m("b ", "X"), WhiskersError);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_param_rendered)
+{
+	std::string templ = "a <b >";
+	Whiskers m(templ);
+	BOOST_CHECK_EQUAL(m.render(), templ);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libyul/Common.cpp b/compiler/test/libyul/Common.cpp
new file mode 100644
index 00000000..10d7d12a
--- /dev/null
+++ b/compiler/test/libyul/Common.cpp
@@ -0,0 +1,143 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @date 2017
+ * Common functions the Yul tests.
+ */
+
+#include <test/libyul/Common.h>
+
+#include <test/Common.h>
+
+#include <libyul/optimiser/Disambiguator.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/AsmPrinter.h>
+#include <libyul/YulStack.h>
+#include <libyul/AST.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/ErrorReporter.h>
+#include <liblangutil/Scanner.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <variant>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::langutil;
+
+namespace
+{
+Dialect const& defaultDialect(bool _yul)
+{
+	return _yul ? yul::Dialect::yulDeprecated() : yul::EVMDialect::strictAssemblyForEVM(solidity::test::CommonOptions::get().evmVersion());
+}
+}
+
+std::pair<std::shared_ptr<Block>, std::shared_ptr<yul::AsmAnalysisInfo>> yul::test::parse(std::string const& _source, bool _yul)
+{
+	YulStack stack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		_yul ? YulStack::Language::Yul : YulStack::Language::StrictAssembly,
+		solidity::test::CommonOptions::get().optimize ?
+			solidity::frontend::OptimiserSettings::standard() :
+			solidity::frontend::OptimiserSettings::minimal(),
+		DebugInfoSelection::All()
+	);
+	if (!stack.parseAndAnalyze("", _source) || !stack.errors().empty())
+		BOOST_FAIL("Invalid source.");
+	return make_pair(stack.parserResult()->code, stack.parserResult()->analysisInfo);
+}
+
+std::pair<std::shared_ptr<Object>, std::shared_ptr<yul::AsmAnalysisInfo>> yul::test::parse(
+	std::string const& _source,
+	Dialect const& _dialect,
+	ErrorList& _errors
+)
+{
+	ErrorReporter errorReporter(_errors);
+	CharStream stream(_source, "");
+	std::shared_ptr<Scanner> scanner = std::make_shared<Scanner>(stream);
+	std::shared_ptr<Object> parserResult = yul::ObjectParser(errorReporter, _dialect).parse(scanner, false);
+	if (!parserResult)
+		return {};
+	if (!parserResult->code || errorReporter.hasErrors())
+		return {};
+	std::shared_ptr<AsmAnalysisInfo> analysisInfo = std::make_shared<AsmAnalysisInfo>();
+	AsmAnalyzer analyzer(*analysisInfo, errorReporter, _dialect, {}, parserResult->qualifiedDataNames());
+	// TODO this should be done recursively.
+	if (!analyzer.analyze(*parserResult->code) || errorReporter.hasErrors())
+		return {};
+	return {std::move(parserResult), std::move(analysisInfo)};
+}
+
+yul::Block yul::test::disambiguate(std::string const& _source, bool _yul)
+{
+	auto result = parse(_source, _yul);
+	return std::get<Block>(Disambiguator(defaultDialect(_yul), *result.second, {})(*result.first));
+}
+
+std::string yul::test::format(std::string const& _source, bool _yul)
+{
+	return yul::AsmPrinter()(*parse(_source, _yul).first);
+}
+
+namespace
+{
+std::map<std::string const, yul::Dialect const& (*)(langutil::EVMVersion)> const validDialects = {
+	{
+		"evm",
+		[](langutil::EVMVersion _evmVersion) -> yul::Dialect const&
+		{ return yul::EVMDialect::strictAssemblyForEVMObjects(_evmVersion); }
+	},
+	{
+		"evmTyped",
+		[](langutil::EVMVersion _evmVersion) -> yul::Dialect const&
+		{ return yul::EVMDialectTyped::instance(_evmVersion); }
+	},
+	{
+		"yul",
+		[](langutil::EVMVersion) -> yul::Dialect const&
+		{ return yul::Dialect::yulDeprecated(); }
+	}
+};
+
+	std::vector<std::string> validDialectNames()
+{
+	std::vector<std::string> names{size(validDialects), ""};
+	std::transform(begin(validDialects), end(validDialects), names.begin(), [](auto const& dialect) { return dialect.first; });
+
+	return names;
+}
+}
+
+yul::Dialect const& yul::test::dialect(std::string const& _name, langutil::EVMVersion _evmVersion)
+{
+	if (!validDialects.count(_name))
+		BOOST_THROW_EXCEPTION(std::runtime_error{
+			"Invalid Dialect \"" +
+			_name +
+			"\". Valid dialects are " +
+			util::joinHumanReadable(validDialectNames(), ", ", " and ") +
+			"."
+		});
+
+	return validDialects.at(_name)(_evmVersion);
+}
diff --git a/compiler/test/libyul/CompilabilityChecker.cpp b/compiler/test/libyul/CompilabilityChecker.cpp
new file mode 100644
index 00000000..27310cd8
--- /dev/null
+++ b/compiler/test/libyul/CompilabilityChecker.cpp
@@ -0,0 +1,338 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for the compilability checker.
+ */
+
+#include <test/Common.h>
+
+#include <test/libyul/Common.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <libyul/CompilabilityChecker.h>
+
+#include <boost/test/unit_test.hpp>
+
+namespace solidity::yul::test
+{
+
+namespace
+{
+std::string check(std::string const& _input)
+{
+	Object obj;
+	std::tie(obj.code, obj.analysisInfo) = yul::test::parse(_input, false);
+	BOOST_REQUIRE(obj.code);
+	auto functions = CompilabilityChecker(EVMDialect::strictAssemblyForEVM(solidity::test::CommonOptions::get().evmVersion()), obj, true).stackDeficit;
+	std::string out;
+	for (auto const& function: functions)
+		out += function.first.str() + ": " + std::to_string(function.second) + " ";
+	return out;
+}
+}
+
+BOOST_AUTO_TEST_SUITE(CompilabilityChecker)
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	std::string out = check("{}");
+	BOOST_CHECK_EQUAL(out, "");
+}
+
+BOOST_AUTO_TEST_CASE(simple_function)
+{
+	std::string out = check("{ function f(a, b) -> x, y { x := a y := b } }");
+	BOOST_CHECK_EQUAL(out, "");
+}
+
+BOOST_AUTO_TEST_CASE(many_variables_few_uses)
+{
+	std::string out = check(R"({
+		function f(a, b) -> x, y {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(x, r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "f: 4 ");
+}
+
+BOOST_AUTO_TEST_CASE(many_variables_many_uses)
+{
+	std::string out = check(R"({
+		function f(a, b) -> x, y {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "f: 10 ");
+}
+
+BOOST_AUTO_TEST_CASE(many_return_variables_unused_arguments)
+{
+	std::string out = check(R"({
+		function f(a, b) -> r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19 {
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "f: 3 ");
+}
+
+BOOST_AUTO_TEST_CASE(many_return_variables_used_arguments)
+{
+	std::string out = check(R"({
+		function f(a, b) -> r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19 {
+			r1 := 0
+			sstore(a, b)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "f: 5 ");
+}
+
+BOOST_AUTO_TEST_CASE(multiple_functions_used_arguments)
+{
+	std::string out = check(R"({
+		function f(a, b) -> r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19 {
+			r1 := 0
+			sstore(a, b)
+		}
+		function g(r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19) -> x, y {
+			x := 0
+			sstore(r1, r2)
+		}
+		function h(x) {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "h: 9 g: 5 f: 5 ");
+}
+
+BOOST_AUTO_TEST_CASE(multiple_functions_unused_arguments)
+{
+	std::string out = check(R"({
+		function f(a, b) -> r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19 {
+		}
+		function g(r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19) -> x, y {
+		}
+		function h(x) {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "h: 9 f: 3 ");
+}
+
+BOOST_AUTO_TEST_CASE(nested_used_arguments)
+{
+	std::string out = check(R"({
+		function h(x) {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			function f(a, b) -> t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 {
+				function g(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19) -> w, v {
+					w := v
+					sstore(s1, s2)
+				}
+				t1 := t2
+				sstore(a, b)
+			}
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "h: 9 g: 5 f: 5 ");
+}
+
+
+BOOST_AUTO_TEST_CASE(nested_unused_arguments)
+{
+	std::string out = check(R"({
+		function h(x) {
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			function f(a, b) -> t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 {
+				function g(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19) -> w, v {
+				}
+			}
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+		}
+	})");
+	BOOST_CHECK_EQUAL(out, "h: 9 f: 3 ");
+}
+
+
+BOOST_AUTO_TEST_CASE(also_in_outer_block_used_arguments)
+{
+	std::string out = check(R"({
+			let x := 0
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+			function g(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19) -> w, v {
+				w := v
+				sstore(s1, s2)
+			}
+	})");
+	BOOST_CHECK_EQUAL(out, "g: 5 : 9 ");
+}
+
+BOOST_AUTO_TEST_CASE(also_in_outer_block_unused_arguments)
+{
+	std::string out = check(R"({
+			let x := 0
+			let r1 := 0
+			let r2 := 0
+			let r3 := 0
+			let r4 := 0
+			let r5 := 0
+			let r6 := 0
+			let r7 := 0
+			let r8 := 0
+			let r9 := 0
+			let r10 := 0
+			let r11 := 0
+			let r12 := 0
+			let r13 := 0
+			let r14 := 0
+			let r15 := 0
+			let r16 := 0
+			let r17 := 0
+			let r18 := 0
+			x := add(add(add(add(add(add(add(add(add(add(add(add(x, r12), r11), r10), r9), r8), r7), r6), r5), r4), r3), r2), r1)
+			function g(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19) -> w, v {
+			}
+	})");
+	BOOST_CHECK_EQUAL(out, ": 9 ");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libyul/ControlFlowGraphTest.cpp b/compiler/test/libyul/ControlFlowGraphTest.cpp
new file mode 100644
index 00000000..9a0e6f09
--- /dev/null
+++ b/compiler/test/libyul/ControlFlowGraphTest.cpp
@@ -0,0 +1,252 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/ControlFlowGraphTest.h>
+#include <test/libyul/Common.h>
+#include <test/Common.h>
+
+#include <libyul/backends/evm/ControlFlowGraph.h>
+#include <libyul/backends/evm/ControlFlowGraphBuilder.h>
+#include <libyul/backends/evm/StackHelpers.h>
+#include <libyul/Object.h>
+
+#include <libsolutil/AnsiColorized.h>
+#include <libsolutil/Visitor.h>
+
+#ifdef ISOLTEST
+#include <boost/process.hpp>
+#endif
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+ControlFlowGraphTest::ControlFlowGraphTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	auto dialectName = m_reader.stringSetting("dialect", "evm");
+	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_expectation = m_reader.simpleExpectations();
+}
+
+namespace
+{
+static std::string variableSlotToString(VariableSlot const& _slot)
+{
+	return _slot.variable.get().name.str();
+}
+}
+
+class ControlFlowGraphPrinter
+{
+public:
+	ControlFlowGraphPrinter(std::ostream& _stream):
+	m_stream(_stream)
+	{
+	}
+	void operator()(CFG::BasicBlock const& _block, bool _isMainEntry = true)
+	{
+		if (_isMainEntry)
+		{
+			m_stream << "Entry [label=\"Entry\"];\n";
+			m_stream << "Entry -> Block" << getBlockId(_block) << ";\n";
+		}
+		while (!m_blocksToPrint.empty())
+		{
+			CFG::BasicBlock const* block = *m_blocksToPrint.begin();
+			m_blocksToPrint.erase(m_blocksToPrint.begin());
+			printBlock(*block);
+		}
+
+	}
+	void operator()(
+		CFG::FunctionInfo const& _info
+	)
+	{
+		m_stream << "FunctionEntry_" << _info.function.name.str() << "_" << getBlockId(*_info.entry) << " [label=\"";
+		m_stream << "function " << _info.function.name.str() << "(";
+		m_stream << joinHumanReadable(_info.parameters | ranges::views::transform(variableSlotToString));
+		m_stream << ")";
+		if (!_info.returnVariables.empty())
+		{
+			m_stream << " -> ";
+			m_stream << joinHumanReadable(_info.returnVariables | ranges::views::transform(variableSlotToString));
+		}
+		m_stream << "\"];\n";
+		m_stream << "FunctionEntry_" << _info.function.name.str() << "_" << getBlockId(*_info.entry) << " -> Block" << getBlockId(*_info.entry) << ";\n";
+		(*this)(*_info.entry, false);
+	}
+
+private:
+	void printBlock(CFG::BasicBlock const& _block)
+	{
+		m_stream << "Block" << getBlockId(_block) << " [label=\"\\\n";
+
+		// Verify that the entries of this block exit into this block.
+		for (auto const& entry: _block.entries)
+			std::visit(util::GenericVisitor{
+				[&](CFG::BasicBlock::Jump const& _jump)
+				{
+					soltestAssert(_jump.target == &_block, "Invalid control flow graph.");
+				},
+				[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+				{
+					soltestAssert(
+						_conditionalJump.zero == &_block || _conditionalJump.nonZero == &_block,
+						"Invalid control flow graph."
+					);
+				},
+				[&](auto const&)
+				{
+					soltestAssert(false, "Invalid control flow graph.");
+				}
+			}, entry->exit);
+
+		for (auto const& operation: _block.operations)
+		{
+			std::visit(util::GenericVisitor{
+				[&](CFG::FunctionCall const& _call) {
+					m_stream << _call.function.get().name.str() << ": ";
+				},
+				[&](CFG::BuiltinCall const& _call) {
+					m_stream << _call.functionCall.get().functionName.name.str() << ": ";
+
+				},
+				[&](CFG::Assignment const& _assignment) {
+					m_stream << "Assignment(";
+					m_stream << joinHumanReadable(_assignment.variables | ranges::views::transform(variableSlotToString));
+					m_stream << "): ";
+				}
+			}, operation.operation);
+			m_stream << stackToString(operation.input) << " => " << stackToString(operation.output) << "\\l\\\n";
+		}
+		m_stream << "\"];\n";
+		std::visit(util::GenericVisitor{
+			[&](CFG::BasicBlock::MainExit const&)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"MainExit\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			},
+			[&](CFG::BasicBlock::Jump const& _jump)
+			{
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit [arrowhead=none];\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"";
+				if (_jump.backwards)
+					m_stream << "Backwards";
+				m_stream << "Jump\" shape=oval];\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit -> Block" << getBlockId(*_jump.target) << ";\n";
+			},
+			[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+			{
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"{ ";
+				m_stream << stackSlotToString(_conditionalJump.condition);
+				m_stream << "| { <0> Zero | <1> NonZero }}\" shape=Mrecord];\n";
+				m_stream << "Block" << getBlockId(_block);
+				m_stream << "Exit:0 -> Block" << getBlockId(*_conditionalJump.zero) << ";\n";
+				m_stream << "Block" << getBlockId(_block);
+				m_stream << "Exit:1 -> Block" << getBlockId(*_conditionalJump.nonZero) << ";\n";
+			},
+			[&](CFG::BasicBlock::FunctionReturn const& _return)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"FunctionReturn[" << _return.info->function.name.str() << "]\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			},
+			[&](CFG::BasicBlock::Terminated const&)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"Terminated\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			}
+		}, _block.exit);
+		m_stream << "\n";
+	}
+	size_t getBlockId(CFG::BasicBlock const& _block)
+	{
+		if (size_t* id = util::valueOrNullptr(m_blockIds, &_block))
+			return *id;
+		size_t id = m_blockIds[&_block] = m_blockCount++;
+		m_blocksToPrint.emplace_back(&_block);
+		return id;
+	}
+	std::ostream& m_stream;
+	std::map<CFG::BasicBlock const*, size_t> m_blockIds;
+	size_t m_blockCount = 0;
+	std::list<CFG::BasicBlock const*> m_blocksToPrint;
+};
+
+TestCase::TestResult ControlFlowGraphTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	ErrorList errors;
+	auto [object, analysisInfo] = parse(m_source, *m_dialect, errors);
+	if (!object || !analysisInfo || Error::containsErrors(errors))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		return TestResult::FatalError;
+	}
+
+	std::ostringstream output;
+
+	std::unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(*analysisInfo, *m_dialect, *object->code);
+
+	output << "digraph CFG {\nnodesep=0.7;\nnode[shape=box];\n\n";
+	ControlFlowGraphPrinter printer{output};
+	printer(*cfg->entry);
+	for (auto function: cfg->functions)
+		printer(cfg->functionInfo.at(function));
+	output << "}\n";
+
+	m_obtainedResult = output.str();
+
+	auto result = checkResult(_stream, _linePrefix, _formatted);
+
+#ifdef ISOLTEST
+	char* graphDisplayer = nullptr;
+	// The environment variables specify an optional command that will receive the graph encoded in DOT through stdin.
+	// Examples for suitable commands are ``dot -Tx11:cairo`` or ``xdot -``.
+	if (result == TestResult::Failure)
+		// ISOLTEST_DISPLAY_GRAPHS_ON_FAILURE_COMMAND will run on all failing tests (intended for use during modifications).
+		graphDisplayer = getenv("ISOLTEST_DISPLAY_GRAPHS_ON_FAILURE_COMMAND");
+	else if (result == TestResult::Success)
+		// ISOLTEST_DISPLAY_GRAPHS_ON_FAILURE_COMMAND will run on all succeeding tests (intended for use during reviews).
+		graphDisplayer = getenv("ISOLTEST_DISPLAY_GRAPHS_ON_SUCCESS_COMMAND");
+
+	if (graphDisplayer)
+	{
+		if (result == TestResult::Success)
+			std::cout << std::endl << m_source << std::endl;
+		boost::process::opstream pipe;
+		boost::process::child child(graphDisplayer, boost::process::std_in < pipe);
+
+		pipe << output.str();
+		pipe.flush();
+		pipe.pipe().close();
+		if (result == TestResult::Success)
+			child.wait();
+		else
+			child.detach();
+	}
+#endif
+
+	return result;
+
+}
diff --git a/compiler/test/libyul/ControlFlowSideEffectsTest.cpp b/compiler/test/libyul/ControlFlowSideEffectsTest.cpp
new file mode 100644
index 00000000..6ac5a7b0
--- /dev/null
+++ b/compiler/test/libyul/ControlFlowSideEffectsTest.cpp
@@ -0,0 +1,75 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/ControlFlowSideEffectsTest.h>
+
+#include <test/Common.h>
+#include <test/libyul/Common.h>
+
+#include <libyul/Object.h>
+#include <libyul/AST.h>
+#include <libyul/ControlFlowSideEffects.h>
+#include <libyul/ControlFlowSideEffectsCollector.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend::test;
+
+namespace
+{
+std::string toString(ControlFlowSideEffects const& _sideEffects)
+{
+	std::vector<std::string> r;
+	if (_sideEffects.canTerminate)
+		r.emplace_back("can terminate");
+	if (_sideEffects.canRevert)
+		r.emplace_back("can revert");
+	if (_sideEffects.canContinue)
+		r.emplace_back("can continue");
+	return util::joinHumanReadable(r);
+}
+}
+
+ControlFlowSideEffectsTest::ControlFlowSideEffectsTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult ControlFlowSideEffectsTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	Object obj;
+	std::tie(obj.code, obj.analysisInfo) = yul::test::parse(m_source, false);
+	if (!obj.code)
+		BOOST_THROW_EXCEPTION(std::runtime_error("Parsing input failed."));
+
+	ControlFlowSideEffectsCollector sideEffects(
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		*obj.code
+	);
+	m_obtainedResult.clear();
+	forEach<FunctionDefinition const>(*obj.code, [&](FunctionDefinition const& _fun) {
+		std::string effectStr = toString(sideEffects.functionSideEffects().at(&_fun));
+		m_obtainedResult += _fun.name.str() + (effectStr.empty() ? ":" : ": " + effectStr) + "\n";
+	});
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libyul/EVMCodeTransformTest.cpp b/compiler/test/libyul/EVMCodeTransformTest.cpp
new file mode 100644
index 00000000..4c2eecab
--- /dev/null
+++ b/compiler/test/libyul/EVMCodeTransformTest.cpp
@@ -0,0 +1,85 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/EVMCodeTransformTest.h>
+#include <test/libyul/Common.h>
+
+#include <test/Common.h>
+
+#include <libyul/YulStack.h>
+#include <libyul/backends/evm/EthAssemblyAdapter.h>
+#include <libyul/backends/evm/EVMObjectCompiler.h>
+
+#include <libevmasm/Assembly.h>
+
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolutil/AnsiColorized.h>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+EVMCodeTransformTest::EVMCodeTransformTest(std::string const& _filename):
+	EVMVersionRestrictedTestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_stackOpt = m_reader.boolSetting("stackOptimization", false);
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult EVMCodeTransformTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	solidity::frontend::OptimiserSettings settings = solidity::frontend::OptimiserSettings::none();
+	settings.runYulOptimiser = false;
+	settings.optimizeStackAllocation = m_stackOpt;
+	YulStack stack(
+		EVMVersion{},
+		std::nullopt,
+		YulStack::Language::StrictAssembly,
+		settings,
+		DebugInfoSelection::All()
+	);
+	if (!stack.parseAndAnalyze("", m_source))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		SourceReferenceFormatter{_stream, stack, true, false}
+			.printErrorInformation(stack.errors());
+		return TestResult::FatalError;
+	}
+
+	evmasm::Assembly assembly{solidity::test::CommonOptions::get().evmVersion(), false, {}};
+	EthAssemblyAdapter adapter(assembly);
+	EVMObjectCompiler::compile(
+		*stack.parserResult(),
+		adapter,
+		EVMDialect::strictAssemblyForEVMObjects(EVMVersion{}),
+		m_stackOpt,
+		std::nullopt
+	);
+
+	std::ostringstream output;
+	output << assembly;
+	m_obtainedResult = output.str();
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libyul/EVMCodeTransformTest.h b/compiler/test/libyul/EVMCodeTransformTest.h
new file mode 100644
index 00000000..9926d43a
--- /dev/null
+++ b/compiler/test/libyul/EVMCodeTransformTest.h
@@ -0,0 +1,39 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+
+namespace solidity::yul::test
+{
+
+class EVMCodeTransformTest: public solidity::frontend::test::EVMVersionRestrictedTestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<EVMCodeTransformTest>(_config.filename);
+	}
+	explicit EVMCodeTransformTest(std::string const& _filename);
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+private:
+	bool m_stackOpt = false;
+};
+
+}
diff --git a/compiler/test/libyul/FunctionSideEffects.cpp b/compiler/test/libyul/FunctionSideEffects.cpp
new file mode 100644
index 00000000..a57ec980
--- /dev/null
+++ b/compiler/test/libyul/FunctionSideEffects.cpp
@@ -0,0 +1,104 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/FunctionSideEffects.h>
+#include <test/Common.h>
+#include <test/libyul/Common.h>
+
+#include <libsolutil/AnsiColorized.h>
+
+#include <libyul/SideEffects.h>
+#include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/optimiser/Semantics.h>
+#include <libyul/Object.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <libsolutil/StringUtils.h>
+
+#include <boost/algorithm/string.hpp>
+
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+namespace
+{
+std::string toString(SideEffects const& _sideEffects)
+{
+	std::vector<std::string> ret;
+	if (_sideEffects.movable)
+		ret.emplace_back("movable");
+	if (_sideEffects.movableApartFromEffects)
+		ret.emplace_back("movable apart from effects");
+	if (_sideEffects.canBeRemoved)
+		ret.emplace_back("can be removed");
+	if (_sideEffects.canBeRemovedIfNoMSize)
+		ret.emplace_back("can be removed if no msize");
+	if (!_sideEffects.cannotLoop)
+		ret.emplace_back("can loop");
+	if (_sideEffects.otherState == SideEffects::Write)
+		ret.emplace_back("writes other state");
+	else if (_sideEffects.otherState == SideEffects::Read)
+		ret.emplace_back("reads other state");
+	if (_sideEffects.storage == SideEffects::Write)
+		ret.emplace_back("writes storage");
+	else if (_sideEffects.storage == SideEffects::Read)
+		ret.emplace_back("reads storage");
+	if (_sideEffects.memory == SideEffects::Write)
+		ret.emplace_back("writes memory");
+	else if (_sideEffects.memory == SideEffects::Read)
+		ret.emplace_back("reads memory");
+
+	return joinHumanReadable(ret);
+}
+}
+
+FunctionSideEffects::FunctionSideEffects(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult FunctionSideEffects::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	Object obj;
+	std::tie(obj.code, obj.analysisInfo) = yul::test::parse(m_source, false);
+	if (!obj.code)
+		BOOST_THROW_EXCEPTION(std::runtime_error("Parsing input failed."));
+
+	std::map<YulString, SideEffects> functionSideEffects = SideEffectsPropagator::sideEffects(
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		CallGraphGenerator::callGraph(*obj.code)
+	);
+
+	std::map<std::string, std::string> functionSideEffectsStr;
+	for (auto const& fun: functionSideEffects)
+		functionSideEffectsStr[fun.first.str()] = toString(fun.second);
+
+	m_obtainedResult.clear();
+	for (auto const& fun: functionSideEffectsStr)
+		m_obtainedResult += fun.first + ":" + (fun.second.empty() ? "" : " ") + fun.second + "\n";
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libyul/Inliner.cpp b/compiler/test/libyul/Inliner.cpp
new file mode 100644
index 00000000..6f622b41
--- /dev/null
+++ b/compiler/test/libyul/Inliner.cpp
@@ -0,0 +1,109 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * @date 2017
+ * Unit tests for the Yul function inliner.
+ */
+
+#include <test/libyul/Common.h>
+
+#include <libyul/optimiser/ExpressionInliner.h>
+#include <libyul/optimiser/InlinableExpressionFunctionFinder.h>
+#include <libyul/optimiser/FullInliner.h>
+#include <libyul/optimiser/FunctionHoister.h>
+#include <libyul/optimiser/FunctionGrouper.h>
+#include <libyul/AST.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/algorithm/string/join.hpp>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+namespace
+{
+std::string inlinableFunctions(std::string const& _source)
+{
+	auto ast = disambiguate(_source);
+
+	InlinableExpressionFunctionFinder funFinder;
+	funFinder(ast);
+
+	std::vector<std::string> functionNames;
+	for (auto const& f: funFinder.inlinableFunctions())
+		functionNames.emplace_back(f.first.str());
+	return boost::algorithm::join(functionNames, ",");
+}
+
+}
+
+
+BOOST_AUTO_TEST_SUITE(YulInlinableFunctionFilter)
+
+BOOST_AUTO_TEST_CASE(smoke_test)
+{
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ }"), "");
+}
+
+BOOST_AUTO_TEST_CASE(simple)
+{
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256 { x := 2:u256 } }"), "f");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{"
+		"function g(a:u256) -> b:u256 { b := a }"
+		"function f() -> x:u256 { x := g(2:u256) }"
+	"}"), "g,f");
+}
+
+BOOST_AUTO_TEST_CASE(simple_inside_structures)
+{
+	BOOST_CHECK_EQUAL(inlinableFunctions("{"
+		"switch 2:u256 "
+		"case 2:u256 {"
+			"function g(a:u256) -> b:u256 { b := a }"
+			"function f() -> x:u256 { x := g(2:u256) }"
+		"}"
+	"}"), "g,f");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{"
+		"function g(a:u256) -> b:u256 { b := a }"
+		"for {"
+		"} true {"
+			"function f() -> x:u256 { x := g(2:u256) }"
+		"}"
+		"{"
+			"function h() -> y:u256 { y := 2:u256 }"
+		"}"
+	"}"), "h,g,f");
+}
+
+BOOST_AUTO_TEST_CASE(negative)
+{
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256 { } }"), "");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256 { x := 2:u256 {} } }"), "");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256 { x := f() } }"), "");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256 { x := x } }"), "");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f() -> x:u256, y:u256 { x := 2:u256 } }"), "");
+  BOOST_CHECK_EQUAL(inlinableFunctions(
+    "{ function g() -> x:u256, y:u256 {} function f(y:u256) -> x:u256 { x,y := g() } }"), "");
+	BOOST_CHECK_EQUAL(inlinableFunctions("{ function f(y:u256) -> x:u256 { y := 2:u256 } }"), "");
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/compiler/test/libyul/KnowledgeBaseTest.cpp b/compiler/test/libyul/KnowledgeBaseTest.cpp
new file mode 100644
index 00000000..b1dd0e6d
--- /dev/null
+++ b/compiler/test/libyul/KnowledgeBaseTest.cpp
@@ -0,0 +1,132 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for KnowledgeBase
+ */
+
+#include <test/Common.h>
+
+#include <test/libyul/Common.h>
+
+#include <libyul/Object.h>
+#include <libyul/optimiser/KnowledgeBase.h>
+#include <libyul/optimiser/SSAValueTracker.h>
+#include <libyul/optimiser/NameDispenser.h>
+#include <libyul/optimiser/CommonSubexpressionEliminator.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <liblangutil/ErrorReporter.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+
+namespace solidity::yul::test
+{
+
+class KnowledgeBaseTest
+{
+protected:
+	KnowledgeBase constructKnowledgeBase(std::string const& _source)
+	{
+		ErrorList errorList;
+		std::shared_ptr<AsmAnalysisInfo> analysisInfo;
+		std::tie(m_object, analysisInfo) = yul::test::parse(_source, m_dialect, errorList);
+		BOOST_REQUIRE(m_object && errorList.empty() && m_object->code);
+
+		NameDispenser dispenser(m_dialect, *m_object->code);
+		std::set<YulString> reserved;
+		OptimiserStepContext context{m_dialect, dispenser, reserved, 0};
+		CommonSubexpressionEliminator::run(context, *m_object->code);
+
+		m_ssaValues(*m_object->code);
+		for (auto const& [name, expression]: m_ssaValues.values())
+			m_values[name].value = expression;
+
+		return KnowledgeBase([this](YulString _var) { return util::valueOrNullptr(m_values, _var); });
+	}
+
+	EVMDialect m_dialect{EVMVersion{}, true};
+	std::shared_ptr<Object> m_object;
+	SSAValueTracker m_ssaValues;
+	std::map<YulString, AssignedValue> m_values;
+};
+
+BOOST_FIXTURE_TEST_SUITE(KnowledgeBase, KnowledgeBaseTest)
+
+BOOST_AUTO_TEST_CASE(basic)
+{
+	yul::KnowledgeBase kb = constructKnowledgeBase(R"({
+		let a := calldataload(0)
+		let b := calldataload(0)
+		let zero := 0
+		let c := add(b, 0)
+		let d := mul(b, 0)
+		let e := sub(a, b)
+	})");
+
+	BOOST_CHECK(!kb.knownToBeDifferent("a"_yulstring, "b"_yulstring));
+	// This only works if the variable names are the same.
+	// It assumes that SSA+CSE+Simplifier actually replaces the variables.
+	BOOST_CHECK(!kb.valueIfKnownConstant("a"_yulstring));
+	BOOST_CHECK(kb.valueIfKnownConstant("zero"_yulstring) == u256(0));
+	BOOST_CHECK(kb.differenceIfKnownConstant("a"_yulstring, "b"_yulstring) == u256(0));
+	BOOST_CHECK(kb.differenceIfKnownConstant("a"_yulstring, "c"_yulstring) == u256(0));
+	BOOST_CHECK(kb.valueIfKnownConstant("e"_yulstring) == u256(0));
+}
+
+BOOST_AUTO_TEST_CASE(difference)
+{
+	yul::KnowledgeBase kb = constructKnowledgeBase(R"({
+		let a := calldataload(0)
+		let b := add(a, 200)
+		let c := add(a, 220)
+		let d := add(12, c)
+		let e := sub(c, 12)
+	})");
+
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("c"_yulstring, "b"_yulstring) ==
+		u256(20)
+	);
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("b"_yulstring, "c"_yulstring) ==
+		u256(-20)
+	);
+	BOOST_CHECK(!kb.knownToBeDifferentByAtLeast32("b"_yulstring, "c"_yulstring));
+	BOOST_CHECK(kb.knownToBeDifferentByAtLeast32("b"_yulstring, "d"_yulstring));
+	BOOST_CHECK(kb.knownToBeDifferentByAtLeast32("a"_yulstring, "b"_yulstring));
+	BOOST_CHECK(kb.knownToBeDifferentByAtLeast32("b"_yulstring, "a"_yulstring));
+
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("e"_yulstring, "a"_yulstring) == u256(208)
+	);
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("e"_yulstring, "b"_yulstring) == u256(8)
+	);
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("a"_yulstring, "e"_yulstring) == u256(-208)
+	);
+	BOOST_CHECK(
+		kb.differenceIfKnownConstant("b"_yulstring, "e"_yulstring) == u256(-8)
+	);
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libyul/Metrics.cpp b/compiler/test/libyul/Metrics.cpp
new file mode 100644
index 00000000..ac315343
--- /dev/null
+++ b/compiler/test/libyul/Metrics.cpp
@@ -0,0 +1,382 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Unit tests for the code metrics.
+ */
+
+#include <test/Common.h>
+
+#include <test/libyul/Common.h>
+
+#include <libyul/optimiser/Metrics.h>
+#include <libyul/AST.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace solidity::langutil;
+
+namespace solidity::yul::test
+{
+
+namespace
+{
+
+size_t codeSize(std::string const& _source, CodeWeights const _weights = {})
+{
+	std::shared_ptr<Block> ast = parse(_source, false).first;
+	BOOST_REQUIRE(ast);
+	return CodeSize::codeSize(*ast, _weights);
+}
+
+}
+
+class CustomWeightFixture
+{
+protected:
+	CodeWeights m_weights{
+		/* expressionStatementCost = */ 1,
+		/* assignmentCost = */ 2,
+		/* variableDeclarationCost = */ 3,
+		/* functionDefinitionCost = */ 4,
+		/* ifCost = */ 5,
+		/* switchCost = */ 6,
+		/* caseCost = */ 7,
+		/* forLoopCost = */ 8,
+		/* breakCost = */ 9,
+		/* continueCost = */ 10,
+		/* leaveCost = */ 11,
+		/* blockCost = */ 12,
+
+		/* functionCallCost = */ 13,
+		/* identifierCost = */ 14,
+		/* literalCost = */ 15,
+	};
+};
+
+BOOST_AUTO_TEST_SUITE(YulCodeSize)
+
+BOOST_AUTO_TEST_CASE(empty_code)
+{
+	BOOST_CHECK_EQUAL(codeSize("{}"), 0);
+}
+
+BOOST_FIXTURE_TEST_CASE(empty_code_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(codeSize("{}", m_weights), 0);
+}
+
+BOOST_AUTO_TEST_CASE(nested_blocks)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ {} {} {{ }} }"), 0);
+}
+
+BOOST_FIXTURE_TEST_CASE(nested_blocks_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ {} {} {{ }} }", m_weights), 4 * m_weights.blockCost);
+}
+
+BOOST_AUTO_TEST_CASE(instruction)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ pop(calldatasize()) }"), 2);
+}
+
+BOOST_FIXTURE_TEST_CASE(instruction_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ pop(calldatasize()) }", m_weights),
+		2 * m_weights.functionCallCost +
+		1 * m_weights.expressionStatementCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(variables_are_free)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ let x let y let a, b, c }"), 0);
+}
+
+BOOST_FIXTURE_TEST_CASE(variables_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ let x let y let a, b, c }", m_weights),
+		3 * m_weights.variableDeclarationCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(constants_cost_one)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ let x := 3 }"), 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(constants_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ let x := 3 }", m_weights),
+		1 * m_weights.variableDeclarationCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(functions_are_skipped)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ function f(x) -> r { r := mload(x) } }"), 0);
+}
+
+BOOST_FIXTURE_TEST_CASE(functions_are_skipped_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ function f(x) -> r { r := mload(x) } }", m_weights), 0);
+}
+
+BOOST_AUTO_TEST_CASE(function_with_arguments)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ function f(x) { sstore(x, 2) } f(2) }"), 2);
+}
+
+BOOST_FIXTURE_TEST_CASE(function_with_arguments_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ function f(x) { sstore(x, 2) } f(2) }", m_weights),
+		1 * m_weights.expressionStatementCost +
+		1 * m_weights.functionCallCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(function_with_variables_as_arguments)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ function f(x) { sstore(x, 2) } let y f(y) }"), 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(function_with_variables_as_arguments_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ function f(x) { sstore(x, 2) } let y f(y) }", m_weights),
+		1 * m_weights.variableDeclarationCost +
+		1 * m_weights.expressionStatementCost +
+		1 * m_weights.functionCallCost +
+		1 * m_weights.identifierCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(function_with_variables_and_constants_as_arguments)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ function f(x, r) -> z { sstore(x, r) z := r } let y let t := f(y, 2) }"
+	), 2);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+	function_with_variables_and_constants_as_arguments_custom_weights,
+	CustomWeightFixture
+)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize(
+			"{ function f(x, r) -> z { sstore(x, r) z := r } let y let t := f(y, 2) }",
+			m_weights
+		),
+		2 * m_weights.variableDeclarationCost +
+		1 * m_weights.functionCallCost +
+		1 * m_weights.identifierCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(assignment)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ let a a := 3 }"), 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(assignment_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ let a a := 3 }", m_weights),
+		1 * m_weights.variableDeclarationCost +
+		1 * m_weights.assignmentCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(assignments_between_vars_are_free)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ let a let b := a a := b }"), 0);
+}
+
+BOOST_FIXTURE_TEST_CASE(assignments_between_vars_are_free_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ let a let b := a a := b }", m_weights),
+		2 * m_weights.variableDeclarationCost +
+		1 * m_weights.assignmentCost +
+		2 * m_weights.identifierCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(assignment_complex)
+{
+	BOOST_CHECK_EQUAL(codeSize("{ let a let x := mload(a) a := sload(x) }"), 2);
+}
+
+BOOST_FIXTURE_TEST_CASE(assignment_complex_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ let a let x := mload(a) a := sload(x) }", m_weights),
+		2 * m_weights.variableDeclarationCost +
+		1 * m_weights.assignmentCost +
+		2 * m_weights.identifierCost +
+		2 * m_weights.functionCallCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(empty_for_loop)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ for {} 1 {} {} }"
+	), 4);
+}
+
+BOOST_FIXTURE_TEST_CASE(empty_for_loop_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ for {} 1 {} {} }", m_weights),
+		1 * m_weights.forLoopCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(break_statement)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ for {} 1 {} { break } }"
+	), 6);
+}
+
+BOOST_FIXTURE_TEST_CASE(break_statement_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ for {} 1 {} { break } }", m_weights),
+		1 * m_weights.forLoopCost +
+		1 * m_weights.literalCost +
+		1 * m_weights.breakCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(continue_statement)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ for {} 1 {} { continue } }"
+	), 6);
+}
+
+BOOST_FIXTURE_TEST_CASE(continue_statement_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ for {} 1 {} { continue } }", m_weights),
+		1 * m_weights.forLoopCost +
+		1 * m_weights.literalCost +
+		1 * m_weights.continueCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(regular_for_loop)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ for { let x := 0 } lt(x, 10) { x := add(x, 1) } { mstore(x, 1) } }"
+	), 9);
+}
+
+BOOST_FIXTURE_TEST_CASE(regular_for_loop_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ for { let x := 0 } lt(x, 10) { x := add(x, 1) } { mstore(x, 1) } }", m_weights),
+		1 * m_weights.forLoopCost +
+		1 * m_weights.variableDeclarationCost +
+		1 * m_weights.assignmentCost +
+		3 * m_weights.functionCallCost +
+		3 * m_weights.literalCost +
+		1 * m_weights.literalZeroCost +
+		3 * m_weights.identifierCost +
+		1 * m_weights.expressionStatementCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(if_statement)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ if 1 {} }"
+	), 3);
+}
+
+BOOST_FIXTURE_TEST_CASE(if_statement_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ if 1 {} }", m_weights),
+		1 * m_weights.ifCost +
+		1 * m_weights.literalCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(switch_statement_tiny)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ switch calldatasize() case 0 {} }"
+	), 4);
+}
+
+BOOST_AUTO_TEST_CASE(switch_statement_small)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ switch calldatasize() case 0 {} default {} }"
+	), 6);
+}
+
+BOOST_FIXTURE_TEST_CASE(switch_statement_small_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ switch calldatasize() case 0 {} default {} }", m_weights),
+		1 * m_weights.functionCallCost +
+		1 * m_weights.switchCost +
+		2 * m_weights.caseCost
+	);
+}
+
+BOOST_AUTO_TEST_CASE(switch_statement_medium)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ switch calldatasize() case 0 {} case 1 {} case 2 {} }"
+	), 8);
+}
+
+BOOST_AUTO_TEST_CASE(switch_statement_large)
+{
+	BOOST_CHECK_EQUAL(codeSize(
+		"{ switch calldatasize() case 0 {} case 1 {} case 2 {} default {} }"
+	), 10);
+}
+
+BOOST_FIXTURE_TEST_CASE(switch_statement_large_custom_weights, CustomWeightFixture)
+{
+	BOOST_CHECK_EQUAL(
+		codeSize("{ switch calldatasize() case 0 {} case 1 {} case 2 {} default {} }", m_weights),
+		1 * m_weights.functionCallCost +
+		1 * m_weights.switchCost +
+		4 * m_weights.caseCost
+	);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libyul/ObjectCompilerTest.cpp b/compiler/test/libyul/ObjectCompilerTest.cpp
new file mode 100644
index 00000000..65ff18a7
--- /dev/null
+++ b/compiler/test/libyul/ObjectCompilerTest.cpp
@@ -0,0 +1,100 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/ObjectCompilerTest.h>
+
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <test/Common.h>
+
+#include <libsolutil/AnsiColorized.h>
+
+#include <libyul/YulStack.h>
+
+#include <libevmasm/Instruction.h>
+#include <libevmasm/Disassemble.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <fstream>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+ObjectCompilerTest::ObjectCompilerTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_optimisationPreset = m_reader.enumSetting<OptimisationPreset>(
+		"optimizationPreset",
+		{
+			{"none", OptimisationPreset::None},
+			{"minimal", OptimisationPreset::Minimal},
+			{"standard", OptimisationPreset::Standard},
+			{"full", OptimisationPreset::Full},
+		},
+		"minimal"
+	);
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult ObjectCompilerTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	YulStack stack(
+		EVMVersion(),
+		std::nullopt,
+		YulStack::Language::StrictAssembly,
+		OptimiserSettings::preset(m_optimisationPreset),
+		DebugInfoSelection::All()
+	);
+	if (!stack.parseAndAnalyze("source", m_source))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		SourceReferenceFormatter{_stream, stack, true, false}
+			.printErrorInformation(stack.errors());
+		return TestResult::FatalError;
+	}
+	stack.optimize();
+
+	MachineAssemblyObject obj = stack.assemble(YulStack::Machine::EVM);
+	solAssert(obj.bytecode, "");
+	solAssert(obj.sourceMappings, "");
+
+	m_obtainedResult = "Assembly:\n" + obj.assembly;
+	if (obj.bytecode->bytecode.empty())
+		m_obtainedResult += "-- empty bytecode --\n";
+	else
+		m_obtainedResult +=
+			"Bytecode: " +
+			util::toHex(obj.bytecode->bytecode) +
+			"\nOpcodes: " +
+			boost::trim_copy(evmasm::disassemble(obj.bytecode->bytecode, solidity::test::CommonOptions::get().evmVersion())) +
+			"\nSourceMappings:" +
+			(obj.sourceMappings->empty() ? "" : " " + *obj.sourceMappings) +
+			"\n";
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libyul/ObjectCompilerTest.h b/compiler/test/libyul/ObjectCompilerTest.h
new file mode 100644
index 00000000..fe899870
--- /dev/null
+++ b/compiler/test/libyul/ObjectCompilerTest.h
@@ -0,0 +1,60 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+
+namespace solidity::langutil
+{
+class Scanner;
+class Error;
+using ErrorList = std::vector<std::shared_ptr<Error const>>;
+}
+
+namespace solidity::yul
+{
+struct AsmAnalysisInfo;
+struct Block;
+}
+
+namespace solidity::yul::test
+{
+
+class ObjectCompilerTest: public solidity::frontend::test::TestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<ObjectCompilerTest>(_config.filename);
+	}
+
+	explicit ObjectCompilerTest(std::string const& _filename);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+
+private:
+	bool parse(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted);
+	void disambiguate();
+
+	frontend::OptimisationPreset m_optimisationPreset;
+};
+
+}
diff --git a/compiler/test/libyul/ObjectParser.cpp b/compiler/test/libyul/ObjectParser.cpp
new file mode 100644
index 00000000..d9623384
--- /dev/null
+++ b/compiler/test/libyul/ObjectParser.cpp
@@ -0,0 +1,288 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @date 2018
+ * Unit tests for the Yul object parser.
+ */
+
+#include <test/Common.h>
+
+#include <test/libsolidity/ErrorCheck.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/Scanner.h>
+
+#include <libyul/YulStack.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <range/v3/view/iota.hpp>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <sstream>
+
+using namespace solidity::frontend;
+using namespace solidity::langutil;
+using namespace std::string_literals;
+
+namespace solidity::yul::test
+{
+
+namespace
+{
+
+std::pair<bool, ErrorList> parse(std::string const& _source)
+{
+	try
+	{
+		YulStack asmStack(
+			solidity::test::CommonOptions::get().evmVersion(),
+			solidity::test::CommonOptions::get().eofVersion(),
+			YulStack::Language::StrictAssembly,
+			solidity::frontend::OptimiserSettings::none(),
+			DebugInfoSelection::All()
+		);
+		bool success = asmStack.parseAndAnalyze("source", _source);
+		return {success, asmStack.errors()};
+	}
+	catch (FatalError const&)
+	{
+		BOOST_FAIL("Fatal error leaked.");
+	}
+	return {false, {}};
+}
+
+std::optional<Error> parseAndReturnFirstError(std::string const& _source, bool _allowWarningsAndInfos = true)
+{
+	bool success;
+	ErrorList errors;
+	tie(success, errors) = parse(_source);
+	if (!success)
+	{
+		BOOST_REQUIRE_EQUAL(errors.size(), 1);
+		return *errors.front();
+	}
+	else
+	{
+		// If success is true, there might still be an error in the assembly stage.
+		if (_allowWarningsAndInfos && !Error::containsErrors(errors))
+			return {};
+		else if (!errors.empty())
+		{
+			if (!_allowWarningsAndInfos)
+				BOOST_CHECK_EQUAL(errors.size(), 1);
+			return *errors.front();
+		}
+	}
+	return {};
+}
+
+bool successParse(std::string const& _source, bool _allowWarningsAndInfos = true)
+{
+	return !parseAndReturnFirstError(_source, _allowWarningsAndInfos);
+}
+
+Error expectError(std::string const& _source, bool _allowWarningsAndInfos = false)
+{
+
+	auto error = parseAndReturnFirstError(_source, _allowWarningsAndInfos);
+	BOOST_REQUIRE(error);
+	return *error;
+}
+
+std::tuple<std::optional<SourceNameMap>, ErrorList> tryGetSourceLocationMapping(std::string _source)
+{
+	std::vector<std::string> lines;
+	boost::split(lines, _source, boost::is_any_of("\n"));
+	std::string source = util::joinHumanReadablePrefixed(lines, "\n///") + "\n{}\n";
+
+	ErrorList errors;
+	ErrorReporter reporter(errors);
+	Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(EVMVersion::berlin());
+	ObjectParser objectParser{reporter, dialect};
+	CharStream stream(std::move(source), "");
+	auto object = objectParser.parse(std::make_shared<Scanner>(stream), false);
+	BOOST_REQUIRE(object && object->debugData);
+	return {object->debugData->sourceNames, std::move(errors)};
+}
+
+}
+
+#define CHECK_ERROR(text, typ, substring) \
+do \
+{ \
+	Error err = expectError((text), false); \
+	BOOST_CHECK(err.type() == (Error::Type::typ)); \
+	BOOST_CHECK(::solidity::frontend::test::searchErrorMessage(err, (substring))); \
+} while(0)
+
+BOOST_AUTO_TEST_SUITE(YulObjectParser)
+
+BOOST_AUTO_TEST_CASE(empty_code)
+{
+	BOOST_CHECK(successParse("{ }"));
+}
+
+BOOST_AUTO_TEST_CASE(recursion_depth)
+{
+	std::string input;
+	for (size_t i = 0; i < 20000; i++)
+		input += "object \"a" + std::to_string(i) + "\" { code {} ";
+	for (size_t i = 0; i < 20000; i++)
+		input += "}";
+
+	CHECK_ERROR(input, ParserError, "recursion");
+}
+
+BOOST_AUTO_TEST_CASE(to_string)
+{
+	std::string code = R"(
+		object "O" {
+			code { let x := mload(0) if x { sstore(0, 1) } }
+			object "i" { code {} data "j" "def" }
+			data "j" "abc"
+			data "k" hex"010203"
+		}
+	)";
+	std::string expectation = R"(object "O" {
+	code {
+		let x := mload(0)
+		if x { sstore(0, 1) }
+	}
+	object "i" {
+		code { }
+		data "j" hex"646566"
+	}
+	data "j" hex"616263"
+	data "k" hex"010203"
+}
+)";
+	expectation = boost::replace_all_copy(expectation, "\t", "    ");
+	YulStack asmStack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::none(),
+		DebugInfoSelection::All()
+	);
+	BOOST_REQUIRE(asmStack.parseAndAnalyze("source", code));
+	BOOST_CHECK_EQUAL(asmStack.print(), expectation);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_empty)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping("");
+	BOOST_REQUIRE(!mapping);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_simple)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping(R"(@use-src 0:"contract.sol")");
+	BOOST_REQUIRE(mapping.has_value());
+	BOOST_REQUIRE_EQUAL(mapping->size(), 1);
+	BOOST_REQUIRE_EQUAL(*mapping->at(0), "contract.sol");
+}
+
+BOOST_AUTO_TEST_CASE(use_src_multiple)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping(R"(@use-src 0:"contract.sol", 1:"misc.yul")");
+	BOOST_REQUIRE(mapping);
+	BOOST_REQUIRE_EQUAL(mapping->size(), 2);
+	BOOST_REQUIRE_EQUAL(*mapping->at(0), "contract.sol");
+	BOOST_REQUIRE_EQUAL(*mapping->at(1), "misc.yul");
+}
+
+BOOST_AUTO_TEST_CASE(use_src_escaped_filenames)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping(
+		R"(@use-src 42:"con\"tract@\".sol")"
+	);
+	BOOST_REQUIRE(mapping);
+	BOOST_REQUIRE_EQUAL(mapping->size(), 1);
+	BOOST_REQUIRE(mapping->count(42));
+	BOOST_REQUIRE_EQUAL(*mapping->at(42), "con\"tract@\".sol");
+}
+
+BOOST_AUTO_TEST_CASE(use_src_invalid_syntax_malformed_param_1)
+{
+	// open quote arg, missing closing quote
+	auto const [mapping, errors] = tryGetSourceLocationMapping(R"(@use-src 42_"con")");
+
+	BOOST_REQUIRE_EQUAL(errors.size(), 1);
+	BOOST_CHECK_EQUAL(errors.front()->errorId().error, 9804);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_invalid_syntax_malformed_param_2)
+{
+	// open quote arg, missing closing quote
+	auto const [mapping, errors] = tryGetSourceLocationMapping(R"(@use-src 42:"con)");
+
+	BOOST_REQUIRE_EQUAL(errors.size(), 1);
+	BOOST_CHECK_EQUAL(errors.front()->errorId().error, 9804);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_error_unexpected_trailing_tokens)
+{
+	auto const [mapping, errors] = tryGetSourceLocationMapping(
+		R"(@use-src 1:"file.sol" @use-src 2:"foo.sol")"
+	);
+
+	BOOST_REQUIRE_EQUAL(errors.size(), 1);
+	BOOST_CHECK_EQUAL(errors.front()->errorId().error, 9804);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_multiline)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping(
+		" @use-src \n  0:\"contract.sol\" \n , \n 1:\"misc.yul\""
+	);
+	BOOST_REQUIRE(mapping);
+	BOOST_REQUIRE_EQUAL(mapping->size(), 2);
+	BOOST_REQUIRE_EQUAL(*mapping->at(0), "contract.sol");
+	BOOST_REQUIRE_EQUAL(*mapping->at(1), "misc.yul");
+}
+
+BOOST_AUTO_TEST_CASE(use_src_empty_body)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping("@use-src");
+	BOOST_REQUIRE(mapping);
+	BOOST_REQUIRE_EQUAL(mapping->size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(use_src_leading_text)
+{
+	auto const [mapping, _] = tryGetSourceLocationMapping(
+		"@something else @use-src 0:\"contract.sol\", 1:\"misc.sol\""s
+	);
+	BOOST_REQUIRE(mapping);
+	BOOST_REQUIRE_EQUAL(mapping->size(), 2);
+	BOOST_REQUIRE(mapping->find(0) != mapping->end());
+	BOOST_REQUIRE_EQUAL(*mapping->at(0), "contract.sol");
+	BOOST_REQUIRE_EQUAL(*mapping->at(1), "misc.sol");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/libyul/Parser.cpp b/compiler/test/libyul/Parser.cpp
new file mode 100644
index 00000000..c9b9ec07
--- /dev/null
+++ b/compiler/test/libyul/Parser.cpp
@@ -0,0 +1,955 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @date 2017
+ * Unit tests for parsing Yul.
+ */
+
+#include <test/Common.h>
+
+#include <test/libsolidity/ErrorCheck.h>
+#include <test/libyul/Common.h>
+
+#include <libyul/AST.h>
+#include <libyul/AsmParser.h>
+#include <libyul/AsmPrinter.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/AsmAnalysisInfo.h>
+#include <libyul/Dialect.h>
+#include <liblangutil/ErrorReporter.h>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+
+BOOST_TEST_DONT_PRINT_LOG_VALUE(ErrorId)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(Error::Type)
+
+namespace solidity::yul::test
+{
+
+namespace
+{
+
+std::shared_ptr<Block> parse(std::string const& _source, Dialect const& _dialect, ErrorReporter& errorReporter)
+{
+	try
+	{
+		auto stream = CharStream(_source, "");
+		std::map<unsigned, std::shared_ptr<std::string const>> indicesToSourceNames;
+		indicesToSourceNames[0] = std::make_shared<std::string const>("source0");
+		indicesToSourceNames[1] = std::make_shared<std::string const>("source1");
+
+		auto parserResult = yul::Parser(
+			errorReporter,
+			_dialect,
+			std::move(indicesToSourceNames)
+		).parse(stream);
+		if (parserResult)
+		{
+			yul::AsmAnalysisInfo analysisInfo;
+			if (yul::AsmAnalyzer(
+				analysisInfo,
+				errorReporter,
+				_dialect
+			).analyze(*parserResult))
+				return parserResult;
+		}
+	}
+	catch (FatalError const&)
+	{
+		BOOST_FAIL("Fatal error leaked.");
+	}
+	return {};
+}
+
+std::optional<Error> parseAndReturnFirstError(std::string const& _source, Dialect const& _dialect, bool _allowWarningsAndInfos = true)
+{
+	ErrorList errors;
+	ErrorReporter errorReporter(errors);
+	if (!parse(_source, _dialect, errorReporter))
+	{
+		BOOST_REQUIRE(!errors.empty());
+		BOOST_CHECK_EQUAL(errors.size(), 1);
+		return *errors.front();
+	}
+	else
+	{
+		// If success is true, there might still be an error in the assembly stage.
+		if (_allowWarningsAndInfos && !Error::containsErrors(errors))
+			return {};
+		else if (!errors.empty())
+		{
+			if (!_allowWarningsAndInfos)
+				BOOST_CHECK_EQUAL(errors.size(), 1);
+			return *errors.front();
+		}
+	}
+	return {};
+}
+
+bool successParse(std::string const& _source, Dialect const& _dialect = Dialect::yulDeprecated(), bool _allowWarningsAndInfos = true)
+{
+	return !parseAndReturnFirstError(_source, _dialect, _allowWarningsAndInfos);
+}
+
+Error expectError(std::string const& _source, Dialect const& _dialect = Dialect::yulDeprecated(), bool _allowWarningsAndInfos = false)
+{
+
+	auto error = parseAndReturnFirstError(_source, _dialect, _allowWarningsAndInfos);
+	BOOST_REQUIRE(error);
+	return *error;
+}
+
+}
+
+#define CHECK_ERROR_DIALECT(text, typ, substring, dialect) \
+do \
+{ \
+	Error err = expectError((text), dialect, false); \
+	BOOST_CHECK(err.type() == (Error::Type::typ)); \
+	BOOST_CHECK(solidity::frontend::test::searchErrorMessage(err, (substring))); \
+} while(0)
+
+#define CHECK_ERROR(text, typ, substring) CHECK_ERROR_DIALECT(text, typ, substring, Dialect::yulDeprecated())
+
+BOOST_AUTO_TEST_SUITE(YulParser)
+
+BOOST_AUTO_TEST_CASE(builtins_analysis)
+{
+	struct SimpleDialect: public Dialect
+	{
+		BuiltinFunction const* builtin(YulString _name) const override
+		{
+			return _name == "builtin"_yulstring ? &f : nullptr;
+		}
+		BuiltinFunction f{"builtin"_yulstring, std::vector<Type>(2), std::vector<Type>(3), {}, {}, false, {}};
+	};
+
+	SimpleDialect dialect;
+	BOOST_CHECK(successParse("{ let a, b, c := builtin(1, 2) }", dialect));
+	CHECK_ERROR_DIALECT("{ let a, b, c := builtin(1) }", TypeError, "Function \"builtin\" expects 2 arguments but got 1", dialect);
+	CHECK_ERROR_DIALECT("{ let a, b := builtin(1, 2) }", DeclarationError, "Variable count mismatch for declaration of \"a, b\": 2 variables and 3 values.", dialect);
+}
+
+BOOST_AUTO_TEST_CASE(default_types_set)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	std::shared_ptr<Block> result = parse(
+		"{"
+			"let x:bool := true:bool "
+			"let z:bool := true "
+			"let y := add(1, 2) "
+			"switch y case 0 {} default {} "
+		"}",
+		EVMDialectTyped::instance(EVMVersion{}),
+		reporter
+	);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+
+	// Use no dialect so that all types are printed.
+	// This tests that the default types are properly assigned.
+	BOOST_CHECK_EQUAL(AsmPrinter{}(*result),
+		"{\n"
+		"    let x:bool := true:bool\n"
+		"    let z:bool := true:bool\n"
+		"    let y:u256 := add(1:u256, 2:u256)\n"
+		"    switch y\n"
+		"    case 0:u256 { }\n"
+		"    default { }\n"
+		"}"
+	);
+
+	// Now test again with type dialect. Now the default types
+	// should be omitted.
+	BOOST_CHECK_EQUAL(AsmPrinter{EVMDialectTyped::instance(EVMVersion{})}(*result),
+		"{\n"
+		"    let x:bool := true\n"
+		"    let z:bool := true\n"
+		"    let y := add(1, 2)\n"
+		"    switch y\n"
+		"    case 0 { }\n"
+		"    default { }\n"
+		"}"
+	);
+}
+
+#define CHECK_LOCATION(_actual, _sourceName, _start, _end) \
+	do { \
+		BOOST_CHECK_EQUAL((_sourceName), ((_actual).sourceName ? *(_actual).sourceName : "")); \
+		BOOST_CHECK_EQUAL((_start), (_actual).start); \
+		BOOST_CHECK_EQUAL((_end), (_actual).end); \
+	} while (0)
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_empty_block)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:234:543\n"
+		"{}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 234, 543);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_block_with_children)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:234:543\n"
+		"{\n"
+			"let x:bool := true:bool\n"
+			"/// @src 0:123:432\n"
+			"let z:bool := true\n"
+			"let y := add(1, 2)\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 234, 543);
+	BOOST_REQUIRE_EQUAL(3, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(0)), "source0", 234, 543);
+	CHECK_LOCATION(originLocationOf(result->statements.at(1)), "source0", 123, 432);
+	// [2] is inherited source location
+	CHECK_LOCATION(originLocationOf(result->statements.at(2)), "source0", 123, 432);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_block_different_sources)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:234:543\n"
+		"{\n"
+			"let x:bool := true:bool\n"
+			"/// @src 1:123:432\n"
+			"let z:bool := true\n"
+			"let y := add(1, 2)\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 234, 543);
+	BOOST_REQUIRE_EQUAL(3, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(0)), "source0", 234, 543);
+	CHECK_LOCATION(originLocationOf(result->statements.at(1)), "source1", 123, 432);
+	// [2] is inherited source location
+	CHECK_LOCATION(originLocationOf(result->statements.at(2)), "source1", 123, 432);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_block_nested)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:234:543\n"
+		"{\n"
+			"let y := add(1, 2)\n"
+			"/// @src 0:343:434\n"
+			"switch y case 0 {} default {}\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 234, 543);
+	BOOST_REQUIRE_EQUAL(2, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(1)), "source0", 343, 434);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_block_switch_case)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:234:543\n"
+		"{\n"
+			"let y := add(1, 2)\n"
+			"/// @src 0:343:434\n"
+			"switch y\n"
+			"/// @src 0:3141:59265\n"
+			"case 0 {\n"
+			"    /// @src 0:271:828\n"
+			"    let z := add(3, 4)\n"
+			"}\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 234, 543);
+
+	BOOST_REQUIRE_EQUAL(2, result->statements.size());
+	BOOST_REQUIRE(std::holds_alternative<Switch>(result->statements.at(1)));
+	auto const& switchStmt = std::get<Switch>(result->statements.at(1));
+
+	CHECK_LOCATION(switchStmt.debugData->originLocation, "source0", 343, 434);
+	BOOST_REQUIRE_EQUAL(1, switchStmt.cases.size());
+	CHECK_LOCATION(switchStmt.cases.at(0).debugData->originLocation, "source0", 3141, 59265);
+
+	auto const& caseBody = switchStmt.cases.at(0).body;
+	BOOST_REQUIRE_EQUAL(1, caseBody.statements.size());
+	CHECK_LOCATION(originLocationOf(caseBody.statements.at(0)), "source0", 271, 828);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_inherit_into_outer_scope)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"/// @src 0:1:100\n"
+		"{\n"
+			"{\n"
+				"/// @src 0:123:432\n"
+				"let x:bool := true:bool\n"
+			"}\n"
+			"let z:bool := true\n"
+			"let y := add(1, 2)\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 1, 100);
+
+	BOOST_REQUIRE_EQUAL(3, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(0)), "source0", 1, 100);
+
+	// First child element must be a block itself with one statement.
+	BOOST_REQUIRE(std::holds_alternative<Block>(result->statements.at(0)));
+	BOOST_REQUIRE_EQUAL(std::get<Block>(result->statements.at(0)).statements.size(), 1);
+	CHECK_LOCATION(originLocationOf(std::get<Block>(result->statements.at(0)).statements.at(0)), "source0", 123, 432);
+
+	// The next two elements have an inherited source location from the prior inner scope.
+	CHECK_LOCATION(originLocationOf(result->statements.at(1)), "source0", 123, 432);
+	CHECK_LOCATION(originLocationOf(result->statements.at(2)), "source0", 123, 432);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_assign_empty)
+{
+	// Tests single AST node (e.g. VariableDeclaration) with different source locations for each child.
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"{\n"
+			"/// @src 0:123:432\n"
+			"let a:bool\n"
+			"/// @src 1:1:10\n"
+			"a := true:bool\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0); // should still parse
+	BOOST_REQUIRE_EQUAL(2, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(0)), "source0", 123, 432);
+	CHECK_LOCATION(originLocationOf(result->statements.at(1)), "source1", 1, 10);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_invalid_source_index)
+{
+	// Tests single AST node (e.g. VariableDeclaration) with different source locations for each child.
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"{\n"
+			"/// @src 1:123:432\n"
+			"let a:bool := true:bool\n"
+			"/// @src 2345:0:8\n"
+			"let b:bool := true:bool\n"
+			"\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result); // should still parse
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 2674_error);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_mixed_locations_1)
+{
+	// Tests single AST node (e.g. VariableDeclaration) with different source locations for each child.
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"{\n"
+			"/// @src 0:123:432\n"
+			"let x:bool \n"
+			"/// @src 0:234:2026\n"
+			":= true:bool\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+
+	BOOST_REQUIRE_EQUAL(1, result->statements.size());
+	CHECK_LOCATION(originLocationOf(result->statements.at(0)), "source0", 123, 432);
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varDecl = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(originLocationOf(*varDecl.value), "source0", 234, 2026);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_mixed_locations_2)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:0:5
+		{
+			let x := /// @src 1:2:3
+			add(1,   /// @src 0:4:8
+			2)
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(1, result->statements.size());
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 0, 5);
+
+	// `let x := add(1, `
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varDecl = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(varDecl.debugData->originLocation, "source0", 0, 5);
+	BOOST_REQUIRE(!!varDecl.value);
+	BOOST_REQUIRE(std::holds_alternative<FunctionCall>(*varDecl.value));
+	FunctionCall const& call = std::get<FunctionCall>(*varDecl.value);
+	CHECK_LOCATION(call.debugData->originLocation, "source1", 2, 3);
+
+	// `2`
+	BOOST_REQUIRE_EQUAL(2, call.arguments.size());
+	CHECK_LOCATION(originLocationOf(call.arguments.at(1)), "source0", 4, 8);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_mixed_locations_3)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 1:23:45
+		{								// Block
+			{							// Block
+				sstore(0, 1)			// FunctionCall
+				/// @src 0:420:680
+			}
+			mstore(1, 2)				// FunctionCall
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(2, result->statements.size());
+	CHECK_LOCATION(result->debugData->originLocation, "source1", 23, 45);
+
+	BOOST_REQUIRE(std::holds_alternative<Block>(result->statements.at(0)));
+	Block const& innerBlock = std::get<Block>(result->statements.at(0));
+	CHECK_LOCATION(innerBlock.debugData->originLocation, "source1", 23, 45);
+
+	BOOST_REQUIRE_EQUAL(1, innerBlock.statements.size());
+	BOOST_REQUIRE(std::holds_alternative<ExpressionStatement>(result->statements.at(1)));
+	ExpressionStatement const& sstoreStmt = std::get<ExpressionStatement>(innerBlock.statements.at(0));
+	BOOST_REQUIRE(std::holds_alternative<FunctionCall>(sstoreStmt.expression));
+	FunctionCall const& sstoreCall = std::get<FunctionCall>(sstoreStmt.expression);
+	CHECK_LOCATION(sstoreCall.debugData->originLocation, "source1", 23, 45);
+
+	BOOST_REQUIRE(std::holds_alternative<ExpressionStatement>(result->statements.at(1)));
+	ExpressionStatement mstoreStmt = std::get<ExpressionStatement>(result->statements.at(1));
+	BOOST_REQUIRE(std::holds_alternative<FunctionCall>(mstoreStmt.expression));
+	FunctionCall const& mstoreCall = std::get<FunctionCall>(mstoreStmt.expression);
+	CHECK_LOCATION(mstoreCall.debugData->originLocation, "source0", 420, 680);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_invalid_comments_after_valid)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 1:23:45
+		{
+			/// @src 0:420:680
+			/// @invalid
+			let a:bool := true
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(1, result->statements.size());
+	CHECK_LOCATION(result->debugData->originLocation, "source1", 23, 45);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varDecl = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(varDecl.debugData->originLocation, "source0", 420, 680);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_invalid_suffix)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:420:680foo
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 8387_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_invalid_prefix)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// abc@src 0:111:222
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_unspecified)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src -1:-1:-1
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_non_integer)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src a:b:c
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 8387_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_bad_integer)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 111111111111111111111:222222222222222222222:333333333333333333333
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 6367_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_ensure_last_match)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:123:432
+		{
+			/// @src 1:10:20
+			/// @src 0:30:40
+			let x:bool := true
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varDecl = std::get<VariableDeclaration>(result->statements.at(0));
+
+	// Ensure the latest @src per documentation-comment is used (0:30:40).
+	CHECK_LOCATION(varDecl.debugData->originLocation, "source0", 30, 40);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_two_locations_no_whitespace)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222@src 1:333:444
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 8387_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_two_locations_separated_with_single_space)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222 @src 1:333:444
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source1", 333, 444);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_leading_trailing_whitespace)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = "///     @src 0:111:222    \n{}";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 111, 222);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_reference_original_sloc)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 1:2:3
+		{
+			/// @src -1:10:20
+			let x:bool := true
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varDecl = std::get<VariableDeclaration>(result->statements.at(0));
+
+	// -1 points to original source code, which in this case is `"source0"` (which is also
+	CHECK_LOCATION(varDecl.debugData->originLocation, "", 10, 20);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_with_code_snippets)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"~~~(
+		{
+			/// @src 0:149:156  "new C(\"123\")"
+			let x := 123
+
+			let y := /** @src 1:96:165  "contract D {..." */ 128
+		}
+	)~~~";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(result->statements.size(), 2);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varX = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(varX.debugData->originLocation, "source0", 149, 156);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(1)));
+	VariableDeclaration const& varY = std::get<VariableDeclaration>(result->statements.at(1));
+	BOOST_REQUIRE(!!varY.value);
+	BOOST_REQUIRE(std::holds_alternative<Literal>(*varY.value));
+	Literal const& literal128 = std::get<Literal>(*varY.value);
+	CHECK_LOCATION(literal128.debugData->originLocation, "source1", 96, 165);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_with_code_snippets_empty_snippet)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222 ""
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 111, 222);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_with_code_snippets_no_whitespace_before_snippet)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222"abc" def
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 8387_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_with_code_snippets_no_whitespace_after_snippet)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222 "abc"def
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source0", 111, 222);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_two_locations_with_snippets_no_whitespace)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222 "abc"@src 1:333:444 "abc"
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	CHECK_LOCATION(result->debugData->originLocation, "source1", 333, 444);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_two_locations_with_snippets_unterminated_quote)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src 0:111:222 " abc @src 1:333:444
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 1544_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_with_code_snippets_with_nested_locations)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"~~~(
+		{
+			/// @src 0:149:156  "new C(\"123\") /// @src 1:3:4 "
+			let x := 123
+
+			let y := /** @src 1:96:165  "function f() internal { \"\/** @src 0:6:7 *\/\"; }" */ 128
+		}
+	)~~~";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(result->statements.size(), 2);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varX = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(varX.debugData->originLocation, "source0", 149, 156);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(1)));
+	VariableDeclaration const& varY = std::get<VariableDeclaration>(result->statements.at(1));
+	BOOST_REQUIRE(!!varY.value);
+	BOOST_REQUIRE(std::holds_alternative<Literal>(*varY.value));
+	Literal const& literal128 = std::get<Literal>(*varY.value);
+	CHECK_LOCATION(literal128.debugData->originLocation, "source1", 96, 165);
+}
+
+BOOST_AUTO_TEST_CASE(astid)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src -1:-1:-1 @ast-id 7
+		{
+			/** @ast-id 2 */
+			function f(x) -> y {}
+			mstore(1, 2)
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_CHECK(result->debugData->astID == int64_t(7));
+	auto const& funDef = std::get<FunctionDefinition>(result->statements.at(0));
+	BOOST_CHECK(funDef.debugData->astID == int64_t(2));
+	BOOST_CHECK(funDef.parameters.at(0).debugData->astID == std::nullopt);
+	BOOST_CHECK(debugDataOf(result->statements.at(1))->astID == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(astid_reset)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src -1:-1:-1 @ast-id 7 @src 1:1:1
+		{
+			/** @ast-id 2 */
+			function f(x) -> y {}
+			mstore(1, 2)
+		}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_CHECK(result->debugData->astID == int64_t(7));
+	auto const& funDef = std::get<FunctionDefinition>(result->statements.at(0));
+	BOOST_CHECK(funDef.debugData->astID == int64_t(2));
+	BOOST_CHECK(funDef.parameters.at(0).debugData->astID == std::nullopt);
+	BOOST_CHECK(debugDataOf(result->statements.at(1))->astID == std::nullopt);
+}
+
+BOOST_AUTO_TEST_CASE(astid_multi)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src -1:-1:-1 @ast-id 7 @src 1:1:1 @ast-id 8
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_CHECK(result->debugData->astID == int64_t(8));
+}
+
+BOOST_AUTO_TEST_CASE(astid_invalid)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @src -1:-1:-1 @ast-id abc @src 1:1:1
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 1749_error);
+	CHECK_LOCATION(result->debugData->originLocation, "", -1, -1);
+}
+
+BOOST_AUTO_TEST_CASE(astid_too_large)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @ast-id 9223372036854775808
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 1749_error);
+}
+
+BOOST_AUTO_TEST_CASE(astid_way_too_large)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @ast-id 999999999999999999999999999999999999999
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 1749_error);
+}
+
+BOOST_AUTO_TEST_CASE(astid_not_fully_numeric)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText = R"(
+		/// @ast-id 9x
+		{}
+	)";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result);
+	BOOST_REQUIRE(errorList.size() == 1);
+	BOOST_TEST(errorList[0]->type() == Error::Type::SyntaxError);
+	BOOST_TEST(errorList[0]->errorId() == 1749_error);
+}
+
+BOOST_AUTO_TEST_CASE(customSourceLocations_multiple_src_tags_on_one_line)
+{
+	ErrorList errorList;
+	ErrorReporter reporter(errorList);
+	auto const sourceText =
+		"{\n"
+		"    /// "
+			R"~~(@src 1:2:3 ""@src 1:2:4 @src-1:2:5@src 1:2:6 @src 1:2:7     "" @src 1:2:8)~~"
+			R"~~( X "@src 0:10:20 "new C(\"123\") /// @src 1:4:5 "" XYZ)~~"
+			R"~~( @src0:20:30 "abc"@src0:2:4 @src-0:2:5@)~~"
+			R"~~( @some text with random @ signs @@@ @- @** 1:6:7 "src 1:8:9")~~"
+		"\n"
+		"    let x := 123\n"
+		"}\n";
+	EVMDialectTyped const& dialect = EVMDialectTyped::instance(EVMVersion{});
+	std::shared_ptr<Block> result = parse(sourceText, dialect, reporter);
+	BOOST_REQUIRE(!!result && errorList.size() == 0);
+	BOOST_REQUIRE_EQUAL(result->statements.size(), 1);
+
+	BOOST_REQUIRE(std::holds_alternative<VariableDeclaration>(result->statements.at(0)));
+	VariableDeclaration const& varX = std::get<VariableDeclaration>(result->statements.at(0));
+	CHECK_LOCATION(varX.debugData->originLocation, "source1", 4, 5);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // end namespaces
diff --git a/compiler/test/libyul/StackLayoutGeneratorTest.cpp b/compiler/test/libyul/StackLayoutGeneratorTest.cpp
new file mode 100644
index 00000000..02b03cce
--- /dev/null
+++ b/compiler/test/libyul/StackLayoutGeneratorTest.cpp
@@ -0,0 +1,266 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/StackLayoutGeneratorTest.h>
+#include <test/libyul/Common.h>
+#include <test/Common.h>
+
+#include <libyul/backends/evm/ControlFlowGraph.h>
+#include <libyul/backends/evm/ControlFlowGraphBuilder.h>
+#include <libyul/backends/evm/StackHelpers.h>
+#include <libyul/backends/evm/StackLayoutGenerator.h>
+#include <libyul/Object.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolutil/AnsiColorized.h>
+#include <libsolutil/Visitor.h>
+
+#include <range/v3/view/reverse.hpp>
+
+#ifdef ISOLTEST
+#include <boost/process.hpp>
+#endif
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+StackLayoutGeneratorTest::StackLayoutGeneratorTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	auto dialectName = m_reader.stringSetting("dialect", "evm");
+	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+	m_expectation = m_reader.simpleExpectations();
+}
+
+namespace
+{
+static std::string variableSlotToString(VariableSlot const& _slot)
+{
+	return _slot.variable.get().name.str();
+}
+}
+
+class StackLayoutPrinter
+{
+public:
+	StackLayoutPrinter(std::ostream& _stream, StackLayout const& _stackLayout):
+	m_stream(_stream), m_stackLayout(_stackLayout)
+	{
+	}
+	void operator()(CFG::BasicBlock const& _block, bool _isMainEntry = true)
+	{
+		if (_isMainEntry)
+		{
+			m_stream << "Entry [label=\"Entry\"];\n";
+			m_stream << "Entry -> Block" << getBlockId(_block) << ";\n";
+		}
+		while (!m_blocksToPrint.empty())
+		{
+			CFG::BasicBlock const* block = *m_blocksToPrint.begin();
+			m_blocksToPrint.erase(m_blocksToPrint.begin());
+			printBlock(*block);
+		}
+
+	}
+	void operator()(
+		CFG::FunctionInfo const& _info
+	)
+	{
+		m_stream << "FunctionEntry_" << _info.function.name.str() << " [label=\"";
+		m_stream << "function " << _info.function.name.str() << "(";
+		m_stream << joinHumanReadable(_info.parameters | ranges::views::transform(variableSlotToString));
+		m_stream << ")";
+		if (!_info.returnVariables.empty())
+		{
+			m_stream << " -> ";
+			m_stream << joinHumanReadable(_info.returnVariables | ranges::views::transform(variableSlotToString));
+		}
+		m_stream << "\\l\\\n";
+		Stack functionEntryStack = {FunctionReturnLabelSlot{_info.function}};
+		functionEntryStack += _info.parameters | ranges::views::reverse;
+		m_stream << stackToString(functionEntryStack) << "\"];\n";
+		m_stream << "FunctionEntry_" << _info.function.name.str() << " -> Block" << getBlockId(*_info.entry) << ";\n";
+		(*this)(*_info.entry, false);
+	}
+
+private:
+	void printBlock(CFG::BasicBlock const& _block)
+	{
+		m_stream << "Block" << getBlockId(_block) << " [label=\"\\\n";
+
+		// Verify that the entries of this block exit into this block.
+		for (auto const& entry: _block.entries)
+			std::visit(util::GenericVisitor{
+				[&](CFG::BasicBlock::Jump const& _jump)
+				{
+					soltestAssert(_jump.target == &_block, "Invalid control flow graph.");
+				},
+				[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+				{
+					soltestAssert(
+						_conditionalJump.zero == &_block || _conditionalJump.nonZero == &_block,
+						"Invalid control flow graph."
+					);
+				},
+				[&](auto const&)
+				{
+					soltestAssert(false, "Invalid control flow graph.");
+				}
+			}, entry->exit);
+
+		auto const& blockInfo = m_stackLayout.blockInfos.at(&_block);
+		m_stream << stackToString(blockInfo.entryLayout) << "\\l\\\n";
+		for (auto const& operation: _block.operations)
+		{
+			auto entryLayout = m_stackLayout.operationEntryLayout.at(&operation);
+			m_stream << stackToString(m_stackLayout.operationEntryLayout.at(&operation)) << "\\l\\\n";
+			std::visit(util::GenericVisitor{
+				[&](CFG::FunctionCall const& _call) {
+					m_stream << _call.function.get().name.str();
+				},
+				[&](CFG::BuiltinCall const& _call) {
+					m_stream << _call.functionCall.get().functionName.name.str();
+
+				},
+				[&](CFG::Assignment const& _assignment) {
+					m_stream << "Assignment(";
+					m_stream << joinHumanReadable(_assignment.variables | ranges::views::transform(variableSlotToString));
+					m_stream << ")";
+				}
+			}, operation.operation);
+			m_stream << "\\l\\\n";
+			soltestAssert(operation.input.size() <= entryLayout.size(), "Invalid Stack Layout.");
+			for (size_t i = 0; i < operation.input.size(); ++i)
+				entryLayout.pop_back();
+			entryLayout += operation.output;
+			m_stream << stackToString(entryLayout) << "\\l\\\n";
+		}
+		m_stream << stackToString(blockInfo.exitLayout) << "\\l\\\n";
+		m_stream << "\"];\n";
+		std::visit(util::GenericVisitor{
+			[&](CFG::BasicBlock::MainExit const&)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"MainExit\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			},
+			[&](CFG::BasicBlock::Jump const& _jump)
+			{
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit [arrowhead=none];\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"";
+				if (_jump.backwards)
+					m_stream << "Backwards";
+				m_stream << "Jump\" shape=oval];\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit -> Block" << getBlockId(*_jump.target) << ";\n";
+			},
+			[&](CFG::BasicBlock::ConditionalJump const& _conditionalJump)
+			{
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"{ ";
+				m_stream << stackSlotToString(_conditionalJump.condition);
+				m_stream << "| { <0> Zero | <1> NonZero }}\" shape=Mrecord];\n";
+				m_stream << "Block" << getBlockId(_block);
+				m_stream << "Exit:0 -> Block" << getBlockId(*_conditionalJump.zero) << ";\n";
+				m_stream << "Block" << getBlockId(_block);
+				m_stream << "Exit:1 -> Block" << getBlockId(*_conditionalJump.nonZero) << ";\n";
+			},
+			[&](CFG::BasicBlock::FunctionReturn const& _return)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"FunctionReturn[" << _return.info->function.name.str() << "]\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			},
+			[&](CFG::BasicBlock::Terminated const&)
+			{
+				m_stream << "Block" << getBlockId(_block) << "Exit [label=\"Terminated\"];\n";
+				m_stream << "Block" << getBlockId(_block) << " -> Block" << getBlockId(_block) << "Exit;\n";
+			}
+		}, _block.exit);
+		m_stream << "\n";
+	}
+	size_t getBlockId(CFG::BasicBlock const& _block)
+	{
+		if (size_t* id = util::valueOrNullptr(m_blockIds, &_block))
+			return *id;
+		size_t id = m_blockIds[&_block] = m_blockCount++;
+		m_blocksToPrint.emplace_back(&_block);
+		return id;
+	}
+	std::ostream& m_stream;
+	StackLayout const& m_stackLayout;
+	std::map<CFG::BasicBlock const*, size_t> m_blockIds;
+	size_t m_blockCount = 0;
+	std::list<CFG::BasicBlock const*> m_blocksToPrint;
+};
+
+TestCase::TestResult StackLayoutGeneratorTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	ErrorList errors;
+	auto [object, analysisInfo] = parse(m_source, *m_dialect, errors);
+	if (!object || !analysisInfo || Error::containsErrors(errors))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		return TestResult::FatalError;
+	}
+
+	std::ostringstream output;
+
+	std::unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(*analysisInfo, *m_dialect, *object->code);
+	StackLayout stackLayout = StackLayoutGenerator::run(*cfg);
+
+	output << "digraph CFG {\nnodesep=0.7;\nnode[shape=box];\n\n";
+	StackLayoutPrinter printer{output, stackLayout};
+	printer(*cfg->entry);
+	for (auto function: cfg->functions)
+		printer(cfg->functionInfo.at(function));
+	output << "}\n";
+
+	m_obtainedResult = output.str();
+
+	auto result = checkResult(_stream, _linePrefix, _formatted);
+
+#ifdef ISOLTEST
+	char* graphDisplayer = nullptr;
+	if (result == TestResult::Failure)
+		graphDisplayer = getenv("ISOLTEST_DISPLAY_GRAPHS_FAILURE");
+	else if (result == TestResult::Success)
+		graphDisplayer = getenv("ISOLTEST_DISPLAY_GRAPHS_SUCCESS");
+
+	if (graphDisplayer)
+	{
+		if (result == TestResult::Success)
+			std::cout << std::endl << m_source << std::endl;
+		boost::process::opstream pipe;
+		boost::process::child child(graphDisplayer, boost::process::std_in < pipe);
+
+		pipe << output.str();
+		pipe.flush();
+		pipe.pipe().close();
+		if (result == TestResult::Success)
+			child.wait();
+		else
+			child.detach();
+	}
+#endif
+
+	return result;
+}
diff --git a/compiler/test/libyul/StackShufflingTest.cpp b/compiler/test/libyul/StackShufflingTest.cpp
new file mode 100644
index 00000000..7c85a931
--- /dev/null
+++ b/compiler/test/libyul/StackShufflingTest.cpp
@@ -0,0 +1,178 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/libyul/StackShufflingTest.h>
+
+#include <liblangutil/Scanner.h>
+#include <libsolutil/AnsiColorized.h>
+#include <libyul/backends/evm/StackHelpers.h>
+
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+bool StackShufflingTest::parse(std::string const& _source)
+{
+	CharStream stream(_source, "");
+	Scanner scanner(stream);
+
+	auto expectToken = [&](Token _token)
+	{
+		soltestAssert(
+			scanner.next() == _token,
+			"Invalid token. Expected: \"" + TokenTraits::friendlyName(_token) + "\"."
+        );
+	};
+
+	auto parseStack = [&](Stack& stack) -> bool
+	{
+		if (scanner.currentToken() != Token::LBrack)
+			return false;
+		scanner.next();
+		while (scanner.currentToken() != Token::RBrack &&
+			   scanner.currentToken() != Token::EOS)
+		{
+			std::string literal = scanner.currentLiteral();
+			if (literal == "RET")
+			{
+				scanner.next();
+				if (scanner.currentToken() == Token::LBrack)
+				{
+					scanner.next();
+					std::string functionName = scanner.currentLiteral();
+					auto call = yul::FunctionCall{
+						{},	yul::Identifier{{}, YulString(functionName)}, {}
+					};
+					stack.emplace_back(FunctionCallReturnLabelSlot{
+							m_functions.insert(
+								make_pair(functionName, call)
+							).first->second
+					});
+					expectToken(Token::RBrack);
+				}
+				else
+				{
+					static Scope::Function function;
+					stack.emplace_back(FunctionReturnLabelSlot{function});
+					continue;
+				}
+			}
+			else if (literal == "TMP")
+			{
+				expectToken(Token::LBrack);
+				scanner.next();
+				std::string functionName = scanner.currentLiteral();
+				auto call = yul::FunctionCall{
+				    {},	yul::Identifier{{}, YulString(functionName)}, {}
+			    };
+				expectToken(Token::Comma);
+				scanner.next();
+				size_t index = size_t(atoi(scanner.currentLiteral().c_str()));
+				stack.emplace_back(TemporarySlot{
+						m_functions.insert(make_pair(functionName, call)).first->second,
+						index
+				});
+				expectToken(Token::RBrack);
+			}
+			else if (literal.find("0x") != std::string::npos || scanner.currentToken() == Token::Number)
+			{
+				stack.emplace_back(LiteralSlot{u256(literal)});
+			}
+			else if (literal == "JUNK")
+			{
+				stack.emplace_back(JunkSlot());
+			}
+			else if (literal == "GHOST")
+			{
+				expectToken(Token::LBrack);
+				scanner.next(); // read number of ghost variables as ghostVariableId
+				std::string ghostVariableId = scanner.currentLiteral();
+				Scope::Variable ghostVar = Scope::Variable{""_yulstring, YulString(literal + "[" + ghostVariableId + "]")};
+				stack.emplace_back(VariableSlot{
+						m_variables.insert(std::make_pair(ghostVar.name, ghostVar)).first->second
+				});
+				expectToken(Token::RBrack);
+			}
+			else
+			{
+				Scope::Variable var = Scope::Variable{""_yulstring, YulString(literal)};
+				stack.emplace_back(VariableSlot{
+						m_variables.insert(
+							make_pair(literal, var)
+						).first->second
+				});
+			}
+			scanner.next();
+		}
+		return scanner.currentToken() == Token::RBrack;
+	};
+
+	if (!parseStack(m_sourceStack))
+		return false;
+	scanner.next();
+	return parseStack(m_targetStack);
+}
+
+StackShufflingTest::StackShufflingTest(std::string const& _filename):
+	TestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult StackShufflingTest::run(std::ostream& _stream, std::string const& _linePrefix, bool _formatted)
+{
+	if (!parse(m_source))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		return TestResult::FatalError;
+	}
+
+	std::ostringstream output;
+	createStackLayout(
+		m_sourceStack,
+		m_targetStack,
+		[&](unsigned _swapDepth) // swap
+		{
+			output << stackToString(m_sourceStack) << std::endl;
+			output << "SWAP" << _swapDepth << std::endl;
+		},
+		[&](StackSlot const& _slot) // dupOrPush
+		{
+			output << stackToString(m_sourceStack) << std::endl;
+			if (canBeFreelyGenerated(_slot))
+				output << "PUSH " << stackSlotToString(_slot) << std::endl;
+			else
+			{
+				if (auto depth = util::findOffset(m_sourceStack | ranges::views::reverse, _slot))
+					output << "DUP" << *depth + 1 << std::endl;
+				else
+					BOOST_THROW_EXCEPTION(std::runtime_error("Invalid DUP operation."));
+			}
+		},
+		[&](){ // pop
+			output << stackToString(m_sourceStack) << std::endl;
+			output << "POP" << std::endl;
+		}
+    );
+
+	output << stackToString(m_sourceStack) << std::endl;
+	m_obtainedResult = output.str();
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
diff --git a/compiler/test/libyul/StackShufflingTest.h b/compiler/test/libyul/StackShufflingTest.h
new file mode 100644
index 00000000..75715d25
--- /dev/null
+++ b/compiler/test/libyul/StackShufflingTest.h
@@ -0,0 +1,47 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+
+#include <libyul/backends/evm/ControlFlowGraph.h>
+
+using namespace solidity::frontend::test;
+
+namespace solidity::yul::test
+{
+
+class StackShufflingTest: public TestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<StackShufflingTest>(_config.filename);
+	}
+	explicit StackShufflingTest(std::string const& _filename);
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+private:
+	bool parse(std::string const& _source);
+
+	Stack m_sourceStack;
+	Stack m_targetStack;
+	std::map<YulString, yul::FunctionCall> m_functions;
+	std::map<YulString, Scope::Variable> m_variables;
+};
+}
diff --git a/compiler/test/libyul/SyntaxTest.cpp b/compiler/test/libyul/SyntaxTest.cpp
new file mode 100644
index 00000000..0201e047
--- /dev/null
+++ b/compiler/test/libyul/SyntaxTest.cpp
@@ -0,0 +1,79 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libyul/AsmAnalysis.h>
+#include <libyul/AsmAnalysisInfo.h>
+
+#include <liblangutil/EVMVersion.h>
+#include <liblangutil/Exceptions.h>
+
+#include <test/libyul/Common.h>
+#include <test/libyul/SyntaxTest.h>
+#include <test/TestCaseReader.h>
+
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <test/Common.h>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul::test;
+using namespace solidity::frontend::test;
+
+void SyntaxTest::parseAndAnalyze()
+{
+	if (m_sources.sources.size() != 1)
+		BOOST_THROW_EXCEPTION(std::runtime_error{"Expected only one source for yul test."});
+
+	std::string const& name = m_sources.sources.begin()->first;
+	std::string const& source = m_sources.sources.begin()->second;
+
+	ErrorList errorList{};
+	soltestAssert(m_dialect, "");
+	// Silently ignoring the results.
+	yul::test::parse(source, *m_dialect, errorList);
+	for (auto const& error: errorList)
+	{
+		int locationStart = -1;
+		int locationEnd = -1;
+
+		if (SourceLocation const* location = error->sourceLocation())
+		{
+			locationStart = location->start;
+			locationEnd = location->end;
+		}
+
+		m_errorList.emplace_back(SyntaxTestError{
+			error->type(),
+			error->errorId(),
+			errorMessage(*error),
+			name,
+			locationStart,
+			locationEnd
+		});
+	}
+
+}
+
+SyntaxTest::SyntaxTest(std::string const& _filename, langutil::EVMVersion _evmVersion):
+	CommonSyntaxTest(_filename, _evmVersion)
+{
+	std::string dialectName = m_reader.stringSetting("dialect", "evmTyped");
+	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+}
diff --git a/compiler/test/libyul/SyntaxTest.h b/compiler/test/libyul/SyntaxTest.h
new file mode 100644
index 00000000..27e59ee6
--- /dev/null
+++ b/compiler/test/libyul/SyntaxTest.h
@@ -0,0 +1,45 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/CommonSyntaxTest.h>
+#include <libyul/Dialect.h>
+
+namespace solidity::yul::test
+{
+
+using solidity::test::SyntaxTestError;
+
+class SyntaxTest: public solidity::test::CommonSyntaxTest
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<SyntaxTest>(_config.filename, _config.evmVersion);
+	}
+	SyntaxTest(std::string const& _filename, langutil::EVMVersion _evmVersion);
+	~SyntaxTest() override {}
+protected:
+	void parseAndAnalyze() override;
+
+private:
+	Dialect const* m_dialect = nullptr;
+};
+
+}
diff --git a/compiler/test/libyul/YulInterpreterTest.cpp b/compiler/test/libyul/YulInterpreterTest.cpp
new file mode 100644
index 00000000..eb6a447d
--- /dev/null
+++ b/compiler/test/libyul/YulInterpreterTest.cpp
@@ -0,0 +1,113 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/YulInterpreterTest.h>
+
+#include <test/tools/yulInterpreter/Interpreter.h>
+
+#include <test/Common.h>
+
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/YulStack.h>
+#include <libyul/AsmAnalysisInfo.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/ErrorReporter.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolutil/AnsiColorized.h>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/algorithm/string.hpp>
+
+#include <fstream>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+YulInterpreterTest::YulInterpreterTest(std::string const& _filename):
+	EVMVersionRestrictedTestCase(_filename)
+{
+	m_source = m_reader.source();
+	m_expectation = m_reader.simpleExpectations();
+	m_simulateExternalCallsToSelf = m_reader.boolSetting("simulateExternalCall", false);
+}
+
+TestCase::TestResult YulInterpreterTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	if (!parse(_stream, _linePrefix, _formatted))
+		return TestResult::FatalError;
+
+	m_obtainedResult = interpret();
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
+
+bool YulInterpreterTest::parse(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	YulStack stack(
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::none(),
+		DebugInfoSelection::All()
+	);
+	if (stack.parseAndAnalyze("", m_source))
+	{
+		m_ast = stack.parserResult()->code;
+		m_analysisInfo = stack.parserResult()->analysisInfo;
+		return true;
+	}
+	else
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		SourceReferenceFormatter{_stream, stack, true, false}
+			.printErrorInformation(stack.errors());
+		return false;
+	}
+}
+
+std::string YulInterpreterTest::interpret()
+{
+	InterpreterState state;
+	state.maxTraceSize = 32;
+	state.maxSteps = 512;
+	state.maxExprNesting = 64;
+	try
+	{
+		Interpreter::run(
+			state,
+			EVMDialect::strictAssemblyForEVMObjects(solidity::test::CommonOptions::get().evmVersion()),
+			*m_ast,
+			/*disableExternalCalls=*/ !m_simulateExternalCallsToSelf,
+			/*disableMemoryTracing=*/ false
+		);
+	}
+	catch (InterpreterTerminatedGeneric const&)
+	{
+	}
+
+	std::stringstream result;
+	state.dumpTraceAndState(result, false);
+	return result.str();
+}
diff --git a/compiler/test/libyul/YulInterpreterTest.h b/compiler/test/libyul/YulInterpreterTest.h
new file mode 100644
index 00000000..a20b0688
--- /dev/null
+++ b/compiler/test/libyul/YulInterpreterTest.h
@@ -0,0 +1,53 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/TestCase.h>
+
+namespace solidity::yul
+{
+struct AsmAnalysisInfo;
+struct Block;
+}
+
+namespace solidity::yul::test
+{
+
+class YulInterpreterTest: public solidity::frontend::test::EVMVersionRestrictedTestCase
+{
+public:
+	static std::unique_ptr<TestCase> create(Config const& _config)
+	{
+		return std::make_unique<YulInterpreterTest>(_config.filename);
+	}
+
+	explicit YulInterpreterTest(std::string const& _filename);
+
+	TestResult run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
+
+private:
+	bool parse(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted);
+	std::string interpret();
+
+	std::shared_ptr<Block> m_ast;
+	std::shared_ptr<AsmAnalysisInfo> m_analysisInfo;
+	bool m_simulateExternalCallsToSelf = false;
+};
+
+}
diff --git a/compiler/test/libyul/YulOptimizerTest.cpp b/compiler/test/libyul/YulOptimizerTest.cpp
new file mode 100644
index 00000000..9fc6712d
--- /dev/null
+++ b/compiler/test/libyul/YulOptimizerTest.cpp
@@ -0,0 +1,119 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/YulOptimizerTest.h>
+#include <test/libyul/YulOptimizerTestCommon.h>
+
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <test/libyul/Common.h>
+#include <test/Common.h>
+
+#include <libyul/Object.h>
+#include <libyul/AsmPrinter.h>
+
+#include <liblangutil/CharStreamProvider.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+#include <liblangutil/Scanner.h>
+
+#include <libsolutil/AnsiColorized.h>
+#include <libsolutil/StringUtils.h>
+
+#include <fstream>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+
+YulOptimizerTest::YulOptimizerTest(std::string const& _filename):
+	EVMVersionRestrictedTestCase(_filename)
+{
+	boost::filesystem::path path(_filename);
+
+	if (path.empty() || std::next(path.begin()) == path.end() || std::next(std::next(path.begin())) == path.end())
+		BOOST_THROW_EXCEPTION(std::runtime_error("Filename path has to contain a directory: \"" + _filename + "\"."));
+	m_optimizerStep = std::prev(std::prev(path.end()))->string();
+
+	m_source = m_reader.source();
+
+	auto dialectName = m_reader.stringSetting("dialect", "evm");
+	m_dialect = &dialect(dialectName, solidity::test::CommonOptions::get().evmVersion());
+
+	m_expectation = m_reader.simpleExpectations();
+}
+
+TestCase::TestResult YulOptimizerTest::run(std::ostream& _stream, std::string const& _linePrefix, bool const _formatted)
+{
+	std::tie(m_object, m_analysisInfo) = parse(_stream, _linePrefix, _formatted, m_source);
+	if (!m_object)
+		return TestResult::FatalError;
+
+	soltestAssert(m_dialect, "Dialect not set.");
+
+	m_object->analysisInfo = m_analysisInfo;
+	YulOptimizerTestCommon tester(m_object, *m_dialect);
+	tester.setStep(m_optimizerStep);
+
+	if (!tester.runStep())
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Invalid optimizer step: " << m_optimizerStep << std::endl;
+		return TestResult::FatalError;
+	}
+
+	auto const printed = (m_object->subObjects.empty() ? AsmPrinter{ *m_dialect }(*m_object->code) : m_object->toString(m_dialect));
+
+	// Re-parse new code for compilability
+	// TODO: support for wordSizeTransform which needs different input and output dialects
+	if (m_optimizerStep != "wordSizeTransform" && !std::get<0>(parse(_stream, _linePrefix, _formatted, printed)))
+	{
+		util::AnsiColorized(_stream, _formatted, {util::formatting::BOLD, util::formatting::CYAN})
+			<< _linePrefix << "Result after the optimiser:" << std::endl;
+		printPrefixed(_stream, printed, _linePrefix + "  ");
+		return TestResult::FatalError;
+	}
+
+	m_obtainedResult = "step: " + m_optimizerStep + "\n\n" + printed + "\n";
+
+	return checkResult(_stream, _linePrefix, _formatted);
+}
+
+std::pair<std::shared_ptr<Object>, std::shared_ptr<AsmAnalysisInfo>> YulOptimizerTest::parse(
+	std::ostream& _stream,
+	std::string const& _linePrefix,
+	bool const _formatted,
+	std::string const& _source
+)
+{
+	ErrorList errors;
+	soltestAssert(m_dialect, "");
+	std::shared_ptr<Object> object;
+	std::shared_ptr<AsmAnalysisInfo> analysisInfo;
+	std::tie(object, analysisInfo) = yul::test::parse(_source, *m_dialect, errors);
+	if (!object || !analysisInfo || Error::containsErrors(errors))
+	{
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::RED}) << _linePrefix << "Error parsing source." << std::endl;
+		CharStream charStream(_source, "");
+		SourceReferenceFormatter{_stream, SingletonCharStreamProvider(charStream), true, false}
+			.printErrorInformation(errors);
+		return {};
+	}
+	return {std::move(object), std::move(analysisInfo)};
+}
diff --git a/compiler/test/libyul/YulOptimizerTestCommon.cpp b/compiler/test/libyul/YulOptimizerTestCommon.cpp
new file mode 100644
index 00000000..e529f1d9
--- /dev/null
+++ b/compiler/test/libyul/YulOptimizerTestCommon.cpp
@@ -0,0 +1,460 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/libyul/YulOptimizerTestCommon.h>
+
+#include <libyul/optimiser/BlockFlattener.h>
+#include <libyul/optimiser/VarDeclInitializer.h>
+#include <libyul/optimiser/VarNameCleaner.h>
+#include <libyul/optimiser/ControlFlowSimplifier.h>
+#include <libyul/optimiser/DeadCodeEliminator.h>
+#include <libyul/optimiser/Disambiguator.h>
+#include <libyul/optimiser/CircularReferencesPruner.h>
+#include <libyul/optimiser/ConditionalUnsimplifier.h>
+#include <libyul/optimiser/ConditionalSimplifier.h>
+#include <libyul/optimiser/CommonSubexpressionEliminator.h>
+#include <libyul/optimiser/EqualStoreEliminator.h>
+#include <libyul/optimiser/EquivalentFunctionCombiner.h>
+#include <libyul/optimiser/ExpressionSplitter.h>
+#include <libyul/optimiser/FunctionGrouper.h>
+#include <libyul/optimiser/FunctionHoister.h>
+#include <libyul/optimiser/FunctionSpecializer.h>
+#include <libyul/optimiser/ExpressionInliner.h>
+#include <libyul/optimiser/FullInliner.h>
+#include <libyul/optimiser/ForLoopConditionIntoBody.h>
+#include <libyul/optimiser/ForLoopInitRewriter.h>
+#include <libyul/optimiser/LoadResolver.h>
+#include <libyul/optimiser/LoopInvariantCodeMotion.h>
+#include <libyul/optimiser/StackLimitEvader.h>
+#include <libyul/optimiser/NameDisplacer.h>
+#include <libyul/optimiser/Rematerialiser.h>
+#include <libyul/optimiser/ExpressionSimplifier.h>
+#include <libyul/optimiser/UnusedFunctionParameterPruner.h>
+#include <libyul/optimiser/UnusedPruner.h>
+#include <libyul/optimiser/ExpressionJoiner.h>
+#include <libyul/optimiser/OptimiserStep.h>
+#include <libyul/optimiser/SSAReverser.h>
+#include <libyul/optimiser/SSATransform.h>
+#include <libyul/optimiser/Semantics.h>
+#include <libyul/optimiser/UnusedAssignEliminator.h>
+#include <libyul/optimiser/UnusedStoreEliminator.h>
+#include <libyul/optimiser/StructuralSimplifier.h>
+#include <libyul/optimiser/StackCompressor.h>
+#include <libyul/optimiser/Suite.h>
+#include <libyul/backends/evm/ConstantOptimiser.h>
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/backends/evm/EVMMetrics.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/CompilabilityChecker.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+
+#include <random>
+
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::frontend;
+
+YulOptimizerTestCommon::YulOptimizerTestCommon(
+	std::shared_ptr<Object> _obj,
+	Dialect const& _dialect
+)
+{
+	m_object = _obj;
+	m_ast = m_object->code;
+	m_analysisInfo = m_object->analysisInfo;
+	m_dialect = &_dialect;
+
+	m_namedSteps = {
+		{"disambiguator", [&]() { disambiguate(); }},
+		{"nameDisplacer", [&]() {
+			disambiguate();
+			NameDisplacer{
+				*m_nameDispenser,
+				{"illegal1"_yulstring, "illegal2"_yulstring, "illegal3"_yulstring, "illegal4"_yulstring, "illegal5"_yulstring}
+			}(*m_ast);
+		}},
+		{"blockFlattener", [&]() {
+			disambiguate();
+			FunctionGrouper::run(*m_context, *m_ast);
+			BlockFlattener::run(*m_context, *m_ast);
+		}},
+		{"constantOptimiser", [&]() {
+			GasMeter meter(dynamic_cast<EVMDialect const&>(*m_dialect), false, 200);
+			ConstantOptimiser{dynamic_cast<EVMDialect const&>(*m_dialect), meter}(*m_ast);
+		}},
+		{"varDeclInitializer", [&]() { VarDeclInitializer::run(*m_context, *m_ast); }},
+		{"varNameCleaner", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+			FunctionGrouper::run(*m_context, *m_ast);
+			VarNameCleaner::run(*m_context, *m_ast);
+		}},
+		{"forLoopConditionIntoBody", [&]() {
+			disambiguate();
+			ForLoopConditionIntoBody::run(*m_context, *m_ast);
+		}},
+		{"forLoopInitRewriter", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+		}},
+		{"commonSubexpressionEliminator", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			CommonSubexpressionEliminator::run(*m_context, *m_ast);
+		}},
+		{"conditionalUnsimplifier", [&]() {
+			disambiguate();
+			ConditionalUnsimplifier::run(*m_context, *m_ast);
+		}},
+		{"conditionalSimplifier", [&]() {
+			disambiguate();
+			ConditionalSimplifier::run(*m_context, *m_ast);
+		}},
+		{"expressionSplitter", [&]() { ExpressionSplitter::run(*m_context, *m_ast); }},
+		{"expressionJoiner", [&]() {
+			disambiguate();
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"splitJoin", [&]() {
+			disambiguate();
+			ExpressionSplitter::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"functionGrouper", [&]() {
+			disambiguate();
+			FunctionGrouper::run(*m_context, *m_ast);
+		}},
+		{"functionHoister", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+		}},
+		{"functionSpecializer", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_object->code);
+			FunctionSpecializer::run(*m_context, *m_object->code);
+		}},
+		{"expressionInliner", [&]() {
+			disambiguate();
+			ExpressionInliner::run(*m_context, *m_ast);
+		}},
+		{"fullInliner", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+			FunctionGrouper::run(*m_context, *m_ast);
+			ExpressionSplitter::run(*m_context, *m_ast);
+			FullInliner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"fullInlinerWithoutSplitter", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+			FunctionGrouper::run(*m_context, *m_ast);
+			FullInliner::run(*m_context, *m_ast);
+		}},
+		{"rematerialiser", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			Rematerialiser::run(*m_context, *m_ast);
+		}},
+		{"expressionSimplifier", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			ExpressionSplitter::run(*m_context, *m_ast);
+			CommonSubexpressionEliminator::run(*m_context, *m_ast);
+			ExpressionSimplifier::run(*m_context, *m_ast);
+			ExpressionSimplifier::run(*m_context, *m_ast);
+			ExpressionSimplifier::run(*m_context, *m_ast);
+			UnusedPruner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"fullSimplify", [&]() {
+			disambiguate();
+			FunctionGrouper::run(*m_context, *m_ast);
+			BlockFlattener::run(*m_context, *m_ast);
+			ExpressionSplitter::run(*m_context, *m_ast);
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			CommonSubexpressionEliminator::run(*m_context, *m_ast);
+			ExpressionSimplifier::run(*m_context, *m_ast);
+			UnusedPruner::run(*m_context, *m_ast);
+			CircularReferencesPruner::run(*m_context, *m_ast);
+			DeadCodeEliminator::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"unusedFunctionParameterPruner", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_object->code);
+			LiteralRematerialiser::run(*m_context, *m_object->code);
+			UnusedFunctionParameterPruner::run(*m_context, *m_object->code);
+		}},
+		{"unusedPruner", [&]() {
+			disambiguate();
+			UnusedPruner::run(*m_context, *m_ast);
+		}},
+		{"circularReferencesPruner", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+			CircularReferencesPruner::run(*m_context, *m_ast);
+		}},
+		{"deadCodeEliminator", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			DeadCodeEliminator::run(*m_context, *m_ast);
+		}},
+		{"ssaTransform", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			SSATransform::run(*m_context, *m_ast);
+		}},
+		{"unusedAssignEliminator", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			UnusedAssignEliminator::run(*m_context, *m_ast);
+		}},
+		{"unusedStoreEliminator", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			ExpressionSplitter::run(*m_context, *m_ast);
+			SSATransform::run(*m_context, *m_ast);
+			UnusedStoreEliminator::run(*m_context, *m_ast);
+			SSAReverser::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"equalStoreEliminator", [&]() {
+			disambiguate();
+			FunctionHoister::run(*m_context, *m_ast);
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			EqualStoreEliminator::run(*m_context, *m_ast);
+		}},
+		{"ssaPlusCleanup", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			SSATransform::run(*m_context, *m_ast);
+			UnusedAssignEliminator::run(*m_context, *m_ast);
+		}},
+		{"loadResolver", [&]() {
+			disambiguate();
+			FunctionGrouper::run(*m_context, *m_ast);
+			BlockFlattener::run(*m_context, *m_ast);
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			ExpressionSplitter::run(*m_context, *m_ast);
+			CommonSubexpressionEliminator::run(*m_context, *m_ast);
+			ExpressionSimplifier::run(*m_context, *m_ast);
+
+			LoadResolver::run(*m_context, *m_ast);
+
+			UnusedPruner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+			ExpressionJoiner::run(*m_context, *m_ast);
+		}},
+		{"loopInvariantCodeMotion", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			LoopInvariantCodeMotion::run(*m_context, *m_ast);
+		}},
+		{"controlFlowSimplifier", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			ControlFlowSimplifier::run(*m_context, *m_ast);
+		}},
+		{"structuralSimplifier", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			LiteralRematerialiser::run(*m_context, *m_ast);
+			StructuralSimplifier::run(*m_context, *m_ast);
+		}},
+		{"equivalentFunctionCombiner", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			EquivalentFunctionCombiner::run(*m_context, *m_ast);
+		}},
+		{"ssaReverser", [&]() {
+			disambiguate();
+			SSAReverser::run(*m_context, *m_ast);
+		}},
+		{"ssaAndBack", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			// apply SSA
+			SSATransform::run(*m_context, *m_ast);
+			UnusedAssignEliminator::run(*m_context, *m_ast);
+			// reverse SSA
+			SSAReverser::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			CommonSubexpressionEliminator::run(*m_context, *m_ast);
+			UnusedPruner::run(*m_context, *m_ast);
+		}},
+		{"stackCompressor", [&]() {
+			disambiguate();
+			ForLoopInitRewriter::run(*m_context, *m_ast);
+			FunctionHoister::run(*m_context, *m_ast);
+			FunctionGrouper::run(*m_context, *m_ast);
+			size_t maxIterations = 16;
+			StackCompressor::run(*m_dialect, *m_object, true, maxIterations);
+			BlockFlattener::run(*m_context, *m_ast);
+		}},
+		{"fullSuite", [&]() {
+			GasMeter meter(dynamic_cast<EVMDialect const&>(*m_dialect), false, 200);
+			OptimiserSuite::run(
+				*m_dialect,
+				&meter,
+				*m_object,
+				true,
+				frontend::OptimiserSettings::DefaultYulOptimiserSteps,
+				frontend::OptimiserSettings::DefaultYulOptimiserCleanupSteps,
+				frontend::OptimiserSettings::standard().expectedExecutionsPerDeployment
+			);
+		}},
+		{"stackLimitEvader", [&]() {
+			disambiguate();
+			StackLimitEvader::run(*m_context, *m_object, CompilabilityChecker{
+				*m_dialect,
+				*m_object,
+				true
+			}.unreachableVariables);
+		}},
+		{"fakeStackLimitEvader", [&]() {
+			disambiguate();
+			// Mark all variables with a name starting with "$" for escalation to memory.
+			struct FakeUnreachableGenerator: ASTWalker
+			{
+				std::map<YulString, std::vector<YulString>> fakeUnreachables;
+				using ASTWalker::operator();
+				void operator()(FunctionDefinition const& _function) override
+				{
+					YulString originalFunctionName = m_currentFunction;
+					m_currentFunction = _function.name;
+					for (TypedName const& _argument: _function.parameters)
+						visitVariableName(_argument.name);
+					for (TypedName const& _argument: _function.returnVariables)
+						visitVariableName(_argument.name);
+					ASTWalker::operator()(_function);
+					m_currentFunction = originalFunctionName;
+				}
+				void visitVariableName(YulString _var)
+				{
+					if (!_var.empty() && _var.str().front() == '$')
+						if (!util::contains(fakeUnreachables[m_currentFunction], _var))
+							fakeUnreachables[m_currentFunction].emplace_back(_var);
+				}
+				void operator()(VariableDeclaration const& _varDecl) override
+				{
+					for (auto const& var: _varDecl.variables)
+						visitVariableName(var.name);
+					ASTWalker::operator()(_varDecl);
+				}
+				void operator()(Identifier const& _identifier) override
+				{
+					visitVariableName(_identifier.name);
+					ASTWalker::operator()(_identifier);
+				}
+				YulString m_currentFunction = YulString{};
+			};
+			FakeUnreachableGenerator fakeUnreachableGenerator;
+			fakeUnreachableGenerator(*m_ast);
+			StackLimitEvader::run(*m_context, *m_object, fakeUnreachableGenerator.fakeUnreachables);
+		}}
+	};
+}
+
+void YulOptimizerTestCommon::setStep(std::string const& _optimizerStep)
+{
+	m_optimizerStep = _optimizerStep;
+}
+
+bool YulOptimizerTestCommon::runStep()
+{
+	yulAssert(m_dialect, "Dialect not set.");
+
+	updateContext();
+
+	if (m_namedSteps.count(m_optimizerStep))
+		m_namedSteps[m_optimizerStep]();
+	else
+		return false;
+
+	return true;
+}
+
+std::string YulOptimizerTestCommon::randomOptimiserStep(unsigned _seed)
+{
+	std::mt19937 prng(_seed);
+	std::uniform_int_distribution<size_t> dist(1, m_namedSteps.size());
+	size_t idx = dist(prng);
+	size_t count = 1;
+	for (auto &step: m_namedSteps)
+	{
+		if (count == idx)
+		{
+			std::string optimiserStep = step.first;
+			// Do not fuzz mainFunction and wordSizeTransform
+			// because they do not preserve yul code semantics.
+			// Do not fuzz reasoning based simplifier because
+			// it can sometimes drain memory.
+			if (
+				optimiserStep == "mainFunction"	||
+				optimiserStep == "wordSizeTransform"
+			)
+				// "Fullsuite" is fuzzed roughly four times more frequently than
+				// other steps because of the filtering in place above.
+				return "fullSuite";
+			else
+				return optimiserStep;
+		}
+		count++;
+	}
+	yulAssert(false, "Optimiser step selection failed.");
+}
+
+std::shared_ptr<Block> YulOptimizerTestCommon::run()
+{
+	return runStep() ? m_ast : nullptr;
+}
+
+void YulOptimizerTestCommon::disambiguate()
+{
+	*m_object->code = std::get<Block>(Disambiguator(*m_dialect, *m_analysisInfo)(*m_object->code));
+	m_analysisInfo.reset();
+	updateContext();
+}
+
+void YulOptimizerTestCommon::updateContext()
+{
+	m_nameDispenser = std::make_unique<NameDispenser>(*m_dialect, *m_object->code, m_reservedIdentifiers);
+	m_context = std::make_unique<OptimiserStepContext>(OptimiserStepContext{
+		*m_dialect,
+		*m_nameDispenser,
+		m_reservedIdentifiers,
+		frontend::OptimiserSettings::standard().expectedExecutionsPerDeployment
+	});
+}
diff --git a/compiler/test/libyul/evmCodeTransform/after_terminating_function.yul b/compiler/test/libyul/evmCodeTransform/after_terminating_function.yul
new file mode 100644
index 00000000..ee32b443
--- /dev/null
+++ b/compiler/test/libyul/evmCodeTransform/after_terminating_function.yul
@@ -0,0 +1,22 @@
+{
+	let b := f(1, 2)
+	function f(a, r) -> t { revert(0, 0) }
+	b := f(3, 4)
+}
+// ====
+// stackOptimization: true
+// ----
+//     /* "":17:18   */
+//   0x02
+//     /* "":14:15   */
+//   0x01
+//     /* "":12:19   */
+//   tag_1
+//   jump	// in
+//     /* "":21:59   */
+// tag_1:
+//     /* "":55:56   */
+//   0x00
+//     /* "":45:57   */
+//   dup1
+//   revert
diff --git a/compiler/test/libyul/evmCodeTransform/stackReuse/function_argument_reuse_without_retparams.yul b/compiler/test/libyul/evmCodeTransform/stackReuse/function_argument_reuse_without_retparams.yul
new file mode 100644
index 00000000..b5cc6118
--- /dev/null
+++ b/compiler/test/libyul/evmCodeTransform/stackReuse/function_argument_reuse_without_retparams.yul
@@ -0,0 +1,38 @@
+{
+  function f(x, y) {
+    mstore(0x80, x)
+    if calldataload(0) { sstore(y, y) }
+  }
+}
+// ====
+// stackOptimization: true
+// EVMVersion: >=shanghai
+// ----
+//     /* "":0:88   */
+//   stop
+//     /* "":4:86   */
+// tag_1:
+//     /* "":34:38   */
+//   0x80
+//     /* "":27:42   */
+//   mstore
+//     /* "":63:64   */
+//   0x00
+//     /* "":50:65   */
+//   calldataload
+//     /* "":47:82   */
+//   tag_2
+//   jumpi
+//     /* "":21:86   */
+// tag_3:
+//     /* "":4:86   */
+//   pop
+//   jump	// out
+//     /* "":66:82   */
+// tag_2:
+//     /* "":68:80   */
+//   dup1
+//   sstore
+//     /* "":66:82   */
+//   0x00
+//   jump(tag_3)
diff --git a/compiler/test/libyul/evmCodeTransform/unassigned_return_variable.yul b/compiler/test/libyul/evmCodeTransform/unassigned_return_variable.yul
new file mode 100644
index 00000000..666fefe1
--- /dev/null
+++ b/compiler/test/libyul/evmCodeTransform/unassigned_return_variable.yul
@@ -0,0 +1,19 @@
+{
+  // This used to throw during stack layout generation.
+  function g(b,s) -> y {
+    y := g(b, g(y, s))
+  }
+}
+// ====
+// stackOptimization: true
+// ----
+//     /* "":0:111   */
+//   stop
+//     /* "":60:109   */
+// tag_1:
+//   pop
+//     /* "":99:100   */
+//   0x00
+//     /* "":97:104   */
+//   tag_1
+//   jump	// in
diff --git a/compiler/test/libyul/objectCompiler/data.yul b/compiler/test/libyul/objectCompiler/data.yul
new file mode 100644
index 00000000..caa64992
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/data.yul
@@ -0,0 +1,14 @@
+object "a" {
+  code {}
+  // Unreferenced data is not added to the assembled bytecode.
+  data "str" "Hello, World!"
+}
+// ----
+// Assembly:
+//     /* "source":20:22   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// Bytecode: 00fe
+// Opcodes: STOP INVALID
+// SourceMappings: 20:2:0:-:0
diff --git a/compiler/test/libyul/objectCompiler/datacopy.yul b/compiler/test/libyul/objectCompiler/datacopy.yul
new file mode 100644
index 00000000..cb9fbcb1
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/datacopy.yul
@@ -0,0 +1,52 @@
+object "a" {
+  code {
+    datacopy(0, dataoffset("sub"), datasize("sub"))
+    return(0, datasize("sub"))
+  }
+  object "sub" {
+    code {
+      sstore(0, dataoffset("sub"))
+      mstore(0, datasize("data1"))
+    }
+    data "data1" "Hello, World!"
+  }
+}
+// ----
+// Assembly:
+//     /* "source":57:72   */
+//   dataSize(sub_0)
+//     /* "source":38:55   */
+//   dataOffset(sub_0)
+//     /* "source":35:36   */
+//   0x00
+//     /* "source":26:73   */
+//   codecopy
+//     /* "source":88:103   */
+//   dataSize(sub_0)
+//     /* "source":85:86   */
+//   0x00
+//     /* "source":78:104   */
+//   return
+// stop
+//
+// sub_0: assembly {
+//         /* "source":153:170   */
+//       0x00
+//         /* "source":150:151   */
+//       dup1
+//         /* "source":143:171   */
+//       sstore
+//         /* "source":188:205   */
+//       0x0d
+//         /* "source":185:186   */
+//       0x00
+//         /* "source":178:206   */
+//       mstore
+//         /* "source":135:212   */
+//       stop
+//     stop
+//     data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// }
+// Bytecode: 6009600b5f3960095ff3fe5f8055600d5f5200fe
+// Opcodes: PUSH1 0x9 PUSH1 0xB PUSH0 CODECOPY PUSH1 0x9 PUSH0 RETURN INVALID PUSH0 DUP1 SSTORE PUSH1 0xD PUSH0 MSTORE STOP INVALID
+// SourceMappings: 57:15:0:-:0;38:17;35:1;26:47;88:15;85:1;78:26
diff --git a/compiler/test/libyul/objectCompiler/dataoffset_code.yul b/compiler/test/libyul/objectCompiler/dataoffset_code.yul
new file mode 100644
index 00000000..58521c87
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/dataoffset_code.yul
@@ -0,0 +1,34 @@
+object "a" {
+  code { sstore(0, dataoffset("sub")) }
+  object "sub" {
+    code { sstore(0, 8) }
+    data "data1" "Hello, World!"
+  }
+}
+// ----
+// Assembly:
+//     /* "source":32:49   */
+//   dataOffset(sub_0)
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:50   */
+//   sstore
+//     /* "source":20:52   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":91:92   */
+//       0x08
+//         /* "source":88:89   */
+//       0x00
+//         /* "source":81:93   */
+//       sstore
+//         /* "source":79:95   */
+//       stop
+//     stop
+//     data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// }
+// Bytecode: 60065f5500fe60085f5500fe
+// Opcodes: PUSH1 0x6 PUSH0 SSTORE STOP INVALID PUSH1 0x8 PUSH0 SSTORE STOP INVALID
+// SourceMappings: 32:17:0:-:0;29:1;22:28;20:32
diff --git a/compiler/test/libyul/objectCompiler/dataoffset_data.yul b/compiler/test/libyul/objectCompiler/dataoffset_data.yul
new file mode 100644
index 00000000..61f0c441
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/dataoffset_data.yul
@@ -0,0 +1,19 @@
+object "a" {
+  code { sstore(0, dataoffset("data1")) }
+  data "data1" "Hello, World!"
+}
+// ----
+// Assembly:
+//     /* "source":32:51   */
+//   data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:52   */
+//   sstore
+//     /* "source":20:54   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// Bytecode: 60065f5500fe48656c6c6f2c20576f726c6421
+// Opcodes: PUSH1 0x6 PUSH0 SSTORE STOP INVALID BASEFEE PUSH6 0x6C6C6F2C2057 PUSH16 0x726C6421000000000000000000000000
+// SourceMappings: 32:19:0:-:0;29:1;22:30;20:34
diff --git a/compiler/test/libyul/objectCompiler/dataoffset_self.yul b/compiler/test/libyul/objectCompiler/dataoffset_self.yul
new file mode 100644
index 00000000..7c38b950
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/dataoffset_self.yul
@@ -0,0 +1,19 @@
+object "a" {
+  code { sstore(0, dataoffset("a")) }
+  data "data1" "Hello, World!"
+}
+// ----
+// Assembly:
+//     /* "source":32:47   */
+//   0x00
+//     /* "source":29:30   */
+//   dup1
+//     /* "source":22:48   */
+//   sstore
+//     /* "source":20:50   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// Bytecode: 5f805500fe
+// Opcodes: PUSH0 DUP1 SSTORE STOP INVALID
+// SourceMappings: 32:15:0:-:0;29:1;22:26;20:30
diff --git a/compiler/test/libyul/objectCompiler/datasize_code.yul b/compiler/test/libyul/objectCompiler/datasize_code.yul
new file mode 100644
index 00000000..4e559ab8
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/datasize_code.yul
@@ -0,0 +1,34 @@
+object "a" {
+  code { sstore(0, datasize("sub")) }
+  object "sub" {
+    code { sstore(0, 8) }
+    data "data1" "Hello, World!"
+  }
+}
+// ----
+// Assembly:
+//     /* "source":32:47   */
+//   dataSize(sub_0)
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:48   */
+//   sstore
+//     /* "source":20:50   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":89:90   */
+//       0x08
+//         /* "source":86:87   */
+//       0x00
+//         /* "source":79:91   */
+//       sstore
+//         /* "source":77:93   */
+//       stop
+//     stop
+//     data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// }
+// Bytecode: 60065f5500fe
+// Opcodes: PUSH1 0x6 PUSH0 SSTORE STOP INVALID
+// SourceMappings: 32:15:0:-:0;29:1;22:26;20:30
diff --git a/compiler/test/libyul/objectCompiler/datasize_data.yul b/compiler/test/libyul/objectCompiler/datasize_data.yul
new file mode 100644
index 00000000..3281bd9b
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/datasize_data.yul
@@ -0,0 +1,19 @@
+object "a" {
+  code { sstore(0, datasize("data1")) }
+  data "data1" "Hello, World!"
+}
+// ----
+// Assembly:
+//     /* "source":32:49   */
+//   0x0d
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:50   */
+//   sstore
+//     /* "source":20:52   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// Bytecode: 600d5f5500fe
+// Opcodes: PUSH1 0xD PUSH0 SSTORE STOP INVALID
+// SourceMappings: 32:17:0:-:0;29:1;22:28;20:32
diff --git a/compiler/test/libyul/objectCompiler/datasize_self.yul b/compiler/test/libyul/objectCompiler/datasize_self.yul
new file mode 100644
index 00000000..6bc520af
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/datasize_self.yul
@@ -0,0 +1,19 @@
+object "a" {
+  code { sstore(0, datasize("a")) }
+  data "data1" "Hello, World!"
+}
+// ----
+// Assembly:
+//     /* "source":32:45   */
+//   bytecodeSize
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:46   */
+//   sstore
+//     /* "source":20:48   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// Bytecode: 60065f5500fe
+// Opcodes: PUSH1 0x6 PUSH0 SSTORE STOP INVALID
+// SourceMappings: 32:13:0:-:0;29:1;22:24;20:28
diff --git a/compiler/test/libyul/objectCompiler/function_series.yul b/compiler/test/libyul/objectCompiler/function_series.yul
new file mode 100644
index 00000000..7be2db96
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/function_series.yul
@@ -0,0 +1,39 @@
+object "Contract" {
+  code {
+    function f() {}
+    function g() {}
+    sstore(0, 1)
+
+    // NOTE: msize forces the compiler to completely disable the Yul optimizer.
+    // Otherwise the functions would get optimized out.
+    pop(msize())
+  }
+}
+
+// ====
+// optimizationPreset: none
+// ----
+// Assembly:
+//     /* "source":33:48   */
+//   jump(tag_3)
+// tag_1:
+// tag_4:
+//   jump	// out
+//     /* "source":53:68   */
+// tag_2:
+// tag_5:
+//   jump	// out
+// tag_3:
+//     /* "source":83:84   */
+//   0x01
+//     /* "source":80:81   */
+//   0x00
+//     /* "source":73:85   */
+//   sstore
+//     /* "source":231:238   */
+//   msize
+//     /* "source":227:239   */
+//   pop
+// Bytecode: 6009565b5b565b5b565b60015f555950
+// Opcodes: PUSH1 0x9 JUMP JUMPDEST JUMPDEST JUMP JUMPDEST JUMPDEST JUMP JUMPDEST PUSH1 0x1 PUSH0 SSTORE MSIZE POP
+// SourceMappings: 33:15:0:-:0;;;;:::o;53:::-;;:::o;:::-;83:1;80;73:12;231:7;227:12
diff --git a/compiler/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul b/compiler/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul
new file mode 100644
index 00000000..285a8a8d
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/immutable_long_name_does_not_end_up_in_bytecode.yul
@@ -0,0 +1,22 @@
+object "a" {
+    code {
+        setimmutable(
+            0,
+            "long___name___that___definitely___exceeds___the___thirty___two___byte___limit",
+             0x1234567890123456789012345678901234567890
+        )
+    }
+}
+// ----
+// Assembly:
+//     /* "source":167:209   */
+//   0x1234567890123456789012345678901234567890
+//     /* "source":58:59   */
+//   0x00
+//     /* "source":32:219   */
+//   assignImmutable("0x85a5b1db611c82c46f5fa18e39ae218397536256c451e5de155a86de843a9ad6")
+//     /* "source":22:225   */
+//   stop
+// Bytecode: 7312345678901234567890123456789012345678905f505000
+// Opcodes: PUSH20 0x1234567890123456789012345678901234567890 PUSH0 POP POP STOP
+// SourceMappings: 167:42:0:-:0;58:1;32:187;;22:203
diff --git a/compiler/test/libyul/objectCompiler/jump_tags.yul b/compiler/test/libyul/objectCompiler/jump_tags.yul
new file mode 100644
index 00000000..0d1f1ff7
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/jump_tags.yul
@@ -0,0 +1,75 @@
+object "Contract" {
+  code {
+    function f() { g(1) }
+    function g(x) { if x { leave } g(add(x, 2)) }
+    g(1)
+
+    // NOTE: msize forces the compiler to completely disable the Yul optimizer.
+    // Otherwise f() would get optimized out.
+    pop(msize())
+  }
+}
+
+// ====
+// optimizationPreset: none
+// ----
+// Assembly:
+//     /* "source":33:54   */
+//   jump(tag_3)
+// tag_1:
+//     /* "source":48:52   */
+//   tag_5
+//     /* "source":50:51   */
+//   0x01
+//     /* "source":48:52   */
+//   tag_2
+//   jump	// in
+// tag_5:
+//     /* "source":33:54   */
+// tag_4:
+//   jump	// out
+//     /* "source":59:104   */
+// tag_2:
+//     /* "source":78:79   */
+//   dup1
+//     /* "source":75:89   */
+//   iszero
+//   tag_7
+//   jumpi
+//     /* "source":82:87   */
+//   pop
+//   jump(tag_6)
+//     /* "source":75:89   */
+// tag_7:
+//     /* "source":90:102   */
+//   tag_8
+//     /* "source":99:100   */
+//   0x02
+//     /* "source":96:97   */
+//   dup3
+//     /* "source":92:101   */
+//   add
+//     /* "source":90:102   */
+//   tag_2
+//   jump	// in
+// tag_8:
+//     /* "source":59:104   */
+//   pop
+// tag_6:
+//   jump	// out
+// tag_3:
+//     /* "source":109:113   */
+//   tag_9
+//     /* "source":111:112   */
+//   0x01
+//     /* "source":109:113   */
+//   tag_2
+//   jump	// in
+// tag_9:
+//     /* "source":249:256   */
+//   msize
+//     /* "source":245:257   */
+//   pop
+// Bytecode: 6026565b600b6001600e565b5b565b8015601857506024565b602260028201600e565b505b565b602e6001600e565b5950
+// Opcodes: PUSH1 0x26 JUMP JUMPDEST PUSH1 0xB PUSH1 0x1 PUSH1 0xE JUMP JUMPDEST JUMPDEST JUMP JUMPDEST DUP1 ISZERO PUSH1 0x18 JUMPI POP PUSH1 0x24 JUMP JUMPDEST PUSH1 0x22 PUSH1 0x2 DUP3 ADD PUSH1 0xE JUMP JUMPDEST POP JUMPDEST JUMP JUMPDEST PUSH1 0x2E PUSH1 0x1 PUSH1 0xE JUMP JUMPDEST MSIZE POP
+// SourceMappings: 33:21:0:-:0;;;48:4;50:1;48:4;:::i;:::-;33:21;:::o;59:45::-;78:1;75:14;;;82:5;;;75:14;90:12;99:1;96;92:9;90:12;:::i;:::-;59:45;;:::o;:::-;109:4;111:1;109:4;:::i;:::-;249:7;245:12
diff --git a/compiler/test/libyul/objectCompiler/linkersymbol.yul b/compiler/test/libyul/objectCompiler/linkersymbol.yul
new file mode 100644
index 00000000..c4da288e
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/linkersymbol.yul
@@ -0,0 +1,37 @@
+object "a" {
+    code {
+        let addr := linkersymbol("contract/test.sol:L")
+        mstore(128, shl(227, 0x18530aaf))
+        let success := call(gas(), addr, 0, 128, 4, 128, 0)
+    }
+}
+// ----
+// Assembly:
+//     /* "source":179:180   */
+//   0x00
+//     /* "source":174:177   */
+//   0x80
+//     /* "source":171:172   */
+//   0x04
+//     /* "source":44:79   */
+//   dup2
+//   dup4
+//   linkerSymbol("f919ba91ac99f96129544b80b9516b27a80e376b9dc693819d0b18b7e0395612")
+//     /* "source":109:119   */
+//   0x18530aaf
+//     /* "source":104:107   */
+//   0xe3
+//     /* "source":100:120   */
+//   shl
+//     /* "source":88:121   */
+//   dup4
+//   mstore
+//     /* "source":150:155   */
+//   gas
+//     /* "source":145:181   */
+//   call
+//     /* "source":130:181   */
+//   stop
+// Bytecode: 5f6080600481837300000000000000000000000000000000000000006318530aaf60e31b83525af100
+// Opcodes: PUSH0 PUSH1 0x80 PUSH1 0x4 DUP2 DUP4 PUSH20 0x0 PUSH4 0x18530AAF PUSH1 0xE3 SHL DUP4 MSTORE GAS CALL STOP
+// SourceMappings: 179:1:0:-:0;174:3;171:1;44:35;;;109:10;104:3;100:20;88:33;;150:5;145:36;130:51
diff --git a/compiler/test/libyul/objectCompiler/long_object_name.yul b/compiler/test/libyul/objectCompiler/long_object_name.yul
new file mode 100644
index 00000000..aa2dd1ac
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/long_object_name.yul
@@ -0,0 +1,29 @@
+object "t" {
+	code {
+		sstore(0, datasize("name_that_is_longer_than_32_bytes_name_that_is_longer_than_32_bytes_name_that_is_longer_than_32_bytes"))
+	}
+	object "name_that_is_longer_than_32_bytes_name_that_is_longer_than_32_bytes_name_that_is_longer_than_32_bytes" {
+		code {}
+	}
+}
+// ====
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":33:146   */
+//   dataSize(sub_0)
+//     /* "source":30:31   */
+//   0x00
+//     /* "source":23:147   */
+//   sstore
+//     /* "source":19:150   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":272:274   */
+//       stop
+// }
+// Bytecode: 60015f5500fe
+// Opcodes: PUSH1 0x1 PUSH0 SSTORE STOP INVALID
+// SourceMappings: 33:113:0:-:0;30:1;23:124;19:131
diff --git a/compiler/test/libyul/objectCompiler/manySubObjects.yul b/compiler/test/libyul/objectCompiler/manySubObjects.yul
new file mode 100644
index 00000000..2f4b1638
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/manySubObjects.yul
@@ -0,0 +1,475 @@
+object "root" {
+    code {
+        sstore(0, datasize("root"))
+        sstore(1, datasize("0"))
+        sstore(2, datasize("1"))
+        sstore(3, datasize("2"))
+        sstore(4, datasize("3"))
+        sstore(5, datasize("4"))
+        sstore(6, datasize("5"))
+        sstore(7, datasize("6"))
+        sstore(8, datasize("7"))
+        sstore(9, datasize("8"))
+        sstore(10, datasize("9"))
+        sstore(11, datasize("a"))
+        sstore(12, datasize("b"))
+        sstore(13, datasize("c"))
+        sstore(14, datasize("d"))
+        sstore(15, datasize("e"))
+        sstore(16, datasize("f"))
+        sstore(17, datasize("10"))
+    }
+
+    object "0" {
+        code {
+            sstore(100, 0)
+            sstore(200, datasize("sub0"))
+        }
+        object "sub0" {
+            code {
+                sstore(300, 0)
+            }
+        }
+    }
+
+    object "1" {
+        code {
+            sstore(100, 1)
+        }
+    }
+
+    object "2" {
+        code {
+            sstore(101, 2)
+        }
+    }
+
+    object "3" {
+        code {
+            sstore(102, 3)
+        }
+    }
+
+    object "4" {
+        code {
+            sstore(103, 4)
+        }
+    }
+
+    object "5" {
+        code {
+            sstore(104, 5)
+        }
+    }
+
+    object "6" {
+        code {
+            sstore(105, 6)
+        }
+    }
+
+    object "7" {
+        code {
+            sstore(106, 7)
+        }
+    }
+
+    object "8" {
+        code {
+            sstore(107, 8)
+        }
+    }
+
+    object "9" {
+        code {
+            sstore(108, 9)
+        }
+    }
+
+    object "a" {
+        code {
+            sstore(109, 10)
+        }
+    }
+
+    object "b" {
+        code {
+            sstore(110, 11)
+        }
+    }
+
+    object "c" {
+        code {
+            sstore(111, 12)
+        }
+    }
+
+    object "d" {
+        code {
+            sstore(112, 13)
+        }
+    }
+
+    object "e" {
+        code {
+            sstore(113, 14)
+        }
+    }
+
+    object "f" {
+        code {
+            sstore(114, 15)
+        }
+    }
+
+    object "10" {
+        code {
+            sstore(115, 16)
+            sstore(201, datasize("sub10"))
+        }
+        object "sub10" {
+            code {
+                sstore(300, 16)
+            }
+        }
+    }
+}
+// ----
+// Assembly:
+//     /* "source":45:61   */
+//   bytecodeSize
+//     /* "source":42:43   */
+//   0x00
+//     /* "source":35:62   */
+//   sstore
+//     /* "source":81:94   */
+//   dataSize(sub_0)
+//     /* "source":78:79   */
+//   0x01
+//     /* "source":71:95   */
+//   sstore
+//     /* "source":114:127   */
+//   dataSize(sub_1)
+//     /* "source":111:112   */
+//   0x02
+//     /* "source":104:128   */
+//   sstore
+//     /* "source":147:160   */
+//   dataSize(sub_2)
+//     /* "source":144:145   */
+//   0x03
+//     /* "source":137:161   */
+//   sstore
+//     /* "source":180:193   */
+//   dataSize(sub_3)
+//     /* "source":177:178   */
+//   0x04
+//     /* "source":170:194   */
+//   sstore
+//     /* "source":213:226   */
+//   dataSize(sub_4)
+//     /* "source":210:211   */
+//   0x05
+//     /* "source":203:227   */
+//   sstore
+//     /* "source":246:259   */
+//   dataSize(sub_5)
+//     /* "source":243:244   */
+//   0x06
+//     /* "source":236:260   */
+//   sstore
+//     /* "source":279:292   */
+//   dataSize(sub_6)
+//     /* "source":276:277   */
+//   0x07
+//     /* "source":269:293   */
+//   sstore
+//     /* "source":312:325   */
+//   dataSize(sub_7)
+//     /* "source":309:310   */
+//   0x08
+//     /* "source":302:326   */
+//   sstore
+//     /* "source":345:358   */
+//   dataSize(sub_8)
+//     /* "source":342:343   */
+//   0x09
+//     /* "source":335:359   */
+//   sstore
+//     /* "source":379:392   */
+//   dataSize(sub_9)
+//     /* "source":375:377   */
+//   0x0a
+//     /* "source":368:393   */
+//   sstore
+//     /* "source":413:426   */
+//   dataSize(sub_10)
+//     /* "source":409:411   */
+//   0x0b
+//     /* "source":402:427   */
+//   sstore
+//     /* "source":447:460   */
+//   dataSize(sub_11)
+//     /* "source":443:445   */
+//   0x0c
+//     /* "source":436:461   */
+//   sstore
+//     /* "source":481:494   */
+//   dataSize(sub_12)
+//     /* "source":477:479   */
+//   0x0d
+//     /* "source":470:495   */
+//   sstore
+//     /* "source":515:528   */
+//   dataSize(sub_13)
+//     /* "source":511:513   */
+//   0x0e
+//     /* "source":504:529   */
+//   sstore
+//     /* "source":549:562   */
+//   dataSize(sub_14)
+//     /* "source":545:547   */
+//   0x0f
+//     /* "source":538:563   */
+//   sstore
+//     /* "source":583:596   */
+//   dataSize(sub_15)
+//     /* "source":579:581   */
+//   0x10
+//     /* "source":572:597   */
+//   sstore
+//     /* "source":617:631   */
+//   dataSize(sub_16)
+//     /* "source":613:615   */
+//   0x11
+//     /* "source":606:632   */
+//   sstore
+//     /* "source":25:638   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":696:697   */
+//       0x00
+//         /* "source":691:694   */
+//       0x64
+//         /* "source":684:698   */
+//       sstore
+//         /* "source":723:739   */
+//       dataSize(sub_0)
+//         /* "source":718:721   */
+//       0xc8
+//         /* "source":711:740   */
+//       sstore
+//         /* "source":670:750   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":822:823   */
+//           0x00
+//             /* "source":817:820   */
+//           0x012c
+//             /* "source":810:824   */
+//           sstore
+//             /* "source":792:838   */
+//           stop
+//     }
+// }
+//
+// sub_1: assembly {
+//         /* "source":912:913   */
+//       0x01
+//         /* "source":907:910   */
+//       0x64
+//         /* "source":900:914   */
+//       sstore
+//         /* "source":886:924   */
+//       stop
+// }
+//
+// sub_2: assembly {
+//         /* "source":988:989   */
+//       0x02
+//         /* "source":983:986   */
+//       0x65
+//         /* "source":976:990   */
+//       sstore
+//         /* "source":962:1000   */
+//       stop
+// }
+//
+// sub_3: assembly {
+//         /* "source":1064:1065   */
+//       0x03
+//         /* "source":1059:1062   */
+//       0x66
+//         /* "source":1052:1066   */
+//       sstore
+//         /* "source":1038:1076   */
+//       stop
+// }
+//
+// sub_4: assembly {
+//         /* "source":1140:1141   */
+//       0x04
+//         /* "source":1135:1138   */
+//       0x67
+//         /* "source":1128:1142   */
+//       sstore
+//         /* "source":1114:1152   */
+//       stop
+// }
+//
+// sub_5: assembly {
+//         /* "source":1216:1217   */
+//       0x05
+//         /* "source":1211:1214   */
+//       0x68
+//         /* "source":1204:1218   */
+//       sstore
+//         /* "source":1190:1228   */
+//       stop
+// }
+//
+// sub_6: assembly {
+//         /* "source":1292:1293   */
+//       0x06
+//         /* "source":1287:1290   */
+//       0x69
+//         /* "source":1280:1294   */
+//       sstore
+//         /* "source":1266:1304   */
+//       stop
+// }
+//
+// sub_7: assembly {
+//         /* "source":1368:1369   */
+//       0x07
+//         /* "source":1363:1366   */
+//       0x6a
+//         /* "source":1356:1370   */
+//       sstore
+//         /* "source":1342:1380   */
+//       stop
+// }
+//
+// sub_8: assembly {
+//         /* "source":1444:1445   */
+//       0x08
+//         /* "source":1439:1442   */
+//       0x6b
+//         /* "source":1432:1446   */
+//       sstore
+//         /* "source":1418:1456   */
+//       stop
+// }
+//
+// sub_9: assembly {
+//         /* "source":1520:1521   */
+//       0x09
+//         /* "source":1515:1518   */
+//       0x6c
+//         /* "source":1508:1522   */
+//       sstore
+//         /* "source":1494:1532   */
+//       stop
+// }
+//
+// sub_10: assembly {
+//         /* "source":1596:1598   */
+//       0x0a
+//         /* "source":1591:1594   */
+//       0x6d
+//         /* "source":1584:1599   */
+//       sstore
+//         /* "source":1570:1609   */
+//       stop
+// }
+//
+// sub_11: assembly {
+//         /* "source":1673:1675   */
+//       0x0b
+//         /* "source":1668:1671   */
+//       0x6e
+//         /* "source":1661:1676   */
+//       sstore
+//         /* "source":1647:1686   */
+//       stop
+// }
+//
+// sub_12: assembly {
+//         /* "source":1750:1752   */
+//       0x0c
+//         /* "source":1745:1748   */
+//       0x6f
+//         /* "source":1738:1753   */
+//       sstore
+//         /* "source":1724:1763   */
+//       stop
+// }
+//
+// sub_13: assembly {
+//         /* "source":1827:1829   */
+//       0x0d
+//         /* "source":1822:1825   */
+//       0x70
+//         /* "source":1815:1830   */
+//       sstore
+//         /* "source":1801:1840   */
+//       stop
+// }
+//
+// sub_14: assembly {
+//         /* "source":1904:1906   */
+//       0x0e
+//         /* "source":1899:1902   */
+//       0x71
+//         /* "source":1892:1907   */
+//       sstore
+//         /* "source":1878:1917   */
+//       stop
+// }
+//
+// sub_15: assembly {
+//         /* "source":1981:1983   */
+//       0x0f
+//         /* "source":1976:1979   */
+//       0x72
+//         /* "source":1969:1984   */
+//       sstore
+//         /* "source":1955:1994   */
+//       stop
+// }
+//
+// sub_16: assembly {
+//         /* "source":2059:2061   */
+//       0x10
+//         /* "source":2054:2057   */
+//       0x73
+//         /* "source":2047:2062   */
+//       sstore
+//         /* "source":2087:2104   */
+//       dataSize(sub_0)
+//         /* "source":2082:2085   */
+//       0xc9
+//         /* "source":2075:2105   */
+//       sstore
+//         /* "source":2033:2115   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":2188:2190   */
+//           0x10
+//             /* "source":2183:2186   */
+//           0x012c
+//             /* "source":2176:2191   */
+//           sstore
+//             /* "source":2158:2205   */
+//           stop
+//     }
+// }
+// Bytecode: 61005c5f55600b600155600660025560066003556006600455600660055560066006556006600755600660085560066009556006600a556006600b556006600c556006600d556006600e556006600f556006601055600c60115500fe
+// Opcodes: PUSH2 0x5C PUSH0 SSTORE PUSH1 0xB PUSH1 0x1 SSTORE PUSH1 0x6 PUSH1 0x2 SSTORE PUSH1 0x6 PUSH1 0x3 SSTORE PUSH1 0x6 PUSH1 0x4 SSTORE PUSH1 0x6 PUSH1 0x5 SSTORE PUSH1 0x6 PUSH1 0x6 SSTORE PUSH1 0x6 PUSH1 0x7 SSTORE PUSH1 0x6 PUSH1 0x8 SSTORE PUSH1 0x6 PUSH1 0x9 SSTORE PUSH1 0x6 PUSH1 0xA SSTORE PUSH1 0x6 PUSH1 0xB SSTORE PUSH1 0x6 PUSH1 0xC SSTORE PUSH1 0x6 PUSH1 0xD SSTORE PUSH1 0x6 PUSH1 0xE SSTORE PUSH1 0x6 PUSH1 0xF SSTORE PUSH1 0x6 PUSH1 0x10 SSTORE PUSH1 0xC PUSH1 0x11 SSTORE STOP INVALID
+// SourceMappings: 45:16:0:-:0;42:1;35:27;81:13;78:1;71:24;114:13;111:1;104:24;147:13;144:1;137:24;180:13;177:1;170:24;213:13;210:1;203:24;246:13;243:1;236:24;279:13;276:1;269:24;312:13;309:1;302:24;345:13;342:1;335:24;379:13;375:2;368:25;413:13;409:2;402:25;447:13;443:2;436:25;481:13;477:2;470:25;515:13;511:2;504:25;549:13;545:2;538:25;583:13;579:2;572:25;617:14;613:2;606:26;25:613
diff --git a/compiler/test/libyul/objectCompiler/metadata.yul b/compiler/test/libyul/objectCompiler/metadata.yul
new file mode 100644
index 00000000..335522d0
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/metadata.yul
@@ -0,0 +1,62 @@
+object "A" {
+  code {
+    let x := datasize("x")
+    let c := datasize("C")
+    sstore(0, x)
+    sstore(32, c)
+  }
+
+  object "B" {
+    code {
+      let o := dataoffset("other")
+      sstore(0, o)
+    }
+    data ".metadata" "M1"
+    data "other" "Hello, World2!"
+  }
+
+  data "C" "ABC"
+  data ".metadata" "M2"
+  data "x" "Hello, World2!"
+}
+// ----
+// Assembly:
+//     /* "source":35:48   */
+//   0x0e
+//     /* "source":62:75   */
+//   0x03
+//     /* "source":80:92   */
+//   swap1
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":80:92   */
+//   sstore
+//     /* "source":104:106   */
+//   0x20
+//     /* "source":97:110   */
+//   sstore
+//     /* "source":20:114   */
+//   stop
+// stop
+// data_211450822d7f8c345093893187e7e1fbebc4ec67af72601920194be14104e336 48656c6c6f2c20576f726c643221
+// data_e1629b9dda060bb30c7908346f6af189c16773fa148d3366701fbaa35d54f3c8 414243
+//
+// sub_0: assembly {
+//         /* "source":157:176   */
+//       data_211450822d7f8c345093893187e7e1fbebc4ec67af72601920194be14104e336
+//         /* "source":190:191   */
+//       0x00
+//         /* "source":183:195   */
+//       sstore
+//         /* "source":140:201   */
+//       stop
+//     stop
+//     data_211450822d7f8c345093893187e7e1fbebc4ec67af72601920194be14104e336 48656c6c6f2c20576f726c643221
+//
+//     auxdata: 0x4d31
+// }
+//
+// auxdata: 0x4d32
+// Bytecode: 600e6003905f5560205500fe4d32
+// Opcodes: PUSH1 0xE PUSH1 0x3 SWAP1 PUSH0 SSTORE PUSH1 0x20 SSTORE STOP INVALID 0x4D ORIGIN
+// SourceMappings: 35:13:0:-:0;62;80:12;87:1;80:12;104:2;97:13;20:94
diff --git a/compiler/test/libyul/objectCompiler/namedObject.yul b/compiler/test/libyul/objectCompiler/namedObject.yul
new file mode 100644
index 00000000..d55c3ca2
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/namedObject.yul
@@ -0,0 +1,10 @@
+object "a" {
+  code {}
+}
+// ----
+// Assembly:
+//     /* "source":20:22   */
+//   stop
+// Bytecode: 00
+// Opcodes: STOP
+// SourceMappings: 20:2:0:-:0
diff --git a/compiler/test/libyul/objectCompiler/namedObjectCode.yul b/compiler/test/libyul/objectCompiler/namedObjectCode.yul
new file mode 100644
index 00000000..5936aa74
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/namedObjectCode.yul
@@ -0,0 +1,16 @@
+object "a" {
+  code { sstore(0, 1) }
+}
+// ----
+// Assembly:
+//     /* "source":32:33   */
+//   0x01
+//     /* "source":29:30   */
+//   0x00
+//     /* "source":22:34   */
+//   sstore
+//     /* "source":20:36   */
+//   stop
+// Bytecode: 60015f5500
+// Opcodes: PUSH1 0x1 PUSH0 SSTORE STOP
+// SourceMappings: 32:1:0:-:0;29;22:12;20:16
diff --git a/compiler/test/libyul/objectCompiler/nested_optimizer.yul b/compiler/test/libyul/objectCompiler/nested_optimizer.yul
new file mode 100644
index 00000000..cde1210f
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/nested_optimizer.yul
@@ -0,0 +1,45 @@
+object "a" {
+  code {
+    let x := calldataload(0)
+    let y := calldataload(0)
+    let z := sub(y, x)
+    sstore(add(x, 0), z)
+  }
+  object "sub" {
+    code {
+      let x := calldataload(0)
+      let y := calldataload(0)
+      let z := sub(y, x)
+      sstore(add(x, 0), z)
+    }
+  }
+}
+// ====
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":48:49   */
+//   0x00
+//     /* "source":35:50   */
+//   dup1
+//   calldataload
+//     /* "source":107:127   */
+//   sstore
+//     /* "source":20:131   */
+//   stop
+// stop
+//
+// sub_0: assembly {
+//         /* "source":188:189   */
+//       0x00
+//         /* "source":175:190   */
+//       dup1
+//       calldataload
+//         /* "source":253:273   */
+//       sstore
+//         /* "source":158:279   */
+//       stop
+// }
+// Bytecode: 5f80355500fe
+// Opcodes: PUSH0 DUP1 CALLDATALOAD SSTORE STOP INVALID
+// SourceMappings: 48:1:0:-:0;35:15;;107:20;20:111
diff --git a/compiler/test/libyul/objectCompiler/simple.yul b/compiler/test/libyul/objectCompiler/simple.yul
new file mode 100644
index 00000000..b84c49a5
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/simple.yul
@@ -0,0 +1,16 @@
+{
+  sstore(0, 1)
+}
+// ----
+// Assembly:
+//     /* "source":14:15   */
+//   0x01
+//     /* "source":11:12   */
+//   0x00
+//     /* "source":4:16   */
+//   sstore
+//     /* "source":0:18   */
+//   stop
+// Bytecode: 60015f5500
+// Opcodes: PUSH1 0x1 PUSH0 SSTORE STOP
+// SourceMappings: 14:1:0:-:0;11;4:12;0:18
diff --git a/compiler/test/libyul/objectCompiler/simple_optimizer.yul b/compiler/test/libyul/objectCompiler/simple_optimizer.yul
new file mode 100644
index 00000000..3ce4b7a4
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/simple_optimizer.yul
@@ -0,0 +1,22 @@
+{
+  let x := calldataload(0)
+  let y := calldataload(0)
+  let z := sub(y, x)
+  sstore(add(x, 0), z)
+}
+// ====
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":26:27   */
+//   0x00
+//     /* "source":13:28   */
+//   dup1
+//   calldataload
+//     /* "source":79:99   */
+//   sstore
+//     /* "source":0:101   */
+//   stop
+// Bytecode: 5f80355500
+// Opcodes: PUSH0 DUP1 CALLDATALOAD SSTORE STOP
+// SourceMappings: 26:1:0:-:0;13:15;;79:20;0:101
diff --git a/compiler/test/libyul/objectCompiler/smoke.yul b/compiler/test/libyul/objectCompiler/smoke.yul
new file mode 100644
index 00000000..3f1079aa
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/smoke.yul
@@ -0,0 +1,9 @@
+{
+}
+// ----
+// Assembly:
+//     /* "source":0:3   */
+//   stop
+// Bytecode: 00
+// Opcodes: STOP
+// SourceMappings: 0:3:0:-:0
diff --git a/compiler/test/libyul/objectCompiler/sourceLocations.yul b/compiler/test/libyul/objectCompiler/sourceLocations.yul
new file mode 100644
index 00000000..1c847732
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/sourceLocations.yul
@@ -0,0 +1,55 @@
+// something else
+/*-- another unrelated comment --*/
+/// @use-src 3: "abc.sol" , 2: "def.sol"
+object "a" {
+  code {
+    /// @src 3:0:2
+    datacopy(0, dataoffset("sub"), datasize("sub"))
+    return(0,
+      /** @src 2:5:6 */
+      datasize("sub")
+    )
+  }
+  /// @use-src 3: "abc.sol" , 2: "def.sol"
+  object "sub" {
+    code {
+      /// @src 2:70:72
+      sstore(0, dataoffset("sub"))
+      /**
+       * @something else
+       * @src 3:2:5
+       */
+      mstore(
+        0,
+        datasize("data1")
+        /// @src 3:90:2
+      )
+    }
+    data "data1" "Hello, World!"
+  }
+}
+// ----
+// Assembly:
+//     /* "abc.sol":0:2   */
+//   codecopy(0x00, dataOffset(sub_0), dataSize(sub_0))
+//     /* "def.sol":5:6   */
+//   dataSize(sub_0)
+//     /* "abc.sol":0:2   */
+//   0x00
+//   return
+// stop
+//
+// sub_0: assembly {
+//         /* "def.sol":70:72   */
+//       0x00
+//       dup1
+//       sstore
+//         /* "abc.sol":2:5   */
+//       mstore(0x00, 0x0d)
+//       stop
+//     stop
+//     data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+// }
+// Bytecode: 6009600b5f3960095ff3fe5f8055600d5f5200fe
+// Opcodes: PUSH1 0x9 PUSH1 0xB PUSH0 CODECOPY PUSH1 0x9 PUSH0 RETURN INVALID PUSH0 DUP1 SSTORE PUSH1 0xD PUSH0 MSTORE STOP INVALID
+// SourceMappings: 0:2::-:0;;;;5:1;0:2;
diff --git a/compiler/test/libyul/objectCompiler/subObject.yul b/compiler/test/libyul/objectCompiler/subObject.yul
new file mode 100644
index 00000000..46fc03f1
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/subObject.yul
@@ -0,0 +1,26 @@
+object "a" {
+  code {}
+  // Unreferenced data is not added to the assembled bytecode.
+  data "str" "Hello, World!"
+  object "sub" { code { sstore(0, 1) } }
+}
+// ----
+// Assembly:
+//     /* "source":20:22   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+//
+// sub_0: assembly {
+//         /* "source":149:150   */
+//       0x01
+//         /* "source":146:147   */
+//       0x00
+//         /* "source":139:151   */
+//       sstore
+//         /* "source":137:153   */
+//       stop
+// }
+// Bytecode: 00fe
+// Opcodes: STOP INVALID
+// SourceMappings: 20:2:0:-:0
diff --git a/compiler/test/libyul/objectCompiler/subObjectAccess.yul b/compiler/test/libyul/objectCompiler/subObjectAccess.yul
new file mode 100644
index 00000000..29174922
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/subObjectAccess.yul
@@ -0,0 +1,230 @@
+object "A" {
+  code {
+    let a_o := dataoffset("A")
+    let a_s := datasize("A")
+    let b_o := dataoffset("B")
+    let b_s := datasize("B")
+    let bc_o := dataoffset("B.C")
+    let bc_s := datasize("B.C")
+    let be_o := dataoffset("B.E")
+    let be_s := datasize("B.E")
+    let bcd_o := dataoffset("B.C.D")
+    let bcd_s := datasize("B.C.D")
+
+    sstore(0, a_o)
+    sstore(32, a_s)
+    sstore(64, b_o)
+    sstore(96, b_s)
+    sstore(128, bc_o)
+    sstore(160, bc_s)
+    sstore(192, be_o)
+    sstore(224, be_s)
+    sstore(256, bcd_o)
+    sstore(288, bcd_s)
+    return(0, 320)
+  }
+
+  data "data1" "Hello, World!"
+
+  object "B" {
+    code {
+      let c_o := dataoffset("C")
+      let c_s := datasize("C")
+      let e_o := dataoffset("E")
+      let e_s := datasize("E")
+      let cd_o := dataoffset("C.D")
+      let cd_s := datasize("C.D")
+
+      sstore(0, c_o)
+      sstore(32, c_s)
+      sstore(64, e_o)
+      sstore(96, e_s)
+      sstore(128, cd_o)
+      sstore(160, cd_s)
+      return(0, 192)
+    }
+    object "C" {
+      code {
+        let d_o := dataoffset("D")
+        let d_s := datasize("D")
+
+        sstore(0, d_o)
+        sstore(32, d_s)
+        return(0, 64)
+      }
+      object "D" {
+        code {
+          invalid()
+        }
+      }
+    }
+    object "E" {
+      code {
+        invalid()
+      }
+    }
+  }
+}
+// ----
+// Assembly:
+//     /* "source":37:52   */
+//   0x00
+//     /* "source":68:81   */
+//   bytecodeSize
+//     /* "source":97:112   */
+//   dataOffset(sub_0)
+//     /* "source":128:141   */
+//   dataSize(sub_0)
+//     /* "source":158:175   */
+//   dataOffset(sub_0.sub_0)
+//     /* "source":192:207   */
+//   dataSize(sub_0.sub_0)
+//     /* "source":224:241   */
+//   swap1
+//   dataOffset(sub_0.sub_1)
+//     /* "source":258:273   */
+//   swap3
+//   dataSize(sub_0.sub_1)
+//     /* "source":291:310   */
+//   swap5
+//   dataOffset(sub_0.sub_0.sub_0)
+//     /* "source":328:345   */
+//   swap7
+//   dataSize(sub_0.sub_0.sub_0)
+//     /* "source":351:365   */
+//   swap9
+//     /* "source":358:359   */
+//   0x00
+//     /* "source":351:365   */
+//   sstore
+//     /* "source":377:379   */
+//   0x20
+//     /* "source":370:385   */
+//   sstore
+//     /* "source":397:399   */
+//   0x40
+//     /* "source":390:405   */
+//   sstore
+//     /* "source":417:419   */
+//   0x60
+//     /* "source":410:425   */
+//   sstore
+//     /* "source":437:440   */
+//   0x80
+//     /* "source":430:447   */
+//   sstore
+//     /* "source":459:462   */
+//   0xa0
+//     /* "source":452:469   */
+//   sstore
+//     /* "source":481:484   */
+//   0xc0
+//     /* "source":474:491   */
+//   sstore
+//     /* "source":503:506   */
+//   0xe0
+//     /* "source":496:513   */
+//   sstore
+//     /* "source":525:528   */
+//   0x0100
+//     /* "source":518:536   */
+//   sstore
+//     /* "source":548:551   */
+//   0x0120
+//     /* "source":541:559   */
+//   sstore
+//     /* "source":574:577   */
+//   0x0140
+//     /* "source":571:572   */
+//   0x00
+//     /* "source":564:578   */
+//   return
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+//
+// sub_0: assembly {
+//         /* "source":659:674   */
+//       dataOffset(sub_0)
+//         /* "source":692:705   */
+//       dataSize(sub_0)
+//         /* "source":723:738   */
+//       dataOffset(sub_1)
+//         /* "source":756:769   */
+//       dataSize(sub_1)
+//         /* "source":788:805   */
+//       swap1
+//       dataOffset(sub_0.sub_0)
+//         /* "source":824:839   */
+//       swap3
+//       dataSize(sub_0.sub_0)
+//         /* "source":847:861   */
+//       swap5
+//         /* "source":854:855   */
+//       0x00
+//         /* "source":847:861   */
+//       sstore
+//         /* "source":875:877   */
+//       0x20
+//         /* "source":868:883   */
+//       sstore
+//         /* "source":897:899   */
+//       0x40
+//         /* "source":890:905   */
+//       sstore
+//         /* "source":919:921   */
+//       0x60
+//         /* "source":912:927   */
+//       sstore
+//         /* "source":941:944   */
+//       0x80
+//         /* "source":934:951   */
+//       sstore
+//         /* "source":965:968   */
+//       0xa0
+//         /* "source":958:975   */
+//       sstore
+//         /* "source":992:995   */
+//       0xc0
+//         /* "source":989:990   */
+//       0x00
+//         /* "source":982:996   */
+//       return
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":1052:1067   */
+//           dataOffset(sub_0)
+//             /* "source":1087:1100   */
+//           dataSize(sub_0)
+//             /* "source":1110:1124   */
+//           swap1
+//             /* "source":1117:1118   */
+//           0x00
+//             /* "source":1110:1124   */
+//           sstore
+//             /* "source":1140:1142   */
+//           0x20
+//             /* "source":1133:1148   */
+//           sstore
+//             /* "source":1167:1169   */
+//           0x40
+//             /* "source":1164:1165   */
+//           0x00
+//             /* "source":1157:1170   */
+//           return
+//         stop
+//
+//         sub_0: assembly {
+//                 /* "source":1223:1232   */
+//               invalid
+//         }
+//     }
+//
+//     sub_1: assembly {
+//             /* "source":1295:1304   */
+//           invalid
+//     }
+// }
+// Bytecode: 5f6084603d603660746010906073926001946073966001985f5560205560405560605560805560a05560c05560e05561010055610120556101405ff3fe6025601060356001906035926001945f5560205560405560605560805560a05560c05ff3fe600f6001905f5560205560405ff3fefefefe600f6001905f5560205560405ff3fefe
+// Opcodes: PUSH0 PUSH1 0x84 PUSH1 0x3D PUSH1 0x36 PUSH1 0x74 PUSH1 0x10 SWAP1 PUSH1 0x73 SWAP3 PUSH1 0x1 SWAP5 PUSH1 0x73 SWAP7 PUSH1 0x1 SWAP9 PUSH0 SSTORE PUSH1 0x20 SSTORE PUSH1 0x40 SSTORE PUSH1 0x60 SSTORE PUSH1 0x80 SSTORE PUSH1 0xA0 SSTORE PUSH1 0xC0 SSTORE PUSH1 0xE0 SSTORE PUSH2 0x100 SSTORE PUSH2 0x120 SSTORE PUSH2 0x140 PUSH0 RETURN INVALID PUSH1 0x25 PUSH1 0x10 PUSH1 0x35 PUSH1 0x1 SWAP1 PUSH1 0x35 SWAP3 PUSH1 0x1 SWAP5 PUSH0 SSTORE PUSH1 0x20 SSTORE PUSH1 0x40 SSTORE PUSH1 0x60 SSTORE PUSH1 0x80 SSTORE PUSH1 0xA0 SSTORE PUSH1 0xC0 PUSH0 RETURN INVALID PUSH1 0xF PUSH1 0x1 SWAP1 PUSH0 SSTORE PUSH1 0x20 SSTORE PUSH1 0x40 PUSH0 RETURN INVALID INVALID INVALID INVALID PUSH1 0xF PUSH1 0x1 SWAP1 PUSH0 SSTORE PUSH1 0x20 SSTORE PUSH1 0x40 PUSH0 RETURN INVALID INVALID
+// SourceMappings: 37:15:0:-:0;68:13;97:15;128:13;158:17;192:15;224:17;;258:15;;291:19;;328:17;;351:14;358:1;351:14;377:2;370:15;397:2;390:15;417:2;410:15;437:3;430:17;459:3;452:17;481:3;474:17;503:3;496:17;525:3;518:18;548:3;541:18;574:3;571:1;564:14
diff --git a/compiler/test/libyul/objectCompiler/subSubObject.yul b/compiler/test/libyul/objectCompiler/subSubObject.yul
new file mode 100644
index 00000000..a9936d58
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/subSubObject.yul
@@ -0,0 +1,46 @@
+object "a" {
+  code {}
+  // Unreferenced data is not added to the assembled bytecode.
+  data "str" "Hello, World!"
+  object "sub" {
+    code { sstore(0, 1) }
+    object "subsub" {
+      code { sstore(2, 3) }
+      data "str" hex"123456"
+    }
+  }
+}
+// ----
+// Assembly:
+//     /* "source":20:22   */
+//   stop
+// stop
+// data_acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f 48656c6c6f2c20576f726c6421
+//
+// sub_0: assembly {
+//         /* "source":153:154   */
+//       0x01
+//         /* "source":150:151   */
+//       0x00
+//         /* "source":143:155   */
+//       sstore
+//         /* "source":141:157   */
+//       stop
+//     stop
+//
+//     sub_0: assembly {
+//             /* "source":203:204   */
+//           0x03
+//             /* "source":200:201   */
+//           0x02
+//             /* "source":193:205   */
+//           sstore
+//             /* "source":191:207   */
+//           stop
+//         stop
+//         data_6adf031833174bbe4c85eafe59ddb54e6584648c2c962c6f94791ab49caa0ad4 123456
+//     }
+// }
+// Bytecode: 00fe
+// Opcodes: STOP INVALID
+// SourceMappings: 20:2:0:-:0
diff --git a/compiler/test/libyul/objectCompiler/verbatim_bug.yul b/compiler/test/libyul/objectCompiler/verbatim_bug.yul
new file mode 100644
index 00000000..778494f0
--- /dev/null
+++ b/compiler/test/libyul/objectCompiler/verbatim_bug.yul
@@ -0,0 +1,124 @@
+object "a" {
+    code {
+        let dummy := 0xAABBCCDDEEFF
+        let input := sload(0)
+        let output
+
+        switch input
+        case 0x00 {
+            // Note that due to a bug the following disappeared from the assembly output.
+            output := verbatim_1i_1o(hex"506000", dummy)
+        }
+        case 0x01 {
+            output := 1
+        }
+        case 0x02 {
+            output := verbatim_1i_1o(hex"506002", dummy)
+        }
+        case 0x03 {
+            output := 3
+        }
+
+        sstore(0, output)
+    }
+}
+// ====
+// optimizationPreset: full
+// ----
+// Assembly:
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":81:89   */
+//   dup1
+//   sload
+//     /* "source":139:307   */
+//   dup1
+//   iszero
+//   tag_1
+//   jumpi
+//     /* "source":316:361   */
+//   dup1
+//     /* "source":321:325   */
+//   0x01
+//     /* "source":316:361   */
+//   eq
+//   tag_3
+//   jumpi
+//     /* "source":370:448   */
+//   dup1
+//     /* "source":375:379   */
+//   0x02
+//     /* "source":370:448   */
+//   eq
+//   tag_5
+//   jumpi
+//     /* "source":462:466   */
+//   0x03
+//     /* "source":457:502   */
+//   eq
+//   tag_7
+//   jumpi
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":512:529   */
+//   sstore
+//     /* "source":118:502   */
+//   stop
+//     /* "source":467:502   */
+// tag_7:
+//     /* "source":481:492   */
+//   pop
+//     /* "source":491:492   */
+//   0x03
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":512:529   */
+//   sstore
+//     /* "source":118:502   */
+//   stop
+//     /* "source":380:448   */
+// tag_5:
+//     /* "source":404:438   */
+//   pop
+//   pop
+//     /* "source":45:59   */
+//   0xaabbccddeeff
+//     /* "source":404:438   */
+//   verbatimbytecode_506002
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":512:529   */
+//   sstore
+//     /* "source":118:502   */
+//   stop
+//     /* "source":326:361   */
+// tag_3:
+//     /* "source":340:351   */
+//   pop
+//   pop
+//     /* "source":350:351   */
+//   0x01
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":512:529   */
+//   sstore
+//     /* "source":118:502   */
+//   stop
+//     /* "source":149:307   */
+// tag_1:
+//     /* "source":263:297   */
+//   pop
+//   pop
+//     /* "source":45:59   */
+//   0xaabbccddeeff
+//     /* "source":263:297   */
+//   verbatimbytecode_506000
+//     /* "source":87:88   */
+//   0x00
+//     /* "source":512:529   */
+//   sstore
+//     /* "source":118:502   */
+//   stop
+// Bytecode: 5f80548015603e578060011460365780600214602657600314601f575f55005b5060035f55005b505065aabbccddeeff5060025f55005b505060015f55005b505065aabbccddeeff5060005f5500
+// Opcodes: PUSH0 DUP1 SLOAD DUP1 ISZERO PUSH1 0x3E JUMPI DUP1 PUSH1 0x1 EQ PUSH1 0x36 JUMPI DUP1 PUSH1 0x2 EQ PUSH1 0x26 JUMPI PUSH1 0x3 EQ PUSH1 0x1F JUMPI PUSH0 SSTORE STOP JUMPDEST POP PUSH1 0x3 PUSH0 SSTORE STOP JUMPDEST POP POP PUSH6 0xAABBCCDDEEFF POP PUSH1 0x2 PUSH0 SSTORE STOP JUMPDEST POP POP PUSH1 0x1 PUSH0 SSTORE STOP JUMPDEST POP POP PUSH6 0xAABBCCDDEEFF POP PUSH1 0x0 PUSH0 SSTORE STOP
+// SourceMappings: 87:1:0:-:0;81:8;;139:168;;;;316:45;321:4;316:45;;;370:78;375:4;370:78;;;462:4;457:45;;;87:1;512:17;118:384;467:35;481:11;491:1;87;512:17;118:384;380:68;404:34;;45:14;404:34;87:1;512:17;118:384;326:35;340:11;;350:1;87;512:17;118:384;149:158;263:34;;45:14;263:34;87:1;512:17;118:384
diff --git a/compiler/test/libyul/yulControlFlowGraph/function.yul b/compiler/test/libyul/yulControlFlowGraph/function.yul
new file mode 100644
index 00000000..90c4b380
--- /dev/null
+++ b/compiler/test/libyul/yulControlFlowGraph/function.yul
@@ -0,0 +1,73 @@
+{
+    function f(a, b) -> r {
+        let x := add(a,b)
+        r := sub(x,a)
+    }
+    function g() {
+        sstore(0x01, 0x0101)
+    }
+    function h(x) {
+        h(f(x, 0))
+        g()
+    }
+    function i() -> v, w {
+        v := 0x0202
+        w := 0x0303
+    }
+    let x, y := i()
+    h(x)
+    h(y)
+}
+// ----
+// digraph CFG {
+// nodesep=0.7;
+// node[shape=box];
+//
+// Entry [label="Entry"];
+// Entry -> Block0;
+// Block0 [label="\
+// i: [ RET[i] ] => [ TMP[i, 0] TMP[i, 1] ]\l\
+// Assignment(x, y): [ TMP[i, 0] TMP[i, 1] ] => [ x y ]\l\
+// h: [ x ] => [ ]\l\
+// "];
+// Block0Exit [label="Terminated"];
+// Block0 -> Block0Exit;
+//
+// FunctionEntry_f_1 [label="function f(a, b) -> r"];
+// FunctionEntry_f_1 -> Block1;
+// Block1 [label="\
+// add: [ b a ] => [ TMP[add, 0] ]\l\
+// Assignment(x): [ TMP[add, 0] ] => [ x ]\l\
+// sub: [ a x ] => [ TMP[sub, 0] ]\l\
+// Assignment(r): [ TMP[sub, 0] ] => [ r ]\l\
+// "];
+// Block1Exit [label="FunctionReturn[f]"];
+// Block1 -> Block1Exit;
+//
+// FunctionEntry_g_2 [label="function g()"];
+// FunctionEntry_g_2 -> Block2;
+// Block2 [label="\
+// sstore: [ 0x0101 0x01 ] => [ ]\l\
+// "];
+// Block2Exit [label="FunctionReturn[g]"];
+// Block2 -> Block2Exit;
+//
+// FunctionEntry_h_3 [label="function h(x)"];
+// FunctionEntry_h_3 -> Block3;
+// Block3 [label="\
+// f: [ RET[f] 0x00 x ] => [ TMP[f, 0] ]\l\
+// h: [ TMP[f, 0] ] => [ ]\l\
+// "];
+// Block3Exit [label="Terminated"];
+// Block3 -> Block3Exit;
+//
+// FunctionEntry_i_4 [label="function i() -> v, w"];
+// FunctionEntry_i_4 -> Block4;
+// Block4 [label="\
+// Assignment(v): [ 0x0202 ] => [ v ]\l\
+// Assignment(w): [ 0x0303 ] => [ w ]\l\
+// "];
+// Block4Exit [label="FunctionReturn[i]"];
+// Block4 -> Block4Exit;
+//
+// }
diff --git a/compiler/test/libyul/yulInterpreterTests/access_large_memory_offsets.yul b/compiler/test/libyul/yulInterpreterTests/access_large_memory_offsets.yul
new file mode 100644
index 00000000..ce108ddf
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/access_large_memory_offsets.yul
@@ -0,0 +1,15 @@
+{
+    mstore(0, 7)
+    sstore(0, mload(0))
+    mstore(sub(0, 1), sub(0, 1))
+    sstore(1, mload(sub(0, 1)))
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07
+//   FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0: 00000000000000000000000000000000000000000000000000000000000000ff
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000007
+//   0000000000000000000000000000000000000000000000000000000000000001: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/ambiguous_vars.yul b/compiler/test/libyul/yulInterpreterTests/ambiguous_vars.yul
new file mode 100644
index 00000000..2fca766e
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/ambiguous_vars.yul
@@ -0,0 +1,15 @@
+{
+  {
+     let a := 0x20
+     mstore(a, 2)
+  }
+  let a
+  mstore(a, 3)
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000000003
+//     20: 0000000000000000000000000000000000000000000000000000000000000002
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/and_create.yul b/compiler/test/libyul/yulInterpreterTests/and_create.yul
new file mode 100644
index 00000000..da962c3c
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/and_create.yul
@@ -0,0 +1,14 @@
+{
+    let u160max := 0xffffffffffffffffffffffffffffffffffffffff
+    let a := create(0, u160max, 0)
+    let b := and(u160max, create(0, u160max, 0))
+    mstore(0, eq(a, b))
+}
+// ----
+// Trace:
+//   CREATE(0, 0, 0)
+//   CREATE(0, 0, 0)
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000000001
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/and_create2.yul b/compiler/test/libyul/yulInterpreterTests/and_create2.yul
new file mode 100644
index 00000000..0b83d818
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/and_create2.yul
@@ -0,0 +1,16 @@
+{
+    let u160max := 0xffffffffffffffffffffffffffffffffffffffff
+    let a := create2(0, u160max, 0, 0)
+    let b := and(u160max, create2(0, u160max, 0, 0))
+    mstore(0, eq(a, b))
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+//   CREATE2(0, 0, 0, 0)
+//   CREATE2(0, 0, 0, 0)
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000000001
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/blobbasefee.yul b/compiler/test/libyul/yulInterpreterTests/blobbasefee.yul
new file mode 100644
index 00000000..5dd9095e
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/blobbasefee.yul
@@ -0,0 +1,11 @@
+{
+	sstore(0, blobbasefee())
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/blobhash.yul b/compiler/test/libyul/yulInterpreterTests/blobhash.yul
new file mode 100644
index 00000000..48ed47c6
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/blobhash.yul
@@ -0,0 +1,14 @@
+{
+    sstore(0, blobhash(0))
+    sstore(1, blobhash(1))
+    sstore(2, blobhash(2)) // should store 0 since EVMHost has only two blob hashes injected in the block the transaction is being executed.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 014916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc5
+//   0000000000000000000000000000000000000000000000000000000000000001: 0167d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed2
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/bounded_recursion.yul b/compiler/test/libyul/yulInterpreterTests/bounded_recursion.yul
new file mode 100644
index 00000000..48d13340
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/bounded_recursion.yul
@@ -0,0 +1,17 @@
+{
+  function f(x) -> y {
+    if lt(x, 150) {
+      y := f(add(x, 1))
+    }
+    if eq(x, 150) {
+      y := x
+    }
+  }
+  mstore(0, f(0))
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000000096
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/create2.yul b/compiler/test/libyul/yulInterpreterTests/create2.yul
new file mode 100644
index 00000000..b7484f5d
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/create2.yul
@@ -0,0 +1,14 @@
+{
+    pop(create2(0, 0, 32, 32))
+    // This used to store 64
+    sstore(0, msize())
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+//   CREATE2(0, 0, 32, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000020
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/datacopy.yul b/compiler/test/libyul/yulInterpreterTests/datacopy.yul
new file mode 100644
index 00000000..ce5b6ce5
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/datacopy.yul
@@ -0,0 +1,19 @@
+object "main"
+{
+    code {
+        datacopy(0, and(dataoffset("main"), 15), and(datasize("main"), 15))
+        datacopy(32, and(dataoffset("sub"), 15), and(datasize("sub"), 15))
+        sstore(0, mload(0))
+        sstore(1, mload(32))
+    }
+    object "sub" { code { sstore(0, 1) } }
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 6465636f00000000000000000000000000000000000000000000000000000000
+//     20: 636f6465636f6465000000000000000000000000000000000000000000000000
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 6465636f00000000000000000000000000000000000000000000000000000000
+//   0000000000000000000000000000000000000000000000000000000000000001: 636f6465636f6465000000000000000000000000000000000000000000000000
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/dataoffset.yul b/compiler/test/libyul/yulInterpreterTests/dataoffset.yul
new file mode 100644
index 00000000..f5a9aeb1
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/dataoffset.yul
@@ -0,0 +1,15 @@
+object "main"
+{
+    code {
+        sstore(0, dataoffset("main"))
+        sstore(1, dataoffset("sub"))
+    }
+    object "sub" { code { sstore(0, 1) } }
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 000000000000000000000000000000000000000000000000000000000000006e
+//   0000000000000000000000000000000000000000000000000000000000000001: 000000000000000000000000000000000000000000000000000000000000070c
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/datasize.yul b/compiler/test/libyul/yulInterpreterTests/datasize.yul
new file mode 100644
index 00000000..ff80edee
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/datasize.yul
@@ -0,0 +1,15 @@
+object "main"
+{
+    code {
+        sstore(0, datasize("main"))
+        sstore(1, datasize("sub"))
+    }
+    object "sub" { code { sstore(0, 1) } }
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000b64
+//   0000000000000000000000000000000000000000000000000000000000000001: 0000000000000000000000000000000000000000000000000000000000000109
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/difficulty.yul b/compiler/test/libyul/yulInterpreterTests/difficulty.yul
new file mode 100644
index 00000000..bea70cb4
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/difficulty.yul
@@ -0,0 +1,11 @@
+{
+  sstore(0, difficulty())
+}
+// ====
+// EVMVersion: <paris
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000009999999
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/exp.yul b/compiler/test/libyul/yulInterpreterTests/exp.yul
new file mode 100644
index 00000000..15825b8a
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/exp.yul
@@ -0,0 +1,9 @@
+{
+  mstore(0, exp(3,not(1)))
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e39
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_exceeded.yul b/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_exceeded.yul
new file mode 100644
index 00000000..5447dcb9
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_exceeded.yul
@@ -0,0 +1,15 @@
+{
+  function f(x) -> y
+  {
+    // 32 nested additions are computed in
+    // exactly 66 expression evaluation steps
+    y := add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,x))))))))))))))))))))))))))))))))
+  }
+  mstore(0,f(0))
+}
+// ----
+// Trace:
+//   Maximum expression nesting level reached.
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_not_exceeded.yul b/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_not_exceeded.yul
new file mode 100644
index 00000000..19aa3677
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/expr_nesting_depth_not_exceeded.yul
@@ -0,0 +1,15 @@
+{
+  function f(x) -> y
+  {
+    // 31 nested additions are computed in
+    // exactly 64 expression evaluation steps
+    y := add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,add(0x1,x)))))))))))))))))))))))))))))))
+  }
+  mstore(0,f(0))
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 000000000000000000000000000000000000000000000000000000000000001f
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/external_call_to_self.yul b/compiler/test/libyul/yulInterpreterTests/external_call_to_self.yul
new file mode 100644
index 00000000..3f5c887b
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/external_call_to_self.yul
@@ -0,0 +1,23 @@
+{
+	mstore(0x40, 0x42)
+
+	if iszero(calldatasize()) {
+		let x := call(gas(), address(), 0, 0x40, 0x20, 0x100, 0x20)
+		sstore(0x64, calldataload(0))
+		sstore(0x100, x)
+		return(0x0, 0)
+	}
+	return(0x40, 0x20)
+}
+// ====
+// simulateExternalCall: true
+// ----
+// Trace:
+//   CALL(153, 0x11111111, 0, 64, 32, 256, 32)
+//   RETURN(0, 0)
+// Memory dump:
+//     40: 0000000000000000000000000000000000000000000000000000000000000042
+//    100: 0000000000000000000000000000000000000000000000000000000000000042
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000100: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/external_call_unexecuted.yul b/compiler/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
new file mode 100644
index 00000000..0a5458b4
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
@@ -0,0 +1,11 @@
+{
+	let x := call(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
+	sstore(0x64, x)
+}
+// ----
+// Trace:
+//   CALL(153, 69, 5, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul b/compiler/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
new file mode 100644
index 00000000..5245d744
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
@@ -0,0 +1,11 @@
+{
+	let x := callcode(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
+	sstore(100, x)
+}
+// ----
+// Trace:
+//   CALLCODE(153, 69, 5, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul b/compiler/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
new file mode 100644
index 00000000..a827181f
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
@@ -0,0 +1,11 @@
+{
+	let x := delegatecall(gas(), 0x45, 0, 0x20, 0x30, 0x20)
+	sstore(100, x)
+}
+// ----
+// Trace:
+//   DELEGATECALL(153, 69, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul b/compiler/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
new file mode 100644
index 00000000..66ea146a
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
@@ -0,0 +1,13 @@
+{
+	let x := staticcall(gas(), 0x45, 0, 0x20, 0x30, 0x20)
+	sstore(0x64, x)
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// Trace:
+//   STATICCALL(153, 69, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/function_calls.yul b/compiler/test/libyul/yulInterpreterTests/function_calls.yul
new file mode 100644
index 00000000..69a351ae
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/function_calls.yul
@@ -0,0 +1,14 @@
+{
+    function f(a, b) -> x, y {
+        x := add(a, b)
+        y := mul(a, b)
+    }
+    let r, t := f(6, 7)
+    sstore(r, t)
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   000000000000000000000000000000000000000000000000000000000000000d: 000000000000000000000000000000000000000000000000000000000000002a
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/function_scopes.yul b/compiler/test/libyul/yulInterpreterTests/function_scopes.yul
new file mode 100644
index 00000000..48e29a40
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/function_scopes.yul
@@ -0,0 +1,21 @@
+{
+    f(1)
+    function f(i) {
+        if i { g(1) }
+        function g(j) {
+            if j { h() }
+            f(0)
+            function h() {
+                g(0)
+            }
+        }
+        sstore(i, add(i, 7))
+    }
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000007
+//   0000000000000000000000000000000000000000000000000000000000000001: 0000000000000000000000000000000000000000000000000000000000000008
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/hex_literals.yul b/compiler/test/libyul/yulInterpreterTests/hex_literals.yul
new file mode 100644
index 00000000..a0710de4
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/hex_literals.yul
@@ -0,0 +1,13 @@
+{
+	let x := hex"112233445566778899aabbccddeeff6677889900"
+	let y := hex"1234_abcd"
+	sstore(0, x)
+	sstore(1, y)
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 112233445566778899aabbccddeeff6677889900000000000000000000000000
+//   0000000000000000000000000000000000000000000000000000000000000001: 1234abcd00000000000000000000000000000000000000000000000000000000
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/infinite_recursion.yul b/compiler/test/libyul/yulInterpreterTests/infinite_recursion.yul
new file mode 100644
index 00000000..91d1773f
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/infinite_recursion.yul
@@ -0,0 +1,12 @@
+{
+  function f() {
+    f()
+  }
+  f()
+}
+// ----
+// Trace:
+//   Interpreter execution step limit reached.
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/infinite_recursion_tracelimit.yul b/compiler/test/libyul/yulInterpreterTests/infinite_recursion_tracelimit.yul
new file mode 100644
index 00000000..207d004e
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/infinite_recursion_tracelimit.yul
@@ -0,0 +1,45 @@
+{
+  function f() {
+    log0(0x0, 0x0)
+    f()
+  }
+  f()
+}
+// ----
+// Trace:
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   LOG0(0, 0)
+//   Trace size limit reached.
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/leave.yul b/compiler/test/libyul/yulInterpreterTests/leave.yul
new file mode 100644
index 00000000..b127f312
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/leave.yul
@@ -0,0 +1,21 @@
+{
+  function f() -> x, y
+  {
+    for { x := 0 } lt(x, 10) { x := add(x, 1) } {
+      if eq(x, 5) { y := 1 leave }
+    }
+    x := 9
+  }
+  {
+    let a, b := f()
+    sstore(a, b)
+  }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000005: 0000000000000000000000000000000000000000000000000000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/leave_for_init.yul b/compiler/test/libyul/yulInterpreterTests/leave_for_init.yul
new file mode 100644
index 00000000..ad4965e4
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/leave_for_init.yul
@@ -0,0 +1,19 @@
+{
+  function f() -> x
+  {
+    for { leave x := 2 } eq(x, 0) { } {
+    }
+  }
+  {
+    let a := f()
+    sstore(a, 7)
+  }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000007
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/long_obect_name.yul b/compiler/test/libyul/yulInterpreterTests/long_obect_name.yul
new file mode 100644
index 00000000..ede30402
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/long_obect_name.yul
@@ -0,0 +1,20 @@
+object "t" {
+	code {
+		datacopy(not(datasize("object2.object3.object4.datablock")), 0, 0)
+	}
+	object "object2" {
+		code{}
+		object "object3" {
+			code{}
+			object "object4" {
+				code{}
+				data "datablock" ""
+			}
+		}
+	}
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/loop.yul b/compiler/test/libyul/yulInterpreterTests/loop.yul
new file mode 100644
index 00000000..cccbdc0c
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/loop.yul
@@ -0,0 +1,11 @@
+{
+    for { let x := 2 } lt(x, 10) { x := add(x, 1) } {
+        mstore(mul(x, 5), mul(x, 0x1000))
+    }
+}
+// ----
+// Trace:
+// Memory dump:
+//     40: 0000000000000000000000900000000000000000000000000000000000000000
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy.yul b/compiler/test/libyul/yulInterpreterTests/mcopy.yul
new file mode 100644
index 00000000..6483239c
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy.yul
@@ -0,0 +1,35 @@
+{
+    mstore(0x00, 0x1111111111111111111111111111111122222222222222222222222222222222)
+    mstore(0x20, 0x3333333333333333333333333333333344444444444444444444444444444444)
+    mstore(0x40, 0x5555555555555555555555555555555566666666666666666666666666666666)
+
+    mcopy(0, 0, 32)      // No-op
+    mcopy(0x60, 0, 32)   // Append a duplicate of the first word past msize
+    mcopy(0x90, 0x30, 1) // Copy the 0x44 byte from the middle of second word past msize
+    mcopy(0, 0, 0)       // No-op
+    mcopy(0x2f, 0x90, 2) // Copy the 0x4400 straddling msize back into the the middle of second word
+    mcopy(0xa0, 0, 160)  // Duplicate the whole thing
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(0, 0, 32)
+//   MCOPY(96, 0, 32)
+//   MCOPY(144, 48, 1)
+//   MCOPY(0, 0, 0)
+//   MCOPY(47, 144, 2)
+//   MCOPY(160, 0, 160)
+// Memory dump:
+//      0: 1111111111111111111111111111111122222222222222222222222222222222
+//     20: 3333333333333333333333333333334400444444444444444444444444444444
+//     40: 5555555555555555555555555555555566666666666666666666666666666666
+//     60: 1111111111111111111111111111111122222222222222222222222222222222
+//     80: 0000000000000000000000000000000044000000000000000000000000000000
+//     A0: 1111111111111111111111111111111122222222222222222222222222222222
+//     C0: 3333333333333333333333333333334400444444444444444444444444444444
+//     E0: 5555555555555555555555555555555566666666666666666666666666666666
+//    100: 1111111111111111111111111111111122222222222222222222222222222222
+//    120: 0000000000000000000000000000000044000000000000000000000000000000
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy_memory_access_out_of_range.yul b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_access_out_of_range.yul
new file mode 100644
index 00000000..d45163b8
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_access_out_of_range.yul
@@ -0,0 +1,22 @@
+{
+    mstore8(0xffffffffffffffff, 1)
+
+    // Interpreter ignores memory copies with very large offset and/or size.
+    // None of these will show up in memory dump.
+    mcopy(0, 0xffffffffffffffff, 1)
+    mcopy(0xffffffffffffffff, 0, 1)
+    mcopy(0, 1, 0xffffffffffffffff)
+    mcopy(0xffffffff00000000, 0xffffffffffffffff, 0xffffffffffffffff)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(0, 0xffffffffffffffff, 1)
+//   MCOPY(0xffffffffffffffff, 0, 1)
+//   MCOPY(0, 1, 0xffffffffffffffff)
+//   MCOPY(0xffffffff00000000, 0xffffffffffffffff, 0xffffffffffffffff)
+// Memory dump:
+//   FFFFFFFFFFFFFFE0: 0000000000000000000000000000000000000000000000000000000000000001
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_read.yul b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_read.yul
new file mode 100644
index 00000000..a20dc7b0
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_read.yul
@@ -0,0 +1,13 @@
+{
+    // Should not affect msize
+    mcopy(0x30, 0x30, 0)
+    sstore(0, msize())
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(48, 48, 0)
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_write.yul b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_write.yul
new file mode 100644
index 00000000..69c4fedf
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_on_write.yul
@@ -0,0 +1,14 @@
+{
+    // Should expand memory to two full words (0x40 bytes)
+    mcopy(0x30, 0, 1)
+    sstore(0, msize())
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(48, 0, 1)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000040
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_zero_size.yul b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_zero_size.yul
new file mode 100644
index 00000000..69c4fedf
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy_memory_expansion_zero_size.yul
@@ -0,0 +1,14 @@
+{
+    // Should expand memory to two full words (0x40 bytes)
+    mcopy(0x30, 0, 1)
+    sstore(0, msize())
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(48, 0, 1)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000040
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/mcopy_overlap.yul b/compiler/test/libyul/yulInterpreterTests/mcopy_overlap.yul
new file mode 100644
index 00000000..aefb84be
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/mcopy_overlap.yul
@@ -0,0 +1,22 @@
+{
+    mstore(0x00, 0x0000000000000000000000000000000000000000000000000000000000000000)
+    mstore(0x20, 0x1111111122222222333333334444444455555555666666667777777788888888)
+    mstore(0x40, 0x1111111122222222333333334444444455555555666666667777777788888888)
+    mstore(0x60, 0x0000000000000000000000000000000000000000000000000000000000000000)
+
+    mcopy(0x08, 0x20, 0x20)
+    mcopy(0x58, 0x40, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+//   MCOPY(8, 32, 32)
+//   MCOPY(88, 64, 32)
+// Memory dump:
+//      0: 0000000000000000111111112222222233333333444444445555555566666666
+//     20: 7777777788888888333333334444444455555555666666667777777788888888
+//     40: 1111111122222222333333334444444455555555666666661111111122222222
+//     60: 3333333344444444555555556666666677777777888888880000000000000000
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul b/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul
new file mode 100644
index 00000000..ec9ca2fe
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_call.yul
@@ -0,0 +1,11 @@
+{
+  pop(byte(0, shr(0x8, call(0, 0, 0, 0, 0, 0, 0))))
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+//   CALL(0, 0, 0, 0, 0, 0, 0)
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_func.yul b/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_func.yul
new file mode 100644
index 00000000..e9a63dcb
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/pop_byte_shr_func.yul
@@ -0,0 +1,12 @@
+{
+  function f() -> x { mstore(0, 0x1337) }
+  pop(byte(0, shr(0x8, f())))
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000001337
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/prevrandao.yul b/compiler/test/libyul/yulInterpreterTests/prevrandao.yul
new file mode 100644
index 00000000..29a5c114
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/prevrandao.yul
@@ -0,0 +1,11 @@
+{
+  sstore(0, prevrandao())
+}
+// ====
+// EVMVersion: >=paris
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000010000000000000001
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/recursion.yul b/compiler/test/libyul/yulInterpreterTests/recursion.yul
new file mode 100644
index 00000000..777e0185
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/recursion.yul
@@ -0,0 +1,15 @@
+{
+  function fib(i) -> y {
+    y := 1
+    if gt(i, 2) {
+      y := add(fib(sub(i, 1)), fib(sub(i, 2)))
+    }
+  }
+  sstore(0, fib(8))
+}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000015
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/recursive_function_for_loop.yul b/compiler/test/libyul/yulInterpreterTests/recursive_function_for_loop.yul
new file mode 100644
index 00000000..9d2c08ff
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/recursive_function_for_loop.yul
@@ -0,0 +1,23 @@
+{
+        {
+            let a := foo_0(calldataload(0))
+            sstore(0, a)
+        }
+        function foo_0(x) -> y
+        {
+            y := 1
+            mstore8(1, 1)
+            for { } slt(1, keccak256(1, msize())) { let x_1 := foo_0(x) }
+            {
+                y := add(y, 1)
+                continue
+            }
+        }
+}
+// ----
+// Trace:
+// Memory dump:
+//      0: 0001000000000000000000000000000000000000000000000000000000000000
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000002
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/self_balance.yul b/compiler/test/libyul/yulInterpreterTests/self_balance.yul
new file mode 100644
index 00000000..b61f470c
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/self_balance.yul
@@ -0,0 +1,17 @@
+{
+  mstore(0, balance(address()))
+  mstore(0x20, selfbalance())
+  mstore(0x40, balance(div(mul(address(), 2), 2)))
+  mstore(0x60, balance(add(address(), 1)))
+}
+// ====
+// EVMVersion: >=istanbul
+// ----
+// Trace:
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000022223333
+//     20: 0000000000000000000000000000000000000000000000000000000022223333
+//     40: 0000000000000000000000000000000000000000000000000000000022223333
+//     60: 0000000000000000000000000000000000000000000000000000000022222222
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/shadowed_symbol.yul b/compiler/test/libyul/yulInterpreterTests/shadowed_symbol.yul
new file mode 100644
index 00000000..b6443f51
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/shadowed_symbol.yul
@@ -0,0 +1,20 @@
+{
+  function f()
+  {
+    // Variable declaration does not shadow namesake function declaration
+    // because latter not visible here.
+    let shadow_id
+  }
+  {
+    // Function named `shadow_id` is in scope now.
+    f()
+    function shadow_id() {}
+  }
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/side_effect_free.yul b/compiler/test/libyul/yulInterpreterTests/side_effect_free.yul
new file mode 100644
index 00000000..adedd299
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/side_effect_free.yul
@@ -0,0 +1,21 @@
+{
+	// These can be removed by the optimizer and should not
+	// appear in the trace.
+	pop(gas())
+	pop(extcodesize(0))
+	pop(extcodehash(0))
+	pop(returndatasize())
+	pop(sload(0))
+	pop(msize())
+	pop(mload(0))
+	pop(sload(0))
+	pop(msize())
+	pop(keccak256(0, 10))
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/simple_mstore.yul b/compiler/test/libyul/yulInterpreterTests/simple_mstore.yul
new file mode 100644
index 00000000..82b088e9
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/simple_mstore.yul
@@ -0,0 +1,9 @@
+{
+  mstore(10, 11)
+}
+// ----
+// Trace:
+// Memory dump:
+//     20: 0000000000000000000b00000000000000000000000000000000000000000000
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/smoke.yul b/compiler/test/libyul/yulInterpreterTests/smoke.yul
new file mode 100644
index 00000000..f1d3564c
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/smoke.yul
@@ -0,0 +1,6 @@
+{}
+// ----
+// Trace:
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/switch_statement.yul b/compiler/test/libyul/yulInterpreterTests/switch_statement.yul
new file mode 100644
index 00000000..52b4319d
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/switch_statement.yul
@@ -0,0 +1,12 @@
+{
+    switch 7
+        case 7 { mstore(1, 2) }
+        case 3 { mstore(6, 7) }
+        default { mstore(8, 9) }
+}
+// ----
+// Trace:
+// Memory dump:
+//     20: 0200000000000000000000000000000000000000000000000000000000000000
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/transient_storage.yul b/compiler/test/libyul/yulInterpreterTests/transient_storage.yul
new file mode 100644
index 00000000..3e9466f8
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/transient_storage.yul
@@ -0,0 +1,13 @@
+{
+    tstore(0, 8)
+    mstore(0, tload(0))
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Trace:
+// Memory dump:
+//      0: 0000000000000000000000000000000000000000000000000000000000000008
+// Storage dump:
+// Transient storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000008
diff --git a/compiler/test/libyul/yulInterpreterTests/zero_length_reads.yul b/compiler/test/libyul/yulInterpreterTests/zero_length_reads.yul
new file mode 100644
index 00000000..661db49f
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/zero_length_reads.yul
@@ -0,0 +1,41 @@
+{
+  returndatacopy(1, 1, 0)
+  calldatacopy(1, 1, 0)
+  extcodecopy(1, 1, 1, 0)
+  codecopy(1, 1, 0)
+  log0(1, 0)
+  log1(1, 0, 1)
+  log2(1, 0, 1, 1)
+  log3(1, 0, 1, 1, 1)
+  log4(1, 0, 1, 1, 1, 1)
+  pop(create(1, 1, 0))
+  pop(create2(1, 1, 0, 1))
+  pop(call(1, 1, 1, 1, 0, 1, 0))
+  pop(callcode(1, 1, 1, 1, 0, 1, 0))
+  pop(delegatecall(1, 1, 1, 0, 1, 0))
+  pop(staticcall(1, 1, 1, 0, 1, 0))
+  return(1, 0)
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+//   RETURNDATACOPY(0, 1, 0)
+//   CALLDATACOPY(0, 1, 0)
+//   EXTCODECOPY(1, 0, 1, 0)
+//   CODECOPY(0, 1, 0)
+//   LOG0(0, 0)
+//   LOG1(0, 0, 1)
+//   LOG2(0, 0, 1, 1)
+//   LOG3(0, 0, 1, 1, 1)
+//   LOG4(0, 0, 1, 1, 1, 1)
+//   CREATE(1, 0, 0)
+//   CREATE2(1, 0, 0, 1)
+//   CALL(1, 1, 1, 0, 0, 1, 0)
+//   CALLCODE(1, 1, 1, 0, 0, 1, 0)
+//   DELEGATECALL(1, 1, 0, 0, 1, 0)
+//   STATICCALL(1, 1, 0, 0, 1, 0)
+//   RETURN(0, 0)
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul b/compiler/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul
new file mode 100644
index 00000000..0d0f9242
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/zero_length_reads_and_revert.yul
@@ -0,0 +1,41 @@
+{
+  returndatacopy(1, 1, 0)
+  calldatacopy(1, 1, 0)
+  extcodecopy(1, 1, 1, 0)
+  codecopy(1, 1, 0)
+  log0(1, 0)
+  log1(1, 0, 1)
+  log2(1, 0, 1, 1)
+  log3(1, 0, 1, 1, 1)
+  log4(1, 0, 1, 1, 1, 1)
+  pop(create(1, 1, 0))
+  pop(create2(1, 1, 0, 1))
+  pop(call(1, 1, 1, 1, 0, 1, 0))
+  pop(callcode(1, 1, 1, 1, 0, 1, 0))
+  pop(delegatecall(1, 1, 1, 0, 1, 0))
+  pop(staticcall(1, 1, 1, 0, 1, 0))
+  revert(1, 0)
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// Trace:
+//   RETURNDATACOPY(0, 1, 0)
+//   CALLDATACOPY(0, 1, 0)
+//   EXTCODECOPY(1, 0, 1, 0)
+//   CODECOPY(0, 1, 0)
+//   LOG0(0, 0)
+//   LOG1(0, 0, 1)
+//   LOG2(0, 0, 1, 1)
+//   LOG3(0, 0, 1, 1, 1)
+//   LOG4(0, 0, 1, 1, 1, 1)
+//   CREATE(1, 0, 0)
+//   CREATE2(1, 0, 0, 1)
+//   CALL(1, 1, 1, 0, 0, 1, 0)
+//   CALLCODE(1, 1, 1, 0, 0, 1, 0)
+//   DELEGATECALL(1, 1, 0, 0, 1, 0)
+//   STATICCALL(1, 1, 0, 0, 1, 0)
+//   REVERT(0, 0)
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulInterpreterTests/zero_range.yul b/compiler/test/libyul/yulInterpreterTests/zero_range.yul
new file mode 100644
index 00000000..50b60435
--- /dev/null
+++ b/compiler/test/libyul/yulInterpreterTests/zero_range.yul
@@ -0,0 +1,11 @@
+{
+  calldatacopy(32, 0, 0)
+  // Used to store 32
+  sstore(0, msize())
+}
+// ----
+// Trace:
+//   CALLDATACOPY(0, 0, 0)
+// Memory dump:
+// Storage dump:
+// Transient storage dump:
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy.yul
new file mode 100644
index 00000000..aaa36047
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy.yul
@@ -0,0 +1,19 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+
+    mcopy(_0, _32, _32) // Not redundant. Read/write between different areas.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     calldatacopy(0, 0, 0x40)
+//     let _0 := 0
+//     let _32 := 32
+//     mcopy(_0, _32, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore.yul
new file mode 100644
index 00000000..cb6364b8
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore.yul
@@ -0,0 +1,23 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)
+    mcopy(_0, _32, _32) // Redundant with MSTORE.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+//     mcopy(_0, _32, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore_overlap.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore_overlap.yul
new file mode 100644
index 00000000..4dbe80fe
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_mstore_overlap.yul
@@ -0,0 +1,29 @@
+{
+    let _0 := 0
+    let _1 := 1
+    let _31 := 31
+    let _32 := 32
+    let _33 := 33
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)
+    mcopy(_1, _33, _31) // Not redundant. MCOPY does not copy all of it.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _1 := 1
+//     let _31 := 31
+//     let _32 := 32
+//     let _33 := 33
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+//     mcopy(_1, _33, _31)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area.yul
new file mode 100644
index 00000000..d7e672f1
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area.yul
@@ -0,0 +1,19 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x20)
+
+    mcopy(_0, _0, _32) // Redundant (no-op)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x20)
+//     mcopy(_0, _0, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area_mcopy.yul
new file mode 100644
index 00000000..2b11528f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_area_mcopy.yul
@@ -0,0 +1,21 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+
+    mcopy(_0, _32, _32)
+    mcopy(_0, _32, _32) // Redundant with previous MCOPY.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     mcopy(_0, _32, _32)
+//     mcopy(_0, _32, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mcopy.yul
new file mode 100644
index 00000000..12cf27c8
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mcopy.yul
@@ -0,0 +1,23 @@
+{
+    let _0 := 0
+    let _32 := 32
+    let _64 := 64
+
+    calldatacopy(0, 0, 0x60)
+
+    mcopy(_0, _64, _32)
+    mcopy(_32, _64, _32) // Not redundant. Writing to a different area.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     let _64 := 64
+//     calldatacopy(0, 0, 0x60)
+//     mcopy(_0, _64, _32)
+//     mcopy(_32, _64, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore.yul
new file mode 100644
index 00000000..9802bfb5
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore.yul
@@ -0,0 +1,23 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)
+    mcopy(_0, _0, _32) // Redundant (no-op)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+//     mcopy(_0, _0, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore8_mstore8.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore8_mstore8.yul
new file mode 100644
index 00000000..8db2b800
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore8_mstore8.yul
@@ -0,0 +1,27 @@
+{
+    let _0 := 0
+    let _1 := 1
+    let _31 := 31
+
+    calldatacopy(0, 0, 0x40)
+    let mem31 := mload(_31)
+
+    mstore8(_0, mem31)  // Redundant. Overwritten by MSTORE.
+    mcopy(_0, _0, _1)   // Redundant (no-op)
+    mstore8(_0, mem31)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _1 := 1
+//     let _31 := 31
+//     calldatacopy(0, 0, 0x40)
+//     let mem31 := mload(_31)
+//     mstore8(_0, mem31)
+//     mcopy(_0, _0, _1)
+//     mstore8(_0, mem31)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore.yul
new file mode 100644
index 00000000..cc080803
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore.yul
@@ -0,0 +1,25 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)
+    mcopy(_0, _0, _32) // Redundant (no-op)
+    mstore(_0, mem32)  // Redundant with previous MSTORE.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+//     mcopy(_0, _0, _32)
+//     mstore(_0, mem32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore_overlap.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore_overlap.yul
new file mode 100644
index 00000000..639d0266
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_read_area_mstore_mstore_overlap.yul
@@ -0,0 +1,27 @@
+{
+    let _0 := 0
+    let _1 := 1
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x20)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)
+    mcopy(_1, _1, _32) // Redundant (no-op)
+    mstore(_0, mem32)  // Redundant with previous MSTORE.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _1 := 1
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x20)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+//     mcopy(_1, _1, _32)
+//     mstore(_0, mem32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_write_area_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_write_area_mcopy.yul
new file mode 100644
index 00000000..e083572b
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mcopy_same_write_area_mcopy.yul
@@ -0,0 +1,23 @@
+{
+    let _0 := 0
+    let _32 := 32
+    let _64 := 64
+
+    calldatacopy(0, 0, 0x60)
+
+    mcopy(_0, _32, _32)
+    mcopy(_0, _64, _32) // Not redundant. Copying from a different spot.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     let _64 := 64
+//     calldatacopy(0, 0, 0x60)
+//     mcopy(_0, _32, _32)
+//     mcopy(_0, _64, _32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore8_mstore8.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore8_mstore8.yul
new file mode 100644
index 00000000..e907a301
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore8_mstore8.yul
@@ -0,0 +1,21 @@
+{
+    let _0 := 0
+    let _31 := 31
+
+    calldatacopy(0, 0, 0x40)
+    let mem31 := mload(_31)
+
+    mstore8(_0, mem31)
+    mstore8(_0, mem31) // Redundant with previous MSTORE8.
+}
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _31 := 31
+//     calldatacopy(0, 0, 0x40)
+//     let mem31 := mload(_31)
+//     mstore8(_0, mem31)
+//     mstore8(_0, mem31)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mcopy.yul
new file mode 100644
index 00000000..fd35befc
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mcopy.yul
@@ -0,0 +1,23 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mcopy(_0, _32, _32)
+    mstore(_0, mem32) // Redundant with MCOPY.
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mcopy(_0, _32, _32)
+//     mstore(_0, mem32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mstore.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mstore.yul
new file mode 100644
index 00000000..b133a68f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/mstore_mstore.yul
@@ -0,0 +1,20 @@
+{
+    let _0 := 0
+    let _32 := 32
+
+    calldatacopy(0, 0, 0x40)
+    let mem32 := mload(_32)
+
+    mstore(_0, mem32)  // Redundant. Overwritten by MSTORE.
+    mstore(_0, mem32)
+}
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     let _0 := 0
+//     let _32 := 32
+//     calldatacopy(0, 0, 0x40)
+//     let mem32 := mload(_32)
+//     mstore(_0, mem32)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/transient_storage.yul b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/transient_storage.yul
new file mode 100644
index 00000000..f50e1ba0
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equalStoreEliminator/transient_storage.yul
@@ -0,0 +1,25 @@
+{
+    tstore(0, 42)
+    tstore(0, 42)
+    let x := tload(0)
+    tstore(0, 42)
+    x := tload(0)
+    tstore(0, 24)
+    x := tload(0)
+    tstore(0, 24)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: equalStoreEliminator
+//
+// {
+//     tstore(0, 42)
+//     tstore(0, 42)
+//     let x := tload(0)
+//     tstore(0, 42)
+//     x := tload(0)
+//     tstore(0, 24)
+//     x := tload(0)
+//     tstore(0, 24)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation.yul b/compiler/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation.yul
new file mode 100644
index 00000000..b7a815dd
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/equivalentFunctionCombiner/constant_representation.yul
@@ -0,0 +1,17 @@
+{
+  f()
+  g()
+  function f() { mstore(0x01, mload(0x00)) }
+  function g() { mstore(1, mload(0)) }
+}
+// ----
+// step: equivalentFunctionCombiner
+//
+// {
+//     f()
+//     f()
+//     function f()
+//     { mstore(0x01, mload(0x00)) }
+//     function g()
+//     { mstore(1, mload(0)) }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_non_zero_size.sol b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_non_zero_size.sol
new file mode 100644
index 00000000..410b7df5
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_non_zero_size.sol
@@ -0,0 +1,22 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    mcopy(0x20, 0x40, 0x20)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: expressionSimplifier
+//
+// {
+//     {
+//         let _1 := 0x60
+//         let _2 := 0
+//         calldatacopy(_2, _2, _1)
+//         let _4 := 0x20
+//         mcopy(_4, 0x40, _4)
+//         return(_2, _1)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_zero_size.sol b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_zero_size.sol
new file mode 100644
index 00000000..fe442011
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/mcopy_zero_size.sol
@@ -0,0 +1,21 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    mcopy(0x20, 0x40, 0) // Equivalent to mcopy(0, 0, 0)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: expressionSimplifier
+//
+// {
+//     {
+//         let _1 := 0x60
+//         let _2 := 0
+//         calldatacopy(_2, _2, _1)
+//         mcopy(0, 0, _2)
+//         return(_2, _1)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/optimize_shl_over_and.yul b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/optimize_shl_over_and.yul
new file mode 100644
index 00000000..27d1845f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/expressionSimplifier/optimize_shl_over_and.yul
@@ -0,0 +1,15 @@
+{
+    let x := calldataload(0)
+    let a := and(shl(x, 248), shl(x, 12))
+    sstore(10, a)
+}
+// ====
+// EVMVersion: >byzantium
+// ----
+// step: expressionSimplifier
+//
+// {
+//     {
+//         sstore(10, shl(calldataload(0), 8))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/connected.yul b/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/connected.yul
new file mode 100644
index 00000000..99e92c18
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/connected.yul
@@ -0,0 +1,62 @@
+{
+	mstore(0x40, memoryguard(0))
+	function g() -> a, b {
+		a := 21
+		let $c := 1
+		b,a,$c := z()
+	}
+	function f() -> x {
+		let $x2
+		$x2 := 42
+		let $x3, $x4 := g()
+		x := mul(add($x2, $x3), h($x4))
+		sstore($x3, $x4)
+	}
+	function h(v) -> a {
+		let x, $z, y := z()
+		a, $z, v := z()
+	}
+	function z() -> a,b,c { let $x := 0 }
+	sstore(0, f())
+	let x, y := g()
+}
+// ----
+// step: fakeStackLimitEvader
+//
+// {
+//     mstore(0x40, memoryguard(0xa0))
+//     function g() -> a, b
+//     {
+//         a := 21
+//         mstore(0x60, 1)
+//         let b_1, a_2, $c_3 := z()
+//         mstore(0x60, $c_3)
+//         a := a_2
+//         b := b_1
+//     }
+//     function f() -> x
+//     {
+//         mstore(0x40, 0)
+//         mstore(0x40, 42)
+//         let $x3_4, $x4_5 := g()
+//         mstore(0x00, $x4_5)
+//         mstore(0x20, $x3_4)
+//         x := mul(add(mload(0x40), mload(0x20)), h(mload(0x00)))
+//         sstore(mload(0x20), mload(0x00))
+//     }
+//     function h(v) -> a_1
+//     {
+//         let x_2_6, $z_7, y_8 := z()
+//         mstore(0x60, $z_7)
+//         let y := y_8
+//         let x_2 := x_2_6
+//         let a_1_9, $z_10, v_11 := z()
+//         mstore(0x60, $z_10)
+//         v := v_11
+//         a_1 := a_1_9
+//     }
+//     function z() -> a_3, b_4, c
+//     { mstore(0x80, 0) }
+//     sstore(0, f())
+//     let x_5, y_6 := g()
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/stub.yul b/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/stub.yul
new file mode 100644
index 00000000..e86619e4
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fakeStackLimitEvader/stub.yul
@@ -0,0 +1,88 @@
+{
+	mstore(0x40, memoryguard(0))
+	function f() {
+	    let $fx
+	    let $fy := 42
+	    sstore($fx, $fy)
+	    $fx := 21
+	}
+	function g(gx) {
+	    let $gx, $gy := tuple2()
+	    { $gx, $gy := tuple2() }
+	    { $gx, gx := tuple2() }
+	    { gx, $gy := tuple2() }
+	}
+	function h(hx, hy, hz, hw) {
+	    let $hx, $hy, $hz, $hw := tuple4()
+	    { hx, $hy, hz, $hw := tuple4() }
+	    { $hx, $hy, hz, hw := tuple4() }
+	}
+	function tuple2() -> a, b {}
+	function tuple4() -> a, b, c, d {}
+    f()
+    g(0)
+    h(1, 2, 3, 4)
+}
+// ----
+// step: fakeStackLimitEvader
+//
+// {
+//     mstore(0x40, memoryguard(0x80))
+//     function f()
+//     {
+//         mstore(0x60, 0)
+//         mstore(0x40, 42)
+//         sstore(mload(0x60), mload(0x40))
+//         mstore(0x60, 21)
+//     }
+//     function g(gx)
+//     {
+//         let $gx_1, $gy_2 := tuple2()
+//         mstore(0x40, $gy_2)
+//         mstore(0x60, $gx_1)
+//         {
+//             let $gx_3, $gy_4 := tuple2()
+//             mstore(0x40, $gy_4)
+//             mstore(0x60, $gx_3)
+//         }
+//         {
+//             let $gx_5, gx_6 := tuple2()
+//             mstore(0x60, $gx_5)
+//             gx := gx_6
+//         }
+//         {
+//             let gx_7, $gy_8 := tuple2()
+//             mstore(0x40, $gy_8)
+//             gx := gx_7
+//         }
+//     }
+//     function h(hx, hy, hz, hw)
+//     {
+//         let $hx_9, $hy_10, $hz_11, $hw_12 := tuple4()
+//         mstore(0x00, $hw_12)
+//         mstore(0x20, $hz_11)
+//         mstore(0x40, $hy_10)
+//         mstore(0x60, $hx_9)
+//         {
+//             let hx_13, $hy_14, hz_15, $hw_16 := tuple4()
+//             mstore(0x00, $hw_16)
+//             mstore(0x40, $hy_14)
+//             hz := hz_15
+//             hx := hx_13
+//         }
+//         {
+//             let $hx_17, $hy_18, hz_19, hw_20 := tuple4()
+//             mstore(0x40, $hy_18)
+//             mstore(0x60, $hx_17)
+//             hw := hw_20
+//             hz := hz_19
+//         }
+//     }
+//     function tuple2() -> a, b
+//     { }
+//     function tuple4() -> a_1, b_2, c, d
+//     { }
+//     f()
+//     g(0)
+//     h(1, 2, 3, 4)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_with_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_with_side_effects.yul
new file mode 100644
index 00000000..94b0c72d
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_with_side_effects.yul
@@ -0,0 +1,29 @@
+{
+    function fun_revert() -> ret { revert(0, 0) }
+    function fun_return() -> ret { return(0, 0) }
+    function empty(a, b) {}
+
+    // Evaluation order in Yul is right to left so fun_revert() should run first.
+    empty(fun_return(), fun_revert())
+}
+// ----
+// step: fullInliner
+//
+// {
+//     {
+//         let ret_7 := 0
+//         revert(0, 0)
+//         let _1 := ret_7
+//         let ret_1_10 := 0
+//         return(0, 0)
+//         let _2 := ret_1_10
+//         let b_13 := _1
+//         let a_14 := _2
+//     }
+//     function fun_revert() -> ret
+//     { revert(0, 0) }
+//     function fun_return() -> ret_1
+//     { return(0, 0) }
+//     function empty(a, b)
+//     { }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_without_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_without_side_effects.yul
new file mode 100644
index 00000000..747ac808
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInliner/call_arguments_without_side_effects.yul
@@ -0,0 +1,51 @@
+{
+    function empty(a, b, c) {}
+
+    // Constants
+    empty(111, 222, 333)
+
+    // Variables
+    let x := 111
+    let y := 222
+    let z := 333
+    empty(x, y, z)
+
+    // Calls
+    empty(mload(111), sload(222), calldataload(333))
+
+    // Mix
+    let a := 222
+    empty(111, a, mload(333))
+}
+// ----
+// step: fullInliner
+//
+// {
+//     {
+//         let _1 := 333
+//         let _2 := 222
+//         let _3 := 111
+//         let c_13 := _1
+//         let b_14 := _2
+//         let a_15 := _3
+//         let x := 111
+//         let y := 222
+//         let c_16 := 333
+//         let b_17 := y
+//         let a_18 := x
+//         let _5 := calldataload(333)
+//         let _7 := sload(222)
+//         let _9 := mload(111)
+//         let c_19 := _5
+//         let b_20 := _7
+//         let a_21 := _9
+//         let a_1 := 222
+//         let _11 := mload(333)
+//         let _12 := 111
+//         let c_22 := _11
+//         let b_23 := a_1
+//         let a_24 := _12
+//     }
+//     function empty(a, b, c)
+//     { }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul b/compiler/test/libyul/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul
new file mode 100644
index 00000000..1f777237
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInliner/move_up_rightwards_argument.yul
@@ -0,0 +1,31 @@
+{
+	function f(a, b, c) -> x {
+		x := add(a, b)
+		x := mul(x, c)
+	}
+	let y := add(mload(1), add(f(mload(2), mload(3), mload(4)), mload(5)))
+}
+// ----
+// step: fullInliner
+//
+// {
+//     {
+//         let _2 := mload(5)
+//         let _4 := mload(4)
+//         let _6 := mload(3)
+//         let _8 := mload(2)
+//         let c_13 := _4
+//         let b_14 := _6
+//         let a_15 := _8
+//         let x_16 := 0
+//         x_16 := add(a_15, b_14)
+//         x_16 := mul(x_16, c_13)
+//         let _10 := add(x_16, _2)
+//         let y := add(mload(1), _10)
+//     }
+//     function f(a, b, c) -> x
+//     {
+//         x := add(a, b)
+//         x := mul(x, c)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInliner/multi_fun.yul b/compiler/test/libyul/yulOptimizerTests/fullInliner/multi_fun.yul
new file mode 100644
index 00000000..b30078cb
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInliner/multi_fun.yul
@@ -0,0 +1,34 @@
+{
+	function f(a) -> x { x := add(a, a) }
+	function g(b, c) -> y { y := mul(mload(c), f(b)) }
+	let y := g(f(3), 7)
+}
+// ----
+// step: fullInliner
+//
+// {
+//     {
+//         let _1 := 7
+//         let a_8 := 3
+//         let x_9 := 0
+//         x_9 := add(a_8, a_8)
+//         let _3 := x_9
+//         let c_10 := _1
+//         let b_11 := _3
+//         let y_12 := 0
+//         let a_6_13 := b_11
+//         let x_7_14 := 0
+//         x_7_14 := add(a_6_13, a_6_13)
+//         y_12 := mul(mload(c_10), x_7_14)
+//         let y_1 := y_12
+//     }
+//     function f(a) -> x
+//     { x := add(a, a) }
+//     function g(b, c) -> y
+//     {
+//         let a_6 := b
+//         let x_7 := 0
+//         x_7 := add(a_6, a_6)
+//         y := mul(mload(c), x_7)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_with_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_with_side_effects.yul
new file mode 100644
index 00000000..a89dd891
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_with_side_effects.yul
@@ -0,0 +1,22 @@
+{
+    function fun_revert() -> ret { revert(0, 0) }
+    function fun_return() -> ret { return(0, 0) }
+    function empty(a, b) {}
+
+    // Evaluation order in Yul is right to left so fun_revert() should run first.
+    empty(fun_return(), fun_revert())
+}
+// ----
+// step: fullInlinerWithoutSplitter
+//
+// {
+//     {
+//         empty(fun_return(), fun_revert())
+//     }
+//     function fun_revert() -> ret
+//     { revert(0, 0) }
+//     function fun_return() -> ret_1
+//     { return(0, 0) }
+//     function empty(a, b)
+//     { }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_without_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_without_side_effects.yul
new file mode 100644
index 00000000..8f903b48
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/call_arguments_without_side_effects.yul
@@ -0,0 +1,40 @@
+{
+    function empty(a, b, c) {}
+
+    // Constants
+    empty(111, 222, 333)
+
+    // Variables
+    let x := 111
+    let y := 222
+    let z := 333
+    empty(x, y, z)
+
+    // Calls
+    empty(mload(111), sload(222), calldataload(333))
+
+    // Mix
+    let a := 222
+    empty(111, a, mload(333))
+}
+// ----
+// step: fullInlinerWithoutSplitter
+//
+// {
+//     {
+//         let c_1 := 333
+//         let b_2 := 222
+//         let a_3 := 111
+//         let x := 111
+//         let y := 222
+//         let z := 333
+//         let c_4 := z
+//         let b_5 := y
+//         let a_6 := x
+//         empty(mload(111), sload(222), calldataload(333))
+//         let a_1 := 222
+//         empty(111, a_1, mload(333))
+//     }
+//     function empty(a, b, c)
+//     { }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/simple.sol b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/simple.sol
new file mode 100644
index 00000000..80b97590
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullInlinerWithoutSplitter/simple.sol
@@ -0,0 +1,19 @@
+{
+    function f(a) -> x {
+        x := add(a, a)
+    }
+    let y := f(2)
+}
+// ----
+// step: fullInlinerWithoutSplitter
+//
+// {
+//     {
+//         let a_1 := 2
+//         let x_2 := 0
+//         x_2 := add(a_1, a_1)
+//         let y := x_2
+//     }
+//     function f(a) -> x
+//     { x := add(a, a) }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul b/compiler/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul
new file mode 100644
index 00000000..38e5ab21
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSimplify/scoped_var_ref_in_function_call.yul
@@ -0,0 +1,20 @@
+{
+    function f(x) {}
+    let x
+    {
+        x := add(1, calldataload(0))
+    }
+    f(call(2, 0, 1, mod(x, 8), 1, 1, 1))
+}
+// ----
+// step: fullSimplify
+//
+// {
+//     {
+//         let x_1
+//         let _2 := calldataload(x_1)
+//         let _3 := 1
+//         x_1 := add(_3, _2)
+//         pop(call(2, 0, _3, addmod(_3, _2, 8), _3, _3, _3))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul
new file mode 100644
index 00000000..2abdf6d9
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul
@@ -0,0 +1,575 @@
+// We require constantinople because numbers are represented using shifts.
+{
+    let x := abi_encode_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr_to_t_array$_t_array$_t_address_$3_memory_$dyn_memory_ptr(mload(0), 0x20)
+    let a, b, c, d := abi_decode_tuple_t_uint256t_uint256t_array$_t_uint256_$dyn_memory_ptrt_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(mload(0x20), mload(0x40))
+    sstore(a, b)
+    sstore(c, d)
+    sstore(0, x)
+
+    function abi_decode_t_address(offset, end) -> value
+    {
+        value := cleanup_revert_t_address(calldataload(offset))
+    }
+    function abi_decode_t_array$_t_address_$dyn_memory(offset, end) -> array
+    {
+        if iszero(slt(add(offset, 0x1f), end))
+        {
+            revert(0, 0)
+        }
+        let length := calldataload(offset)
+        array := allocateMemory(array_allocation_size_t_array$_t_address_$dyn_memory(length))
+        let dst := array
+        mstore(array, length)
+        offset := add(offset, 0x20)
+        dst := add(dst, 0x20)
+        let src := offset
+        if gt(add(src, mul(length, 0x20)), end)
+        {
+            revert(0, 0)
+        }
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            let elementPos := src
+            mstore(dst, abi_decode_t_address(elementPos, end))
+            dst := add(dst, 0x20)
+            src := add(src, 0x20)
+        }
+    }
+    function abi_decode_t_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(offset, end) -> array
+    {
+        if iszero(slt(add(offset, 0x1f), end))
+        {
+            revert(0, 0)
+        }
+        let length := calldataload(offset)
+        array := allocateMemory(array_allocation_size_t_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(length))
+        let dst := array
+        mstore(array, length)
+        offset := add(offset, 0x20)
+        dst := add(dst, 0x20)
+        let src := offset
+        if gt(add(src, mul(length, 0x40)), end)
+        {
+            revert(0, 0)
+        }
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            let elementPos := src
+            mstore(dst, abi_decode_t_array$_t_uint256_$2_memory(elementPos, end))
+            dst := add(dst, 0x20)
+            src := add(src, 0x40)
+        }
+    }
+    function abi_decode_t_array$_t_uint256_$2_memory(offset, end) -> array
+    {
+        if iszero(slt(add(offset, 0x1f), end))
+        {
+            revert(0, 0)
+        }
+        let length := 0x2
+        array := allocateMemory(array_allocation_size_t_array$_t_uint256_$2_memory(length))
+        let dst := array
+        let src := offset
+        if gt(add(src, mul(length, 0x20)), end)
+        {
+            revert(0, 0)
+        }
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            let elementPos := src
+            mstore(dst, abi_decode_t_uint256(elementPos, end))
+            dst := add(dst, 0x20)
+            src := add(src, 0x20)
+        }
+    }
+    function abi_decode_t_array$_t_uint256_$dyn_memory(offset, end) -> array
+    {
+        if iszero(slt(add(offset, 0x1f), end))
+        {
+            revert(0, 0)
+        }
+        let length := calldataload(offset)
+        array := allocateMemory(array_allocation_size_t_array$_t_uint256_$dyn_memory(length))
+        let dst := array
+        mstore(array, length)
+        offset := add(offset, 0x20)
+        dst := add(dst, 0x20)
+        let src := offset
+        if gt(add(src, mul(length, 0x20)), end)
+        {
+            revert(0, 0)
+        }
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            let elementPos := src
+            mstore(dst, abi_decode_t_uint256(elementPos, end))
+            dst := add(dst, 0x20)
+            src := add(src, 0x20)
+        }
+    }
+    function abi_decode_t_array$_t_uint256_$dyn_memory_ptr(offset, end) -> array
+    {
+        if iszero(slt(add(offset, 0x1f), end))
+        {
+            revert(0, 0)
+        }
+        let length := calldataload(offset)
+        array := allocateMemory(array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr(length))
+        let dst := array
+        mstore(array, length)
+        offset := add(offset, 0x20)
+        dst := add(dst, 0x20)
+        let src := offset
+        if gt(add(src, mul(length, 0x20)), end)
+        {
+            revert(0, 0)
+        }
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            let elementPos := src
+            mstore(dst, abi_decode_t_uint256(elementPos, end))
+            dst := add(dst, 0x20)
+            src := add(src, 0x20)
+        }
+    }
+    function abi_decode_t_contract$_C_$55(offset, end) -> value
+    {
+        value := cleanup_revert_t_contract$_C_$55(calldataload(offset))
+    }
+    function abi_decode_t_struct$_S_$11_memory_ptr(headStart, end) -> value
+    {
+        if slt(sub(end, headStart), 0x60)
+        {
+            revert(0, 0)
+        }
+        value := allocateMemory(0x60)
+        {
+            let offset := 0
+            mstore(add(value, 0x0), abi_decode_t_uint256(add(headStart, offset), end))
+        }
+        {
+            let offset := calldataload(add(headStart, 32))
+            if gt(offset, 0xffffffffffffffff)
+            {
+                revert(0, 0)
+            }
+            mstore(add(value, 0x20), abi_decode_t_array$_t_uint256_$dyn_memory(add(headStart, offset), end))
+        }
+        {
+            let offset := calldataload(add(headStart, 64))
+            if gt(offset, 0xffffffffffffffff)
+            {
+                revert(0, 0)
+            }
+            mstore(add(value, 0x40), abi_decode_t_array$_t_address_$dyn_memory(add(headStart, offset), end))
+        }
+    }
+    function abi_decode_t_uint256(offset, end) -> value
+    {
+        value := cleanup_revert_t_uint256(calldataload(offset))
+    }
+    function abi_decode_t_uint8(offset, end) -> value
+    {
+        value := cleanup_revert_t_uint8(calldataload(offset))
+    }
+    function abi_decode_tuple_t_contract$_C_$55t_uint8(headStart, dataEnd) -> value0, value1
+    {
+        if slt(sub(dataEnd, headStart), 64)
+        {
+            revert(0, 0)
+        }
+        {
+            let offset := 0
+            value0 := abi_decode_t_contract$_C_$55(add(headStart, offset), dataEnd)
+        }
+        {
+            let offset := 32
+            value1 := abi_decode_t_uint8(add(headStart, offset), dataEnd)
+        }
+    }
+    function abi_decode_tuple_t_struct$_S_$11_memory_ptrt_uint256(headStart, dataEnd) -> value0, value1
+    {
+        if slt(sub(dataEnd, headStart), 64)
+        {
+            revert(0, 0)
+        }
+        {
+            let offset := calldataload(add(headStart, 0))
+            if gt(offset, 0xffffffffffffffff)
+            {
+                revert(0, 0)
+            }
+            value0 := abi_decode_t_struct$_S_$11_memory_ptr(add(headStart, offset), dataEnd)
+        }
+        {
+            let offset := 32
+            value1 := abi_decode_t_uint256(add(headStart, offset), dataEnd)
+        }
+    }
+    function abi_decode_tuple_t_uint256t_uint256t_array$_t_uint256_$dyn_memory_ptrt_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(headStart, dataEnd) -> value0, value1, value2, value3
+    {
+        if slt(sub(dataEnd, headStart), 128)
+        {
+            revert(0, 0)
+        }
+        {
+            let offset := 0
+            value0 := abi_decode_t_uint256(add(headStart, offset), dataEnd)
+        }
+        {
+            let offset := 32
+            value1 := abi_decode_t_uint256(add(headStart, offset), dataEnd)
+        }
+        {
+            let offset := calldataload(add(headStart, 64))
+            if gt(offset, 0xffffffffffffffff)
+            {
+                revert(0, 0)
+            }
+            value2 := abi_decode_t_array$_t_uint256_$dyn_memory_ptr(add(headStart, offset), dataEnd)
+        }
+        {
+            let offset := calldataload(add(headStart, 96))
+            if gt(offset, 0xffffffffffffffff)
+            {
+                revert(0, 0)
+            }
+            value3 := abi_decode_t_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(add(headStart, offset), dataEnd)
+        }
+    }
+    function abi_encode_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr_to_t_array$_t_array$_t_address_$3_memory_$dyn_memory_ptr(value, pos) -> end
+    {
+        let length := array_length_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(value)
+        mstore(pos, length)
+        pos := add(pos, 0x20)
+        let srcPtr := array_dataslot_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(value)
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            abi_encode_t_array$_t_contract$_C_$55_$3_memory_to_t_array$_t_address_$3_memory_ptr(mload(srcPtr), pos)
+            srcPtr := array_nextElement_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(srcPtr)
+            pos := add(pos, 0x60)
+        }
+        end := pos
+    }
+    function abi_encode_t_array$_t_contract$_C_$55_$3_memory_to_t_array$_t_address_$3_memory_ptr(value, pos)
+    {
+        let length := array_length_t_array$_t_contract$_C_$55_$3_memory(value)
+        let srcPtr := array_dataslot_t_array$_t_contract$_C_$55_$3_memory(value)
+        for {
+            let i := 0
+        }
+        lt(i, length)
+        {
+            i := add(i, 1)
+        }
+        {
+            abi_encode_t_contract$_C_$55_to_t_address(mload(srcPtr), pos)
+            srcPtr := array_nextElement_t_array$_t_contract$_C_$55_$3_memory(srcPtr)
+            pos := add(pos, 0x20)
+        }
+    }
+    function abi_encode_t_bool_to_t_bool(value, pos)
+    {
+        mstore(pos, cleanup_assert_t_bool(value))
+    }
+    function abi_encode_t_contract$_C_$55_to_t_address(value, pos)
+    {
+        mstore(pos, convert_t_contract$_C_$55_to_t_address(value))
+    }
+    function abi_encode_t_uint16_to_t_uint16(value, pos)
+    {
+        mstore(pos, cleanup_assert_t_uint16(value))
+    }
+    function abi_encode_t_uint24_to_t_uint24(value, pos)
+    {
+        mstore(pos, cleanup_assert_t_uint24(value))
+    }
+    function abi_encode_tuple_t_bool__to_t_bool_(headStart, value0) -> tail
+    {
+        tail := add(headStart, 32)
+        abi_encode_t_bool_to_t_bool(value0, add(headStart, 0))
+    }
+    function abi_encode_tuple_t_uint16_t_uint24_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr__to_t_uint16_t_uint24_t_array$_t_array$_t_address_$3_memory_$dyn_memory_ptr_(headStart, value2, value1, value0) -> tail
+    {
+        tail := add(headStart, 96)
+        abi_encode_t_uint16_to_t_uint16(value0, add(headStart, 0))
+        abi_encode_t_uint24_to_t_uint24(value1, add(headStart, 32))
+        mstore(add(headStart, 64), sub(tail, headStart))
+        tail := abi_encode_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr_to_t_array$_t_array$_t_address_$3_memory_$dyn_memory_ptr(value2, tail)
+    }
+    function allocateMemory(size) -> memPtr
+    {
+        memPtr := mload(64)
+        let newFreePtr := add(memPtr, size)
+        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr))
+        {
+            revert(0, 0)
+        }
+        mstore(64, newFreePtr)
+    }
+    function array_allocation_size_t_array$_t_address_$dyn_memory(length) -> size
+    {
+        if gt(length, 0xffffffffffffffff)
+        {
+            revert(0, 0)
+        }
+        size := mul(length, 0x20)
+        size := add(size, 0x20)
+    }
+    function array_allocation_size_t_array$_t_array$_t_uint256_$2_memory_$dyn_memory_ptr(length) -> size
+    {
+        if gt(length, 0xffffffffffffffff)
+        {
+            revert(0, 0)
+        }
+        size := mul(length, 0x20)
+        size := add(size, 0x20)
+    }
+    function array_allocation_size_t_array$_t_uint256_$2_memory(length) -> size
+    {
+        if gt(length, 0xffffffffffffffff)
+        {
+            revert(0, 0)
+        }
+        size := mul(length, 0x20)
+    }
+    function array_allocation_size_t_array$_t_uint256_$dyn_memory(length) -> size
+    {
+        if gt(length, 0xffffffffffffffff)
+        {
+            revert(0, 0)
+        }
+        size := mul(length, 0x20)
+        size := add(size, 0x20)
+    }
+    function array_allocation_size_t_array$_t_uint256_$dyn_memory_ptr(length) -> size
+    {
+        if gt(length, 0xffffffffffffffff)
+        {
+            revert(0, 0)
+        }
+        size := mul(length, 0x20)
+        size := add(size, 0x20)
+    }
+    function array_dataslot_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(memPtr) -> dataPtr
+    {
+        dataPtr := add(memPtr, 0x20)
+    }
+    function array_dataslot_t_array$_t_contract$_C_$55_$3_memory(memPtr) -> dataPtr
+    {
+        dataPtr := memPtr
+    }
+    function array_length_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(value) -> length
+    {
+        length := mload(value)
+    }
+    function array_length_t_array$_t_contract$_C_$55_$3_memory(value) -> length
+    {
+        length := 0x3
+    }
+    function array_nextElement_t_array$_t_array$_t_contract$_C_$55_$3_memory_$dyn_memory_ptr(memPtr) -> nextPtr
+    {
+        nextPtr := add(memPtr, 0x20)
+    }
+    function array_nextElement_t_array$_t_contract$_C_$55_$3_memory(memPtr) -> nextPtr
+    {
+        nextPtr := add(memPtr, 0x20)
+    }
+    function cleanup_assert_t_address(value) -> cleaned
+    {
+        cleaned := cleanup_assert_t_uint160(value)
+    }
+    function cleanup_assert_t_bool(value) -> cleaned
+    {
+        cleaned := iszero(iszero(value))
+    }
+    function cleanup_assert_t_uint16(value) -> cleaned
+    {
+        cleaned := and(value, 0xFFFF)
+    }
+    function cleanup_assert_t_uint160(value) -> cleaned
+    {
+        cleaned := and(value, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
+    }
+    function cleanup_assert_t_uint24(value) -> cleaned
+    {
+        cleaned := and(value, 0xFFFFFF)
+    }
+    function cleanup_revert_t_address(value) -> cleaned
+    {
+        cleaned := cleanup_assert_t_uint160(value)
+    }
+    function cleanup_revert_t_contract$_C_$55(value) -> cleaned
+    {
+        cleaned := cleanup_assert_t_address(value)
+    }
+    function cleanup_revert_t_uint256(value) -> cleaned
+    {
+        cleaned := value
+    }
+    function cleanup_revert_t_uint8(value) -> cleaned
+    {
+        cleaned := and(value, 0xFF)
+    }
+    function convert_t_contract$_C_$55_to_t_address(value) -> converted
+    {
+        converted := convert_t_contract$_C_$55_to_t_uint160(value)
+    }
+    function convert_t_contract$_C_$55_to_t_uint160(value) -> converted
+    {
+        converted := cleanup_assert_t_uint160(value)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let _1 := mload(0)
+//         let pos := 0x20
+//         let length := mload(_1)
+//         mstore(pos, length)
+//         pos := 64
+//         let srcPtr := add(_1, 0x20)
+//         let i := 0
+//         for { } lt(i, length) { i := add(i, 1) }
+//         {
+//             let _2 := mload(srcPtr)
+//             let pos_1 := pos
+//             let srcPtr_1 := _2
+//             let i_1 := 0
+//             for { } lt(i_1, 0x3) { i_1 := add(i_1, 1) }
+//             {
+//                 mstore(pos_1, and(mload(srcPtr_1), sub(shl(160, 1), 1)))
+//                 srcPtr_1 := add(srcPtr_1, 0x20)
+//                 pos_1 := add(pos_1, 0x20)
+//             }
+//             srcPtr := add(srcPtr, 0x20)
+//             pos := add(pos, 0x60)
+//         }
+//         let a, b, c, d := abi_decode_uint256t_uint256t_array_uint256_dynt_array_array_uint256_memory_dyn(mload(0x20), mload(64))
+//         sstore(a, b)
+//         sstore(c, d)
+//         sstore(0, pos)
+//     }
+//     function abi_decode_array_array_uint256_memory_dyn(offset, end) -> array
+//     {
+//         let _1 := 0x1f
+//         if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }
+//         let length := calldataload(offset)
+//         array := allocateMemory(array_allocation_size_array_address_dyn_memory(length))
+//         let dst := array
+//         mstore(array, length)
+//         let _2 := 0x20
+//         dst := add(array, _2)
+//         let src := add(offset, _2)
+//         if gt(add(add(offset, shl(6, length)), _2), end) { revert(0, 0) }
+//         let i := 0
+//         for { } lt(i, length) { i := add(i, 1) }
+//         {
+//             if iszero(slt(add(src, _1), end)) { revert(0, 0) }
+//             let dst_1 := allocateMemory_967()
+//             let dst_2 := dst_1
+//             let src_1 := src
+//             let _3 := add(src, 64)
+//             if gt(_3, end) { revert(0, 0) }
+//             let i_1 := 0
+//             for { } lt(i_1, 0x2) { i_1 := add(i_1, 1) }
+//             {
+//                 mstore(dst_1, calldataload(src_1))
+//                 dst_1 := add(dst_1, _2)
+//                 src_1 := add(src_1, _2)
+//             }
+//             mstore(dst, dst_2)
+//             dst := add(dst, _2)
+//             src := _3
+//         }
+//     }
+//     function abi_decode_uint256t_uint256t_array_uint256_dynt_array_array_uint256_memory_dyn(headStart, dataEnd) -> value0, value1, value2, value3
+//     {
+//         if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
+//         value0 := calldataload(headStart)
+//         let _1 := 32
+//         value1 := calldataload(add(headStart, _1))
+//         let offset := calldataload(add(headStart, 64))
+//         let _2 := 0xffffffffffffffff
+//         if gt(offset, _2) { revert(0, 0) }
+//         let _3 := add(headStart, offset)
+//         if iszero(slt(add(_3, 0x1f), dataEnd)) { revert(0, 0) }
+//         let length := calldataload(_3)
+//         let dst := allocateMemory(array_allocation_size_array_address_dyn_memory(length))
+//         let dst_1 := dst
+//         mstore(dst, length)
+//         dst := add(dst, _1)
+//         let src := add(_3, _1)
+//         if gt(add(add(_3, shl(5, length)), _1), dataEnd) { revert(0, 0) }
+//         let i := 0
+//         for { } lt(i, length) { i := add(i, 1) }
+//         {
+//             mstore(dst, calldataload(src))
+//             dst := add(dst, _1)
+//             src := add(src, _1)
+//         }
+//         value2 := dst_1
+//         let offset_1 := calldataload(add(headStart, 96))
+//         if gt(offset_1, _2) { revert(0, 0) }
+//         value3 := abi_decode_array_array_uint256_memory_dyn(add(headStart, offset_1), dataEnd)
+//     }
+//     function allocateMemory_967() -> memPtr
+//     {
+//         memPtr := mload(64)
+//         let newFreePtr := add(memPtr, 64)
+//         if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { revert(0, 0) }
+//         mstore(64, newFreePtr)
+//     }
+//     function allocateMemory(size) -> memPtr
+//     {
+//         memPtr := mload(64)
+//         let newFreePtr := add(memPtr, size)
+//         if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { revert(0, 0) }
+//         mstore(64, newFreePtr)
+//     }
+//     function array_allocation_size_array_address_dyn_memory(length) -> size
+//     {
+//         if gt(length, 0xffffffffffffffff) { revert(0, 0) }
+//         size := add(shl(5, length), 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_with_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_with_side_effects.yul
new file mode 100644
index 00000000..c8c969d8
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_with_side_effects.yul
@@ -0,0 +1,12 @@
+{
+    function fun_revert() -> ret { revert(0, 0) }
+    function fun_return() -> ret { return(0, 0) }
+    function empty(a, b) {}
+
+    // Evaluation order in Yul is always right to left so optimized code should reach the revert first.
+    empty(fun_return(), fun_revert())
+}
+// ----
+// step: fullSuite
+//
+// { { revert(0, 0) } }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_without_side_effects.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_without_side_effects.yul
new file mode 100644
index 00000000..fc36bdfa
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/call_arguments_without_side_effects.yul
@@ -0,0 +1,48 @@
+{
+    function empty(a, b, c) {
+        mstore(a, 1)
+        mstore(b, 1)
+        mstore(c, 1)
+    }
+
+    // Constants
+    empty(1, 2, 3)
+
+    // Variables
+    let x := 4
+    let y := 5
+    let z := 6
+    empty(x, y, z)
+
+    // Calls
+    empty(mload(7), sload(8), calldataload(9))
+
+    // Mix
+    let a := 12
+    empty(11, a, mload(13))
+
+    return(0, 32)
+}
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let _1 := 1
+//         mstore(_1, _1)
+//         mstore(2, _1)
+//         mstore(3, _1)
+//         mstore(4, _1)
+//         mstore(5, _1)
+//         mstore(6, _1)
+//         let _2 := sload(8)
+//         mstore(mload(7), _1)
+//         mstore(_2, _1)
+//         mstore(calldataload(9), _1)
+//         let _3 := mload(13)
+//         mstore(11, _1)
+//         mstore(12, _1)
+//         mstore(_3, _1)
+//         return(0, 32)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/clear_after_if_continue.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/clear_after_if_continue.yul
new file mode 100644
index 00000000..d5a5af83
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/clear_after_if_continue.yul
@@ -0,0 +1,25 @@
+{
+    let y := mload(0x20)
+    for {} and(y, 8) { if y { revert(0, 0) } } {
+        if y { continue }
+        sstore(1, y)
+    }
+    if y { revert(0, 0) }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let y := mload(0x20)
+//         let _1 := iszero(and(y, 8))
+//         for { } iszero(_1) { if y { revert(0, 0) } }
+//         {
+//             if y { continue }
+//             sstore(1, 0)
+//         }
+//         if y { revert(0, 0) }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul
new file mode 100644
index 00000000..f9d248e2
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul
@@ -0,0 +1,20 @@
+{
+    // This does not optimize the masks away. Due to the way the expression simplifier
+    // is built, it would have to create another `create2` opcode for the simplification
+    // which would be fatal.
+    let a := and(create2(0, 0, 0x20, 0), 0xffffffffffffffffffffffffffffffffffffffff)
+    let b := and(0xffffffffffffffffffffffffffffffffffffffff, create2(0, 0, 0x20, 0))
+    sstore(a, b)
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let _1 := sub(shl(160, 1), 1)
+//         let a := and(create2(0, 0, 0x20, 0), _1)
+//         sstore(a, and(_1, create2(0, 0, 0x20, 0)))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/devcon_example.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/devcon_example.yul
new file mode 100644
index 00000000..fe06f162
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/devcon_example.yul
@@ -0,0 +1,34 @@
+{
+    sstore(0, array_sum(calldataload(0)))
+
+    function array_sum(x) -> sum {
+        let length := calldataload(x)
+        for { let i := 0 } lt(i, length) { i := add(i, 1) } {
+            sum := add(sum, array_load(x, i))
+        }
+    }
+    function array_load(x, i) -> v {
+        let len := calldataload(x)
+        if iszero(lt(i, len)) { revert(0, 0) }
+        let data := add(x, 0x20)
+        v := calldataload(add(data, mul(i, 0x20)))
+    }
+}
+// ====
+// EVMVersion: >=istanbul
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let _1 := calldataload(0)
+//         let sum := 0
+//         let length := calldataload(_1)
+//         let i := 0
+//         for { } lt(i, length) { i := add(i, 1) }
+//         {
+//             sum := add(sum, calldataload(add(add(_1, shl(5, i)), 0x20)))
+//         }
+//         sstore(0, sum)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/loopInvariantCodeMotion.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/loopInvariantCodeMotion.yul
new file mode 100644
index 00000000..86329c32
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/loopInvariantCodeMotion.yul
@@ -0,0 +1,38 @@
+{
+    sstore(0, array_sum(calldataload(0)))
+
+    function array_sum(x) -> sum {
+        let length := calldataload(x)
+        for { let i := 0 } lt(i, length) { i := add(i, 1) } {
+            sum := add(sum, array_load(x, i))
+        }
+    }
+    function array_load(x, i) -> v {
+        let len := calldataload(x)
+        if iszero(lt(i, len)) { revert(0, 0) }
+        let data := add(x, 0x20)
+        v := calldataload(add(data, mul(i, 0x20)))
+        // this is just to have some additional code that
+        // can be moved out of the loop.
+        v := add(v, calldataload(7))
+    }
+}
+// ====
+// EVMVersion: >=istanbul
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let _1 := calldataload(0)
+//         let sum := 0
+//         let length := calldataload(_1)
+//         let i := 0
+//         let _2 := calldataload(7)
+//         for { } lt(i, length) { i := add(i, 1) }
+//         {
+//             sum := add(sum, add(calldataload(add(add(_1, shl(5, i)), 0x20)), _2))
+//         }
+//         sstore(0, sum)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy.sol b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy.sol
new file mode 100644
index 00000000..b0485242
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy.sol
@@ -0,0 +1,23 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    mcopy(0x20, 0, 0x20)    // Not redundant. MCOPY reads it.
+    mcopy(0x40, 0x10, 0x30)
+    mstore(0x20, 42)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         mcopy(0x20, 0, 0x20)
+//         mcopy(0x40, 0x10, 0x30)
+//         mstore(0x20, 42)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_overwritten.sol b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_overwritten.sol
new file mode 100644
index 00000000..252363de
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_overwritten.sol
@@ -0,0 +1,21 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    mcopy(0, 0x20, 0x20) // Redundant. Overwritten by MSTORE.
+    mstore(0, 42)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         mcopy(0, 0x20, 0x20)
+//         mstore(0, 42)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_same_area.sol b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_same_area.sol
new file mode 100644
index 00000000..a39f5b68
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_same_area.sol
@@ -0,0 +1,19 @@
+{
+    calldatacopy(0, 0, 0x20)
+
+    mcopy(0, 0, 0x20) // Redundant. Does not change any values.
+
+    return(0, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x20)
+//         mcopy(0, 0, 0x20)
+//         return(0, 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_zero_size.sol b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_zero_size.sol
new file mode 100644
index 00000000..3ae7c2c3
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/mcopy_redundant_zero_size.sol
@@ -0,0 +1,19 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    mcopy(0, 0x20, 0) // Redundant. Does not copy anything.
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         mcopy(0, 0, 0)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/name_cleaner_reserved.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_cleaner_reserved.yul
new file mode 100644
index 00000000..05cf04a7
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_cleaner_reserved.yul
@@ -0,0 +1,34 @@
+{
+	// This function name can be shortened, the other cannot.
+	function nonmstore_(x) {
+		if calldataload(0) { nonmstore_(x) }
+		sstore(10, calldataload(2))
+	}
+	function mstore_(x) -> y {
+		if calldataload(0) { let t3_3_ := mstore_(x) }
+		y := 8
+		sstore(y, calldataload(y))
+	}
+	let t2_ := mstore_(7)
+	nonmstore_(70)
+}
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         pop(mstore_(7))
+//         nonmstore(70)
+//     }
+//     function nonmstore(x)
+//     {
+//         if calldataload(0) { nonmstore(x) }
+//         sstore(10, calldataload(2))
+//     }
+//     function mstore_(x) -> y
+//     {
+//         if calldataload(0) { pop(mstore_(x)) }
+//         y := 8
+//         sstore(8, calldataload(8))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1.yul
new file mode 100644
index 00000000..f0d4b49b
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1.yul
@@ -0,0 +1,45 @@
+{
+    main(0, 0)
+
+    function main(a, b) {
+        for {} 1 {}
+        {
+            if iszero(a) { break }
+
+            let mid := avg(a, a)
+            switch a
+            case 0 {
+                a := mid
+            }
+            default {
+                sstore(0, mid)
+            }
+        }
+    }
+
+    function avg(x, y) -> var {
+        // NOTE: Variable names should not affect CSE.
+        // This should not be optimized differently than name_dependent_cse_bug_part_2.yul.
+        // `let mid := var` should be present in both or missing in both.
+        let _1 := add(x, y)
+        var := add(_1, _1)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let a := 0
+//         for { } a { }
+//         {
+//             let _1 := add(a, a)
+//             let var := add(_1, _1)
+//             switch a
+//             case 0 { a := var }
+//             default { sstore(0, var) }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1_pre_shanghai.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1_pre_shanghai.yul
new file mode 100644
index 00000000..d041cff1
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_1_pre_shanghai.yul
@@ -0,0 +1,46 @@
+{
+    main(0, 0)
+
+    function main(a, b) {
+        for {} 1 {}
+        {
+            if iszero(a) { break }
+
+            let mid := avg(a, a)
+            switch a
+            case 0 {
+                a := mid
+            }
+            default {
+                sstore(0, mid)
+            }
+        }
+    }
+
+    function avg(x, y) -> var {
+        // NOTE: Variable names should not affect CSE.
+        // This should not be optimized differently than name_dependent_cse_bug_part_2_pre_shanghai.yul.
+        // `let mid := var` should be present in both or missing in both.
+        let _1 := add(x, y)
+        var := add(_1, _1)
+    }
+}
+// ====
+// EVMVersion: <shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let a := 0
+//         let a_1 := 0
+//         for { } a_1 { }
+//         {
+//             let _1 := add(a_1, a_1)
+//             let var := add(_1, _1)
+//             switch a_1
+//             case 0 { a_1 := var }
+//             default { sstore(a, var) }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2.yul
new file mode 100644
index 00000000..879f8483
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2.yul
@@ -0,0 +1,45 @@
+{
+    main(0, 0)
+
+    function main(a, b) {
+        for {} 1 {}
+        {
+            if iszero(a) { break }
+
+            let mid := avg(a, a)
+            switch a
+            case 0 {
+                a := mid
+            }
+            default {
+                sstore(0, mid)
+            }
+        }
+    }
+
+    function avg(x, y) -> var {
+        // NOTE: Variable names should not affect CSE.
+        // This should not be optimized differently than name_dependent_cse_bug_part_1.yul.
+        // `let mid := var` should be present in both or missing in both.
+        let _2 := add(x, y)
+        var := add(_2, _2)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let a := 0
+//         for { } a { }
+//         {
+//             let _1 := add(a, a)
+//             let var := add(_1, _1)
+//             switch a
+//             case 0 { a := var }
+//             default { sstore(0, var) }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2_pre_shanghai.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2_pre_shanghai.yul
new file mode 100644
index 00000000..06965e3c
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/name_dependent_cse_bug_part_2_pre_shanghai.yul
@@ -0,0 +1,46 @@
+{
+    main(0, 0)
+
+    function main(a, b) {
+        for {} 1 {}
+        {
+            if iszero(a) { break }
+
+            let mid := avg(a, a)
+            switch a
+            case 0 {
+                a := mid
+            }
+            default {
+                sstore(0, mid)
+            }
+        }
+    }
+
+    function avg(x, y) -> var {
+        // NOTE: Variable names should not affect CSE.
+        // This should not be optimized differently than name_dependent_cse_bug_part_1_pre_shanghai.yul.
+        // `let mid := var` should be present in both or missing in both.
+        let _2 := add(x, y)
+        var := add(_2, _2)
+    }
+}
+// ====
+// EVMVersion: <shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         let a := 0
+//         let a_1 := 0
+//         for { } a_1 { }
+//         {
+//             let _1 := add(a_1, a_1)
+//             let var := add(_1, _1)
+//             switch a_1
+//             case 0 { a_1 := var }
+//             default { sstore(a, var) }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul
new file mode 100644
index 00000000..bf74af6f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/static_array_slot_computation.yul
@@ -0,0 +1,44 @@
+// The yul code for the following contract
+//  contract C {
+//	  uint256[] x;
+//	  function f() public { x[10] = 5; }
+//  }
+
+{
+    let _1 := 0
+    if eq(0x26121ff0, shr(224, calldataload(_1)))
+    {
+        if callvalue() { revert(_1, _1) }
+        if slt(add(calldatasize(), not(3)), _1) { revert(_1, _1) }
+        if iszero(lt(0x0a, sload(_1)))
+        {
+            mstore(_1, shl(224, 0x4e487b71))
+            mstore(4, 0x32)
+            revert(_1, 0x24)
+        }
+        mstore(_1, _1)
+        // The hash should be evaluated here
+        sstore(add(keccak256(_1, 0x20), 0x0a), 0x05)
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         if eq(0x26121ff0, shr(224, calldataload(0)))
+//         {
+//             if callvalue() { revert(0, 0) }
+//             if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) }
+//             if iszero(lt(0x0a, sload(0)))
+//             {
+//                 mstore(0, shl(224, 0x4e487b71))
+//                 mstore(4, 0x32)
+//                 revert(0, 0x24)
+//             }
+//             sstore(0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e56d, 0x05)
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/transient_storage.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/transient_storage.yul
new file mode 100644
index 00000000..44cd0a7f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/transient_storage.yul
@@ -0,0 +1,21 @@
+{
+    tstore(0, 13)
+    tstore(0, 42)
+    tstore(0x20, tload(0))
+    let x:= tload(0x20)
+    tstore(0, x)
+    pop(tload(0x20))
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         tstore(0, 13)
+//         tstore(0, 42)
+//         tstore(0x20, tload(0))
+//         tstore(0, tload(0x20))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul b/compiler/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul
new file mode 100644
index 00000000..f0b7546d
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/fullSuite/unusedFunctionParameterPruner_loop.yul
@@ -0,0 +1,38 @@
+{
+    sstore(f(1), 1)
+    sstore(f(2), 1)
+    sstore(f(3), 1)
+    function f(a) -> x {
+        for {let b := 10} iszero(b) { b := sub(b, 1) }
+        {
+            a := calldataload(0)
+            mstore(a, x)
+            // to prevent f from getting inlined
+            if iszero(a) { leave }
+        }
+    }
+}
+// ====
+// EVMVersion: >=shanghai
+// ----
+// step: fullSuite
+//
+// {
+//     {
+//         f()
+//         f()
+//         f()
+//         sstore(0, 1)
+//     }
+//     function f()
+//     {
+//         let b := 10
+//         let a := calldataload(0)
+//         let _1 := iszero(a)
+//         for { } iszero(b) { b := add(b, not(0)) }
+//         {
+//             mstore(a, 0)
+//             if _1 { leave }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_basic.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_basic.yul
new file mode 100644
index 00000000..b838c87e
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_basic.yul
@@ -0,0 +1,19 @@
+{
+    let x := calldataload(0)
+    let a := keccak256(0, x)
+    sstore(a, 2)
+    let t := mload(2)
+    let b := keccak256(0, x)
+    sstore(b, 3)
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let a := keccak256(_1, calldataload(_1))
+//         sstore(a, 2)
+//         sstore(a, 3)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_expr_mstore.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_expr_mstore.yul
new file mode 100644
index 00000000..7b37f8c9
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_expr_mstore.yul
@@ -0,0 +1,30 @@
+{
+    let a := calldataload(0)
+    sstore(f(keccak256(0, a)), keccak256(0, a))
+    sstore(f(keccak256(0, a)), keccak256(0, a))
+    sstore(keccak256(0, a), f(keccak256(0, a)))
+
+    function f(x) -> y {
+        mstore(x, 2)
+        y := mload(8)
+    }
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let a := calldataload(_1)
+//         let _3 := keccak256(_1, a)
+//         sstore(f(_3), _3)
+//         let _8 := keccak256(_1, a)
+//         sstore(f(_8), _8)
+//         sstore(keccak256(_1, a), f(keccak256(_1, a)))
+//     }
+//     function f(x) -> y
+//     {
+//         mstore(x, 2)
+//         y := mload(8)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_in_expression.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_in_expression.yul
new file mode 100644
index 00000000..f4d37d90
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_in_expression.yul
@@ -0,0 +1,14 @@
+{
+    let x := calldataload(0)
+    sstore(keccak256(0, x), keccak256(0, x))
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let _3 := keccak256(_1, calldataload(_1))
+//         sstore(_3, _3)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_msize.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_msize.yul
new file mode 100644
index 00000000..499a227c
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_msize.yul
@@ -0,0 +1,18 @@
+{
+    let a := calldataload(0)
+    let t := msize()
+    let x := keccak256(0, a)
+    let y := keccak256(0, a)
+    sstore(x, y)
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let a := calldataload(_1)
+//         let x := keccak256(_1, a)
+//         sstore(x, keccak256(_1, a))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_mstore.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_mstore.yul
new file mode 100644
index 00000000..65b5931a
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_mstore.yul
@@ -0,0 +1,22 @@
+{
+    let x := calldataload(0)
+    let a := keccak256(0x20, x)
+    sstore(a, 2)
+    // will disable loading for now, might improve later
+    mstore(0, 1)
+    let b := keccak256(0x20, x)
+    sstore(b, 3)
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let x := calldataload(_1)
+//         let _2 := 0x20
+//         sstore(keccak256(_2, x), 2)
+//         mstore(_1, 1)
+//         sstore(keccak256(_2, x), 3)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_branch.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_branch.yul
new file mode 100644
index 00000000..b780d62b
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_branch.yul
@@ -0,0 +1,37 @@
+{
+    let x := calldataload(0)
+    let y := calldataload(1)
+    let a := keccak256(x, y)
+    if calldataload(2) {
+        a := 8
+    }
+    let b := keccak256(x, y)
+    sstore(b, 2)
+    if calldataload(3) {
+        x := 8
+    }
+    let c := keccak256(x, y)
+    sstore(c, 2)
+    if calldataload(4) {
+        y := 8
+    }
+    let d := keccak256(x, y)
+    sstore(d, 2)
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let x := calldataload(0)
+//         let y := calldataload(1)
+//         let a := keccak256(x, y)
+//         let _3 := 2
+//         if calldataload(_3) { a := 8 }
+//         sstore(keccak256(x, y), _3)
+//         if calldataload(3) { x := 8 }
+//         sstore(keccak256(x, y), _3)
+//         if calldataload(4) { y := 8 }
+//         sstore(keccak256(x, y), _3)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_value.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_value.yul
new file mode 100644
index 00000000..232d76f1
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/keccak_reuse_reassigned_value.yul
@@ -0,0 +1,41 @@
+{
+    let x := calldataload(0)
+    let y := calldataload(1)
+    let a := keccak256(x, y)
+    sstore(a, 2)
+    // reassign value
+    a := calldataload(10)
+    let b := keccak256(x, y)
+    sstore(b, 3)
+    // reassign arg1
+    x := 10
+    let c := keccak256(x, y)
+    sstore(c, 4)
+    // reassign arg2
+    y := 9
+    let d := keccak256(x, y)
+    sstore(d, 5)
+    // no reassign, check that it is still working here.
+    let e := keccak256(x, y)
+    sstore(e, 6)
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let x := calldataload(0)
+//         let y := calldataload(1)
+//         let a := keccak256(x, y)
+//         sstore(a, 2)
+//         let _4 := 10
+//         a := calldataload(_4)
+//         sstore(keccak256(x, y), 3)
+//         x := _4
+//         sstore(keccak256(_4, y), 4)
+//         y := 9
+//         let d := keccak256(_4, y)
+//         sstore(d, 5)
+//         sstore(d, 6)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/scoped_var_ref_in_keccak.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/scoped_var_ref_in_keccak.yul
new file mode 100644
index 00000000..74660133
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/scoped_var_ref_in_keccak.yul
@@ -0,0 +1,20 @@
+{
+    let x
+    {
+        let y := msize()
+        x := add(4, y)
+    }
+    x := keccak256(0, mod(x, 2))
+}
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let x
+//         let y := msize()
+//         let _1 := 4
+//         x := add(_1, y)
+//         x := keccak256(0, addmod(_1, y, 2))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul b/compiler/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul
new file mode 100644
index 00000000..418221a9
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loadResolver/zero_length_reads.yul
@@ -0,0 +1,45 @@
+{
+  returndatacopy(1, 1, 0)
+  calldatacopy(1, 1, 0)
+  extcodecopy(1, 1, 1, 0)
+  codecopy(1, 1, 0)
+  log0(1, 0)
+  log1(1, 0, 1)
+  log2(1, 0, 1, 1)
+  log3(1, 0, 1, 1, 1)
+  log4(1, 0, 1, 1, 1, 1)
+  pop(create(1, 1, 0))
+  pop(create2(1, 1, 0, 1))
+  pop(call(1, 1, 1, 1, 0, 1, 0))
+  pop(callcode(1, 1, 1, 1, 0, 1, 0))
+  pop(delegatecall(1, 1, 1, 0, 1, 0))
+  pop(staticcall(1, 1, 1, 0, 1, 0))
+  return(1, 0)
+}
+// ====
+// EVMVersion: >=constantinople
+// ----
+// step: loadResolver
+//
+// {
+//     {
+//         let _1 := 0
+//         let _2 := 1
+//         returndatacopy(0, _2, _1)
+//         calldatacopy(0, _2, _1)
+//         extcodecopy(_2, 0, _2, _1)
+//         codecopy(0, _2, _1)
+//         log0(0, _1)
+//         log1(0, _1, _2)
+//         log2(0, _1, _2, _2)
+//         log3(0, _1, _2, _2, _2)
+//         log4(0, _1, _2, _2, _2, _2)
+//         pop(create(_2, 0, _1))
+//         pop(create2(_2, 0, _1, _2))
+//         pop(call(_2, _2, _2, 0, _1, _2, _1))
+//         pop(callcode(_2, _2, _2, 0, _1, _2, _1))
+//         pop(delegatecall(_2, _2, 0, _1, _2, _1))
+//         pop(staticcall(_2, _2, 0, _1, _2, _1))
+//         return(0, _1)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_transient_storage.yul b/compiler/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_transient_storage.yul
new file mode 100644
index 00000000..4c766c0b
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/loopInvariantCodeMotion/no_move_transient_storage.yul
@@ -0,0 +1,20 @@
+{
+    for { let i := 1 } iszero(eq(i, 10)) { i := add(i, 1) }
+    {
+        tstore(0, i)
+        sstore(i, tload(0))
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: loopInvariantCodeMotion
+//
+// {
+//     let i := 1
+//     for { } iszero(eq(i, 10)) { i := add(i, 1) }
+//     {
+//         tstore(0, i)
+//         sstore(i, tload(0))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_14.yul b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_14.yul
new file mode 100644
index 00000000..02614c49
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_14.yul
@@ -0,0 +1,55 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+        v := add(b1,b29)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x02c0))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) -> v
+//     {
+//         mstore(0x02a0, b1)
+//         mstore(0x0280, b2)
+//         mstore(0x0260, b3)
+//         mstore(0x0240, b4)
+//         mstore(0x0220, b5)
+//         mstore(0x0200, b6)
+//         mstore(0x01e0, b7)
+//         mstore(0x01c0, b8)
+//         mstore(0x01a0, b9)
+//         mstore(0x0180, b10)
+//         mstore(0x0160, b11)
+//         mstore(0x0140, b12)
+//         mstore(0x0120, b13)
+//         mstore(0x0100, b14)
+//         mstore(0xe0, b17)
+//         mstore(0xc0, b18)
+//         mstore(0xa0, b19)
+//         mstore(0x80, b29)
+//         sstore(0, mload(0x0100))
+//         sstore(1, b15)
+//         sstore(2, b16)
+//         sstore(3, mload(0xe0))
+//         sstore(4, mload(0xc0))
+//         sstore(5, mload(0xa0))
+//         sstore(6, mload(0x80))
+//         v := add(mload(0x02a0), mload(0x80))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_15.yul b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_15.yul
new file mode 100644
index 00000000..9ce9be70
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_15.yul
@@ -0,0 +1,61 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29, 30), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+	sstore(7, b30)
+        v := b30
+        sstore(b1, b30)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0300))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) -> v
+//     {
+//         mstore(0x02e0, b1)
+//         mstore(0x02c0, b2)
+//         mstore(0x02a0, b3)
+//         mstore(0x0280, b4)
+//         mstore(0x0260, b5)
+//         mstore(0x0240, b6)
+//         mstore(0x0220, b7)
+//         mstore(0x0200, b8)
+//         mstore(0x01e0, b9)
+//         mstore(0x01c0, b10)
+//         mstore(0x01a0, b11)
+//         mstore(0x0180, b12)
+//         mstore(0x0160, b13)
+//         mstore(0x0140, b14)
+//         mstore(0x0120, b15)
+//         mstore(0x0100, b17)
+//         mstore(0xe0, b18)
+//         mstore(0xc0, b19)
+//         mstore(0xa0, b29)
+//         mstore(0x80, b30)
+//         sstore(0, mload(0x0140))
+//         sstore(1, mload(0x0120))
+//         sstore(2, b16)
+//         sstore(3, mload(0x0100))
+//         sstore(4, mload(0xe0))
+//         sstore(5, mload(0xc0))
+//         sstore(6, mload(0xa0))
+//         sstore(7, mload(0x80))
+//         v := mload(0x80)
+//         sstore(mload(0x02e0), mload(0x80))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_16.yul b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_16.yul
new file mode 100644
index 00000000..5a3b3454
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/too_many_args_16.yul
@@ -0,0 +1,63 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        sstore(g(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31), 0)
+    }
+    function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> v {
+	sstore(0, b14)
+	sstore(1, b15)
+	sstore(2, b16)
+	sstore(3, b17)
+	sstore(4, b18)
+	sstore(5, b19)
+	sstore(6, b29)
+	sstore(7, b30)
+	sstore(8, b31)
+        v := add(b1,b31)
+    }
+
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0340))
+//         sstore(g(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31), 0)
+//     }
+//     function g(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) -> v
+//     {
+//         mstore(0x0320, b1)
+//         mstore(0x0300, b2)
+//         mstore(0x02e0, b3)
+//         mstore(0x02c0, b4)
+//         mstore(0x02a0, b5)
+//         mstore(0x0280, b6)
+//         mstore(0x0260, b7)
+//         mstore(0x0240, b8)
+//         mstore(0x0220, b9)
+//         mstore(0x0200, b10)
+//         mstore(0x01e0, b11)
+//         mstore(0x01c0, b12)
+//         mstore(0x01a0, b13)
+//         mstore(0x0180, b14)
+//         mstore(0x0160, b15)
+//         mstore(0x0140, b16)
+//         mstore(0x0120, b17)
+//         mstore(0x0100, b18)
+//         mstore(0xe0, b19)
+//         mstore(0xc0, b29)
+//         mstore(0xa0, b30)
+//         mstore(0x80, b31)
+//         sstore(0, mload(0x0180))
+//         sstore(1, mload(0x0160))
+//         sstore(2, mload(0x0140))
+//         sstore(3, mload(0x0120))
+//         sstore(4, mload(0x0100))
+//         sstore(5, mload(0xe0))
+//         sstore(6, mload(0xc0))
+//         sstore(7, mload(0xa0))
+//         sstore(8, mload(0x80))
+//         v := add(mload(0x0320), mload(0x80))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments.yul b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments.yul
new file mode 100644
index 00000000..bde030f6
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments.yul
@@ -0,0 +1,55 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        let a_1 := 1
+        let a_2 := 2
+        let a_3 := 3
+        let a_4 := 4
+        let a_5 := 5
+        let a_6 := 6
+        let a_7 := 7
+        let a_8 := 8
+        let a_9 := 9
+        let a_10 := 10
+        let a_11 := 11
+        let a_12 := 12
+        let a_13 := 13
+        let a_14 := 14
+        let a_15 := 15
+        let a_16 := 16
+        let a_17 := 17
+        let a_18 := 18
+        let a_19 := 19
+        let a_20 := 20
+        verbatim_20i_0o("test", a_1, a_2, a_3, a_4, a_5, a_6, a_7, a_8, a_9, a_10, a_11, a_12, a_13, a_14, a_15, a_16, a_17, a_18, a_19, a_20)
+    }
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0200))
+//         mstore(0x80, 1)
+//         mstore(0xa0, 2)
+//         mstore(0xc0, 3)
+//         mstore(0xe0, 4)
+//         mstore(0x0100, 5)
+//         mstore(0x0120, 6)
+//         mstore(0x0140, 7)
+//         mstore(0x0160, 8)
+//         mstore(0x0180, 9)
+//         mstore(0x01a0, 10)
+//         mstore(0x01c0, 11)
+//         mstore(0x01e0, 12)
+//         let a_13 := 13
+//         let a_14 := 14
+//         let a_15 := 15
+//         let a_16 := 16
+//         let a_17 := 17
+//         let a_18 := 18
+//         let a_19 := 19
+//         let a_20 := 20
+//         verbatim_20i_0o("test", mload(0x80), mload(0xa0), mload(0xc0), mload(0xe0), mload(0x0100), mload(0x0120), mload(0x0140), mload(0x0160), mload(0x0180), mload(0x01a0), mload(0x01c0), mload(0x01e0), a_13, a_14, a_15, a_16, a_17, a_18, a_19, a_20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments_and_returns.yul b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments_and_returns.yul
new file mode 100644
index 00000000..46435dd2
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/stackLimitEvader/verbatim_many_arguments_and_returns.yul
@@ -0,0 +1,116 @@
+{
+    {
+        mstore(0x40, memoryguard(128))
+        let a_1 := 1
+        let a_2 := 2
+        let a_3 := 3
+        let a_4 := 4
+        let a_5 := 5
+        let a_6 := 6
+        let a_7 := 7
+        let a_8 := 8
+        let a_9 := 9
+        let a_10 := 10
+        let a_11 := 11
+        let a_12 := 12
+        let a_13 := 13
+        let a_14 := 14
+        let a_15 := 15
+        let a_16 := 16
+        let a_17 := 17
+        let a_18 := 18
+        let a_19 := 19
+        let a_20 := 20
+        let b_1, b_2, b_3, b_4, b_5, b_6, b_7, b_8, b_9, b_10, b_11, b_12, b_13, b_14, b_15, b_16, b_17, b_18, b_19, b_20 := verbatim_20i_20o("test", a_1, a_2, a_3, a_4, a_5, a_6, a_7, a_8, a_9, a_10, a_11, a_12, a_13, a_14, a_15, a_16, a_17, a_18, a_19, a_20)
+        sstore(1, b_1)
+        sstore(2, b_2)
+        sstore(3, b_3)
+        sstore(4, b_4)
+        sstore(5, b_5)
+        sstore(6, b_6)
+        sstore(7, b_7)
+        sstore(8, b_8)
+        sstore(9, b_9)
+        sstore(10, b_10)
+        sstore(11, b_11)
+        sstore(12, b_12)
+        sstore(13, b_13)
+        sstore(14, b_14)
+        sstore(15, b_15)
+        sstore(16, b_16)
+        sstore(17, b_17)
+        sstore(18, b_18)
+        sstore(19, b_19)
+        sstore(20, b_20)
+
+    }
+}
+// ----
+// step: stackLimitEvader
+//
+// {
+//     {
+//         mstore(0x40, memoryguard(0x0280))
+//         mstore(0x0100, 1)
+//         mstore(0x0120, 2)
+//         mstore(0x0140, 3)
+//         mstore(0x0160, 4)
+//         mstore(0x0180, 5)
+//         mstore(0x01a0, 6)
+//         mstore(0x01c0, 7)
+//         mstore(0x01e0, 8)
+//         mstore(0x0200, 9)
+//         mstore(0x0220, 10)
+//         mstore(0x0240, 11)
+//         mstore(0x0260, 12)
+//         let a_13 := 13
+//         let a_14 := 14
+//         let a_15 := 15
+//         let a_16 := 16
+//         let a_17 := 17
+//         let a_18 := 18
+//         let a_19 := 19
+//         let a_20 := 20
+//         let b_1_1, b_2_2, b_3_3, b_4_4, b_5_5, b_6_6, b_7_7, b_8_8, b_9_9, b_10_10, b_11_11, b_12_12, b_13_13, b_14_14, b_15_15, b_16_16, b_17_17, b_18_18, b_19_19, b_20_20 := verbatim_20i_20o("test", mload(0x0100), mload(0x0120), mload(0x0140), mload(0x0160), mload(0x0180), mload(0x01a0), mload(0x01c0), mload(0x01e0), mload(0x0200), mload(0x0220), mload(0x0240), mload(0x0260), a_13, a_14, a_15, a_16, a_17, a_18, a_19, a_20)
+//         mstore(0x80, b_4_4)
+//         mstore(0xa0, b_3_3)
+//         mstore(0xc0, b_2_2)
+//         mstore(0xe0, b_1_1)
+//         let b_20 := b_20_20
+//         let b_19 := b_19_19
+//         let b_18 := b_18_18
+//         let b_17 := b_17_17
+//         let b_16 := b_16_16
+//         let b_15 := b_15_15
+//         let b_14 := b_14_14
+//         let b_13 := b_13_13
+//         let b_12 := b_12_12
+//         let b_11 := b_11_11
+//         let b_10 := b_10_10
+//         let b_9 := b_9_9
+//         let b_8 := b_8_8
+//         let b_7 := b_7_7
+//         let b_6 := b_6_6
+//         let b_5 := b_5_5
+//         sstore(1, mload(0xe0))
+//         sstore(2, mload(0xc0))
+//         sstore(3, mload(0xa0))
+//         sstore(4, mload(0x80))
+//         sstore(5, b_5)
+//         sstore(6, b_6)
+//         sstore(7, b_7)
+//         sstore(8, b_8)
+//         sstore(9, b_9)
+//         sstore(10, b_10)
+//         sstore(11, b_11)
+//         sstore(12, b_12)
+//         sstore(13, b_13)
+//         sstore(14, b_14)
+//         sstore(15, b_15)
+//         sstore(16, b_16)
+//         sstore(17, b_17)
+//         sstore(18, b_18)
+//         sstore(19, b_19)
+//         sstore(20, b_20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_conditional_revert.yul b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_conditional_revert.yul
new file mode 100644
index 00000000..3eeea6f4
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_conditional_revert.yul
@@ -0,0 +1,33 @@
+{
+    function g() {
+        if calldataload(10) { revert(0, 0) }
+    }
+    function f() {
+        let a := calldataload(0)
+        if calldataload(1) {
+            // this can NOT be removed
+            a := 2
+            g()
+        }
+        sstore(0, a)
+    }
+}
+// ----
+// step: unusedAssignEliminator
+//
+// {
+//     function g()
+//     {
+//         if calldataload(10) { revert(0, 0) }
+//     }
+//     function f()
+//     {
+//         let a := calldataload(0)
+//         if calldataload(1)
+//         {
+//             a := 2
+//             g()
+//         }
+//         sstore(0, a)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_leave.yul b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_leave.yul
new file mode 100644
index 00000000..4564f5d0
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_leave.yul
@@ -0,0 +1,22 @@
+{
+    function f() {
+        let a := calldataload(0)
+        if calldataload(1) {
+            // this can be removed
+            a := 2
+            leave
+        }
+        sstore(0, a)
+    }
+}
+// ----
+// step: unusedAssignEliminator
+//
+// {
+//     function f()
+//     {
+//         let a := calldataload(0)
+//         if calldataload(1) { leave }
+//         sstore(0, a)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_revert.yul b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_revert.yul
new file mode 100644
index 00000000..469da01f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/conditionally_assign_before_revert.yul
@@ -0,0 +1,17 @@
+{
+    let a := calldataload(0)
+    if calldataload(1) {
+        // this can be removed
+        a := 2
+        revert(0, 0)
+    }
+    sstore(0, a)
+}
+// ----
+// step: unusedAssignEliminator
+//
+// {
+//     let a := calldataload(0)
+//     if calldataload(1) { revert(0, 0) }
+//     sstore(0, a)
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/for_deep_noremove.yul b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/for_deep_noremove.yul
new file mode 100644
index 00000000..c0a84c24
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/for_deep_noremove.yul
@@ -0,0 +1,56 @@
+{
+    let x := 1
+    let y := 2
+    let a := 3
+    let b := 4
+    for {} 1 {} {
+    for {} 1 {} {
+    for {} 1 {} {
+    // Here, the nesting is not yet too deep, so the assignment
+    // should be removed.
+    for {} 1 { x := 9 } {
+        y := 10
+        for {} 1 {} {
+        for {} 1 {} {
+        // Now we are too deep, assignments stay.
+        for {} 1 { a := 10 } {
+            b := 12
+            b := 11
+        }
+        }
+        }
+    }
+    }
+    }
+    }
+    x := 13
+}
+// ----
+// step: unusedAssignEliminator
+//
+// {
+//     let x := 1
+//     let y := 2
+//     let a := 3
+//     let b := 4
+//     for { } 1 { }
+//     {
+//         for { } 1 { }
+//         {
+//             for { } 1 { }
+//             {
+//                 for { } 1 { }
+//                 {
+//                     for { } 1 { }
+//                     {
+//                         for { } 1 { }
+//                         {
+//                             for { } 1 { a := 10 }
+//                             { b := 11 }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/revert_after_assign_return.yul b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/revert_after_assign_return.yul
new file mode 100644
index 00000000..0a8a3582
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedAssignEliminator/revert_after_assign_return.yul
@@ -0,0 +1,35 @@
+{
+    function g() -> x {
+        x := 7
+        if calldataload(0) {
+            x := 3
+            reverting()
+        }
+        if calldataload(1) {
+            x := 3
+            leave
+        }
+        x := 2
+        reverting()
+    }
+    function reverting() { revert(0, 0) }
+    sstore(0, g())
+}
+// ----
+// step: unusedAssignEliminator
+//
+// {
+//     function g() -> x
+//     {
+//         if calldataload(0) { reverting() }
+//         if calldataload(1)
+//         {
+//             x := 3
+//             leave
+//         }
+//         reverting()
+//     }
+//     function reverting()
+//     { revert(0, 0) }
+//     sstore(0, g())
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedPruner/transient_storage.yul b/compiler/test/libyul/yulOptimizerTests/unusedPruner/transient_storage.yul
new file mode 100644
index 00000000..de083205
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedPruner/transient_storage.yul
@@ -0,0 +1,20 @@
+{
+    tstore(0, 5)
+    let x:= tload(0)
+    tstore(0, 8)
+    let y := tload(0)
+    tstore(0, y)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedPruner
+//
+// {
+//     {
+//         tstore(0, 5)
+//         tstore(0, 8)
+//         let y := tload(0)
+//         tstore(0, y)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mcopy_no_overlap.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mcopy_no_overlap.yul
new file mode 100644
index 00000000..51b6da83
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mcopy_no_overlap.yul
@@ -0,0 +1,31 @@
+{
+    calldatacopy(0, 0, 0x80)
+
+    let _0 := 0
+    let _32 := 32
+    let _64 := 64
+    let _96 := 96
+
+    // Sanity check: independent MCOPY is not affected
+    mcopy(_0, _32, _32)  // Not redundant. Not being overwritten.
+    mcopy(_64, _96, _32)
+
+    return(0, 0x80)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x80)
+//         let _0 := 0
+//         let _32 := 32
+//         let _64 := 64
+//         let _96 := 96
+//         mcopy(_0, _32, _32)
+//         mcopy(_64, _96, _32)
+//         return(0, 0x80)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mstore_no_overlap.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mstore_no_overlap.yul
new file mode 100644
index 00000000..0ff179d4
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_mstore_no_overlap.yul
@@ -0,0 +1,31 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _64 := 64
+
+    // Sanity check: independent MCOPY and MSTORE are not affected
+    mcopy(_0, _32, _32) // Not redundant. Not being overwritten.
+    mstore(_64, _42)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _64 := 64
+//         mcopy(_0, _32, _32)
+//         mstore(_64, _42)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_non_overlapping_areas.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_non_overlapping_areas.yul
new file mode 100644
index 00000000..48e1a4ec
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_non_overlapping_areas.yul
@@ -0,0 +1,24 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+
+    mcopy(_0, _32, _32) // Not redundant. Not being overwritten.
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         mcopy(_0, _32, _32)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overlapping_areas.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overlapping_areas.yul
new file mode 100644
index 00000000..70d67640
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overlapping_areas.yul
@@ -0,0 +1,25 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _32 := 32
+    let _64 := 64
+
+    mcopy(_0, _32, _64) // Not redundant. Not being overwritten.
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _32 := 32
+//         mcopy(_0, _32, 64)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mcopy.yul
new file mode 100644
index 00000000..3334580f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mcopy.yul
@@ -0,0 +1,26 @@
+{
+    calldatacopy(0, 0, 0x80)
+
+    let _0 := 0
+    let _64 := 64
+
+    mcopy(_0, _64, _64) // Redundant. MCOPY overwrites it.
+    mcopy(_0, _64, _64)
+
+    return(0, 0x80)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x80)
+//         let _0 := 0
+//         let _64 := 64
+//         mcopy(_0, _64, _64)
+//         mcopy(_0, _64, _64)
+//         return(0, 0x80)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore.yul
new file mode 100644
index 00000000..0c4490a4
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore.yul
@@ -0,0 +1,27 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+
+    mstore(_0, _42) // Redundant. MCOPY overwrites it.
+    mcopy(_0, _32, _32)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         mcopy(_0, _32, _32)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore_overlap.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore_overlap.yul
new file mode 100644
index 00000000..1c99063f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_overwriting_mstore_overlap.yul
@@ -0,0 +1,32 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _1 := 1
+    let _32 := 32
+    let _42 := 42
+    let _64 := 64
+
+    mstore(_0, _42) // Not redundant. MCOPY does not overwrite all of it.
+    mcopy(_1, _64, _32)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _1 := 1
+//         let _32 := 32
+//         let _42 := 42
+//         let _64 := 64
+//         mstore(_0, _42)
+//         mcopy(_1, _64, _32)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mcopy.yul
new file mode 100644
index 00000000..96d69ffb
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mcopy.yul
@@ -0,0 +1,31 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _64 := 64
+
+    mcopy(_32, _64, _32) // Not redundant. MCOPY reads it.
+    mcopy(_0, _32, _32)
+    mstore(_32, _42)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         mcopy(_32, 64, _32)
+//         mcopy(_0, _32, _32)
+//         mstore(_32, _42)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore.yul
new file mode 100644
index 00000000..d0c50bfb
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore.yul
@@ -0,0 +1,32 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    mstore(_0, _42) // Not redundant. MCOPY reads it.
+    mcopy(_32, _0, _32)
+    mstore(_0, _123)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mstore(_0, _42)
+//         mcopy(_32, _0, _32)
+//         mstore(_0, _123)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore8.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore8.yul
new file mode 100644
index 00000000..c6dcbc18
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore8.yul
@@ -0,0 +1,34 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _1 := 1
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    mstore8(_0, _42) // Not redundant. MCOPY reads it.
+    mcopy(_32, _0, _1)
+    mstore8(_0, _123)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _1 := 1
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mstore8(_0, _42)
+//         mcopy(_32, _0, _1)
+//         mstore8(_0, _123)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overhang.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overhang.yul
new file mode 100644
index 00000000..98a77592
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overhang.yul
@@ -0,0 +1,34 @@
+{
+    calldatacopy(0, 0, 0x120)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _96 := 96
+    let _123 := 123
+
+    mstore(_32, _42) // Not redundant. MCOPY reads it.
+    mcopy(_96, _0, _96)
+    mstore(_32, _123)
+
+    return(0, 0x120)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x120)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _96 := 96
+//         let _123 := 123
+//         mstore(_32, _42)
+//         mcopy(_96, _0, _96)
+//         mstore(_32, _123)
+//         return(0, 0x120)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overlap.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overlap.yul
new file mode 100644
index 00000000..32a1fbf4
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_overlap.yul
@@ -0,0 +1,36 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _31 := 31
+    let _32 := 32
+    let _42 := 42
+    let _64 := 64
+    let _123 := 123
+
+    mstore(_0, _42) // Not redundant. MCOPY reads part of it.
+    mcopy(_64, _31, _32)
+    mstore(_0, _123)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _31 := 31
+//         let _32 := 32
+//         let _42 := 42
+//         let _64 := 64
+//         let _123 := 123
+//         mstore(_0, _42)
+//         mcopy(_64, _31, _32)
+//         mstore(_0, _123)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_underhang.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_underhang.yul
new file mode 100644
index 00000000..b339d284
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_mstore_underhang.yul
@@ -0,0 +1,36 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _1 := 1
+    let _16 := 16
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    mstore(_0, _42) // Not redundant. MCOPY reads part of it.
+    mcopy(_32, _16, _1)
+    mstore(_0, _123)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _1 := 1
+//         let _16 := 16
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mstore(_0, _42)
+//         mcopy(_32, _16, _1)
+//         mstore(_0, _123)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_overlapping_areas_mstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_overlapping_areas_mstore.yul
new file mode 100644
index 00000000..fa73f017
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_overlapping_areas_mstore.yul
@@ -0,0 +1,34 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _64 := 64
+    let _123 := 123
+
+    mstore(_32, _42) // Redundant. MCOPY overwrites it.
+    mcopy(_0, _32, _64)
+    mstore(_32, _123)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _64 := 64
+//         let _123 := 123
+//         mstore(_32, _42)
+//         mcopy(_0, _32, _64)
+//         mstore(_32, _123)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mcopy.yul
new file mode 100644
index 00000000..b7227913
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mcopy.yul
@@ -0,0 +1,30 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+
+    mcopy(_0, _32, _32) // Redundant. MSTORE overwrites it.
+    mcopy(_0, _0, _32)  // Redundant (no-op)
+    mstore(_32, _42)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         mcopy(_0, _32, _32)
+//         mcopy(_0, _0, _32)
+//         mstore(_32, _42)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore.yul
new file mode 100644
index 00000000..5edbc22b
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore.yul
@@ -0,0 +1,34 @@
+{
+    calldatacopy(0, 0, 0x20)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    mstore(_0, _42)    // Redundant. MSTORE overwrites it.
+    mcopy(_0, _0, _32) // Redundant (no-op)
+    mstore(_0, _123)
+
+    return(0, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         let _1 := 0x20
+//         let _2 := 0
+//         let _3 := 0
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mstore(_0, _42)
+//         mcopy(_0, _0, _32)
+//         mstore(_0, _123)
+//         return(0, 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore8.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore8.yul
new file mode 100644
index 00000000..aab661f6
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore8.yul
@@ -0,0 +1,32 @@
+{
+    calldatacopy(0, 0, 0x20)
+
+    let _0 := 0
+    let _1 := 1
+    let _42 := 42
+    let _123 := 123
+
+    mstore8(_0, _42)  // Redundant. MSTORE8 overwrites it.
+    mcopy(_0, _0, _1) // Redundant (no-op)
+    mstore8(_0, _123)
+
+    return(0, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x20)
+//         let _0 := 0
+//         let _1 := 1
+//         let _42 := 42
+//         let _123 := 123
+//         mstore8(_0, _42)
+//         mcopy(_0, _0, _1)
+//         mstore8(_0, _123)
+//         return(0, 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore_overlap.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore_overlap.yul
new file mode 100644
index 00000000..36b4fc48
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_reading_writing_same_area_mstore_overlap.yul
@@ -0,0 +1,34 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _1 := 1
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    mstore(_0, _42)    // Redundant. MSTORE overwrites it.
+    mcopy(_1, _1, _32) // Redundant (no-op)
+    mstore(_0, _123)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _1 := 1
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mstore(_0, _42)
+//         mcopy(_1, _1, _32)
+//         mstore(_0, _123)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_area.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_area.yul
new file mode 100644
index 00000000..1d0f86b8
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_area.yul
@@ -0,0 +1,23 @@
+{
+    calldatacopy(0, 0, 0x20)
+
+    let _0 := 0
+    let _32 := 32
+
+    mcopy(_0, _0, _32) // Redundant (no-op)
+
+    return(0, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x20)
+//         let _0 := 0
+//         mcopy(_0, _0, 32)
+//         return(0, 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_write_area_overwriting_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_write_area_overwriting_mcopy.yul
new file mode 100644
index 00000000..0e473a35
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_same_write_area_overwriting_mcopy.yul
@@ -0,0 +1,28 @@
+{
+    calldatacopy(0, 0, 0x60)
+
+    let _0 := 0
+    let _32 := 32
+    let _64 := 64
+
+    mcopy(_0, _32, _32) // Redundant. MCOPY overwrites it.
+    mcopy(_0, _64, _32)
+
+    return(0, 0x60)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x60)
+//         let _0 := 0
+//         let _32 := 32
+//         let _64 := 64
+//         mcopy(_0, _32, _32)
+//         mcopy(_0, _64, _32)
+//         return(0, 0x60)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_sstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_sstore.yul
new file mode 100644
index 00000000..87fd89d3
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mcopy_sstore.yul
@@ -0,0 +1,32 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+    let _123 := 123
+
+    // Sanity check: MCOPY does not affect storage
+    sstore(_0, _42) // Redundant. SSTORE overwrites it.
+    mcopy(_32, _0, _32)
+    sstore(_0, _123)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         let _123 := 123
+//         mcopy(_32, _0, _32)
+//         sstore(_0, _123)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload_reading_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload_reading_mcopy.yul
new file mode 100644
index 00000000..759e631f
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mload_reading_mcopy.yul
@@ -0,0 +1,32 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+
+    mcopy(_0, _32, _32) // Not redundant. MLOAD reads it.
+    let mem0 := mload(_0)
+    mstore(_0, _42)
+
+    sstore(_0, mem0)
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         mcopy(_0, _32, _32)
+//         let mem0 := mload(_0)
+//         mstore(_0, _42)
+//         sstore(_0, mem0)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mcopy.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mcopy.yul
new file mode 100644
index 00000000..f32267a3
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mcopy.yul
@@ -0,0 +1,28 @@
+{
+    calldatacopy(0, 0, 0x40)
+
+    let _0 := 0
+    let _32 := 32
+    let _42 := 42
+
+    mcopy(_0, _32, _32) // Redundant. MSTORE overwrites it.
+    mstore(_0, _42)
+
+    return(0, 0x40)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         calldatacopy(0, 0, 0x40)
+//         let _0 := 0
+//         let _32 := 32
+//         let _42 := 42
+//         mcopy(_0, _32, _32)
+//         mstore(_0, _42)
+//         return(0, 0x40)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mstore.yul
new file mode 100644
index 00000000..83208b8e
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/mstore_overwriting_mstore.yul
@@ -0,0 +1,28 @@
+{
+    calldatacopy(0, 0, 0x20)
+
+    let _0 := 0
+    let _42 := 42
+    let _123 := 123
+
+    mstore(_0, _42) // Redundant. MSTORE overwrites it.
+    mstore(_0, _123)
+
+    return(0, 0x20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         let _1 := 0x20
+//         let _2 := 0
+//         let _3 := 0
+//         let _0 := 0
+//         let _42 := 42
+//         mstore(_0, 123)
+//         return(0, 0x20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tload.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tload.yul
new file mode 100644
index 00000000..43b96f0e
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tload.yul
@@ -0,0 +1,22 @@
+{
+    let zero := 0
+    tstore(zero, 5)
+    let x := tload(zero)
+    tstore(zero, 8)
+    let y := tload(zero)
+    tstore(zero, y)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         let zero := 0
+//         tstore(zero, 5)
+//         let x := tload(zero)
+//         tstore(zero, 8)
+//         tstore(zero, tload(zero))
+//     }
+// }
diff --git a/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tstore.yul b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tstore.yul
new file mode 100644
index 00000000..f3befb79
--- /dev/null
+++ b/compiler/test/libyul/yulOptimizerTests/unusedStoreEliminator/tstore.yul
@@ -0,0 +1,23 @@
+{
+    let x := 5
+    tstore(x, 10)
+    sstore(x, 10)
+    pop(mload(0))
+    tstore(x, 10)
+    sstore(x, 20)
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// step: unusedStoreEliminator
+//
+// {
+//     {
+//         let x := 5
+//         tstore(x, 10)
+//         let _2 := 10
+//         pop(mload(0))
+//         tstore(x, 10)
+//         sstore(x, 20)
+//     }
+// }
diff --git a/compiler/test/libyul/yulStackLayout/function.yul b/compiler/test/libyul/yulStackLayout/function.yul
new file mode 100644
index 00000000..ccf97422
--- /dev/null
+++ b/compiler/test/libyul/yulStackLayout/function.yul
@@ -0,0 +1,111 @@
+{
+    function f(a, b) -> r {
+        let x := add(a,b)
+        r := sub(x,a)
+    }
+    function g() {
+        sstore(0x01, 0x0101)
+    }
+    function h(x) {
+        h(f(x, 0))
+        g()
+    }
+    function i() -> v, w {
+        v := 0x0202
+        w := 0x0303
+    }
+    let x, y := i()
+    h(x)
+    h(y)
+}
+// ----
+// digraph CFG {
+// nodesep=0.7;
+// node[shape=box];
+//
+// Entry [label="Entry"];
+// Entry -> Block0;
+// Block0 [label="\
+// [ ]\l\
+// [ RET[i] ]\l\
+// i\l\
+// [ TMP[i, 0] TMP[i, 1] ]\l\
+// [ TMP[i, 0] TMP[i, 1] ]\l\
+// Assignment(x, y)\l\
+// [ x y ]\l\
+// [ x ]\l\
+// h\l\
+// [ ]\l\
+// [ ]\l\
+// "];
+// Block0Exit [label="Terminated"];
+// Block0 -> Block0Exit;
+//
+// FunctionEntry_f [label="function f(a, b) -> r\l\
+// [ RET b a ]"];
+// FunctionEntry_f -> Block1;
+// Block1 [label="\
+// [ RET a b ]\l\
+// [ RET a b a ]\l\
+// add\l\
+// [ RET a TMP[add, 0] ]\l\
+// [ RET a TMP[add, 0] ]\l\
+// Assignment(x)\l\
+// [ RET a x ]\l\
+// [ RET a x ]\l\
+// sub\l\
+// [ RET TMP[sub, 0] ]\l\
+// [ RET TMP[sub, 0] ]\l\
+// Assignment(r)\l\
+// [ RET r ]\l\
+// [ r RET ]\l\
+// "];
+// Block1Exit [label="FunctionReturn[f]"];
+// Block1 -> Block1Exit;
+//
+// FunctionEntry_g [label="function g()\l\
+// [ RET ]"];
+// FunctionEntry_g -> Block2;
+// Block2 [label="\
+// [ RET ]\l\
+// [ RET 0x0101 0x01 ]\l\
+// sstore\l\
+// [ RET ]\l\
+// [ RET ]\l\
+// "];
+// Block2Exit [label="FunctionReturn[g]"];
+// Block2 -> Block2Exit;
+//
+// FunctionEntry_h [label="function h(x)\l\
+// [ RET x ]"];
+// FunctionEntry_h -> Block3;
+// Block3 [label="\
+// [ RET[f] 0x00 x ]\l\
+// [ RET[f] 0x00 x ]\l\
+// f\l\
+// [ TMP[f, 0] ]\l\
+// [ TMP[f, 0] ]\l\
+// h\l\
+// [ ]\l\
+// [ ]\l\
+// "];
+// Block3Exit [label="Terminated"];
+// Block3 -> Block3Exit;
+//
+// FunctionEntry_i [label="function i() -> v, w\l\
+// [ RET ]"];
+// FunctionEntry_i -> Block4;
+// Block4 [label="\
+// [ RET ]\l\
+// [ RET 0x0202 ]\l\
+// Assignment(v)\l\
+// [ RET v ]\l\
+// [ v RET 0x0303 ]\l\
+// Assignment(w)\l\
+// [ v RET w ]\l\
+// [ v w RET ]\l\
+// "];
+// Block4Exit [label="FunctionReturn[i]"];
+// Block4 -> Block4Exit;
+//
+// }
diff --git a/compiler/test/libyul/yulStackShuffling/swap_cycle.stack b/compiler/test/libyul/yulStackShuffling/swap_cycle.stack
new file mode 100644
index 00000000..fbda89eb
--- /dev/null
+++ b/compiler/test/libyul/yulStackShuffling/swap_cycle.stack
@@ -0,0 +1,22 @@
+[ v0 v1 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET RET v5 ]
+[ v1 v0 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET JUNK JUNK ]
+// ----
+// [ v0 v1 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET RET v5 ]
+// POP
+// [ v0 v1 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET RET ]
+// SWAP16
+// [ v0 RET v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET v1 ]
+// SWAP16
+// [ v0 v1 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET RET ]
+// POP
+// [ v0 v1 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET ]
+// SWAP15
+// [ v0 RET v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 v1 ]
+// SWAP16
+// [ v1 RET v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 v0 ]
+// SWAP15
+// [ v1 v0 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET ]
+// PUSH JUNK
+// [ v1 v0 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET JUNK ]
+// PUSH JUNK
+// [ v1 v0 v2 v3 v4 v5 v6 v7 v9 v10 v11 v12 v13 v14 v15 v16 RET JUNK JUNK ]
diff --git a/compiler/test/libyul/yulSyntaxTests/blobbasefee_identifier_pre_cancun.yul b/compiler/test/libyul/yulSyntaxTests/blobbasefee_identifier_pre_cancun.yul
new file mode 100644
index 00000000..42c1f2c0
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/blobbasefee_identifier_pre_cancun.yul
@@ -0,0 +1,6 @@
+{
+    function blobbasefee() {}
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
diff --git a/compiler/test/libyul/yulSyntaxTests/blobbasefee_reserved_identifier_post_cancun.yul b/compiler/test/libyul/yulSyntaxTests/blobbasefee_reserved_identifier_post_cancun.yul
new file mode 100644
index 00000000..61fa7d7e
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/blobbasefee_reserved_identifier_post_cancun.yul
@@ -0,0 +1,7 @@
+{
+    function blobbasefee() {}
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (15-26): Cannot use builtin function name "blobbasefee" as identifier name.
diff --git a/compiler/test/libyul/yulSyntaxTests/blobhash.yul b/compiler/test/libyul/yulSyntaxTests/blobhash.yul
new file mode 100644
index 00000000..6337f22c
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/blobhash.yul
@@ -0,0 +1,15 @@
+{
+    {
+        let blobhash := 1
+    }
+
+    {
+        function blobhash() {}
+        blobhash()
+    }
+}
+
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (20-28): Cannot use builtin function name "blobhash" as identifier name.
diff --git a/compiler/test/libyul/yulSyntaxTests/blobhash_pre_cancun.yul b/compiler/test/libyul/yulSyntaxTests/blobhash_pre_cancun.yul
new file mode 100644
index 00000000..777024cd
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/blobhash_pre_cancun.yul
@@ -0,0 +1,13 @@
+{
+    {
+        let blobhash := 1
+    }
+
+    {
+        function blobhash() {}
+        blobhash()
+    }
+}
+// ====
+// EVMVersion: <=shanghai
+// ----
diff --git a/compiler/test/libyul/yulSyntaxTests/invalid/push0_disallowed.yul b/compiler/test/libyul/yulSyntaxTests/invalid/push0_disallowed.yul
new file mode 100644
index 00000000..00fe3c12
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/invalid/push0_disallowed.yul
@@ -0,0 +1,6 @@
+// Based on ./push_disallowed.yul (which already includes push0).
+{
+    push0()
+}
+// ----
+// DeclarationError 4619: (72-77): Function "push0" not found.
diff --git a/compiler/test/libyul/yulSyntaxTests/mcopy.yul b/compiler/test/libyul/yulSyntaxTests/mcopy.yul
new file mode 100644
index 00000000..1f5d042f
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/mcopy.yul
@@ -0,0 +1,5 @@
+{
+    mcopy(0x100, 0x200, 0x300)
+}
+// ====
+// EVMVersion: >=cancun
diff --git a/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier.yul b/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier.yul
new file mode 100644
index 00000000..e48c27d0
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier.yul
@@ -0,0 +1,14 @@
+{
+    {
+        let mcopy := 1
+    }
+
+    {
+        function mcopy() {}
+        mcopy()
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (20-25): Cannot use builtin function name "mcopy" as identifier name.
diff --git a/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier_pre_cancun.yul b/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier_pre_cancun.yul
new file mode 100644
index 00000000..096fce4e
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/mcopy_as_identifier_pre_cancun.yul
@@ -0,0 +1,12 @@
+{
+    {
+        let mcopy := 1
+    }
+
+    {
+        function mcopy() {}
+        mcopy()
+    }
+}
+// ====
+// EVMVersion: <cancun
diff --git a/compiler/test/libyul/yulSyntaxTests/mcopy_pre_cancun.yul b/compiler/test/libyul/yulSyntaxTests/mcopy_pre_cancun.yul
new file mode 100644
index 00000000..096fce4e
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/mcopy_pre_cancun.yul
@@ -0,0 +1,12 @@
+{
+    {
+        let mcopy := 1
+    }
+
+    {
+        function mcopy() {}
+        mcopy()
+    }
+}
+// ====
+// EVMVersion: <cancun
diff --git a/compiler/test/libyul/yulSyntaxTests/mcopy_wrong_args.yul b/compiler/test/libyul/yulSyntaxTests/mcopy_wrong_args.yul
new file mode 100644
index 00000000..87203a65
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/mcopy_wrong_args.yul
@@ -0,0 +1,13 @@
+{
+    mcopy(0x100, 0x200, 0x300, 0x400)
+    mcopy(0x100, 0x200)
+    mcopy(0x100)
+    mcopy()
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// TypeError 7000: (6-11): Function "mcopy" expects 3 arguments but got 4.
+// TypeError 7000: (44-49): Function "mcopy" expects 3 arguments but got 2.
+// TypeError 7000: (68-73): Function "mcopy" expects 3 arguments but got 1.
+// TypeError 7000: (85-90): Function "mcopy" expects 3 arguments but got 0.
diff --git a/compiler/test/libyul/yulSyntaxTests/selfdestruct.yul b/compiler/test/libyul/yulSyntaxTests/selfdestruct.yul
new file mode 100644
index 00000000..faecf92c
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/selfdestruct.yul
@@ -0,0 +1,5 @@
+{
+	selfdestruct(0x02)
+}
+// ----
+// Warning 1699: (3-15): "selfdestruct" has been deprecated. Note that, starting from the Cancun hard fork, the underlying opcode no longer deletes the code and data associated with an account and only transfers its Ether to the beneficiary, unless executed in the same transaction in which the contract was created (see EIP-6780). Any use in newly deployed contracts is strongly discouraged even if the new behavior is taken into account. Future changes to the EVM might further reduce the functionality of the opcode.
diff --git a/compiler/test/libyul/yulSyntaxTests/tload_as_identifier_post_cancun.yul b/compiler/test/libyul/yulSyntaxTests/tload_as_identifier_post_cancun.yul
new file mode 100644
index 00000000..2c1dcb0d
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/tload_as_identifier_post_cancun.yul
@@ -0,0 +1,9 @@
+{
+    function f() {
+        let tload := 0
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (33-38): Cannot use builtin function name "tload" as identifier name.
diff --git a/compiler/test/libyul/yulSyntaxTests/tstore_as_identifier_post_cancun.yul b/compiler/test/libyul/yulSyntaxTests/tstore_as_identifier_post_cancun.yul
new file mode 100644
index 00000000..d810ed2b
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/tstore_as_identifier_post_cancun.yul
@@ -0,0 +1,7 @@
+{
+    function tstore() {}
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// ParserError 5568: (15-21): Cannot use builtin function name "tstore" as identifier name.
diff --git a/compiler/test/libyul/yulSyntaxTests/tstore_tload.yul b/compiler/test/libyul/yulSyntaxTests/tstore_tload.yul
new file mode 100644
index 00000000..e7342935
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/tstore_tload.yul
@@ -0,0 +1,11 @@
+{
+    function f() {
+        let x := tload(0)
+        let y := add(x, 1)
+        tstore(0, y)
+    }
+}
+// ====
+// EVMVersion: >=cancun
+// ----
+// Warning 2394: (82-88): Transient storage as defined by EIP-1153 can break the composability of smart contracts: Since transient storage is cleared only at the end of the transaction and not at the end of the outermost call frame to the contract within a transaction, your contract may unintentionally misbehave when invoked multiple times in a complex transaction. To avoid this, be sure to clear all transient storage at the end of any call to your contract. The use of transient storage for reentrancy guards that are cleared at the end of the call is safe.
diff --git a/compiler/test/libyul/yulSyntaxTests/tstore_tload_as_identifiers_pre_cancun.yul b/compiler/test/libyul/yulSyntaxTests/tstore_tload_as_identifiers_pre_cancun.yul
new file mode 100644
index 00000000..19e9d2f5
--- /dev/null
+++ b/compiler/test/libyul/yulSyntaxTests/tstore_tload_as_identifiers_pre_cancun.yul
@@ -0,0 +1,6 @@
+{
+    function tstore() {}
+    function tload() {}
+}
+// ====
+// EVMVersion: <cancun
diff --git a/compiler/test/lsp.py b/compiler/test/lsp.py
new file mode 100755
index 00000000..11007ae8
--- /dev/null
+++ b/compiler/test/lsp.py
@@ -0,0 +1,2061 @@
+#!/usr/bin/env python3
+# pragma pylint: disable=too-many-lines
+# test line 1
+from __future__ import annotations # See: https://github.com/PyCQA/pylint/issues/3320
+import argparse
+import fnmatch
+import functools
+import json
+import os
+import re
+import subprocess
+import sys
+import traceback
+from collections import namedtuple
+from copy import deepcopy
+from enum import Enum, auto
+from itertools import islice
+from pathlib import PurePath
+from typing import Any, List, Optional, Tuple, Union, NewType
+
+import colorama  # Enables the use of SGR & CUP terminal VT sequences on Windows.
+from deepdiff import DeepDiff
+
+if os.name == 'nt':
+    # pragma pylint: disable=import-error
+    import msvcrt
+else:
+    import tty
+    # Turn off user input buffering so we get the input immediately,
+    # not only after a line break
+    if os.isatty(sys.stdin.fileno()):
+        tty.setcbreak(sys.stdin.fileno())
+
+
+# Type for the pure test name without .sol suffix or sub directory
+TestName = NewType("TestName", str)
+
+# Type for the test path, e.g.  subdir/mytest.sol
+RelativeTestPath = NewType("RelativeTestPath", str)
+
+
+def escape_string(text: str) -> str:
+    """
+    Trivially escapes given input string's \r \n and \\.
+    """
+    return text.translate(str.maketrans({
+        "\r": r"\r",
+        "\n": r"\n",
+        "\\": r"\\"
+    }))
+
+
+def getCharFromStdin() -> str:
+    """
+    Gets a single character from stdin without line-buffering.
+    """
+    if os.name == 'nt':
+        # pragma pylint: disable=import-error
+        return msvcrt.getch().decode("utf-8")
+    else:
+        return sys.stdin.read(1)
+
+
+"""
+Named tuple that holds various regexes used to parse the test specification.
+"""
+TestRegexesTuple = namedtuple("TestRegexesTuple", [
+    "sendRequest", # regex to find requests to be sent & tested
+    "findQuotedTag", # regex to find tags wrapped in quotes
+    "findTag", # regex to find tags
+    "fileDiagnostics", # regex to find diagnostic expectations for a file
+    "diagnostic" # regex to find a single diagnostic within the file expectations
+])
+"""
+Instance of the named tuple holding the regexes
+"""
+TEST_REGEXES = TestRegexesTuple(
+    re.compile(R'^// -> (?P<method>[\w\/]+) {'),
+    re.compile(R'(?P<tag>"@\w+")'),
+    re.compile(R'(?P<tag>@\w+)'),
+    re.compile(R'// (?P<testname>\S+):([ ](?P<diagnostics>[\w @]*))?'),
+    re.compile(R'(?P<tag>@\w+) (?P<code>\d\d\d\d)')
+)
+
+"""
+Named tuple holding regexes to find tags in the solidity code
+"""
+TagRegexesTuple = namedtuple("TagRegexestuple", ["simpleRange", "multilineRange"])
+TAG_REGEXES = TagRegexesTuple(
+    re.compile(R"(?P<range>[\^]+) (?P<tag>@\w+)"),
+    re.compile(R"\^(?P<delimiter>[()]{1,2}) (?P<tag>@\w+)$")
+)
+
+def split_path(path):
+    """
+    Return the test name and the subdir path of the given path.
+    """
+    sub_dir_separator = path.rfind("/")
+
+    if sub_dir_separator == -1:
+        return (path, None)
+
+    return (path[sub_dir_separator+1:], path[:sub_dir_separator])
+
+def count_index(lines, start=0):
+    """
+    Takes an iterable of lines and adds the current byte index so it's available
+    when iterating or looping.
+    """
+    n = start
+    for elem in lines:
+        yield n, elem
+        n += 1 + len(elem)
+
+def tags_only(lines, start=0):
+    """
+    Filter the lines for tag comments and report the line number that the tags
+    _refer_ to (which is not the line they are on!).
+    """
+    n = start
+    numCommentLines = 0
+
+    def hasTag(line):
+        if line.find("// ") != -1:
+            for _, regex in TAG_REGEXES._asdict().items():
+                if regex.search(line[len("// "):]) is not None:
+                    return True
+        return False
+
+    for line in lines:
+        if hasTag(line):
+            numCommentLines += 1
+            yield n - numCommentLines, line
+        else:
+            numCommentLines = 0
+
+        n += 1
+
+
+def prepend_comments(sequence):
+    """
+    Prepends a comment indicator to each element
+    """
+    result = ""
+    for line in sequence.splitlines(True):
+        result = result + "// " + line
+    return result
+
+
+# {{{ JsonRpcProcess
+class BadHeader(Exception):
+    def __init__(self, msg: str):
+        super().__init__("Bad header: " + msg)
+
+class JsonRpcProcess:
+    exe_path: str
+    exe_args: List[str]
+    process: subprocess.Popen
+    trace_io: bool
+    print_pid: bool
+
+    def __init__(self, exe_path: str, exe_args: List[str], trace_io: bool = True, print_pid = False):
+        self.exe_path = exe_path
+        self.exe_args = exe_args
+        self.trace_io = trace_io
+        self.print_pid = print_pid
+
+    def __enter__(self):
+        self.process = subprocess.Popen(
+            [self.exe_path, *self.exe_args],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+
+        if self.print_pid:
+            print(f"solc pid: {self.process.pid}. Attach with sudo gdb -p {self.process.pid}")
+
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback) -> None:
+        self.process.kill()
+        self.process.wait(timeout=2.0)
+
+    def trace(self, topic: str, message: str) -> None:
+        if self.trace_io:
+            print(f"{SGR_TRACE}{topic}:{SGR_RESET} {message}")
+
+    def receive_message(self) -> Union[None, dict]:
+        # Note, we should make use of timeout to avoid infinite blocking if nothing is received.
+        CONTENT_LENGTH_HEADER = "Content-Length: "
+        CONTENT_TYPE_HEADER = "Content-Type: "
+        if self.process.stdout is None:
+            return None
+        message_size = None
+        while True:
+            # read header
+            line = self.process.stdout.readline()
+            if len(line) == 0:
+                # server quit
+                return None
+            line = line.decode("utf-8")
+            if self.trace_io:
+                print(f"Received header-line: {escape_string(line)}")
+            if not line.endswith("\r\n"):
+                raise BadHeader("missing newline")
+            # Safely remove the "\r\n".
+            line = line.rstrip("\r\n")
+            if line == '':
+                break # done with the headers
+            if line.startswith(CONTENT_LENGTH_HEADER):
+                line = line[len(CONTENT_LENGTH_HEADER):]
+                if not line.isdigit():
+                    raise BadHeader("size is not int")
+                message_size = int(line)
+            elif line.startswith(CONTENT_TYPE_HEADER):
+                # nothing todo with type for now.
+                pass
+            else:
+                raise BadHeader("unknown header")
+        if message_size is None:
+            raise BadHeader("missing size")
+        rpc_message = self.process.stdout.read(message_size).decode("utf-8")
+        json_object = json.loads(rpc_message)
+        self.trace('receive_message', json.dumps(json_object, indent=4, sort_keys=True))
+        return json_object
+
+    def send_message(self, method_name: str, params: Optional[dict]) -> None:
+        if self.process.stdin is None:
+            return
+        message = {
+            'jsonrpc': '2.0',
+            'method': method_name,
+            'params': params
+        }
+        json_string = json.dumps(obj=message)
+        rpc_message = f"Content-Length: {len(json_string)}\r\n\r\n{json_string}"
+        self.trace(f'send_message ({method_name})', json.dumps(message, indent=4, sort_keys=True))
+        self.process.stdin.write(rpc_message.encode("utf-8"))
+        self.process.stdin.flush()
+
+    def call_method(self, method_name: str, params: Optional[dict], expects_response: bool = True) -> Any:
+        self.send_message(method_name, params)
+        if not expects_response:
+            return None
+        return self.receive_message()
+
+    def send_notification(self, name: str, params: Optional[dict] = None) -> None:
+        self.send_message(name, params)
+
+# }}}
+
+SGR_RESET = '\033[m'
+SGR_TRACE = '\033[1;36m'
+SGR_NOTICE = '\033[1;35m'
+SGR_TEST_BEGIN = '\033[1;33m'
+SGR_ASSERT_BEGIN = '\033[1;34m'
+SGR_STATUS_OKAY = '\033[1;32m'
+SGR_STATUS_FAIL = '\033[1;31m'
+
+class ExpectationFailed(Exception):
+    class Part(Enum):
+        Diagnostics = auto()
+        Methods = auto()
+
+    def __init__(self, reason: str, part):
+        self.part = part
+        super().__init__(reason)
+
+class JSONExpectationFailed(ExpectationFailed):
+    def __init__(self, actual, expected, part):
+        self.actual = actual
+        self.expected = expected
+
+        expected_pretty = ""
+
+        if expected is not None:
+            expected_pretty = json.dumps(expected, sort_keys=True)
+
+        diff = DeepDiff(actual, expected)
+
+        super().__init__(
+            f"\n\tExpected {expected_pretty}" + \
+            f"\n\tbut got {json.dumps(actual, sort_keys=True)}.\n\t{diff}",
+            part
+        )
+
+
+def create_cli_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Solidity LSP Test suite")
+    parser.set_defaults(fail_fast=False)
+    parser.add_argument(
+        "-f", "--fail-fast",
+        dest="fail_fast",
+        action="store_true",
+        help="Terminates the running tests on first failure."
+    )
+    parser.set_defaults(non_interactive=False)
+    parser.add_argument(
+        "-n", "--non-interactive",
+        dest="non_interactive",
+        action="store_true",
+        help="Prevent interactive queries and just fail instead."
+    )
+    parser.set_defaults(print_solc_pid=False)
+    parser.add_argument(
+        "-p", "--print-solc-pid",
+        dest="print_solc_pid",
+        action="store_true",
+        help="Print pid of each started solc for debugging purposes."
+    )
+    parser.set_defaults(trace_io=False)
+    parser.add_argument(
+        "-T", "--trace-io",
+        dest="trace_io",
+        action="store_true",
+        help="Be more verbose by also printing assertions."
+    )
+    parser.set_defaults(print_assertions=False)
+    parser.add_argument(
+        "-v", "--print-assertions",
+        dest="print_assertions",
+        action="store_true",
+        help="Be more verbose by also printing assertions."
+    )
+    parser.add_argument(
+        "-t", "--test-pattern",
+        dest="test_pattern",
+        type=str,
+        default="*",
+        help="Filters all available tests by matching against this test pattern (using globbing)",
+        nargs="?"
+    )
+    parser.add_argument(
+        "solc_path",
+        type=str,
+        default="solc",
+        help="Path to solc binary to test against",
+        nargs="?"
+    )
+    parser.add_argument(
+        "project_root_dir",
+        type=str,
+        default=f"{os.path.dirname(os.path.realpath(__file__))}/..",
+        help="Path to Solidity project's root directory (must be fully qualified).",
+        nargs="?"
+    )
+    return parser
+
+class Counter:
+    total: int = 0
+    passed: int = 0
+    failed: int = 0
+
+
+# Returns the given marker with the end extended by 'amount'
+def extendEnd(marker, amount=1):
+    newMarker = deepcopy(marker)
+    newMarker["end"]["character"] += amount
+    return newMarker
+
+class TestParserException(Exception):
+    def __init__(self, incompleteResult, msg: str):
+        self.result = incompleteResult
+        super().__init__("Failed to parse test specification: " + msg)
+
+class TestParser:
+    """
+    Parses test specifications.
+    Usage example:
+
+    parsed_testcases = TestParser(content).parse()
+
+    # First diagnostics are yielded.
+    # Type is "TestParser.Diagnostics"
+    expected_diagnostics = next(parsed_testcases)
+
+    ...
+    # Now each request/response pair in the test definition
+    # Type is "TestParser.RequestAndResponse"
+    for testcase in self.parsed_testcases:
+        ...
+    """
+    RequestAndResponse = namedtuple('RequestAndResponse',
+        "method, request, response, responseBegin, responseEnd",
+        defaults=(None, None, None, None)
+    )
+    Diagnostics = namedtuple('Diagnostics', 'tests start end has_header')
+    Diagnostic = namedtuple('Diagnostic', 'marker code')
+
+    TEST_START = "// ----"
+
+    def __init__(self, content: str):
+        self.content = content
+        self.lines = None
+        self.current_line_tuple = None
+
+    def parse(self):
+        """
+        Starts parsing the test specifications.
+        Will first yield with the diagnostics expectations as type 'Diagnostics'.
+        After that, it will yield once for every Request/Response pair found in
+        the file, each time as type 'RequestAndResponse'.
+
+        """
+        testDefStartIdx = self.content.rfind(f"\n{self.TEST_START}\n")
+
+        if testDefStartIdx == -1:
+            # Set start/end to end of file if there is no test section
+            yield self.Diagnostics({}, len(self.content), len(self.content), False)
+            return
+
+        self.lines = islice(
+            count_index(self.content[testDefStartIdx+1:].splitlines(), testDefStartIdx+1),
+            1,
+            None
+        )
+        self.next_line()
+
+        yield self.parseDiagnostics()
+
+        while not self.at_end():
+            yield self.parseRequestAndResponse()
+            self.next_line()
+
+
+    def parseDiagnostics(self) -> TestParser.Diagnostics:
+        """
+        Parse diagnostic expectations specified in the file.
+        Returns a named tuple instance of "Diagnostics"
+        """
+        diagnostics = { "tests": {}, "has_header": True }
+
+        diagnostics["start"] = self.position()
+
+        while not self.at_end():
+            fileDiagMatch = TEST_REGEXES.fileDiagnostics.match(self.current_line())
+            if fileDiagMatch is None:
+                break
+
+            testDiagnostics = []
+
+            diagnostics_string = fileDiagMatch.group("diagnostics")
+            if diagnostics_string is not None:
+                for diagnosticMatch in TEST_REGEXES.diagnostic.finditer(diagnostics_string):
+                    testDiagnostics.append(self.Diagnostic(
+                        diagnosticMatch.group("tag"),
+                        int(diagnosticMatch.group("code"))
+                    ))
+
+            diagnostics["tests"][fileDiagMatch.group("testname")] = testDiagnostics
+
+            self.next_line()
+
+        diagnostics["end"] = self.position()
+        return self.Diagnostics(**diagnostics)
+
+
+    def parseRequestAndResponse(self) -> TestParser.RequestAndResponse:
+        RESPONSE_START = "// <- "
+        REQUEST_END = "// }"
+        COMMENT_PREFIX = "// "
+
+        ret = {}
+        start_character = None
+
+        # Parse request header
+        requestResult = TEST_REGEXES.sendRequest.match(self.current_line())
+        if requestResult is None:
+            raise TestParserException(ret, "Method for request not found on line " + self.current_line())
+
+        ret["method"] = requestResult.group("method")
+        ret["request"] = "{\n"
+
+        self.next_line()
+
+        # Search for request block end
+        while not self.at_end():
+            line = self.current_line()
+            ret["request"] += line[len(COMMENT_PREFIX):] + "\n"
+
+            self.next_line()
+
+            if line.startswith(REQUEST_END):
+                break
+
+            # Reached end without finding request_end. Abort.
+            if self.at_end():
+                raise TestParserException(ret, "Request body not found")
+
+        if self.at_end():
+            return self.RequestAndResponse(**ret)
+
+        # Parse response header
+        if self.current_line().startswith(RESPONSE_START):
+            start_character = self.current_line()[len(RESPONSE_START)]
+            if start_character not in ("{", "["):
+                raise TestParserException(ret, "Response header malformed")
+            ret["response"] = self.current_line()[len(RESPONSE_START):] + "\n"
+            ret["responseBegin"] = self.position()
+
+        self.next_line()
+
+        end_character = "}" if start_character == "{" else "]"
+
+        # Search for request block end
+        while not self.at_end():
+            ret["response"] += self.current_line()[len(COMMENT_PREFIX):] + "\n"
+
+            if self.current_line().startswith(f"// {end_character}"):
+                ret["responseEnd"] = self.position() + len(self.current_line())
+                break
+
+            self.next_line()
+
+            # Reached end without finding block_end. Abort.
+            if self.at_end():
+                raise TestParserException(ret, "Response footer not found")
+
+        return self.RequestAndResponse(**ret)
+
+    def next_line(self):
+        self.current_line_tuple = next(self.lines, None)
+
+    def current_line(self):
+        return self.current_line_tuple[1]
+
+    def position(self):
+        """
+        Returns current byte position
+        """
+        if self.current_line_tuple is None:
+            return len(self.content)
+        return self.current_line_tuple[0]
+
+    def at_end(self):
+        """
+        Returns True if we exhausted the lines
+        """
+        return self.current_line_tuple is None
+
+class FileLoadStrategy(Enum):
+    Undefined = None
+    ProjectDirectory = 'project-directory'
+    DirectlyOpenedAndOnImport =  'directly-opened-and-on-import'
+
+class FileTestRunner:
+    """
+    Runs all tests in a given file.
+    It is required to call test_diagnostics() before calling test_methods().
+
+    When a test fails, asks the user how to proceed.
+    Offers automatic test expectation updates and rerunning of the tests.
+    """
+
+    class TestResult(Enum):
+        SuccessOrIgnored = auto()
+        Reparse = auto()
+
+    def __init__(self, test_name, sub_dir, solc, suite):
+        self.test_name = test_name
+        self.sub_dir = sub_dir
+        self.suite = suite
+        self.solc = solc
+        self.open_tests = []
+        self.content = self.suite.get_test_file_contents(self.test_name, self.sub_dir)
+        self.markers = self.suite.get_test_tags(self.test_name, self.sub_dir)
+        self.parsed_testcases = None
+        self.expected_diagnostics = None
+
+    def test_diagnostics(self):
+        """
+        Test that the expected diagnostics match the actual diagnostics
+        """
+        try:
+            self.parsed_testcases = TestParser(self.content).parse()
+
+            # Process diagnostics first
+            self.expected_diagnostics = next(self.parsed_testcases)
+            assert isinstance(self.expected_diagnostics, TestParser.Diagnostics)
+            if not self.expected_diagnostics.has_header:
+                return
+
+            expected_diagnostics_per_file = self.expected_diagnostics.tests
+
+            # Add our own test diagnostics if they didn't exist
+            if self.test_name not in expected_diagnostics_per_file:
+                expected_diagnostics_per_file[self.test_name] = []
+
+            published_diagnostics = \
+                self.suite.open_file_and_wait_for_diagnostics(self.solc, self.test_name, self.sub_dir)
+
+            for diagnostics in published_diagnostics:
+                if not diagnostics["uri"].startswith(self.suite.project_root_uri + "/"):
+                    raise RuntimeError(
+                        f"'{self.test_name}.sol' imported file outside of test directory: '{diagnostics['uri']}'"
+                    )
+                self.open_tests.append(self.suite.normalizeUri(diagnostics["uri"]))
+
+            self.suite.expect_equal(
+                len(published_diagnostics),
+                len(expected_diagnostics_per_file),
+                description="Amount of reports does not match!")
+
+            for diagnostics_per_file in published_diagnostics:
+                testname, sub_dir = split_path(self.suite.normalizeUri(diagnostics_per_file['uri']))
+
+                # Clear all processed expectations so we can check at the end
+                # what's missing
+                expected_diagnostics = expected_diagnostics_per_file.pop(testname, {})
+
+                self.suite.expect_equal(
+                    len(diagnostics_per_file["diagnostics"]),
+                    len(expected_diagnostics),
+                    description="Unexpected amount of diagnostics"
+                )
+                markers = self.suite.get_test_tags(testname, sub_dir)
+                for actual_diagnostic in diagnostics_per_file["diagnostics"]:
+                    expected_diagnostic = next((diagnostic for diagnostic in
+                        expected_diagnostics if actual_diagnostic['range'] ==
+                        markers[diagnostic.marker]), None)
+
+                    if expected_diagnostic is None:
+                        raise ExpectationFailed(
+                            f"Unexpected diagnostic: {json.dumps(actual_diagnostic, indent=4, sort_keys=True)}",
+                            ExpectationFailed.Part.Diagnostics
+                        )
+
+                    self.suite.expect_diagnostic(
+                        actual_diagnostic,
+                        code=expected_diagnostic.code,
+                        marker=markers[expected_diagnostic.marker]
+                    )
+
+            if len(expected_diagnostics_per_file) > 0:
+                raise ExpectationFailed(
+                    f"Expected diagnostics but received none for {expected_diagnostics_per_file}",
+                    ExpectationFailed.Part.Diagnostics
+                )
+
+        except Exception:
+            self.close_all_open_files()
+            raise
+
+    def close_all_open_files(self):
+        for testpath in self.open_tests:
+            test, sub_dir = split_path(testpath)
+
+            self.solc.send_message(
+                'textDocument/didClose',
+                { 'textDocument': { 'uri': self.suite.get_test_file_uri(test, sub_dir) }}
+            )
+            self.suite.wait_for_diagnostics(self.solc)
+
+        self.open_tests.clear()
+
+    def test_methods(self) -> bool:
+        """
+        Test all methods. Returns False if a reparsing is required, else True
+        """
+        try:
+            # Now handle each request/response pair in the test definition
+            for testcase in self.parsed_testcases:
+                try:
+                    self.run_testcase(testcase)
+                except JSONExpectationFailed as e:
+                    result = self.user_interaction_failed_method_test(testcase, e.actual, e.expected)
+
+                    if result == self.TestResult.Reparse:
+                        return False
+
+            return True
+        except TestParserException as e:
+            print(e)
+            print(e.result)
+            raise
+        finally:
+            self.close_all_open_files()
+
+    def user_interaction_failed_method_test(
+        self,
+        testcase: TestParser.RequestAndResponse,
+        actual,
+        expected
+    ) -> TestResult:
+
+        actual_pretty = self.suite.replace_ranges_with_tags(actual, self.sub_dir)
+
+        if expected is None:
+            print("Failed to parse expected response, received:\n" + actual)
+        else:
+            print("Expected:\n" + \
+                self.suite.replace_ranges_with_tags(expected, self.sub_dir) + \
+                "\nbut got:\n" + actual_pretty
+            )
+
+        if self.suite.non_interactive:
+            return self.TestResult.SuccessOrIgnored
+
+        while True:
+            print("(u)pdate/(r)etry/(i)gnore?")
+            user_response = getCharFromStdin()
+            if user_response == "i":
+                return self.TestResult.SuccessOrIgnored
+
+            if user_response == "u":
+                actual = actual["result"]
+                self.content = self.content[:testcase.responseBegin] + \
+                    prepend_comments(
+                        "<- " + \
+                        self.suite.replace_ranges_with_tags(actual, self.sub_dir)) + \
+                    self.content[testcase.responseEnd:]
+
+                with open(self.suite.get_test_file_path(\
+                    self.test_name, self.sub_dir), \
+                    mode="w", \
+                    encoding="utf-8", \
+                    newline='') as f:
+                    f.write(self.content)
+                return self.TestResult.Reparse
+            if user_response == "r":
+                return self.TestResult.Reparse
+
+            print("Invalid response.")
+
+
+    def run_testcase(self, testcase: TestParser.RequestAndResponse):
+        """
+        Runs the given testcase.
+        """
+
+        requestBodyJson = self.parse_json_with_tags(testcase.request, self.markers)
+        # add textDocument/uri if missing
+        if 'textDocument' not in requestBodyJson:
+            requestBodyJson['textDocument'] = { 'uri': self.suite.get_test_file_uri(self.test_name, self.sub_dir) }
+
+        actualResponseJson = self.solc.call_method(
+            testcase.method,
+            requestBodyJson,
+            expects_response=testcase.response is not None
+        )
+
+        if testcase.response is None:
+            return
+
+        # simplify response
+        if "result" in actualResponseJson:
+            if isinstance(actualResponseJson["result"], list):
+                for result in actualResponseJson["result"]:
+                    if "uri" in result:
+                        result["uri"] = result["uri"].replace(self.suite.project_root_uri + "/" + self.sub_dir + "/", "")
+
+            elif isinstance(actualResponseJson["result"], dict):
+                if "changes" in actualResponseJson["result"]:
+                    changes = actualResponseJson["result"]["changes"]
+                    for key in list(changes.keys()):
+                        new_key = key.replace(self.suite.project_root_uri + "/", "")
+                        changes[new_key] = changes[key]
+                        del changes[key]
+
+        if "jsonrpc" in actualResponseJson:
+            actualResponseJson.pop("jsonrpc")
+
+        try:
+            expectedResponseJson = self.parse_json_with_tags(testcase.response, self.markers)
+        except json.decoder.JSONDecodeError:
+            expectedResponseJson = None
+
+        expectedResponseJson = { "result": expectedResponseJson }
+
+        self.suite.expect_equal(
+            actualResponseJson,
+            expectedResponseJson,
+            f"Request failed: \n{testcase.request}",
+            ExpectationFailed.Part.Methods
+        )
+
+
+    def parse_json_with_tags(self, content, markersFallback):
+        """
+        Replaces any tags with their actual content and parsers the result as
+        json to return it.
+        """
+        split_by_tag = TEST_REGEXES.findTag.split(content)
+
+        # add quotes so we can parse it as json
+        contentReplaced = '"'.join(split_by_tag)
+        contentJson = json.loads(contentReplaced)
+
+        def replace_tag(data, markers):
+
+            if isinstance(data, list):
+                for el in data:
+                    replace_tag(el, markers)
+                return data
+
+            if not isinstance(data, dict):
+                return data
+
+            def findMarker(desired_tag):
+                if not isinstance(desired_tag, str):
+                    return desired_tag
+
+                for tag, tagRange in markers.items():
+                    if tag == desired_tag:
+                        return tagRange
+                    elif tag.lower() == desired_tag.lower():
+                        raise RuntimeError(f"Detected lower/upper case mismatch: Requested {desired_tag} but only found {tag}")
+
+                raise RuntimeError(f"Marker {desired_tag} not found in file")
+
+
+            # Check if we need markers from a specific file
+            # Needs to be done before the loop or it might be called only after
+            # we found "range" or "position"
+            if "uri" in data:
+                markers = self.suite.get_test_tags(data["uri"][:-len(".sol")], self.sub_dir)
+
+            for key, val in data.items():
+                if key == "range":
+                    data[key] = findMarker(val)
+                elif key == "position":
+                    tag_range = findMarker(val)
+                    if "start" in tag_range:
+                        data[key] = tag_range["start"]
+                elif key == "changes":
+                    for path, list_of_changes in val.items():
+                        test_name, file_sub_dir = split_path(path)
+                        markers = self.suite.get_test_tags(test_name[:-len(".sol")], file_sub_dir)
+                        for change in list_of_changes:
+                            if "range" in change:
+                                change["range"] = findMarker(change["range"])
+                elif isinstance(val, dict):
+                    replace_tag(val, markers)
+                elif isinstance(val, list):
+                    for el in val:
+                        replace_tag(el, markers)
+            return data
+
+        return replace_tag(contentJson, markersFallback)
+
+
+class SolidityLSPTestSuite: # {{{
+    test_counter = Counter()
+    assertion_counter = Counter()
+    print_assertions: bool = False
+    trace_io: bool = False
+    fail_fast: bool = False
+    test_pattern: str
+
+    def __init__(self):
+        colorama.init()
+        args = create_cli_parser().parse_args()
+        self.solc_path = args.solc_path
+        self.project_root_dir = os.path.realpath(args.project_root_dir) + "/test/libsolidity/lsp"
+        self.project_root_uri = PurePath(self.project_root_dir).as_uri()
+        self.print_assertions = args.print_assertions
+        self.trace_io = args.trace_io
+        self.test_pattern = args.test_pattern
+        self.fail_fast = args.fail_fast
+        self.non_interactive = args.non_interactive
+        self.print_solc_pid = args.print_solc_pid
+
+        print(f"{SGR_NOTICE}test pattern: {self.test_pattern}{SGR_RESET}")
+
+    def main(self) -> int:
+        """
+        Runs all test cases.
+        Returns 0 on success and the number of failing assertions (capped to 127) otherwise.
+        """
+        all_tests = sorted([
+            str(name)[5:]
+            for name in dir(SolidityLSPTestSuite)
+            if callable(getattr(SolidityLSPTestSuite, name)) and name.startswith("test_")
+        ])
+        filtered_tests = fnmatch.filter(all_tests, self.test_pattern)
+        if filtered_tests.count("generic") == 0:
+            filtered_tests.append("generic")
+
+        for method_name in filtered_tests:
+            test_fn = getattr(self, 'test_' + method_name)
+            title: str = test_fn.__name__[5:]
+            print(f"{SGR_TEST_BEGIN}Testing {title} ...{SGR_RESET}")
+            try:
+                with JsonRpcProcess(self.solc_path, ["--lsp"], trace_io=self.trace_io, print_pid=self.print_solc_pid) as solc:
+                    test_fn(solc)
+                    self.test_counter.passed += 1
+            except ExpectationFailed:
+                self.test_counter.failed += 1
+                print(traceback.format_exc())
+                if self.fail_fast:
+                    break
+            except Exception as e: # pragma pylint: disable=broad-except
+                self.test_counter.failed += 1
+                print(f"Unhandled exception {e.__class__.__name__} caught: {e}")
+                print(traceback.format_exc())
+                if self.fail_fast:
+                    break
+
+        print(
+            f"\n{SGR_NOTICE}Summary:{SGR_RESET}\n\n"
+            f"  Test cases: {self.test_counter.passed} passed, {self.test_counter.failed} failed\n"
+            f"  Assertions: {self.assertion_counter.passed} passed, {self.assertion_counter.failed} failed\n"
+        )
+
+        return min(max(self.test_counter.failed, self.assertion_counter.failed), 127)
+
+    def setup_lsp(
+        self,
+        lsp: JsonRpcProcess,
+        expose_project_root=True,
+        file_load_strategy: FileLoadStrategy=FileLoadStrategy.DirectlyOpenedAndOnImport,
+        custom_include_paths: list[str] = None,
+        project_root_subdir=None
+    ):
+        """
+        Prepares the solc LSP server by calling `initialize`,
+        and `initialized` methods.
+        """
+        project_root_uri_with_maybe_subdir = self.project_root_uri
+        if project_root_subdir is not None:
+            project_root_uri_with_maybe_subdir = self.project_root_uri + '/' + project_root_subdir
+        params = {
+            'processId': None,
+            'rootUri': project_root_uri_with_maybe_subdir,
+            # Enable traces to receive the amount of expected diagnostics before
+            # actually receiving them.
+            'trace': 'messages',
+            'capabilities': {
+                'textDocument': {
+                    'publishDiagnostics': {'relatedInformation': True}
+                },
+                'workspace': {
+                    'applyEdit': True,
+                    'configuration': True,
+                    'didChangeConfiguration': {'dynamicRegistration': True},
+                    'workspaceEdit': {'documentChanges': True},
+                    'workspaceFolders': True
+                }
+            }
+        }
+
+        if file_load_strategy != FileLoadStrategy.Undefined:
+            params['initializationOptions'] = {}
+            params['initializationOptions']['file-load-strategy'] = file_load_strategy.value
+
+        if custom_include_paths is not None and len(custom_include_paths) != 0:
+            if params['initializationOptions'] is None:
+                params['initializationOptions'] = {}
+            params['initializationOptions']['include-paths'] = custom_include_paths
+
+        if not expose_project_root:
+            params['rootUri'] = None
+
+        lsp.call_method('initialize', params)
+        lsp.send_notification('initialized')
+
+    # {{{ helpers
+    def get_test_file_path(self, test_case_name, sub_dir=None):
+        if sub_dir:
+            return f"{self.project_root_dir}/{sub_dir}/{test_case_name}.sol"
+        return f"{self.project_root_dir}/{test_case_name}.sol"
+
+    def get_test_file_uri(self, test_case_name, sub_dir=None):
+        return PurePath(self.get_test_file_path(test_case_name, sub_dir)).as_uri()
+
+    def get_test_file_contents(self, test_case_name, sub_dir=None):
+        """
+        Reads the file contents from disc for a given test case.
+        The `test_case_name` will be the basename of the file
+        in the test path (test/libsolidity/lsp/{sub_dir}).
+        """
+        with open(self.get_test_file_path(test_case_name, sub_dir), mode="r", encoding="utf-8", newline='') as f:
+            return f.read().replace("\r\n", "\n")
+
+    def require_params_for_method(self, method_name: str, message: dict) -> Any:
+        """
+        Ensures the given RPC message does contain the
+        field 'method' with the given method name,
+        and then returns its passed params.
+        An exception is raised on expectation failures.
+        """
+        assert message is not None
+        if 'error' in message.keys():
+            code = message['error']["code"]
+            text = message['error']['message']
+            raise RuntimeError(f"Error {code} received. {text}")
+        if 'method' not in message.keys():
+            raise RuntimeError("No method received but something else.")
+        self.expect_equal(message['method'], method_name, description="Ensure expected method name")
+        return message['params']
+
+    def wait_for_diagnostics(self, solc: JsonRpcProcess) -> List[dict]:
+        """
+        Return all published diagnostic reports sorted by file URI.
+        """
+        reports = []
+
+        num_files = solc.receive_message()["params"]["openFileCount"]
+
+        for _ in range(0, num_files):
+            message = solc.receive_message()
+
+            assert message is not None # This can happen if the server aborts early.
+
+            reports.append(
+                self.require_params_for_method(
+                    'textDocument/publishDiagnostics',
+                    message,
+                )
+            )
+
+        return sorted(reports, key=lambda x: x['uri'])
+
+    def normalizeUri(self, uri):
+        return uri.replace(self.project_root_uri + "/", "")[:-len(".sol")]
+
+    def fetch_and_format_diagnostics(self, solc: JsonRpcProcess, test, sub_dir=None):
+        expectations = ""
+
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, test, sub_dir)
+
+        for file_diagnostics in published_diagnostics:
+            testname, local_sub_dir = split_path(self.normalizeUri(file_diagnostics["uri"]))
+
+            # Skip empty diagnostics within the same file
+            if len(file_diagnostics["diagnostics"]) == 0 and testname == test:
+                continue
+
+            expectations += f"// {testname}:"
+
+            for diagnostic in file_diagnostics["diagnostics"]:
+                tag = self.find_tag_with_range(testname, local_sub_dir, diagnostic['range'])
+
+                if tag is None:
+                    raise RuntimeError(f"No tag found for diagnostic range {diagnostic['range']}")
+
+                expectations += f" {tag} {diagnostic['code']}"
+            expectations += "\n"
+
+        return expectations
+
+    def update_diagnostics_in_file(
+        self,
+        solc: JsonRpcProcess,
+        test,
+        sub_dir,
+        content,
+        current_diagnostics: TestParser.Diagnostics
+    ):
+        test_header = ""
+
+        if not current_diagnostics.has_header:
+            test_header = f"{TestParser.TEST_START}\n"
+
+        content = content[:current_diagnostics.start] + \
+            test_header + \
+            self.fetch_and_format_diagnostics(solc, test, sub_dir) + \
+            content[current_diagnostics.end:]
+
+        with open(self.get_test_file_path(test, sub_dir), mode="w", encoding="utf-8", newline='') as f:
+            f.write(content)
+
+        return content
+
+    def open_file_and_wait_for_diagnostics(
+        self,
+        solc_process: JsonRpcProcess,
+        test_case_name: str,
+        sub_dir=None
+    ) -> List[Any]:
+        """
+        Opens file for given test case and waits for diagnostics to be published.
+        """
+        solc_process.send_message(
+            'textDocument/didOpen',
+            {
+                'textDocument':
+                {
+                    'uri': self.get_test_file_uri(test_case_name, sub_dir),
+                    'languageId': 'Solidity',
+                    'version': 1,
+                    'text': self.get_test_file_contents(test_case_name, sub_dir)
+                }
+            }
+        )
+        return self.wait_for_diagnostics(solc_process)
+
+    def expect_true(
+        self,
+        actual,
+        description="Expected True value",
+        part=ExpectationFailed.Part.Diagnostics
+    ) -> None:
+        self.expect_equal(actual, True, description, part)
+
+    def expect_equal(
+        self,
+        actual,
+        expected,
+        description="Equality",
+        part=ExpectationFailed.Part.Diagnostics
+    ) -> None:
+        self.assertion_counter.total += 1
+        prefix = f"[{self.assertion_counter.total}] {SGR_ASSERT_BEGIN}{description}: "
+        diff = DeepDiff(actual, expected)
+        if len(diff) == 0:
+            self.assertion_counter.passed += 1
+            if self.print_assertions:
+                print(prefix + SGR_STATUS_OKAY + 'OK' + SGR_RESET)
+            return
+
+        # Failed assertions are always printed.
+        self.assertion_counter.failed += 1
+        print(prefix + SGR_STATUS_FAIL + 'FAILED' + SGR_RESET)
+        raise JSONExpectationFailed(actual, expected, part)
+
+    def expect_empty_diagnostics(self, published_diagnostics: List[dict]) -> None:
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        self.expect_equal(len(published_diagnostics[0]['diagnostics']), 0, "should not contain diagnostics")
+
+    def expect_diagnostic(
+        self,
+        diagnostic,
+        code: int,
+        lineNo: int = None,
+        startEndColumns: Tuple[int, int] = None,
+        marker: {} = None
+    ):
+        self.expect_equal(
+            diagnostic['code'],
+            code,
+            ExpectationFailed.Part.Diagnostics,
+            f'diagnostic: {code}'
+        )
+
+        if marker:
+            self.expect_equal(
+                diagnostic['range'],
+                marker,
+                ExpectationFailed.Part.Diagnostics,
+                "diagnostic: check range"
+            )
+
+        else:
+            assert len(startEndColumns) == 2
+            [startColumn, endColumn] = startEndColumns
+            self.expect_equal(
+                diagnostic['range'],
+                {
+                    'start': {'character': startColumn, 'line': lineNo},
+                    'end': {'character': endColumn, 'line': lineNo}
+                },
+                ExpectationFailed.Part.Diagnostics,
+                "diagnostic: check range"
+            )
+
+
+    def expect_location(
+        self,
+        obj: dict,
+        uri: str,
+        lineNo: int,
+        startEndColumns: Tuple[int, int]
+    ):
+        """
+        obj is an JSON object containing two keys:
+            - 'uri': a string of the document URI
+            - 'range': the location range, two child objects 'start' and 'end',
+                        each having a 'line' and 'character' integer value.
+        """
+        [startColumn, endColumn] = startEndColumns
+        self.expect_equal(obj['uri'], uri)
+        self.expect_equal(obj['range']['start']['line'], lineNo)
+        self.expect_equal(obj['range']['start']['character'], startColumn)
+        self.expect_equal(obj['range']['end']['line'], lineNo)
+        self.expect_equal(obj['range']['end']['character'], endColumn)
+
+    def expect_goto_definition_location(
+        self,
+        solc: JsonRpcProcess,
+        document_uri: str,
+        document_position: Tuple[int, int],
+        expected_uri: str,
+        expected_lineNo: int,
+        expected_startEndColumns: Tuple[int, int],
+        description: str
+    ):
+        response = solc.call_method(
+            'textDocument/definition',
+            {
+                'textDocument': {
+                    'uri': document_uri,
+                },
+                'position': {
+                    'line': document_position[0],
+                    'character': document_position[1]
+                }
+            }
+        )
+        message = "Goto definition (" + description + ")"
+        self.expect_equal(len(response['result']), 1, message)
+        self.expect_location(response['result'][0], expected_uri, expected_lineNo, expected_startEndColumns)
+
+
+    def find_tag_with_range(self, test, sub_dir, target_range):
+        """
+        Find and return the tag that represents the requested range otherwise
+        return None.
+        """
+        markers = self.get_test_tags(test, sub_dir)
+
+        for tag, tag_range in markers.items():
+            if tag_range == target_range:
+                return str(tag)
+
+        return None
+
+    def replace_ranges_with_tags(self, content, sub_dir):
+        """
+        Replace matching ranges with "@<tagname>".
+
+        Recognized patterns:
+            { "changes": { "<uri>": { "range": "<range>" } } }
+            { "uri": "<uri>", "range": "<range> }
+
+        """
+
+        def replace_range(item: dict, markers):
+            for tag, tagRange in markers.items():
+                if "range" in item and tagRange == item["range"]:
+                    item["range"] = str(tag)
+
+        def recursive_iter(obj):
+            if isinstance(obj, dict):
+                yield obj
+                for item in obj.values():
+                    yield from recursive_iter(item)
+            elif any(isinstance(obj, t) for t in (list, tuple)):
+                for item in obj:
+                    yield from recursive_iter(item)
+
+        for item in recursive_iter(content):
+            if "uri" in item and "range" in item:
+                try:
+                    markers = self.get_test_tags(item["uri"][:-len(".sol")], sub_dir)
+                    replace_range(item, markers)
+                except FileNotFoundError:
+                    # Skip over errors as this is user provided input that can
+                    # point to non-existing files
+                    pass
+            elif "changes" in item:
+                for file, changes_for_file in item["changes"].items():
+                    test_name, file_sub_dir = split_path(file)
+                    try:
+                        markers = self.get_test_tags(test_name[:-len(".sol")], file_sub_dir)
+                        for change in changes_for_file:
+                            replace_range(change, markers)
+
+                    except FileNotFoundError:
+                        # Skip over errors as this is user provided input that can
+                        # point to non-existing files
+                        pass
+
+
+
+        # Convert JSON to string and split it at the quoted tags
+        split_by_tag = TEST_REGEXES.findQuotedTag.split(json.dumps(content, indent=4, sort_keys=True))
+
+        # remove the quotes and return result
+        return "".join(map(lambda p: p[1:-1] if p.startswith('"@') else p, split_by_tag))
+
+    def user_interaction_failed_diagnostics(
+        self,
+        solc: JsonRpcProcess,
+        test,
+        sub_dir,
+        content,
+        current_diagnostics: TestParser.Diagnostics
+    ):
+        """
+        Asks the user how to proceed after an error.
+        Returns True if the test/file should be ignored, otherwise False
+        """
+
+        # Prevent user interaction when in non-interactive mode
+        if self.non_interactive:
+            return False
+
+        while True:
+            print("(u)pdate/(r)etry/(s)kip file?")
+            user_response = getCharFromStdin()
+            if user_response == "u":
+                while True:
+                    try:
+                        self.update_diagnostics_in_file(solc, test, sub_dir, content, current_diagnostics)
+                        return False
+                    # pragma pylint: disable=broad-except
+                    except Exception as e:
+                        print(e)
+                        if self.user_interaction_failed_autoupdate(test, sub_dir):
+                            return True
+            elif user_response == 's':
+                return True
+            elif user_response == 'r':
+                return False
+
+    def user_interaction_failed_autoupdate(self, test, sub_dir):
+        print("(e)dit/(r)etry/(s)kip file?")
+        user_response = getCharFromStdin()
+        if user_response == "r":
+            print("retrying...")
+            # pragma pylint: disable=no-member
+            self.get_test_tags.cache_clear()
+            return False
+        if user_response == "e":
+            editor = os.environ.get('VISUAL', os.environ.get('EDITOR', 'vi'))
+            subprocess.run(
+                f'{editor} {self.get_test_file_path(test, sub_dir)}',
+                shell=True,
+                check=True
+            )
+            # pragma pylint: disable=no-member
+            self.get_test_tags.cache_clear()
+        elif user_response == "s":
+            print("skipping...")
+
+        return True
+
+    # }}}
+
+    # {{{ actual tests
+    def test_analyze_all_project_files_flat(self, solc: JsonRpcProcess) -> None:
+        """
+        Tests the option (default) to analyze all .sol project files even when they have not been actively
+        opened yet. This is how other LSPs (at least for C++) work too and it makes cross-unit tasks
+        actually correct (e.g. symbolic rename, find all references, ...).
+
+        In this test, we simply open up a custom project and ensure we're receiving the diagnostics
+        for all existing files in that project (while having none of these files opened).
+        """
+        SUBDIR = 'analyze-full-project'
+        self.setup_lsp(
+            solc,
+            file_load_strategy=FileLoadStrategy.ProjectDirectory,
+            project_root_subdir=SUBDIR
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 3, "Diagnostic reports for 3 files")
+
+        # C.sol
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri('C', SUBDIR), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 0, "no diagnostics")
+
+        # D.sol
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], self.get_test_file_uri('D', SUBDIR), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 0, "no diagnostics")
+
+        # E.sol
+        report = published_diagnostics[2]
+        self.expect_equal(report['uri'], self.get_test_file_uri('E', SUBDIR), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 0, "no diagnostics")
+
+    def test_analyze_all_project_files_nested(self, solc: JsonRpcProcess) -> None:
+        """
+        Same as first test on that matter but with deeper nesting levels.
+        """
+        SUBDIR = 'include-paths-nested'
+        EXPECTED_FILES = {
+            "A/B/C/foo",
+            "A/B/foo",
+            "A/foo",
+            "foo",
+        }
+        EXPECTED_URIS = {self.get_test_file_uri(x, SUBDIR) for x in EXPECTED_FILES}
+        self.setup_lsp(
+            solc,
+            file_load_strategy=FileLoadStrategy.ProjectDirectory,
+            project_root_subdir=SUBDIR
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), len(EXPECTED_FILES), "Test number of files analyzed.")
+        self.expect_equal({report['uri'] for report in published_diagnostics}, EXPECTED_URIS)
+        self.expect_equal([len(report['diagnostics']) for report in published_diagnostics], [0] * len(EXPECTED_URIS))
+
+    def test_analyze_all_project_files_nested_with_include_paths(self, solc: JsonRpcProcess) -> None:
+        """
+        Same as first test on that matter but with deeper nesting levels.
+        """
+        SUBDIR = 'include-paths-nested-2'
+        EXPECTED_FILES = {
+            "A/B/C/foo",
+            "A/B/foo",
+            "A/foo",
+            "foo",
+        }
+        IMPLICITLY_LOADED_FILE_COUNT = 1
+        EXPECTED_URIS = {self.get_test_file_uri(x, SUBDIR) for x in EXPECTED_FILES}
+        self.setup_lsp(
+            solc,
+            file_load_strategy=FileLoadStrategy.ProjectDirectory,
+            project_root_subdir=SUBDIR,
+            custom_include_paths=[f"{self.project_root_dir}/other-include-dir"]
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(
+            len(published_diagnostics),
+            len(EXPECTED_FILES) + IMPLICITLY_LOADED_FILE_COUNT,
+            "Test number of files analyzed."
+        )
+
+        # All but the last report should be from expected files
+        for report in published_diagnostics[:-IMPLICITLY_LOADED_FILE_COUNT]:
+            self.expect_true(report['uri'] in EXPECTED_URIS, "Correct file URI")
+            self.expect_equal(len(report['diagnostics']), 0, "no diagnostics")
+
+        # Check last report (should be the custom imported lib).
+        # This file is analyzed because it was imported via "A/B/C/foo.sol".
+        last_report = published_diagnostics[len(EXPECTED_URIS)]
+        self.expect_equal(last_report['uri'], self.get_test_file_uri('second', 'other-include-dir/otherlib'), "Correct file URI")
+        self.expect_equal(len(last_report['diagnostics']), 0, "no diagnostics")
+
+
+    def test_publish_diagnostics_errors_multiline(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc)
+        TEST_NAME = 'publish_diagnostics_3'
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, TEST_NAME)
+
+        self.expect_equal(len(published_diagnostics), 1, "One published_diagnostics message")
+        report = published_diagnostics[0]
+
+        self.expect_equal(report['uri'], self.get_test_file_uri(TEST_NAME), "Correct file URI")
+        diagnostics = report['diagnostics']
+
+        self.expect_equal(len(diagnostics), 1, "1 diagnostic messages")
+        self.expect_equal(diagnostics[0]['code'], 3656, "diagnostic: check code")
+        self.expect_equal(
+            diagnostics[0]['range'],
+            {
+                'start': {'character': 0, 'line': 7},
+                'end': {'character': 1, 'line': 10}
+            },
+            "diagnostic: check range"
+        )
+
+    def test_textDocument_didOpen_with_relative_import(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc)
+        TEST_NAME = 'didOpen_with_import'
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, TEST_NAME)
+
+        self.expect_equal(len(published_diagnostics), 2, "Diagnostic reports for 2 files")
+
+        # primary file:
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri(TEST_NAME), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 0, "no diagnostics")
+
+        # imported file (goto/lib.sol):
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], self.get_test_file_uri('lib', 'goto'), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 1, "one diagnostic")
+        marker = self.get_test_tags("lib", "goto")["@diagnostics"]
+        self.expect_diagnostic(report['diagnostics'][0], code=2072, marker=marker)
+
+    @functools.lru_cache() # pragma pylint: disable=lru-cache-decorating-method
+    def get_test_tags(self, test_name: TestName, sub_dir=None, verbose=False):
+        """
+        Finds all tags (e.g. @tagname) in the given test and returns them as a
+        dictionary having the following structure: {
+            "@tagname": {
+             "start": { "character": 3, "line": 2 },
+             "end":   { "character": 30, "line": 2 }
+            }
+        }
+        """
+        content = self.get_test_file_contents(test_name, sub_dir)
+
+        markers = {}
+
+        for lineNum, line in tags_only(content.splitlines()):
+            commentStart = line.find("//")
+
+            for kind, regex in TAG_REGEXES._asdict().items():
+                for match in regex.finditer(line[commentStart:]):
+                    if kind == "simpleRange":
+                        markers[match.group("tag")] = {
+                            "start": {
+                                "line": lineNum,
+                                "character": match.start("range") + commentStart
+                            },
+                            "end": {
+                                "line": lineNum,
+                                "character": match.end("range") + commentStart
+                        }}
+                    elif kind == "multilineRange":
+                        if match.group("delimiter") == "(":
+                            markers[match.group("tag")] = \
+                                { "start": { "line": lineNum, "character": 0 } }
+                        elif match.group("delimiter") == ")":
+                            markers[match.group("tag")]["end"] = \
+                                { "line": lineNum, "character": 0 }
+
+        if verbose:
+            print(markers)
+        return markers
+
+
+    def test_custom_includes(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc, expose_project_root=False)
+        solc.send_notification(
+            'workspace/didChangeConfiguration', {
+                'settings': {
+                    'include-paths': [
+                        f"{self.project_root_dir}/other-include-dir"
+                    ]
+                }
+            }
+        )
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, 'include-paths/using-custom-includes')
+
+        self.expect_equal(len(published_diagnostics), 2, "Diagnostic reports for 2 files")
+
+        # test file
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri('using-custom-includes', 'include-paths'))
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 0, "no diagnostics")
+
+        # imported file
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], f"{self.project_root_uri}/other-include-dir/otherlib/otherlib.sol")
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 1, "no diagnostics")
+        self.expect_diagnostic(diagnostics[0], code=2018, lineNo=5, startEndColumns=(4, 62))
+
+    def test_custom_includes_with_full_project(self, solc: JsonRpcProcess) -> None:
+        """
+        Tests loading all project files while having custom include directories configured.
+        In such a scenario, all project files should be analyzed and those being included via search path
+        but not those include files that are not directly nor indirectly included.
+        """
+        self.setup_lsp(
+            solc,
+            expose_project_root=True,
+            project_root_subdir=''
+        )
+        solc.send_notification(
+            'workspace/didChangeConfiguration', {
+                'settings': {
+                    'include-paths': [
+                        f"{self.project_root_dir}/other-include-dir"
+                    ]
+                }
+            }
+        )
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, 'include-paths/using-custom-includes')
+
+        self.expect_equal(len(published_diagnostics), 2, "Diagnostic reports for 2 files")
+
+        # test file
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri('using-custom-includes', 'include-paths'))
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 0, "no diagnostics")
+
+        # imported file
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], f"{self.project_root_uri}/other-include-dir/otherlib/otherlib.sol")
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 1)
+        self.expect_diagnostic(diagnostics[0], code=2018, lineNo=5, startEndColumns=(4, 62))
+
+    def test_didChange_in_A_causing_error_in_B(self, solc: JsonRpcProcess) -> None:
+        # Reusing another test but now change some file that generates an error in the other.
+        self.test_textDocument_didOpen_with_relative_import(solc)
+        marker = self.get_test_tags("lib", "goto")["@addFunction"]
+        self.open_file_and_wait_for_diagnostics(solc, 'lib', "goto")
+        solc.send_message(
+            'textDocument/didChange',
+            {
+                'textDocument':
+                {
+                    'uri': self.get_test_file_uri('lib', 'goto')
+                },
+                'contentChanges':
+                [
+                    {
+                        'range': marker,
+                        'text': "" # deleting function `add`
+                    }
+                ]
+            }
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 2, "Diagnostic reports for 2 files")
+
+        # Main file now contains a new diagnostic
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri('didOpen_with_import'))
+        diagnostics = report['diagnostics']
+        marker = self.get_test_tags("didOpen_with_import")["@diagnostics"]
+        self.expect_equal(len(diagnostics), 1, "now, no diagnostics")
+        self.expect_diagnostic(diagnostics[0], code=9582, marker=marker)
+
+        # The modified file retains the same diagnostics.
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], self.get_test_file_uri('lib', 'goto'))
+        self.expect_equal(len(report['diagnostics']), 0)
+        # The warning went away because the compiler aborts further processing after the error.
+
+    def test_textDocument_didOpen_with_relative_import_without_project_url(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc, expose_project_root=False)
+        TEST_NAME = 'didOpen_with_import'
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, TEST_NAME)
+        self.verify_didOpen_with_import_diagnostics(published_diagnostics)
+
+    def verify_didOpen_with_import_diagnostics(
+        self,
+        published_diagnostics: List[Any],
+        main_file_name='didOpen_with_import'
+    ):
+        self.expect_equal(len(published_diagnostics), 2, "Diagnostic reports for 2 files")
+
+        # primary file:
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri(main_file_name), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 0, "one diagnostic")
+
+        # imported file (./goto/lib.sol):
+        report = published_diagnostics[1]
+        self.expect_equal(report['uri'], self.get_test_file_uri('lib', 'goto'), "Correct file URI")
+        self.expect_equal(len(report['diagnostics']), 1, "one diagnostic")
+
+        markers = self.get_test_tags('lib', 'goto')
+        marker = markers["@diagnostics"]
+        self.expect_diagnostic(report['diagnostics'][0], code=2072, marker=marker)
+
+    def test_generic(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc)
+
+        sub_dirs = filter(
+            lambda filepath: filepath.is_dir() and filepath.name != 'node_modules',
+            os.scandir(self.project_root_dir)
+        )
+
+        for sub_dir in map(lambda filepath: filepath.name, sub_dirs):
+            tests = map(
+                lambda file_object, sd=sub_dir: sd + "/" + file_object.name[:-len(".sol")],
+                filter(
+                    lambda filepath: filepath.is_file() and filepath.name.endswith('.sol'),
+                    os.scandir(f"{self.project_root_dir}/{sub_dir}")
+                )
+            )
+
+            tests = map(
+                lambda path, sd=sub_dir: path[len(sd)+1:],
+                fnmatch.filter(tests, self.test_pattern)
+            )
+
+            print(f"Running tests in subdirectory '{sub_dir}'...")
+            for test in tests:
+                try_again = True
+                print(f"\t{test}")
+
+                while try_again:
+                    runner = FileTestRunner(test, sub_dir, solc, self)
+
+                    try:
+                        runner.test_diagnostics()
+                        try_again = not runner.test_methods()
+                    except ExpectationFailed as e:
+                        print(e)
+
+                        if e.part == e.Part.Diagnostics:
+                            try_again = not self.user_interaction_failed_diagnostics(
+                                solc,
+                                test,
+                                sub_dir,
+                                runner.content,
+                                runner.expected_diagnostics
+                            )
+                        else:
+                            raise
+
+    def test_textDocument_didChange_updates_diagnostics(self, solc: JsonRpcProcess) -> None:
+        self.setup_lsp(solc)
+        TEST_NAME = 'publish_diagnostics_1'
+        published_diagnostics = self.open_file_and_wait_for_diagnostics(solc, TEST_NAME, "goto")
+        self.expect_equal(len(published_diagnostics), 1, "One published_diagnostics message")
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri(TEST_NAME, "goto"), "Correct file URI")
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 3, "3 diagnostic messages")
+        markers = self.get_test_tags(TEST_NAME, "goto")
+        self.expect_diagnostic(diagnostics[0], code=6321, marker=markers["@unusedReturnVariable"])
+        self.expect_diagnostic(diagnostics[1], code=2072, marker=markers["@unusedVariable"])
+        self.expect_diagnostic(diagnostics[2], code=2072, marker=markers["@unusedContractVariable"])
+
+        solc.send_message(
+            'textDocument/didChange',
+            {
+                'textDocument': {
+                    'uri': self.get_test_file_uri(TEST_NAME, "goto")
+                },
+                'contentChanges': [
+                    {
+                        'range': extendEnd(markers["@unusedVariable"]),
+                        'text': ""
+                    }
+                ]
+            }
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1)
+        report = published_diagnostics[0]
+        self.expect_equal(report['uri'], self.get_test_file_uri(TEST_NAME, "goto"), "Correct file URI")
+        diagnostics = report['diagnostics']
+        self.expect_equal(len(diagnostics), 2)
+        self.expect_diagnostic(diagnostics[0], code=6321, marker=markers["@unusedReturnVariable"])
+        self.expect_diagnostic(diagnostics[1], code=2072, marker=markers["@unusedContractVariable"])
+
+    def test_textDocument_didChange_delete_line_and_close(self, solc: JsonRpcProcess) -> None:
+        # Reuse this test to prepare and ensure it is as expected
+        self.test_textDocument_didOpen_with_relative_import(solc)
+        self.open_file_and_wait_for_diagnostics(solc, 'lib', 'goto')
+
+        marker = self.get_test_tags('lib', 'goto')["@diagnostics"]
+
+        # lib.sol: Fix the unused variable message by removing it.
+        solc.send_message(
+            'textDocument/didChange',
+            {
+                'textDocument':
+                {
+                    'uri': self.get_test_file_uri('lib', 'goto')
+                },
+                'contentChanges': # delete the in-body statement: `uint unused;`
+                [
+                    {
+                        'range': extendEnd(marker),
+                        'text': ""
+                    }
+                ]
+            }
+        )
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 2, "published diagnostics count")
+        report1 = published_diagnostics[0]
+        self.expect_equal(report1['uri'], self.get_test_file_uri('didOpen_with_import'), "Correct file URI")
+        self.expect_equal(len(report1['diagnostics']), 0, "no diagnostics in didOpen_with_import.sol")
+        report2 = published_diagnostics[1]
+        self.expect_equal(report2['uri'], self.get_test_file_uri('lib', 'goto'), "Correct file URI")
+        self.expect_equal(len(report2['diagnostics']), 0, "no diagnostics in lib.sol")
+
+        # Now close the file and expect the warning to re-appear
+        solc.send_message(
+            'textDocument/didClose',
+            { 'textDocument': { 'uri': self.get_test_file_uri('lib', 'goto') }}
+        )
+
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.verify_didOpen_with_import_diagnostics(published_diagnostics)
+
+    def test_textDocument_opening_two_new_files_edit_and_close(self, solc: JsonRpcProcess) -> None:
+        """
+        Open two new files A and B, let A import B, expect no error,
+        then close B and now expect the error of file B not being found.
+        """
+
+        self.setup_lsp(solc)
+        FILE_A_URI = 'file:///a.sol'
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_A_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text': ''.join([
+                    '// SPDX-License-Identifier: UNLICENSED\n',
+                    'pragma solidity >=0.8.0;\n',
+                ])
+            }
+        })
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 1, "one publish diagnostics notification")
+        self.expect_equal(len(reports[0]['diagnostics']), 0, "should not contain diagnostics")
+
+        FILE_B_URI = 'file:///b.sol'
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_B_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text': ''.join([
+                    '// SPDX-License-Identifier: UNLICENSED\n',
+                    'pragma solidity >=0.8.0;\n',
+                ])
+            }
+        })
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 2, "one publish diagnostics notification")
+        self.expect_equal(len(reports[0]['diagnostics']), 0, "should not contain diagnostics")
+        self.expect_equal(len(reports[1]['diagnostics']), 0, "should not contain diagnostics")
+
+        solc.send_message('textDocument/didChange', {
+            'textDocument': {
+                'uri': FILE_A_URI
+            },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 2, 'character': 0 },
+                        'end': { 'line': 2, 'character': 0 }
+                    },
+                    'text': 'import "./b.sol";\n'
+                }
+            ]
+        })
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 2, "one publish diagnostics notification")
+        self.expect_equal(len(reports[0]['diagnostics']), 0, "should not contain diagnostics")
+        self.expect_equal(len(reports[1]['diagnostics']), 0, "should not contain diagnostics")
+
+        solc.send_message(
+            'textDocument/didClose',
+            { 'textDocument': { 'uri': FILE_B_URI }}
+        )
+        # We only get one diagnostics message since the diagnostics for b.sol was empty.
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 1, "one publish diagnostics notification")
+        self.expect_diagnostic(reports[0]['diagnostics'][0], 6275, 2, (0, 17)) # a.sol: File B not found
+        self.expect_equal(reports[0]['uri'], FILE_A_URI, "Correct uri")
+
+    def test_textDocument_closing_virtual_file_removes_imported_real_file(self, solc: JsonRpcProcess) -> None:
+        """
+        We open a virtual file that imports a real file with a warning.
+        Once we close the virtual file, the warning is removed from the diagnostics,
+        since the real file is not considered part of the project anymore.
+        """
+
+        self.setup_lsp(solc)
+        FILE_A_URI = f'{self.project_root_uri}/a.sol'
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_A_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text':
+                    '// SPDX-License-Identifier: UNLICENSED\n'
+                    'pragma solidity >=0.8.0;\n'
+                    'import "./goto/lib.sol";\n'
+            }
+        })
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 2, '')
+        self.expect_equal(len(reports[0]['diagnostics']), 0, "should not contain diagnostics")
+
+        marker = self.get_test_tags("lib", 'goto')["@diagnostics"]
+
+        # unused variable in lib.sol
+        self.expect_diagnostic(reports[1]['diagnostics'][0], code=2072, marker=marker)
+
+        # Now close the file and expect the warning for lib.sol to be removed
+        solc.send_message(
+            'textDocument/didClose',
+            { 'textDocument': { 'uri': FILE_A_URI }}
+        )
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 1, '')
+        self.expect_equal(reports[0]['uri'], f'{self.project_root_uri}/goto/lib.sol', "")
+        self.expect_equal(len(reports[0]['diagnostics']), 0, "should not contain diagnostics")
+
+    def test_textDocument_didChange_at_eol(self, solc: JsonRpcProcess) -> None:
+        """
+        Append at one line and insert a new one below.
+        """
+        self.setup_lsp(solc)
+        FILE_NAME = 'didChange_template'
+        FILE_URI = self.get_test_file_uri(FILE_NAME)
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text': self.get_test_file_contents(FILE_NAME)
+            }
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        self.expect_equal(len(published_diagnostics[0]['diagnostics']), 0, "no diagnostics")
+        solc.send_message('textDocument/didChange', {
+            'textDocument': {
+                'uri': FILE_URI
+            },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 6, 'character': 0 },
+                        'end': { 'line': 6, 'character': 0 }
+                    },
+                    'text': " f"
+                }
+            ]
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        report2 = published_diagnostics[0]
+        self.expect_equal(report2['uri'], FILE_URI, "Correct file URI")
+        self.expect_equal(len(report2['diagnostics']), 1, "one diagnostic")
+        self.expect_diagnostic(report2['diagnostics'][0], 7858, 6, (1, 2))
+
+        solc.send_message('textDocument/didChange', {
+            'textDocument': { 'uri': FILE_URI },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 6, 'character': 2 },
+                        'end': { 'line': 6, 'character': 2 }
+                    },
+                    'text': 'unction f() public {}'
+                }
+            ]
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        report3 = published_diagnostics[0]
+        self.expect_equal(report3['uri'], FILE_URI, "Correct file URI")
+        self.expect_equal(len(report3['diagnostics']), 1, "one diagnostic")
+        self.expect_diagnostic(report3['diagnostics'][0], 4126, 6, (1, 23))
+
+    def test_textDocument_didChange_empty_file(self, solc: JsonRpcProcess) -> None:
+        """
+        Starts with an empty file and changes it to look like
+        the didOpen_with_import test case. Then we can use
+        the same verification calls to ensure it worked as expected.
+        """
+        # This FILE_NAME must be alphabetically before lib.sol to not over-complify
+        # the test logic in verify_didOpen_with_import_diagnostics.
+        FILE_NAME = 'a_new_file'
+        FILE_URI = self.get_test_file_uri(FILE_NAME)
+        self.setup_lsp(solc)
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text': ''
+            }
+        })
+        reports = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(reports), 1)
+        report = reports[0]
+        published_diagnostics = report['diagnostics']
+        self.expect_equal(len(published_diagnostics), 2)
+        self.expect_diagnostic(published_diagnostics[0], code=1878, lineNo=0, startEndColumns=(0, 0))
+        self.expect_diagnostic(published_diagnostics[1], code=3420, lineNo=0, startEndColumns=(0, 0))
+        solc.send_message('textDocument/didChange', {
+            'textDocument': {
+                'uri': self.get_test_file_uri('a_new_file')
+            },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 0, 'character': 0 },
+                        'end': { 'line': 0, 'character': 0 }
+                    },
+                    'text': self.get_test_file_contents('didOpen_with_import')
+                }
+            ]
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.verify_didOpen_with_import_diagnostics(published_diagnostics, 'a_new_file')
+
+    def test_textDocument_didChange_multi_line(self, solc: JsonRpcProcess) -> None:
+        """
+        Starts with an empty file and changes it to multiple times, changing
+        content across lines.
+        """
+        self.setup_lsp(solc)
+        FILE_NAME = 'didChange_template'
+        FILE_URI = self.get_test_file_uri(FILE_NAME)
+        solc.send_message('textDocument/didOpen', {
+            'textDocument': {
+                'uri': FILE_URI,
+                'languageId': 'Solidity',
+                'version': 1,
+                'text': self.get_test_file_contents(FILE_NAME)
+            }
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        self.expect_equal(len(published_diagnostics[0]['diagnostics']), 0, "no diagnostics")
+        solc.send_message('textDocument/didChange', {
+            'textDocument': { 'uri': FILE_URI },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 3, 'character': 3 },
+                        'end': { 'line': 4, 'character': 1 }
+                    },
+                    'text': "tract D {\n\n  uint x\n = -1; \n "
+                }
+            ]
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        report2 = published_diagnostics[0]
+        self.expect_equal(report2['uri'], FILE_URI, "Correct file URI")
+        self.expect_equal(len(report2['diagnostics']), 1, "one diagnostic")
+        self.expect_diagnostic(report2['diagnostics'][0], 7407, 6, (3, 5))
+
+        # Now we are changing the part "x\n = -" of "uint x\n = -1;"
+        solc.send_message('textDocument/didChange', {
+            'textDocument': { 'uri': FILE_URI },
+            'contentChanges': [
+                {
+                    'range': {
+                        'start': { 'line': 5, 'character': 7 },
+                        'end': { 'line': 6, 'character': 4 }
+                    },
+                    'text': "y\n = [\nuint(1),\n3,4]+"
+                }
+            ]
+        })
+        published_diagnostics = self.wait_for_diagnostics(solc)
+        self.expect_equal(len(published_diagnostics), 1, "one publish diagnostics notification")
+        report3 = published_diagnostics[0]
+        self.expect_equal(report3['uri'], FILE_URI, "Correct file URI")
+        self.expect_equal(len(report3['diagnostics']), 2, "two diagnostics")
+        diagnostic = report3['diagnostics'][0]
+        self.expect_equal(diagnostic['code'], 2271, 'diagnostic: 2271')
+        # check multi-line error code
+        self.expect_equal(
+            diagnostic['range'],
+            {
+                'end': {'character': 6, 'line': 8},
+                'start': {'character': 3, 'line': 6}
+            },
+            "diagnostic: check range"
+        )
+        diagnostic = report3['diagnostics'][1]
+        self.expect_equal(diagnostic['code'], 7407, 'diagnostic: 7407')
+        # check multi-line error code
+        self.expect_equal(
+            diagnostic['range'],
+            {
+                'end': {'character': 6, 'line': 8},
+                'start': {'character': 3, 'line': 6}
+            },
+            "diagnostic: check range"
+        )
+
+    # }}}
+    # }}}
+
+
+if __name__ == "__main__":
+    suite = SolidityLSPTestSuite()
+    exit_code = suite.main()
+    sys.exit(exit_code)
diff --git a/compiler/test/scripts/test_bytecodecompare_prepare_report.py b/compiler/test/scripts/test_bytecodecompare_prepare_report.py
new file mode 100644
index 00000000..28a89ec3
--- /dev/null
+++ b/compiler/test/scripts/test_bytecodecompare_prepare_report.py
@@ -0,0 +1,675 @@
+#!/usr/bin/env python
+
+import json
+import unittest
+from pathlib import Path
+from textwrap import dedent
+
+from unittest_helpers import FIXTURE_DIR, LIBSOLIDITY_TEST_DIR, load_fixture, load_libsolidity_test_case
+
+# NOTE: This test file file only works with scripts/ added to PYTHONPATH so pylint can't find the imports
+# pragma pylint: disable=import-error
+from bytecodecompare.prepare_report import ExecutionArchitecture, CompilerInterface, FileReport, ContractReport
+from bytecodecompare.prepare_report import SettingsPreset, SMTUse, Statistics
+from bytecodecompare.prepare_report import load_source, parse_cli_output, parse_standard_json_output, prepare_compiler_input
+# pragma pylint: enable=import-error
+
+
+SMT_SMOKE_TEST_SOL_PATH = FIXTURE_DIR / 'smt_smoke_test.sol'
+SMT_SMOKE_TEST_SOL_CODE = load_fixture(SMT_SMOKE_TEST_SOL_PATH)
+
+SMT_CONTRACT_WITH_LF_NEWLINES_SOL_PATH = FIXTURE_DIR / 'smt_contract_with_lf_newlines.sol'
+SMT_CONTRACT_WITH_CRLF_NEWLINES_SOL_PATH = FIXTURE_DIR / 'smt_contract_with_crlf_newlines.sol'
+SMT_CONTRACT_WITH_CR_NEWLINES_SOL_PATH = FIXTURE_DIR / 'smt_contract_with_cr_newlines.sol'
+SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH = FIXTURE_DIR / 'smt_contract_with_mixed_newlines.sol'
+SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_CODE = load_fixture(SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH)
+
+SYNTAX_SMOKE_TEST_SOL_PATH = LIBSOLIDITY_TEST_DIR / 'syntaxTests/smoke_test.sol'
+SYNTAX_SMOKE_TEST_SOL_CODE = load_libsolidity_test_case(SYNTAX_SMOKE_TEST_SOL_PATH)
+
+LIBRARY_INHERITED2_SOL_JSON_OUTPUT = load_fixture('library_inherited2_sol_json_output.json')
+LIBRARY_INHERITED2_SOL_CLI_OUTPUT = load_fixture('library_inherited2_sol_cli_output.txt')
+
+UNKNOWN_PRAGMA_SOL_JSON_OUTPUT = load_fixture('unknown_pragma_sol_json_output.json')
+UNKNOWN_PRAGMA_SOL_CLI_OUTPUT = load_fixture('unknown_pragma_sol_cli_output.txt')
+
+UNIMPLEMENTED_FEATURE_JSON_OUTPUT = load_fixture('unimplemented_feature_json_output.json')
+UNIMPLEMENTED_FEATURE_CLI_OUTPUT = load_fixture('unimplemented_feature_cli_output.txt')
+
+STACK_TOO_DEEP_JSON_OUTPUT = load_fixture('stack_too_deep_json_output.json')
+STACK_TOO_DEEP_CLI_OUTPUT = load_fixture('stack_too_deep_cli_output.txt')
+
+CODE_GENERATION_ERROR_JSON_OUTPUT = load_fixture('code_generation_error_json_output.json')
+CODE_GENERATION_ERROR_CLI_OUTPUT = load_fixture('code_generation_error_cli_output.txt')
+
+SOLC_0_4_0_CLI_OUTPUT = load_fixture('solc_0.4.0_cli_output.txt')
+SOLC_0_4_8_CLI_OUTPUT = load_fixture('solc_0.4.8_cli_output.txt')
+
+
+class PrepareReportTestBase(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = 10000
+
+
+class TestFileReport(PrepareReportTestBase):
+    def test_format_report(self):
+        report = FileReport(
+            file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+            contract_reports=[
+                ContractReport(
+                    contract_name='A',
+                    file_name=Path('syntaxTests/smoke_test.sol'),
+                    bytecode=None,
+                    metadata=None,
+                ),
+                ContractReport(
+                    contract_name='B',
+                    file_name=Path('syntaxTests/smoke_test.sol'),
+                    bytecode=None,
+                    metadata='{"language":"Solidity"}',
+                ),
+                ContractReport(
+                    contract_name='Lib',
+                    file_name=Path('syntaxTests/smoke_test.sol'),
+                    bytecode='60566050600b828282398051',
+                    metadata=None,
+                ),
+            ]
+        )
+
+        expected_output = (
+            "syntaxTests/scoping/library_inherited2.sol:A <NO BYTECODE>\n"
+            "syntaxTests/scoping/library_inherited2.sol:A <NO METADATA>\n"
+            "syntaxTests/scoping/library_inherited2.sol:B <NO BYTECODE>\n"
+            "syntaxTests/scoping/library_inherited2.sol:B {\"language\":\"Solidity\"}\n"
+            "syntaxTests/scoping/library_inherited2.sol:Lib 60566050600b828282398051\n"
+            "syntaxTests/scoping/library_inherited2.sol:Lib <NO METADATA>\n"
+        )
+
+        self.assertEqual(report.format_report(), expected_output)
+
+    def test_format_report_should_print_error_if_contract_report_list_is_missing(self):
+        report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        expected_output = "file.sol: <ERROR>\n"
+
+        self.assertEqual(report.format_report(), expected_output)
+
+    def test_format_report_should_not_print_anything_if_contract_report_list_is_empty(self):
+        report = FileReport(file_name=Path('file.sol'), contract_reports=[])
+
+        self.assertEqual(report.format_report(), '')
+
+class TestPrepareReport_Statistics(unittest.TestCase):
+    def test_initialization(self):
+        self.assertEqual(Statistics(), Statistics(0, 0, 0, 0, 0))
+
+    def test_aggregate_bytecode_and_metadata_present(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[ContractReport('C', 'c.sol', 'B', 'M')]))
+        self.assertEqual(statistics, Statistics(1, 1, 0, 0, 0))
+
+    def test_aggregate_bytecode_missing(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[ContractReport('C', 'c.sol', None, 'M')]))
+        self.assertEqual(statistics, Statistics(1, 1, 0, 1, 0))
+
+    def test_aggregate_metadata_missing(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[ContractReport('C', 'c.sol', 'B', None)]))
+        self.assertEqual(statistics, Statistics(1, 1, 0, 0, 1))
+
+    def test_aggregate_no_contract_reports(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[]))
+        self.assertEqual(statistics, Statistics(1, 0, 0, 0, 0))
+
+    def test_aggregate_missing_contract_report_list(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=None))
+        self.assertEqual(statistics, Statistics(1, 0, 1, 0, 0))
+
+    def test_aggregate_multiple_contract_reports(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[
+            ContractReport('C', 'c.sol', 'B', 'M'),
+            ContractReport('C', 'c.sol', None, 'M'),
+            ContractReport('C', 'c.sol', 'B', None),
+            ContractReport('C', 'c.sol', None, None),
+        ]))
+        self.assertEqual(statistics, Statistics(1, 4, 0, 2, 2))
+
+    def test_str(self):
+        statistics = Statistics()
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=[
+            ContractReport('C', 'c.sol', 'B', 'M'),
+            ContractReport('C', 'c.sol', None, 'M'),
+            ContractReport('C', 'c.sol', 'B', None),
+            ContractReport('C', 'c.sol', None, None),
+        ]))
+        statistics.aggregate(FileReport(file_name=Path('F'), contract_reports=None))
+
+        self.assertEqual(statistics, Statistics(2, 4, 1, 2, 2))
+        self.assertEqual(str(statistics), "test cases: 2, contracts: 4+, errors: 1, missing bytecode: 2, missing metadata: 2")
+
+
+class TestLoadSource(PrepareReportTestBase):
+    def test_load_source_should_strip_smt_pragmas_if_requested(self):
+        expected_file_content = (
+            "\n"
+            "contract C {\n"
+            "}\n"
+        )
+
+        self.assertEqual(load_source(SMT_SMOKE_TEST_SOL_PATH, SMTUse.STRIP_PRAGMAS), expected_file_content)
+
+    def test_load_source_should_not_strip_smt_pragmas_if_not_requested(self):
+        self.assertEqual(load_source(SMT_SMOKE_TEST_SOL_PATH, SMTUse.DISABLE), SMT_SMOKE_TEST_SOL_CODE)
+        self.assertEqual(load_source(SMT_SMOKE_TEST_SOL_PATH, SMTUse.PRESERVE), SMT_SMOKE_TEST_SOL_CODE)
+
+    def test_load_source_preserves_lf_newlines(self):
+        expected_output = (
+            "\n"
+            "\n"
+            "contract C {\n"
+            "}\n"
+        )
+
+        self.assertEqual(load_source(SMT_CONTRACT_WITH_LF_NEWLINES_SOL_PATH, SMTUse.STRIP_PRAGMAS), expected_output)
+
+    def test_load_source_preserves_crlf_newlines(self):
+        expected_output = (
+            "\r\n"
+            "\r\n"
+            "contract C {\r\n"
+            "}\r\n"
+        )
+
+        self.assertEqual(load_source(SMT_CONTRACT_WITH_CRLF_NEWLINES_SOL_PATH, SMTUse.STRIP_PRAGMAS), expected_output)
+
+    def test_load_source_preserves_cr_newlines(self):
+        expected_output = (
+            "\r"
+            "\r"
+            "contract C {\r"
+            "}\r"
+        )
+
+        self.assertEqual(load_source(SMT_CONTRACT_WITH_CR_NEWLINES_SOL_PATH, SMTUse.STRIP_PRAGMAS), expected_output)
+
+    def test_load_source_preserves_mixed_newlines(self):
+        expected_output = (
+            "\n"
+            "\n"
+            "contract C {\r"
+            "}\r\n"
+        )
+
+        self.assertEqual(load_source(SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH, SMTUse.STRIP_PRAGMAS), expected_output)
+
+
+class TestPrepareCompilerInput(PrepareReportTestBase):
+    def test_prepare_compiler_input_should_work_with_standard_json_interface(self):
+        expected_compiler_input = {
+            'language': 'Solidity',
+            'sources': {
+                str(SMT_SMOKE_TEST_SOL_PATH): {'content': SMT_SMOKE_TEST_SOL_CODE},
+            },
+            'settings': {
+                'optimizer': {'enabled': True},
+                'outputSelection': {'*': {'*': ['evm.bytecode.object', 'metadata']}},
+                'modelChecker': {'engine': 'none'},
+            }
+        }
+
+        (command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_SMOKE_TEST_SOL_PATH,
+            preset=SettingsPreset.LEGACY_OPTIMIZE,
+            force_no_optimize_yul=False,
+            interface=CompilerInterface.STANDARD_JSON,
+            smt_use=SMTUse.DISABLE,
+            metadata_option_supported=True,
+        )
+
+        self.assertEqual(command_line, ['solc', '--standard-json'])
+        self.assertEqual(json.loads(compiler_input), expected_compiler_input)
+
+    def test_prepare_compiler_input_should_work_with_cli_interface(self):
+        (command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_SMOKE_TEST_SOL_PATH,
+            preset=SettingsPreset.LEGACY_OPTIMIZE,
+            force_no_optimize_yul=False,
+            interface=CompilerInterface.CLI,
+            smt_use=SMTUse.DISABLE,
+            metadata_option_supported=True,
+        )
+
+        self.assertEqual(
+            command_line,
+            ['solc', str(SMT_SMOKE_TEST_SOL_PATH), '--bin', '--metadata', '--optimize', '--model-checker-engine', 'none']
+        )
+        self.assertEqual(compiler_input, SMT_SMOKE_TEST_SOL_CODE)
+
+    def test_prepare_compiler_input_for_json_preserves_newlines(self):
+        expected_compiler_input = {
+            'language': 'Solidity',
+            'sources': {
+                str(SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH): {
+                    'content':
+                        "pragma experimental SMTChecker;\n"
+                        "\n"
+                        "contract C {\r"
+                        "}\r\n"
+                },
+            },
+            'settings': {
+                'optimizer': {'enabled': True},
+                'viaIR': True,
+                'outputSelection': {'*': {'*': ['evm.bytecode.object', 'metadata']}},
+                'modelChecker': {'engine': 'none'},
+            }
+        }
+
+        (command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH,
+            preset=SettingsPreset.VIA_IR_OPTIMIZE,
+            force_no_optimize_yul=False,
+            interface=CompilerInterface.STANDARD_JSON,
+            smt_use=SMTUse.DISABLE,
+            metadata_option_supported=True,
+        )
+
+        self.assertEqual(command_line, ['solc', '--standard-json'])
+        self.assertEqual(json.loads(compiler_input), expected_compiler_input)
+
+    def test_prepare_compiler_input_for_cli_preserves_newlines(self):
+        (_command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_PATH,
+            preset=SettingsPreset.LEGACY_OPTIMIZE,
+            force_no_optimize_yul=True,
+            interface=CompilerInterface.CLI,
+            smt_use=SMTUse.DISABLE,
+            metadata_option_supported=True,
+        )
+
+        self.assertEqual(compiler_input, SMT_CONTRACT_WITH_MIXED_NEWLINES_SOL_CODE)
+
+    def test_prepare_compiler_input_for_cli_should_handle_force_no_optimize_yul_flag(self):
+        (command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_SMOKE_TEST_SOL_PATH,
+            preset=SettingsPreset.LEGACY_NO_OPTIMIZE,
+            force_no_optimize_yul=True,
+            interface=CompilerInterface.CLI,
+            smt_use=SMTUse.DISABLE,
+            metadata_option_supported=True,
+        )
+
+        self.assertEqual(
+            command_line,
+            ['solc', str(SMT_SMOKE_TEST_SOL_PATH), '--bin', '--metadata', '--no-optimize-yul', '--model-checker-engine', 'none'],
+        )
+        self.assertEqual(compiler_input, SMT_SMOKE_TEST_SOL_CODE)
+
+    def test_prepare_compiler_input_for_cli_should_not_use_metadata_option_if_not_supported(self):
+        (command_line, compiler_input) = prepare_compiler_input(
+            Path('solc'),
+            ExecutionArchitecture.NATIVE,
+            SMT_SMOKE_TEST_SOL_PATH,
+            preset=SettingsPreset.VIA_IR_OPTIMIZE,
+            force_no_optimize_yul=False,
+            interface=CompilerInterface.CLI,
+            smt_use=SMTUse.PRESERVE,
+            metadata_option_supported=False,
+        )
+
+        self.assertEqual(
+            command_line,
+            ['solc', str(SMT_SMOKE_TEST_SOL_PATH), '--bin', '--optimize', '--via-ir'],
+        )
+        self.assertEqual(compiler_input, SMT_SMOKE_TEST_SOL_CODE)
+
+
+class TestParseStandardJSONOutput(PrepareReportTestBase):
+    def test_parse_standard_json_output(self):
+        expected_report = FileReport(
+            file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+            contract_reports=[
+                # pragma pylint: disable=line-too-long
+                ContractReport(
+                    contract_name='A',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea264697066735822122086e727f29d40b264a19bbfcad38d64493dca4bab5dbba8c82ffdaae389d2bba064736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"A"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                ContractReport(
+                    contract_name='B',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='608060405234801561001057600080fd5b506101cc806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80630423a13214610030575b600080fd5b61004a6004803603810190610045919061009d565b610060565b60405161005791906100d5565b60405180910390f35b600061006b82610072565b9050919050565b6000602a8261008191906100f0565b9050919050565b6000813590506100978161017f565b92915050565b6000602082840312156100af57600080fd5b60006100bd84828501610088565b91505092915050565b6100cf81610146565b82525050565b60006020820190506100ea60008301846100c6565b92915050565b60006100fb82610146565b915061010683610146565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561013b5761013a610150565b5b828201905092915050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b61018881610146565b811461019357600080fd5b5056fea2646970667358221220104c345633313efe410492448844d96d78452c3044ce126b5e041b7fbeaa790064736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"bar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"B"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                ContractReport(
+                    contract_name='Lib',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207f9515e2263fa71a7984707e2aefd82241fac15c497386ca798b526f14f8ba6664736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"Lib"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                # pragma pylint: enable=line-too-long
+            ]
+        )
+
+        report = parse_standard_json_output(
+            Path('syntaxTests/scoping/library_inherited2.sol'),
+            LIBRARY_INHERITED2_SOL_JSON_OUTPUT,
+        )
+        self.assertEqual(report, expected_report)
+
+    def test_parse_standard_json_output_should_report_error_on_compiler_errors(self):
+        expected_report = FileReport(file_name=Path('syntaxTests/pragma/unknown_pragma.sol'), contract_reports=None)
+
+        report = parse_standard_json_output(Path('syntaxTests/pragma/unknown_pragma.sol'), UNKNOWN_PRAGMA_SOL_JSON_OUTPUT)
+        self.assertEqual(report, expected_report)
+
+    def test_parse_standard_json_output_should_report_error_on_empty_json(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('file.sol'), '{}'), expected_report)
+
+    def test_parse_standard_json_output_should_report_error_if_contracts_is_empty(self):
+        compiler_output = '{"contracts": {}}'
+
+        expected_report = FileReport(file_name=Path('contract.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('contract.sol'), compiler_output), expected_report)
+
+    def test_parse_standard_json_output_should_report_error_if_every_file_has_no_contracts(self):
+        compiler_output = (
+            "{\n"
+            "    \"contracts\": {\n"
+            "        \"contract1.sol\": {},\n"
+            "        \"contract2.sol\": {}\n"
+            "    }\n"
+            "}\n"
+        )
+
+        expected_report = FileReport(file_name=Path('contract.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('contract.sol'), compiler_output), expected_report)
+
+    def test_parse_standard_json_output_should_not_report_error_if_there_is_at_least_one_file_with_contracts(self):
+        compiler_output = (
+            "{\n"
+            "    \"contracts\": {\n"
+            "        \"contract1.sol\": {\"A\": {}},\n"
+            "        \"contract2.sol\": {}\n"
+            "    }\n"
+            "}\n"
+        )
+
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[ContractReport(contract_name='A', file_name=Path('contract1.sol'), bytecode=None, metadata=None)]
+        )
+
+        self.assertEqual(parse_standard_json_output(Path('contract.sol'), compiler_output), expected_report)
+
+    def test_parse_standard_json_output_should_report_error_on_unimplemented_feature_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('file.sol'), UNIMPLEMENTED_FEATURE_JSON_OUTPUT), expected_report)
+
+    def test_parse_standard_json_output_should_report_error_on_stack_too_deep_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('file.sol'), STACK_TOO_DEEP_JSON_OUTPUT), expected_report)
+
+    def test_parse_standard_json_output_should_report_error_on_code_generation_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_standard_json_output(Path('file.sol'), CODE_GENERATION_ERROR_JSON_OUTPUT), expected_report)
+
+
+class TestParseCLIOutput(PrepareReportTestBase):
+    def test_parse_standard_json_output_should_report_missing_if_value_is_just_whitespace(self):
+        compiler_output = dedent("""\
+            {
+                "contracts": {
+                    "contract.sol": {
+                        "A": {
+                            "evm": {"bytecode": {"object": ""}},
+                            "metadata": ""
+                        },
+                        "B": {
+                            "evm": {"bytecode": {"object": "  "}},
+                            "metadata": "  "
+                        }
+                    }
+                }
+            }
+        """)
+
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                ContractReport(contract_name='A', file_name=Path('contract.sol'), bytecode=None, metadata=None),
+                ContractReport(contract_name='B', file_name=Path('contract.sol'), bytecode=None, metadata=None),
+            ]
+        )
+
+        self.assertEqual(parse_standard_json_output(Path('contract.sol'), compiler_output), expected_report)
+
+    def test_parse_cli_output(self):
+        expected_report = FileReport(
+            file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+            contract_reports=[
+                # pragma pylint: disable=line-too-long
+                ContractReport(
+                    contract_name='A',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea264697066735822122086e727f29d40b264a19bbfcad38d64493dca4bab5dbba8c82ffdaae389d2bba064736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"A"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                ContractReport(
+                    contract_name='B',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='608060405234801561001057600080fd5b506101cc806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80630423a13214610030575b600080fd5b61004a6004803603810190610045919061009d565b610060565b60405161005791906100d5565b60405180910390f35b600061006b82610072565b9050919050565b6000602a8261008191906100f0565b9050919050565b6000813590506100978161017f565b92915050565b6000602082840312156100af57600080fd5b60006100bd84828501610088565b91505092915050565b6100cf81610146565b82525050565b60006020820190506100ea60008301846100c6565b92915050565b60006100fb82610146565b915061010683610146565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561013b5761013a610150565b5b828201905092915050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b61018881610146565b811461019357600080fd5b5056fea2646970667358221220104c345633313efe410492448844d96d78452c3044ce126b5e041b7fbeaa790064736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"bar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"B"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                ContractReport(
+                    contract_name='Lib',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207f9515e2263fa71a7984707e2aefd82241fac15c497386ca798b526f14f8ba6664736f6c63430008000033',
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"Lib"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                # pragma pylint: enable=line-too-long
+            ]
+        )
+
+        report = parse_cli_output(Path('syntaxTests/scoping/library_inherited2.sol'), LIBRARY_INHERITED2_SOL_CLI_OUTPUT, 0)
+        self.assertEqual(report, expected_report)
+
+    def test_parse_cli_output_should_report_error_on_compiler_errors(self):
+        expected_report = FileReport(file_name=Path('syntaxTests/pragma/unknown_pragma.sol'), contract_reports=None)
+
+        report = parse_cli_output(Path('syntaxTests/pragma/unknown_pragma.sol'), UNKNOWN_PRAGMA_SOL_CLI_OUTPUT, 0)
+        self.assertEqual(report, expected_report)
+
+    def test_parse_cli_output_should_report_error_on_empty_output(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_cli_output(Path('file.sol'), '', 0), expected_report)
+
+    def test_parse_cli_output_should_report_missing_bytecode_and_metadata(self):
+        compiler_output = dedent("""\
+            ======= syntaxTests/scoping/library_inherited2.sol:A =======
+            ======= syntaxTests/scoping/library_inherited2.sol:B =======
+            608060405234801561001057600080fd5b506101cc806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80630423a13214610030575b600080fd5b61004a6004803603810190610045919061009d565b610060565b60405161005791906100d5565b60405180910390f35b600061006b82610072565b9050919050565b6000602a8261008191906100f0565b9050919050565b6000813590506100978161017f565b92915050565b6000602082840312156100af57600080fd5b60006100bd84828501610088565b91505092915050565b6100cf81610146565b82525050565b60006020820190506100ea60008301846100c6565b92915050565b60006100fb82610146565b915061010683610146565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561013b5761013a610150565b5b828201905092915050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b61018881610146565b811461019357600080fd5b5056fea2646970667358221220104c345633313efe410492448844d96d78452c3044ce126b5e041b7fbeaa790064736f6c63430008000033
+            Metadata:
+            {"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"bar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"B"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}
+
+            ======= syntaxTests/scoping/library_inherited2.sol:Lib =======
+            Binary:
+            60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207f9515e2263fa71a7984707e2aefd82241fac15c497386ca798b526f14f8ba6664736f6c63430008000033
+            Metadata:
+        """)
+
+        expected_report = FileReport(
+            file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+            contract_reports=[
+                ContractReport(
+                    contract_name='A',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode=None,
+                    metadata=None,
+                ),
+                # pragma pylint: disable=line-too-long
+                ContractReport(
+                    contract_name='B',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode=None,
+                    metadata='{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"bar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"syntaxTests/scoping/library_inherited2.sol":"B"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"syntaxTests/scoping/library_inherited2.sol":{"keccak256":"0xd0619f00638fdfea187368965615dbd599fead93dd14b6558725e85ec7011d96","urls":["bzz-raw://ec7af066be66a223f0d25ba3bf9ba6dc103e1a57531a66a38a5ca2b6ce172f55","dweb:/ipfs/QmW1NrqQNhnY1Tkgr3Z9oM8buCGLUJCJVCDTVejJTT5Vet"]}},"version":1}',
+                ),
+                ContractReport(
+                    contract_name='Lib',
+                    file_name=Path('syntaxTests/scoping/library_inherited2.sol'),
+                    bytecode='60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207f9515e2263fa71a7984707e2aefd82241fac15c497386ca798b526f14f8ba6664736f6c63430008000033',
+                    metadata=None,
+                ),
+                # pragma pylint: enable=line-too-long
+            ]
+        )
+
+        self.assertEqual(
+            parse_cli_output(Path('syntaxTests/scoping/library_inherited2.sol'), compiler_output, 0),
+            expected_report
+        )
+
+    def test_parse_cli_output_should_report_error_on_unimplemented_feature_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_cli_output(Path('file.sol'), UNIMPLEMENTED_FEATURE_CLI_OUTPUT, 0), expected_report)
+
+    def test_parse_cli_output_should_report_error_on_stack_too_deep_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_cli_output(Path('file.sol'), STACK_TOO_DEEP_CLI_OUTPUT, 0), expected_report)
+
+    def test_parse_cli_output_should_report_error_on_code_generation_error(self):
+        expected_report = FileReport(file_name=Path('file.sol'), contract_reports=None)
+
+        self.assertEqual(parse_cli_output(Path('file.sol'), CODE_GENERATION_ERROR_CLI_OUTPUT, 0), expected_report)
+
+    def test_parse_cli_output_should_handle_output_from_solc_0_4_0(self):
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                ContractReport(
+                    contract_name='C',
+                    file_name=None,
+                    bytecode='6060604052600c8060106000396000f360606040526008565b600256',
+                    metadata=None,
+                )
+            ]
+        )
+
+        self.assertEqual(parse_cli_output(Path('contract.sol'), SOLC_0_4_0_CLI_OUTPUT, 0), expected_report)
+
+    def test_parse_cli_output_should_handle_output_from_solc_0_4_8(self):
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                # pragma pylint: disable=line-too-long
+                ContractReport(
+                    contract_name='C',
+                    file_name=None,
+                    bytecode='6060604052346000575b60358060166000396000f30060606040525b60005600a165627a7a72305820ccf9337430b4c4f7d6ad41efb10a94411a2af6a9f173ef52daeadd31f4bf11890029',
+                    metadata='{"compiler":{"version":"0.4.8+commit.60cc1668.mod.Darwin.appleclang"},"language":"Solidity","output":{"abi":[],"devdoc":{"methods":{}},"userdoc":{"methods":{}}},"settings":{"compilationTarget":{"contract.sol":"C"},"libraries":{},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"contract.sol":{"keccak256":"0xbe86d3681a198587296ad6d4a834606197e1a8f8944922c501631b04e21eeba2","urls":["bzzr://af16957d3d86013309d64d3cc572d007b1d8b08a821f2ff366840deb54a78524"]}},"version":1}',
+                )
+                # pragma pylint: enable=line-too-long
+            ]
+        )
+
+        self.assertEqual(parse_cli_output(Path('contract.sol'), SOLC_0_4_8_CLI_OUTPUT, 0), expected_report)
+
+    def test_parse_cli_output_should_handle_leading_and_trailing_spaces(self):
+        compiler_output = (
+            ' =======  contract.sol : C  ======= \n'
+            ' Binary: \n'
+            ' 60806040523480156 \n'
+            ' Metadata: \n'
+            ' {  } \n'
+        )
+
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                ContractReport(contract_name='C', file_name=Path('contract.sol'), bytecode='60806040523480156', metadata='{  }')
+            ]
+        )
+
+        self.assertEqual(parse_cli_output(Path('contract.sol'), compiler_output, 0), expected_report)
+
+    def test_parse_cli_output_should_handle_empty_bytecode_and_metadata_lines(self):
+        compiler_output = dedent("""\
+            ======= contract.sol:C =======
+            Binary:
+            60806040523480156
+            Metadata:
+
+
+            ======= contract.sol:D =======
+            Binary:
+
+            Metadata:
+            {}
+
+
+            ======= contract.sol:E =======
+            Binary:
+
+            Metadata:
+
+
+        """)
+
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                ContractReport(contract_name='C', file_name=Path('contract.sol'), bytecode='60806040523480156', metadata=None),
+                ContractReport(contract_name='D', file_name=Path('contract.sol'), bytecode=None, metadata='{}'),
+                ContractReport(contract_name='E', file_name=Path('contract.sol'), bytecode=None, metadata=None),
+            ]
+        )
+
+        self.assertEqual(parse_cli_output(Path('contract.sol'), compiler_output, 0), expected_report)
+
+    def test_parse_cli_output_should_handle_link_references_in_bytecode(self):
+        compiler_output = dedent("""\
+            ======= contract.sol:C =======
+            Binary:
+            73123456789012345678901234567890123456789073__$fb58009a6b1ecea3b9d99bedd645df4ec3$__5050
+            ======= contract.sol:D =======
+            Binary:
+            __$fb58009a6b1ecea3b9d99bedd645df4ec3$__
+        """)
+
+        # pragma pylint: disable=line-too-long
+        expected_report = FileReport(
+            file_name=Path('contract.sol'),
+            contract_reports=[
+                ContractReport(contract_name='C', file_name=Path('contract.sol'), bytecode='73123456789012345678901234567890123456789073__$fb58009a6b1ecea3b9d99bedd645df4ec3$__5050', metadata=None),
+                ContractReport(contract_name='D', file_name=Path('contract.sol'), bytecode='__$fb58009a6b1ecea3b9d99bedd645df4ec3$__', metadata=None),
+            ]
+        )
+        # pragma pylint: enable=line-too-long
+
+        self.assertEqual(parse_cli_output(Path('contract.sol'), compiler_output, 0), expected_report)
diff --git a/compiler/test/solc/CommandLineInterface.cpp b/compiler/test/solc/CommandLineInterface.cpp
new file mode 100644
index 00000000..7a4f625c
--- /dev/null
+++ b/compiler/test/solc/CommandLineInterface.cpp
@@ -0,0 +1,1390 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for solc/CommandLineInterface.h
+
+#include <solc/CommandLineInterface.h>
+#include <solc/Exceptions.h>
+
+#include <test/solc/Common.h>
+
+#include <test/Common.h>
+#include <test/libsolidity/util/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+#include <liblangutil/SemVerHandler.h>
+#include <test/FilesystemUtils.h>
+
+#include <libsolutil/JSON.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <range/v3/view/transform.hpp>
+
+#include <map>
+#include <ostream>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace solidity::frontend;
+using namespace solidity::test;
+using namespace solidity::util;
+using namespace solidity::langutil;
+
+using PathSet = std::set<boost::filesystem::path>;
+
+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
+
+namespace
+{
+
+std::ostream& operator<<(std::ostream& _out, std::vector<ImportRemapper::Remapping> const& _remappings)
+{
+	static auto remappingToString = [](auto const& _remapping)
+	{
+		return _remapping.context + ":" + _remapping.prefix + "=" + _remapping.target;
+	};
+
+	_out << "[" << joinHumanReadable(_remappings | ranges::views::transform(remappingToString)) << "]";
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, std::map<std::string, std::string> const& _map)
+{
+	_out << "{" << std::endl;
+	for (auto const& [key, value]: _map)
+		_out << "" << key << ": " << value << "," << std::endl;
+	_out << "}";
+
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, PathSet const& _paths)
+{
+	static auto pathString = [](auto const& _path) { return _path.string(); };
+
+	_out << "{" << joinHumanReadable(_paths | ranges::views::transform(pathString)) << "}";
+	return _out;
+}
+
+} // namespace
+
+namespace boost::test_tools::tt_detail
+{
+
+// Boost won't find the << operator unless we put it in the std namespace which is illegal.
+// The recommended solution is to overload print_log_value<> struct and make it use our operator.
+
+template<>
+struct print_log_value<std::vector<ImportRemapper::Remapping>>
+{
+	void operator()(std::ostream& _out, std::vector<ImportRemapper::Remapping> const& _value) { ::operator<<(_out, _value); }
+};
+
+template<>
+struct print_log_value<std::map<std::string, std::string>>
+{
+	void operator()(std::ostream& _out, std::map<std::string, std::string> const& _value) { ::operator<<(_out, _value); }
+};
+
+template<>
+struct print_log_value<PathSet>
+{
+	void operator()(std::ostream& _out, PathSet const& _value) { ::operator<<(_out, _value); }
+};
+
+} // namespace boost::test_tools::tt_detail
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(CommandLineInterfaceTest)
+
+BOOST_AUTO_TEST_CASE(help)
+{
+	OptionsReaderAndMessages result = runCLI({"solc", "--help"}, "");
+
+	BOOST_TEST(result.success);
+	BOOST_TEST(boost::starts_with(result.stdoutContent, "solc, the Solidity commandline compiler."));
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::Help);
+}
+
+BOOST_AUTO_TEST_CASE(license)
+{
+	OptionsReaderAndMessages result = runCLI({"solc", "--license"}, "");
+
+	BOOST_TEST(result.success);
+	BOOST_TEST(boost::starts_with(result.stdoutContent, "Most of the code is licensed under GPLv3"));
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::License);
+}
+
+BOOST_AUTO_TEST_CASE(version)
+{
+	OptionsReaderAndMessages result = runCLI({"solc", "--version"}, "");
+
+	BOOST_TEST(result.success);
+	BOOST_TEST(boost::ends_with(result.stdoutContent, "Version: " + solidity::frontend::VersionString + "\n"));
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::Version);
+}
+
+BOOST_AUTO_TEST_CASE(multiple_input_modes)
+{
+	std::array<std::string, 10> inputModeOptions = {
+		"--help",
+		"--license",
+		"--version",
+		"--standard-json",
+		"--link",
+		"--assemble",
+		"--strict-assembly",
+		"--yul",
+		"--import-ast",
+		"--import-asm-json",
+	};
+	std::string expectedMessage =
+		"The following options are mutually exclusive: "
+		"--help, --license, --version, --standard-json, --link, --assemble, --strict-assembly, --yul, --import-ast, --lsp, --import-asm-json. "
+		"Select at most one.";
+
+	for (std::string const& mode1: inputModeOptions)
+		for (std::string const& mode2: inputModeOptions)
+			if (mode1 != mode2)
+				BOOST_CHECK_EXCEPTION(
+					parseCommandLineAndReadInputFiles({"solc", mode1, mode2}),
+					CommandLineValidationError,
+					[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+				);
+}
+
+BOOST_AUTO_TEST_CASE(no_import_callback_allowed_paths)
+{
+	std::array<std::string, 2> options = {
+		"--no-import-callback",
+		"--allow-paths"
+	};
+
+	std::string expectedMessage =
+		"The following options are mutually exclusive: "
+		"--no-import-callback, --allow-paths. "
+		"Select at most one.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", options[0], options[1], "."}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cli_input)
+{
+	TemporaryDirectory tempDir1(TEST_CASE_NAME);
+	TemporaryDirectory tempDir2(TEST_CASE_NAME);
+	createFilesWithParentDirs({tempDir1.path() / "input1.sol"});
+	createFilesWithParentDirs({tempDir2.path() / "input2.sol"});
+
+	boost::filesystem::path expectedRootPath = FileReader::normalizeCLIRootPathForVFS(tempDir1);
+	boost::filesystem::path expectedDir1 = expectedRootPath / tempDir1.path().relative_path();
+	boost::filesystem::path expectedDir2 = expectedRootPath / tempDir2.path().relative_path();
+	soltestAssert(expectedDir1.is_absolute() || expectedDir1.root_path() == "/", "");
+	soltestAssert(expectedDir2.is_absolute() || expectedDir2.root_path() == "/", "");
+
+	std::vector<ImportRemapper::Remapping> expectedRemappings = {
+		{"", "a", "b/c/d"},
+		{"a", "b", "c/d/e/"},
+	};
+	std::map<std::string, std::string> expectedSources = {
+		{"<stdin>", ""},
+		{(expectedDir1 / "input1.sol").generic_string(), ""},
+		{(expectedDir2 / "input2.sol").generic_string(), ""},
+	};
+	PathSet expectedAllowedPaths = {
+		boost::filesystem::canonical(tempDir1),
+		boost::filesystem::canonical(tempDir2),
+		"b/c",
+		"c/d/e",
+	};
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles({
+		"solc",
+		"a=b/c/d",
+		(tempDir1.path() / "input1.sol").string(),
+		(tempDir2.path() / "input2.sol").string(),
+		"a:b=c/d/e/",
+		"-",
+	});
+
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::Compiler);
+	BOOST_TEST(result.options.input.addStdin);
+	BOOST_CHECK_EQUAL(result.options.input.remappings, expectedRemappings);
+	BOOST_CHECK_EQUAL(result.reader.sourceUnits(), expectedSources);
+	BOOST_CHECK_EQUAL(result.reader.allowedDirectories(), expectedAllowedPaths);
+}
+
+BOOST_AUTO_TEST_CASE(cli_ignore_missing_some_files_exist)
+{
+	TemporaryDirectory tempDir1(TEST_CASE_NAME);
+	TemporaryDirectory tempDir2(TEST_CASE_NAME);
+	createFilesWithParentDirs({tempDir1.path() / "input1.sol"});
+
+	boost::filesystem::path expectedRootPath = FileReader::normalizeCLIRootPathForVFS(tempDir1);
+	boost::filesystem::path expectedDir1 = expectedRootPath / tempDir1.path().relative_path();
+	soltestAssert(expectedDir1.is_absolute() || expectedDir1.root_path() == "/", "");
+
+	// NOTE: Allowed paths should not be added for skipped files.
+	std::map<std::string, std::string> expectedSources = {{(expectedDir1 / "input1.sol").generic_string(), ""}};
+	PathSet expectedAllowedPaths = {boost::filesystem::canonical(tempDir1)};
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles({
+		"solc",
+		(tempDir1.path() / "input1.sol").string(),
+		(tempDir2.path() / "input2.sol").string(),
+		"--ignore-missing",
+		"--no-color",
+	});
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "Info: \"" + (tempDir2.path() / "input2.sol").string() + "\" is not found. Skipping.\n");
+	BOOST_TEST(result.options.input.mode == InputMode::Compiler);
+	BOOST_TEST(!result.options.input.addStdin);
+	BOOST_CHECK_EQUAL(result.reader.sourceUnits(), expectedSources);
+	BOOST_CHECK_EQUAL(result.reader.allowedDirectories(), expectedAllowedPaths);
+}
+
+BOOST_AUTO_TEST_CASE(cli_ignore_missing_no_files_exist)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+
+	std::string expectedMessage =
+		"Info: \"" + (tempDir.path() / "input1.sol").string() + "\" is not found. Skipping.\n"
+		"Info: \"" + (tempDir.path() / "input2.sol").string() + "\" is not found. Skipping.\n"
+		"Error: All specified input files either do not exist or are not regular files.\n";
+
+	OptionsReaderAndMessages result = runCLI({
+		"solc",
+		(tempDir.path() / "input1.sol").string(),
+		(tempDir.path() / "input2.sol").string(),
+		"--ignore-missing",
+		"--no-color",
+	});
+	BOOST_TEST(!result.success);
+	BOOST_TEST(result.stderrContent == expectedMessage);
+}
+
+BOOST_AUTO_TEST_CASE(cli_not_a_file)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+
+	std::string expectedMessage = "\"" + tempDir.path().string() + "\" is not a valid file.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", tempDir.path().string()}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_base_path)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir.path().root_path());
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles({
+		"solc",
+		"--standard-json",
+		"--base-path=" + tempDir.path().string(),
+	});
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::StandardJson);
+	BOOST_TEST(result.options.input.addStdin);
+	BOOST_TEST(result.options.input.paths.empty());
+	BOOST_TEST(result.reader.sourceUnits().empty());
+	BOOST_TEST(result.reader.allowedDirectories().empty());
+	BOOST_TEST(result.reader.basePath() == "/" / tempDir.path().relative_path());
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_no_input_file)
+{
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles({"solc", "--standard-json"});
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::StandardJson);
+	BOOST_TEST(result.options.input.addStdin);
+	BOOST_TEST(result.options.input.paths.empty());
+	BOOST_TEST(result.reader.sourceUnits().empty());
+	BOOST_TEST(result.reader.allowedDirectories().empty());
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_dash)
+{
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles({"solc", "--standard-json", "-"});
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::StandardJson);
+	BOOST_TEST(result.options.input.addStdin);
+	BOOST_TEST(result.reader.sourceUnits().empty());
+	BOOST_TEST(result.reader.allowedDirectories().empty());
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_one_input_file)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	createFilesWithParentDirs({tempDir.path() / "input.json"});
+
+	std::vector<std::string> commandLine = {"solc", "--standard-json", (tempDir.path() / "input.json").string()};
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+	BOOST_TEST(result.success);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.options.input.mode == InputMode::StandardJson);
+	BOOST_TEST(!result.options.input.addStdin);
+	BOOST_TEST(result.options.input.paths == PathSet{tempDir.path() / "input.json"});
+	BOOST_TEST(result.reader.allowedDirectories().empty());
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_two_input_files)
+{
+	std::string expectedMessage =
+		"Too many input files for --standard-json.\n"
+		"Please either specify a single file name or provide its content on standard input.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", "--standard-json", "input1.json", "input2.json"}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_one_input_file_and_stdin)
+{
+	std::string expectedMessage =
+		"Too many input files for --standard-json.\n"
+		"Please either specify a single file name or provide its content on standard input.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", "--standard-json", "input1.json", "-"}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_ignore_missing)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+
+	// This option is pretty much useless Standard JSON mode.
+	std::string expectedMessage =
+		"All specified input files either do not exist or are not regular files.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({
+			"solc",
+			"--standard-json",
+			(tempDir.path() / "input.json").string(),
+			"--ignore-missing",
+		}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_remapping)
+{
+	std::string expectedMessage =
+		"Import remappings are not accepted on the command line in Standard JSON mode.\n"
+		"Please put them under 'settings.remappings' in the JSON input.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", "--standard-json", "a=b"}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_no_base_path)
+{
+	TemporaryDirectory tempDirCurrent(TEST_CASE_NAME);
+	TemporaryDirectory tempDirOther(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDirCurrent);
+	soltestAssert(tempDirCurrent.path().is_absolute(), "");
+	soltestAssert(tempDirOther.path().is_absolute(), "");
+
+	// NOTE: On macOS the path usually contains symlinks which prevents base path from being stripped.
+	// Use canonical() to resolve symnlinks and get consistent results on all platforms.
+	boost::filesystem::path currentDirNoSymlinks = boost::filesystem::canonical(tempDirCurrent);
+	boost::filesystem::path otherDirNoSymlinks = boost::filesystem::canonical(tempDirOther);
+
+	boost::filesystem::path expectedOtherDir = "/" / otherDirNoSymlinks.relative_path();
+	soltestAssert(expectedOtherDir.is_absolute() || expectedOtherDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"contract1.sol",                                   // Relative path
+		"c/d/contract2.sol",                               // Relative path with subdirectories
+		currentDirNoSymlinks.string() + "/contract3.sol",  // Absolute path inside working dir
+		otherDirNoSymlinks.string() + "/contract4.sol",    // Absolute path outside of working dir
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"contract1.sol",
+		"c/d/contract2.sol",
+		currentDirNoSymlinks / "contract3.sol",
+		otherDirNoSymlinks / "contract4.sol",
+	};
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{"contract1.sol", ""},
+		{"c/d/contract2.sol", ""},
+		{"contract3.sol", ""},
+		{expectedOtherDir.generic_string() + "/contract4.sol", ""},
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		currentDirNoSymlinks / "c/d",
+		currentDirNoSymlinks,
+		otherDirNoSymlinks,
+	};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == "");
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_base_path_same_as_work_dir)
+{
+	TemporaryDirectory tempDirCurrent(TEST_CASE_NAME);
+	TemporaryDirectory tempDirOther(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDirCurrent);
+	soltestAssert(tempDirCurrent.path().is_absolute(), "");
+	soltestAssert(tempDirOther.path().is_absolute(), "");
+
+	// NOTE: On macOS the path usually contains symlinks which prevents base path from being stripped.
+	// Use canonical() to resolve symnlinks and get consistent results on all platforms.
+	boost::filesystem::path currentDirNoSymlinks = boost::filesystem::canonical(tempDirCurrent);
+	boost::filesystem::path otherDirNoSymlinks = boost::filesystem::canonical(tempDirOther);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	boost::filesystem::path expectedOtherDir = "/" / otherDirNoSymlinks.relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+	soltestAssert(expectedOtherDir.is_absolute() || expectedOtherDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--base-path=" + currentDirNoSymlinks.string(),
+		"contract1.sol",                                   // Relative path
+		"c/d/contract2.sol",                               // Relative path with subdirectories
+		currentDirNoSymlinks.string() + "/contract3.sol",  // Absolute path inside working dir
+		otherDirNoSymlinks.string() + "/contract4.sol",    // Absolute path outside of working dir
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"contract1.sol",
+		"c/d/contract2.sol",
+		currentDirNoSymlinks / "contract3.sol",
+		otherDirNoSymlinks / "contract4.sol",
+	};
+	expectedOptions.input.basePath = currentDirNoSymlinks;
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{"contract1.sol", ""},
+		{"c/d/contract2.sol", ""},
+		{"contract3.sol", ""},
+		{expectedOtherDir.generic_string() + "/contract4.sol", ""},
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		currentDirNoSymlinks / "c/d",
+		currentDirNoSymlinks,
+		otherDirNoSymlinks,
+	};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir);
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_base_path_different_from_work_dir)
+{
+	TemporaryDirectory tempDirCurrent(TEST_CASE_NAME);
+	TemporaryDirectory tempDirOther(TEST_CASE_NAME);
+	TemporaryDirectory tempDirBase(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDirCurrent);
+	soltestAssert(tempDirCurrent.path().is_absolute(), "");
+	soltestAssert(tempDirOther.path().is_absolute(), "");
+	soltestAssert(tempDirBase.path().is_absolute(), "");
+
+	// NOTE: On macOS the path usually contains symlinks which prevents base path from being stripped.
+	// Use canonical() to resolve symnlinks and get consistent results on all platforms.
+	boost::filesystem::path currentDirNoSymlinks = boost::filesystem::canonical(tempDirCurrent);
+	boost::filesystem::path otherDirNoSymlinks = boost::filesystem::canonical(tempDirOther);
+	boost::filesystem::path baseDirNoSymlinks = boost::filesystem::canonical(tempDirBase);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	boost::filesystem::path expectedCurrentDir = "/" / currentDirNoSymlinks.relative_path();
+	boost::filesystem::path expectedOtherDir = "/" / otherDirNoSymlinks.relative_path();
+	boost::filesystem::path expectedBaseDir = "/" / baseDirNoSymlinks.relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+	soltestAssert(expectedCurrentDir.is_absolute() || expectedCurrentDir.root_path() == "/", "");
+	soltestAssert(expectedOtherDir.is_absolute() || expectedOtherDir.root_path() == "/", "");
+	soltestAssert(expectedBaseDir.is_absolute() || expectedBaseDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--base-path=" + baseDirNoSymlinks.string(),
+		"contract1.sol",                                   // Relative path
+		"c/d/contract2.sol",                               // Relative path with subdirectories
+		currentDirNoSymlinks.string() + "/contract3.sol",  // Absolute path inside working dir
+		otherDirNoSymlinks.string() + "/contract4.sol",    // Absolute path outside of working dir
+		baseDirNoSymlinks.string() + "/contract5.sol",     // Absolute path inside base path
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"contract1.sol",
+		"c/d/contract2.sol",
+		currentDirNoSymlinks / "contract3.sol",
+		otherDirNoSymlinks / "contract4.sol",
+		baseDirNoSymlinks / "contract5.sol",
+	};
+	expectedOptions.input.basePath = baseDirNoSymlinks;
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{expectedWorkDir.generic_string() + "/contract1.sol", ""},
+		{expectedWorkDir.generic_string() + "/c/d/contract2.sol", ""},
+		{expectedCurrentDir.generic_string() + "/contract3.sol", ""},
+		{expectedOtherDir.generic_string() + "/contract4.sol", ""},
+		{"contract5.sol", ""},
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		currentDirNoSymlinks / "c/d",
+		currentDirNoSymlinks,
+		otherDirNoSymlinks,
+		baseDirNoSymlinks,
+	};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedBaseDir);
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_relative_base_path)
+{
+	TemporaryDirectory tempDirCurrent(TEST_CASE_NAME);
+	TemporaryDirectory tempDirOther(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDirCurrent);
+	soltestAssert(tempDirCurrent.path().is_absolute(), "");
+	soltestAssert(tempDirOther.path().is_absolute(), "");
+
+	// NOTE: On macOS the path usually contains symlinks which prevents base path from being stripped.
+	// Use canonical() to resolve symnlinks and get consistent results on all platforms.
+	boost::filesystem::path currentDirNoSymlinks = boost::filesystem::canonical(tempDirCurrent);
+	boost::filesystem::path otherDirNoSymlinks = boost::filesystem::canonical(tempDirOther);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	boost::filesystem::path expectedOtherDir = "/" / otherDirNoSymlinks.relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+	soltestAssert(expectedOtherDir.is_absolute() || expectedOtherDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--base-path=base",
+		"contract1.sol",                                       // Relative path outside of base path
+		"base/contract2.sol",                                  // Relative path inside base path
+		currentDirNoSymlinks.string() + "/contract3.sol",      // Absolute path inside working dir
+		currentDirNoSymlinks.string() + "/base/contract4.sol", // Absolute path inside base path
+		otherDirNoSymlinks.string() + "/contract5.sol",        // Absolute path outside of working dir
+		otherDirNoSymlinks.string() + "/base/contract6.sol",   // Absolute path outside of working dir
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"contract1.sol",
+		"base/contract2.sol",
+		currentDirNoSymlinks / "contract3.sol",
+		currentDirNoSymlinks / "base/contract4.sol",
+		otherDirNoSymlinks / "contract5.sol",
+		otherDirNoSymlinks / "base/contract6.sol",
+	};
+	expectedOptions.input.basePath = "base";
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{expectedWorkDir.generic_string() + "/contract1.sol", ""},
+		{"contract2.sol", ""},
+		{expectedWorkDir.generic_string() + "/contract3.sol", ""},
+		{"contract4.sol", ""},
+		{expectedOtherDir.generic_string() + "/contract5.sol", ""},
+		{expectedOtherDir.generic_string() + "/base/contract6.sol", ""},
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		currentDirNoSymlinks / "base",
+		currentDirNoSymlinks,
+		otherDirNoSymlinks,
+		otherDirNoSymlinks / "base",
+	};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "base");
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_normalization_and_weird_names)
+{
+	TemporaryDirectory tempDir({"x/y/z"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir.path() / "x/y/z");
+	soltestAssert(tempDir.path().is_absolute(), "");
+
+	std::string uncPath = "//" + tempDir.path().relative_path().generic_string();
+	soltestAssert(FileReader::isUNCPath(uncPath), "");
+
+	boost::filesystem::path tempDirNoSymlinks = boost::filesystem::canonical(tempDir);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+
+#if !defined(_WIN32)
+		// URLs. We interpret them as local paths.
+		// Note that : is not allowed in file names on Windows.
+		"file://c/d/contract1.sol",
+		"file:///c/d/contract2.sol",
+		"https://example.com/contract3.sol",
+#endif
+
+		// Redundant slashes
+		"a/b//contract4.sol",
+		"a/b///contract5.sol",
+		"a/b////contract6.sol",
+
+		// Dot segments
+		"./a/b/contract7.sol",
+		"././a/b/contract8.sol",
+		"a/./b/contract9.sol",
+		"a/././b/contract10.sol",
+
+		// Dot dot segments
+		"../a/b/contract11.sol",
+		"../../a/b/contract12.sol",
+		"a/../b/contract13.sol",
+		"a/b/../../contract14.sol",
+		tempDirNoSymlinks.string() + "/x/y/z/a/../b/contract15.sol",
+		tempDirNoSymlinks.string() + "/x/y/z/a/b/../../contract16.sol",
+
+		// Dot dot segments going beyond filesystem root
+		"/../" + tempDir.path().relative_path().generic_string() + "/contract17.sol",
+		"/../../" + tempDir.path().relative_path().generic_string() + "/contract18.sol",
+
+#if !defined(_WIN32)
+		// Name conflict with source unit name of stdin.
+		// Note that < and > are not allowed in file names on Windows.
+		"<stdin>",
+
+		// UNC paths on UNIX just resolve into normal paths. On Windows this would be an network
+		// share (and an error unless the share actually exists so I can't test it here).
+		uncPath + "/contract19.sol",
+
+		// Windows paths on non-Windows systems.
+		// Note that on Windows we tested them already just by using absolute paths.
+		"a\\b\\contract20.sol",
+		"C:\\a\\b\\contract21.sol",
+#endif
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+#if !defined(_WIN32)
+		"file://c/d/contract1.sol",
+		"file:///c/d/contract2.sol",
+		"https://example.com/contract3.sol",
+#endif
+
+		"a/b//contract4.sol",
+		"a/b///contract5.sol",
+		"a/b////contract6.sol",
+
+		"./a/b/contract7.sol",
+		"././a/b/contract8.sol",
+		"a/./b/contract9.sol",
+		"a/././b/contract10.sol",
+
+		"../a/b/contract11.sol",
+		"../../a/b/contract12.sol",
+		"a/../b/contract13.sol",
+		"a/b/../../contract14.sol",
+		tempDirNoSymlinks.string() + "/x/y/z/a/../b/contract15.sol",
+		tempDirNoSymlinks.string() + "/x/y/z/a/b/../../contract16.sol",
+
+		"/../" + tempDir.path().relative_path().string() + "/contract17.sol",
+		"/../../" + tempDir.path().relative_path().string() + "/contract18.sol",
+
+#if !defined(_WIN32)
+		"<stdin>",
+
+		uncPath + "/contract19.sol",
+
+		"a\\b\\contract20.sol",
+		"C:\\a\\b\\contract21.sol",
+#endif
+	};
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+#if !defined(_WIN32)
+		{"file:/c/d/contract1.sol", ""},
+		{"file:/c/d/contract2.sol", ""},
+		{"https:/example.com/contract3.sol", ""},
+#endif
+
+		{"a/b/contract4.sol", ""},
+		{"a/b/contract5.sol", ""},
+		{"a/b/contract6.sol", ""},
+
+		{"a/b/contract7.sol", ""},
+		{"a/b/contract8.sol", ""},
+		{"a/b/contract9.sol", ""},
+		{"a/b/contract10.sol", ""},
+
+		{expectedWorkDir.parent_path().generic_string() + "/a/b/contract11.sol", ""},
+		{expectedWorkDir.parent_path().parent_path().generic_string() + "/a/b/contract12.sol", ""},
+		{"b/contract13.sol", ""},
+		{"contract14.sol", ""},
+		{"b/contract15.sol", ""},
+		{"contract16.sol", ""},
+
+		{"/" + tempDir.path().relative_path().generic_string() + "/contract17.sol", ""},
+		{"/" + tempDir.path().relative_path().generic_string() + "/contract18.sol", ""},
+
+#if !defined(_WIN32)
+		{"<stdin>", ""},
+
+		{uncPath + "/contract19.sol", ""},
+
+		{"a\\b\\contract20.sol", ""},
+		{"C:\\a\\b\\contract21.sol", ""},
+#endif
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+#if !defined(_WIN32)
+		tempDirNoSymlinks / "x/y/z/file:/c/d",
+		tempDirNoSymlinks / "x/y/z/https:/example.com",
+#endif
+		tempDirNoSymlinks / "x/y/z/a/b",
+		tempDirNoSymlinks / "x/y/z",
+		tempDirNoSymlinks / "x/y/z/b",
+		tempDirNoSymlinks / "x/y/a/b",
+		tempDirNoSymlinks / "x/a/b",
+		tempDirNoSymlinks,
+#if !defined(_WIN32)
+		boost::filesystem::canonical(uncPath),
+#endif
+	};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedOptions.input.basePath);
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_symlinks)
+{
+	TemporaryDirectory tempDir({"r/"}, TEST_CASE_NAME);
+	createFilesWithParentDirs({tempDir.path() / "x/y/z/contract.sol"});
+	TemporaryWorkingDirectory tempWorkDir(tempDir.path() / "r");
+
+	if (
+		!createSymlinkIfSupportedByFilesystem("../x/y", tempDir.path() / "r/sym", true) ||
+		!createSymlinkIfSupportedByFilesystem("contract.sol", tempDir.path() / "x/y/z/contract_symlink.sol", false)
+	)
+		return;
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+	soltestAssert(expectedWorkDir.is_absolute() || expectedWorkDir.root_path() == "/", "");
+
+	std::vector<std::string> commandLine = {
+		"solc",
+
+		"--base-path=../r/sym/z/",
+		"sym/z/contract.sol",            // File accessed directly + same dir symlink as base path
+		"../x/y/z/contract.sol",         // File accessed directly + different dir symlink than base path
+		"sym/z/contract_symlink.sol",    // File accessed via symlink + same dir symlink as base path
+		"../x/y/z/contract_symlink.sol", // File accessed via symlink + different dir symlink than base path
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"sym/z/contract.sol",
+		"../x/y/z/contract.sol",
+		"sym/z/contract_symlink.sol",
+		"../x/y/z/contract_symlink.sol",
+	};
+	expectedOptions.input.basePath = "../r/sym/z/";
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{"contract.sol", ""},
+		{(expectedWorkDir.parent_path() / "x/y/z/contract.sol").generic_string(), ""},
+		{"contract_symlink.sol", ""},
+		{(expectedWorkDir.parent_path() / "x/y/z/contract_symlink.sol").generic_string(), ""},
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		boost::filesystem::canonical(tempDir) / "x/y/z",
+	};
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "sym/z/");
+}
+
+BOOST_AUTO_TEST_CASE(cli_paths_to_source_unit_names_base_path_and_stdin)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+	boost::filesystem::create_directories(tempDir.path() / "base");
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::current_path().relative_path();
+
+	std::vector<std::string> commandLine = {"solc", "--base-path=base", "-"};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.addStdin = true;
+	expectedOptions.input.basePath = "base";
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{"<stdin>", ""},
+	};
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {};
+
+	createFilesWithParentDirs(expectedOptions.input.paths);
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_TEST(result.stdoutContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "base");
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths)
+{
+	TemporaryDirectory tempDir({"base/", "include/", "lib/nested/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	std::string const mainContractSource = withPreamble(
+		"import \"contract.sol\";\n"
+		"import \"contract_via_callback.sol\";\n"
+		"import \"include.sol\";\n"
+		"import \"include_via_callback.sol\";\n"
+		"import \"nested.sol\";\n"
+		"import \"nested_via_callback.sol\";\n"
+		"import \"lib.sol\";\n"
+		"import \"lib_via_callback.sol\";\n"
+	);
+
+	std::string const onlyPreamble = withPreamble("");
+	createFilesWithParentDirs(
+		{
+			tempDir.path() / "base/contract.sol",
+			tempDir.path() / "base/contract_via_callback.sol",
+			tempDir.path() / "include/include.sol",
+			tempDir.path() / "include/include_via_callback.sol",
+			tempDir.path() / "lib/nested/nested.sol",
+			tempDir.path() / "lib/nested/nested_via_callback.sol",
+			tempDir.path() / "lib/lib.sol",
+			tempDir.path() / "lib/lib_via_callback.sol",
+		},
+		onlyPreamble
+	);
+	createFilesWithParentDirs({tempDir.path() / "base/main.sol"}, mainContractSource);
+
+	boost::filesystem::path canonicalWorkDir = boost::filesystem::canonical(tempDir);
+	boost::filesystem::path expectedWorkDir = "/" / canonicalWorkDir.relative_path();
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--no-color",
+		"--base-path=base/",
+		"--include-path=include/",
+		"--include-path=lib/nested",
+		"--include-path=lib/",
+		"base/main.sol",
+		"base/contract.sol",
+		"include/include.sol",
+		"lib/nested/nested.sol",
+		"lib/lib.sol",
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {
+		"base/main.sol",
+		"base/contract.sol",
+		"include/include.sol",
+		"lib/nested/nested.sol",
+		"lib/lib.sol",
+	};
+	expectedOptions.input.basePath = "base/";
+	expectedOptions.input.includePaths = {
+		"include/",
+		"lib/nested",
+		"lib/",
+	};
+	expectedOptions.formatting.coloredOutput = false;
+	expectedOptions.modelChecker.initialize = true;
+
+	std::map<std::string, std::string> expectedSources = {
+		{"main.sol", mainContractSource},
+		{"contract.sol", onlyPreamble},
+		{"contract_via_callback.sol", onlyPreamble},
+		{"include.sol", onlyPreamble},
+		{"include_via_callback.sol", onlyPreamble},
+		{"nested.sol", onlyPreamble},
+		{"nested_via_callback.sol", onlyPreamble},
+		{"lib.sol", onlyPreamble},
+		{"lib_via_callback.sol", onlyPreamble},
+	};
+
+	std::vector<boost::filesystem::path> expectedIncludePaths = {
+		expectedWorkDir / "include/",
+		expectedWorkDir / "lib/nested",
+		expectedWorkDir / "lib/",
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {
+		canonicalWorkDir / "base",
+		canonicalWorkDir / "include",
+		canonicalWorkDir / "lib/nested",
+		canonicalWorkDir / "lib",
+	};
+
+	std::string const expectedStdoutContent = "Compiler run successful. No contracts to compile.\n";
+	OptionsReaderAndMessages result = runCLI(commandLine, "");
+
+	BOOST_TEST(result.stderrContent == "");
+	if (SemVerVersion{std::string(VersionString)}.isPrerelease())
+		BOOST_TEST(result.stdoutContent == "");
+	else
+		BOOST_TEST(result.stdoutContent == expectedStdoutContent);
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.includePaths() == expectedIncludePaths);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "base/");
+}
+
+BOOST_AUTO_TEST_CASE(cli_no_contracts_to_compile)
+{
+	std::string const contractSource = R"(
+		// SPDX-License-Identifier: GPL-3.0
+		pragma solidity >=0.0;
+		enum Status { test }
+	)";
+
+	std::string const expectedStdoutContent = "Compiler run successful. No contracts to compile.\n";
+	OptionsReaderAndMessages result = runCLI({"solc", "-"}, contractSource);
+
+	if (SemVerVersion{std::string(VersionString)}.isPrerelease())
+		BOOST_TEST(result.stdoutContent == "");
+	else
+		BOOST_TEST(result.stdoutContent == expectedStdoutContent);
+	BOOST_REQUIRE(result.success);
+}
+
+BOOST_AUTO_TEST_CASE(cli_no_output)
+{
+	std::string const contractSource = R"(
+		// SPDX-License-Identifier: GPL-3.0
+		pragma solidity >=0.0;
+		abstract contract A {
+			function B() public virtual returns(uint);
+		})";
+
+	std::string const expectedStdoutContent = "Compiler run successful. No output generated.\n";
+	OptionsReaderAndMessages result = runCLI({"solc", "-"}, contractSource);
+
+	if (SemVerVersion{std::string(VersionString)}.isPrerelease())
+		BOOST_TEST(result.stdoutContent == "");
+	else
+		BOOST_TEST(result.stdoutContent == expectedStdoutContent);
+	BOOST_REQUIRE(result.success);
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_include_paths)
+{
+	TemporaryDirectory tempDir({"base/", "include/", "lib/nested/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	std::string const mainContractSource = withPreamble(
+		"import 'contract_via_callback.sol';\n"
+		"import 'include_via_callback.sol';\n"
+		"import 'nested_via_callback.sol';\n"
+		"import 'lib_via_callback.sol';\n"
+	);
+
+	std::string const standardJsonInput = R"(
+		{
+			"language": "Solidity",
+			"sources": {
+				"main.sol": {"content": ")" + mainContractSource + R"("}
+			}
+		}
+	)";
+
+	std::string const onlyPreamble = withPreamble("");
+	createFilesWithParentDirs(
+		{
+			tempDir.path() / "base/contract_via_callback.sol",
+			tempDir.path() / "include/include_via_callback.sol",
+			tempDir.path() / "lib/nested/nested_via_callback.sol",
+			tempDir.path() / "lib/lib_via_callback.sol",
+		},
+		onlyPreamble
+	);
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::canonical(tempDir).relative_path();
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--base-path=base/",
+		"--include-path=include/",
+		"--include-path=lib/nested",
+		"--include-path=lib/",
+		"--standard-json",
+	};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.mode = InputMode::StandardJson;
+	expectedOptions.input.paths = {};
+	expectedOptions.input.addStdin = true;
+	expectedOptions.input.basePath = "base/";
+	expectedOptions.input.includePaths = {
+		"include/",
+		"lib/nested",
+		"lib/",
+	};
+	expectedOptions.modelChecker.initialize = false;
+
+	// NOTE: Source code from Standard JSON does not end up in FileReader. This is not a problem
+	// because FileReader is only used once to initialize the compiler stack and after that
+	// its sources are irrelevant (even though the callback still stores everything it loads).
+	std::map<std::string, std::string> expectedSources = {
+		{"contract_via_callback.sol", onlyPreamble},
+		{"include_via_callback.sol", onlyPreamble},
+		{"nested_via_callback.sol", onlyPreamble},
+		{"lib_via_callback.sol", onlyPreamble},
+	};
+
+	std::vector<boost::filesystem::path> expectedIncludePaths = {
+		expectedWorkDir / "include/",
+		expectedWorkDir / "lib/nested",
+		expectedWorkDir / "lib/",
+	};
+
+	FileReader::FileSystemPathSet expectedAllowedDirectories = {};
+
+	OptionsReaderAndMessages result = runCLI(commandLine, standardJsonInput);
+
+	Json::Value parsedStdout;
+	std::string jsonParsingErrors;
+	BOOST_TEST(util::jsonParseStrict(result.stdoutContent, parsedStdout, &jsonParsingErrors));
+	BOOST_TEST(jsonParsingErrors == "");
+	for (Json::Value const& errorDict: parsedStdout["errors"])
+		// The error list might contain pre-release compiler warning
+		BOOST_TEST(errorDict["severity"] != "error");
+	BOOST_TEST(
+		(parsedStdout["sources"].getMemberNames() | ranges::to<std::set>) ==
+		(expectedSources | ranges::views::keys | ranges::to<std::set>) + std::set<std::string>{"main.sol"}
+	);
+
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.options == expectedOptions);
+	BOOST_TEST(result.reader.sourceUnits() == expectedSources);
+	BOOST_TEST(result.reader.includePaths() == expectedIncludePaths);
+	BOOST_TEST(result.reader.allowedDirectories() == expectedAllowedDirectories);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "base/");
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths_empty_path)
+{
+	TemporaryDirectory tempDir({"base/", "include/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+	createFilesWithParentDirs({tempDir.path() / "base/main.sol"});
+
+	std::string expectedMessage = "Empty values are not allowed in --include-path.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({
+			"solc",
+			"--base-path=base/",
+			"--include-path", "include/",
+			"--include-path", "",
+			"base/main.sol",
+		}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths_without_base_path)
+{
+	TemporaryDirectory tempDir(TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+	createFilesWithParentDirs({tempDir.path() / "contract.sol"});
+
+	std::string expectedMessage = "--include-path option requires a non-empty base path.";
+
+	BOOST_CHECK_EXCEPTION(
+		parseCommandLineAndReadInputFiles({"solc", "--include-path", "include/", "contract.sol"}),
+		CommandLineValidationError,
+		[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+	);
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths_should_detect_source_unit_name_collisions)
+{
+	TemporaryDirectory tempDir({"dir1/", "dir2/", "dir3/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+	createFilesWithParentDirs({
+		"dir1/contract1.sol",
+		"dir1/contract2.sol",
+		"dir2/contract1.sol",
+		"dir2/contract2.sol",
+	});
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::canonical(tempDir).relative_path();
+
+	std::string expectedMessage =
+		"Source unit name collision detected. "
+		"The specified values of base path and/or include paths would result in multiple "
+		"input files being assigned the same source unit name:\n"
+		"contract1.sol matches: "
+		"\"" + (expectedWorkDir / "dir1/contract1.sol").generic_string() + "\", "
+		"\"" + (expectedWorkDir / "dir2/contract1.sol").generic_string() + "\"\n"
+		"contract2.sol matches: "
+		"\"" + (expectedWorkDir / "dir1/contract2.sol").generic_string() + "\", "
+		"\"" + (expectedWorkDir / "dir2/contract2.sol").generic_string() + "\"\n";
+
+	{
+		// import "contract1.sol" and import "contract2.sol" would be ambiguous:
+		BOOST_CHECK_EXCEPTION(
+			parseCommandLineAndReadInputFiles({
+				"solc",
+				"--base-path=dir1/",
+				"--include-path=dir2/",
+				"dir1/contract1.sol",
+				"dir2/contract1.sol",
+				"dir1/contract2.sol",
+				"dir2/contract2.sol",
+			}),
+			CommandLineValidationError,
+			[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+		);
+	}
+
+	{
+		// import "contract1.sol" and import "contract2.sol" would be ambiguous:
+		BOOST_CHECK_EXCEPTION(
+			parseCommandLineAndReadInputFiles({
+				"solc",
+				"--base-path=dir3/",
+				"--include-path=dir1/",
+				"--include-path=dir2/",
+				"dir1/contract1.sol",
+				"dir2/contract1.sol",
+				"dir1/contract2.sol",
+				"dir2/contract2.sol",
+			}),
+			CommandLineValidationError,
+			[&](auto const& _exception) { BOOST_TEST(_exception.what() == expectedMessage); return true; }
+		);
+	}
+
+	{
+		// No conflict if files with the same name exist but only one is given to the compiler.
+		std::vector<std::string> commandLine = {
+			"solc",
+			"--base-path=dir3/",
+			"--include-path=dir1/",
+			"--include-path=dir2/",
+			"dir1/contract1.sol",
+			"dir1/contract2.sol",
+		};
+		OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+		BOOST_TEST(result.stderrContent == "");
+		BOOST_REQUIRE(result.success);
+	}
+
+	{
+		// The same file specified multiple times is not a conflict.
+		std::vector<std::string> commandLine = {
+			"solc",
+			"--base-path=dir3/",
+			"--include-path=dir1/",
+			"--include-path=dir2/",
+			"dir1/contract1.sol",
+			"dir1/contract1.sol",
+			"./dir1/contract1.sol",
+		};
+		OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+		BOOST_TEST(result.stderrContent == "");
+		BOOST_REQUIRE(result.success);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths_should_allow_duplicate_paths)
+{
+	TemporaryDirectory tempDir({"dir1/", "dir2/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+	createFilesWithParentDirs({"dir1/contract.sol"});
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::canonical(tempDir).relative_path();
+	boost::filesystem::path expectedTempDir = "/" / tempDir.path().relative_path();
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--base-path=dir1/",
+		"--include-path", "dir1",
+		"--include-path", "dir1",
+		"--include-path", "dir1/",
+		"--include-path", "dir1/",
+		"--include-path", "./dir1/",
+		"--include-path", "dir2/../dir1/",
+		"--include-path", (tempDir.path() / "dir1/").string(),
+		"--include-path", (expectedWorkDir / "dir1/").string(),
+		"--include-path", "dir1/",
+		"dir1/contract.sol",
+	};
+
+	// Duplicates do not affect the result but are not removed from the include path list.
+	std::vector<boost::filesystem::path> expectedIncludePaths = {
+		expectedWorkDir / "dir1",
+		expectedWorkDir / "dir1",
+		expectedWorkDir / "dir1/",
+		expectedWorkDir / "dir1/",
+		expectedWorkDir / "dir1/",
+		expectedWorkDir / "dir1/",
+		// NOTE: On macOS expectedTempDir usually contains a symlink and therefore for us it's
+		// different from expectedWorkDir.
+		expectedTempDir / "dir1/",
+		expectedWorkDir / "dir1/",
+		expectedWorkDir / "dir1/",
+	};
+
+	OptionsReaderAndMessages result = parseCommandLineAndReadInputFiles(commandLine);
+	BOOST_TEST(result.stderrContent == "");
+	BOOST_REQUIRE(result.success);
+	BOOST_TEST(result.reader.includePaths() == expectedIncludePaths);
+	BOOST_TEST(result.reader.basePath() == expectedWorkDir / "dir1/");
+}
+
+BOOST_AUTO_TEST_CASE(cli_include_paths_ambiguous_import)
+{
+	TemporaryDirectory tempDir({"base/", "include/"}, TEST_CASE_NAME);
+	TemporaryWorkingDirectory tempWorkDir(tempDir);
+
+	// Ambiguous: both base/contract.sol and include/contract.sol match the import.
+	std::string const mainContractSource = withPreamble("import \"contract.sol\";");
+
+	createFilesWithParentDirs({"base/contract.sol", "include/contract.sol"}, withPreamble(""));
+
+	boost::filesystem::path expectedWorkDir = "/" / boost::filesystem::canonical(tempDir).relative_path();
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"--no-color",
+		"--base-path=base/",
+		"--include-path=include/",
+		"-",
+	};
+
+	std::string expectedMessage =
+		"Error: Source \"contract.sol\" not found: Ambiguous import. "
+		"Multiple matching files found inside base path and/or include paths: \"" +
+		(expectedWorkDir / "base/contract.sol").generic_string() + "\", \"" +
+		(expectedWorkDir / "include/contract.sol").generic_string() + "\".\n"
+		" --> <stdin>:3:1:\n"
+		"  |\n"
+		"3 | import \"contract.sol\";\n"
+		"  | ^^^^^^^^^^^^^^^^^^^^^^\n\n";
+
+	OptionsReaderAndMessages result = runCLI(commandLine, mainContractSource);
+	BOOST_TEST(result.stderrContent == expectedMessage);
+	BOOST_REQUIRE(!result.success);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/solc/CommandLineInterfaceAllowPaths.cpp b/compiler/test/solc/CommandLineInterfaceAllowPaths.cpp
new file mode 100644
index 00000000..4fe603a4
--- /dev/null
+++ b/compiler/test/solc/CommandLineInterfaceAllowPaths.cpp
@@ -0,0 +1,570 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for solc/CommandLineInterface.h
+
+#include <solc/CommandLineInterface.h>
+
+#include <test/solc/Common.h>
+
+#include <test/Common.h>
+#include <test/FilesystemUtils.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <fstream>
+#include <regex>
+#include <string>
+#include <vector>
+
+using namespace solidity::frontend;
+using namespace solidity::util;
+using namespace solidity::test;
+
+#define TEST_CASE_NAME (boost::unit_test::framework::current_test_case().p_name)
+
+namespace
+{
+
+struct ImportCheck
+{
+	enum class Result
+	{
+		Unknown,        ///< Status is unknown due to a failure of the status check.
+		OK,             ///< Passed compilation without errors.
+		FileNotFound,   ///< Error was reported: file not found.
+		PathDisallowed, ///< Error was reported: file not allowed paths.
+	};
+
+	bool operator==(ImportCheck const& _other) const { return result == _other.result && message == _other.message; }
+	bool operator!=(ImportCheck const& _other) const { return !(*this == _other); }
+
+	operator bool() const { return this->result == Result::OK; }
+
+	static ImportCheck const OK() { return {Result::OK, ""}; }
+	static ImportCheck const FileNotFound() { return {Result::FileNotFound, ""}; }
+	static ImportCheck const PathDisallowed() { return {Result::PathDisallowed, ""}; }
+	static ImportCheck const Unknown(const std::string& _message) { return {Result::Unknown, _message}; }
+
+	Result result;
+	std::string message;
+};
+
+ImportCheck checkImport(
+	std::string const& _import,
+	std::vector<std::string> const& _cliOptions
+)
+{
+	soltestAssert(regex_match(_import, std::regex{R"(import '[^']*')"}), "");
+	for (std::string const& option: _cliOptions)
+		soltestAssert(
+			boost::starts_with(option, "--base-path") ||
+			boost::starts_with(option, "--include-path") ||
+			boost::starts_with(option, "--allow-paths") ||
+			!boost::starts_with(option, "--"),
+			""
+		);
+
+	std::vector<std::string> commandLine = {
+		"solc",
+		"-",
+		"--no-color",
+		"--error-codes",
+	};
+	commandLine += _cliOptions;
+
+	std::string standardInputContent =
+		"// SPDX-License-Identifier: GPL-3.0\n"
+		"pragma solidity >=0.0;\n" +
+		_import + ";";
+
+	test::OptionsReaderAndMessages cliResult = test::runCLI(commandLine, standardInputContent);
+	if (cliResult.success)
+		return ImportCheck::OK();
+
+	static std::regex const sourceNotFoundErrorRegex{
+		R"(^Error \(6275\): Source "[^"]+" not found: (.*)\.\n)"
+		R"(\s*--> .*<stdin>:\d+:\d+:\n)"
+		R"(\s*\|\n)"
+		R"(\d+\s*\| import '.+';\n)"
+		R"(\s*\| \^+\n\s*$)"
+	};
+
+	std::smatch submatches;
+	if (!regex_match(cliResult.stderrContent, submatches, sourceNotFoundErrorRegex))
+		return ImportCheck::Unknown("Unexpected stderr content: '" + cliResult.stderrContent + "'");
+	if (submatches[1] != "File not found" && !boost::starts_with(std::string(submatches[1]), "File outside of allowed directories"))
+		return ImportCheck::Unknown("Unexpected error message: '" + cliResult.stderrContent + "'");
+
+	if (submatches[1] == "File not found")
+		return ImportCheck::FileNotFound();
+	else if (boost::starts_with(std::string(submatches[1]), "File outside of allowed directories"))
+		return ImportCheck::PathDisallowed();
+	else
+		return ImportCheck::Unknown("Unexpected error message '" + submatches[1].str() + "'");
+}
+
+class AllowPathsFixture
+{
+protected:
+	AllowPathsFixture():
+		m_tempDir({"code/", "work/"}, TEST_CASE_NAME),
+		m_tempWorkDir(m_tempDir.path() / "work"),
+		m_codeDir(m_tempDir.path() / "code"),
+		m_workDir(m_tempDir.path() / "work"),
+		m_portablePrefix(("/" / boost::filesystem::canonical(m_codeDir).relative_path()).generic_string())
+	{
+		createFilesWithParentDirs(
+			{
+				m_codeDir / "a/b/c/d.sol",
+				m_codeDir / "a/b/c.sol",
+				m_codeDir / "a/b/X.sol",
+				m_codeDir / "a/X/c.sol",
+				m_codeDir / "X/b/c.sol",
+
+				m_codeDir / "a/bc/d.sol",
+				m_codeDir / "X/bc/d.sol",
+
+				m_codeDir / "x/y/z.sol",
+				m_codeDir / "1/2/3.sol",
+				m_codeDir / "contract.sol",
+
+				m_workDir / "a/b/c/d.sol",
+				m_workDir / "a/b/c.sol",
+				m_workDir / "a/b/X.sol",
+				m_workDir / "a/X/c.sol",
+				m_workDir / "X/b/c.sol",
+
+				m_workDir / "contract.sol",
+			},
+			"// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.0;"
+		);
+
+		if (
+			!createSymlinkIfSupportedByFilesystem("b", m_codeDir / "a/b_sym", true) ||
+			!createSymlinkIfSupportedByFilesystem("../x/y", m_codeDir / "a/y_sym", true) ||
+			!createSymlinkIfSupportedByFilesystem("../../a/b/c.sol", m_codeDir / "a/b/c_sym.sol", false) ||
+			!createSymlinkIfSupportedByFilesystem("../../x/y/z.sol", m_codeDir / "a/b/z_sym.sol", false)
+		)
+			return;
+
+		m_caseSensitiveFilesystem = boost::filesystem::create_directories(m_codeDir / "A/B/C");
+		soltestAssert(boost::filesystem::equivalent(m_codeDir / "a/b/c", m_codeDir / "A/B/C") != m_caseSensitiveFilesystem, "");
+	}
+
+	TemporaryDirectory m_tempDir;
+	TemporaryWorkingDirectory m_tempWorkDir;
+	boost::filesystem::path const m_codeDir;
+	boost::filesystem::path const m_workDir;
+	std::string m_portablePrefix;
+	bool m_caseSensitiveFilesystem = true;
+};
+
+std::ostream& operator<<(std::ostream& _out, ImportCheck const& _value)
+{
+	switch (_value.result)
+	{
+	case ImportCheck::Result::Unknown: _out << "Unknown"; break;
+	case ImportCheck::Result::OK: _out << "OK"; break;
+	case ImportCheck::Result::FileNotFound: _out << "FileNotFound"; break;
+	case ImportCheck::Result::PathDisallowed: _out << "PathDisallowed"; break;
+	}
+	if (_value.message != "")
+		_out << "(" << _value.message << ")";
+	return _out;
+}
+
+} // namespace
+
+namespace boost::test_tools::tt_detail
+{
+
+// Boost won't find the << operator unless we put it in the std namespace which is illegal.
+// The recommended solution is to overload print_log_value<> struct and make it use our operator.
+
+template<>
+struct print_log_value<ImportCheck>
+{
+	void operator()(std::ostream& _out, ImportCheck const& _value) { ::operator<<(_out, _value); }
+};
+
+} // namespace boost::test_tools::tt_detail
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(CommandLineInterfaceAllowPathsTest)
+
+BOOST_FIXTURE_TEST_CASE(allow_path_multiple_paths, AllowPathsFixture)
+{
+	std::string allowedPaths =
+		m_codeDir.generic_string() + "/a/b/X.sol," +
+		m_codeDir.generic_string() + "/X/," +
+		m_codeDir.generic_string() + "/z," +
+		m_codeDir.generic_string() + "/a/b";
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", allowedPaths}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"--allow-paths", allowedPaths}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"--allow-paths", allowedPaths}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"--allow-paths", allowedPaths}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_should_work_with_various_path_forms, AllowPathsFixture)
+{
+	std::string import = "import '" + m_portablePrefix + "/a/b/c.sol'";
+
+	// Without --allow-path
+	BOOST_TEST(checkImport(import, {}) == ImportCheck::PathDisallowed());
+
+	// Absolute paths allowed
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string()}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string() + "/a/"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string() + "/a/b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string() + "/a/b/c.sol"}));
+
+	// Relative paths allowed
+	BOOST_TEST(checkImport(import, {"--allow-paths=../code/a"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=../code/a/"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=../code/a/b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=../code/a/b/c.sol"}));
+
+	// Non-normalized paths allowed
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/."}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/./"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/.."}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/../"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/./b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/../a/b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a///b"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/b//"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths", "./../code/a/b///"}));
+
+	// Root path allowed
+	BOOST_TEST(checkImport(import, {"--allow-paths=/"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=///"}));
+
+	// UNC paths should be treated differently from normal paths
+	soltestAssert(FileReader::isUNCPath("/" + m_portablePrefix), "");
+	BOOST_TEST(checkImport(import, {"--allow-paths=//"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport(import, {"--allow-paths=/" + m_portablePrefix}) == ImportCheck::PathDisallowed());
+
+	// Paths going beyond root allowed
+	BOOST_TEST(checkImport(import, {"--allow-paths=/../../"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=/../.."}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=/../../a/../"}));
+	BOOST_TEST(checkImport(import, {"--allow-paths=/../../" + m_portablePrefix}));
+
+	// File named like a directory
+	BOOST_TEST(checkImport(import, {"--allow-paths", m_codeDir.string() + "/a/b/c.sol/"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_should_handle_empty_paths, AllowPathsFixture)
+{
+	// Work dir is base path
+	BOOST_TEST(checkImport("import 'a/../../work/a/b/c.sol'", {"--allow-paths", ""}));
+	BOOST_TEST(checkImport("import 'a/../../work/a/b/c.sol'", {"--allow-paths", "x,,y"}));
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/c.sol'", {"--allow-paths", ""}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/c.sol'", {"--allow-paths", "x,,y"}) == ImportCheck::PathDisallowed());
+
+	// Work dir is not base path
+	BOOST_TEST(checkImport("import 'a/../../work/a/b/c.sol'", {"--allow-paths", "", "--base-path=../code/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'a/../../work/a/b/c.sol'", {"--allow-paths", "x,,y", "--base-path=../code/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/c.sol'", {"--allow-paths", "", "--base-path=../code/"}));
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/c.sol'", {"--allow-paths", "x,,y", "--base-path=../code/"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_case_sensitive, AllowPathsFixture)
+{
+	// Allowed paths are case-sensitive even on case-insensitive filesystems
+	BOOST_TEST(
+		checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", m_codeDir.string() + "/A/B/"}) ==
+		ImportCheck::PathDisallowed()
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_should_work_with_various_import_forms, AllowPathsFixture)
+{
+	// Absolute import paths
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"--allow-paths", "../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", "../code/a/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"--allow-paths", "../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"--allow-paths", "../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"--allow-paths", "../code/a/b/"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", "../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"--allow-paths", "../code/a/b"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"--allow-paths", "../code/a/b"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"--allow-paths", "../code/a/b"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths", "../code/a"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"--allow-paths", "../code/a"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"--allow-paths", "../code/a"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"--allow-paths", "../code/a"}));
+
+	// Relative import paths
+	// NOTE: Base path is whitelisted by default so we need the 'a/../../code/' part to get
+	// outside of it. And it can't be just '../code/' because that would not be a direct import.
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/c.sol'", {"--allow-paths", "../code/a/b"}));
+	BOOST_TEST(checkImport("import 'a/../../code/X/b/c.sol'", {"--allow-paths", "../code/a/b"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'a/../../code/a/X/c.sol'", {"--allow-paths", "../code/a/b"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'a/../../code/a/b/X.sol'", {"--allow-paths", "../code/a/b"}));
+
+	// Non-normalized relative import paths
+	BOOST_TEST(checkImport("import 'a/../../code/a/./b/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import 'a/../../code/a/../a/b/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import 'a/../../code/a///b/c.sol'", {"--allow-paths", "../code/a/b/c.sol"}));
+
+#if !defined(_WIN32)
+	// UNC paths in imports.
+	// Unfortunately can't test it on Windows without having an existing UNC path. On Linux we can
+	// at least rely on the fact that `//` works like `/`.
+	std::string uncImportPath = "/" + m_portablePrefix + "/a/b/c.sol";
+	soltestAssert(FileReader::isUNCPath(uncImportPath), "");
+	BOOST_TEST(checkImport("import '" + uncImportPath + "'", {"--allow-paths", "../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+#endif
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_automatic_whitelisting_input_files, AllowPathsFixture)
+{
+	// By default none of the files is whitelisted
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c/d.sol'", {}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {}) == ImportCheck::PathDisallowed());
+
+	// Compiling a file whitelists its directory and subdirectories
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {m_codeDir.string() + "/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c/d.sol'", {m_codeDir.string() + "/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {m_codeDir.string() + "/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {m_codeDir.string() + "/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {m_codeDir.string() + "/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {m_codeDir.string() + "/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+
+	// If only file name is specified, its parent dir path is empty. This should be equivalent to
+	// whitelisting the work dir.
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/contract.sol'", {"contract.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'contract.sol'", {"contract.sol"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_automatic_whitelisting_remappings, AllowPathsFixture)
+{
+	// Adding a remapping whitelists target's parent directory and subdirectories
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c/d.sol'", {"x=../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"x=../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {"x=../code/a/b/c.sol"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=/contract.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=/contract.sol/"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {m_portablePrefix + "/a/b=../code/X/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {m_portablePrefix + "/a/b/=../code/X/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {m_portablePrefix + "/a/b=../code/X/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {m_portablePrefix + "/a/b/=../code/X/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {m_portablePrefix + "/a/b:y/z=x/w"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {m_portablePrefix + "/a/b:y/z=x/w"}) == ImportCheck::PathDisallowed());
+
+	// Adding a remapping whitelists the target and subdirectories when the target is a directory
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c/d.sol'", {"x=../code/a/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"x=../code/a/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {"x=../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {"x=../code/a/c/"}) == ImportCheck::PathDisallowed());
+
+	// Adding a remapping whitelists target's parent directory and subdirectories when the target
+	// is a directory but does not have a trailing slash
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c/d.sol'", {"x=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/X.sol'", {"x=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {"x=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/bc/d.sol'", {"x=../code/a/c"}));
+
+	// Adding a remapping to a relative target at VFS root whitelists the work dir
+	BOOST_TEST(checkImport("import '/../../x/y/z.sol'", {"x=contract.sol", "--base-path=../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '/../../../work/a/b/c.sol'", {"x=contract.sol", "--base-path=../code/a/b/"}));
+
+	BOOST_TEST(checkImport("import '/../../x/y/z.sol'", {"x=contract.sol/", "--base-path=../code/a/b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '/../../../work/a/b/c.sol'", {"x=contract.sol/", "--base-path=../code/a/b/"}) == ImportCheck::PathDisallowed());
+
+	// Adding a remapping with an empty target does not whitelist anything
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + m_portablePrefix + "/a/b/c.sol'", {m_portablePrefix + "="}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"../code/="}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '/../work/a/b/c.sol'", {"../code/=", "--base-path", m_portablePrefix}) == ImportCheck::PathDisallowed());
+
+	// Adding a remapping that includes .. or . segments whitelists the parent dir and subdirectories
+	// of the resolved target
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=."}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=."}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=./"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=./"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=.."}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=.."}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/./.."}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/./.."}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/./.."}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/./../"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/./../"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/./../"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/./../b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/./../b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/./../b"}) == ImportCheck::PathDisallowed());
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"x=../code/a/b/./../b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/X/c.sol'", {"x=../code/a/b/./../b/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/X/b/c.sol'", {"x=../code/a/b/./../b/"}) == ImportCheck::PathDisallowed());
+
+	// If the target is just a file name, its parent dir path is empty. This should be equivalent to
+	// whitelisting the work dir.
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/contract.sol'", {"x=contract.sol"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import 'contract.sol'", {"x=contract.sol"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_automatic_whitelisting_base_path, AllowPathsFixture)
+{
+	// Relative base path whitelists its content
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path=../code/a"}));
+
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path=../code/a/"}));
+
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {"--base-path=../code/."}));
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {"--base-path=../code/./"}));
+	BOOST_TEST(checkImport("import 'code/a/b/c.sol'", {"--base-path=.."}));
+	BOOST_TEST(checkImport("import 'code/a/b/c.sol'", {"--base-path=../"}));
+
+	// Absolute base path whitelists its content
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path", m_codeDir.string() + "/a"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_automatic_whitelisting_work_dir, AllowPathsFixture)
+{
+	// Work dir is only automatically whitelisted if it matches base path
+	BOOST_TEST(checkImport("import 'b/../../../work/a/b/c.sol'", {"--base-path=../code/a/"}) == ImportCheck::PathDisallowed());
+
+	// Compiling a file in the work dir whitelists it even if it's not in base path
+	BOOST_TEST(checkImport("import 'b/../../../work/a/b/c.sol'", {"--base-path", "../code/a/", "a/b/c.sol"}));
+
+	// Work dir can also be whitelisted manually
+	BOOST_TEST(checkImport("import 'b/../../../work/a/b/c.sol'", {"--base-path", "../code/a/", "--allow-paths=."}));
+
+	// Not setting base path whitelists the working directory
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {}));
+	BOOST_TEST(checkImport("import 'a/b/c/d.sol'", {}));
+	BOOST_TEST(checkImport("import 'a/b/X.sol'", {}));
+	BOOST_TEST(checkImport("import 'a/X/c.sol'", {}));
+
+	// Setting base path to an empty value whitelists the working directory
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {"--base-path", ""}));
+	BOOST_TEST(checkImport("import 'a/b/c/d.sol'", {"--base-path", ""}));
+	BOOST_TEST(checkImport("import 'a/b/X.sol'", {"--base-path", ""}));
+	BOOST_TEST(checkImport("import 'a/X/c.sol'", {"--base-path", ""}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_automatic_whitelisting_include_paths, AllowPathsFixture)
+{
+	// Relative include path whitelists its content
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path=a/b/c", "--include-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path=a/b/c", "--include-path=../code/a"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path=a/b/c", "--include-path=../code/a"}));
+
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path=a/b/c", "--include-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path=a/b/c", "--include-path=../code/a/"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path=a/b/c", "--include-path=../code/a/"}));
+
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/."}));
+	BOOST_TEST(checkImport("import 'a/b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/./"}));
+	BOOST_TEST(checkImport("import 'code/a/b/c.sol'", {"--base-path=a/b/c", "--include-path=.."}));
+	BOOST_TEST(checkImport("import 'code/a/b/c.sol'", {"--base-path=a/b/c", "--include-path=../"}));
+
+	// Absolute include path whitelists its content
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=a/b/c", "--include-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'b/c/d.sol'", {"--base-path=a/b/c", "--include-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'b/X.sol'", {"--base-path=a/b/c", "--include-path", m_codeDir.string() + "/a"}));
+	BOOST_TEST(checkImport("import 'X/c.sol'", {"--base-path=a/b/c", "--include-path", m_codeDir.string() + "/a"}));
+
+	// If there are multiple include paths, all of them get whitelisted
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/a", "--include-path=../code/1"}));
+	BOOST_TEST(checkImport("import '2/3.sol'", {"--base-path=a/b/c", "--include-path=../code/a", "--include-path=../code/1"}));
+	BOOST_TEST(checkImport("import 'b/c.sol'", {"--base-path=a/b/c", "--include-path=../code/1", "--include-path=../code/a"}));
+	BOOST_TEST(checkImport("import '2/3.sol'", {"--base-path=a/b/c", "--include-path=../code/1", "--include-path=../code/a"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_symlinks_within_whitelisted_dir, AllowPathsFixture)
+{
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b_sym/c.sol'", {"--allow-paths=../code/a/b/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths=../code/a/b_sym/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b_sym/c.sol'", {"--allow-paths=../code/a/b_sym/"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b_sym/c.sol'", {"--allow-paths=../code/a/b"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths=../code/a/b_sym"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b_sym/c.sol'", {"--allow-paths=../code/a/b_sym"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c_sym.sol'", {"--allow-paths=../code/a/b/c.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c.sol'", {"--allow-paths=../code/a/b/c_sym.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/c_sym.sol'", {"--allow-paths=../code/a/b/c_sym.sol"}));
+}
+
+BOOST_FIXTURE_TEST_CASE(allow_path_symlinks_outside_whitelisted_dir, AllowPathsFixture)
+{
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/y_sym/z.sol'", {"--allow-paths=../code/a/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/y_sym/z.sol'", {"--allow-paths=../code/x/"}));
+
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/z_sym.sol'", {"--allow-paths=../code/a/"}) == ImportCheck::PathDisallowed());
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/z_sym.sol'", {"--allow-paths=../code/x/"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/z_sym.sol'", {"--allow-paths=../code/a/b/z_sym.sol"}));
+	BOOST_TEST(checkImport("import '" + m_portablePrefix + "/a/b/z_sym.sol'", {"--allow-paths=../code/x/y/z.sol"}));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/solc/CommandLineParser.cpp b/compiler/test/solc/CommandLineParser.cpp
new file mode 100644
index 00000000..e0592da5
--- /dev/null
+++ b/compiler/test/solc/CommandLineParser.cpp
@@ -0,0 +1,612 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Unit tests for solc/CommandLineParser.h
+
+#include <solc/CommandLineParser.h>
+#include <solc/Exceptions.h>
+
+#include <test/solc/Common.h>
+
+#include <test/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
+
+#include <libsolutil/CommonData.h>
+#include <liblangutil/EVMVersion.h>
+#include <libsmtutil/SolverInterface.h>
+#include <libsolidity/interface/Version.h>
+
+#include <map>
+#include <optional>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using namespace solidity::frontend;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace solidity::yul;
+
+namespace
+{
+
+CommandLineOptions parseCommandLine(std::vector<std::string> const& _commandLine)
+{
+	std::vector<char const*> argv = test::makeArgv(_commandLine);
+
+	CommandLineParser cliParser;
+	cliParser.parse(static_cast<int>(_commandLine.size()), argv.data());
+	return cliParser.options();
+}
+
+} // namespace
+
+namespace solidity::frontend::test
+{
+
+BOOST_AUTO_TEST_SUITE(CommandLineParserTest)
+
+BOOST_AUTO_TEST_CASE(no_options)
+{
+	std::vector<std::string> commandLine = {"solc", "contract.sol"};
+
+	CommandLineOptions expectedOptions;
+	expectedOptions.input.paths = {"contract.sol"};
+	expectedOptions.modelChecker.initialize = true;
+	expectedOptions.modelChecker.settings = {};
+
+	CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+
+	BOOST_TEST(parsedOptions == expectedOptions);
+}
+
+BOOST_AUTO_TEST_CASE(help_license_version)
+{
+	std::map<std::string, InputMode> expectedModePerOption = {
+		{"--help", InputMode::Help},
+		{"--license", InputMode::License},
+		{"--version", InputMode::Version},
+	};
+
+	for (auto const& [option, expectedMode]: expectedModePerOption)
+	{
+		CommandLineOptions parsedOptions = parseCommandLine({"solc", option});
+
+		CommandLineOptions expectedOptions;
+		expectedOptions.input.mode = expectedMode;
+
+		BOOST_TEST(parsedOptions == expectedOptions);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(cli_mode_options)
+{
+	for (InputMode inputMode: {InputMode::Compiler, InputMode::CompilerWithASTImport})
+	{
+		std::vector<std::string> commandLine = {
+			"solc",
+			"contract.sol",             // Both modes do not care about file names, just about
+			"/tmp/projects/token.sol",  // their content. They also both support stdin.
+			"/home/user/lib/dex.sol",
+			"file",
+			"input.json",
+			"-",
+			"/tmp=/usr/lib/",
+			"a:b=c/d",
+			":contract.sol=",
+			"--base-path=/home/user/",
+			"--include-path=/usr/lib/include/",
+			"--include-path=/home/user/include",
+			"--allow-paths=/tmp,/home,project,../contracts",
+			"--ignore-missing",
+			"--output-dir=/tmp/out",
+			"--overwrite",
+			"--evm-version=spuriousDragon",
+			"--via-ir",
+			"--experimental-via-ir",
+			"--revert-strings=strip",
+			"--debug-info=location",
+			"--pretty-json",
+			"--json-indent=7",
+			"--no-color",
+			"--error-codes",
+			"--libraries="
+				"dir1/file1.sol:L=0x1234567890123456789012345678901234567890,"
+				"dir2/file2.sol:L=0x1111122222333334444455555666667777788888",
+			"--ast-compact-json", "--asm", "--asm-json", "--opcodes", "--bin", "--bin-runtime", "--abi",
+			"--ir", "--ir-ast-json", "--ir-optimized", "--ir-optimized-ast-json", "--hashes", "--userdoc", "--devdoc", "--metadata", "--storage-layout",
+			"--gas",
+			"--combined-json="
+				"abi,metadata,bin,bin-runtime,opcodes,asm,storage-layout,generated-sources,generated-sources-runtime,"
+				"srcmap,srcmap-runtime,function-debug,function-debug-runtime,hashes,devdoc,userdoc,ast",
+			"--metadata-hash=swarm",
+			"--metadata-literal",
+			"--optimize",
+			"--optimize-yul",
+			"--optimize-runs=1000",
+			"--yul-optimizations=agf",
+			"--model-checker-bmc-loop-iterations=2",
+			"--model-checker-contracts=contract1.yul:A,contract2.yul:B",
+			"--model-checker-div-mod-no-slacks",
+			"--model-checker-engine=bmc",
+			"--model-checker-ext-calls=trusted",
+			"--model-checker-invariants=contract,reentrancy",
+			"--model-checker-show-proved-safe",
+			"--model-checker-show-unproved",
+			"--model-checker-show-unsupported",
+			"--model-checker-solvers=z3,smtlib2",
+			"--model-checker-targets=underflow,divByZero",
+			"--model-checker-timeout=5"
+		};
+
+		if (inputMode == InputMode::CompilerWithASTImport)
+			commandLine += std::vector<std::string>{
+				"--import-ast",
+			};
+
+		CommandLineOptions expectedOptions;
+		expectedOptions.input.mode = inputMode;
+		expectedOptions.input.paths = {"contract.sol", "/tmp/projects/token.sol", "/home/user/lib/dex.sol", "file", "input.json"};
+		expectedOptions.input.remappings = {
+			{"", "/tmp", "/usr/lib/"},
+			{"a", "b", "c/d"},
+			{"", "contract.sol", ""},
+		};
+
+		expectedOptions.input.addStdin = true;
+		expectedOptions.input.basePath = "/home/user/";
+		expectedOptions.input.includePaths = {"/usr/lib/include/", "/home/user/include"};
+
+		expectedOptions.input.allowedDirectories = {"/tmp", "/home", "project", "../contracts", "c", "/usr/lib"};
+		expectedOptions.input.ignoreMissingFiles = true;
+		expectedOptions.output.dir = "/tmp/out";
+		expectedOptions.output.overwriteFiles = true;
+		expectedOptions.output.evmVersion = EVMVersion::spuriousDragon();
+		expectedOptions.output.viaIR = true;
+		expectedOptions.output.revertStrings = RevertStrings::Strip;
+		expectedOptions.output.debugInfoSelection = DebugInfoSelection::fromString("location");
+		expectedOptions.formatting.json = JsonFormat{JsonFormat::Pretty, 7};
+		expectedOptions.linker.libraries = {
+			{"dir1/file1.sol:L", h160("1234567890123456789012345678901234567890")},
+			{"dir2/file2.sol:L", h160("1111122222333334444455555666667777788888")},
+		};
+		expectedOptions.formatting.coloredOutput = false;
+		expectedOptions.formatting.withErrorIds = true;
+		expectedOptions.compiler.outputs = {
+			true, true, true, true, true,
+			true, true, true, true, true,
+			true, true, true, true, true,
+			true,
+		};
+		expectedOptions.compiler.estimateGas = true;
+		expectedOptions.compiler.combinedJsonRequests = {
+			true, true, true, true, true,
+			true, true, true, true, true,
+			true, true, true, true, true,
+			true, true,
+		};
+		expectedOptions.metadata.hash = CompilerStack::MetadataHash::Bzzr1;
+		expectedOptions.metadata.literalSources = true;
+		expectedOptions.optimizer.optimizeEvmasm = true;
+		expectedOptions.optimizer.optimizeYul = true;
+		expectedOptions.optimizer.expectedExecutionsPerDeployment = 1000;
+		expectedOptions.optimizer.yulSteps = "agf";
+
+		expectedOptions.modelChecker.initialize = true;
+		expectedOptions.modelChecker.settings = {
+			2,
+			{{{"contract1.yul", {"A"}}, {"contract2.yul", {"B"}}}},
+			true,
+			{true, false},
+			{ModelCheckerExtCalls::Mode::TRUSTED},
+			{{InvariantType::Contract, InvariantType::Reentrancy}},
+			false, // --model-checker-print-query
+			true,
+			true,
+			true,
+			{false, false, true, true},
+			{{VerificationTargetType::Underflow, VerificationTargetType::DivByZero}},
+			5,
+		};
+
+		CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+
+		BOOST_TEST(parsedOptions == expectedOptions);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(no_cbor_metadata)
+{
+	std::vector<std::string> commandLine = {"solc", "--no-cbor-metadata", "contract.sol"};
+	CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+	bool assert = parsedOptions.metadata.format == CompilerStack::MetadataFormat::NoMetadata;
+
+	BOOST_TEST(assert);
+}
+
+BOOST_AUTO_TEST_CASE(no_import_callback)
+{
+	std::vector<std::vector<std::string>> commandLinePerInputMode = {
+		{"solc", "--no-import-callback", "contract.sol"},
+		{"solc", "--standard-json", "--no-import-callback", "input.json"},
+		{"solc", "--assemble", "--no-import-callback", "input.yul"},
+		{"solc", "--strict-assembly", "--no-import-callback", "input.yul"},
+		{"solc", "--import-ast", "--no-import-callback", "ast.json"},
+		{"solc", "--link", "--no-import-callback", "input.bin"},
+		{"solc", "--yul", "--no-import-callback", "input.yul"},
+	};
+
+	for (auto const& commandLine: commandLinePerInputMode)
+	{
+		CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+		BOOST_TEST(parsedOptions.input.noImportCallback);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(via_ir_options)
+{
+	BOOST_TEST(!parseCommandLine({"solc", "contract.sol"}).output.viaIR);
+	for (std::string viaIrOption: {"--via-ir", "--experimental-via-ir"})
+		BOOST_TEST(parseCommandLine({"solc", viaIrOption, "contract.sol"}).output.viaIR);
+}
+
+BOOST_AUTO_TEST_CASE(assembly_mode_options)
+{
+	static std::vector<std::tuple<std::vector<std::string>, YulStack::Machine, YulStack::Language>> const allowedCombinations = {
+		{{"--machine=evm", "--yul-dialect=evm", "--assemble"}, YulStack::Machine::EVM, YulStack::Language::StrictAssembly},
+		{{"--machine=evm", "--yul-dialect=evm", "--yul"}, YulStack::Machine::EVM, YulStack::Language::StrictAssembly},
+		{{"--machine=evm", "--yul-dialect=evm", "--strict-assembly"}, YulStack::Machine::EVM, YulStack::Language::StrictAssembly},
+		{{"--machine=evm", "--assemble"}, YulStack::Machine::EVM, YulStack::Language::Assembly},
+		{{"--machine=evm", "--yul"}, YulStack::Machine::EVM, YulStack::Language::Yul},
+		{{"--machine=evm", "--strict-assembly"}, YulStack::Machine::EVM, YulStack::Language::StrictAssembly},
+		{{"--assemble"}, YulStack::Machine::EVM, YulStack::Language::Assembly},
+		{{"--yul"}, YulStack::Machine::EVM, YulStack::Language::Yul},
+		{{"--strict-assembly"}, YulStack::Machine::EVM, YulStack::Language::StrictAssembly},
+	};
+
+	for (auto const& [assemblyOptions, expectedMachine, expectedLanguage]: allowedCombinations)
+	{
+		std::vector<std::string> commandLine = {
+			"solc",
+			"contract.yul",
+			"/tmp/projects/token.yul",
+			"/home/user/lib/dex.yul",
+			"file",
+			"input.json",
+			"-",
+			"/tmp=/usr/lib/",
+			"a:b=c/d",
+			":contract.yul=",
+			"--base-path=/home/user/",
+			"--include-path=/usr/lib/include/",
+			"--include-path=/home/user/include",
+			"--allow-paths=/tmp,/home,project,../contracts",
+			"--ignore-missing",
+			"--overwrite",
+			"--evm-version=spuriousDragon",
+			"--revert-strings=strip",      // Accepted but has no effect in assembly mode
+			"--debug-info=location",
+			"--pretty-json",
+			"--json-indent=1",
+			"--no-color",
+			"--error-codes",
+			"--libraries="
+				"dir1/file1.sol:L=0x1234567890123456789012345678901234567890,"
+				"dir2/file2.sol:L=0x1111122222333334444455555666667777788888",
+			"--asm",
+			"--bin",
+			"--ir-optimized",
+			"--ast-compact-json",
+		};
+		commandLine += assemblyOptions;
+		if (expectedLanguage == YulStack::Language::StrictAssembly)
+			commandLine += std::vector<std::string>{
+				"--optimize",
+				"--optimize-runs=1000",
+				"--yul-optimizations=agf",
+			};
+
+		CommandLineOptions expectedOptions;
+		expectedOptions.input.mode = InputMode::Assembler;
+
+		expectedOptions.input.paths = {"contract.yul", "/tmp/projects/token.yul", "/home/user/lib/dex.yul", "file", "input.json"};
+		expectedOptions.input.remappings = {
+			{"", "/tmp", "/usr/lib/"},
+			{"a", "b", "c/d"},
+			{"", "contract.yul", ""},
+		};
+		expectedOptions.input.addStdin = true;
+		expectedOptions.input.basePath = "/home/user/";
+		expectedOptions.input.includePaths = {"/usr/lib/include/", "/home/user/include"};
+		expectedOptions.input.allowedDirectories = {"/tmp", "/home", "project", "../contracts", "c", "/usr/lib"};
+		expectedOptions.input.ignoreMissingFiles = true;
+		expectedOptions.output.overwriteFiles = true;
+		expectedOptions.output.evmVersion = EVMVersion::spuriousDragon();
+		expectedOptions.output.revertStrings = RevertStrings::Strip;
+		expectedOptions.output.debugInfoSelection = DebugInfoSelection::fromString("location");
+		expectedOptions.formatting.json = JsonFormat {JsonFormat::Pretty, 1};
+		expectedOptions.assembly.targetMachine = expectedMachine;
+		expectedOptions.assembly.inputLanguage = expectedLanguage;
+		expectedOptions.linker.libraries = {
+			{"dir1/file1.sol:L", h160("1234567890123456789012345678901234567890")},
+			{"dir2/file2.sol:L", h160("1111122222333334444455555666667777788888")},
+		};
+		expectedOptions.formatting.coloredOutput = false;
+		expectedOptions.formatting.withErrorIds = true;
+		expectedOptions.compiler.outputs.asm_ = true;
+		expectedOptions.compiler.outputs.binary = true;
+		expectedOptions.compiler.outputs.irOptimized = true;
+		expectedOptions.compiler.outputs.astCompactJson = true;
+		if (expectedLanguage == YulStack::Language::StrictAssembly)
+		{
+			expectedOptions.optimizer.optimizeEvmasm = true;
+			expectedOptions.optimizer.optimizeYul = true;
+			expectedOptions.optimizer.yulSteps = "agf";
+			expectedOptions.optimizer.expectedExecutionsPerDeployment = 1000;
+		}
+
+		CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+
+		BOOST_TEST(parsedOptions == expectedOptions);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(standard_json_mode_options)
+{
+	std::vector<std::string> commandLine = {
+		"solc",
+		"input.json",
+		"--standard-json",
+		"--base-path=/home/user/",
+		"--include-path=/usr/lib/include/",
+		"--include-path=/home/user/include",
+		"--allow-paths=/tmp,/home,project,../contracts",
+		"--ignore-missing",
+		"--output-dir=/tmp/out",           // Accepted but has no effect in Standard JSON mode
+		"--overwrite",                     // Accepted but has no effect in Standard JSON mode
+		"--evm-version=spuriousDragon",    // Ignored in Standard JSON mode
+		"--revert-strings=strip",          // Accepted but has no effect in Standard JSON mode
+		"--pretty-json",
+		"--json-indent=1",
+		"--no-color",                      // Accepted but has no effect in Standard JSON mode
+		"--error-codes",                   // Accepted but has no effect in Standard JSON mode
+		"--libraries="                     // Ignored in Standard JSON mode
+			"dir1/file1.sol:L=0x1234567890123456789012345678901234567890,"
+			"dir2/file2.sol:L=0x1111122222333334444455555666667777788888",
+		"--gas",                           // Accepted but has no effect in Standard JSON mode
+		"--combined-json=abi,bin",         // Accepted but has no effect in Standard JSON mode
+	};
+
+	CommandLineOptions expectedOptions;
+
+	expectedOptions.input.mode = InputMode::StandardJson;
+	expectedOptions.input.paths = {"input.json"};
+	expectedOptions.input.basePath = "/home/user/";
+	expectedOptions.input.includePaths = {"/usr/lib/include/", "/home/user/include"};
+	expectedOptions.input.allowedDirectories = {"/tmp", "/home", "project", "../contracts"};
+	expectedOptions.input.ignoreMissingFiles = true;
+	expectedOptions.output.dir = "/tmp/out";
+	expectedOptions.output.overwriteFiles = true;
+	expectedOptions.output.revertStrings = RevertStrings::Strip;
+	expectedOptions.formatting.json = JsonFormat {JsonFormat::Pretty, 1};
+	expectedOptions.formatting.coloredOutput = false;
+	expectedOptions.formatting.withErrorIds = true;
+	expectedOptions.compiler.estimateGas = true;
+	expectedOptions.compiler.combinedJsonRequests = CombinedJsonRequests{};
+	expectedOptions.compiler.combinedJsonRequests->abi = true;
+	expectedOptions.compiler.combinedJsonRequests->binary = true;
+
+	CommandLineOptions parsedOptions = parseCommandLine(commandLine);
+
+	BOOST_TEST(parsedOptions == expectedOptions);
+}
+
+BOOST_AUTO_TEST_CASE(invalid_options_input_modes_combinations)
+{
+	std::map<std::string, std::vector<std::string>> invalidOptionInputModeCombinations = {
+		// TODO: This should eventually contain all options.
+		{"--experimental-via-ir", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--via-ir", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--metadata-literal", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--metadata-hash=swarm", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-show-proved-safe", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-show-unproved", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-show-unsupported", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-div-mod-no-slacks", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-engine=bmc", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-invariants=contract,reentrancy", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-solvers=z3,smtlib2", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-timeout=5", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-contracts=contract1.yul:A,contract2.yul:B", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}},
+		{"--model-checker-targets=underflow,divByZero", {"--assemble", "--yul", "--strict-assembly", "--standard-json", "--link"}}
+	};
+
+	for (auto const& [optionName, inputModes]: invalidOptionInputModeCombinations)
+		for (std::string const& inputMode: inputModes)
+		{
+			std::stringstream serr;
+			size_t separatorPosition = optionName.find("=");
+			std::string optionNameWithoutValue = optionName.substr(0, separatorPosition);
+			soltestAssert(!optionNameWithoutValue.empty());
+
+			std::vector<std::string> commandLine = {"solc", optionName, "file", inputMode};
+
+			std::string expectedMessage = "The following options are not supported in the current input mode: " + optionNameWithoutValue;
+			auto hasCorrectMessage = [&](CommandLineValidationError const& _exception) { return _exception.what() == expectedMessage; };
+
+			BOOST_CHECK_EXCEPTION(parseCommandLine(commandLine), CommandLineValidationError, hasCorrectMessage);
+		}
+}
+
+BOOST_AUTO_TEST_CASE(optimizer_flags)
+{
+	OptimiserSettings yulOnly = OptimiserSettings::minimal();
+	yulOnly.runYulOptimiser = true;
+	yulOnly.optimizeStackAllocation = true;
+
+	OptimiserSettings evmasmOnly = OptimiserSettings::standard();
+	evmasmOnly.runYulOptimiser = false;
+
+	std::map<std::vector<std::string>, OptimiserSettings> settingsMap = {
+		{{}, OptimiserSettings::minimal()},
+		{{"--optimize"}, OptimiserSettings::standard()},
+		{{"--no-optimize-yul"}, OptimiserSettings::minimal()},
+		{{"--optimize-yul"}, yulOnly},
+		{{"--optimize", "--no-optimize-yul"}, evmasmOnly},
+		{{"--optimize", "--optimize-yul"}, OptimiserSettings::standard()},
+	};
+
+	std::map<InputMode, std::string> inputModeFlagMap = {
+		{InputMode::Compiler, ""},
+		{InputMode::CompilerWithASTImport, "--import-ast"},
+		{InputMode::Assembler, "--strict-assembly"},
+	};
+
+	for (auto const& [inputMode, inputModeFlag]: inputModeFlagMap)
+		for (auto const& [optimizerFlags, expectedOptimizerSettings]: settingsMap)
+		{
+			std::vector<std::string> commandLine = {"solc", inputModeFlag, "file"};
+			commandLine += optimizerFlags;
+			BOOST_CHECK(parseCommandLine(commandLine).optimiserSettings() == expectedOptimizerSettings);
+		}
+}
+
+BOOST_AUTO_TEST_CASE(default_optimiser_sequence)
+{
+	CommandLineOptions const& commandLineOptions = parseCommandLine({"solc", "contract.sol", "--optimize"});
+	BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserSteps, OptimiserSettings::DefaultYulOptimiserSteps);
+	BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserCleanupSteps, OptimiserSettings::DefaultYulOptimiserCleanupSteps);
+}
+
+BOOST_AUTO_TEST_CASE(valid_optimiser_sequences)
+{
+	std::vector<std::string> validSequenceInputs {
+		":",                         // Empty optimization sequence and empty cleanup sequence
+		":fDn",                      // Empty optimization sequence and specified cleanup sequence
+		"dhfoDgvulfnTUtnIf:",        // Specified optimization sequence and empty cleanup sequence
+		"dhfoDgvulfnTUtnIf:fDn",     // Specified optimization sequence and cleanup sequence
+		"dhfo[Dgvulfn]TUtnIf:f[D]n", // Specified and nested optimization and cleanup sequence
+		"dhfoDgvulfnTUtnIf",         // Specified optimizer sequence only
+		"iDu",                       // Short optimizer sequence
+		"a[[a][[aa]aa[aa]][]]aaa[aa[aa[aa]]]a[a][a][a]a[a]" // Nested brackets
+	};
+
+	std::vector<std::tuple<std::string, std::string>> const expectedParsedSequences {
+		{"", ""},
+		{"", "fDn"},
+		{"dhfoDgvulfnTUtnIf", ""},
+		{"dhfoDgvulfnTUtnIf", "fDn"},
+		{"dhfo[Dgvulfn]TUtnIf", "f[D]n"},
+		{"dhfoDgvulfnTUtnIf", OptimiserSettings::DefaultYulOptimiserCleanupSteps},
+		{"iDu", OptimiserSettings::DefaultYulOptimiserCleanupSteps},
+		{"a[[a][[aa]aa[aa]][]]aaa[aa[aa[aa]]]a[a][a][a]a[a]", OptimiserSettings::DefaultYulOptimiserCleanupSteps}
+	};
+
+	BOOST_CHECK_EQUAL(validSequenceInputs.size(), expectedParsedSequences.size());
+
+	for (size_t i = 0; i < validSequenceInputs.size(); ++i)
+	{
+		CommandLineOptions const& commandLineOptions = parseCommandLine({"solc", "contract.sol", "--optimize", "--yul-optimizations=" + validSequenceInputs[i]});
+		auto const& [expectedYulOptimiserSteps, expectedYulCleanupSteps] = expectedParsedSequences[i];
+		BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserSteps, expectedYulOptimiserSteps);
+		BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserCleanupSteps, expectedYulCleanupSteps);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(invalid_optimiser_sequences)
+{
+	std::vector<std::string> const invalidSequenceInputs {
+		"abcdefg{hijklmno}pqr[st]uvwxyz", // Invalid abbreviation
+		"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
+		"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
+		"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
+		"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
+		"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[a]"
+		"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
+		"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
+		"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
+		"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
+		"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]",  // Brackets nested too deep
+		"a]a][",                          // Unbalanced closing bracket
+		"a[a][",                          // Unbalanced opening bracket
+		"dhfoDgvulfnTUt[nIf:fd]N",        // Nested cleanup sequence delimiter
+		"dhfoDgvulfnTU:tnIf:fdN"          // Too many cleanup sequence delimiters
+	};
+
+	std::vector<std::string> const expectedErrorMessages {
+		"'b' is not a valid step abbreviation",
+		"Brackets nested too deep",
+		"Unbalanced brackets",
+		"Unbalanced brackets",
+		"Cleanup sequence delimiter cannot be placed inside the brackets",
+		"Too many cleanup sequence delimiters"
+	};
+
+	BOOST_CHECK_EQUAL(invalidSequenceInputs.size(), expectedErrorMessages.size());
+
+	std::string const baseExpectedErrorMessage = "Invalid optimizer step sequence in --yul-optimizations: ";
+
+	for (size_t i = 0; i < invalidSequenceInputs.size(); ++i)
+	{
+		std::vector<std::string> const commandLineOptions = {"solc", "contract.sol", "--optimize", "--yul-optimizations=" + invalidSequenceInputs[i]};
+		std::string const expectedErrorMessage = baseExpectedErrorMessage + expectedErrorMessages[i];
+		auto hasCorrectMessage = [&](CommandLineValidationError const& _exception) { return _exception.what() == expectedErrorMessage; };
+		BOOST_CHECK_EXCEPTION(parseCommandLine(commandLineOptions), CommandLineValidationError, hasCorrectMessage);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(valid_empty_optimizer_sequences_without_optimize)
+{
+	std::vector<std::string> const validSequenceInputs {
+		"   :",
+		": ",
+		"\n : \n",
+		":"
+	};
+
+	std::vector<std::tuple<std::string, std::string>> const expectedParsedSequences {
+		{"   ", ""},
+		{"", " "},
+		{"\n ", " \n"},
+		{"", ""}
+	};
+
+	BOOST_CHECK_EQUAL(validSequenceInputs.size(), expectedParsedSequences.size());
+
+	for (size_t i = 0; i < validSequenceInputs.size(); ++i)
+	{
+		CommandLineOptions const& commandLineOptions = parseCommandLine({"solc", "contract.sol", "--yul-optimizations=" + validSequenceInputs[i]});
+		auto const& [expectedYulOptimiserSteps, expectedYulCleanupSteps] = expectedParsedSequences[i];
+		BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserSteps, expectedYulOptimiserSteps);
+		BOOST_CHECK_EQUAL(commandLineOptions.optimiserSettings().yulOptimiserCleanupSteps, expectedYulCleanupSteps);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(invalid_optimizer_sequence_without_optimize)
+{
+	std::string const invalidSequence{"u: "};
+	std::string const expectedErrorMessage{"--yul-optimizations is invalid with a non-empty sequence if Yul optimizer is disabled."};
+	std::vector<std::string> commandLineOptions{"solc", "contract.sol", "--yul-optimizations=" + invalidSequence};
+	auto hasCorrectMessage = [&](CommandLineValidationError const& _exception) { return _exception.what() == expectedErrorMessage; };
+	BOOST_CHECK_EXCEPTION(parseCommandLine(commandLineOptions), CommandLineValidationError, hasCorrectMessage);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/solc/Common.cpp b/compiler/test/solc/Common.cpp
new file mode 100644
index 00000000..6b6b6995
--- /dev/null
+++ b/compiler/test/solc/Common.cpp
@@ -0,0 +1,81 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/solc/Common.h>
+#include <test/libsolidity/util/Common.h>
+
+#include <solc/CommandLineInterface.h>
+
+#include <sstream>
+
+using namespace solidity::frontend;
+
+std::vector<char const*> test::makeArgv(std::vector<std::string> const& _commandLine)
+{
+	size_t argc = _commandLine.size();
+	std::vector<char const*> argv(_commandLine.size() + 1);
+
+	// C++ standard mandates argv[argc] to be NULL
+	argv[argc] = nullptr;
+
+	for (size_t i = 0; i < argc; ++i)
+		argv[i] = _commandLine[i].c_str();
+
+	return argv;
+}
+
+test::OptionsReaderAndMessages test::parseCommandLineAndReadInputFiles(
+	std::vector<std::string> const& _commandLine,
+	std::string const& _standardInputContent
+)
+{
+	std::vector<char const*> argv = makeArgv(_commandLine);
+	std::stringstream sin(_standardInputContent), sout, serr;
+	CommandLineInterface cli(sin, sout, serr);
+	bool success = cli.parseArguments(static_cast<int>(_commandLine.size()), argv.data());
+	cli.readInputFiles();
+
+	return {
+		success,
+		cli.options(),
+		cli.fileReader(),
+		cli.standardJsonInput(),
+		sout.str(),
+		stripPreReleaseWarning(serr.str()),
+	};
+}
+
+test::OptionsReaderAndMessages test::runCLI(
+	std::vector<std::string> const& _commandLine,
+	std::string const& _standardInputContent
+)
+{
+	std::vector<char const*> argv = makeArgv(_commandLine);
+	std::stringstream sin(_standardInputContent), sout, serr;
+	CommandLineInterface cli(sin, sout, serr);
+	bool success = cli.run(static_cast<int>(_commandLine.size()), argv.data());
+
+	return {
+		success,
+		cli.options(),
+		cli.fileReader(),
+		cli.standardJsonInput(),
+		sout.str(),
+		stripPreReleaseWarning(serr.str()),
+	};
+}
diff --git a/compiler/test/solc/Common.h b/compiler/test/solc/Common.h
new file mode 100644
index 00000000..e2ddee69
--- /dev/null
+++ b/compiler/test/solc/Common.h
@@ -0,0 +1,70 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+/// Utilities shared by multiple tests for code in solc/.
+
+#include <solc/CommandLineParser.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+BOOST_TEST_DONT_PRINT_LOG_VALUE(solidity::frontend::CommandLineOptions)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(solidity::frontend::InputMode)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(solidity::frontend::OptimiserSettings)
+
+namespace solidity::frontend::test
+{
+
+struct OptionsReaderAndMessages
+{
+	bool success;
+	CommandLineOptions options;
+	FileReader reader;
+	std::optional<std::string> standardJsonInput;
+	std::string stdoutContent;
+	std::string stderrContent;
+};
+
+std::vector<char const*> makeArgv(std::vector<std::string> const& _commandLine);
+
+/// Runs only command-line parsing, without compilation, assembling or any other input processing.
+/// Lets through any @a CommandLineErrors throw by the CLI.
+/// Note: This uses the @a CommandLineInterface class and does not actually spawn a new process.
+/// @param _commandLine Arguments in the form of strings that would be specified on the command-line.
+///                     You must specify the program name as the first item.
+/// @param _standardInputContent Content that the CLI will be able to read from its standard input.
+OptionsReaderAndMessages parseCommandLineAndReadInputFiles(
+	std::vector<std::string> const& _commandLine,
+	std::string const& _standardInputContent = ""
+);
+
+/// Runs all stages of command-line interface processing, including error handling.
+/// Never throws @a CommandLineError - validation errors are included in the returned stderr content.
+/// Note: This uses the @a CommandLineInterface class and does not actually spawn a new process.
+/// @param _commandLine Arguments in the form of strings that would be specified on the command-line.
+///                     You must specify the program name as the first item.
+/// @param _standardInputContent Content that the CLI will be able to read from its standard input.
+OptionsReaderAndMessages runCLI(
+	std::vector<std::string> const& _commandLine,
+	std::string const& _standardInputContent = ""
+);
+
+} // namespace solidity::frontend::test
diff --git a/compiler/test/soltest.cpp b/compiler/test/soltest.cpp
new file mode 100644
index 00000000..6aa10024
--- /dev/null
+++ b/compiler/test/soltest.cpp
@@ -0,0 +1,318 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/** @file boostTest.cpp
+ * @author Marko Simovic <markobarko@gmail.com>
+ * @date 2014
+ * Stub for generating main boost.test module.
+ * Original code taken from boost sources.
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4535) // calling _set_se_translator requires /EHa
+#endif
+#include <boost/test/unit_test.hpp>
+#include <boost/test/tree/traverse.hpp>
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#pragma GCC diagnostic pop
+
+#include <test/InteractiveTests.h>
+#include <test/Common.h>
+#include <test/EVMHost.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <string>
+
+using namespace boost::unit_test;
+using namespace solidity::frontend::test;
+namespace fs = boost::filesystem;
+using namespace std;
+
+namespace
+{
+void removeTestSuite(std::string const& _name)
+{
+	master_test_suite_t& master = framework::master_test_suite();
+	auto id = master.get(_name);
+	soltestAssert(id != INV_TEST_UNIT_ID, "Removing non-existent test suite!");
+	master.remove(id);
+}
+
+/**
+ * Class that traverses the boost test tree and removes unit tests that are
+ * not in the current batch.
+ */
+class BoostBatcher: public test_tree_visitor
+{
+public:
+	BoostBatcher(solidity::test::Batcher& _batcher):
+		m_batcher(_batcher)
+	{}
+
+	void visit(test_case const& _testCase) override
+	{
+		if (!m_batcher.checkAndAdvance())
+			// disabling them would be nicer, but it does not work like this:
+			// const_cast<test_case&>(_testCase).p_run_status.value = test_unit::RS_DISABLED;
+			m_path.back()->remove(_testCase.p_id);
+	}
+	bool test_suite_start(test_suite const& _testSuite) override
+	{
+		m_path.push_back(&const_cast<test_suite&>(_testSuite));
+		return test_tree_visitor::test_suite_start(_testSuite);
+	}
+	void test_suite_finish(test_suite const& _testSuite) override
+	{
+		m_path.pop_back();
+		test_tree_visitor::test_suite_finish(_testSuite);
+	}
+
+private:
+	solidity::test::Batcher& m_batcher;
+	std::vector<test_suite*> m_path;
+};
+
+
+void runTestCase(TestCase::Config const& _config, TestCase::TestCaseCreator const& _testCaseCreator)
+{
+	try
+	{
+		stringstream errorStream;
+		auto testCase = _testCaseCreator(_config);
+		if (testCase->shouldRun())
+			switch (testCase->run(errorStream))
+			{
+				case TestCase::TestResult::Success:
+					break;
+				case TestCase::TestResult::Failure:
+					BOOST_ERROR("Test expectation mismatch.\n" + errorStream.str());
+					break;
+				case TestCase::TestResult::FatalError:
+					BOOST_ERROR("Fatal error during test.\n" + errorStream.str());
+					break;
+			}
+	}
+	catch (boost::exception const& _e)
+	{
+		BOOST_ERROR("Exception during extracted test: " << boost::diagnostic_information(_e));
+	}
+	catch (std::exception const& _e)
+	{
+		BOOST_ERROR("Exception during extracted test: " << boost::diagnostic_information(_e));
+	}
+	catch (...)
+	{
+		BOOST_ERROR("Unknown exception during extracted test: " << boost::current_exception_diagnostic_information());
+	}
+}
+
+int registerTests(
+	boost::unit_test::test_suite& _suite,
+	boost::filesystem::path const& _basepath,
+	boost::filesystem::path const& _path,
+	vector<string> const& _labels,
+	TestCase::TestCaseCreator _testCaseCreator,
+	solidity::test::Batcher& _batcher
+)
+{
+	int numTestsAdded = 0;
+	fs::path fullpath = _basepath / _path;
+	TestCase::Config config{
+		fullpath.string(),
+		solidity::test::CommonOptions::get().evmVersion(),
+		solidity::test::CommonOptions::get().eofVersion(),
+		solidity::test::CommonOptions::get().vmPaths,
+		solidity::test::CommonOptions::get().enforceGasTest,
+		solidity::test::CommonOptions::get().enforceGasTestMinValue,
+	};
+	if (fs::is_directory(fullpath))
+	{
+		test_suite* sub_suite = BOOST_TEST_SUITE(_path.filename().string());
+		for (auto const& entry: boost::iterator_range<fs::directory_iterator>(
+			fs::directory_iterator(fullpath),
+			fs::directory_iterator()
+		))
+			if (
+				solidity::test::isValidSemanticTestPath(entry) &&
+				(fs::is_directory(entry.path()) || TestCase::isTestFilename(entry.path().filename()))
+			)
+				numTestsAdded += registerTests(
+					*sub_suite,
+					_basepath, _path / entry.path().filename(),
+					_labels,
+					_testCaseCreator,
+					_batcher
+				);
+		_suite.add(sub_suite);
+	}
+	else
+	{
+		// TODO would be better to set the test to disabled.
+		if (_batcher.checkAndAdvance())
+		{
+			// This must be a vector of unique_ptrs because Boost.Test keeps the equivalent of a string_view to the filename
+			// that is passed in. If the strings were stored directly in the vector, pointers/references to them would be
+			// invalidated on reallocation.
+			static vector<unique_ptr<string const>> filenames;
+
+			filenames.emplace_back(make_unique<string>(_path.string()));
+			auto test_case = make_test_case(
+				[config, _testCaseCreator]
+				{
+					BOOST_REQUIRE_NO_THROW({
+						runTestCase(config, _testCaseCreator);
+					});
+				},
+				_path.stem().string(),
+				*filenames.back(),
+				0
+			);
+			for (auto const& _label: _labels)
+				test_case->add_label(_label);
+			_suite.add(test_case);
+			numTestsAdded = 1;
+		}
+	}
+	return numTestsAdded;
+}
+
+bool initializeOptions()
+{
+	auto const& suite = boost::unit_test::framework::master_test_suite();
+
+	auto options = std::make_unique<solidity::test::CommonOptions>();
+	bool shouldContinue = options->parse(suite.argc, suite.argv);
+	if (!shouldContinue)
+		return false;
+	options->validate();
+
+	solidity::test::CommonOptions::setSingleton(std::move(options));
+	return true;
+}
+
+}
+
+// TODO: Prototype -- why isn't this declared in the boost headers?
+// TODO: replace this with a (global) fixture.
+test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]);
+
+test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
+{
+	using namespace solidity::test;
+
+	master_test_suite_t& master = framework::master_test_suite();
+	master.p_name.value = "SolidityTests";
+
+	try
+	{
+		bool shouldContinue = initializeOptions();
+		if (!shouldContinue)
+			exit(EXIT_SUCCESS);
+
+		if (!solidity::test::loadVMs(solidity::test::CommonOptions::get()))
+			exit(EXIT_FAILURE);
+
+		if (solidity::test::CommonOptions::get().disableSemanticTests)
+			cout << endl << "--- SKIPPING ALL SEMANTICS TESTS ---" << endl << endl;
+
+		if (!solidity::test::CommonOptions::get().enforceGasTest)
+			cout << endl << "WARNING :: Gas Cost Expectations are not being enforced" << endl << endl;
+
+		Batcher batcher(CommonOptions::get().selectedBatch, CommonOptions::get().batches);
+		if (CommonOptions::get().batches > 1)
+			cout << "Batch " << CommonOptions::get().selectedBatch << " out of " << CommonOptions::get().batches << endl;
+
+		// Batch the boost tests
+		BoostBatcher boostBatcher(batcher);
+		traverse_test_tree(master, boostBatcher, true);
+
+		// Include the interactive tests in the automatic tests as well
+		for (auto const& ts: g_interactiveTestsuites)
+		{
+			auto const& options = solidity::test::CommonOptions::get();
+
+			if (ts.smt && options.disableSMT)
+				continue;
+
+			if (ts.needsVM && solidity::test::CommonOptions::get().disableSemanticTests)
+				continue;
+
+			//TODO
+			//solAssert(
+			registerTests(
+				master,
+				options.testPath / ts.path,
+				ts.subpath,
+				ts.labels,
+				ts.testCaseCreator,
+				batcher
+			);
+			// > 0, std::string("no ") + ts.title + " tests found");
+		 }
+
+		if (solidity::test::CommonOptions::get().disableSemanticTests)
+		{
+			for (auto suite: {
+				"ABIDecoderTest",
+				"ABIEncoderTest",
+				"SolidityAuctionRegistrar",
+				"SolidityWallet",
+				"GasMeterTests",
+				"GasCostTests",
+				"SolidityEndToEndTest",
+				"SolidityOptimizer"
+			})
+				removeTestSuite(suite);
+		}
+	}
+	catch (solidity::test::ConfigException const& exception)
+	{
+		cerr << exception.what() << endl;
+		exit(EXIT_FAILURE);
+	}
+	catch (std::runtime_error const& exception)
+	{
+		cerr << exception.what() << endl;
+		exit(EXIT_FAILURE);
+	}
+
+	return nullptr;
+}
+
+// BOOST_TEST_DYN_LINK should be defined if user want to link against shared boost test library
+#ifdef BOOST_TEST_DYN_LINK
+
+// Because we want to have customized initialization function and support shared boost libraries at the same time,
+// we are forced to customize the entry point.
+// see: https://www.boost.org/doc/libs/1_67_0/libs/test/doc/html/boost_test/adv_scenarios/shared_lib_customizations/init_func.html
+
+int main(int argc, char* argv[])
+{
+	auto init_unit_test = []() -> bool { init_unit_test_suite(0, nullptr); return true; };
+	return boost::unit_test::unit_test_main(init_unit_test, argc, argv);
+}
+
+#endif
diff --git a/compiler/test/stopAfterParseTests.sh b/compiler/test/stopAfterParseTests.sh
new file mode 100755
index 00000000..cb15603e
--- /dev/null
+++ b/compiler/test/stopAfterParseTests.sh
@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+
+set -e
+
+READLINK=readlink
+if [[ "$OSTYPE" == "darwin"* ]]; then
+	READLINK=greadlink
+fi
+REPO_ROOT=$(${READLINK} -f "$(dirname "$0")"/..)
+SOLIDITY_BUILD_DIR=${SOLIDITY_BUILD_DIR:-${REPO_ROOT}/build}
+SOLC=${SOLIDITY_BUILD_DIR}/solc/solc
+SPLITSOURCES=${REPO_ROOT}/scripts/splitSources.py
+
+FILETMP=$(mktemp -d -t "stop-after-parse-tests-XXXXXX")
+cd "$FILETMP" || exit 1
+
+
+function testFile
+{
+	set +e
+	ALLOUTPUT=$($SOLC --combined-json ast --pretty-json "$@" --stop-after parsing 2>&1)
+	local RESULT=$?
+	set -e
+	if test ${RESULT} -ne 0; then
+		# solc returned failure. Compilation errors and unimplemented features
+		# are okay, everything else is a failed test (segfault)
+		if ! echo "$ALLOUTPUT" | grep -e "Unimplemented feature:" -e "Error:" -q; then
+			echo -n "Test failed on "
+			echo "$@"
+			echo "$ALLOUTPUT"
+			return 1
+		fi
+	else
+		echo -n .
+	fi
+
+	return 0;
+}
+
+while read -r file; do
+	set +e
+	OUTPUT=$($SPLITSOURCES "$file")
+	RETURN_CODE=$?
+	set -e
+	FAILED=0
+
+	if [ $RETURN_CODE -eq 0 ]
+	then
+		# shellcheck disable=SC2086
+		testFile $OUTPUT
+		FAILED=$?
+		rm -r "${FILETMP:?}"/*
+	elif [ $RETURN_CODE -eq 1 ]
+	then
+		testFile "$file"
+		FAILED=$?
+	elif [ $RETURN_CODE -eq 2 ]
+	then
+		echo -n "<skipping utf8 error>"
+	else
+		echo "Received unexpected return code $RETURN_CODE while processing $file: "
+		echo "-----"
+		echo "$OUTPUT"
+		exit 3
+	fi
+
+	if [ $FAILED -eq 1 ]
+	then
+		echo -n "Failure on "
+		echo "$file"
+		exit 1
+	fi
+done < <(find "${REPO_ROOT}/test" -iname "*.sol" -and -not -name "documentation.sol" -and -not -name "boost_filesystem_bug.sol" -not -path "*/experimental/*" -not -path "*/functionDependencyGraphTests/*")
+echo
diff --git a/compiler/test/tools/CMakeLists.txt b/compiler/test/tools/CMakeLists.txt
new file mode 100644
index 00000000..532a08d9
--- /dev/null
+++ b/compiler/test/tools/CMakeLists.txt
@@ -0,0 +1,53 @@
+add_subdirectory(ossfuzz)
+
+add_subdirectory(yulInterpreter)
+add_executable(yulrun yulrun.cpp)
+target_link_libraries(yulrun PRIVATE yulInterpreter libsolc evmasm Boost::boost Boost::program_options)
+
+add_executable(solfuzzer afl_fuzzer.cpp fuzzer_common.cpp)
+target_link_libraries(solfuzzer PRIVATE libsolc evmasm Boost::boost Boost::program_options Boost::system)
+
+add_executable(yulopti yulopti.cpp)
+target_link_libraries(yulopti PRIVATE solidity Boost::boost Boost::program_options Boost::system)
+
+add_executable(isoltest
+	isoltest.cpp
+	IsolTestOptions.cpp
+	../Common.cpp
+	../CommonSyntaxTest.cpp
+	../EVMHost.cpp
+	../TestCase.cpp
+	../TestCaseReader.cpp
+	../libsolidity/util/BytesUtils.cpp
+	../libsolidity/util/Common.cpp
+	../libsolidity/util/ContractABIUtils.cpp
+	../libsolidity/util/TestFileParser.cpp
+	../libsolidity/util/TestFunctionCall.cpp
+	../libsolidity/GasTest.cpp
+	../libsolidity/MemoryGuardTest.cpp
+	../libsolidity/NatspecJSONTest.cpp
+	../libsolidity/SyntaxTest.cpp
+	../libsolidity/SemanticTest.cpp
+	../libsolidity/AnalysisFramework.cpp
+	../libsolidity/SolidityExecutionFramework.cpp
+	../ExecutionFramework.cpp
+	../libsolidity/ABIJsonTest.cpp
+	../libsolidity/ASTJSONTest.cpp
+	../libsolidity/ASTPropertyTest.cpp
+	../libsolidity/FunctionDependencyGraphTest.cpp
+	../libsolidity/SMTCheckerTest.cpp
+	../libyul/Common.cpp
+	../libyul/ControlFlowGraphTest.cpp
+	../libyul/ControlFlowSideEffectsTest.cpp
+	../libyul/EVMCodeTransformTest.cpp
+	../libyul/FunctionSideEffects.cpp
+	../libyul/ObjectCompilerTest.cpp
+	../libyul/SyntaxTest.cpp
+	../libyul/StackShufflingTest.cpp
+	../libyul/StackLayoutGeneratorTest.cpp
+	../libyul/YulOptimizerTest.cpp
+	../libyul/YulOptimizerTestCommon.cpp
+	../libyul/YulInterpreterTest.cpp
+)
+target_compile_definitions(isoltest PRIVATE ISOLTEST)
+target_link_libraries(isoltest PRIVATE evmc libsolc solidity yulInterpreter evmasm Boost::boost Boost::program_options Boost::unit_test_framework Threads::Threads)
diff --git a/compiler/test/tools/fuzzer_common.cpp b/compiler/test/tools/fuzzer_common.cpp
new file mode 100644
index 00000000..1bb04bf6
--- /dev/null
+++ b/compiler/test/tools/fuzzer_common.cpp
@@ -0,0 +1,226 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/tools/fuzzer_common.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+#include <libsolidity/interface/CompilerStack.h>
+#include <libsolidity/formal/ModelCheckerSettings.h>
+
+#include <libsolutil/JSON.h>
+
+#include <libevmasm/Assembly.h>
+#include <libevmasm/ConstantOptimiser.h>
+
+#include <libsolc/libsolc.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <sstream>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::evmasm;
+using namespace solidity::frontend;
+using namespace solidity::langutil;
+using namespace solidity::util;
+
+static vector<EVMVersion> s_evmVersions = {
+	EVMVersion::homestead(),
+	EVMVersion::tangerineWhistle(),
+	EVMVersion::spuriousDragon(),
+	EVMVersion::byzantium(),
+	EVMVersion::constantinople(),
+	EVMVersion::petersburg(),
+	EVMVersion::istanbul(),
+	EVMVersion::berlin(),
+	EVMVersion::london(),
+	EVMVersion::paris()
+};
+
+void FuzzerUtil::testCompilerJsonInterface(string const& _input, bool _optimize, bool _quiet)
+{
+	if (!_quiet)
+		cout << "Testing compiler " << (_optimize ? "with" : "without") << " optimizer." << endl;
+
+	Json::Value config = Json::objectValue;
+	config["language"] = "Solidity";
+	config["sources"] = Json::objectValue;
+	config["sources"][""] = Json::objectValue;
+	config["sources"][""]["content"] = _input;
+	config["settings"] = Json::objectValue;
+	config["settings"]["optimizer"] = Json::objectValue;
+	config["settings"]["optimizer"]["enabled"] = _optimize;
+	config["settings"]["optimizer"]["runs"] = static_cast<int>(OptimiserSettings{}.expectedExecutionsPerDeployment);
+	config["settings"]["evmVersion"] = "berlin";
+
+	// Enable all SourceUnit-level outputs.
+	config["settings"]["outputSelection"]["*"][""][0] = "*";
+	// Enable all Contract-level outputs.
+	config["settings"]["outputSelection"]["*"]["*"][0] = "*";
+
+	runCompiler(jsonCompactPrint(config), _quiet);
+}
+
+void FuzzerUtil::forceSMT(StringMap& _input)
+{
+	// Add SMT checker pragma if not already present in source
+	static auto constexpr smtPragma = "pragma experimental SMTChecker;";
+	for (auto &sourceUnit: _input)
+		if (sourceUnit.second.find(smtPragma) == string::npos)
+			sourceUnit.second += smtPragma;
+}
+
+void FuzzerUtil::testCompiler(
+	StringMap& _input,
+	bool _optimize,
+	unsigned _rand,
+	bool _forceSMT,
+	bool _compileViaYul
+)
+{
+	frontend::CompilerStack compiler;
+	EVMVersion evmVersion = s_evmVersions[_rand % s_evmVersions.size()];
+	frontend::OptimiserSettings optimiserSettings;
+	if (_optimize)
+		optimiserSettings = frontend::OptimiserSettings::standard();
+	else
+		optimiserSettings = frontend::OptimiserSettings::minimal();
+	if (_forceSMT)
+	{
+		forceSMT(_input);
+		compiler.setModelCheckerSettings({
+			/*bmcLoopIterations*/1,
+			frontend::ModelCheckerContracts::Default(),
+			/*divModWithSlacks*/true,
+			frontend::ModelCheckerEngine::All(),
+			frontend::ModelCheckerExtCalls{},
+			frontend::ModelCheckerInvariants::All(),
+			/*printQuery=*/false,
+			/*showProvedSafe=*/false,
+			/*showUnproved=*/false,
+			/*showUnsupported=*/false,
+			smtutil::SMTSolverChoice::All(),
+			frontend::ModelCheckerTargets::Default(),
+			/*timeout=*/1
+		});
+	}
+	compiler.setSources(_input);
+	compiler.setEVMVersion(evmVersion);
+	compiler.setOptimiserSettings(optimiserSettings);
+	compiler.setViaIR(_compileViaYul);
+	try
+	{
+		compiler.compile();
+	}
+	catch (Error const&)
+	{
+	}
+	catch (FatalError const&)
+	{
+	}
+	catch (UnimplementedFeatureError const&)
+	{
+	}
+	catch (StackTooDeepError const&)
+	{
+		if (_optimize && _compileViaYul)
+			throw;
+	}
+}
+
+void FuzzerUtil::runCompiler(string const& _input, bool _quiet)
+{
+	if (!_quiet)
+		cout << "Input JSON: " << _input << endl;
+	string outputString(solidity_compile(_input.c_str(), nullptr, nullptr));
+	if (!_quiet)
+		cout << "Output JSON: " << outputString << endl;
+
+	// This should be safe given the above copies the output.
+	solidity_reset();
+
+	Json::Value output;
+	if (!jsonParseStrict(outputString, output))
+	{
+		string msg{"Compiler produced invalid JSON output."};
+		cout << msg << endl;
+		BOOST_THROW_EXCEPTION(std::runtime_error(std::move(msg)));
+	}
+	if (output.isMember("errors"))
+		for (auto const& error: output["errors"])
+		{
+			string invalid = findAnyOf(error["type"].asString(), vector<string>{
+					"Exception",
+					"InternalCompilerError"
+			});
+			if (!invalid.empty())
+			{
+				string msg = "Invalid error: \"" + error["type"].asString() + "\"";
+				cout << msg << endl;
+				BOOST_THROW_EXCEPTION(std::runtime_error(std::move(msg)));
+			}
+		}
+}
+
+void FuzzerUtil::testConstantOptimizer(string const& _input, bool _quiet)
+{
+	if (!_quiet)
+		cout << "Testing constant optimizer" << endl;
+	vector<u256> numbers;
+	stringstream sin(_input);
+
+	while (!sin.eof())
+	{
+		h256 data;
+		sin.read(reinterpret_cast<char *>(data.data()), 32);
+		numbers.push_back(u256(data));
+	}
+	if (!_quiet)
+		cout << "Got " << numbers.size() << " inputs:" << endl;
+
+	for (bool isCreation: {false, true})
+	{
+		Assembly assembly{langutil::EVMVersion{}, isCreation, {}};
+		for (u256 const& n: numbers)
+		{
+			if (!_quiet)
+				cout << n << endl;
+			assembly.append(n);
+		}
+		for (unsigned runs: {1u, 2u, 3u, 20u, 40u, 100u, 200u, 400u, 1000u})
+		{
+			// Make a copy here so that each time we start with the original state.
+			Assembly tmp = assembly;
+			ConstantOptimisationMethod::optimiseConstants(
+				isCreation,
+				runs,
+				langutil::EVMVersion{},
+				tmp
+			);
+		}
+	}
+}
+
+void FuzzerUtil::testStandardCompiler(string const& _input, bool _quiet)
+{
+	if (!_quiet)
+		cout << "Testing compiler via JSON interface." << endl;
+
+	runCompiler(_input, _quiet);
+}
diff --git a/compiler/test/tools/isoltest.cpp b/compiler/test/tools/isoltest.cpp
new file mode 100644
index 00000000..2d93bdbc
--- /dev/null
+++ b/compiler/test/tools/isoltest.cpp
@@ -0,0 +1,523 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/AnsiColorized.h>
+
+#include <memory>
+#include <test/Common.h>
+#include <test/tools/IsolTestOptions.h>
+#include <test/InteractiveTests.h>
+#include <test/EVMHost.h>
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/filesystem.hpp>
+
+#include <cstdlib>
+#include <iostream>
+#include <queue>
+#include <regex>
+#include <utility>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::frontend;
+using namespace solidity::frontend::test;
+using namespace solidity::util::formatting;
+
+namespace po = boost::program_options;
+namespace fs = boost::filesystem;
+
+using TestCreator = TestCase::TestCaseCreator;
+using TestOptions = solidity::test::IsolTestOptions;
+
+struct TestStats
+{
+	int successCount = 0;
+	int testCount = 0;
+	int skippedCount = 0;
+	operator bool() const noexcept { return successCount + skippedCount == testCount; }
+	TestStats& operator+=(TestStats const& _other) noexcept
+	{
+		successCount += _other.successCount;
+		testCount += _other.testCount;
+		skippedCount += _other.skippedCount;
+		return *this;
+	}
+};
+
+class TestFilter
+{
+public:
+	explicit TestFilter(string _filter): m_filter(std::move(_filter))
+	{
+		string filter{m_filter};
+
+		boost::replace_all(filter, "/", "\\/");
+		boost::replace_all(filter, "*", ".*");
+
+		m_filterExpression = regex{"(" + filter + "(\\.sol|\\.yul|\\.stack))"};
+	}
+
+	bool matches(fs::path const& _path, string const& _name) const
+	{
+		return regex_match(_name, m_filterExpression) && solidity::test::isValidSemanticTestPath(_path);
+	}
+
+private:
+	string m_filter;
+	regex m_filterExpression;
+};
+
+class TestTool
+{
+public:
+	TestTool(
+		TestCreator _testCaseCreator,
+		TestOptions const& _options,
+		fs::path _path,
+		string _name
+	):
+		m_testCaseCreator(_testCaseCreator),
+		m_options(_options),
+		m_filter(TestFilter{_options.testFilter}),
+		m_path(std::move(_path)),
+		m_name(std::move(_name))
+	{}
+
+	enum class Result
+	{
+		Success,
+		Failure,
+		Exception,
+		Skipped
+	};
+
+	Result process();
+
+	static TestStats processPath(
+		TestCreator _testCaseCreator,
+		TestOptions const& _options,
+		fs::path const& _basepath,
+		fs::path const& _path,
+		solidity::test::Batcher& _batcher
+	);
+private:
+	enum class Request
+	{
+		Skip,
+		Rerun,
+		Quit
+	};
+
+	void updateTestCase();
+	Request handleResponse(bool _exception);
+
+	TestCreator m_testCaseCreator;
+	TestOptions const& m_options;
+	TestFilter m_filter;
+	fs::path const m_path;
+	string const m_name;
+
+	unique_ptr<TestCase> m_test;
+
+	static bool m_exitRequested;
+};
+
+bool TestTool::m_exitRequested = false;
+
+TestTool::Result TestTool::process()
+{
+	bool formatted{!m_options.noColor};
+
+	try
+	{
+		if (m_filter.matches(m_path, m_name))
+		{
+			(AnsiColorized(cout, formatted, {BOLD}) << m_name << ": ").flush();
+
+			m_test = m_testCaseCreator(TestCase::Config{
+				m_path.string(),
+				m_options.evmVersion(),
+				m_options.eofVersion(),
+				m_options.vmPaths,
+				m_options.enforceGasTest,
+				m_options.enforceGasTestMinValue
+			});
+			if (m_test->shouldRun())
+			{
+				std::stringstream outputMessages;
+				switch (TestCase::TestResult result = m_test->run(outputMessages, "  ", formatted))
+				{
+					case TestCase::TestResult::Success:
+						AnsiColorized(cout, formatted, {BOLD, GREEN}) << "OK" << endl;
+						return Result::Success;
+					default:
+						AnsiColorized(cout, formatted, {BOLD, RED}) << "FAIL" << endl;
+
+						AnsiColorized(cout, formatted, {BOLD, CYAN}) << "  Contract:" << endl;
+						m_test->printSource(cout, "    ", formatted);
+						m_test->printSettings(cout, "    ", formatted);
+
+						cout << endl << outputMessages.str() << endl;
+						return result == TestCase::TestResult::FatalError ? Result::Exception : Result::Failure;
+				}
+			}
+			else
+			{
+				AnsiColorized(cout, formatted, {BOLD, YELLOW}) << "NOT RUN" << endl;
+				return Result::Skipped;
+			}
+		}
+		else
+			return Result::Skipped;
+	}
+	catch (boost::exception const& _e)
+	{
+		AnsiColorized(cout, formatted, {BOLD, RED}) <<
+			"Exception during test: " << boost::diagnostic_information(_e) << endl;
+		return Result::Exception;
+	}
+	catch (std::exception const& _e)
+	{
+		AnsiColorized(cout, formatted, {BOLD, RED}) <<
+			"Exception during test: " << boost::diagnostic_information(_e) << endl;
+		return Result::Exception;
+	}
+	catch (...)
+	{
+		AnsiColorized(cout, formatted, {BOLD, RED}) <<
+			"Unknown exception during test: " << boost::current_exception_diagnostic_information() << endl;
+		return Result::Exception;
+	}
+}
+
+void TestTool::updateTestCase()
+{
+	ofstream file(m_path.string(), ios::trunc);
+	m_test->printSource(file);
+	m_test->printUpdatedSettings(file);
+	file << "// ----" << endl;
+	m_test->printUpdatedExpectations(file, "// ");
+}
+
+TestTool::Request TestTool::handleResponse(bool _exception)
+{
+	if (!_exception && m_options.acceptUpdates)
+	{
+		updateTestCase();
+		return Request::Rerun;
+	}
+
+	if (_exception)
+		cout << "(e)dit/(s)kip/(q)uit? ";
+	else
+		cout << "(e)dit/(u)pdate expectations/(s)kip/(q)uit? ";
+	cout.flush();
+
+	while (true)
+	{
+		switch(readStandardInputChar())
+		{
+		case 's':
+			cout << endl;
+			return Request::Skip;
+		case 'u':
+			if (_exception)
+				break;
+			else
+			{
+				cout << endl;
+				updateTestCase();
+				return Request::Rerun;
+			}
+		case 'e':
+			cout << endl << endl;
+			if (system((m_options.editor + " \"" + m_path.string() + "\"").c_str()))
+				cerr << "Error running editor command." << endl << endl;
+			return Request::Rerun;
+		case 'q':
+			cout << endl;
+			return Request::Quit;
+		default:
+			break;
+		}
+	}
+}
+
+TestStats TestTool::processPath(
+	TestCreator _testCaseCreator,
+	TestOptions const& _options,
+	fs::path const& _basepath,
+	fs::path const& _path,
+	solidity::test::Batcher& _batcher
+)
+{
+	std::queue<fs::path> paths;
+	paths.push(_path);
+	int successCount = 0;
+	int testCount = 0;
+	int skippedCount = 0;
+
+	while (!paths.empty())
+	{
+		auto currentPath = paths.front();
+
+		fs::path fullpath = _basepath / currentPath;
+		if (fs::is_directory(fullpath))
+		{
+			paths.pop();
+			for (auto const& entry: boost::iterator_range<fs::directory_iterator>(
+				fs::directory_iterator(fullpath),
+				fs::directory_iterator()
+			))
+				if (fs::is_directory(entry.path()) || TestCase::isTestFilename(entry.path().filename()))
+					paths.push(currentPath / entry.path().filename());
+		}
+		else if (m_exitRequested)
+		{
+			++testCount;
+			paths.pop();
+		}
+		else if (!_batcher.checkAndAdvance())
+		{
+			paths.pop();
+			++skippedCount;
+		}
+		else
+		{
+			++testCount;
+			TestTool testTool(
+				_testCaseCreator,
+				_options,
+				fullpath,
+				currentPath.generic_path().string()
+			);
+			auto result = testTool.process();
+
+			switch(result)
+			{
+			case Result::Failure:
+			case Result::Exception:
+				switch(testTool.handleResponse(result == Result::Exception))
+				{
+				case Request::Quit:
+					paths.pop();
+					m_exitRequested = true;
+					break;
+				case Request::Rerun:
+					cout << "Re-running test case..." << endl;
+					--testCount;
+					break;
+				case Request::Skip:
+					paths.pop();
+					++skippedCount;
+					break;
+				}
+				break;
+			case Result::Success:
+				paths.pop();
+				++successCount;
+				break;
+			case Result::Skipped:
+				paths.pop();
+				++skippedCount;
+				break;
+			}
+		}
+	}
+
+	return { successCount, testCount, skippedCount };
+
+}
+
+namespace
+{
+
+void setupTerminal()
+{
+#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+	// Set output mode to handle virtual terminal (ANSI escape sequences)
+	// ignore any error, as this is just a "nice-to-have"
+	// only windows needs to be taken care of, as other platforms (Linux/OSX) support them natively.
+	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+	if (hOut == INVALID_HANDLE_VALUE)
+		return;
+
+	DWORD dwMode = 0;
+	if (!GetConsoleMode(hOut, &dwMode))
+		return;
+
+	dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+	if (!SetConsoleMode(hOut, dwMode))
+		return;
+#endif
+}
+
+std::optional<TestStats> runTestSuite(
+	TestCreator _testCaseCreator,
+	TestOptions const& _options,
+	fs::path const& _basePath,
+	fs::path const& _subdirectory,
+	string const& _name,
+	solidity::test::Batcher& _batcher
+)
+{
+	fs::path testPath{_basePath / _subdirectory};
+	bool formatted{!_options.noColor};
+
+	if (!fs::exists(testPath) || !fs::is_directory(testPath))
+	{
+		cerr << _name << " tests not found. Use the --testpath argument." << endl;
+		return std::nullopt;
+	}
+
+	TestStats stats = TestTool::processPath(
+		_testCaseCreator,
+		_options,
+		_basePath,
+		_subdirectory,
+		_batcher
+	);
+
+	if (stats.skippedCount != stats.testCount)
+	{
+		cout << endl << _name << " Test Summary: ";
+		AnsiColorized(cout, formatted, {BOLD, stats ? GREEN : RED}) <<
+			stats.successCount <<
+			"/" <<
+			stats.testCount;
+		cout << " tests successful";
+		if (stats.skippedCount > 0)
+		{
+			cout << " (";
+			AnsiColorized(cout, formatted, {BOLD, YELLOW}) << stats.skippedCount;
+			cout<< " tests skipped)";
+		}
+		cout << "." << endl << endl;
+	}
+	return stats;
+}
+
+}
+
+int main(int argc, char const *argv[])
+{
+	using namespace solidity::test;
+
+	try
+	{
+		setupTerminal();
+
+		{
+			auto options = std::make_unique<IsolTestOptions>();
+
+			bool shouldContinue = options->parse(argc, argv);
+			if (!shouldContinue)
+				return EXIT_SUCCESS;
+
+			options->validate();
+			CommonOptions::setSingleton(std::move(options));
+		}
+
+		auto& options = dynamic_cast<IsolTestOptions const&>(CommonOptions::get());
+
+		if (!solidity::test::loadVMs(options))
+			return EXIT_FAILURE;
+
+		if (options.disableSemanticTests)
+			cout << endl << "--- SKIPPING ALL SEMANTICS TESTS ---" << endl << endl;
+
+		if (!options.enforceGasTest)
+			cout << "WARNING :: Gas Cost Expectations are not being enforced" << endl << endl;
+
+		TestStats global_stats{0, 0};
+		cout << "Running tests..." << endl << endl;
+
+		Batcher batcher(CommonOptions::get().selectedBatch, CommonOptions::get().batches);
+		if (CommonOptions::get().batches > 1)
+			cout << "Batch " << CommonOptions::get().selectedBatch << " out of " << CommonOptions::get().batches << endl;
+
+		// Actually run the tests.
+		// Interactive tests are added in InteractiveTests.h
+		for (auto const& ts: g_interactiveTestsuites)
+		{
+			if (ts.needsVM && options.disableSemanticTests)
+				continue;
+
+			if (ts.smt && options.disableSMT)
+				continue;
+
+			auto stats = runTestSuite(
+				ts.testCaseCreator,
+				options,
+				options.testPath / ts.path,
+				ts.subpath,
+				ts.title,
+				batcher
+			);
+			if (stats)
+				global_stats += *stats;
+			else
+				return EXIT_FAILURE;
+		}
+
+		cout << endl << "Summary: ";
+		AnsiColorized(cout, !options.noColor, {BOLD, global_stats ? GREEN : RED}) <<
+			 global_stats.successCount << "/" << global_stats.testCount;
+		cout << " tests successful";
+		if (global_stats.skippedCount > 0)
+		{
+			cout << " (";
+			AnsiColorized(cout, !options.noColor, {BOLD, YELLOW}) << global_stats.skippedCount;
+			cout << " tests skipped)";
+		}
+		cout << "." << endl;
+
+		if (options.disableSemanticTests)
+			cout << "\nNOTE: Skipped semantics tests.\n" << endl;
+
+		return global_stats ? EXIT_SUCCESS : EXIT_FAILURE;
+	}
+	catch (boost::program_options::error const& exception)
+	{
+		cerr << exception.what() << endl;
+		return 2;
+	}
+	catch (std::runtime_error const& exception)
+	{
+		cerr << exception.what() << endl;
+		return 2;
+	}
+	catch (solidity::test::ConfigException const& exception)
+	{
+		cerr << exception.what() << endl;
+		return 2;
+	}
+	catch (...)
+	{
+		cerr << "Unhandled exception caught." << endl;
+		cerr << boost::current_exception_diagnostic_information() << endl;
+		return 2;
+	}
+}
diff --git a/compiler/test/tools/ossfuzz/CMakeLists.txt b/compiler/test/tools/ossfuzz/CMakeLists.txt
new file mode 100644
index 00000000..9449eddb
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/CMakeLists.txt
@@ -0,0 +1,271 @@
+add_custom_target(ossfuzz)
+add_dependencies(ossfuzz
+        solc_ossfuzz
+        solc_mutator_ossfuzz
+        const_opt_ossfuzz
+        strictasm_diff_ossfuzz
+        strictasm_opt_ossfuzz
+        strictasm_assembly_ossfuzz
+)
+
+if (OSSFUZZ)
+    add_custom_target(ossfuzz_proto)
+    add_dependencies(ossfuzz_proto
+            sol_proto_ossfuzz
+            yul_proto_ossfuzz
+            yul_proto_diff_ossfuzz
+            yul_proto_diff_custom_mutate_ossfuzz
+            stack_reuse_codegen_ossfuzz
+    )
+
+    add_custom_target(ossfuzz_abiv2)
+    add_dependencies(ossfuzz_abiv2 abiv2_proto_ossfuzz abiv2_isabelle_ossfuzz)
+endif()
+
+if (OSSFUZZ)
+    add_executable(solc_ossfuzz
+            solc_ossfuzz.cpp
+            ../fuzzer_common.cpp
+            ../../TestCaseReader.cpp
+    )
+    target_link_libraries(solc_ossfuzz PRIVATE libsolc evmasm)
+    set_target_properties(solc_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(solc_mutator_ossfuzz
+            solc_ossfuzz.cpp
+            ../fuzzer_common.cpp
+            ../../TestCaseReader.cpp
+            SolidityGenerator.cpp
+            SolidityCustomMutatorInterface.cpp
+    )
+    target_link_libraries(solc_mutator_ossfuzz PRIVATE libsolc evmasm)
+    set_target_properties(solc_mutator_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(const_opt_ossfuzz const_opt_ossfuzz.cpp ../fuzzer_common.cpp)
+    target_link_libraries(const_opt_ossfuzz PRIVATE libsolc evmasm)
+    set_target_properties(const_opt_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(strictasm_diff_ossfuzz strictasm_diff_ossfuzz.cpp yulFuzzerCommon.cpp)
+    target_link_libraries(strictasm_diff_ossfuzz PRIVATE libsolc evmasm yulInterpreter)
+    set_target_properties(strictasm_diff_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(strictasm_opt_ossfuzz strictasm_opt_ossfuzz.cpp)
+    target_link_libraries(strictasm_opt_ossfuzz PRIVATE yul)
+    set_target_properties(strictasm_opt_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(strictasm_assembly_ossfuzz strictasm_assembly_ossfuzz.cpp)
+    target_link_libraries(strictasm_assembly_ossfuzz PRIVATE yul)
+    set_target_properties(strictasm_assembly_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+
+    add_executable(yul_proto_ossfuzz
+	    yulProtoFuzzer.cpp
+	    protoToYul.cpp
+	    yulProto.pb.cc
+	    ../../libyul/YulOptimizerTestCommon.cpp
+    )
+    target_include_directories(yul_proto_ossfuzz PRIVATE /usr/include/libprotobuf-mutator)
+    target_link_libraries(yul_proto_ossfuzz PRIVATE yul
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(yul_proto_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    # The -Wno-* compile options are required for source files that
+    # are auto-generated by the protobuf compiler because the compiler
+    # does not generate warning-free C++ bindings with regard to
+    # upstream Clang builds that are used by ossfuzz.
+    target_compile_options(yul_proto_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+
+    add_executable(
+	    yul_proto_diff_ossfuzz
+	    yulProto_diff_ossfuzz.cpp
+	    yulFuzzerCommon.cpp
+	    protoToYul.cpp
+	    yulProto.pb.cc
+	    ../../libyul/YulOptimizerTestCommon.cpp
+    )
+    target_include_directories(yul_proto_diff_ossfuzz PRIVATE /usr/include/libprotobuf-mutator)
+    target_link_libraries(yul_proto_diff_ossfuzz PRIVATE yul
+            yulInterpreter
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(yul_proto_diff_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(yul_proto_diff_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+
+    add_executable(yul_proto_diff_custom_mutate_ossfuzz
+            yulProto_diff_ossfuzz.cpp
+            yulFuzzerCommon.cpp
+            protoToYul.cpp
+            yulProto.pb.cc
+            protomutators/YulProtoMutator.cpp
+            ../../libyul/YulOptimizerTestCommon.cpp
+    )
+    target_include_directories(yul_proto_diff_custom_mutate_ossfuzz PRIVATE /usr/include/libprotobuf-mutator)
+    target_link_libraries(yul_proto_diff_custom_mutate_ossfuzz PRIVATE yul
+            yulInterpreter
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(yul_proto_diff_custom_mutate_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(yul_proto_diff_custom_mutate_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+
+    add_executable(stack_reuse_codegen_ossfuzz
+            StackReuseCodegenFuzzer.cpp
+            protoToYul.cpp
+            yulProto.pb.cc
+            ../../EVMHost.cpp
+            YulEvmoneInterface.cpp
+    )
+    target_include_directories(stack_reuse_codegen_ossfuzz PRIVATE /usr/include/libprotobuf-mutator)
+    target_link_libraries(stack_reuse_codegen_ossfuzz PRIVATE yul
+            evmc
+            evmone-standalone
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(stack_reuse_codegen_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(stack_reuse_codegen_ossfuzz PUBLIC
+            ${COMPILE_OPTIONS}
+            -Wno-sign-conversion
+            -Wno-inconsistent-missing-destructor-override
+            -Wno-unused-parameter
+            -Wno-zero-length-array
+            -Wno-suggest-destructor-override
+            -Wno-shorten-64-to-32
+    )
+
+    add_executable(abiv2_proto_ossfuzz
+            ../../EVMHost.cpp
+            abiV2ProtoFuzzer.cpp
+            SolidityEvmoneInterface.cpp
+            protoToAbiV2.cpp
+            abiV2Proto.pb.cc
+    )
+    target_include_directories(abiv2_proto_ossfuzz PRIVATE
+            /usr/include/libprotobuf-mutator
+    )
+    target_link_libraries(abiv2_proto_ossfuzz PRIVATE solidity
+            evmc
+            evmone-standalone
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(abiv2_proto_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(abiv2_proto_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+
+    add_executable(abiv2_isabelle_ossfuzz
+            AbiV2IsabelleFuzzer.cpp
+            SolidityEvmoneInterface.cpp
+            ../../EVMHost.cpp
+            protoToAbiV2.cpp
+            abiV2Proto.pb.cc
+    )
+    target_include_directories(abiv2_isabelle_ossfuzz PRIVATE
+            /usr/include/libprotobuf-mutator
+    )
+    target_link_libraries(abiv2_isabelle_ossfuzz PRIVATE solidity
+            evmc
+            evmone-standalone
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+            abicoder
+            gmp.a
+    )
+    set_target_properties(abiv2_isabelle_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(abiv2_isabelle_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+
+    add_executable(sol_proto_ossfuzz
+            solProtoFuzzer.cpp
+            SolidityEvmoneInterface.cpp
+            protoToSol.cpp
+            solProto.pb.cc
+            ../../EVMHost.cpp
+    )
+    target_include_directories(sol_proto_ossfuzz PRIVATE
+            /usr/include/libprotobuf-mutator
+    )
+    target_link_libraries(sol_proto_ossfuzz PRIVATE solidity libsolc
+            evmc
+            evmone-standalone
+            protobuf-mutator-libfuzzer.a
+            protobuf-mutator.a
+            protobuf.a
+    )
+    set_target_properties(sol_proto_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
+    target_compile_options(sol_proto_ossfuzz PUBLIC ${COMPILE_OPTIONS} -Wno-sign-conversion -Wno-suggest-destructor-override -Wno-inconsistent-missing-destructor-override -Wno-shorten-64-to-32)
+else()
+    add_library(solc_ossfuzz
+            solc_ossfuzz.cpp
+            ../fuzzer_common.cpp
+            )
+    target_link_libraries(solc_ossfuzz PRIVATE libsolc evmasm)
+
+    add_library(solc_mutator_ossfuzz
+            solc_ossfuzz.cpp
+            ../fuzzer_common.cpp
+            )
+    target_link_libraries(solc_mutator_ossfuzz PRIVATE libsolc evmasm)
+
+    add_library(const_opt_ossfuzz
+            const_opt_ossfuzz.cpp
+            ../fuzzer_common.cpp)
+    target_link_libraries(const_opt_ossfuzz PRIVATE libsolc evmasm)
+
+    add_library(strictasm_diff_ossfuzz
+            strictasm_diff_ossfuzz.cpp
+            yulFuzzerCommon.cpp
+            )
+    target_link_libraries(strictasm_diff_ossfuzz PRIVATE libsolc evmasm yulInterpreter)
+
+    add_library(strictasm_opt_ossfuzz
+            strictasm_opt_ossfuzz.cpp
+            )
+    target_link_libraries(strictasm_opt_ossfuzz PRIVATE yul)
+
+    add_library(strictasm_assembly_ossfuzz
+            strictasm_assembly_ossfuzz.cpp
+            )
+    target_link_libraries(strictasm_assembly_ossfuzz PRIVATE yul)
+
+#    add_executable(yul_proto_ossfuzz yulProtoFuzzer.cpp protoToYul.cpp yulProto.pb.cc)
+#    target_include_directories(yul_proto_ossfuzz PRIVATE /src/libprotobuf-mutator /src/LPM/external.protobuf/include)
+#    target_link_libraries(yul_proto_ossfuzz PRIVATE yul
+#            protobuf-mutator-libfuzzer.a
+#            protobuf-mutator.a
+#            protobuf.a
+#            FuzzingEngine.a)
+#
+#    add_executable(yul_proto_diff_ossfuzz yulProto_diff_ossfuzz.cpp yulFuzzerCommon.cpp protoToYul.cpp yulProto.pb.cc)
+#    target_include_directories(yul_proto_diff_ossfuzz PRIVATE /src/libprotobuf-mutator /src/LPM/external.protobuf/include)
+#    target_link_libraries(yul_proto_diff_ossfuzz PRIVATE yul
+#            yulInterpreter
+#            protobuf-mutator-libfuzzer.a
+#            protobuf-mutator.a
+#            protobuf.a
+#            FuzzingEngine.a)
+#    add_executable(abiv2_proto_ossfuzz
+#            ../../EVMHost.cpp
+#            abiV2ProtoFuzzer.cpp
+#            abiV2FuzzerCommon.cpp
+#            protoToAbiV2.cpp
+#            abiV2Proto.pb.cc
+#    )
+#    target_include_directories(abiv2_proto_ossfuzz PRIVATE
+#            /src/LPM/external.protobuf/include
+#            /src/libprotobuf-mutator
+#            /src/evmone/include
+#    )
+#    target_link_libraries(abiv2_proto_ossfuzz PRIVATE solidity
+#            evmone intx ethash keccak evmc-instructions evmc
+#            protobuf-mutator-libfuzzer.a
+#            protobuf-mutator.a
+#            protobuf.a
+#            FuzzingEngine.a
+#    )
+endif()
diff --git a/compiler/test/tools/ossfuzz/README.md b/compiler/test/tools/ossfuzz/README.md
new file mode 100644
index 00000000..9343602d
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/README.md
@@ -0,0 +1,76 @@
+## Intro
+
+[oss-fuzz][1] is Google's fuzzing infrastructure that performs continuous fuzzing. What this means is that, each and every upstream commit is automatically fetched by the infrastructure and fuzzed on a daily basis.
+
+## How to build fuzzers?
+
+We have multiple fuzzers, some based on string input and others on protobuf input. To build them, please do the following:
+
+- Create a local docker image from `Dockerfile.ubuntu.clang.ossfuzz` in the `.circleci/docker` sub-directory. Please note that this step is likely to take at least an hour to complete. Therefore, it is recommended to do it when you are away from the computer (and the computer is plugged to power since we do not want a battery drain).
+
+```
+$ cd .circleci/docker
+$ docker build -t solidity-ossfuzz-local -f Dockerfile.ubuntu.clang.ossfuzz .
+```
+
+- Login to the docker container sourced from the image built in the previous step from the solidity parent directory
+
+```
+## Host
+$ cd solidity
+$ docker run -v `pwd`:/src/solidity -ti solidity-ossfuzz-local /bin/bash
+## Docker shell
+$ cd /src/solidity
+```
+
+- Run cmake and build fuzzer harnesses
+
+```
+## Docker shell
+$ cd /src/solidity
+$ rm -rf fuzzer-build && mkdir fuzzer-build && cd fuzzer-build
+## Compile protobuf C++ bindings
+$ protoc --proto_path=../test/tools/ossfuzz yulProto.proto --cpp_out=../test/tools/ossfuzz
+$ protoc --proto_path=../test/tools/ossfuzz abiV2Proto.proto --cpp_out=../test/tools/ossfuzz
+## Run cmake
+$ export CC=clang CXX=clang++
+$ cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/libfuzzer.cmake -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE:-Release} ..
+$ make ossfuzz ossfuzz_proto ossfuzz_abiv2 -j
+```
+
+## Why the elaborate docker image to build fuzzers?
+
+For the following reasons:
+
+- Fuzzing binaries **must** link against libc++ and not libstdc++
+  - This is [because][2] (1) MemorySanitizer (which flags uses of uninitialized memory) depends on libc++; and (2) because libc++ is instrumented (to check for memory and type errors) and libstdc++ not, the former may find more bugs.
+
+- Linking against libc++ requires us to compile everything solidity depends on from source (and link these against libc++ as well)
+
+- To reproduce the compiler versions used by upstream oss-fuzz bots, we need to reuse their docker image containing the said compiler versions
+
+- Some fuzzers depend on libprotobuf, libprotobuf-mutator, libevmone etc. which may not be available locally; even if they were they might not be the right versions
+
+## What is LIB\_FUZZING\_ENGINE?
+
+oss-fuzz contains multiple fuzzer back-ends i.e., fuzzers. Each back-end may require different linker flags. oss-fuzz builder bot defines the correct linker flags via a bash environment variable called `LIB_FUZZING_ENGINE`.
+
+For the solidity ossfuzz CI build, we use the libFuzzer back-end. This back-end requires us to manually set the `LIB_FUZZING_ENGINE` to `-fsanitize=fuzzer`.
+
+## What does the ossfuzz directory contain?
+
+To help oss-fuzz do this, we (as project maintainers) need to provide the following:
+
+- test harnesses: C/C++ tests that define the `LLVMFuzzerTestOneInput` API. This determines what is to be fuzz tested.
+- build infrastructure: (c)make targets per fuzzing binary. Fuzzing requires coverage and memory instrumentation of the code to be fuzzed.
+- configuration files: These are files with the `.options` extension that are parsed by oss-fuzz. The only option that we use currently is the `dictionary` option that asks the fuzzing engines behind oss-fuzz to use the specified dictionary. The specified dictionary happens to be `solidity.dict.`
+
+`solidity.dict` contains Solidity-specific syntactical tokens that are more likely to guide the fuzzer towards generating parseable and varied Solidity input.
+
+To be consistent and aid better evaluation of the utility of the fuzzing dictionary, we stick to the following rules-of-thumb:
+  - Full tokens such as `block.number` are preceded and followed by a whitespace
+  - Incomplete tokens including function calls such as `msg.sender.send()` are abbreviated `.send(` to provide some leeway to the fuzzer to sythesize variants such as `address(this).send()`
+  - Language keywords are suffixed by a whitespace with the exception of those that end a line of code such as `break;` and `continue;`
+
+[1]: https://github.com/google/oss-fuzz
+[2]: https://github.com/google/oss-fuzz/issues/1114#issuecomment-360660201
diff --git a/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.cpp b/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.cpp
new file mode 100644
index 00000000..34147090
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.cpp
@@ -0,0 +1,188 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/tools/ossfuzz/SolidityEvmoneInterface.h>
+
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <range/v3/algorithm/all_of.hpp>
+#include <range/v3/span.hpp>
+
+using namespace solidity::test::fuzzer;
+using namespace solidity::frontend;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace std;
+
+optional<CompilerOutput> SolidityCompilationFramework::compileContract()
+{
+	m_compiler.setSources(m_compilerInput.sourceCode);
+	m_compiler.setLibraries(m_compilerInput.libraryAddresses);
+	m_compiler.setEVMVersion(m_compilerInput.evmVersion);
+	m_compiler.setOptimiserSettings(m_compilerInput.optimiserSettings);
+	m_compiler.setViaIR(m_compilerInput.viaIR);
+	if (!m_compiler.compile())
+	{
+		if (m_compilerInput.debugFailure)
+		{
+			cerr << "Compiling contract failed" << endl;
+			cerr << SourceReferenceFormatter::formatErrorInformation(
+				m_compiler.errors(),
+				m_compiler
+			);
+		}
+		return {};
+	}
+	else
+	{
+		string contractName;
+		if (m_compilerInput.contractName.empty())
+			contractName = m_compiler.lastContractName();
+		else
+			contractName = m_compilerInput.contractName;
+		evmasm::LinkerObject obj = m_compiler.object(contractName);
+		Json::Value methodIdentifiers = m_compiler.interfaceSymbols(contractName)["methods"];
+		return CompilerOutput{obj.bytecode, methodIdentifiers};
+	}
+}
+
+bool EvmoneUtility::zeroWord(uint8_t const* _result, size_t _length)
+{
+	return _length == 32 &&
+		ranges::all_of(
+			ranges::span(_result, static_cast<long>(_length)),
+			[](uint8_t _v) { return _v == 0; });
+}
+
+evmc_message EvmoneUtility::initializeMessage(bytes const& _input)
+{
+	// Zero initialize all message fields
+	evmc_message msg = {};
+	// Gas available (value of type int64_t) is set to its maximum
+	// value.
+	msg.gas = std::numeric_limits<int64_t>::max();
+	msg.input_data = _input.data();
+	msg.input_size = _input.size();
+	return msg;
+}
+
+evmc::Result EvmoneUtility::executeContract(
+	bytes const& _functionHash,
+	evmc_address _deployedAddress
+)
+{
+	evmc_message message = initializeMessage(_functionHash);
+	message.recipient = _deployedAddress;
+	message.code_address = _deployedAddress;
+	message.kind = EVMC_CALL;
+	return m_evmHost.call(message);
+}
+
+evmc::Result EvmoneUtility::deployContract(bytes const& _code)
+{
+	evmc_message message = initializeMessage(_code);
+	message.kind = EVMC_CREATE;
+	return m_evmHost.call(message);
+}
+
+evmc::Result EvmoneUtility::deployAndExecute(
+	bytes const& _byteCode,
+	string const& _hexEncodedInput
+)
+{
+	// Deploy contract and signal failure if deploy failed
+	evmc::Result createResult = deployContract(_byteCode);
+	solAssert(
+		createResult.status_code == EVMC_SUCCESS,
+		"SolidityEvmoneInterface: Contract creation failed"
+	);
+
+	// Execute test function and signal failure if EVM reverted or
+	// did not return expected output on successful execution.
+	evmc::Result callResult = executeContract(
+		util::fromHex(_hexEncodedInput),
+		createResult.create_address
+	);
+
+	// We don't care about EVM One failures other than EVMC_REVERT
+	solAssert(
+		callResult.status_code != EVMC_REVERT,
+		"SolidityEvmoneInterface: EVM One reverted"
+	);
+	return callResult;
+}
+
+evmc::Result EvmoneUtility::compileDeployAndExecute(string _fuzzIsabelle)
+{
+	map<string, h160> libraryAddressMap;
+	// Stage 1: Compile and deploy library if present.
+	if (!m_libraryName.empty())
+	{
+		m_compilationFramework.contractName(m_libraryName);
+		auto compilationOutput = m_compilationFramework.compileContract();
+		solAssert(compilationOutput.has_value(), "Compiling library failed");
+		CompilerOutput cOutput = compilationOutput.value();
+		// Deploy contract and signal failure if deploy failed
+		evmc::Result createResult = deployContract(cOutput.byteCode);
+		solAssert(
+			createResult.status_code == EVMC_SUCCESS,
+			"SolidityEvmoneInterface: Library deployment failed"
+		);
+		libraryAddressMap[m_libraryName] = EVMHost::convertFromEVMC(createResult.create_address);
+		m_compilationFramework.libraryAddresses(libraryAddressMap);
+	}
+
+	// Stage 2: Compile, deploy, and execute contract, optionally using library
+	// address map.
+	m_compilationFramework.contractName(m_contractName);
+	auto cOutput = m_compilationFramework.compileContract();
+	solAssert(cOutput.has_value(), "Compiling contract failed");
+	solAssert(
+		!cOutput->byteCode.empty() && !cOutput->methodIdentifiersInContract.empty(),
+		"SolidityEvmoneInterface: Invalid compilation output."
+	);
+
+	string methodName;
+	if (!_fuzzIsabelle.empty())
+		// TODO: Remove this once a cleaner solution is found for querying
+		// isabelle test entry point. At the moment, we are sure that the
+		// entry point is the second method in the contract (hence the ++)
+		// but not its name.
+		methodName = (++cOutput->methodIdentifiersInContract.begin())->asString() +
+			_fuzzIsabelle.substr(2, _fuzzIsabelle.size());
+	else
+		methodName = cOutput->methodIdentifiersInContract[m_methodName].asString();
+
+	return deployAndExecute(
+		cOutput->byteCode,
+		methodName
+	);
+}
+
+optional<CompilerOutput> EvmoneUtility::compileContract()
+{
+	try
+	{
+		return m_compilationFramework.compileContract();
+	}
+	catch (evmasm::StackTooDeepException const&)
+	{
+		return {};
+	}
+}
diff --git a/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.h b/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.h
new file mode 100644
index 00000000..ea684ea7
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/SolidityEvmoneInterface.h
@@ -0,0 +1,174 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <test/EVMHost.h>
+
+#include <libsolidity/interface/CompilerStack.h>
+
+#include <libyul/YulStack.h>
+
+#include <libsolutil/Keccak256.h>
+
+#include <evmone/evmone.h>
+
+namespace solidity::test::fuzzer
+{
+struct CompilerOutput
+{
+	/// EVM bytecode returned by compiler
+	solidity::bytes byteCode;
+	/// Method identifiers in a contract
+	Json::Value methodIdentifiersInContract;
+};
+
+struct CompilerInput
+{
+	CompilerInput(
+		langutil::EVMVersion _evmVersion,
+		StringMap const& _sourceCode,
+		std::string const& _contractName,
+		frontend::OptimiserSettings _optimiserSettings,
+		std::map<std::string, solidity::util::h160> _libraryAddresses,
+		bool _debugFailure = false,
+		bool _viaIR = false
+	):
+		evmVersion(_evmVersion),
+		sourceCode(_sourceCode),
+		contractName(_contractName),
+		optimiserSettings(_optimiserSettings),
+		libraryAddresses(_libraryAddresses),
+		debugFailure(_debugFailure),
+		viaIR(_viaIR)
+	{}
+	/// EVM target version
+	langutil::EVMVersion evmVersion;
+	/// Source code to be compiled
+	StringMap const& sourceCode;
+	/// Contract name without a colon prefix
+	std::string contractName;
+	/// Optimiser setting to be used during compilation
+	frontend::OptimiserSettings optimiserSettings;
+	/// Information on which library is deployed where
+	std::map<std::string, solidity::util::h160> libraryAddresses;
+	/// Flag used for debugging
+	bool debugFailure;
+	/// Flag to enable new code generator.
+	bool viaIR;
+};
+
+class SolidityCompilationFramework
+{
+public:
+	SolidityCompilationFramework(CompilerInput _input): m_compilerInput(_input)
+	{}
+	/// Sets contract name to @param _contractName.
+	void contractName(std::string const& _contractName)
+	{
+		m_compilerInput.contractName = _contractName;
+	}
+	/// Sets library addresses to @param _libraryAddresses.
+	void libraryAddresses(std::map<std::string, solidity::util::h160> _libraryAddresses)
+	{
+		m_compilerInput.libraryAddresses = std::move(_libraryAddresses);
+	}
+	/// @returns method identifiers in contract called @param _contractName.
+	Json::Value methodIdentifiers(std::string const& _contractName)
+	{
+		return m_compiler.interfaceSymbols(_contractName)["methods"];
+	}
+	/// @returns Compilation output comprising EVM bytecode and list of
+	/// method identifiers in contract if compilation is successful,
+	/// null value otherwise.
+	std::optional<CompilerOutput> compileContract();
+private:
+	frontend::CompilerStack m_compiler;
+	CompilerInput m_compilerInput;
+};
+
+class EvmoneUtility
+{
+public:
+	EvmoneUtility(
+		solidity::test::EVMHost& _evmHost,
+		CompilerInput _compilerInput,
+		std::string const& _contractName,
+		std::string const& _libraryName,
+		std::string const& _methodName
+	):
+		m_evmHost(_evmHost),
+		m_compilationFramework(_compilerInput),
+		m_contractName(_contractName),
+		m_libraryName(_libraryName),
+		m_methodName(_methodName)
+	{}
+	/// @returns the result returned by the EVM host on compiling, deploying,
+	/// and executing test configuration.
+	/// @param _isabelleData contains encoding data to be passed to the
+	/// isabelle test entry point.
+	evmc::Result compileDeployAndExecute(std::string _isabelleData = {});
+	/// Compares the contents of the memory address pointed to
+	/// by `_result` of `_length` bytes to u256 zero.
+	/// @returns true if `_result` is zero, false
+	/// otherwise.
+	static bool zeroWord(uint8_t const* _result, size_t _length);
+	/// @returns an evmc_message with all of its fields zero
+	/// initialized except gas and input fields.
+	/// The gas field is set to the maximum permissible value so that we
+	/// don't run into out of gas errors. The input field is copied from
+	/// @param _input.
+	static evmc_message initializeMessage(bytes const& _input);
+private:
+	/// @returns the result of the execution of the function whose
+	/// keccak256 hash is @param _functionHash that is deployed at
+	/// @param _deployedAddress in @param _hostContext.
+	evmc::Result executeContract(
+		bytes const& _functionHash,
+		evmc_address _deployedAddress
+	);
+	/// @returns the result of deployment of @param _code on @param _hostContext.
+	evmc::Result deployContract(bytes const& _code);
+	/// Deploys and executes EVM byte code in @param _byteCode on
+	/// EVM Host referenced by @param _hostContext. Input passed
+	/// to execution context is @param _hexEncodedInput.
+	/// @returns result returning by @param _hostContext.
+	evmc::Result deployAndExecute(
+		bytes const& _byteCode,
+		std::string const& _hexEncodedInput
+	);
+	/// Compiles contract named @param _contractName present in
+	/// @param _sourceCode, optionally using a precompiled library
+	/// specified via a library mapping and an optimisation setting.
+	/// @returns a pair containing the generated byte code and method
+	/// identifiers for methods in @param _contractName.
+	std::optional<CompilerOutput> compileContract();
+
+	/// EVM Host implementation
+	solidity::test::EVMHost& m_evmHost;
+	/// Solidity compilation framework
+	SolidityCompilationFramework m_compilationFramework;
+	/// Contract name
+	std::string m_contractName;
+	/// Library name
+	std::string m_libraryName;
+	/// Method name
+	std::string m_methodName;
+};
+
+}
diff --git a/compiler/test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp b/compiler/test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp
new file mode 100644
index 00000000..fb502af5
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/StackReuseCodegenFuzzer.cpp
@@ -0,0 +1,209 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/tools/ossfuzz/yulProto.pb.h>
+#include <test/tools/ossfuzz/protoToYul.h>
+
+#include <test/EVMHost.h>
+
+#include <test/tools/ossfuzz/YulEvmoneInterface.h>
+
+#include <libyul/Exceptions.h>
+
+#include <libyul/backends/evm/EVMCodeTransform.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <libyul/optimiser/CallGraphGenerator.h>
+#include <libyul/CompilabilityChecker.h>
+
+#include <libevmasm/Instruction.h>
+
+#include <liblangutil/EVMVersion.h>
+
+#include <evmone/evmone.h>
+
+#include <src/libfuzzer/libfuzzer_macro.h>
+
+#include <fstream>
+
+using namespace solidity;
+using namespace solidity::test;
+using namespace solidity::test::fuzzer;
+using namespace solidity::yul;
+using namespace solidity::yul::test::yul_fuzzer;
+using namespace solidity::langutil;
+using namespace std;
+
+static evmc::VM evmone = evmc::VM{evmc_create_evmone()};
+
+namespace
+{
+/// @returns true if there are recursive functions, false otherwise.
+bool recursiveFunctionExists(Dialect const& _dialect, yul::Object& _object)
+{
+	auto recursiveFunctions = CallGraphGenerator::callGraph(*_object.code).recursiveFunctions();
+	for(auto&& [function, variables]: CompilabilityChecker{
+			_dialect,
+			_object,
+			true
+		}.unreachableVariables
+	)
+		if(recursiveFunctions.count(function))
+			return true;
+	return false;
+}
+}
+
+DEFINE_PROTO_FUZZER(Program const& _input)
+{
+	// Solidity creates an invalid instruction for subobjects, so we simply
+	// ignore them in this fuzzer.
+	if (_input.has_obj())
+		return;
+	bool filterStatefulInstructions = true;
+	bool filterUnboundedLoops = true;
+	ProtoConverter converter(
+		filterStatefulInstructions,
+		filterUnboundedLoops
+	);
+	string yul_source = converter.programToString(_input);
+	// Do not fuzz the EVM Version field.
+	// See https://github.com/ethereum/solidity/issues/12590
+	langutil::EVMVersion version;
+	EVMHost hostContext(version, evmone);
+	hostContext.reset();
+
+	if (const char* dump_path = getenv("PROTO_FUZZER_DUMP_PATH"))
+	{
+		ofstream of(dump_path);
+		of.write(yul_source.data(), static_cast<streamsize>(yul_source.size()));
+	}
+
+	YulStringRepository::reset();
+
+	solidity::frontend::OptimiserSettings settings = solidity::frontend::OptimiserSettings::full();
+	settings.runYulOptimiser = false;
+	settings.optimizeStackAllocation = false;
+	bytes unoptimisedByteCode;
+	bool recursiveFunction = false;
+	bool unoptimizedStackTooDeep = false;
+	try
+	{
+		YulAssembler assembler{version, nullopt, settings, yul_source};
+		unoptimisedByteCode = assembler.assemble();
+		auto yulObject = assembler.object();
+		recursiveFunction = recursiveFunctionExists(
+			EVMDialect::strictAssemblyForEVMObjects(version),
+			*yulObject
+		);
+	}
+	catch (solidity::yul::StackTooDeepError const&)
+	{
+		unoptimizedStackTooDeep = true;
+	}
+
+	ostringstream unoptimizedState;
+	bool noRevertInSource = true;
+	bool noInvalidInSource = true;
+	if (!unoptimizedStackTooDeep)
+	{
+		evmc::Result deployResult = YulEvmoneUtility{}.deployCode(unoptimisedByteCode, hostContext);
+		if (deployResult.status_code != EVMC_SUCCESS)
+			return;
+		auto callMessage = YulEvmoneUtility{}.callMessage(deployResult.create_address);
+		evmc::Result callResult = hostContext.call(callMessage);
+		// If the fuzzer synthesized input does not contain the revert opcode which
+		// we lazily check by string find, the EVM call should not revert.
+		noRevertInSource = yul_source.find("revert") == string::npos;
+		noInvalidInSource = yul_source.find("invalid") == string::npos;
+		if (noInvalidInSource)
+			solAssert(
+				callResult.status_code != EVMC_INVALID_INSTRUCTION,
+				"Invalid instruction."
+			);
+		if (noRevertInSource)
+			solAssert(
+				callResult.status_code != EVMC_REVERT,
+				"SolidityEvmoneInterface: EVM One reverted"
+			);
+		// Bail out on serious errors encountered during a call.
+		if (YulEvmoneUtility{}.seriousCallError(callResult.status_code))
+			return;
+		solAssert(
+			(callResult.status_code == EVMC_SUCCESS ||
+			(!noRevertInSource && callResult.status_code == EVMC_REVERT) ||
+			(!noInvalidInSource && callResult.status_code == EVMC_INVALID_INSTRUCTION)),
+			"Unoptimised call failed."
+		);
+		unoptimizedState << EVMHostPrinter{hostContext, deployResult.create_address}.state();
+	}
+
+	settings.runYulOptimiser = true;
+	settings.optimizeStackAllocation = true;
+	bytes optimisedByteCode;
+	try
+	{
+		optimisedByteCode = YulAssembler{version, nullopt, settings, yul_source}.assemble();
+	}
+	catch (solidity::yul::StackTooDeepError const&)
+	{
+		if (!recursiveFunction)
+			throw;
+		else
+			return;
+	}
+
+	if (unoptimizedStackTooDeep)
+		return;
+	// Reset host before running optimised code.
+	hostContext.reset();
+	evmc::Result deployResultOpt = YulEvmoneUtility{}.deployCode(optimisedByteCode, hostContext);
+	solAssert(
+		deployResultOpt.status_code == EVMC_SUCCESS,
+		"Evmone: Optimized contract creation failed"
+	);
+	auto callMessageOpt = YulEvmoneUtility{}.callMessage(deployResultOpt.create_address);
+	evmc::Result callResultOpt = hostContext.call(callMessageOpt);
+	if (noRevertInSource)
+		solAssert(
+			callResultOpt.status_code != EVMC_REVERT,
+			"SolidityEvmoneInterface: EVM One reverted"
+		);
+	if (noInvalidInSource)
+		solAssert(
+			callResultOpt.status_code != EVMC_INVALID_INSTRUCTION,
+			"Invalid instruction."
+		);
+	solAssert(
+		(callResultOpt.status_code == EVMC_SUCCESS ||
+		 (!noRevertInSource && callResultOpt.status_code == EVMC_REVERT) ||
+		 (!noInvalidInSource && callResultOpt.status_code == EVMC_INVALID_INSTRUCTION)),
+		"Optimised call failed."
+	);
+	ostringstream optimizedState;
+	optimizedState << EVMHostPrinter{hostContext, deployResultOpt.create_address}.state();
+
+	if (unoptimizedState.str() != optimizedState.str())
+	{
+		cout << unoptimizedState.str() << endl;
+		cout << optimizedState.str() << endl;
+		solAssert(
+			false,
+			"State of unoptimised and optimised stack reused code do not match."
+		);
+	}
+}
diff --git a/compiler/test/tools/ossfuzz/YulEvmoneInterface.cpp b/compiler/test/tools/ossfuzz/YulEvmoneInterface.cpp
new file mode 100644
index 00000000..b8924544
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/YulEvmoneInterface.cpp
@@ -0,0 +1,104 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/tools/ossfuzz/YulEvmoneInterface.h>
+
+#include <libyul/Exceptions.h>
+
+using namespace solidity;
+using namespace solidity::test::fuzzer;
+using namespace solidity::yul;
+
+bytes YulAssembler::assemble()
+{
+	if (
+		!m_stack.parseAndAnalyze("source", m_yulProgram) ||
+		!m_stack.parserResult()->code ||
+		!m_stack.parserResult()->analysisInfo ||
+		langutil::Error::containsErrors(m_stack.errors())
+	)
+		yulAssert(false, "Yul program could not be parsed successfully.");
+
+	if (m_optimiseYul)
+		m_stack.optimize();
+	return m_stack.assemble(YulStack::Machine::EVM).bytecode->bytecode;
+}
+
+std::shared_ptr<yul::Object> YulAssembler::object()
+{
+	return m_stack.parserResult();
+}
+
+evmc::Result YulEvmoneUtility::deployCode(bytes const& _input, EVMHost& _host)
+{
+	// Zero initialize all message fields
+	evmc_message msg = {};
+	// Gas available (value of type int64_t) is set to its maximum value
+	msg.gas = std::numeric_limits<int64_t>::max();
+	solAssert(
+		_input.size() <= 0xffff,
+		"Deployed byte code is larger than the permissible 65535 bytes."
+	);
+	uint8_t inputSizeHigher = static_cast<uint8_t>(_input.size() >> 8);
+	uint8_t inputSizeLower = _input.size() & 0xff;
+	/*
+	 * CODESIZE
+	 * PUSH0 0xc
+	 * PUSH0 0x0
+	 * CODECOPY
+	 * PUSH1 <INPUTSIZE>
+	 * PUSH0 0x0
+	 * RETURN
+	 */
+	bytes deployCode = bytes{
+		0x38, 0x60, 0x0c, 0x60, 0x00, 0x39, 0x61,
+		inputSizeHigher, inputSizeLower,
+		0x60, 0x00, 0xf3
+	} + _input;
+	msg.input_data = deployCode.data();
+	msg.input_size = deployCode.size();
+	msg.kind = EVMC_CREATE;
+	return _host.call(msg);
+}
+
+evmc_message YulEvmoneUtility::callMessage(evmc_address _address)
+{
+	evmc_message call = {};
+	call.gas = std::numeric_limits<int64_t>::max();
+	call.recipient = _address;
+	call.code_address = _address;
+	call.kind = EVMC_CALL;
+	return call;
+}
+
+bool YulEvmoneUtility::seriousCallError(evmc_status_code _code)
+{
+	if (_code == EVMC_OUT_OF_GAS)
+		return true;
+	else if (_code == EVMC_STACK_OVERFLOW)
+		return true;
+	else if (_code == EVMC_STACK_UNDERFLOW)
+		return true;
+	else if (_code == EVMC_INTERNAL_ERROR)
+		return true;
+	else if (_code == EVMC_UNDEFINED_INSTRUCTION)
+		return true;
+	else if (_code == EVMC_INVALID_MEMORY_ACCESS)
+		return true;
+	else
+		return false;
+}
diff --git a/compiler/test/tools/ossfuzz/YulEvmoneInterface.h b/compiler/test/tools/ossfuzz/YulEvmoneInterface.h
new file mode 100644
index 00000000..71a47507
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/YulEvmoneInterface.h
@@ -0,0 +1,66 @@
+/*
+    This file is part of solidity.
+
+    solidity is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    solidity is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <test/EVMHost.h>
+
+#include <libyul/YulStack.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+
+namespace solidity::test::fuzzer
+{
+class YulAssembler
+{
+public:
+	YulAssembler(
+		langutil::EVMVersion _evmVersion,
+		std::optional<uint8_t> _eofVersion,
+		solidity::frontend::OptimiserSettings _optSettings,
+		std::string const& _yulSource
+	):
+		m_stack(
+			_evmVersion,
+			_eofVersion,
+			solidity::yul::YulStack::Language::StrictAssembly,
+			_optSettings,
+			langutil::DebugInfoSelection::All()
+		),
+		m_yulProgram(_yulSource),
+		m_optimiseYul(_optSettings.runYulOptimiser)
+	{}
+	solidity::bytes assemble();
+	std::shared_ptr<yul::Object> object();
+private:
+	solidity::yul::YulStack m_stack;
+	std::string m_yulProgram;
+	bool m_optimiseYul;
+};
+
+struct YulEvmoneUtility
+{
+	/// @returns the result of deploying bytecode @param _input on @param _host.
+	static evmc::Result deployCode(solidity::bytes const& _input, EVMHost& _host);
+	/// @returns call message to be sent to @param _address.
+	static evmc_message callMessage(evmc_address _address);
+	/// @returns true if call result indicates a serious error, false otherwise.
+	static bool seriousCallError(evmc_status_code _code);
+};
+}
diff --git a/compiler/test/tools/ossfuzz/protoToAbiV2.cpp b/compiler/test/tools/ossfuzz/protoToAbiV2.cpp
new file mode 100644
index 00000000..98de7dd3
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protoToAbiV2.cpp
@@ -0,0 +1,1408 @@
+#include <test/tools/ossfuzz/protoToAbiV2.h>
+
+#include <boost/preprocessor.hpp>
+#include <regex>
+
+/// Convenience macros
+/// Returns a valid Solidity integer width w such that 8 <= w <= 256.
+#define INTWIDTH(z, n, _ununsed) BOOST_PP_MUL(BOOST_PP_ADD(n, 1), 8)
+/// Using declaration that aliases long boost multiprecision types with
+/// s(u)<width> where <width> is a valid Solidity integer width and "s"
+/// stands for "signed" and "u" for "unsigned".
+#define USINGDECL(z, n, sign) \
+	using BOOST_PP_CAT(BOOST_PP_IF(sign, s, u), INTWIDTH(z, n,)) =             \
+	boost::multiprecision::number<                                             \
+		boost::multiprecision::cpp_int_backend<                                \
+			INTWIDTH(z, n,),                                                   \
+			INTWIDTH(z, n,),                                                   \
+			BOOST_PP_IF(                                                       \
+				sign,                                                          \
+				boost::multiprecision::signed_magnitude,                       \
+				boost::multiprecision::unsigned_magnitude                      \
+			),                                                                 \
+			boost::multiprecision::unchecked,                                  \
+			void                                                               \
+		>                                                                      \
+	>;
+/// Instantiate the using declarations for signed and unsigned integer types.
+BOOST_PP_REPEAT(32, USINGDECL, 1)
+BOOST_PP_REPEAT(32, USINGDECL, 0)
+/// Case implementation that returns an integer value of the specified type.
+/// For signed integers, we divide by two because the range for boost multiprecision
+/// types is double that of Solidity integer types. Example, 8-bit signed boost
+/// number range is [-255, 255] but Solidity `int8` range is [-128, 127]
+#define CASEIMPL(z, n, sign)                                                   \
+	case INTWIDTH(z, n,):                                                      \
+		stream << BOOST_PP_IF(                                                 \
+			sign,                                                              \
+			integerValue<                                                      \
+				BOOST_PP_CAT(                                                  \
+					BOOST_PP_IF(sign, s, u),                                   \
+					INTWIDTH(z, n,)                                            \
+                )>(_counter) / 2,                                              \
+			integerValue<                                                      \
+				BOOST_PP_CAT(                                                  \
+					BOOST_PP_IF(sign, s, u),                                   \
+					INTWIDTH(z, n,)                                            \
+                )>(_counter)                                                   \
+        );                                                                     \
+		break;
+/// Switch implementation that instantiates case statements for (un)signed
+/// Solidity integer types.
+#define SWITCHIMPL(sign)                                                       \
+	ostringstream stream;                                                      \
+	switch (_intWidth)                                                         \
+	{                                                                          \
+	BOOST_PP_REPEAT(32, CASEIMPL, sign)	                                       \
+	}	                                                                       \
+	return stream.str();
+
+using namespace std;
+using namespace solidity::util;
+using namespace solidity::test::abiv2fuzzer;
+
+namespace
+{
+template <typename V>
+static V integerValue(unsigned _counter)
+{
+	V value = V(
+		u256(solidity::util::keccak256(solidity::util::h256(_counter))) % u256(boost::math::tools::max_value<V>())
+	);
+	if (boost::multiprecision::is_signed_number<V>::value && value % 2 == 0)
+		return value * (-1);
+	else
+		return value;
+}
+
+static string signedIntegerValue(unsigned _counter, unsigned _intWidth)
+{
+	SWITCHIMPL(1)
+}
+
+static string unsignedIntegerValue(unsigned _counter, unsigned _intWidth)
+{
+	SWITCHIMPL(0)
+}
+
+static string integerValue(unsigned _counter, unsigned _intWidth, bool _signed)
+{
+	if (_signed)
+		return signedIntegerValue(_counter, _intWidth);
+	else
+		return unsignedIntegerValue(_counter, _intWidth);
+}
+}
+
+string ProtoConverter::getVarDecl(
+	string const& _type,
+	string const& _varName,
+	string const& _qualifier
+)
+{
+	// One level of indentation for state variable declarations
+	// Two levels of indentation for local variable declarations
+	return Whiskers(R"(
+	<?isLocalVar>	</isLocalVar><type><?qual> <qualifier></qual> <varName>;)"
+		)
+		("isLocalVar", !m_isStateVar)
+		("type", _type)
+		("qual", !_qualifier.empty())
+		("qualifier", _qualifier)
+		("varName", _varName)
+		.render() +
+		"\n";
+}
+
+pair<string, string> ProtoConverter::visit(Type const& _type)
+{
+	switch (_type.type_oneof_case())
+	{
+	case Type::kVtype:
+		return visit(_type.vtype());
+	case Type::kNvtype:
+		return visit(_type.nvtype());
+	case Type::TYPE_ONEOF_NOT_SET:
+		return make_pair("", "");
+	}
+}
+
+pair<string, string> ProtoConverter::visit(ValueType const& _type)
+{
+	switch (_type.value_type_oneof_case())
+	{
+	case ValueType::kBoolty:
+		return visit(_type.boolty());
+	case ValueType::kInty:
+		return visit(_type.inty());
+	case ValueType::kByty:
+		return visit(_type.byty());
+	case ValueType::kAdty:
+		return visit(_type.adty());
+	case ValueType::VALUE_TYPE_ONEOF_NOT_SET:
+		return make_pair("", "");
+	}
+}
+
+pair<string, string> ProtoConverter::visit(NonValueType const& _type)
+{
+	switch (_type.nonvalue_type_oneof_case())
+	{
+	case NonValueType::kDynbytearray:
+		return visit(_type.dynbytearray());
+	case NonValueType::kArrtype:
+		if (ValidityVisitor().visit(_type.arrtype()))
+			return visit(_type.arrtype());
+		else
+			return make_pair("", "");
+	case NonValueType::kStype:
+		if (ValidityVisitor().visit(_type.stype()))
+			return visit(_type.stype());
+		else
+			return make_pair("", "");
+	case NonValueType::NONVALUE_TYPE_ONEOF_NOT_SET:
+		return make_pair("", "");
+	}
+}
+
+pair<string, string> ProtoConverter::visit(BoolType const& _type)
+{
+	return processType(_type, true);
+}
+
+pair<string, string> ProtoConverter::visit(IntegerType const& _type)
+{
+	return processType(_type, true);
+}
+
+pair<string, string> ProtoConverter::visit(FixedByteType const& _type)
+{
+	return processType(_type, true);
+}
+
+pair<string, string> ProtoConverter::visit(AddressType const& _type)
+{
+	return processType(_type, true);
+}
+
+pair<string, string> ProtoConverter::visit(DynamicByteArrayType const& _type)
+{
+	return processType(_type, false);
+}
+
+pair<string, string> ProtoConverter::visit(ArrayType const& _type)
+{
+	return processType(_type, false);
+}
+
+pair<string, string> ProtoConverter::visit(StructType const& _type)
+{
+	return processType(_type, false);
+}
+
+template <typename T>
+pair<string, string> ProtoConverter::processType(T const& _type, bool _isValueType)
+{
+	ostringstream local, global;
+	auto [varName, paramName] = newVarNames(getNextVarCounter(), m_isStateVar);
+
+	// Add variable name to the argument list of coder function call
+	if (m_argsCoder.str().empty())
+		m_argsCoder << varName;
+	else
+		m_argsCoder << ", " << varName;
+
+	string location{};
+	if (!m_isStateVar && !_isValueType)
+		location = "memory";
+
+	auto varDeclBuffers = varDecl(
+		varName,
+		paramName,
+		_type,
+		_isValueType,
+		location
+	);
+	global << varDeclBuffers.first;
+	local << varDeclBuffers.second;
+	auto assignCheckBuffers = assignChecker(varName, paramName, _type);
+	global << assignCheckBuffers.first;
+	local << assignCheckBuffers.second;
+
+	m_structCounter += m_numStructsAdded;
+	return make_pair(global.str(), local.str());
+}
+
+template <typename T>
+pair<string, string> ProtoConverter::varDecl(
+	string const& _varName,
+	string const& _paramName,
+	T _type,
+	bool _isValueType,
+	string const& _location
+)
+{
+	ostringstream local, global;
+
+	TypeVisitor tVisitor(m_structCounter);
+	string typeStr = tVisitor.visit(_type);
+	if (typeStr.empty())
+		return make_pair("", "");
+
+	// Append struct defs
+	global << tVisitor.structDef();
+	m_numStructsAdded = tVisitor.numStructs();
+
+	// variable declaration
+	if (m_isStateVar)
+		global << getVarDecl(typeStr, _varName, _location);
+	else
+		local << getVarDecl(typeStr, _varName, _location);
+
+	// Add typed params for calling public and external functions with said type
+	appendTypedParams(
+		CalleeType::PUBLIC,
+		_isValueType,
+		typeStr,
+		_paramName,
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+	appendTypedParams(
+		CalleeType::EXTERNAL,
+		_isValueType,
+		typeStr,
+		_paramName,
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+	appendTypes(
+		_isValueType,
+		typeStr,
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+	appendTypedReturn(
+		_isValueType,
+		typeStr,
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+	appendToIsabelleTypeString(
+		tVisitor.isabelleTypeString(),
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+	// Update dyn param only if necessary
+	if (tVisitor.isLastDynParamRightPadded())
+		m_isLastDynParamRightPadded = true;
+
+	return make_pair(global.str(), local.str());
+}
+
+template <typename T>
+pair<string, string> ProtoConverter::assignChecker(
+	string const& _varName,
+	string const& _paramName,
+	T _type
+)
+{
+	ostringstream local;
+	AssignCheckVisitor acVisitor(
+		_varName,
+		_paramName,
+		m_returnValue,
+		m_isStateVar,
+		m_counter,
+		m_structCounter
+	);
+	pair<string, string> assignCheckStrPair = acVisitor.visit(_type);
+	m_returnValue += acVisitor.errorStmts();
+	m_counter += acVisitor.counted();
+
+	m_checks << assignCheckStrPair.second;
+	appendToIsabelleValueString(
+		acVisitor.isabelleValueString(),
+		((m_varCounter == 1) ? Delimiter::SKIP : Delimiter::ADD)
+	);
+
+	// State variables cannot be assigned in contract-scope
+	// Therefore, we buffer their assignments and
+	// render them in function scope later.
+	local << assignCheckStrPair.first;
+	return make_pair("", local.str());
+}
+
+pair<string, string> ProtoConverter::visit(VarDecl const& _x)
+{
+	return visit(_x.type());
+}
+
+std::string ProtoConverter::equalityChecksAsString()
+{
+	return m_checks.str();
+}
+
+std::string ProtoConverter::delimiterToString(Delimiter _delimiter, bool _space)
+{
+	switch (_delimiter)
+	{
+	case Delimiter::ADD:
+		return _space ? ", " : ",";
+	case Delimiter::SKIP:
+		return "";
+	}
+}
+
+/* When a new variable is declared, we can invoke this function
+ * to prepare the typed param list to be passed to callee functions.
+ * We independently prepare this list for "public" and "external"
+ * callee functions.
+ */
+void ProtoConverter::appendTypedParams(
+	CalleeType _calleeType,
+	bool _isValueType,
+	std::string const& _typeString,
+	std::string const& _varName,
+	Delimiter _delimiter
+)
+{
+	switch (_calleeType)
+	{
+	case CalleeType::PUBLIC:
+		appendTypedParamsPublic(_isValueType, _typeString, _varName, _delimiter);
+		break;
+	case CalleeType::EXTERNAL:
+		appendTypedParamsExternal(_isValueType, _typeString, _varName, _delimiter);
+		break;
+	}
+}
+
+void ProtoConverter::appendTypes(
+	bool _isValueType,
+	string const& _typeString,
+	Delimiter _delimiter
+)
+{
+	string qualifiedTypeString = (
+		_isValueType ?
+		_typeString :
+		_typeString + " memory"
+	);
+	m_types << Whiskers(R"(<delimiter><type>)")
+		("delimiter", delimiterToString(_delimiter))
+		("type", qualifiedTypeString)
+		.render();
+}
+
+void ProtoConverter::appendTypedReturn(
+	bool _isValueType,
+	string const& _typeString,
+	Delimiter _delimiter
+)
+{
+	string qualifiedTypeString = (
+		_isValueType ?
+		_typeString :
+		_typeString + " memory"
+	);
+	m_typedReturn << Whiskers(R"(<delimiter><type> <varName>)")
+		("delimiter", delimiterToString(_delimiter))
+		("type", qualifiedTypeString)
+		("varName", "lv_" + to_string(m_varCounter - 1))
+		.render();
+}
+
+// Adds the qualifier "calldata" to non-value parameter of an external function.
+void ProtoConverter::appendTypedParamsExternal(
+	bool _isValueType,
+    std::string const& _typeString,
+    std::string const& _varName,
+    Delimiter _delimiter
+)
+{
+	m_externalParamsRep.push_back({_delimiter, _isValueType, _typeString, _varName});
+	m_untypedParamsExternal << Whiskers(R"(<delimiter><varName>)")
+		("delimiter", delimiterToString(_delimiter))
+		("varName", _varName)
+		.render();
+}
+
+// Adds the qualifier "memory" to non-value parameter of an external function.
+void ProtoConverter::appendTypedParamsPublic(
+	bool _isValueType,
+	std::string const& _typeString,
+	std::string const& _varName,
+	Delimiter _delimiter
+)
+{
+	std::string qualifiedTypeString = (
+		_isValueType ?
+		_typeString :
+		_typeString + " memory"
+		);
+	m_typedParamsPublic << Whiskers(R"(<delimiter><type> <varName>)")
+		("delimiter", delimiterToString(_delimiter))
+		("type", qualifiedTypeString)
+		("varName", _varName)
+		.render();
+}
+
+void ProtoConverter::appendToIsabelleTypeString(
+	std::string const& _typeString,
+	Delimiter _delimiter
+)
+{
+	m_isabelleTypeString << delimiterToString(_delimiter, false) << _typeString;
+}
+
+void ProtoConverter::appendToIsabelleValueString(
+	std::string const& _valueString,
+	Delimiter _delimiter
+)
+{
+	m_isabelleValueString << delimiterToString(_delimiter, false) << _valueString;
+}
+
+std::string ProtoConverter::typedParametersAsString(CalleeType _calleeType)
+{
+	switch (_calleeType)
+	{
+	case CalleeType::PUBLIC:
+		return m_typedParamsPublic.str();
+	case CalleeType::EXTERNAL:
+	{
+		ostringstream typedParamsExternal;
+		for (auto const& i: m_externalParamsRep)
+		{
+			Delimiter del = get<0>(i);
+			bool valueType = get<1>(i);
+			string typeString = get<2>(i);
+			string varName = get<3>(i);
+			bool isCalldata = randomBool(/*probability=*/0.5);
+			string location = (isCalldata ? "calldata" : "memory");
+			string qualifiedTypeString = (valueType ? typeString : typeString + " " + location);
+			typedParamsExternal << Whiskers(R"(<delimiter><type> <varName>)")
+				("delimiter", delimiterToString(del))
+				("type", qualifiedTypeString)
+				("varName", varName)
+				.render();
+		}
+		return typedParamsExternal.str();
+	}
+	}
+}
+
+string ProtoConverter::visit(TestFunction const& _x, string const& _storageVarDefs)
+{
+	// TODO: Support more than one but less than N local variables
+	auto localVarBuffers = visit(_x.local_vars());
+
+	string structTypeDecl = localVarBuffers.first;
+	string localVarDefs = localVarBuffers.second;
+
+	ostringstream testBuffer;
+
+	string testFunction = Whiskers(R"(
+	function test() public returns (uint) {
+		<?calldata>return test_calldata_coding();</calldata>
+		<?returndata>return test_returndata_coding();</returndata>
+	})")
+	("calldata", m_test == Contract_Test::Contract_Test_CALLDATA_CODER)
+	("returndata", m_test == Contract_Test::Contract_Test_RETURNDATA_CODER)
+	.render();
+
+	string functionDeclCalldata = "function test_calldata_coding() internal returns (uint)";
+	string functionDeclReturndata = "function test_returndata_coding() internal returns (uint)";
+
+	testBuffer << Whiskers(R"(<structTypeDecl>
+<testFunction>
+<?calldata>
+	<functionDeclCalldata> {
+<storageVarDefs>
+<localVarDefs>
+<calldataTestCode>
+	}
+<calldataHelperFuncs>
+</calldata>
+<?returndata>
+	<functionDeclReturndata> {
+<returndataTestCode>
+	}
+
+<?varsPresent>
+	function coder_returndata_external() external returns (<return_types>) {
+<storageVarDefs>
+<localVarDefs>
+		return (<return_values>);
+	}
+</varsPresent>
+</returndata>)")
+		("testFunction", testFunction)
+		("calldata", m_test == Contract_Test::Contract_Test_CALLDATA_CODER)
+		("returndata", m_test == Contract_Test::Contract_Test_RETURNDATA_CODER)
+		("calldataHelperFuncs", calldataHelperFunctions())
+		("varsPresent", !m_types.str().empty())
+		("structTypeDecl", structTypeDecl)
+		("functionDeclCalldata", functionDeclCalldata)
+		("functionDeclReturndata", functionDeclReturndata)
+		("storageVarDefs", _storageVarDefs)
+		("localVarDefs", localVarDefs)
+		("calldataTestCode", testCallDataFunction(static_cast<unsigned>(_x.invalid_encoding_length())))
+		("returndataTestCode", testReturnDataFunction())
+		("return_types", m_types.str())
+		("return_values", m_argsCoder.str())
+		.render();
+	return testBuffer.str();
+}
+
+string ProtoConverter::testCallDataFunction(unsigned _invalidLength)
+{
+	return Whiskers(R"(
+		uint returnVal = this.coder_calldata_public(<argumentNames>);
+		if (returnVal != 0)
+			return returnVal;
+
+		returnVal = this.coder_calldata_external(<argumentNames>);
+		if (returnVal != 0)
+			return uint(200000) + returnVal;
+
+		<?atLeastOneVar>
+		bytes memory argumentEncoding = abi.encode(<argumentNames>);
+
+		returnVal = checkEncodedCall(
+			this.coder_calldata_public.selector,
+			argumentEncoding,
+			<invalidLengthFuzz>,
+			<isRightPadded>
+		);
+		if (returnVal != 0)
+			return returnVal;
+
+		returnVal = checkEncodedCall(
+			this.coder_calldata_external.selector,
+			argumentEncoding,
+			<invalidLengthFuzz>,
+			<isRightPadded>
+		);
+		if (returnVal != 0)
+			return uint(200000) + returnVal;
+		</atLeastOneVar>
+		return 0;
+		)")
+		("argumentNames", m_argsCoder.str())
+		("invalidLengthFuzz", std::to_string(_invalidLength))
+		("isRightPadded", isLastDynParamRightPadded() ? "true" : "false")
+		("atLeastOneVar", m_varCounter > 0)
+		.render();
+}
+
+string ProtoConverter::testReturnDataFunction()
+{
+	return Whiskers(R"(
+<?varsPresent>
+		(<varDecl>) = this.coder_returndata_external();
+<equality_checks>
+</varsPresent>
+		return 0;
+		)")
+		("varsPresent", !m_typedReturn.str().empty())
+		("varDecl", m_typedReturn.str())
+		("equality_checks", m_checks.str())
+		.render();
+}
+
+string ProtoConverter::calldataHelperFunctions()
+{
+	stringstream calldataHelperFuncs;
+	calldataHelperFuncs << R"(
+	/// Accepts function selector, correct argument encoding, and length of
+	/// invalid encoding and returns the correct and incorrect abi encoding
+	/// for calling the function specified by the function selector.
+	function createEncoding(
+		bytes4 funcSelector,
+		bytes memory argumentEncoding,
+		uint invalidLengthFuzz,
+		bool isRightPadded
+	) internal pure returns (bytes memory, bytes memory)
+	{
+		bytes memory validEncoding = new bytes(4 + argumentEncoding.length);
+		// Ensure that invalidEncoding crops at least 32 bytes (padding length
+		// is at most 31 bytes) if `isRightPadded` is true.
+		// This is because shorter bytes/string values (whose encoding is right
+		// padded) can lead to successful decoding when fewer than 32 bytes have
+		// been cropped in the worst case. In other words, if `isRightPadded` is
+		// true, then
+		//  0 <= invalidLength <= argumentEncoding.length - 32
+		// otherwise
+		//  0 <= invalidLength <= argumentEncoding.length - 1
+		uint invalidLength;
+		if (isRightPadded)
+			invalidLength = invalidLengthFuzz % (argumentEncoding.length - 31);
+		else
+			invalidLength = invalidLengthFuzz % argumentEncoding.length;
+		bytes memory invalidEncoding = new bytes(4 + invalidLength);
+		for (uint i = 0; i < 4; i++)
+			validEncoding[i] = invalidEncoding[i] = funcSelector[i];
+		for (uint i = 0; i < argumentEncoding.length; i++)
+			validEncoding[i+4] = argumentEncoding[i];
+		for (uint i = 0; i < invalidLength; i++)
+			invalidEncoding[i+4] = argumentEncoding[i];
+		return (validEncoding, invalidEncoding);
+	}
+
+	/// Accepts function selector, correct argument encoding, and an invalid
+	/// encoding length as input. Returns a non-zero value if either call with
+	/// correct encoding fails or call with incorrect encoding succeeds.
+	/// Returns zero if both calls meet expectation.
+	function checkEncodedCall(
+		bytes4 funcSelector,
+		bytes memory argumentEncoding,
+		uint invalidLengthFuzz,
+		bool isRightPadded
+	) public returns (uint)
+	{
+		(bytes memory validEncoding, bytes memory invalidEncoding) = createEncoding(
+			funcSelector,
+			argumentEncoding,
+			invalidLengthFuzz,
+			isRightPadded
+		);
+		(bool success, bytes memory returnVal) = address(this).call(validEncoding);
+		uint returnCode = abi.decode(returnVal, (uint));
+		// Return non-zero value if call fails for correct encoding
+		if (success == false || returnCode != 0)
+			return 400000;
+		(success, ) = address(this).call(invalidEncoding);
+		// Return non-zero value if call succeeds for incorrect encoding
+		if (success == true)
+			return 400001;
+		return 0;
+	})";
+
+	/// These are indirections to test memory-calldata codings more robustly.
+	stringstream indirections;
+	unsigned numIndirections = randomNumberOneToN(s_maxIndirections);
+	for (unsigned i = 1; i <= numIndirections; i++)
+	{
+		bool finalIndirection = i == numIndirections;
+		string mutability = (finalIndirection ? "pure" : "view");
+		indirections << Whiskers(R"(
+	function coder_calldata_external_i<N>(<parameters>) external <mutability> returns (uint) {
+<?finalIndirection>
+<equality_checks>
+		return 0;
+<!finalIndirection>
+		return this.coder_calldata_external_i<NPlusOne>(<untyped_parameters>);
+</finalIndirection>
+	}
+		)")
+		("N", to_string(i))
+		("parameters", typedParametersAsString(CalleeType::EXTERNAL))
+		("mutability", mutability)
+		("finalIndirection", finalIndirection)
+		("equality_checks", equalityChecksAsString())
+		("NPlusOne", to_string(i + 1))
+		("untyped_parameters", m_untypedParamsExternal.str())
+		.render();
+	}
+
+	// These are callee functions that encode from storage, decode to
+	// memory/calldata and check if decoded value matches storage value
+	// return true on successful match, false otherwise
+	calldataHelperFuncs << Whiskers(R"(
+	function coder_calldata_public(<parameters_memory>) public pure returns (uint) {
+<equality_checks>
+		return 0;
+	}
+
+	function coder_calldata_external(<parameters_calldata>) external view returns (uint) {
+		return this.coder_calldata_external_i1(<untyped_parameters>);
+	}
+<indirections>
+	)")
+	("parameters_memory", typedParametersAsString(CalleeType::PUBLIC))
+	("equality_checks", equalityChecksAsString())
+	("parameters_calldata", typedParametersAsString(CalleeType::EXTERNAL))
+	("untyped_parameters", m_untypedParamsExternal.str())
+	("indirections", indirections.str())
+	.render();
+
+	return calldataHelperFuncs.str();
+}
+
+string ProtoConverter::commonHelperFunctions()
+{
+	stringstream helperFuncs;
+	helperFuncs << R"(
+	/// Compares bytes, returning true if they are equal and false otherwise.
+	function bytesCompare(bytes memory a, bytes memory b) internal pure returns (bool) {
+		if(a.length != b.length)
+			return false;
+		for (uint i = 0; i < a.length; i++)
+			if (a[i] != b[i])
+				return false;
+		return true;
+	}
+	)";
+
+	return helperFuncs.str();
+}
+
+void ProtoConverter::visit(Contract const& _x)
+{
+	string pragmas = R"(pragma solidity >=0.0;
+pragma experimental ABIEncoderV2;)";
+
+	// Record test spec
+	m_test = _x.test();
+
+	// TODO: Support more than one but less than N state variables
+	auto storageBuffers = visit(_x.state_vars());
+	string storageVarDecls = storageBuffers.first;
+	string storageVarDefs = storageBuffers.second;
+	m_isStateVar = false;
+	string testFunction = visit(_x.testfunction(), storageVarDefs);
+	/* Structure of contract body
+	 * - Storage variable declarations
+	 * - Struct definitions
+	 * - Test function
+	 *     - Storage variable assignments
+	 *     - Local variable definitions and assignments
+	 *     - Test code proper (calls public and external functions)
+	 * - Helper functions
+	 */
+	ostringstream contractBody;
+	contractBody << storageVarDecls
+	             << testFunction
+	             << commonHelperFunctions();
+	m_output << Whiskers(R"(<pragmas>
+<contractStart>
+<contractBody>
+<contractEnd>)")
+		("pragmas", pragmas)
+		("contractStart", "contract C {")
+		("contractBody", contractBody.str())
+		("contractEnd", "}")
+		.render();
+}
+
+string ProtoConverter::isabelleTypeString() const
+{
+	string typeString = m_isabelleTypeString.str();
+	if (!typeString.empty())
+		return "(" + typeString + ")";
+	else
+		return typeString;
+}
+
+string ProtoConverter::isabelleValueString() const
+{
+	string valueString = m_isabelleValueString.str();
+	if (!valueString.empty())
+		return "(" + valueString + ")";
+	else
+		return valueString;
+}
+
+string ProtoConverter::contractToString(Contract const& _input)
+{
+	visit(_input);
+	return m_output.str();
+}
+
+/// Type visitor
+void TypeVisitor::StructTupleString::addTypeStringToTuple(string& _typeString)
+{
+	index++;
+	if (index > 1)
+		stream << ",";
+	stream << _typeString;
+}
+
+void TypeVisitor::StructTupleString::addArrayBracketToType(string& _arrayBracket)
+{
+	stream << _arrayBracket;
+}
+
+string TypeVisitor::visit(BoolType const&)
+{
+	m_baseType = "bool";
+	m_structTupleString.addTypeStringToTuple(m_baseType);
+	return m_baseType;
+}
+
+string TypeVisitor::visit(IntegerType const& _type)
+{
+	m_baseType = getIntTypeAsString(_type);
+	m_structTupleString.addTypeStringToTuple(m_baseType);
+	return m_baseType;
+}
+
+string TypeVisitor::visit(FixedByteType const& _type)
+{
+	m_baseType = getFixedByteTypeAsString(_type);
+	m_structTupleString.addTypeStringToTuple(m_baseType);
+	return m_baseType;
+}
+
+string TypeVisitor::visit(AddressType const&)
+{
+	m_baseType = "address";
+	m_structTupleString.addTypeStringToTuple(m_baseType);
+	return m_baseType;
+}
+
+string TypeVisitor::visit(ArrayType const& _type)
+{
+	if (!ValidityVisitor().visit(_type))
+		return "";
+
+	string baseType = visit(_type.t());
+	solAssert(!baseType.empty(), "");
+	string arrayBracket = _type.is_static() ?
+	                     string("[") +
+	                     to_string(getStaticArrayLengthFromFuzz(_type.length())) +
+	                     string("]") :
+	                     string("[]");
+	m_baseType += arrayBracket;
+	m_structTupleString.addArrayBracketToType(arrayBracket);
+
+	// If we don't know yet if the array will be dynamically encoded,
+	// check again. If we already know that it will be, there's no
+	// need to do anything.
+	if (!m_isLastDynParamRightPadded)
+		m_isLastDynParamRightPadded = DynParamVisitor().visit(_type);
+
+	return baseType + arrayBracket;
+}
+
+string TypeVisitor::visit(DynamicByteArrayType const&)
+{
+	m_isLastDynParamRightPadded = true;
+	m_baseType = "bytes";
+	m_structTupleString.addTypeStringToTuple(m_baseType);
+	return m_baseType;
+}
+
+void TypeVisitor::structDefinition(StructType const& _type)
+{
+	// Return an empty string if struct is empty
+	solAssert(ValidityVisitor().visit(_type), "");
+
+	// Reset field counter and indentation
+	unsigned wasFieldCounter = m_structFieldCounter;
+	unsigned wasIndentation = m_indentation;
+
+	m_indentation = 1;
+	m_structFieldCounter = 0;
+
+	// Commence struct declaration
+	string structDef = lineString(
+		"struct " +
+		string(s_structNamePrefix) +
+		to_string(m_structCounter) +
+		" {"
+	);
+	// Start tuple of types with parenthesis
+	m_structTupleString.start();
+	// Increase indentation for struct fields
+	m_indentation++;
+	for (auto const& t: _type.t())
+	{
+		string type{};
+
+		if (!ValidityVisitor().visit(t))
+			continue;
+
+		TypeVisitor tVisitor(m_structCounter + 1);
+		type = tVisitor.visit(t);
+		m_structCounter += tVisitor.numStructs();
+		m_structDef << tVisitor.structDef();
+
+		solAssert(!type.empty(), "");
+
+		structDef += lineString(
+			Whiskers(R"(<type> <member>;)")
+				("type", type)
+				("member", "m" + to_string(m_structFieldCounter++))
+				.render()
+		);
+		string isabelleTypeStr = tVisitor.isabelleTypeString();
+		m_structTupleString.addTypeStringToTuple(isabelleTypeStr);
+	}
+	m_indentation--;
+	structDef += lineString("}");
+	// End tuple of types with parenthesis
+	m_structTupleString.end();
+	m_structCounter++;
+	m_structDef << structDef;
+	m_indentation = wasIndentation;
+	m_structFieldCounter = wasFieldCounter;
+}
+
+string TypeVisitor::visit(StructType const& _type)
+{
+	if (ValidityVisitor().visit(_type))
+	{
+		// Add struct definition
+		structDefinition(_type);
+		// Set last dyn param if struct contains a dyn param e.g., bytes, array etc.
+		m_isLastDynParamRightPadded = DynParamVisitor().visit(_type);
+		// If top-level struct is a non-empty struct, assign the name S<suffix>
+		m_baseType = s_structTypeName + to_string(m_structStartCounter);
+	}
+	else
+		m_baseType = {};
+
+	return m_baseType;
+}
+
+/// AssignCheckVisitor implementation
+void AssignCheckVisitor::ValueStream::appendValue(string& _value)
+{
+	solAssert(!_value.empty(), "Abiv2 fuzzer: Empty value");
+	index++;
+	if (index > 1)
+		stream << ",";
+	stream << _value;
+}
+
+pair<string, string> AssignCheckVisitor::visit(BoolType const& _type)
+{
+	string value = ValueGetterVisitor(counter()).visit(_type);
+	if (!m_forcedVisit)
+		m_valueStream.appendValue(value);
+	return assignAndCheckStringPair(m_varName, m_paramName, value, value, DataType::VALUE);
+}
+
+pair<string, string> AssignCheckVisitor::visit(IntegerType const& _type)
+{
+	string value = ValueGetterVisitor(counter()).visit(_type);
+	if (!m_forcedVisit)
+		m_valueStream.appendValue(value);
+	return assignAndCheckStringPair(m_varName, m_paramName, value, value, DataType::VALUE);
+}
+
+pair<string, string> AssignCheckVisitor::visit(FixedByteType const& _type)
+{
+	string value = ValueGetterVisitor(counter()).visit(_type);
+	if (!m_forcedVisit)
+	{
+		string isabelleValue = ValueGetterVisitor{}.isabelleBytesValueAsString(value);
+		m_valueStream.appendValue(isabelleValue);
+	}
+	return assignAndCheckStringPair(m_varName, m_paramName, value, value, DataType::VALUE);
+}
+
+pair<string, string> AssignCheckVisitor::visit(AddressType const& _type)
+{
+	string value = ValueGetterVisitor(counter()).visit(_type);
+	if (!m_forcedVisit)
+	{
+		string isabelleValue = ValueGetterVisitor{}.isabelleAddressValueAsString(value);
+		m_valueStream.appendValue(isabelleValue);
+	}
+	return assignAndCheckStringPair(m_varName, m_paramName, value, value, DataType::VALUE);
+}
+
+pair<string, string> AssignCheckVisitor::visit(DynamicByteArrayType const& _type)
+{
+	string value = ValueGetterVisitor(counter()).visit(_type);
+	if (!m_forcedVisit)
+	{
+		string isabelleValue = ValueGetterVisitor{}.isabelleBytesValueAsString(value);
+		m_valueStream.appendValue(isabelleValue);
+	}
+	DataType dataType = DataType::BYTES;
+	return assignAndCheckStringPair(m_varName, m_paramName, value, value, dataType);
+}
+
+pair<string, string> AssignCheckVisitor::visit(ArrayType const& _type)
+{
+	if (!ValidityVisitor().visit(_type))
+		return make_pair("", "");
+
+	// Obtain type of array to be resized and initialized
+	string typeStr{};
+
+	unsigned wasStructCounter = m_structCounter;
+	TypeVisitor tVisitor(m_structCounter);
+	typeStr = tVisitor.visit(_type);
+
+	pair<string, string> resizeBuffer;
+	string lengthStr;
+	unsigned length;
+
+	// Resize dynamic arrays
+	if (!_type.is_static())
+	{
+		length = getDynArrayLengthFromFuzz(_type.length(), counter());
+		lengthStr = to_string(length);
+		if (m_stateVar)
+		{
+			// Dynamic storage arrays are resized via the empty push() operation
+			resizeBuffer.first = Whiskers(R"(<indentation>for (uint i = 0; i < <length>; i++) <arrayRef>.push();)")
+				("indentation", indentation())
+				("length", lengthStr)
+				("arrayRef", m_varName)
+				.render() + "\n";
+			// Add a dynamic check on the resized length
+			resizeBuffer.second = checkString(m_paramName + ".length", lengthStr, DataType::VALUE);
+		}
+		else
+		{
+			// Resizing memory arrays via the new operator
+			string resizeOp = Whiskers(R"(new <fullTypeStr>(<length>))")
+				("fullTypeStr", typeStr)
+				("length", lengthStr)
+				.render();
+			resizeBuffer = assignAndCheckStringPair(
+				m_varName,
+				m_paramName + ".length",
+				resizeOp,
+				lengthStr,
+				DataType::VALUE
+				);
+		}
+	}
+	else
+	{
+		length = getStaticArrayLengthFromFuzz(_type.length());
+		lengthStr = to_string(length);
+		// Add check on length
+		resizeBuffer.second = checkString(m_paramName + ".length", lengthStr, DataType::VALUE);
+	}
+
+	// Add assignCheckBuffer and check statements
+	pair<string, string> assignCheckBuffer;
+	string wasVarName = m_varName;
+	string wasParamName = m_paramName;
+	if (!m_forcedVisit)
+		m_valueStream.startArray();
+	for (unsigned i = 0; i < length; i++)
+	{
+		m_varName = wasVarName + "[" + to_string(i) + "]";
+		m_paramName = wasParamName + "[" + to_string(i) + "]";
+		pair<string, string> assign = visit(_type.t());
+		assignCheckBuffer.first += assign.first;
+		assignCheckBuffer.second += assign.second;
+		if (i < length - 1)
+			m_structCounter = wasStructCounter;
+	}
+	// Since struct visitor won't be called for zero-length
+	// arrays, struct counter will not get incremented. Therefore,
+	// we need to manually force a recursive struct visit.
+	if (length == 0 && TypeVisitor().arrayOfStruct(_type))
+	{
+		bool previousState = m_forcedVisit;
+		m_forcedVisit = true;
+		visit(_type.t());
+		m_forcedVisit = previousState;
+	}
+	if (!m_forcedVisit)
+		m_valueStream.endArray();
+
+	m_varName = wasVarName;
+	m_paramName = wasParamName;
+
+	// Compose resize and initialization assignment and check
+	return make_pair(
+		resizeBuffer.first + assignCheckBuffer.first,
+		resizeBuffer.second + assignCheckBuffer.second
+	);
+}
+
+pair<string, string> AssignCheckVisitor::visit(StructType const& _type)
+{
+	if (!ValidityVisitor().visit(_type))
+		return make_pair("", "");
+
+	pair<string, string> assignCheckBuffer;
+	unsigned i = 0;
+
+	// Increment struct counter
+	m_structCounter++;
+
+	string wasVarName = m_varName;
+	string wasParamName = m_paramName;
+
+	if (!m_forcedVisit)
+		m_valueStream.startStruct();
+	for (auto const& t: _type.t())
+	{
+		m_varName = wasVarName + ".m" + to_string(i);
+		m_paramName = wasParamName + ".m" + to_string(i);
+		pair<string, string> assign = visit(t);
+		// If type is not well formed continue without
+		// updating state.
+		if (assign.first.empty() && assign.second.empty())
+			continue;
+		assignCheckBuffer.first += assign.first;
+		assignCheckBuffer.second += assign.second;
+		i++;
+	}
+	if (!m_forcedVisit)
+		m_valueStream.endStruct();
+	m_varName = wasVarName;
+	m_paramName = wasParamName;
+	return assignCheckBuffer;
+}
+
+pair<string, string> AssignCheckVisitor::assignAndCheckStringPair(
+	string const& _varRef,
+	string const& _checkRef,
+	string const& _assignValue,
+	string const& _checkValue,
+	DataType _type
+)
+{
+	return make_pair(assignString(_varRef, _assignValue), checkString(_checkRef, _checkValue, _type));
+}
+
+string AssignCheckVisitor::assignString(string const& _ref, string const& _value)
+{
+	string assignStmt = Whiskers(R"(<ref> = <value>;)")
+		("ref", _ref)
+		("value", _value)
+		.render();
+	return indentation() + assignStmt + "\n";
+}
+
+string AssignCheckVisitor::checkString(string const& _ref, string const& _value, DataType _type)
+{
+	string checkPred;
+	switch (_type)
+	{
+	case DataType::BYTES:
+		checkPred = Whiskers(R"(!bytesCompare(<varName>, <value>))")
+			("varName", _ref)
+			("value", _value)
+			.render();
+		break;
+	case DataType::VALUE:
+		checkPred = Whiskers(R"(<varName> != <value>)")
+			("varName", _ref)
+			("value", _value)
+			.render();
+		break;
+	case DataType::ARRAY:
+		solUnimplemented("Proto ABIv2 fuzzer: Invalid data type.");
+	}
+	string checkStmt = Whiskers(R"(if (<checkPred>) return <errCode>;)")
+		("checkPred", checkPred)
+		("errCode", to_string(m_errorCode++))
+		.render();
+	return indentation() + checkStmt + "\n";
+}
+
+/// ValueGetterVisitor
+string ValueGetterVisitor::visit(BoolType const&)
+{
+	return counter() % 2 ? "true" : "false";
+}
+
+string ValueGetterVisitor::visit(IntegerType const& _type)
+{
+	return integerValue(counter(), getIntWidth(_type), _type.is_signed());
+}
+
+string ValueGetterVisitor::visit(FixedByteType const& _type)
+{
+	return fixedByteValueAsString(
+		getFixedByteWidth(_type),
+		counter()
+	);
+}
+
+string ValueGetterVisitor::visit(AddressType const&)
+{
+	return addressValueAsString(counter());
+}
+
+string ValueGetterVisitor::visit(DynamicByteArrayType const&)
+{
+	return bytesArrayValueAsString(
+		counter(),
+		true
+	);
+}
+
+std::string ValueGetterVisitor::croppedString(
+	unsigned _numBytes,
+	unsigned _counter,
+	bool _isHexLiteral
+)
+{
+	solAssert(
+		_numBytes > 0 && _numBytes <= 32,
+		"Proto ABIv2 fuzzer: Too short or too long a cropped string"
+	);
+
+	// Number of masked nibbles is twice the number of bytes for a
+	// hex literal of _numBytes bytes. For a string literal, each nibble
+	// is treated as a character.
+	unsigned numMaskNibbles = _isHexLiteral ? _numBytes * 2 : _numBytes;
+
+	// Start position of substring equals totalHexStringLength - numMaskNibbles
+	// totalHexStringLength = 64 + 2 = 66
+	// e.g., 0x12345678901234567890123456789012 is a total of 66 characters
+	//      |---------------------^-----------|
+	//      <--- start position---><--numMask->
+	//      <-----------total length --------->
+	// Note: This assumes that maskUnsignedIntToHex() invokes toHex(..., HexPrefix::Add)
+	unsigned startPos = 66 - numMaskNibbles;
+	// Extracts the least significant numMaskNibbles from the result
+	// of maskUnsignedIntToHex().
+	return maskUnsignedIntToHex(
+		_counter,
+		numMaskNibbles
+	).substr(startPos, numMaskNibbles);
+}
+
+std::string ValueGetterVisitor::hexValueAsString(
+	unsigned _numBytes,
+	unsigned _counter,
+	bool _isHexLiteral,
+	bool _decorate
+)
+{
+	solAssert(_numBytes > 0 && _numBytes <= 32,
+	          "Proto ABIv2 fuzzer: Invalid hex length"
+	);
+
+	// If _decorate is set, then we return a hex"" or a "" string.
+	if (_numBytes == 0)
+		return Whiskers(R"(<?decorate><?isHex>hex</isHex>""</decorate>)")
+			("decorate", _decorate)
+			("isHex", _isHexLiteral)
+			.render();
+
+	// This is needed because solidity interprets a 20-byte 0x prefixed hex literal as an address
+	// payable type.
+	return Whiskers(R"(<?decorate><?isHex>hex</isHex>"</decorate><value><?decorate>"</decorate>)")
+		("decorate", _decorate)
+		("isHex", _isHexLiteral)
+		("value", croppedString(_numBytes, _counter, _isHexLiteral))
+		.render();
+}
+
+std::string ValueGetterVisitor::fixedByteValueAsString(unsigned _width, unsigned _counter)
+{
+	solAssert(
+		(_width >= 1 && _width <= 32),
+		"Proto ABIv2 Fuzzer: Fixed byte width is not between 1--32"
+	);
+	return hexValueAsString(_width, _counter, /*isHexLiteral=*/true);
+}
+
+std::string ValueGetterVisitor::addressValueAsString(unsigned _counter)
+{
+	return "address(" + maskUnsignedIntToHex(_counter, 40) + ")";
+}
+
+std::string ValueGetterVisitor::isabelleAddressValueAsString(std::string& _solAddressString)
+{
+	// Isabelle encoder expects address literal to be exactly
+	// 20 bytes and a hex string.
+	// Example: 0x0102030405060708090a0102030405060708090a
+	std::regex const addressPattern("address\\((.*)\\)");
+	std::smatch match;
+	solAssert(std::regex_match(_solAddressString, match, addressPattern), "Abiv2 fuzzer: Invalid address string");
+	std::string addressHex = match[1].str();
+	addressHex.erase(2, 24);
+	return addressHex;
+}
+
+std::string ValueGetterVisitor::isabelleBytesValueAsString(std::string& _solBytesString)
+{
+	std::regex const bytesPattern("hex\"(.*)\"");
+	std::smatch match;
+	solAssert(std::regex_match(_solBytesString, match, bytesPattern), "Abiv2 fuzzer: Invalid bytes string");
+	std::string bytesHex = match[1].str();
+	return "0x" + bytesHex;
+}
+
+std::string ValueGetterVisitor::variableLengthValueAsString(
+	unsigned _numBytes,
+	unsigned _counter,
+	bool _isHexLiteral
+)
+{
+	if (_numBytes == 0)
+		return Whiskers(R"(<?isHex>hex</isHex>"")")
+			("isHex", _isHexLiteral)
+			.render();
+
+	unsigned numBytesRemaining = _numBytes;
+	// Stores the literal
+	string output{};
+	// If requested value is shorter than or exactly 32 bytes,
+	// the literal is the return value of hexValueAsString.
+	if (numBytesRemaining <= 32)
+		output = hexValueAsString(
+			numBytesRemaining,
+			_counter,
+			_isHexLiteral,
+			/*decorate=*/false
+		);
+		// If requested value is longer than 32 bytes, the literal
+		// is obtained by duplicating the return value of hexValueAsString
+		// until we reach a value of the requested size.
+	else
+	{
+		// Create a 32-byte value to be duplicated and
+		// update number of bytes to be appended.
+		// Stores the cached literal that saves us
+		// (expensive) calls to keccak256.
+		string cachedString = hexValueAsString(
+			/*numBytes=*/32,
+			             _counter,
+			             _isHexLiteral,
+			/*decorate=*/false
+		);
+		output = cachedString;
+		numBytesRemaining -= 32;
+
+		// Append bytes from cachedString until
+		// we create a value of desired length.
+		unsigned numAppendedBytes;
+		while (numBytesRemaining > 0)
+		{
+			// We append at most 32 bytes at a time
+			numAppendedBytes = numBytesRemaining >= 32 ? 32 : numBytesRemaining;
+			output += cachedString.substr(
+				0,
+				// Double the substring length for hex literals since each
+				// character is actually half a byte (or a nibble).
+				_isHexLiteral ? numAppendedBytes * 2 : numAppendedBytes
+			);
+			numBytesRemaining -= numAppendedBytes;
+		}
+		solAssert(
+			numBytesRemaining == 0,
+			"Proto ABIv2 fuzzer: Logic flaw in variable literal creation"
+		);
+	}
+
+	if (_isHexLiteral)
+		solAssert(
+			output.size() == 2 * _numBytes,
+			"Proto ABIv2 fuzzer: Generated hex literal is of incorrect length"
+		);
+	else
+		solAssert(
+			output.size() == _numBytes,
+			"Proto ABIv2 fuzzer: Generated string literal is of incorrect length"
+		);
+
+	// Decorate output
+	return Whiskers(R"(<?isHexLiteral>hex</isHexLiteral>"<value>")")
+		("isHexLiteral", _isHexLiteral)
+		("value", output)
+		.render();
+}
+
+string ValueGetterVisitor::bytesArrayValueAsString(unsigned _counter, bool _isHexLiteral)
+{
+	return variableLengthValueAsString(
+		getVarLength(_counter),
+		_counter,
+		_isHexLiteral
+	);
+}
diff --git a/compiler/test/tools/ossfuzz/protoToAbiV2.h b/compiler/test/tools/ossfuzz/protoToAbiV2.h
new file mode 100644
index 00000000..be583d49
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protoToAbiV2.h
@@ -0,0 +1,1027 @@
+#pragma once
+
+#include <test/tools/ossfuzz/abiV2Proto.pb.h>
+
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/Keccak256.h>
+#include <libsolutil/StringUtils.h>
+#include <libsolutil/Whiskers.h>
+#include <libsolutil/Numeric.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <boost/algorithm/string.hpp>
+
+#include <ostream>
+#include <random>
+#include <sstream>
+
+/**
+ * Template of the solidity test program generated by this converter is as follows:
+ *
+ *	pragma solidity >=0.0;
+ *	pragma experimental ABIEncoderV2;
+ *
+ *	contract C {
+ *		// State variable
+ *		string sv_0;
+ *		// Test function that is called by the VM.
+ *		// There are 2 variations of this function: one returns
+ *		// the output of test_calldata_coding() and the other
+ *		// returns the output of test_returndata_coding(). The
+ *		// proto field called Test decides which one of the two
+ *		// are chosen for creating a test case.
+ *		function test() public returns (uint) {
+ *			// The protobuf field "Contract.test" decides which of
+ *			// the two internal functions "test_calldata_coding()"
+ *			// and "test_returndata_coding()" are called. Here,
+ *			// we assume that the protobuf field equals "CALLDATA_CODER"
+ *			return this.test_calldata_coding()
+ *		}
+ *
+ *		// The following function is generated if the protobuf field
+ *		// "Contract.test" is equal to "RETURNDATA_CODER".
+ *		function test_returndata_coding() internal returns (uint) {
+ *			string memory lv_0, bytes memory lv_1 = test_returndata_external();
+ *			if (lv_0 != 044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d)
+ *				return 1;
+ *			if (lv_1 != "1")
+ *				return 2;
+ *			return 0;
+ *		}
+ *
+ *		// The following function is generated if the protobuf field
+ *		// "Contract.test" is equal to "RETURNDATA_CODER".
+ *		function test_returndata_external() external returns (string memory, bytes memory)
+ *		{
+ *			sv_0 = "044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d";
+ *			bytes memory lv_0 = "1";
+ *			return (sv_0, lv_0);
+ *		}
+ *
+  *		// The following function is generated if the protobuf field
+ *		// "Contract.test" is equal to "CALLDATA_CODER".
+ *		function test_calldata_coding() internal returns (uint) {
+ *			// Local variable
+ *			bytes lv_1 = "1";
+ *			sv_0 = "044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d";
+ *			uint returnVal = this.coder_public(sv_0, lv_1);
+ *			if (returnVal != 0)
+ *				return returnVal;
+ *			// Since the return codes in the public and external coder functions are identical
+ *			// we offset error code by a fixed amount (200000) for differentiation.
+ *			returnVal = this.coder_external(sv_0, lv_1);
+ *			if (returnVal != 0)
+ *				return 200000 + returnVal;
+ *			// Encode parameters
+ *			bytes memory argumentEncoding = abi.encode(<parameter_names>);
+ *			returnVal = checkEncodedCall(this.coder_public.selector, argumentEncoding, <invalidLengthFuzz>);
+ *			// Check if calls to coder_public meet expectations for correctly/incorrectly encoded data.
+ *			if (returnVal != 0)
+ *				return returnVal;
+ *
+ *			returnVal = checkEncodedCall(this.coder_external.selector, argumentEncoding, <invalidLengthFuzz>);
+ *			// Check if calls to coder_external meet expectations for correctly/incorrectly encoded data.
+ *			// Offset return value to distinguish between failures originating from coder_public and coder_external.
+ *			if (returnVal != 0)
+ *				return uint(200000) + returnVal;
+ *			// Return zero if all checks pass.
+ *			return 0;
+ *		}
+ *
+ *		/// Accepts function selector, correct argument encoding, and an invalid encoding length as input.
+ *		/// Returns a non-zero value if either call with correct encoding fails or call with incorrect encoding
+ *		/// succeeds. Returns zero if both calls meet expectation.
+ *		function checkEncodedCall(bytes4 funcSelector, bytes memory argumentEncoding, uint invalidLengthFuzz)
+ *			public returns (uint) {
+ *			...
+ *		}
+ *
+ *		/// Accepts function selector, correct argument encoding, and length of invalid encoding and returns
+ *		/// the correct and incorrect abi encoding for calling the function specified by the function selector.
+ *		function createEncoding(bytes4 funcSelector, bytes memory argumentEncoding, uint invalidLengthFuzz)
+ *			internal pure returns (bytes memory, bytes memory) {
+ *			...
+ *		}
+ *
+ *		/// Compares two dynamically sized bytes arrays for equality.
+ *		function bytesCompare(bytes memory a, bytes memory b) internal pure returns (bool) {
+ *			...
+ *		}
+ *
+ *		// Public function that is called by test() function. Accepts one or more arguments and returns
+ *		// a uint value (zero if abi en/decoding was successful, non-zero otherwise)
+ *		function coder_public(string memory c_0, bytes memory c_1) public pure returns (uint) {
+ *			if (!bytesCompare(bytes(c_0), "044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d"))
+ *				return 1;
+ *			if (!bytesCompare(c_1, "1"))
+ *				return 2;
+ *			return 0;
+ *		}
+ *
+ *		// External function that is called by test() function. Accepts one or more arguments and returns
+ *		// a uint value (zero if abi en/decoding was successful, non-zero otherwise)
+ *		function coder_external(string calldata c_0, bytes calldata c_1) external pure returns (uint) {
+ *			if (!bytesCompare(bytes(c_0), "044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d"))
+ *				return 1;
+ *			if (!bytesCompare(c_1, "1"))
+ *				return 2;
+ *			return 0;
+ *		}
+ *	}
+ */
+
+namespace solidity::test::abiv2fuzzer
+{
+using RandomEngine = std::mt19937_64;
+using Distribution = std::uniform_int_distribution<unsigned>;
+using Bernoulli = std::bernoulli_distribution;
+
+/// Converts a protobuf input into a Solidity program that tests
+/// abi coding.
+class ProtoConverter
+{
+public:
+	ProtoConverter(unsigned _seed):
+		m_isStateVar(true),
+		m_counter(0),
+		m_varCounter(0),
+		m_returnValue(1),
+		m_isLastDynParamRightPadded(false),
+		m_structCounter(0),
+		m_numStructsAdded(0)
+	{
+		m_random = std::make_unique<RandomEngine>(_seed);
+	}
+
+	ProtoConverter(ProtoConverter const&) = delete;
+	ProtoConverter(ProtoConverter&&) = delete;
+	std::string contractToString(Contract const& _input);
+	std::string isabelleTypeString() const;
+	std::string isabelleValueString() const;
+	bool coderFunction() const
+	{
+		return m_test == Contract_Test::Contract_Test_CALLDATA_CODER;
+	}
+private:
+	enum class Delimiter
+	{
+		ADD,
+		SKIP
+	};
+	/// Enum of possible function types that decode abi
+	/// encoded parameters.
+	enum class CalleeType
+	{
+		PUBLIC,
+		EXTERNAL
+	};
+
+	/// Each external parameter representation contains the following:
+	/// - Delimiter prefix
+	/// - Boolean that is true if value type, false otherwise
+	/// - String representation of type
+	/// - Parameter name
+	using ParameterPack = std::tuple<Delimiter, bool, std::string, std::string>;
+
+	/// Visitors for various Protobuf types
+	/// Visit top-level contract specification
+	void visit(Contract const&);
+
+	/// Convert test function specification into Solidity test
+	/// function
+	/// @param _testSpec: Protobuf test function specification
+	/// @param _storageDefs: String containing Solidity assignment
+	/// statements to be placed inside the scope of the test function.
+	std::string visit(TestFunction const& _testSpec, std::string const& _storageDefs);
+
+	/// Visitors for the remaining protobuf types. They convert
+	/// the input protobuf specification type into Solidity code.
+	/// @return A pair of strings, first of which contains Solidity
+	/// code to be placed inside contract scope, second of which contains
+	/// Solidity code to be placed inside test function scope.
+	std::pair<std::string, std::string> visit(VarDecl const&);
+	std::pair<std::string, std::string> visit(Type const&);
+	std::pair<std::string, std::string> visit(ValueType const&);
+	std::pair<std::string, std::string> visit(NonValueType const&);
+	std::pair<std::string, std::string> visit(BoolType const&);
+	std::pair<std::string, std::string> visit(IntegerType const&);
+	std::pair<std::string, std::string> visit(FixedByteType const&);
+	std::pair<std::string, std::string> visit(AddressType const&);
+	std::pair<std::string, std::string> visit(DynamicByteArrayType const&);
+	std::pair<std::string, std::string> visit(ArrayType const&);
+	std::pair<std::string, std::string> visit(StructType const&);
+
+	/// Convert a protobuf type @a _T into Solidity code to be placed
+	/// inside contract and test function scopes.
+	/// @param: _type (of parameterized type protobuf type T) is the type
+	/// of protobuf input to be converted.
+	/// @param: _isValueType is true if _type is a Solidity value type e.g., uint
+	/// and false otherwise e.g., string
+	/// @return: A pair of strings, first of which contains Solidity
+	/// code to be placed inside contract scope, second of which contains
+	/// Solidity code to be placed inside test function scope.
+	template <typename T>
+	std::pair<std::string, std::string> processType(T const& _type, bool _isValueType);
+
+	/// Convert a protobuf type @a _T into Solidity variable assignment and check
+	/// statements to be placed inside contract and test function scopes.
+	/// @param: _varName is the name of the Solidity variable
+	/// @param: _paramName is the name of the Solidity parameter that is passed
+	/// to the test function
+	/// @param: _type (of parameterized type protobuf type T) is the type
+	/// of protobuf input to be converted.
+	/// @return: A pair of strings, first of which contains Solidity
+	/// statements to be placed inside contract scope, second of which contains
+	/// Solidity statements to be placed inside test function scope.
+	template <typename T>
+	std::pair<std::string, std::string> assignChecker(
+		std::string const& _varName,
+		std::string const& _paramName,
+		T _type
+	);
+
+	/// Convert a protobuf type @a _T into Solidity variable declaration statement.
+	/// @param: _varName is the name of the Solidity variable
+	/// @param: _paramName is the name of the Solidity parameter that is passed
+	/// to the test function
+	/// @param: _type (of parameterized type protobuf type T) is the type
+	/// of protobuf input to be converted.
+	/// @param: _isValueType is a boolean that is true if _type is a
+	/// Solidity value type e.g., uint and false otherwise e.g., string
+	/// @param: _location is the Solidity location qualifier string to
+	/// be used inside variable declaration statements
+	/// @return: A pair of strings, first of which contains Solidity
+	/// variable declaration statement to be placed inside contract scope,
+	/// second of which contains Solidity variable declaration statement
+	/// to be placed inside test function scope.
+	template <typename T>
+	std::pair<std::string, std::string> varDecl(
+		std::string const& _varName,
+		std::string const& _paramName,
+		T _type,
+		bool _isValueType,
+		std::string const& _location
+	);
+
+	/// Appends a function parameter to the function parameter stream.
+	void appendTypedParams(
+		CalleeType _calleeType,
+		bool _isValueType,
+		std::string const& _typeString,
+		std::string const& _varName,
+		Delimiter _delimiter
+	);
+
+	/// Appends a function parameter to the public test function's
+	/// parameter stream.
+	void appendTypedParamsPublic(
+		bool _isValueType,
+		std::string const& _typeString,
+		std::string const& _varName,
+		Delimiter _delimiter = Delimiter::ADD
+	);
+
+	/// Appends a function parameter to the external test function's
+	/// parameter stream.
+	void appendTypedParamsExternal(
+		bool _isValueType,
+		std::string const& _typeString,
+		std::string const& _varName,
+		Delimiter _delimiter = Delimiter::ADD
+	);
+
+	/// Append types to typed stream used by returndata coders.
+	void appendTypes(
+		bool _isValueType,
+		std::string const& _typeString,
+		Delimiter _delimiter
+	);
+
+	/// Append typed return value.
+	void appendTypedReturn(
+		bool _isValueType,
+		std::string const& _typeString,
+		Delimiter _delimiter
+	);
+
+	/// Append type name to type string meant to be
+	/// passed to Isabelle coder API.
+	void appendToIsabelleTypeString(
+		std::string const& _typeString,
+		Delimiter _delimiter
+	);
+
+	/// Append @a _valueString to value string meant to be
+	/// passed to Isabelle coder API.
+	void appendToIsabelleValueString(
+		std::string const& _valueString,
+		Delimiter _delimiter
+	);
+
+	/// Returns a Solidity variable declaration statement
+	/// @param _type: string containing Solidity type of the
+	/// variable to be declared.
+	/// @param _varName: string containing Solidity variable
+	/// name
+	/// @param _qualifier: string containing location where
+	/// the variable will be placed
+	std::string getVarDecl(
+		std::string const& _type,
+		std::string const& _varName,
+		std::string const& _qualifier
+	);
+
+	/// Return checks that are encoded as Solidity if statements
+	/// as string
+	std::string equalityChecksAsString();
+
+	/// Return comma separated typed function parameters as string
+	std::string typedParametersAsString(CalleeType _calleeType);
+
+	/// Return commonly used Solidity helper functions as string
+	std::string commonHelperFunctions();
+
+	/// Return helper functions used to test calldata coding
+	std::string calldataHelperFunctions();
+
+	/// Return top-level calldata coder test function as string
+	std::string testCallDataFunction(unsigned _invalidLength);
+
+	/// Return top-level returndata coder test function as string
+	std::string testReturnDataFunction();
+
+	/// Return the next variable count that is used for
+	/// variable naming.
+	unsigned getNextVarCounter()
+	{
+		return m_varCounter++;
+	}
+
+	/// Return a pair of names for Solidity variable and the same variable when
+	/// passed either as a function parameter or used to store the tuple
+	/// returned from a function.
+	/// @param _varCounter: name suffix
+	/// @param _stateVar: predicate that is true for state variables, false otherwise
+	std::pair<std::string, std::string> newVarNames(unsigned _varCounter, bool _stateVar)
+	{
+		std::string varName = _stateVar ? s_stateVarNamePrefix : s_localVarNamePrefix;
+		return std::make_pair(
+			varName + std::to_string(_varCounter),
+			paramName() + std::to_string(_varCounter)
+		);
+	}
+
+	std::string paramName()
+	{
+		switch (m_test)
+		{
+		case Contract_Test::Contract_Test_CALLDATA_CODER:
+			return s_paramNamePrefix;
+		case Contract_Test::Contract_Test_RETURNDATA_CODER:
+			return s_localVarNamePrefix;
+		}
+	}
+
+	/// Checks if the last dynamically encoded Solidity type is right
+	/// padded, returning true if it is and false otherwise.
+	bool isLastDynParamRightPadded()
+	{
+		return m_isLastDynParamRightPadded;
+	}
+
+	/// Convert delimiter to a comma or null string.
+	static std::string delimiterToString(Delimiter _delimiter, bool _space = true);
+	/// Generates number in the range [1, @param _n] uniformly at random.
+	unsigned randomNumberOneToN(unsigned _n)
+	{
+		return Distribution(1, _n)(*m_random);
+	}
+	/// Generates boolean that has a bernoulli distribution defined by @param _p.
+	bool randomBool(double _p)
+	{
+		return Bernoulli{_p}(*m_random);
+	}
+
+	/// Contains the test program
+	std::ostringstream m_output;
+	/// Contains a subset of the test program. This subset contains
+	/// checks to be encoded in the test program
+	std::ostringstream m_checks;
+	/// Contains typed parameter list to be passed to callee functions
+	std::ostringstream m_typedParamsPublic;
+	/// Contains parameter list to be passed to callee functions
+	std::ostringstream m_untypedParamsExternal;
+	/// Contains type string to be passed to Isabelle API
+	std::ostringstream m_isabelleTypeString;
+	/// Contains values to be encoded in the format accepted
+	/// by the Isabelle API.
+	std::ostringstream m_isabelleValueString;
+	/// Contains type stream to be used in returndata coder function
+	/// signature
+	std::ostringstream m_types;
+	std::ostringstream m_typedReturn;
+	/// Argument names to be passed to coder functions
+	std::ostringstream m_argsCoder;
+	/// Predicate that is true if we are in contract scope
+	bool m_isStateVar;
+	unsigned m_counter;
+	unsigned m_varCounter;
+	/// Monotonically increasing return value for error reporting
+	unsigned m_returnValue;
+	/// Flag that indicates if last dynamically encoded parameter
+	/// passed to a function call is of a type that is going to be
+	/// right padded by the ABI encoder.
+	bool m_isLastDynParamRightPadded;
+	/// Struct counter
+	unsigned m_structCounter;
+	unsigned m_numStructsAdded;
+	/// Enum stating abiv2 coder to be tested
+	Contract_Test m_test;
+	/// Representation of external parameters
+	std::vector<ParameterPack> m_externalParamsRep;
+	/// Random number generator
+	std::unique_ptr<RandomEngine> m_random;
+	/// Prefixes for declared and parameterized variable names
+	static auto constexpr s_localVarNamePrefix = "lv_";
+	static auto constexpr s_stateVarNamePrefix = "sv_";
+	static auto constexpr s_paramNamePrefix = "p_";
+	/// Maximum number of indirections to test calldata coding
+	static unsigned constexpr s_maxIndirections = 5;
+};
+
+/// Visitor interface for Solidity protobuf types.
+template <typename T>
+class AbiV2ProtoVisitor
+{
+public:
+	static unsigned constexpr s_maxArrayDimensions = 3;
+	virtual ~AbiV2ProtoVisitor() = default;
+
+	virtual T visit(BoolType const& _node) = 0;
+	virtual T visit(IntegerType const& _node) = 0;
+	virtual T visit(FixedByteType const& _node) = 0;
+	virtual T visit(AddressType const& _node) = 0;
+	virtual T visit(DynamicByteArrayType const& _node) = 0;
+	virtual T visit(ArrayType const& _node) = 0;
+	virtual T visit(StructType const& _node) = 0;
+	virtual T visit(ValueType const& _node)
+	{
+		return visitValueType(_node);
+	}
+	virtual T visit(NonValueType const& _node)
+	{
+		return visitNonValueType(_node);
+	}
+	virtual T visit(Type const& _node)
+	{
+		return visitType(_node);
+	}
+
+	enum class DataType
+	{
+		BYTES,
+		VALUE,
+		ARRAY
+	};
+
+	/// Prefixes for declared and parameterized variable names
+	static auto constexpr s_structNamePrefix = "S";
+
+	// Static function definitions
+	static bool isValueType(DataType _dataType)
+	{
+		return _dataType == DataType::VALUE;
+	}
+
+	static unsigned getIntWidth(IntegerType const& _x)
+	{
+		return 8 * ((_x.width() % 32) + 1);
+	}
+
+	static bool isIntSigned(IntegerType const& _x)
+	{
+		return _x.is_signed();
+	}
+
+	static std::string getIntTypeAsString(IntegerType const& _x)
+	{
+		return ((isIntSigned(_x) ? "int" : "uint") + std::to_string(getIntWidth(_x)));
+	}
+
+	static unsigned getFixedByteWidth(FixedByteType const& _x)
+	{
+		return (_x.width() % 32) + 1;
+	}
+
+	static std::string getFixedByteTypeAsString(FixedByteType const& _x)
+	{
+		return "bytes" + std::to_string(getFixedByteWidth(_x));
+	}
+
+	// Convert _counter to string and return its keccak256 hash
+	static u256 hashUnsignedInt(unsigned _counter)
+	{
+		return util::keccak256(util::h256(_counter));
+	}
+
+	static u256 maskUnsignedInt(unsigned _counter, unsigned _numMaskNibbles)
+	{
+		return hashUnsignedInt(_counter) & u256("0x" + std::string(_numMaskNibbles, 'f'));
+	}
+
+	// Requires caller to pass number of nibbles (twice the number of bytes) as second argument.
+	// Note: Don't change HexPrefix::Add. See comment in fixedByteValueAsString().
+	static std::string maskUnsignedIntToHex(unsigned _counter, unsigned _numMaskNibbles)
+	{
+		return "0x" + toHex(maskUnsignedInt(_counter, _numMaskNibbles));
+	}
+
+	/// Dynamically sized arrays can have a length of at least zero
+	/// and at most s_maxArrayLength.
+	static unsigned getDynArrayLengthFromFuzz(unsigned _fuzz, unsigned _counter)
+	{
+		// Increment modulo value by one in order to meet upper bound
+		return (_fuzz + _counter) % (s_maxArrayLength + 1);
+	}
+
+	/// Statically sized arrays must have a length of at least one
+	/// and at most s_maxArrayLength.
+	static unsigned getStaticArrayLengthFromFuzz(unsigned _fuzz)
+	{
+		return _fuzz % s_maxArrayLength + 1;
+	}
+
+	/// Returns a pseudo-random value for the size of a string/hex
+	/// literal. Used for creating variable length hex/string literals.
+	/// @param _counter Monotonically increasing counter value
+	static unsigned getVarLength(unsigned _counter)
+	{
+		// Since _counter values are usually small, we use
+		// this linear equation to make the number derived from
+		// _counter approach a uniform distribution over
+		// [0, s_maxDynArrayLength]
+		auto v = (_counter + 879) * 32 % (s_maxDynArrayLength + 1);
+		/// Always return an even number because Isabelle string
+		/// values are formatted as hex literals
+		if (v % 2 == 1)
+			return v + 1;
+		else
+			return v;
+	}
+protected:
+T visitValueType(ValueType const& _type)
+{
+	switch (_type.value_type_oneof_case())
+	{
+	case ValueType::kInty:
+		return visit(_type.inty());
+	case ValueType::kByty:
+		return visit(_type.byty());
+	case ValueType::kAdty:
+		return visit(_type.adty());
+	case ValueType::kBoolty:
+		return visit(_type.boolty());
+	case ValueType::VALUE_TYPE_ONEOF_NOT_SET:
+		return T();
+	}
+}
+
+T visitNonValueType(NonValueType const& _type)
+{
+	switch (_type.nonvalue_type_oneof_case())
+	{
+	case NonValueType::kDynbytearray:
+		return visit(_type.dynbytearray());
+	case NonValueType::kArrtype:
+		return visit(_type.arrtype());
+	case NonValueType::kStype:
+		return visit(_type.stype());
+	case NonValueType::NONVALUE_TYPE_ONEOF_NOT_SET:
+		return T();
+	}
+}
+
+T visitType(Type const& _type)
+{
+	switch (_type.type_oneof_case())
+	{
+	case Type::kVtype:
+		return visit(_type.vtype());
+	case Type::kNvtype:
+		return visit(_type.nvtype());
+	case Type::TYPE_ONEOF_NOT_SET:
+		return T();
+	}
+}
+private:
+	static unsigned constexpr s_maxArrayLength = 4;
+	static unsigned constexpr s_maxDynArrayLength = 256;
+};
+
+/// Converts a protobuf type into a Solidity type string.
+class TypeVisitor: public AbiV2ProtoVisitor<std::string>
+{
+public:
+	TypeVisitor(unsigned _structSuffix = 0):
+		m_indentation(1),
+		m_structCounter(_structSuffix),
+		m_structStartCounter(_structSuffix),
+		m_structFieldCounter(0),
+		m_isLastDynParamRightPadded(false)
+	{}
+
+	std::string visit(BoolType const&) override;
+	std::string visit(IntegerType const&) override;
+	std::string visit(FixedByteType const&) override;
+	std::string visit(AddressType const&) override;
+	std::string visit(ArrayType const&) override;
+	std::string visit(DynamicByteArrayType const&) override;
+	std::string visit(StructType const&) override;
+	using AbiV2ProtoVisitor<std::string>::visit;
+	std::string baseType()
+	{
+		return m_baseType;
+	}
+	bool isLastDynParamRightPadded()
+	{
+		return m_isLastDynParamRightPadded;
+	}
+	std::string structDef()
+	{
+		return m_structDef.str();
+	}
+	unsigned numStructs()
+	{
+		return m_structCounter - m_structStartCounter;
+	}
+	static bool arrayOfStruct(ArrayType const& _type)
+	{
+		Type const& baseType = _type.t();
+		if (baseType.has_nvtype() && baseType.nvtype().has_stype())
+			return true;
+		else if (baseType.has_nvtype() && baseType.nvtype().has_arrtype())
+			return arrayOfStruct(baseType.nvtype().arrtype());
+		else
+			return false;
+	}
+	std::string isabelleTypeString()
+	{
+		return m_structTupleString.stream.str();
+	}
+private:
+	struct StructTupleString
+	{
+		StructTupleString() = default;
+		unsigned index = 0;
+		std::ostringstream stream;
+		void start()
+		{
+			stream << "(";
+		}
+		void end()
+		{
+			stream << ")";
+		}
+		void addTypeStringToTuple(std::string& _typeString);
+		void addArrayBracketToType(std::string& _arrayBracket);
+	};
+	void structDefinition(StructType const&);
+
+	std::string indentation()
+	{
+		return std::string(m_indentation * 1, '\t');
+	}
+	std::string lineString(std::string const& _line)
+	{
+		return indentation() + _line + "\n";
+	}
+	std::string m_baseType;
+	std::ostringstream m_structDef;
+	/// Utility type for conveniently composing a tuple
+	/// string for struct types.
+	StructTupleString m_structTupleString;
+	unsigned m_indentation;
+	unsigned m_structCounter;
+	unsigned m_structStartCounter;
+	unsigned m_structFieldCounter;
+	bool m_isLastDynParamRightPadded;
+
+	static auto constexpr s_structTypeName = "S";
+};
+
+/// Returns a pair of strings, first of which contains assignment statements
+/// to initialize a given type, and second of which contains checks to be
+/// placed inside the coder function to test abi en/decoding.
+class AssignCheckVisitor: public AbiV2ProtoVisitor<std::pair<std::string, std::string>>
+{
+public:
+	AssignCheckVisitor(
+		std::string _varName,
+		std::string _paramName,
+		unsigned _errorStart,
+		bool _stateVar,
+		unsigned _counter,
+		unsigned _structCounter
+	)
+	{
+		m_counter = m_counterStart = _counter;
+		m_varName = _varName;
+		m_paramName = _paramName;
+		m_errorCode = m_errorStart = _errorStart;
+		m_indentation = 2;
+		m_stateVar = _stateVar;
+		m_structCounter = m_structStart = _structCounter;
+	}
+	std::pair<std::string, std::string> visit(BoolType const&) override;
+	std::pair<std::string, std::string> visit(IntegerType const&) override;
+	std::pair<std::string, std::string> visit(FixedByteType const&) override;
+	std::pair<std::string, std::string> visit(AddressType const&) override;
+	std::pair<std::string, std::string> visit(ArrayType const&) override;
+	std::pair<std::string, std::string> visit(DynamicByteArrayType const&) override;
+	std::pair<std::string, std::string> visit(StructType const&) override;
+	using AbiV2ProtoVisitor<std::pair<std::string, std::string>>::visit;
+
+	unsigned errorStmts()
+	{
+		return m_errorCode - m_errorStart;
+	}
+
+	unsigned counted()
+	{
+		return m_counter - m_counterStart;
+	}
+
+	unsigned structs()
+	{
+		return m_structCounter - m_structStart;
+	}
+
+	std::string isabelleValueString()
+	{
+		return m_valueStream.stream.str();
+	}
+private:
+	struct ValueStream
+	{
+		ValueStream() = default;
+		unsigned index = 0;
+		std::ostringstream stream;
+		void startStruct()
+		{
+			if (index >= 1)
+				stream << ",";
+			index = 0;
+			stream << "(";
+		}
+		void endStruct()
+		{
+			stream << ")";
+		}
+		void startArray()
+		{
+			if (index >= 1)
+				stream << ",";
+			index = 0;
+			stream << "[";
+		}
+		void endArray()
+		{
+			stream << "]";
+			index++;
+		}
+		void appendValue(std::string& _value);
+	};
+	std::string indentation()
+	{
+		return std::string(m_indentation * 1, '\t');
+	}
+	unsigned counter()
+	{
+		return m_counter++;
+	}
+
+	std::pair<std::string, std::string> assignAndCheckStringPair(
+		std::string const& _varRef,
+		std::string const& _checkRef,
+		std::string const& _assignValue,
+		std::string const& _checkValue,
+		DataType _type
+	);
+	std::string assignString(std::string const&, std::string const&);
+	std::string checkString(std::string const&, std::string const&, DataType);
+	unsigned m_counter;
+	unsigned m_counterStart;
+	std::string m_varName;
+	std::string m_paramName;
+	unsigned m_errorCode;
+	unsigned m_errorStart;
+	unsigned m_indentation;
+	bool m_stateVar;
+	unsigned m_structCounter;
+	unsigned m_structStart;
+	ValueStream m_valueStream;
+	bool m_forcedVisit = false;
+};
+
+/// Returns a valid value (as a string) for a given type.
+class ValueGetterVisitor: AbiV2ProtoVisitor<std::string>
+{
+public:
+	ValueGetterVisitor(unsigned _counter = 0): m_counter(_counter) {}
+
+	std::string visit(BoolType const&) override;
+	std::string visit(IntegerType const&) override;
+	std::string visit(FixedByteType const&) override;
+	std::string visit(AddressType const&) override;
+	std::string visit(DynamicByteArrayType const&) override;
+	std::string visit(ArrayType const&) override
+	{
+		solAssert(false, "ABIv2 proto fuzzer: Cannot call valuegettervisitor on complex type");
+	}
+	std::string visit(StructType const&) override
+	{
+		solAssert(false, "ABIv2 proto fuzzer: Cannot call valuegettervisitor on complex type");
+	}
+	using AbiV2ProtoVisitor<std::string>::visit;
+	static std::string isabelleAddressValueAsString(std::string& _solAddressString);
+	static std::string isabelleBytesValueAsString(std::string& _solFixedBytesString);
+private:
+	unsigned counter()
+	{
+		return m_counter++;
+	}
+
+	static std::string addressValueAsString(unsigned _counter);
+	static std::string fixedByteValueAsString(unsigned _width, unsigned _counter);
+
+	/// Returns a hex literal if _isHexLiteral is true, a string literal otherwise.
+	/// The size of the returned literal is _numBytes bytes.
+	/// @param _decorate If true, the returned string is enclosed within double quotes
+	/// if _isHexLiteral is false.
+	/// @param _isHexLiteral If true, the returned string is enclosed within
+	/// double quotes prefixed by the string "hex" if _decorate is true. If
+	/// _decorate is false, the returned string is returned as-is.
+	/// @return hex value as string
+	static std::string hexValueAsString(
+		unsigned _numBytes,
+		unsigned _counter,
+		bool _isHexLiteral,
+		bool _decorate = true
+	);
+
+	/// Returns a hex/string literal of variable length whose value and
+	/// size are pseudo-randomly determined from the counter value.
+	/// @param _counter A monotonically increasing counter value
+	/// @param _isHexLiteral Flag that indicates whether hex (if true) or
+	/// string literal (false) is desired
+	/// @return A variable length hex/string value
+	static std::string bytesArrayValueAsString(unsigned _counter, bool _isHexLiteral);
+
+	/// Concatenates the hash value obtained from monotonically increasing counter
+	/// until the desired number of bytes determined by _numBytes.
+	/// @param _width Desired number of bytes for hex value
+	/// @param _counter A counter value used for creating a keccak256 hash
+	/// @param _isHexLiteral Since this routine may be used to construct
+	/// string or hex literals, this flag is used to construct a valid output.
+	/// @return Valid hex or string literal of size _width bytes
+	static std::string variableLengthValueAsString(
+		unsigned _width,
+		unsigned _counter,
+		bool _isHexLiteral
+	);
+
+	/// Returns a value that is @a _numBytes bytes long.
+	/// @param _numBytes: Number of bytes of desired value
+	/// @param _counter: A counter value
+	/// @param _isHexLiteral: True if desired value is a hex literal, false otherwise
+	static std::string croppedString(unsigned _numBytes, unsigned _counter, bool _isHexLiteral);
+
+	unsigned m_counter;
+};
+
+/// Returns true if protobuf array specification is well-formed, false otherwise
+class ValidityVisitor: AbiV2ProtoVisitor<bool>
+{
+public:
+	ValidityVisitor(): m_arrayDimensions(0) {}
+
+	bool visit(BoolType const&) override
+	{
+		return true;
+	}
+
+	bool visit(IntegerType const&) override
+	{
+		return true;
+	}
+
+	bool visit(FixedByteType const&) override
+	{
+		return true;
+	}
+
+	bool visit(AddressType const&) override
+	{
+		return true;
+	}
+
+	bool visit(DynamicByteArrayType const&) override
+	{
+		return true;
+	}
+
+	bool visit(ArrayType const& _type) override
+	{
+		// Mark array type as invalid in one of the following is true
+		//  - contains more than s_maxArrayDimensions dimensions
+		//  - contains an invalid base type, which happens in the
+		//  following cases
+		//    - array base type is invalid
+		//    - array base type is empty
+		m_arrayDimensions++;
+		if (m_arrayDimensions > s_maxArrayDimensions)
+			return false;
+		return visit(_type.t());
+	}
+
+	bool visit(StructType const& _type) override
+	{
+		// A struct is marked invalid only if all of its fields
+		// are invalid. This is done to prevent an empty struct
+		// being defined (which is a Solidity error).
+		for (auto const& t: _type.t())
+			if (visit(t))
+				return true;
+		return false;
+	}
+
+	unsigned m_arrayDimensions;
+	using AbiV2ProtoVisitor<bool>::visit;
+};
+
+/// Returns true if visited type is dynamically encoded by the abi coder,
+/// false otherwise.
+class DynParamVisitor: AbiV2ProtoVisitor<bool>
+{
+public:
+	DynParamVisitor() = default;
+
+	bool visit(BoolType const&) override
+	{
+		return false;
+	}
+
+	bool visit(IntegerType const&) override
+	{
+		return false;
+	}
+
+	bool visit(FixedByteType const&) override
+	{
+		return false;
+	}
+
+	bool visit(AddressType const&) override
+	{
+		return false;
+	}
+
+	bool visit(DynamicByteArrayType const&) override
+	{
+		return true;
+	}
+
+	bool visit(ArrayType const& _type) override
+	{
+		// Return early if array spec is not well-formed
+		if (!ValidityVisitor().visit(_type))
+			return false;
+
+		// Array is dynamically encoded if it at least one of the following is true
+		//   - at least one dimension is dynamically sized
+		//   - base type is dynamically encoded
+		if (!_type.is_static())
+			return true;
+		else
+			return visit(_type.t());
+	}
+
+	bool visit(StructType const& _type) override
+	{
+		// Return early if empty struct
+		if (!ValidityVisitor().visit(_type))
+			return false;
+
+		// Struct is dynamically encoded if at least one of its fields
+		// is dynamically encoded.
+		for (auto const& t: _type.t())
+			if (visit(t))
+				return true;
+		return false;
+	}
+
+	using AbiV2ProtoVisitor<bool>::visit;
+};
+
+}
diff --git a/compiler/test/tools/ossfuzz/protoToYul.cpp b/compiler/test/tools/ossfuzz/protoToYul.cpp
new file mode 100644
index 00000000..6c8f291d
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protoToYul.cpp
@@ -0,0 +1,2008 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/tools/ossfuzz/protoToYul.h>
+#include <test/tools/ossfuzz/yulOptimizerFuzzDictionary.h>
+
+#include <libyul/Exceptions.h>
+
+#include <libsolutil/StringUtils.h>
+
+#include <range/v3/algorithm/all_of.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/split.hpp>
+
+#include <range/v3/action/remove_if.hpp>
+
+#include <algorithm>
+
+using namespace std;
+using namespace solidity::yul::test::yul_fuzzer;
+using namespace solidity::yul::test;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace solidity;
+
+string ProtoConverter::dictionaryToken(HexPrefix _p)
+{
+	std::string token;
+	// If dictionary constant is requested while converting
+	// for loop condition, then return zero so that we don't
+	// generate infinite for loops.
+	if (m_inForCond)
+		token = "0";
+	else
+	{
+		unsigned indexVar = m_inputSize * m_inputSize + counter();
+		token = hexDictionary[indexVar % hexDictionary.size()];
+		yulAssert(token.size() <= 64, "Proto Fuzzer: Dictionary token too large");
+	}
+
+	return _p == HexPrefix::Add ? "0x" + token : token;
+}
+
+string ProtoConverter::createHex(string const& _hexBytes)
+{
+	string tmp{_hexBytes};
+	if (!tmp.empty())
+	{
+		ranges::actions::remove_if(tmp, [=](char c) -> bool {
+			return !std::isxdigit(c);
+		});
+		tmp = tmp.substr(0, 64);
+	}
+	// We need this awkward if case because hex literals cannot be empty.
+	// Use a dictionary token.
+	if (tmp.empty())
+		tmp = dictionaryToken(HexPrefix::DontAdd);
+	// Hex literals must have even number of digits
+	if (tmp.size() % 2)
+		tmp.insert(0, "0");
+
+	yulAssert(tmp.size() <= 64, "Proto Fuzzer: Dictionary token too large");
+	return tmp;
+}
+
+string ProtoConverter::createAlphaNum(string const& _strBytes)
+{
+	string tmp{_strBytes};
+	if (!tmp.empty())
+	{
+		ranges::actions::remove_if(tmp, [=](char c) -> bool {
+			return !(std::isalpha(c) || std::isdigit(c));
+		});
+		tmp = tmp.substr(0, 32);
+	}
+	return tmp;
+}
+
+EVMVersion ProtoConverter::evmVersionMapping(Program_Version const& _ver)
+{
+	switch (_ver)
+	{
+	case Program::HOMESTEAD:
+		return EVMVersion::homestead();
+	case Program::TANGERINE:
+		return EVMVersion::tangerineWhistle();
+	case Program::SPURIOUS:
+		return EVMVersion::spuriousDragon();
+	case Program::BYZANTIUM:
+		return EVMVersion::byzantium();
+	case Program::CONSTANTINOPLE:
+		return EVMVersion::constantinople();
+	case Program::PETERSBURG:
+		return EVMVersion::petersburg();
+	case Program::ISTANBUL:
+		return EVMVersion::istanbul();
+	case Program::BERLIN:
+		return EVMVersion::berlin();
+	case Program::LONDON:
+		return EVMVersion::london();
+	case Program::PARIS:
+		return EVMVersion::paris();
+	case Program::SHANGHAI:
+		return EVMVersion::shanghai();
+	case Program::CANCUN:
+		return EVMVersion::cancun();
+	}
+}
+
+string ProtoConverter::visit(Literal const& _x)
+{
+	switch (_x.literal_oneof_case())
+	{
+	case Literal::kIntval:
+		return to_string(_x.intval());
+	case Literal::kHexval:
+		return "0x" + createHex(_x.hexval());
+	case Literal::kStrval:
+		return "\"" + createAlphaNum(_x.strval()) + "\"";
+	case Literal::kBoolval:
+		return _x.boolval() ? "true" : "false";
+	case Literal::LITERAL_ONEOF_NOT_SET:
+		return dictionaryToken();
+	}
+}
+
+void ProtoConverter::consolidateVarDeclsInFunctionDef()
+{
+	m_currentFuncVars.clear();
+	yulAssert(!m_funcVars.empty(), "Proto fuzzer: Invalid operation");
+
+	auto const& scopes = m_funcVars.back();
+	for (auto const& s: scopes)
+		for (auto const& var: s)
+			m_currentFuncVars.push_back(&var);
+	yulAssert(!m_funcForLoopInitVars.empty(), "Proto fuzzer: Invalid operation");
+	auto const& forinitscopes = m_funcForLoopInitVars.back();
+	for (auto const& s: forinitscopes)
+		for (auto const& var: s)
+			m_currentFuncVars.push_back(&var);
+}
+
+void ProtoConverter::consolidateGlobalVarDecls()
+{
+	m_currentGlobalVars.clear();
+	// Place pointers to all global variables that are in scope
+	// into a single vector
+	for (auto const& scope: m_globalVars)
+		for (auto const& var: scope)
+			m_currentGlobalVars.push_back(&var);
+	// Place pointers to all variables declared in for-init blocks
+	// that are still live into the same vector
+	for (auto const& init: m_globalForLoopInitVars)
+		for (auto const& var: init)
+			m_currentGlobalVars.push_back(&var);
+}
+
+bool ProtoConverter::varDeclAvailable()
+{
+	if (m_inFunctionDef)
+	{
+		consolidateVarDeclsInFunctionDef();
+		return !m_currentFuncVars.empty();
+	}
+	else
+	{
+		consolidateGlobalVarDecls();
+		return !m_currentGlobalVars.empty();
+	}
+}
+
+void ProtoConverter::visit(VarRef const& _x)
+{
+	if (m_inFunctionDef)
+	{
+		// Ensure that there is at least one variable declaration to reference in function scope.
+		yulAssert(!m_currentFuncVars.empty(), "Proto fuzzer: No variables to reference.");
+		m_output << *m_currentFuncVars[static_cast<size_t>(_x.varnum()) % m_currentFuncVars.size()];
+	}
+	else
+	{
+		// Ensure that there is at least one variable declaration to reference in nested scopes.
+		yulAssert(!m_currentGlobalVars.empty(), "Proto fuzzer: No global variables to reference.");
+		m_output << *m_currentGlobalVars[static_cast<size_t>(_x.varnum()) % m_currentGlobalVars.size()];
+	}
+}
+
+void ProtoConverter::visit(Expression const& _x)
+{
+	switch (_x.expr_oneof_case())
+	{
+	case Expression::kVarref:
+		// If the expression requires a variable reference that we cannot provide
+		// (because there are no variables in scope), we silently output a literal
+		// expression from the optimizer dictionary.
+		if (!varDeclAvailable())
+			m_output << dictionaryToken();
+		else
+			visit(_x.varref());
+		break;
+	case Expression::kCons:
+		// If literal expression describes for-loop condition
+		// then force it to zero, so we don't generate infinite
+		// for loops
+		if (m_inForCond)
+			m_output << "0";
+		else
+			m_output << visit(_x.cons());
+		break;
+	case Expression::kBinop:
+		visit(_x.binop());
+		break;
+	case Expression::kUnop:
+		visit(_x.unop());
+		break;
+	case Expression::kTop:
+		visit(_x.top());
+		break;
+	case Expression::kNop:
+		visit(_x.nop());
+		break;
+	case Expression::kFuncExpr:
+		if (auto v = functionExists(NumFunctionReturns::Single); v.has_value())
+		{
+			string functionName = v.value();
+			visit(_x.func_expr(), functionName, true);
+		}
+		else
+			m_output << dictionaryToken();
+		break;
+	case Expression::kLowcall:
+		visit(_x.lowcall());
+		break;
+	case Expression::kCreate:
+		// Create and create2 return address of created contract which
+		// may lead to state change via sstore of the returned address.
+		if (!m_filterStatefulInstructions)
+			visit(_x.create());
+		else
+			m_output << dictionaryToken();
+		break;
+	case Expression::kUnopdata:
+		// Filter datasize and dataoffset because these instructions may return
+		// a value that is a function of optimisation. Therefore, when run on
+		// an EVM client, the execution traces for unoptimised vs optimised
+		// programs may differ. This ends up as a false-positive bug report.
+		if (m_isObject && !m_filterStatefulInstructions)
+			visit(_x.unopdata());
+		else
+			m_output << dictionaryToken();
+		break;
+	case Expression::EXPR_ONEOF_NOT_SET:
+		m_output << dictionaryToken();
+		break;
+	}
+}
+
+void ProtoConverter::visit(BinaryOp const& _x)
+{
+	BinaryOp_BOp op = _x.op();
+
+	if ((op == BinaryOp::SHL || op == BinaryOp::SHR || op == BinaryOp::SAR) &&
+		!m_evmVersion.hasBitwiseShifting())
+	{
+		m_output << dictionaryToken();
+		return;
+	}
+
+	switch (op)
+	{
+	case BinaryOp::ADD:
+		m_output << "add";
+		break;
+	case BinaryOp::SUB:
+		m_output << "sub";
+		break;
+	case BinaryOp::MUL:
+		m_output << "mul";
+		break;
+	case BinaryOp::DIV:
+		m_output << "div";
+		break;
+	case BinaryOp::MOD:
+		m_output << "mod";
+		break;
+	case BinaryOp::XOR:
+		m_output << "xor";
+		break;
+	case BinaryOp::AND:
+		m_output << "and";
+		break;
+	case BinaryOp::OR:
+		m_output << "or";
+		break;
+	case BinaryOp::EQ:
+		m_output << "eq";
+		break;
+	case BinaryOp::LT:
+		m_output << "lt";
+		break;
+	case BinaryOp::GT:
+		m_output << "gt";
+		break;
+	case BinaryOp::SHR:
+		yulAssert(m_evmVersion.hasBitwiseShifting(), "Proto fuzzer: Invalid evm version");
+		m_output << "shr";
+		break;
+	case BinaryOp::SHL:
+		yulAssert(m_evmVersion.hasBitwiseShifting(), "Proto fuzzer: Invalid evm version");
+		m_output << "shl";
+		break;
+	case BinaryOp::SAR:
+		yulAssert(m_evmVersion.hasBitwiseShifting(), "Proto fuzzer: Invalid evm version");
+		m_output << "sar";
+		break;
+	case BinaryOp::SDIV:
+		m_output << "sdiv";
+		break;
+	case BinaryOp::SMOD:
+		m_output << "smod";
+		break;
+	case BinaryOp::EXP:
+		m_output << "exp";
+		break;
+	case BinaryOp::SLT:
+		m_output << "slt";
+		break;
+	case BinaryOp::SGT:
+		m_output << "sgt";
+		break;
+	case BinaryOp::BYTE:
+		m_output << "byte";
+		break;
+	case BinaryOp::SI:
+		m_output << "signextend";
+		break;
+	case BinaryOp::KECCAK:
+		m_output << "keccak256";
+		break;
+	}
+	m_output << "(";
+	if (op == BinaryOp::KECCAK)
+	{
+		m_output << "mod(";
+		visit(_x.left());
+		m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+		m_output << ",";
+		m_output << "mod(";
+		visit(_x.right());
+		m_output << ", " << to_string(s_maxSize) << ")";
+	}
+	else
+	{
+		visit(_x.left());
+		m_output << ",";
+		visit(_x.right());
+	}
+	m_output << ")";
+}
+
+void ProtoConverter::scopeVariables(vector<string> const& _varNames)
+{
+	// If we are inside a for-init block, there are two places
+	// where the visited vardecl may have been defined:
+	// - directly inside the for-init block
+	// - inside a block within the for-init block
+	// In the latter case, we don't scope extend. The flag
+	// m_forInitScopeExtEnabled (= true) indicates whether we are directly
+	// inside a for-init block e.g., for { let x } or (= false) inside a
+	// nested for-init block e.g., for { { let x } }
+	bool forInitScopeExtendVariable = m_inForInitScope && m_forInitScopeExtEnabled;
+
+	// There are four cases that are tackled here
+	// Case 1. We are inside a function definition and the variable declaration's
+	// scope needs to be extended.
+	// Case 2. We are inside a function definition but scope extension is disabled
+	// Case 3. We are inside global scope and scope extension is required
+	// Case 4. We are inside global scope but scope extension is disabled
+	if (m_inFunctionDef)
+	{
+		// Variables declared directly in for-init block
+		// are tracked separately because their scope
+		// extends beyond the block they are defined in
+		// to the rest of the for-loop statement.
+		// Case 1
+		if (forInitScopeExtendVariable)
+		{
+			yulAssert(
+				!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			for (auto const& varName: _varNames)
+				m_funcForLoopInitVars.back().back().push_back(varName);
+		}
+		// Case 2
+		else
+		{
+			yulAssert(
+				!m_funcVars.empty() && !m_funcVars.back().empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			for (auto const& varName: _varNames)
+				m_funcVars.back().back().push_back(varName);
+		}
+	}
+	// If m_inFunctionDef is false, we are in global scope
+	else
+	{
+		// Case 3
+		if (forInitScopeExtendVariable)
+		{
+			yulAssert(!m_globalForLoopInitVars.empty(), "Proto fuzzer: Invalid operation");
+
+			for (auto const& varName: _varNames)
+				m_globalForLoopInitVars.back().push_back(varName);
+		}
+		// Case 4
+		else
+		{
+			yulAssert(!m_globalVars.empty(), "Proto fuzzer: Invalid operation");
+
+			for (auto const& varName: _varNames)
+				m_globalVars.back().push_back(varName);
+		}
+	}
+}
+
+void ProtoConverter::visit(VarDecl const& _x)
+{
+	string varName = newVarName();
+	m_output << "let " << varName << " := ";
+	visit(_x.expr());
+	m_output << "\n";
+	scopeVariables({varName});
+}
+
+void ProtoConverter::visit(MultiVarDecl const& _x)
+{
+	m_output << "let ";
+	vector<string> varNames;
+	// We support up to 4 variables in a single
+	// declaration statement.
+	unsigned numVars = _x.num_vars() % 3 + 2;
+	string delimiter;
+	for (unsigned i = 0; i < numVars; i++)
+	{
+		string varName = newVarName();
+		varNames.push_back(varName);
+		m_output << delimiter << varName;
+		if (i == 0)
+			delimiter = ", ";
+	}
+	m_output << "\n";
+	scopeVariables(varNames);
+}
+
+void ProtoConverter::visit(TypedVarDecl const& _x)
+{
+	string varName = newVarName();
+	m_output << "let " << varName;
+	switch (_x.type())
+	{
+	case TypedVarDecl::BOOL:
+		m_output << ": bool := ";
+		visit(_x.expr());
+		m_output << " : bool\n";
+		break;
+	case TypedVarDecl::S8:
+		m_output << ": s8 := ";
+		visit(_x.expr());
+		m_output << " : s8\n";
+		break;
+	case TypedVarDecl::S32:
+		m_output << ": s32 := ";
+		visit(_x.expr());
+		m_output << " : s32\n";
+		break;
+	case TypedVarDecl::S64:
+		m_output << ": s64 := ";
+		visit(_x.expr());
+		m_output << " : s64\n";
+		break;
+	case TypedVarDecl::S128:
+		m_output << ": s128 := ";
+		visit(_x.expr());
+		m_output << " : s128\n";
+		break;
+	case TypedVarDecl::S256:
+		m_output << ": s256 := ";
+		visit(_x.expr());
+		m_output << " : s256\n";
+		break;
+	case TypedVarDecl::U8:
+		m_output << ": u8 := ";
+		visit(_x.expr());
+		m_output << " : u8\n";
+		break;
+	case TypedVarDecl::U32:
+		m_output << ": u32 := ";
+		visit(_x.expr());
+		m_output << " : u32\n";
+		break;
+	case TypedVarDecl::U64:
+		m_output << ": u64 := ";
+		visit(_x.expr());
+		m_output << " : u64\n";
+		break;
+	case TypedVarDecl::U128:
+		m_output << ": u128 := ";
+		visit(_x.expr());
+		m_output << " : u128\n";
+		break;
+	case TypedVarDecl::U256:
+		m_output << ": u256 := ";
+		visit(_x.expr());
+		m_output << " : u256\n";
+		break;
+	}
+	// If we are inside a for-init block, there are two places
+	// where the visited vardecl may have been defined:
+	// - directly inside the for-init block
+	// - inside a block within the for-init block
+	// In the latter case, we don't scope extend.
+	if (m_inFunctionDef)
+	{
+		// Variables declared directly in for-init block
+		// are tracked separately because their scope
+		// extends beyond the block they are defined in
+		// to the rest of the for-loop statement.
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		{
+			yulAssert(
+				!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			m_funcForLoopInitVars.back().back().push_back(varName);
+		}
+		else
+		{
+			yulAssert(
+				!m_funcVars.empty() && !m_funcVars.back().empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			m_funcVars.back().back().push_back(varName);
+		}
+	}
+	else
+	{
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		{
+			yulAssert(
+				!m_globalForLoopInitVars.empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			m_globalForLoopInitVars.back().push_back(varName);
+		}
+		else
+		{
+			yulAssert(
+				!m_globalVars.empty(),
+				"Proto fuzzer: Invalid operation"
+			);
+			m_globalVars.back().push_back(varName);
+		}
+	}
+}
+
+void ProtoConverter::visit(UnaryOp const& _x)
+{
+	UnaryOp_UOp op = _x.op();
+
+	// Replace calls to extcodehash on unsupported EVMs with a dictionary
+	// token.
+	if (op == UnaryOp::EXTCODEHASH && !m_evmVersion.hasExtCodeHash())
+	{
+		m_output << dictionaryToken();
+		return;
+	}
+
+	// The following instructions may lead to change of EVM state and are hence
+	// excluded to avoid false positives.
+	if (
+		m_filterStatefulInstructions &&
+		(
+			op == UnaryOp::EXTCODEHASH ||
+			op == UnaryOp::EXTCODESIZE ||
+			op == UnaryOp::BALANCE ||
+			op == UnaryOp::BLOCKHASH
+		)
+	)
+	{
+		m_output << dictionaryToken();
+		return;
+	}
+
+	switch (op)
+	{
+	case UnaryOp::NOT:
+		m_output << "not";
+		break;
+	case UnaryOp::MLOAD:
+		m_output << "mload";
+		break;
+	case UnaryOp::SLOAD:
+		m_output << "sload";
+		break;
+	case UnaryOp::ISZERO:
+		m_output << "iszero";
+		break;
+	case UnaryOp::CALLDATALOAD:
+		m_output << "calldataload";
+		break;
+	case UnaryOp::EXTCODESIZE:
+		m_output << "extcodesize";
+		break;
+	case UnaryOp::EXTCODEHASH:
+		m_output << "extcodehash";
+		break;
+	case UnaryOp::BALANCE:
+		m_output << "balance";
+		break;
+	case UnaryOp::BLOCKHASH:
+		m_output << "blockhash";
+		break;
+	}
+	m_output << "(";
+	if (op == UnaryOp::MLOAD)
+	{
+		m_output << "mod(";
+		visit(_x.operand());
+		m_output << ", " << to_string(s_maxMemory - 32) << ")";
+	}
+	else
+		visit(_x.operand());
+	m_output << ")";
+}
+
+void ProtoConverter::visit(TernaryOp const& _x)
+{
+	switch (_x.op())
+	{
+	case TernaryOp::ADDM:
+		m_output << "addmod";
+		break;
+	case TernaryOp::MULM:
+		m_output << "mulmod";
+		break;
+	}
+	m_output << "(";
+	visit(_x.arg1());
+	m_output << ", ";
+	visit(_x.arg2());
+	m_output << ", ";
+	visit(_x.arg3());
+	m_output << ")";
+}
+
+void ProtoConverter::visit(NullaryOp const& _x)
+{
+	auto op = _x.op();
+	// The following instructions may lead to a change in EVM state and are
+	// excluded to avoid false positive reports.
+	if (
+		m_filterStatefulInstructions &&
+		(
+			op == NullaryOp::GAS ||
+			op == NullaryOp::CODESIZE ||
+			op == NullaryOp::ADDRESS ||
+			op == NullaryOp::TIMESTAMP ||
+			op == NullaryOp::NUMBER ||
+			op == NullaryOp::DIFFICULTY
+		)
+	)
+	{
+		m_output << dictionaryToken();
+		return;
+	}
+
+	switch (op)
+	{
+	case NullaryOp::MSIZE:
+		m_output << "msize()";
+		break;
+	case NullaryOp::GAS:
+		m_output << "gas()";
+		break;
+	case NullaryOp::CALLDATASIZE:
+		m_output << "calldatasize()";
+		break;
+	case NullaryOp::CODESIZE:
+		m_output << "codesize()";
+		break;
+	case NullaryOp::RETURNDATASIZE:
+		// If evm supports returndatasize, we generate it. Otherwise,
+		// we output a dictionary token.
+		if (m_evmVersion.supportsReturndata())
+			m_output << "returndatasize()";
+		else
+			m_output << dictionaryToken();
+		break;
+	case NullaryOp::ADDRESS:
+		m_output << "address()";
+		break;
+	case NullaryOp::ORIGIN:
+		m_output << "origin()";
+		break;
+	case NullaryOp::CALLER:
+		m_output << "caller()";
+		break;
+	case NullaryOp::CALLVALUE:
+		m_output << "callvalue()";
+		break;
+	case NullaryOp::GASPRICE:
+		m_output << "gasprice()";
+		break;
+	case NullaryOp::COINBASE:
+		m_output << "coinbase()";
+		break;
+	case NullaryOp::TIMESTAMP:
+		m_output << "timestamp()";
+		break;
+	case NullaryOp::NUMBER:
+		m_output << "number()";
+		break;
+	case NullaryOp::DIFFICULTY:
+		if (m_evmVersion >= EVMVersion::paris())
+			m_output << "prevrandao()";
+		else
+			m_output << "difficulty()";
+		break;
+	case NullaryOp::GASLIMIT:
+		m_output << "gaslimit()";
+		break;
+	case NullaryOp::SELFBALANCE:
+		// Replace calls to selfbalance() on unsupported EVMs with a dictionary
+		// token.
+		if (m_evmVersion.hasSelfBalance())
+			m_output << "selfbalance()";
+		else
+			m_output << dictionaryToken();
+		break;
+	case NullaryOp::CHAINID:
+		// Replace calls to chainid() on unsupported EVMs with a dictionary
+		// token.
+		if (m_evmVersion.hasChainID())
+			m_output << "chainid()";
+		else
+			m_output << dictionaryToken();
+		break;
+	case NullaryOp::BASEFEE:
+		// Replace calls to basefee() on unsupported EVMs with a dictionary
+		// token.
+		if (m_evmVersion.hasBaseFee())
+			m_output << "basefee()";
+		else
+			m_output << dictionaryToken();
+		break;
+	case NullaryOp::BLOBBASEFEE:
+		// Replace calls to blobbasefee() on unsupported EVMs with a dictionary
+		// token.
+		if (m_evmVersion.hasBlobBaseFee())
+			m_output << "blobbasefee()";
+		else
+			m_output << dictionaryToken();
+		break;
+	}
+}
+
+void ProtoConverter::visit(CopyFunc const& _x)
+{
+	CopyFunc_CopyType type = _x.ct();
+
+	// datacopy() is valid only if we are inside
+	// a Yul object.
+	if (type == CopyFunc::DATA && !m_isObject)
+		return;
+
+	// We don't generate code if the copy function is returndatacopy
+	// and the underlying evm does not support it.
+	if (type == CopyFunc::RETURNDATA && !m_evmVersion.supportsReturndata())
+		return;
+
+	// Code copy may change state if e.g., some byte of code
+	// is stored to storage via a sequence of mload and sstore.
+	if (m_filterStatefulInstructions && type == CopyFunc::CODE)
+		return;
+
+	switch (type)
+	{
+	case CopyFunc::CALLDATA:
+		m_output << "calldatacopy";
+		break;
+	case CopyFunc::CODE:
+		m_output << "codecopy";
+		break;
+	case CopyFunc::RETURNDATA:
+		yulAssert(m_evmVersion.supportsReturndata(), "Proto fuzzer: Invalid evm version");
+		m_output << "returndatacopy";
+		break;
+	case CopyFunc::DATA:
+		m_output << "datacopy";
+		break;
+	}
+	m_output << "(";
+	m_output << "mod(";
+	visit(_x.target());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	visit(_x.source());
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.size());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(ExtCodeCopy const& _x)
+{
+	m_output << "extcodecopy";
+	m_output << "(";
+	visit(_x.addr());
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.target());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	visit(_x.source());
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.size());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(LogFunc const& _x)
+{
+	auto visitPosAndSize = [&](LogFunc const& _y) {
+		m_output << "mod(";
+		visit(_y.pos());
+		m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+		m_output << ", ";
+		m_output << "mod(";
+		visit(_y.size());
+		m_output << ", " << to_string(s_maxSize) << ")";
+	};
+
+	switch (_x.num_topics())
+	{
+	case LogFunc::ZERO:
+		m_output << "log0";
+		m_output << "(";
+		visitPosAndSize(_x);
+		m_output << ")\n";
+		break;
+	case LogFunc::ONE:
+		m_output << "log1";
+		m_output << "(";
+		visitPosAndSize(_x);
+		m_output << ", ";
+		visit(_x.t1());
+		m_output << ")\n";
+		break;
+	case LogFunc::TWO:
+		m_output << "log2";
+		m_output << "(";
+		visitPosAndSize(_x);
+		m_output << ", ";
+		visit(_x.t1());
+		m_output << ", ";
+		visit(_x.t2());
+		m_output << ")\n";
+		break;
+	case LogFunc::THREE:
+		m_output << "log3";
+		m_output << "(";
+		visitPosAndSize(_x);
+		m_output << ", ";
+		visit(_x.t1());
+		m_output << ", ";
+		visit(_x.t2());
+		m_output << ", ";
+		visit(_x.t3());
+		m_output << ")\n";
+		break;
+	case LogFunc::FOUR:
+		m_output << "log4";
+		m_output << "(";
+		visitPosAndSize(_x);
+		m_output << ", ";
+		visit(_x.t1());
+		m_output << ", ";
+		visit(_x.t2());
+		m_output << ", ";
+		visit(_x.t3());
+		m_output << ", ";
+		visit(_x.t4());
+		m_output << ")\n";
+		break;
+	}
+}
+
+void ProtoConverter::visit(AssignmentStatement const& _x)
+{
+	visit(_x.ref_id());
+	m_output << " := ";
+	visit(_x.expr());
+	m_output << "\n";
+}
+
+void ProtoConverter::visitFunctionInputParams(FunctionCall const& _x, unsigned _numInputParams)
+{
+	// We reverse the order of function input visits since it helps keep this switch case concise.
+	switch (_numInputParams)
+	{
+	case 4:
+		visit(_x.in_param4());
+		m_output << ", ";
+		[[fallthrough]];
+	case 3:
+		visit(_x.in_param3());
+		m_output << ", ";
+		[[fallthrough]];
+	case 2:
+		visit(_x.in_param2());
+		m_output << ", ";
+		[[fallthrough]];
+	case 1:
+		visit(_x.in_param1());
+		[[fallthrough]];
+	case 0:
+		break;
+	default:
+		yulAssert(false, "Proto fuzzer: Function call with too many input parameters.");
+		break;
+	}
+}
+
+void ProtoConverter::convertFunctionCall(
+	FunctionCall const& _x,
+	string const& _name,
+	unsigned _numInParams,
+	bool _newLine
+)
+{
+	m_output << _name << "(";
+	visitFunctionInputParams(_x, _numInParams);
+	m_output << ")";
+	if (_newLine)
+		m_output << "\n";
+}
+
+vector<string> ProtoConverter::createVarDecls(unsigned _start, unsigned _end, bool _isAssignment)
+{
+	m_output << "let ";
+	vector<string> varsVec = createVars(_start, _end);
+	if (_isAssignment)
+		m_output << " := ";
+	else
+		m_output << "\n";
+	return varsVec;
+}
+
+optional<string> ProtoConverter::functionExists(NumFunctionReturns _numReturns)
+{
+	for (auto const& item: m_functionSigMap)
+		if (_numReturns == NumFunctionReturns::None || _numReturns == NumFunctionReturns::Single)
+		{
+			if (item.second.second == static_cast<unsigned>(_numReturns))
+				return item.first;
+		}
+		else
+		{
+			if (item.second.second >= static_cast<unsigned>(_numReturns))
+				return item.first;
+		}
+	return nullopt;
+}
+
+void ProtoConverter::visit(FunctionCall const& _x, string const& _functionName, bool _expression)
+{
+	yulAssert(m_functionSigMap.count(_functionName), "Proto fuzzer: Invalid function.");
+	auto ret = m_functionSigMap.at(_functionName);
+	unsigned numInParams = ret.first;
+	unsigned numOutParams = ret.second;
+
+	if (numOutParams == 0)
+	{
+		convertFunctionCall(_x, _functionName, numInParams);
+		return;
+	}
+	else
+	{
+		yulAssert(numOutParams > 0, "");
+		vector<string> varsVec;
+		if (!_expression)
+		{
+			// Obtain variable name suffix
+			unsigned startIdx = counter();
+			varsVec = createVarDecls(
+				startIdx,
+				startIdx + numOutParams,
+				/*isAssignment=*/true
+			);
+		}
+		convertFunctionCall(_x, _functionName, numInParams);
+		// Add newly minted vars in the multidecl statement to current scope
+		if (!_expression)
+			addVarsToScope(varsVec);
+	}
+}
+
+void ProtoConverter::visit(LowLevelCall const& _x)
+{
+	LowLevelCall_Type type = _x.callty();
+
+	// Generate staticcall if it is supported by the underlying evm
+	if (type == LowLevelCall::STATICCALL && !m_evmVersion.hasStaticCall())
+	{
+		// Since staticcall is supposed to return 0 on success and 1 on
+		// failure, we can use counter value to emulate it
+		m_output << ((counter() % 2) ? "0" : "1");
+		return;
+	}
+
+	switch (type)
+	{
+	case LowLevelCall::CALL:
+		m_output << "call(";
+		break;
+	case LowLevelCall::CALLCODE:
+		m_output << "callcode(";
+		break;
+	case LowLevelCall::DELEGATECALL:
+		m_output << "delegatecall(";
+		break;
+	case LowLevelCall::STATICCALL:
+		yulAssert(m_evmVersion.hasStaticCall(), "Proto fuzzer: Invalid evm version");
+		m_output << "staticcall(";
+		break;
+	}
+	visit(_x.gas());
+	m_output << ", ";
+	visit(_x.addr());
+	m_output << ", ";
+	if (type == LowLevelCall::CALL || type == LowLevelCall::CALLCODE)
+	{
+		visit(_x.wei());
+		m_output << ", ";
+	}
+	m_output << "mod(";
+	visit(_x.in());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.insize());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.out());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.outsize());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	m_output << ")";
+}
+
+void ProtoConverter::visit(Create const& _x)
+{
+	Create_Type type = _x.createty();
+
+	// Replace a call to create2 on unsupported EVMs with a dictionary
+	// token.
+	if (type == Create::CREATE2 && !m_evmVersion.hasCreate2())
+	{
+		m_output << dictionaryToken();
+		return;
+	}
+
+	switch (type)
+	{
+	case Create::CREATE:
+		m_output << "create(";
+		break;
+	case Create::CREATE2:
+		m_output << "create2(";
+		break;
+	}
+	visit(_x.wei());
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.position());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.size());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	if (type == Create::CREATE2)
+	{
+		m_output << ", ";
+		visit(_x.value());
+	}
+	m_output << ")";
+}
+
+void ProtoConverter::visit(IfStmt const& _x)
+{
+	m_output << "if ";
+	visit(_x.cond());
+	m_output << " ";
+	visit(_x.if_body());
+}
+
+void ProtoConverter::visit(StoreFunc const& _x)
+{
+	auto storeType = _x.st();
+	switch (storeType)
+	{
+	case StoreFunc::MSTORE:
+		m_output << "mstore(";
+		break;
+	case StoreFunc::SSTORE:
+		m_output << "sstore(";
+		break;
+	case StoreFunc::MSTORE8:
+		m_output << "mstore8(";
+		break;
+	}
+	// Write to memory within bounds, storage is unbounded
+	if (storeType == StoreFunc::SSTORE)
+		visit(_x.loc());
+	else if (storeType == StoreFunc::MSTORE8)
+	{
+		m_output << "mod(";
+		visit(_x.loc());
+		m_output << ", " << to_string(s_maxMemory) << ")";
+	}
+	else if (storeType == StoreFunc::MSTORE)
+	{
+		// Since we write 32 bytes, ensure it does not exceed
+		// upper bound on memory.
+		m_output << "mod(";
+		visit(_x.loc());
+		m_output << ", " << to_string(s_maxMemory - 32) << ")";
+
+	}
+	m_output << ", ";
+	visit(_x.val());
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(ForStmt const& _x)
+{
+	if (++m_numForLoops > s_maxForLoops)
+		return;
+	bool wasInForBody = m_inForBodyScope;
+	bool wasInForInit = m_inForInitScope;
+	bool wasForInitScopeExtEnabled = m_forInitScopeExtEnabled;
+	m_inForBodyScope = false;
+	m_inForInitScope = true;
+	m_forInitScopeExtEnabled = true;
+	m_inForCond = false;
+	m_output << "for ";
+	visit(_x.for_init());
+	m_inForInitScope = false;
+	m_forInitScopeExtEnabled = wasForInitScopeExtEnabled;
+	m_inForCond = true;
+	visit(_x.for_cond());
+	m_inForCond = false;
+	visit(_x.for_post());
+	m_inForBodyScope = true;
+	visit(_x.for_body());
+	m_inForBodyScope = wasInForBody;
+	m_inForInitScope = wasInForInit;
+	if (m_inFunctionDef)
+	{
+		yulAssert(
+			!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
+			"Proto fuzzer: Invalid data structure"
+		);
+		// Remove variables in for-init
+		m_funcForLoopInitVars.back().pop_back();
+	}
+	else
+	{
+		yulAssert(!m_globalForLoopInitVars.empty(), "Proto fuzzer: Invalid data structure");
+		m_globalForLoopInitVars.pop_back();
+	}
+}
+
+void ProtoConverter::visit(BoundedForStmt const& _x)
+{
+	if (++m_numForLoops > s_maxForLoops)
+		return;
+
+	// Boilerplate for loop that limits the number of iterations to a maximum of 4.
+	std::string loopVarName("i_" + std::to_string(m_numNestedForLoops++));
+	m_output << "for { let " << loopVarName << " := 0 } "
+	       << "lt(" << loopVarName << ", 0x60) "
+	       << "{ " << loopVarName << " := add(" << loopVarName << ", 0x20) } ";
+	// Store previous for body scope
+	bool wasInForBody = m_inForBodyScope;
+	bool wasInForInit = m_inForInitScope;
+	m_inForBodyScope = true;
+	m_inForInitScope = false;
+	visit(_x.for_body());
+	// Restore previous for body scope and init
+	m_inForBodyScope = wasInForBody;
+	m_inForInitScope = wasInForInit;
+}
+
+void ProtoConverter::visit(CaseStmt const& _x)
+{
+	string literal = visit(_x.case_lit());
+	// u256 value of literal
+	u256 literalVal;
+
+	// Convert string to u256 before looking for duplicate case literals
+	if (_x.case_lit().has_strval())
+	{
+		// Since string literals returned by the Literal visitor are enclosed within
+		// double quotes (like this "\"<string>\""), their size is at least two in the worst case
+		// that <string> is empty. Here we assert this invariant.
+		yulAssert(literal.size() >= 2, "Proto fuzzer: String literal too short");
+		// This variable stores the <string> part i.e., literal minus the first and last
+		// double quote characters. This is used to compute the keccak256 hash of the
+		// string literal. The hashing is done to check whether we are about to create
+		// a case statement containing a case literal that has already been used in a
+		// previous case statement. If the hash (u256 value) matches a previous hash,
+		// then we simply don't create a new case statement.
+		string noDoubleQuoteStr;
+		if (literal.size() > 2)
+		{
+			// Ensure that all characters in the string literal except the first
+			// and the last (double quote characters) are alphanumeric.
+			yulAssert(
+				ranges::all_of(
+					literal.begin() + 1,
+					literal.end() - 2,
+					[=](char c) { return isalpha(c) || isdigit(c); }),
+				"Proto fuzzer: Invalid string literal encountered"
+			);
+
+			// Make a copy because literal will need to be used later
+			noDoubleQuoteStr = literal.substr(1, literal.size() - 2);
+		}
+		// Hash the result to check for duplicate case literal strings
+		literalVal = u256(h256(noDoubleQuoteStr, h256::FromBinary, h256::AlignLeft));
+
+		// Make sure that an empty string literal evaluates to zero. This is to detect creation of
+		// duplicate case literals like so
+		// switch (x)
+		// {
+		//    case "": { x := 0 }
+		//    case 0: { x:= 1 } // Case statement with duplicate literal is invalid
+		// } // This snippet will not be parsed successfully.
+		if (noDoubleQuoteStr.empty())
+			yulAssert(literalVal == 0, "Proto fuzzer: Empty string does not evaluate to zero");
+	}
+	else if (_x.case_lit().has_boolval())
+		literalVal = _x.case_lit().boolval() ? u256(1) : u256(0);
+	else
+		literalVal = u256(literal);
+
+	// Check if set insertion fails (case literal present) or succeeds (case literal
+	// absent).
+	bool isUnique = m_switchLiteralSetPerScope.top().insert(literalVal).second;
+
+	// It is fine to bail out if we encounter a duplicate case literal because
+	// we can be assured that the switch statement is well-formed i.e., contains
+	// at least one case statement or a default block.
+	if (isUnique)
+	{
+		m_output << "case " << literal << " ";
+		visit(_x.case_block());
+	}
+}
+
+void ProtoConverter::visit(SwitchStmt const& _x)
+{
+	if (_x.case_stmt_size() > 0 || _x.has_default_block())
+	{
+		std::set<u256> s;
+		m_switchLiteralSetPerScope.push(s);
+		m_output << "switch ";
+		visit(_x.switch_expr());
+		m_output << "\n";
+
+		for (auto const& caseStmt: _x.case_stmt())
+			visit(caseStmt);
+
+		m_switchLiteralSetPerScope.pop();
+
+		if (_x.has_default_block())
+		{
+			m_output << "default ";
+			visit(_x.default_block());
+		}
+	}
+}
+
+void ProtoConverter::visit(StopInvalidStmt const& _x)
+{
+	switch (_x.stmt())
+	{
+	case StopInvalidStmt::STOP:
+		m_output << "stop()\n";
+		break;
+	case StopInvalidStmt::INVALID:
+		m_output << "invalid()\n";
+		break;
+	}
+}
+
+void ProtoConverter::visit(RetRevStmt const& _x)
+{
+	switch (_x.stmt())
+	{
+	case RetRevStmt::RETURN:
+		m_output << "return";
+		break;
+	case RetRevStmt::REVERT:
+		m_output << "revert";
+		break;
+	}
+	m_output << "(";
+	m_output << "mod(";
+	visit(_x.pos());
+	m_output << ", " << to_string(s_maxMemory - s_maxSize) << ")";
+	m_output << ", ";
+	m_output << "mod(";
+	visit(_x.size());
+	m_output << ", " << to_string(s_maxSize) << ")";
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(SelfDestructStmt const& _x)
+{
+	m_output << "selfdestruct";
+	m_output << "(";
+	visit(_x.addr());
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(TerminatingStmt const& _x)
+{
+	switch (_x.term_oneof_case())
+	{
+	case TerminatingStmt::kStopInvalid:
+		visit(_x.stop_invalid());
+		break;
+	case TerminatingStmt::kRetRev:
+		visit(_x.ret_rev());
+		break;
+	case TerminatingStmt::kSelfDes:
+		visit(_x.self_des());
+		break;
+	case TerminatingStmt::TERM_ONEOF_NOT_SET:
+		break;
+	}
+}
+
+void ProtoConverter::visit(UnaryOpData const& _x)
+{
+	switch (_x.op())
+	{
+	case UnaryOpData::SIZE:
+		m_output << Whiskers(R"(datasize("<id>"))")
+			("id", getObjectIdentifier(static_cast<unsigned>(_x.identifier())))
+			.render();
+		break;
+	case UnaryOpData::OFFSET:
+		m_output << Whiskers(R"(dataoffset("<id>"))")
+			("id", getObjectIdentifier(static_cast<unsigned>(_x.identifier())))
+			.render();
+		break;
+	}
+}
+
+void ProtoConverter::visit(Statement const& _x)
+{
+	switch (_x.stmt_oneof_case())
+	{
+	case Statement::kDecl:
+		visit(_x.decl());
+		break;
+	case Statement::kAssignment:
+		// Create an assignment statement only if there is at least one variable
+		// declaration that is in scope.
+		if (varDeclAvailable())
+			visit(_x.assignment());
+		break;
+	case Statement::kIfstmt:
+		if (_x.ifstmt().if_body().statements_size() > 0)
+			visit(_x.ifstmt());
+		break;
+	case Statement::kStorageFunc:
+		visit(_x.storage_func());
+		break;
+	case Statement::kBlockstmt:
+		if (_x.blockstmt().statements_size() > 0)
+			visit(_x.blockstmt());
+		break;
+	case Statement::kForstmt:
+		if (_x.forstmt().for_body().statements_size() > 0 && !m_filterUnboundedLoops)
+			visit(_x.forstmt());
+		break;
+	case Statement::kBoundedforstmt:
+		if (_x.boundedforstmt().for_body().statements_size() > 0)
+			visit(_x.boundedforstmt());
+		break;
+	case Statement::kSwitchstmt:
+		visit(_x.switchstmt());
+		break;
+	case Statement::kBreakstmt:
+		if (m_inForBodyScope)
+			m_output << "break\n";
+		break;
+	case Statement::kContstmt:
+		if (m_inForBodyScope)
+			m_output << "continue\n";
+		break;
+	case Statement::kLogFunc:
+		// Log is a stateful statement since it writes to storage.
+		if (!m_filterStatefulInstructions)
+			visit(_x.log_func());
+		break;
+	case Statement::kCopyFunc:
+		visit(_x.copy_func());
+		break;
+	case Statement::kExtcodeCopy:
+		// Extcodecopy may change state if external code is copied via a
+		// sequence of mload/sstore.
+		if (!m_filterStatefulInstructions)
+			visit(_x.extcode_copy());
+		break;
+	case Statement::kTerminatestmt:
+		visit(_x.terminatestmt());
+		break;
+	case Statement::kFunctioncall:
+		if (!m_functionSigMap.empty())
+		{
+			unsigned index = counter() % m_functionSigMap.size();
+			auto iter = m_functionSigMap.begin();
+			advance(iter, index);
+			visit(_x.functioncall(), iter->first);
+		}
+		break;
+	case Statement::kFuncdef:
+		if (_x.funcdef().block().statements_size() > 0)
+			if (!m_inForInitScope)
+				visit(_x.funcdef());
+		break;
+	case Statement::kPop:
+		visit(_x.pop());
+		break;
+	case Statement::kLeave:
+		if (m_inFunctionDef)
+			visit(_x.leave());
+		break;
+	case Statement::kMultidecl:
+		visit(_x.multidecl());
+		break;
+	case Statement::STMT_ONEOF_NOT_SET:
+		break;
+	}
+}
+
+void ProtoConverter::openBlockScope()
+{
+	m_scopeFuncs.emplace_back();
+
+	// Create new block scope inside current function scope
+	if (m_inFunctionDef)
+	{
+		yulAssert(
+			!m_funcVars.empty(),
+			"Proto fuzzer: Invalid data structure"
+		);
+		m_funcVars.back().push_back(vector<string>{});
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		{
+			yulAssert(
+				!m_funcForLoopInitVars.empty(),
+				"Proto fuzzer: Invalid data structure"
+			);
+			m_funcForLoopInitVars.back().push_back(vector<string>{});
+		}
+	}
+	else
+	{
+		m_globalVars.emplace_back();
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+			m_globalForLoopInitVars.emplace_back();
+	}
+}
+
+void ProtoConverter::openFunctionScope(vector<string> const& _funcParams)
+{
+	m_funcVars.push_back(vector<vector<string>>({_funcParams}));
+	m_funcForLoopInitVars.push_back(vector<vector<string>>({}));
+}
+
+void ProtoConverter::updateFunctionMaps(string const& _var)
+{
+	size_t erased = m_functionSigMap.erase(_var);
+
+	for (auto const& i: m_functionDefMap)
+		if (i.second == _var)
+		{
+			erased += m_functionDefMap.erase(i.first);
+			break;
+		}
+
+	yulAssert(erased == 2, "Proto fuzzer: Function maps not updated");
+}
+
+void ProtoConverter::closeBlockScope()
+{
+	// Remove functions declared in the block that is going
+	// out of scope from the global function map.
+	for (auto const& f: m_scopeFuncs.back())
+	{
+		size_t numFuncsRemoved = m_functions.size();
+		m_functions.erase(remove(m_functions.begin(), m_functions.end(), f), m_functions.end());
+		numFuncsRemoved -= m_functions.size();
+		yulAssert(
+			numFuncsRemoved == 1,
+			"Proto fuzzer: Nothing or too much went out of scope"
+		);
+		updateFunctionMaps(f);
+	}
+	// Pop back the vector of scoped functions.
+	if (!m_scopeFuncs.empty())
+		m_scopeFuncs.pop_back();
+
+	// If block belongs to function body, then remove
+	// local variables in function body that are going out of scope.
+	if (m_inFunctionDef)
+	{
+		yulAssert(!m_funcVars.empty(), "Proto fuzzer: Invalid data structure");
+		if (!m_funcVars.back().empty())
+			m_funcVars.back().pop_back();
+	}
+	// Remove variables declared in vanilla block from current
+	// global scope.
+	else
+	{
+		yulAssert(!m_globalVars.empty(), "Proto fuzzer: Invalid data structure");
+		m_globalVars.pop_back();
+	}
+}
+
+void ProtoConverter::closeFunctionScope()
+{
+	yulAssert(!m_funcVars.empty(), "Proto fuzzer: Invalid data structure");
+	m_funcVars.pop_back();
+	yulAssert(!m_funcForLoopInitVars.empty(), "Proto fuzzer: Invalid data structure");
+	m_funcForLoopInitVars.pop_back();
+}
+
+void ProtoConverter::addVarsToScope(vector<string> const& _vars)
+{
+	// If we are in function definition, add the new vars to current function scope
+	if (m_inFunctionDef)
+	{
+		// If we are directly in for-init block, add the newly created vars to the
+		// stack of for-init variables.
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		{
+			yulAssert(
+				!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
+				"Proto fuzzer: Invalid data structure"
+			);
+			m_funcForLoopInitVars.back().back().insert(
+				m_funcForLoopInitVars.back().back().end(),
+				_vars.begin(),
+				_vars.end()
+			);
+		}
+		else
+		{
+			yulAssert(
+				!m_funcVars.empty() && !m_funcVars.back().empty(),
+				"Proto fuzzer: Invalid data structure"
+			);
+			m_funcVars.back().back().insert(
+				m_funcVars.back().back().end(),
+				_vars.begin(),
+				_vars.end()
+			);
+		}
+	}
+	// If we are in a vanilla block, add the new vars to current global scope
+	else
+	{
+		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		{
+			yulAssert(
+				!m_globalForLoopInitVars.empty(),
+				"Proto fuzzer: Invalid data structure"
+			);
+			m_globalForLoopInitVars.back().insert(
+				m_globalForLoopInitVars.back().end(),
+				_vars.begin(),
+				_vars.end()
+			);
+		}
+		else
+		{
+			yulAssert(
+				!m_globalVars.empty(),
+				"Proto fuzzer: Invalid data structure"
+			);
+			m_globalVars.back().insert(
+				m_globalVars.back().end(),
+				_vars.begin(),
+				_vars.end()
+			);
+		}
+	}
+}
+
+void ProtoConverter::visit(Block const& _x)
+{
+	openBlockScope();
+
+	// Register function declarations in this scope unless this
+	// scope belongs to for-init (in which function declarations
+	// are forbidden).
+	for (auto const& statement: _x.statements())
+		if (statement.has_funcdef() && statement.funcdef().block().statements_size() > 0 && !m_inForInitScope)
+			registerFunction(&statement.funcdef());
+
+	if (_x.statements_size() > 0)
+	{
+		m_output << "{\n";
+		bool wasForInitScopeExtEnabled = m_forInitScopeExtEnabled;
+		for (auto const& st: _x.statements())
+		{
+			// If statement is block or introduces one and we are in for-init block
+			// then temporarily disable scope extension if it is not already disabled.
+			if (
+				(st.has_blockstmt() || st.has_switchstmt() || st.has_ifstmt()) &&
+				m_inForInitScope &&
+				m_forInitScopeExtEnabled
+			)
+				m_forInitScopeExtEnabled = false;
+			visit(st);
+			m_forInitScopeExtEnabled = wasForInitScopeExtEnabled;
+		}
+		m_output << "}\n";
+	}
+	else
+		m_output << "{}\n";
+	closeBlockScope();
+}
+
+vector<string> ProtoConverter::createVars(unsigned _startIdx, unsigned _endIdx)
+{
+	yulAssert(_endIdx > _startIdx, "Proto fuzzer: Variable indices not in range");
+	string varsStr = suffixedVariableNameList("x_", _startIdx, _endIdx);
+	m_output << varsStr;
+	vector<string> varsVec;
+	boost::split(
+		varsVec,
+		varsStr,
+		boost::algorithm::is_any_of(", "),
+		boost::algorithm::token_compress_on
+	);
+
+	yulAssert(
+		varsVec.size() == (_endIdx - _startIdx),
+		"Proto fuzzer: Variable count mismatch during function definition"
+	);
+	m_counter += varsVec.size();
+	return varsVec;
+}
+
+void ProtoConverter::registerFunction(FunctionDef const* _x)
+{
+	unsigned numInParams = _x->num_input_params() % s_modInputParams;
+	unsigned numOutParams = _x->num_output_params() % s_modOutputParams;
+	NumFunctionReturns numReturns;
+	if (numOutParams == 0)
+		numReturns = NumFunctionReturns::None;
+	else if (numOutParams == 1)
+		numReturns = NumFunctionReturns::Single;
+	else
+		numReturns = NumFunctionReturns::Multiple;
+
+	// Generate function name
+	string funcName = functionName(numReturns);
+
+	// Register function
+	auto ret = m_functionSigMap.emplace(make_pair(funcName, make_pair(numInParams, numOutParams)));
+	yulAssert(ret.second, "Proto fuzzer: Function already exists.");
+	m_functions.push_back(funcName);
+	m_scopeFuncs.back().push_back(funcName);
+	m_functionDefMap.emplace(make_pair(_x, funcName));
+}
+
+void ProtoConverter::fillFunctionCallInput(unsigned _numInParams)
+{
+	for (unsigned i = 0; i < _numInParams; i++)
+	{
+		// Throw a 4-sided dice to choose whether to populate function input
+		// argument from a pseudo-randomly chosen slot in one of the following
+		// locations: calldata, memory, storage, or Yul optimizer dictionary.
+		unsigned diceValue = counter() % 4;
+		// Pseudo-randomly choose one of the first ten 32-byte
+		// aligned slots.
+		string slot = to_string((counter() % 10) * 32);
+		switch (diceValue)
+		{
+		case 0:
+			m_output << "calldataload(" << slot << ")";
+			break;
+		case 1:
+		{
+			// Access memory within stipulated bounds
+			slot = "mod(" + dictionaryToken() + ", " + to_string(s_maxMemory - 32) + ")";
+			m_output << "mload(" << slot << ")";
+			break;
+		}
+		case 2:
+			m_output << "sload(" << slot << ")";
+			break;
+		default:
+			// Call to dictionaryToken() automatically picks a token
+			// at a pseudo-random location.
+			m_output << dictionaryToken();
+			break;
+		}
+		if (i < _numInParams - 1)
+			m_output << ",";
+	}
+}
+
+void ProtoConverter::saveFunctionCallOutput(vector<string> const& _varsVec)
+{
+	for (auto const& var: _varsVec)
+	{
+		// Flip a dice to choose whether to save output values
+		// in storage or memory.
+		bool coinFlip = counter() % 2 == 0;
+		// Pseudo-randomly choose one of the first ten 32-byte
+		// aligned slots.
+		string slot = to_string((counter() % 10) * 32);
+		if (coinFlip)
+			m_output << "sstore(" << slot << ", " << var << ")\n";
+		else
+			m_output << "mstore(" << slot << ", " << var << ")\n";
+	}
+}
+
+void ProtoConverter::createFunctionCall(
+	string const& _funcName,
+	unsigned _numInParams,
+	unsigned _numOutParams
+)
+{
+	vector<string> varsVec{};
+	if (_numOutParams > 0)
+	{
+		unsigned startIdx = counter();
+		// Prints the following to output stream "let x_i,...,x_n := "
+		varsVec = createVarDecls(
+			startIdx,
+			startIdx + _numOutParams,
+			/*isAssignment=*/true
+		);
+	}
+
+	// Call the function with the correct number of input parameters
+	m_output << _funcName << "(";
+	if (_numInParams > 0)
+		fillFunctionCallInput(_numInParams);
+	m_output << ")\n";
+
+	if (!varsVec.empty())
+	{
+		// Save values returned by function so that they are reflected
+		// in the interpreter trace.
+		saveFunctionCallOutput(varsVec);
+		// Add newly minted vars to current scope
+		addVarsToScope(varsVec);
+	}
+	else
+		yulAssert(_numOutParams == 0, "Proto fuzzer: Function return value not saved");
+}
+
+void ProtoConverter::createFunctionDefAndCall(
+	FunctionDef const& _x,
+	unsigned _numInParams,
+	unsigned _numOutParams
+)
+{
+	yulAssert(
+		((_numInParams <= s_modInputParams - 1) && (_numOutParams <= s_modOutputParams - 1)),
+		"Proto fuzzer: Too many function I/O parameters requested."
+	);
+
+	// Obtain function name
+	yulAssert(m_functionDefMap.count(&_x), "Proto fuzzer: Unregistered function");
+	string funcName = m_functionDefMap.at(&_x);
+
+	vector<string> varsVec = {};
+	m_output << "function " << funcName << "(";
+	unsigned startIdx = counter();
+	if (_numInParams > 0)
+		varsVec = createVars(startIdx, startIdx + _numInParams);
+	m_output << ")";
+
+	vector<string> outVarsVec = {};
+	// This creates -> x_n+1,...,x_r
+	if (_numOutParams > 0)
+	{
+		m_output << " -> ";
+		if (varsVec.empty())
+		{
+			yulAssert(_numInParams == 0, "Proto fuzzer: Input parameters not processed correctly");
+			varsVec = createVars(startIdx, startIdx + _numOutParams);
+		}
+		else
+		{
+			outVarsVec = createVars(startIdx + _numInParams, startIdx + _numInParams + _numOutParams);
+			varsVec.insert(varsVec.end(), outVarsVec.begin(), outVarsVec.end());
+		}
+	}
+	yulAssert(varsVec.size() == _numInParams + _numOutParams, "Proto fuzzer: Function parameters not processed correctly");
+
+	m_output << "\n";
+
+	// If function definition is in for-loop body, update
+	bool wasInForBody = m_inForBodyScope;
+	m_inForBodyScope = false;
+
+	bool wasInFunctionDef = m_inFunctionDef;
+	m_inFunctionDef = true;
+
+	// Create new function scope and add function input and return
+	// parameters to it.
+	openFunctionScope(varsVec);
+	// Visit function body
+	visit(_x.block());
+	closeFunctionScope();
+
+	m_inForBodyScope = wasInForBody;
+	m_inFunctionDef = wasInFunctionDef;
+
+	yulAssert(
+		!m_inForInitScope,
+		"Proto fuzzer: Trying to create function call inside a for-init block"
+	);
+	if (_x.force_call())
+		createFunctionCall(funcName, _numInParams, _numOutParams);
+}
+
+void ProtoConverter::visit(FunctionDef const& _x)
+{
+	unsigned numInParams = _x.num_input_params() % s_modInputParams;
+	unsigned numOutParams = _x.num_output_params() % s_modOutputParams;
+	createFunctionDefAndCall(_x, numInParams, numOutParams);
+}
+
+void ProtoConverter::visit(PopStmt const& _x)
+{
+	m_output << "pop(";
+	visit(_x.expr());
+	m_output << ")\n";
+}
+
+void ProtoConverter::visit(LeaveStmt const&)
+{
+	m_output << "leave\n";
+}
+
+string ProtoConverter::getObjectIdentifier(unsigned _x)
+{
+	unsigned currentId = currentObjectId();
+	string currentObjName = "object" + to_string(currentId);
+	yulAssert(
+		m_objectScope.count(currentObjName) && !m_objectScope.at(currentObjName).empty(),
+		"Yul proto fuzzer: Error referencing object"
+	);
+	vector<string> objectIdsInScope = m_objectScope.at(currentObjName);
+	return objectIdsInScope[_x % objectIdsInScope.size()];
+}
+
+void ProtoConverter::visit(Code const& _x)
+{
+	m_output << "code {\n";
+	visit(_x.block());
+	m_output << "}\n";
+}
+
+void ProtoConverter::visit(Data const& _x)
+{
+	// TODO: Generate random data block identifier
+	m_output << "data \"" << s_dataIdentifier << "\" hex\"" << createHex(_x.hex()) << "\"\n";
+}
+
+void ProtoConverter::visit(Object const& _x)
+{
+	// object "object<n>" {
+	// ...
+	// }
+	m_output << "object " << newObjectId() << " {\n";
+	visit(_x.code());
+	if (_x.has_data())
+		visit(_x.data());
+	for (auto const& subObj: _x.sub_obj())
+		visit(subObj);
+	m_output << "}\n";
+}
+
+void ProtoConverter::buildObjectScopeTree(Object const& _x)
+{
+	// Identifies object being visited
+	string objectName = newObjectId(false);
+	vector<string> node{objectName};
+	if (_x.has_data())
+		node.emplace_back(s_dataIdentifier);
+	for (auto const& subObj: _x.sub_obj())
+	{
+		// Identifies sub object whose numeric suffix is
+		// m_objectId
+		unsigned subObjectId = m_objectId;
+		string subObjectName = "object" + to_string(subObjectId);
+		node.push_back(subObjectName);
+		buildObjectScopeTree(subObj);
+		// Add sub-object to object's ancestors
+		yulAssert(m_objectScope.count(subObjectName), "Yul proto fuzzer: Invalid object hierarchy");
+		for (string const& item: m_objectScope.at(subObjectName))
+			if (item != subObjectName)
+				node.emplace_back(subObjectName + "." + item);
+	}
+	m_objectScope.emplace(objectName, node);
+}
+
+void ProtoConverter::visit(Program const& _x)
+{
+	// Initialize input size
+	m_inputSize = static_cast<unsigned>(_x.ByteSizeLong());
+
+	// Record EVM Version
+	m_evmVersion = evmVersionMapping(_x.ver());
+
+	// Program is either a Yul object or a block of
+	// statements.
+	switch (_x.program_oneof_case())
+	{
+	case Program::kBlock:
+		m_output << "{\n";
+		m_output << "mstore(memoryguard(0x10000), 1)\n";
+		m_output << "sstore(mload(calldataload(0)), 1)\n";
+		visit(_x.block());
+		m_output << "}\n";
+		break;
+	case Program::kObj:
+		m_isObject = true;
+		buildObjectScopeTree(_x.obj());
+		// Reset object id counter
+		m_objectId = 0;
+		visit(_x.obj());
+		break;
+	case Program::PROGRAM_ONEOF_NOT_SET:
+		// {} is a trivial Yul program
+		m_output << "{}";
+		break;
+	}
+}
+
+string ProtoConverter::programToString(Program const& _input)
+{
+	visit(_input);
+	return m_output.str();
+}
+
+string ProtoConverter::functionTypeToString(NumFunctionReturns _type)
+{
+	switch (_type)
+	{
+	case NumFunctionReturns::None:
+		return "n";
+	case NumFunctionReturns::Single:
+		return "s";
+	case NumFunctionReturns::Multiple:
+		return "m";
+	}
+}
diff --git a/compiler/test/tools/ossfuzz/protoToYul.h b/compiler/test/tools/ossfuzz/protoToYul.h
new file mode 100644
index 00000000..b7f7c72e
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protoToYul.h
@@ -0,0 +1,391 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <ostream>
+#include <sstream>
+#include <stack>
+#include <set>
+#include <vector>
+#include <tuple>
+
+#include <test/tools/ossfuzz/yulProto.pb.h>
+
+#include <libsolutil/Common.h>
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/Whiskers.h>
+
+#include <liblangutil/EVMVersion.h>
+
+namespace solidity::yul::test::yul_fuzzer
+{
+class ProtoConverter
+{
+public:
+	ProtoConverter(
+		bool _filterStatefulInstructions = false,
+		bool _filterUnboundedLoops = false
+	)
+	{
+		m_funcVars = std::vector<std::vector<std::vector<std::string>>>{};
+		m_globalVars = std::vector<std::vector<std::string>>{};
+		m_inForBodyScope = false;
+		m_inForInitScope = false;
+		m_inForCond = false;
+		m_numNestedForLoops = 0;
+		m_numForLoops = 0;
+		m_counter = 0;
+		m_inputSize = 0;
+		m_inFunctionDef = false;
+		m_objectId = 0;
+		m_isObject = false;
+		m_forInitScopeExtEnabled = true;
+		m_filterStatefulInstructions = _filterStatefulInstructions;
+		m_filterUnboundedLoops = _filterUnboundedLoops;
+	}
+	ProtoConverter(ProtoConverter const&) = delete;
+	ProtoConverter(ProtoConverter&&) = delete;
+	std::string programToString(Program const& _input);
+
+	/// Returns evm version
+	solidity::langutil::EVMVersion version()
+	{
+		return m_evmVersion;
+	}
+private:
+	void visit(BinaryOp const&);
+
+	/// Visits a basic block optionally adding @a _funcParams to scope.
+	/// @param _block Reference to a basic block of Yul statements.
+	/// @param _funcParams List of function parameter names, defaults to
+	/// an empty vector.
+	void visit(Block const& _block);
+
+	std::string visit(Literal const&);
+	void visit(VarRef const&);
+	void visit(Expression const&);
+	void visit(VarDecl const&);
+	void visit(MultiVarDecl const&);
+	void visit(TypedVarDecl const&);
+	void visit(UnaryOp const&);
+	void visit(AssignmentStatement const&);
+	void visit(IfStmt const&);
+	void visit(StoreFunc const&);
+	void visit(Statement const&);
+	void visit(ForStmt const&);
+	void visit(BoundedForStmt const&);
+	void visit(CaseStmt const&);
+	void visit(SwitchStmt const&);
+	void visit(TernaryOp const&);
+	void visit(NullaryOp const&);
+	void visit(LogFunc const&);
+	void visit(CopyFunc const&);
+	void visit(ExtCodeCopy const&);
+	void visit(StopInvalidStmt const&);
+	void visit(RetRevStmt const&);
+	void visit(SelfDestructStmt const&);
+	void visit(TerminatingStmt const&);
+	/// @param _f is the function call to be visited.
+	/// @param _name is the name of the function called.
+	/// @param _expression is a flag that is true if the function is called
+	/// as a single-value expression, false otherwise.
+	void visit(
+		FunctionCall const& _f,
+		std::string const& _name,
+		bool _expression = false
+	);
+	void visit(FunctionDef const&);
+	void visit(PopStmt const&);
+	void visit(LeaveStmt const&);
+	void visit(LowLevelCall const&);
+	void visit(Create const&);
+	void visit(UnaryOpData const&);
+	void visit(Object const&);
+	void visit(Data const&);
+	void visit(Code const&);
+	void visit(Program const&);
+
+	/// Creates a new block scope.
+	void openBlockScope();
+	/// Creates a new function scope, and adds @a _funcParams to it if it
+	/// is non-empty.
+	void openFunctionScope(std::vector<std::string> const& _funcParams);
+	/// Closes current block scope
+	void closeBlockScope();
+	/// Closes current function scope
+	void closeFunctionScope();
+	/// Adds @a _vars to current scope
+	void addVarsToScope(std::vector<std::string> const& _vars);
+
+	std::string createHex(std::string const& _hexBytes);
+
+	/// Returns a new variable name.
+	std::string newVarName()
+	{
+		return "x_" + std::to_string(counter());
+	}
+
+	/// Accepts an arbitrary string, removes all characters that are neither
+	/// alphabets nor digits from it and returns the said string.
+	static std::string createAlphaNum(std::string const& _strBytes);
+
+	enum class NumFunctionReturns: unsigned
+	{
+		None = 0,
+		Single,
+		Multiple
+	};
+
+	void visitFunctionInputParams(FunctionCall const&, unsigned);
+	void createFunctionDefAndCall(FunctionDef const&, unsigned, unsigned);
+
+	/// Convert function type to a string to be used while naming a
+	/// function that is created by a function declaration statement.
+	/// @param _type Type classified according to the number of
+	/// values returned by function.
+	/// @return A string as follows. If _type is
+	/// None -> "n"
+	/// Single -> "s"
+	/// Multiple -> "m"
+	static std::string functionTypeToString(NumFunctionReturns _type);
+
+	/// Builds a single vector containing variables declared in
+	/// function scope.
+	void consolidateVarDeclsInFunctionDef();
+
+	/// Builds a single vector containing variables declared in
+	/// global scope.
+	void consolidateGlobalVarDecls();
+
+	/// Return true if at least one variable declaration is in scope,
+	/// false otherwise.
+	/// @return True in the following cases:
+	/// - If we are inside a function that has already declared a variable
+	/// - If there is at least one variable declaration that is
+	/// in scope
+	bool varDeclAvailable();
+
+	/// Converts protobuf function call to a Yul function call and appends
+	/// it to output stream.
+	/// @param _x Protobuf function call
+	/// @param _name Function name
+	/// @param _numInParams Number of input arguments accepted by function
+	/// @param _newLine Flag that prints a new line to the output stream if
+	/// true. Default value for the flag is true.
+	void convertFunctionCall(
+		FunctionCall const& _x,
+		std::string const& _name,
+		unsigned _numInParams,
+		bool _newLine = true
+	);
+
+	/// Prints a Yul formatted variable declaration statement to the output
+	/// stream.
+	/// Example 1: createVarDecls(0, 1, true) returns {"x_0"} and prints
+	///		let x_0 :=
+	/// Example 2: createVarDecls(0, 2, false) returns {"x_0", "x_1"} and prints
+	///		let x_0, x_1
+	/// @param _start Start index of variable (inclusive)
+	/// @param _end End index of variable (exclusive)
+	/// @param _isAssignment Flag indicating if variable declaration is also
+	/// an assignment. If true, the string " := " follows the variable
+	/// declaration. Otherwise, a new line is follows the variable
+	/// declaration.
+	/// @return A vector of strings containing the variable names used in
+	/// the declaration statement.
+	std::vector<std::string> createVarDecls(unsigned _start, unsigned _end, bool _isAssignment);
+
+	/// Prints comma separated variable names to output stream and
+	/// returns a vector containing the printed variable names.
+	/// Example: createVars(0, 2) returns {"x_0", "x_1"} and prints
+	///		x_0, x_1
+	/// @param _startIdx Start index of variable (inclusive)
+	/// @param _endIdx End index of variable (exclusive)
+	/// @return A vector of strings containing the printed variable names.
+	std::vector<std::string> createVars(unsigned _startIdx, unsigned _endIdx);
+
+	/// Manages scope of Yul variables
+	/// @param _varNames is a list of Yul variable names whose scope needs
+	/// to be tracked according to Yul scoping rules.
+	void scopeVariables(std::vector<std::string> const& _varNames);
+
+	/// Print the Yul syntax to make a call to a function named @a _funcName to
+	/// the output stream.
+	/// @param _funcName Name of the function to be called
+	/// @param _numInParams Number of input parameters in function signature
+	/// @param _numOutParams Number of output parameters in function signature
+	void createFunctionCall(std::string const& _funcName, unsigned _numInParams, unsigned _numOutParams);
+
+	/// Print the Yul syntax to pass input arguments to a function that has
+	/// @a _numInParams number of input parameters to the output stream.
+	/// The input arguments are pseudo-randomly chosen from calldata, memory,
+	/// storage, or the Yul optimizer hex dictionary.
+	/// @param _numInParams Number of input arguments to fill
+	void fillFunctionCallInput(unsigned _numInParams);
+
+	/// Print the Yul syntax to save values returned by a function call
+	/// to the output stream. The values are either stored to memory or
+	/// storage based on a simulated coin flip. The saved location is
+	/// decided pseudo-randomly.
+	/// @param _varsVec A vector of strings that reference variables
+	/// holding the return values of a function call.
+	void saveFunctionCallOutput(std::vector<std::string> const& _varsVec);
+
+	/// Register a function declaration
+	/// @param _f Pointer to a FunctionDef object
+	void registerFunction(FunctionDef const* _f);
+
+	/// Removes entry from m_functionMap and m_functionName
+	void updateFunctionMaps(std::string const& _x);
+
+	/// Build a tree of objects that contains the object/data
+	/// identifiers that are in scope in a given object.
+	/// @param _x root object of the Yul protobuf specification.
+	void buildObjectScopeTree(Object const& _x);
+
+	/// Returns a pseudo-random dictionary token.
+	/// @param _p Enum that decides if the returned token is hex prefixed ("0x") or not
+	/// @return Dictionary token at the index computed using a
+	/// monotonically increasing counter as follows:
+	///		index = (m_inputSize * m_inputSize + counter) % dictionarySize
+	/// where m_inputSize is the size of the protobuf input and
+	/// dictionarySize is the total number of entries in the dictionary.
+	std::string dictionaryToken(util::HexPrefix _p = util::HexPrefix::Add);
+
+	/// Returns an EVMVersion object corresponding to the protobuf
+	/// enum of type Program_Version
+	static solidity::langutil::EVMVersion evmVersionMapping(Program_Version const& _x);
+
+	/// @returns name of Yul function with return type of @param _numReturns.
+	std::optional<std::string> functionExists(NumFunctionReturns _numReturns);
+
+	/// Returns a monotonically increasing counter that starts from zero.
+	unsigned counter()
+	{
+		return m_counter++;
+	}
+
+	/// Generate function name of the form "foo_<typeSuffix>_<counter>".
+	/// @param _type Type classified according to the number of
+	/// values returned by function.
+	std::string functionName(NumFunctionReturns _type)
+	{
+		return "foo_" + functionTypeToString(_type) + "_" + std::to_string(counter());
+	}
+
+	/// Returns a pseudo-randomly chosen object identifier that is in the
+	/// scope of the Yul object being visited.
+	std::string getObjectIdentifier(unsigned _x);
+
+	/// Return new object identifier as string. Identifier string
+	/// is a template of the form "\"object<n>\"" where <n> is
+	/// a monotonically increasing object ID counter.
+	/// @param _decorate If true (default value), object ID is
+	/// enclosed within double quotes.
+	std::string newObjectId(bool _decorate = true)
+	{
+		return util::Whiskers(R"(<?decorate>"</decorate>object<id><?decorate>"</decorate>)")
+			("decorate", _decorate)
+			("id", std::to_string(m_objectId++))
+			.render();
+	}
+
+	/// Returns the object counter value corresponding to the object
+	/// being visited.
+	unsigned currentObjectId() const
+	{
+		return m_objectId - 1;
+	}
+
+	std::ostringstream m_output;
+	/// Variables in all function definitions
+	std::vector<std::vector<std::vector<std::string>>> m_funcVars;
+	/// Variables in current function definition
+	std::vector<std::string const*> m_currentFuncVars;
+	/// Variables in global scope
+	std::vector<std::string const*> m_currentGlobalVars;
+	/// Functions in current scope
+	std::vector<std::vector<std::string>> m_scopeFuncs;
+	/// Global variables
+	std::vector<std::vector<std::string>> m_globalVars;
+	/// Variables declared in for loop init block that is in global scope
+	std::vector<std::vector<std::string>> m_globalForLoopInitVars;
+	/// Variables declared in for loop init block that is in function scope
+	std::vector<std::vector<std::vector<std::string>>> m_funcForLoopInitVars;
+	/// Vector of function names
+	std::vector<std::string> m_functions;
+	/// Maps FunctionDef object to its name
+	std::map<FunctionDef const*, std::string> m_functionDefMap;
+	// Set that is used for deduplicating switch case literals
+	std::stack<std::set<u256>> m_switchLiteralSetPerScope;
+	// Look-up table per function type that holds the number of input (output) function parameters
+	std::map<std::string, std::pair<unsigned, unsigned>> m_functionSigMap;
+	/// Map of object name to list of sub-object namespace(s) in scope
+	std::map<std::string, std::vector<std::string>> m_objectScope;
+	// mod input/output parameters impose an upper bound on the number of input/output parameters a function may have.
+	static unsigned constexpr s_modInputParams = 5;
+	static unsigned constexpr s_modOutputParams = 5;
+	/// Hard-coded identifier for a Yul object's data block
+	static auto constexpr s_dataIdentifier = "datablock";
+	/// Upper bound on memory writes is 64KB in order to
+	/// preserve semantic equivalence in the presence of
+	/// memory guard
+	static unsigned constexpr s_maxMemory = 65536;
+	/// Upper bound on size for range copy functions
+	static unsigned constexpr s_maxSize = 32768;
+	/// Predicate to keep track of for body scope. If false, break/continue
+	/// statements can not be created.
+	bool m_inForBodyScope;
+	/// Maximum number of for loops that a test case may contain
+	static auto constexpr s_maxForLoops = 2;
+	// Index used for naming loop variable of bounded for loops
+	unsigned m_numNestedForLoops;
+	/// Counter for number of for loops
+	unsigned m_numForLoops;
+	/// Predicate to keep track of for loop init scope. If true, variable
+	/// or function declarations can not be created.
+	bool m_inForInitScope;
+	/// Flag that is true while converting for loop condition,
+	/// false otherwise.
+	bool m_inForCond;
+	/// Monotonically increasing counter
+	unsigned m_counter;
+	/// Size of protobuf input
+	unsigned m_inputSize;
+	/// Predicate that is true if inside function definition, false otherwise
+	bool m_inFunctionDef;
+	/// Index used for naming objects
+	unsigned m_objectId;
+	/// Flag to track whether program is an object (true) or a statement block
+	/// (false: default value)
+	bool m_isObject;
+	/// Flag to track whether scope extension of variables defined in for-init
+	/// block is enabled.
+	bool m_forInitScopeExtEnabled;
+	/// Object that holds the targeted evm version specified by protobuf input
+	solidity::langutil::EVMVersion m_evmVersion;
+	/// Flag that, if set, stops the converter from generating state changing
+	/// opcodes.
+	bool m_filterStatefulInstructions;
+	/// Flat that, if set, stops the converter from generating potentially
+	/// unbounded loops.
+	bool m_filterUnboundedLoops;
+};
+}
diff --git a/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.cpp b/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.cpp
new file mode 100644
index 00000000..9b0c97a2
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.cpp
@@ -0,0 +1,285 @@
+#include <test/tools/ossfuzz/protomutators/YulProtoMutator.h>
+
+#include <libyul/Exceptions.h>
+
+#include <src/text_format.h>
+
+using namespace solidity::yul::test::yul_fuzzer;
+using namespace protobuf_mutator;
+using namespace std;
+
+using YPM = YulProtoMutator;
+
+MutationInfo::MutationInfo(ProtobufMessage const* _message, string const& _info):
+	ScopeGuard([&]{ exitInfo(); }),
+	m_protobufMsg(_message)
+{
+	writeLine("----------------------------------");
+	writeLine("YULMUTATOR: " + _info);
+	writeLine("Before");
+	writeLine(SaveMessageAsText(*m_protobufMsg));
+}
+
+void MutationInfo::exitInfo()
+{
+	writeLine("After");
+	writeLine(SaveMessageAsText(*m_protobufMsg));
+}
+
+/// Add m/sstore(0, variable)
+static LPMPostProcessor<Block> addStoreToZero(
+	[](Block* _message, unsigned _seed)
+	{
+		if (_seed % YPM::s_highIP == 0)
+		{
+			YulRandomNumGenerator yrand(_seed);
+			MutationInfo m{_message, "Added store to zero"};
+			auto storeStmt = new StoreFunc();
+			storeStmt->set_st(YPM::EnumTypeConverter<StoreFunc_Storage>{}.enumFromSeed(yrand()));
+			storeStmt->set_allocated_loc(YPM::litExpression(0));
+			storeStmt->set_allocated_val(YPM::refExpression(yrand));
+			auto stmt = _message->add_statements();
+			stmt->set_allocated_storage_func(storeStmt);
+		}
+	}
+);
+
+
+namespace
+{
+template <typename T>
+struct addControlFlow
+{
+	addControlFlow()
+	{
+		function = [](T* _message, unsigned _seed)
+		{
+			MutationInfo m{_message, "Added control flow."};
+			YPM::addControlFlow(_message, _seed);
+		};
+		/// Unused variable registers callback.
+		LPMPostProcessor<T> callback(function);
+	}
+	function<void(T*, unsigned)> function;
+};
+}
+
+static addControlFlow<ForStmt> c1;
+static addControlFlow<BoundedForStmt> c2;
+static addControlFlow<IfStmt> c3;
+static addControlFlow<SwitchStmt> c4;
+static addControlFlow<FunctionDef> c5;
+static addControlFlow<CaseStmt> c6;
+static addControlFlow<Code> c7;
+static addControlFlow<Program> c8;
+
+Literal* YPM::intLiteral(unsigned _value)
+{
+	auto lit = new Literal();
+	lit->set_intval(_value);
+	return lit;
+}
+
+VarRef* YPM::varRef(unsigned _seed)
+{
+	auto varref = new VarRef();
+	varref->set_varnum(_seed);
+	return varref;
+}
+
+Expression* YPM::refExpression(YulRandomNumGenerator& _rand)
+{
+	auto refExpr = new Expression();
+	refExpr->set_allocated_varref(varRef(_rand()));
+	return refExpr;
+}
+
+Expression* YPM::litExpression(unsigned _value)
+{
+	auto lit = intLiteral(_value);
+	auto expr = new Expression();
+	expr->set_allocated_cons(lit);
+	return expr;
+}
+
+template <typename T>
+T YPM::EnumTypeConverter<T>::validEnum(unsigned _seed)
+{
+	auto ret = static_cast<T>(_seed % (enumMax() - enumMin() + 1) + enumMin());
+	if constexpr (std::is_same_v<std::decay_t<T>, StoreFunc_Storage>)
+		yulAssert(StoreFunc_Storage_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, NullaryOp_NOp>)
+		yulAssert(NullaryOp_NOp_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, BinaryOp_BOp>)
+		yulAssert(BinaryOp_BOp_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOp_UOp>)
+		yulAssert(UnaryOp_UOp_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, LowLevelCall_Type>)
+		yulAssert(LowLevelCall_Type_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, Create_Type>)
+		yulAssert(Create_Type_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOpData_UOpData>)
+		yulAssert(UnaryOpData_UOpData_IsValid(ret), "Yul proto mutator: Invalid enum");
+	else
+		static_assert(AlwaysFalse<T>::value, "Yul proto mutator: non-exhaustive visitor.");
+	return ret;
+}
+
+template <typename T>
+unsigned YPM::EnumTypeConverter<T>::enumMax()
+{
+	if constexpr (std::is_same_v<std::decay_t<T>, StoreFunc_Storage>)
+		return StoreFunc_Storage_Storage_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, NullaryOp_NOp>)
+		return NullaryOp_NOp_NOp_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, BinaryOp_BOp>)
+		return BinaryOp_BOp_BOp_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOp_UOp>)
+		return UnaryOp_UOp_UOp_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, LowLevelCall_Type>)
+		return LowLevelCall_Type_Type_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, Create_Type>)
+		return Create_Type_Type_MAX;
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOpData_UOpData>)
+		return UnaryOpData_UOpData_UOpData_MAX;
+	else
+		static_assert(AlwaysFalse<T>::value, "Yul proto mutator: non-exhaustive visitor.");
+}
+
+template <typename T>
+unsigned YPM::EnumTypeConverter<T>::enumMin()
+{
+	if constexpr (std::is_same_v<std::decay_t<T>, StoreFunc_Storage>)
+		return StoreFunc_Storage_Storage_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, NullaryOp_NOp>)
+		return NullaryOp_NOp_NOp_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, BinaryOp_BOp>)
+		return BinaryOp_BOp_BOp_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOp_UOp>)
+		return UnaryOp_UOp_UOp_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, LowLevelCall_Type>)
+		return LowLevelCall_Type_Type_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, Create_Type>)
+		return Create_Type_Type_MIN;
+	else if constexpr (std::is_same_v<std::decay_t<T>, UnaryOpData_UOpData>)
+		return UnaryOpData_UOpData_UOpData_MIN;
+	else
+		static_assert(AlwaysFalse<T>::value, "Yul proto mutator: non-exhaustive visitor.");
+}
+
+template <typename T>
+void YPM::addControlFlow(T* _msg, unsigned _seed)
+{
+	enum class ControlFlowStmt: unsigned
+	{
+		For = 0,
+		BoundedFor,
+		If,
+		Switch,
+		FunctionCall,
+		Break,
+		Continue,
+		Leave,
+		Termination
+	};
+	uniform_int_distribution<unsigned> d(
+		static_cast<unsigned>(ControlFlowStmt::For),
+		static_cast<unsigned>(ControlFlowStmt::Termination)
+	);
+	YulRandomNumGenerator yrand(_seed);
+	auto random = static_cast<ControlFlowStmt>(d(yrand.m_random));
+	Statement* s = basicBlock(_msg, _seed)->add_statements();
+	switch (random)
+	{
+	case ControlFlowStmt::For:
+		s->set_allocated_forstmt(new ForStmt());
+		break;
+	case ControlFlowStmt::BoundedFor:
+		s->set_allocated_boundedforstmt(new BoundedForStmt());
+		break;
+	case ControlFlowStmt::If:
+		s->set_allocated_ifstmt(new IfStmt());
+		break;
+	case ControlFlowStmt::Switch:
+		s->set_allocated_switchstmt(new SwitchStmt());
+		break;
+	case ControlFlowStmt::FunctionCall:
+		s->set_allocated_functioncall(new FunctionCall());
+		break;
+	case ControlFlowStmt::Break:
+		s->set_allocated_breakstmt(new BreakStmt());
+		break;
+	case ControlFlowStmt::Continue:
+		s->set_allocated_contstmt(new ContinueStmt());
+		break;
+	case ControlFlowStmt::Leave:
+		s->set_allocated_leave(new LeaveStmt());
+		break;
+	case ControlFlowStmt::Termination:
+		s->set_allocated_terminatestmt(new TerminatingStmt());
+		break;
+	}
+}
+
+Block* YPM::randomBlock(ForStmt* _stmt, unsigned _seed)
+{
+	enum class ForBlocks: unsigned
+	{
+		Init = 0,
+		Post = 1,
+		Body = 2
+	};
+	uniform_int_distribution<unsigned> d(
+		static_cast<unsigned>(ForBlocks::Init),
+		static_cast<unsigned>(ForBlocks::Body)
+	);
+	YulRandomNumGenerator yrand(_seed);
+	switch (static_cast<ForBlocks>(d(yrand.m_random)))
+	{
+	case ForBlocks::Init:
+		return _stmt->mutable_for_init();
+	case ForBlocks::Post:
+		return _stmt->mutable_for_post();
+	case ForBlocks::Body:
+		return _stmt->mutable_for_body();
+	}
+}
+
+template <typename T>
+Block* YPM::basicBlock(T* _msg, unsigned _seed)
+{
+	if constexpr (std::is_same_v<T, ForStmt>)
+		return randomBlock(_msg, _seed);
+	else if constexpr (std::is_same_v<T, BoundedForStmt>)
+		return _msg->mutable_for_body();
+	else if constexpr (std::is_same_v<T, SwitchStmt>)
+		return _msg->mutable_default_block();
+	else if constexpr (std::is_same_v<T, FunctionDef>)
+		return _msg->mutable_block();
+	else if constexpr (std::is_same_v<T, IfStmt>)
+		return _msg->mutable_if_body();
+	else if constexpr (std::is_same_v<T, CaseStmt>)
+		return _msg->mutable_case_block();
+	else if constexpr (std::is_same_v<T, Code>)
+		return _msg->mutable_block();
+	else if constexpr (std::is_same_v<T, Program>)
+		return globalBlock(_msg);
+	else
+		static_assert(AlwaysFalse<T>::value, "Yul proto mutator: non-exhaustive visitor.");
+}
+
+Block* YPM::globalBlock(Program* _program)
+{
+	switch (_program->program_oneof_case())
+	{
+	case Program::kBlock:
+		return _program->mutable_block();
+	case Program::kObj:
+		return _program->mutable_obj()->mutable_code()->mutable_block();
+	case Program::PROGRAM_ONEOF_NOT_SET:
+	{
+		_program->set_allocated_block(new Block());
+		return _program->mutable_block();
+	}
+	}
+}
diff --git a/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.h b/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.h
new file mode 100644
index 00000000..0d68b95c
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/protomutators/YulProtoMutator.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <test/tools/ossfuzz/yulProto.pb.h>
+
+#include <libsolutil/Common.h>
+
+#include <src/libfuzzer/libfuzzer_macro.h>
+
+#include <random>
+
+namespace solidity::yul::test::yul_fuzzer
+{
+
+using ProtobufMessage = google::protobuf::Message;
+
+template <typename Proto>
+using LPMPostProcessor = protobuf_mutator::libfuzzer::PostProcessorRegistration<Proto>;
+
+class MutationInfo: public ScopeGuard
+{
+public:
+	MutationInfo(ProtobufMessage const* _message, std::string const& _info);
+
+	static void writeLine(std::string const& _str)
+	{
+		std::cout << _str << std::endl;
+	}
+	void exitInfo();
+
+	ProtobufMessage const* m_protobufMsg;
+};
+
+struct YulRandomNumGenerator
+{
+	using RandomEngine = std::minstd_rand;
+
+	explicit YulRandomNumGenerator(unsigned _seed): m_random(RandomEngine(_seed)) {}
+
+	unsigned operator()()
+	{
+		return static_cast<unsigned>(m_random());
+	}
+
+	RandomEngine m_random;
+};
+
+struct YulProtoMutator
+{
+	/// @param _value: Value of the integer literal
+	/// @returns an integer literal protobuf message initialized with
+	/// the given value.
+	static Literal* intLiteral(unsigned _value);
+
+	/// @param _seed: Pseudo-random unsigned integer used as index
+	/// of variable to be referenced
+	/// @returns a variable reference protobuf message.
+	static VarRef* varRef(unsigned _seed);
+
+	/// @param _value: value of literal expression
+	/// @returns an expression protobuf message
+	static Expression* litExpression(unsigned _value);
+
+	/// @param _rand: Pseudo-random number generator
+	/// of variable to be referenced
+	/// @returns a variable reference protobuf message
+	static Expression* refExpression(YulRandomNumGenerator& _rand);
+
+	/// Helper type for type matching visitor.
+	template<class T> struct AlwaysFalse: std::false_type {};
+
+	/// Template struct for obtaining a valid enum value of
+	/// template type from a pseudo-random unsigned integer.
+	/// @param _seed: Pseudo-random integer
+	/// @returns Valid enum of enum type T
+	template <typename T>
+	struct EnumTypeConverter
+	{
+		T enumFromSeed(unsigned _seed)
+		{
+			return validEnum(_seed);
+		}
+
+		/// @returns a valid enum of type T from _seed
+		T validEnum(unsigned _seed);
+		/// @returns maximum enum value for enum of type T
+		static unsigned enumMax();
+		/// @returns minimum enum value for enum of type T
+		static unsigned enumMin();
+	};
+
+	/// Modulo for mutations that should occur rarely
+	static constexpr unsigned s_lowIP = 31;
+	/// Modulo for mutations that should occur not too often
+	static constexpr unsigned s_mediumIP = 29;
+	/// Modulo for mutations that should occur often
+	static constexpr unsigned s_highIP = 23;
+	/// Add control-flow statement to basic block.
+	template <typename T>
+	static void addControlFlow(T* _msg, unsigned _seed);
+	/// Obtain basic block for statement type.
+	template <typename T>
+	static Block* basicBlock(T* _msg, unsigned _seed);
+	/// Obtain a basic block in a for stmt uniformly
+	/// at random
+	static Block* randomBlock(ForStmt* _msg, unsigned _seed);
+	/// Obtain a basic block in global scope.
+	static Block* globalBlock(Program* _program);
+};
+}
diff --git a/compiler/test/tools/ossfuzz/strictasm_assembly_ossfuzz.cpp b/compiler/test/tools/ossfuzz/strictasm_assembly_ossfuzz.cpp
new file mode 100644
index 00000000..c7ffd3d4
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/strictasm_assembly_ossfuzz.cpp
@@ -0,0 +1,62 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libyul/YulStack.h>
+#include <libyul/backends/evm/EVMCodeTransform.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/EVMVersion.h>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace std;
+
+// Prototype as we can't use the FuzzerInterface.h header.
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size);
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
+{
+	if (_size > 600)
+		return 0;
+
+	YulStringRepository::reset();
+
+	string input(reinterpret_cast<char const*>(_data), _size);
+	YulStack stack(
+		langutil::EVMVersion(),
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::minimal(),
+		langutil::DebugInfoSelection::All()
+	);
+
+	if (!stack.parseAndAnalyze("source", input))
+		return 0;
+
+	try
+	{
+		MachineAssemblyObject obj = stack.assemble(YulStack::Machine::EVM);
+		solAssert(obj.bytecode, "");
+	}
+	catch (StackTooDeepError const&)
+	{
+
+	}
+
+	return 0;
+}
diff --git a/compiler/test/tools/ossfuzz/strictasm_diff_ossfuzz.cpp b/compiler/test/tools/ossfuzz/strictasm_diff_ossfuzz.cpp
new file mode 100644
index 00000000..5c923a3e
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/strictasm_diff_ossfuzz.cpp
@@ -0,0 +1,113 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libyul/AsmAnalysisInfo.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/Dialect.h>
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/YulStack.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/EVMVersion.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/CommonData.h>
+#include <libsolutil/StringUtils.h>
+
+#include <test/tools/ossfuzz/yulFuzzerCommon.h>
+
+#include <string>
+#include <memory>
+#include <iostream>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul::test::yul_fuzzer;
+
+// Prototype as we can't use the FuzzerInterface.h header.
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size);
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
+{
+	if (_size > 600)
+		return 0;
+
+	string input(reinterpret_cast<char const*>(_data), _size);
+
+	if (std::any_of(input.begin(), input.end(), [](char c) {
+		return ((static_cast<unsigned char>(c) > 127) || !(isPrint(c) || (c == '\n') || (c == '\t')));
+	}))
+		return 0;
+
+	YulStringRepository::reset();
+
+	YulStack stack(
+		langutil::EVMVersion(),
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::full(),
+		DebugInfoSelection::All()
+	);
+	try
+	{
+		if (
+			!stack.parseAndAnalyze("source", input) ||
+			!stack.parserResult()->code ||
+			!stack.parserResult()->analysisInfo
+		)
+			return 0;
+	}
+	catch (Exception const&)
+	{
+		return 0;
+	}
+
+	ostringstream os1;
+	ostringstream os2;
+	// Disable memory tracing to avoid false positive reports
+	// such as unused write to memory e.g.,
+	// { mstore(0, 1) }
+	// that would be removed by the redundant store eliminator.
+	yulFuzzerUtil::TerminationReason termReason = yulFuzzerUtil::interpret(
+		os1,
+		stack.parserResult()->code,
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		/*disableMemoryTracing=*/true
+	);
+	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
+		return 0;
+
+	stack.optimize();
+	termReason = yulFuzzerUtil::interpret(
+		os2,
+		stack.parserResult()->code,
+		EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion()),
+		/*disableMemoryTracing=*/true
+	);
+
+	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
+		return 0;
+
+	bool isTraceEq = (os1.str() == os2.str());
+	yulAssert(isTraceEq, "Interpreted traces for optimized and unoptimized code differ.");
+	return 0;
+}
diff --git a/compiler/test/tools/ossfuzz/strictasm_opt_ossfuzz.cpp b/compiler/test/tools/ossfuzz/strictasm_opt_ossfuzz.cpp
new file mode 100644
index 00000000..db35cc86
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/strictasm_opt_ossfuzz.cpp
@@ -0,0 +1,54 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libyul/YulStack.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/EVMVersion.h>
+
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace solidity::yul;
+using namespace std;
+
+// Prototype as we can't use the FuzzerInterface.h header.
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size);
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
+{
+	if (_size > 600)
+		return 0;
+
+	YulStringRepository::reset();
+
+	string input(reinterpret_cast<char const*>(_data), _size);
+	YulStack stack(
+		langutil::EVMVersion(),
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::full(),
+		DebugInfoSelection::All()
+	);
+
+	if (!stack.parseAndAnalyze("source", input))
+		return 0;
+
+	stack.optimize();
+	return 0;
+}
diff --git a/compiler/test/tools/ossfuzz/yulFuzzerCommon.cpp b/compiler/test/tools/ossfuzz/yulFuzzerCommon.cpp
new file mode 100644
index 00000000..57f930cf
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/yulFuzzerCommon.cpp
@@ -0,0 +1,88 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+#include <test/tools/ossfuzz/yulFuzzerCommon.h>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::yul::test::yul_fuzzer;
+
+yulFuzzerUtil::TerminationReason yulFuzzerUtil::interpret(
+	ostream& _os,
+	shared_ptr<yul::Block> _ast,
+	Dialect const& _dialect,
+	bool _disableMemoryTracing,
+	bool _outputStorageOnly,
+	size_t _maxSteps,
+	size_t _maxTraceSize,
+	size_t _maxExprNesting
+)
+{
+	InterpreterState state;
+	state.maxTraceSize = _maxTraceSize;
+	state.maxSteps = _maxSteps;
+	state.maxExprNesting = _maxExprNesting;
+	// Add 64 bytes of pseudo-randomly generated calldata so that
+	// calldata opcodes perform non trivial work.
+	state.calldata = {
+		0xe9, 0x96, 0x40, 0x7d, 0xa5, 0xda, 0xb0, 0x2d,
+		0x97, 0xf5, 0xc3, 0x44, 0xd7, 0x65, 0x0a, 0xd8,
+		0x2c, 0x14, 0x3a, 0xf3, 0xe7, 0x40, 0x0f, 0x1e,
+		0x67, 0xce, 0x90, 0x44, 0x2e, 0x92, 0xdb, 0x88,
+		0xb8, 0x43, 0x9c, 0x41, 0x42, 0x08, 0xf1, 0xd7,
+		0x65, 0xe9, 0x7f, 0xeb, 0x7b, 0xb9, 0x56, 0x9f,
+		0xc7, 0x60, 0x5f, 0x7c, 0xcd, 0xfb, 0x92, 0xcd,
+		0x8e, 0xf3, 0x9b, 0xe4, 0x4f, 0x6c, 0x14, 0xde
+	};
+
+	TerminationReason reason = TerminationReason::None;
+	try
+	{
+		Interpreter::run(state, _dialect, *_ast, true, _disableMemoryTracing);
+	}
+	catch (StepLimitReached const&)
+	{
+		reason = TerminationReason::StepLimitReached;
+	}
+	catch (TraceLimitReached const&)
+	{
+		reason = TerminationReason::TraceLimitReached;
+	}
+	catch (ExpressionNestingLimitReached const&)
+	{
+		reason = TerminationReason::ExpresionNestingLimitReached;
+	}
+	catch (ExplicitlyTerminated const&)
+	{
+		reason = TerminationReason::ExplicitlyTerminated;
+	}
+
+	if (_outputStorageOnly)
+		state.dumpStorage(_os);
+	else
+		state.dumpTraceAndState(_os, _disableMemoryTracing);
+	return reason;
+}
+
+bool yulFuzzerUtil::resourceLimitsExceeded(TerminationReason _reason)
+{
+	return
+		_reason == yulFuzzerUtil::TerminationReason::StepLimitReached ||
+		_reason == yulFuzzerUtil::TerminationReason::TraceLimitReached ||
+		_reason == yulFuzzerUtil::TerminationReason::ExpresionNestingLimitReached;
+}
diff --git a/compiler/test/tools/ossfuzz/yulProto.proto b/compiler/test/tools/ossfuzz/yulProto.proto
new file mode 100644
index 00000000..7552fb23
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/yulProto.proto
@@ -0,0 +1,414 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+syntax = "proto2";
+
+message VarDecl {
+  required Expression expr = 1;
+}
+
+message MultiVarDecl {
+  required uint32 num_vars = 1;
+}
+
+message LowLevelCall {
+  enum Type {
+    CALL = 0;
+    CALLCODE = 1;
+    DELEGATECALL = 2;
+    STATICCALL = 3;
+  }
+  required Type callty = 1;
+  required Expression gas = 2;
+  required Expression addr = 3;
+  // Valid for call and callcode only
+  required Expression wei = 4;
+  required Expression in = 5;
+  required Expression insize = 6;
+  required Expression out = 7;
+  required Expression outsize = 8;
+}
+
+message Create {
+  enum Type {
+    CREATE = 0;
+    CREATE2 = 1;
+  }
+  required Type createty = 1;
+  required Expression wei = 2;
+  required Expression position = 3;
+  required Expression size = 4;
+  // Valid for create2 only
+  required Expression value = 5;
+}
+
+message FunctionCall {
+  required Expression in_param1 = 1;
+  required Expression in_param2 = 2;
+  required Expression in_param3 = 3;
+  required Expression in_param4 = 4;
+}
+
+message TypedVarDecl {
+  enum TypeName {
+    BOOL = 1;
+    U8 = 2;
+    U32 = 3;
+    U64 = 4;
+    U128 = 5;
+    U256 = 6;
+    S8 = 7;
+    S32 = 8;
+    S64 = 9;
+    S128 = 10;
+    S256 = 11;
+  };
+  required int32 id = 1;
+  required TypeName type = 2;
+  required Expression expr = 3;
+}
+
+message VarRef {
+  required int32 varnum = 1;
+}
+
+message Literal {
+  oneof literal_oneof {
+    uint64 intval = 1;
+    string hexval = 2;
+    string strval = 3;
+    bool boolval = 4;
+  }
+}
+
+message TypedLiteral {
+  enum TypeName {
+    BOOL = 1;
+    U8 = 2;
+    U32 = 3;
+    U64 = 4;
+    U128 = 5;
+    U256 = 6;
+    S8 = 7;
+    S32 = 8;
+    S64 = 9;
+    S128 = 10;
+    S256 = 11;
+  };
+  required int32 val = 1;
+  required TypeName type = 2;
+}
+
+message BinaryOp {
+  enum BOp {
+    ADD = 0;
+    SUB = 1;
+    MUL = 2;
+    DIV = 3;
+    MOD = 4;
+    XOR = 5;
+    AND = 6;
+    OR = 7;
+    EQ = 8;
+    LT = 9;
+    GT = 10;
+    SHR = 11;
+    SHL = 12;
+    SAR = 13;
+    SDIV = 14;
+    SMOD = 15;
+    EXP = 16;
+    SLT = 17;
+    SGT = 18;
+    BYTE = 19;
+    SI = 20;
+    KECCAK = 21;
+  };
+  required BOp op = 1;
+  required Expression left = 2;
+  required Expression right = 3;
+}
+
+message UnaryOp {
+  enum UOp {
+    NOT = 0;
+    MLOAD = 1;
+    SLOAD = 2;
+    ISZERO = 3;
+    CALLDATALOAD = 4;
+    EXTCODESIZE = 5;
+    EXTCODEHASH = 6;
+    BALANCE = 7;
+    BLOCKHASH = 8;
+  }
+  required UOp op = 1;
+  required Expression operand = 2;
+}
+
+message UnaryOpData {
+  enum UOpData {
+    SIZE = 1;
+    OFFSET = 2;
+  }
+  required UOpData op = 1;
+  required uint64 identifier = 2;
+}
+
+message TernaryOp {
+  enum TOp {
+    ADDM = 0;
+    MULM = 1;
+  }
+  required TOp op = 1;
+  required Expression arg1 = 2;
+  required Expression arg2 = 3;
+  required Expression arg3 = 4;
+}
+
+message CopyFunc {
+  enum CopyType {
+    CALLDATA = 0;
+    CODE = 1;
+    RETURNDATA = 2;
+    DATA = 3;
+  }
+  required CopyType ct = 1;
+  required Expression target = 2;
+  required Expression source = 3;
+  required Expression size = 4;
+}
+
+message ExtCodeCopy {
+  required Expression addr = 1;
+  required Expression target = 2;
+  required Expression source = 3;
+  required Expression size = 4;
+}
+
+message NullaryOp {
+  enum NOp {
+    MSIZE = 1;
+    GAS = 2;
+    CALLDATASIZE = 3;
+    CODESIZE = 4;
+    RETURNDATASIZE = 5;
+    ADDRESS = 6;
+    ORIGIN = 7;
+    CALLER = 8;
+    CALLVALUE = 9;
+    GASPRICE = 10;
+    COINBASE = 11;
+    TIMESTAMP = 12;
+    NUMBER = 13;
+    DIFFICULTY = 14;
+    GASLIMIT = 15;
+    SELFBALANCE = 16;
+    CHAINID = 17;
+    BASEFEE = 18;
+    BLOBBASEFEE = 19;
+  }
+  required NOp op = 1;
+}
+
+message StoreFunc {
+  enum Storage {
+    MSTORE = 0;
+    SSTORE = 1;
+    MSTORE8 = 2;
+  }
+  required Expression loc = 1;
+  required Expression val = 2;
+  required Storage st = 3;
+}
+
+message LogFunc {
+  enum NumTopics {
+    ZERO = 0;
+    ONE = 1;
+    TWO = 2;
+    THREE = 3;
+    FOUR = 4;
+  }
+  required Expression pos = 1;
+  required Expression size = 2;
+  required NumTopics num_topics = 3;
+  required Expression t1 = 4;
+  required Expression t2 = 5;
+  required Expression t3 = 6;
+  required Expression t4 = 7;
+}
+
+message Expression {
+  oneof expr_oneof {
+    VarRef varref = 1;
+    Literal cons = 2;
+    BinaryOp binop = 3;
+    UnaryOp unop = 4;
+    TernaryOp top = 5;
+    NullaryOp nop = 6;
+    FunctionCall func_expr = 7;
+    LowLevelCall lowcall = 8;
+    Create create = 9;
+    UnaryOpData unopdata = 10;
+  }
+}
+
+message AssignmentStatement {
+  required VarRef ref_id = 1;
+  required Expression expr = 2;
+}
+
+message IfStmt {
+  required Expression cond = 1;
+  required Block if_body = 2;
+}
+
+message BoundedForStmt {
+  required Block for_body = 1;
+}
+
+message ForStmt {
+  required Block for_body = 1;
+  required Block for_init = 2;
+  required Block for_post = 3;
+  required Expression for_cond = 4;
+}
+
+message CaseStmt {
+  required Literal case_lit = 1;
+  required Block case_block = 2;
+}
+
+message SwitchStmt {
+  required Expression switch_expr = 1;
+  repeated CaseStmt case_stmt = 2;
+  optional Block default_block = 3;
+}
+
+message BreakStmt {}
+message ContinueStmt {}
+
+message StopInvalidStmt {
+  enum Type {
+    STOP = 0;
+    INVALID = 1;
+  }
+  required Type stmt = 1;
+}
+
+message RetRevStmt {
+  enum Type {
+    RETURN = 0;
+    REVERT = 1;
+  }
+  required Type stmt = 1;
+  required Expression pos = 2;
+  required Expression size = 3;
+}
+
+message SelfDestructStmt {
+  required Expression addr = 1;
+}
+
+message TerminatingStmt {
+  oneof term_oneof {
+    StopInvalidStmt   stop_invalid = 1;
+    RetRevStmt        ret_rev = 2;
+    SelfDestructStmt  self_des = 3;
+  }
+}
+
+message FunctionDef {
+  required uint32 num_input_params = 1;
+  required uint32 num_output_params = 2;
+  required Block block = 3;
+  required bool force_call = 4;
+}
+
+message PopStmt {
+  required Expression expr = 1;
+}
+
+message LeaveStmt {}
+
+message Statement {
+  oneof stmt_oneof {
+    VarDecl             decl            = 1;
+    AssignmentStatement assignment      = 2;
+    IfStmt              ifstmt          = 3;
+    StoreFunc           storage_func    = 4;
+    Block               blockstmt       = 5;
+    ForStmt             forstmt         = 6;
+    SwitchStmt          switchstmt      = 7;
+    BreakStmt           breakstmt       = 8;
+    ContinueStmt        contstmt        = 9;
+    LogFunc             log_func        = 10;
+    CopyFunc            copy_func       = 11;
+    ExtCodeCopy         extcode_copy    = 12;
+    TerminatingStmt     terminatestmt   = 13;
+    FunctionCall        functioncall    = 14;
+    BoundedForStmt      boundedforstmt  = 15;
+    FunctionDef         funcdef         = 16;
+    PopStmt             pop             = 17;
+    LeaveStmt           leave           = 18;
+    MultiVarDecl        multidecl       = 19;
+  }
+}
+
+message Block {
+  repeated Statement statements = 1;
+}
+
+message Object {
+  required Code code = 1;
+  optional Data data = 2;
+  repeated Object sub_obj = 3;
+}
+
+message Code {
+  required Block block = 1;
+}
+
+message Data {
+  required string hex = 1;
+}
+
+message Program {
+  enum Version {
+    HOMESTEAD = 0;
+    TANGERINE = 1;
+    SPURIOUS = 2;
+    BYZANTIUM = 3;
+    CONSTANTINOPLE = 4;
+    PETERSBURG = 5;
+    ISTANBUL = 6;
+    BERLIN = 7;
+    LONDON = 8;
+    PARIS = 9;
+    SHANGHAI = 10;
+    CANCUN = 11;
+  }
+  oneof program_oneof {
+    Block block = 1;
+    Object obj = 2;
+  }
+  required Version ver = 3;
+  required uint32 step = 4;
+}
+
+package solidity.yul.test.yul_fuzzer;
diff --git a/compiler/test/tools/ossfuzz/yulProtoFuzzer.cpp b/compiler/test/tools/ossfuzz/yulProtoFuzzer.cpp
new file mode 100644
index 00000000..c2ac6809
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/yulProtoFuzzer.cpp
@@ -0,0 +1,90 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <fstream>
+
+#include <test/tools/ossfuzz/yulProto.pb.h>
+#include <test/tools/ossfuzz/protoToYul.h>
+
+#include <test/tools/fuzzer_common.h>
+
+#include <test/libyul/YulOptimizerTestCommon.h>
+
+#include <libyul/YulStack.h>
+#include <libyul/Exceptions.h>
+
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/EVMVersion.h>
+
+#include <src/libfuzzer/libfuzzer_macro.h>
+
+using namespace solidity;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::yul::test::yul_fuzzer;
+using namespace std;
+
+DEFINE_PROTO_FUZZER(Program const& _input)
+{
+	ProtoConverter converter;
+	string yul_source = converter.programToString(_input);
+	EVMVersion version = converter.version();
+
+	if (const char* dump_path = getenv("PROTO_FUZZER_DUMP_PATH"))
+	{
+		// With libFuzzer binary run this to generate a YUL source file x.yul:
+		// PROTO_FUZZER_DUMP_PATH=x.yul ./a.out proto-input
+		ofstream of(dump_path);
+		of.write(yul_source.data(), static_cast<streamsize>(yul_source.size()));
+	}
+
+	if (yul_source.size() > 1200)
+		return;
+
+	YulStringRepository::reset();
+
+	// YulStack entry point
+	YulStack stack(
+		version,
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::full(),
+		DebugInfoSelection::All()
+	);
+
+	// Parse protobuf mutated YUL code
+	if (
+		!stack.parseAndAnalyze("source", yul_source) ||
+		!stack.parserResult()->code ||
+		!stack.parserResult()->analysisInfo ||
+		Error::containsErrors(stack.errors())
+	)
+		yulAssert(false, "Proto fuzzer generated malformed program");
+
+	// Optimize
+	YulOptimizerTestCommon optimizerTest(
+		stack.parserResult(),
+		EVMDialect::strictAssemblyForEVMObjects(version)
+	);
+	optimizerTest.setStep(optimizerTest.randomOptimiserStep(_input.step()));
+	shared_ptr<solidity::yul::Block> astBlock = optimizerTest.run();
+	yulAssert(astBlock != nullptr, "Optimiser error.");
+}
diff --git a/compiler/test/tools/ossfuzz/yulProto_diff_ossfuzz.cpp b/compiler/test/tools/ossfuzz/yulProto_diff_ossfuzz.cpp
new file mode 100644
index 00000000..d1717a15
--- /dev/null
+++ b/compiler/test/tools/ossfuzz/yulProto_diff_ossfuzz.cpp
@@ -0,0 +1,124 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <fstream>
+
+#include <test/tools/ossfuzz/yulProto.pb.h>
+#include <test/tools/fuzzer_common.h>
+#include <test/tools/ossfuzz/protoToYul.h>
+
+#include <test/libyul/YulOptimizerTestCommon.h>
+
+#include <src/libfuzzer/libfuzzer_macro.h>
+
+#include <libyul/YulStack.h>
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/Exceptions.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/EVMVersion.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <test/tools/ossfuzz/yulFuzzerCommon.h>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+using namespace solidity::yul::test::yul_fuzzer;
+
+DEFINE_PROTO_FUZZER(Program const& _input)
+{
+	ProtoConverter converter;
+	string yul_source = converter.programToString(_input);
+	EVMVersion version = converter.version();
+
+	if (const char* dump_path = getenv("PROTO_FUZZER_DUMP_PATH"))
+	{
+		// With libFuzzer binary run this to generate a YUL source file x.yul:
+		// PROTO_FUZZER_DUMP_PATH=x.yul ./a.out proto-input
+		ofstream of(dump_path);
+		of.write(yul_source.data(), static_cast<streamsize>(yul_source.size()));
+	}
+
+	YulStringRepository::reset();
+
+	// YulStack entry point
+	YulStack stack(
+		version,
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::full(),
+		DebugInfoSelection::All()
+	);
+
+	// Parse protobuf mutated YUL code
+	if (
+		!stack.parseAndAnalyze("source", yul_source) ||
+		!stack.parserResult()->code ||
+		!stack.parserResult()->analysisInfo ||
+		Error::containsErrors(stack.errors())
+	)
+	{
+		SourceReferenceFormatter{std::cout, stack, false, false}.printErrorInformation(stack.errors());
+		yulAssert(false, "Proto fuzzer generated malformed program");
+	}
+
+	ostringstream os1;
+	ostringstream os2;
+	// Disable memory tracing to avoid false positive reports
+	// such as unused write to memory e.g.,
+	// { mstore(0, 1) }
+	// that would be removed by the redundant store eliminator.
+	yulFuzzerUtil::TerminationReason termReason = yulFuzzerUtil::interpret(
+		os1,
+		stack.parserResult()->code,
+		EVMDialect::strictAssemblyForEVMObjects(version),
+		/*disableMemoryTracing=*/true
+	);
+
+	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
+		return;
+
+	YulOptimizerTestCommon optimizerTest(
+		stack.parserResult(),
+		EVMDialect::strictAssemblyForEVMObjects(version)
+	);
+	optimizerTest.setStep(optimizerTest.randomOptimiserStep(_input.step()));
+	shared_ptr<solidity::yul::Block> astBlock = optimizerTest.run();
+	yulAssert(astBlock != nullptr, "Optimiser error.");
+	termReason = yulFuzzerUtil::interpret(
+		os2,
+		astBlock,
+		EVMDialect::strictAssemblyForEVMObjects(version),
+		true
+	);
+	if (yulFuzzerUtil::resourceLimitsExceeded(termReason))
+		return;
+
+	bool isTraceEq = (os1.str() == os2.str());
+	if (!isTraceEq)
+	{
+		cout << os1.str() << endl;
+		cout << os2.str() << endl;
+		yulAssert(false, "Interpreted traces for optimized and unoptimized code differ.");
+	}
+	return;
+}
diff --git a/compiler/test/tools/yulInterpreter/CMakeLists.txt b/compiler/test/tools/yulInterpreter/CMakeLists.txt
new file mode 100644
index 00000000..235e8fac
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(sources
+	EVMInstructionInterpreter.h
+	EVMInstructionInterpreter.cpp
+	Interpreter.h
+	Interpreter.cpp
+	Inspector.h
+	Inspector.cpp
+)
+
+add_library(yulInterpreter ${sources})
+target_link_libraries(yulInterpreter PUBLIC yul solidity solutil)
diff --git a/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.cpp b/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.cpp
new file mode 100644
index 00000000..2fe2b218
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.cpp
@@ -0,0 +1,703 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter module that evaluates EVM instructions.
+ */
+
+#include <test/tools/yulInterpreter/EVMInstructionInterpreter.h>
+
+#include <test/tools/yulInterpreter/Interpreter.h>
+
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/AST.h>
+
+#include <libevmasm/Instruction.h>
+#include <libevmasm/SemanticInformation.h>
+
+#include <libsolutil/Keccak256.h>
+#include <libsolutil/Numeric.h>
+#include <libsolutil/picosha2.h>
+
+#include <limits>
+
+using namespace solidity;
+using namespace solidity::evmasm;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+using solidity::util::h160;
+using solidity::util::h256;
+using solidity::util::keccak256;
+
+namespace
+{
+
+/// Reads 32 bytes from @a _data at position @a _offset bytes while
+/// interpreting @a _data to be padded with an infinite number of zero
+/// bytes beyond its end.
+u256 readZeroExtended(bytes const& _data, u256 const& _offset)
+{
+	if (_offset >= _data.size())
+		return 0;
+	else if (_offset + 32 <= _data.size())
+		return *reinterpret_cast<h256 const*>(_data.data() + static_cast<size_t>(_offset));
+	else
+	{
+		size_t off = static_cast<size_t>(_offset);
+		u256 val;
+		for (size_t i = 0; i < 32; ++i)
+		{
+			val <<= 8;
+			if (off + i < _data.size())
+				val += _data[off + i];
+		}
+		return val;
+	}
+}
+
+}
+
+namespace solidity::yul::test
+{
+
+void copyZeroExtended(
+	std::map<u256, uint8_t>& _target,
+	bytes const& _source,
+	size_t _targetOffset,
+	size_t _sourceOffset,
+	size_t _size
+)
+{
+	for (size_t i = 0; i < _size; ++i)
+		_target[_targetOffset + i] = (_sourceOffset + i < _source.size() ? _source[_sourceOffset + i] : 0);
+}
+
+void copyZeroExtendedWithOverlap(
+	std::map<u256, uint8_t>& _target,
+	std::map<u256, uint8_t> const& _source,
+	size_t _targetOffset,
+	size_t _sourceOffset,
+	size_t _size
+)
+{
+	if (_targetOffset >= _sourceOffset)
+		for (size_t i = _size; i > 0; --i)
+			_target[_targetOffset + i - 1] = (_source.count(_sourceOffset + i - 1) != 0 ? _source.at(_sourceOffset + i - 1) : 0);
+	else
+		for (size_t i = 0; i < _size; ++i)
+			_target[_targetOffset + i] = (_source.count(_sourceOffset + i) != 0 ? _source.at(_sourceOffset + i) : 0);
+}
+
+}
+
+using u512 = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512, 256, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>;
+
+u256 EVMInstructionInterpreter::eval(
+	evmasm::Instruction _instruction,
+	std::vector<u256> const& _arguments
+)
+{
+	using namespace solidity::evmasm;
+	using evmasm::Instruction;
+
+	auto info = instructionInfo(_instruction, m_evmVersion);
+	yulAssert(static_cast<size_t>(info.args) == _arguments.size(), "");
+
+	auto const& arg = _arguments;
+	switch (_instruction)
+	{
+	case Instruction::STOP:
+		logTrace(_instruction);
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminated());
+	// --------------- arithmetic ---------------
+	case Instruction::ADD:
+		return arg[0] + arg[1];
+	case Instruction::MUL:
+		return arg[0] * arg[1];
+	case Instruction::SUB:
+		return arg[0] - arg[1];
+	case Instruction::DIV:
+		return arg[1] == 0 ? 0 : arg[0] / arg[1];
+	case Instruction::SDIV:
+		return arg[1] == 0 ? 0 : s2u(u2s(arg[0]) / u2s(arg[1]));
+	case Instruction::MOD:
+		return arg[1] == 0 ? 0 : arg[0] % arg[1];
+	case Instruction::SMOD:
+		return arg[1] == 0 ? 0 : s2u(u2s(arg[0]) % u2s(arg[1]));
+	case Instruction::EXP:
+		return exp256(arg[0], arg[1]);
+	case Instruction::NOT:
+		return ~arg[0];
+	case Instruction::LT:
+		return arg[0] < arg[1] ? 1 : 0;
+	case Instruction::GT:
+		return arg[0] > arg[1] ? 1 : 0;
+	case Instruction::SLT:
+		return u2s(arg[0]) < u2s(arg[1]) ? 1 : 0;
+	case Instruction::SGT:
+		return u2s(arg[0]) > u2s(arg[1]) ? 1 : 0;
+	case Instruction::EQ:
+		return arg[0] == arg[1] ? 1 : 0;
+	case Instruction::ISZERO:
+		return arg[0] == 0 ? 1 : 0;
+	case Instruction::AND:
+		return arg[0] & arg[1];
+	case Instruction::OR:
+		return arg[0] | arg[1];
+	case Instruction::XOR:
+		return arg[0] ^ arg[1];
+	case Instruction::BYTE:
+		return arg[0] >= 32 ? 0 : (arg[1] >> unsigned(8 * (31 - arg[0]))) & 0xff;
+	case Instruction::SHL:
+		return arg[0] > 255 ? 0 : (arg[1] << unsigned(arg[0]));
+	case Instruction::SHR:
+		return arg[0] > 255 ? 0 : (arg[1] >> unsigned(arg[0]));
+	case Instruction::SAR:
+	{
+		static u256 const hibit = u256(1) << 255;
+		if (arg[0] >= 256)
+			return arg[1] & hibit ? u256(-1) : 0;
+		else
+		{
+			unsigned amount = unsigned(arg[0]);
+			u256 v = arg[1] >> amount;
+			if (arg[1] & hibit)
+				v |= u256(-1) << (256 - amount);
+			return v;
+		}
+	}
+	case Instruction::ADDMOD:
+		return arg[2] == 0 ? 0 : u256((u512(arg[0]) + u512(arg[1])) % arg[2]);
+	case Instruction::MULMOD:
+		return arg[2] == 0 ? 0 : u256((u512(arg[0]) * u512(arg[1])) % arg[2]);
+	case Instruction::SIGNEXTEND:
+		if (arg[0] >= 31)
+			return arg[1];
+		else
+		{
+			unsigned testBit = unsigned(arg[0]) * 8 + 7;
+			u256 ret = arg[1];
+			u256 mask = ((u256(1) << testBit) - 1);
+			if (boost::multiprecision::bit_test(ret, testBit))
+				ret |= ~mask;
+			else
+				ret &= mask;
+			return ret;
+		}
+	// --------------- blockchain stuff ---------------
+	case Instruction::KECCAK256:
+	{
+		if (!accessMemory(arg[0], arg[1]))
+			return u256("0x1234cafe1234cafe1234cafe") + arg[0];
+		uint64_t offset = uint64_t(arg[0] & uint64_t(-1));
+		uint64_t size = uint64_t(arg[1] & uint64_t(-1));
+		return u256(keccak256(m_state.readMemory(offset, size)));
+	}
+	case Instruction::ADDRESS:
+		return h256(m_state.address, h256::AlignRight);
+	case Instruction::BALANCE:
+		if (arg[0] == h256(m_state.address, h256::AlignRight))
+			return m_state.selfbalance;
+		else
+			return m_state.balance;
+	case Instruction::SELFBALANCE:
+		return m_state.selfbalance;
+	case Instruction::ORIGIN:
+		return h256(m_state.origin, h256::AlignRight);
+	case Instruction::CALLER:
+		return h256(m_state.caller, h256::AlignRight);
+	case Instruction::CALLVALUE:
+		return m_state.callvalue;
+	case Instruction::CALLDATALOAD:
+		return readZeroExtended(m_state.calldata, arg[0]);
+	case Instruction::CALLDATASIZE:
+		return m_state.calldata.size();
+	case Instruction::CALLDATACOPY:
+		if (accessMemory(arg[0], arg[2]))
+			copyZeroExtended(
+				m_state.memory, m_state.calldata,
+				size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
+			);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::CODESIZE:
+		return m_state.code.size();
+	case Instruction::CODECOPY:
+		if (accessMemory(arg[0], arg[2]))
+			copyZeroExtended(
+				m_state.memory, m_state.code,
+				size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
+			);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::GASPRICE:
+		return m_state.gasprice;
+	case Instruction::CHAINID:
+		return m_state.chainid;
+	case Instruction::BASEFEE:
+		return m_state.basefee;
+	case Instruction::BLOBHASH:
+		return blobHash(arg[0]);
+	case Instruction::BLOBBASEFEE:
+		return m_state.blobbasefee;
+	case Instruction::EXTCODESIZE:
+		return u256(keccak256(h256(arg[0]))) & 0xffffff;
+	case Instruction::EXTCODEHASH:
+		return u256(keccak256(h256(arg[0] + 1)));
+	case Instruction::EXTCODECOPY:
+		if (accessMemory(arg[1], arg[3]))
+			// TODO this way extcodecopy and codecopy do the same thing.
+			copyZeroExtended(
+				m_state.memory, m_state.code,
+				size_t(arg[1]), size_t(arg[2]), size_t(arg[3])
+			);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::RETURNDATASIZE:
+		return m_state.returndata.size();
+	case Instruction::RETURNDATACOPY:
+		if (accessMemory(arg[0], arg[2]))
+			copyZeroExtended(
+				m_state.memory, m_state.returndata,
+				size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
+			);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::MCOPY:
+		if (accessMemory(arg[1], arg[2]) && accessMemory(arg[0], arg[2]))
+			copyZeroExtendedWithOverlap(
+				m_state.memory,
+				m_state.memory,
+				static_cast<size_t>(arg[0]),
+				static_cast<size_t>(arg[1]),
+				static_cast<size_t>(arg[2])
+			);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::BLOCKHASH:
+		if (arg[0] >= m_state.blockNumber || arg[0] + 256 < m_state.blockNumber)
+			return 0;
+		else
+			return 0xaaaaaaaa + (arg[0] - m_state.blockNumber - 256);
+	case Instruction::COINBASE:
+		return h256(m_state.coinbase, h256::AlignRight);
+	case Instruction::TIMESTAMP:
+		return m_state.timestamp;
+	case Instruction::NUMBER:
+		return m_state.blockNumber;
+	case Instruction::PREVRANDAO:
+		return (m_evmVersion < langutil::EVMVersion::paris()) ? m_state.difficulty : m_state.prevrandao;
+	case Instruction::GASLIMIT:
+		return m_state.gaslimit;
+	// --------------- memory / storage / logs ---------------
+	case Instruction::MLOAD:
+		accessMemory(arg[0], 0x20);
+		return readMemoryWord(arg[0]);
+	case Instruction::MSTORE:
+		accessMemory(arg[0], 0x20);
+		writeMemoryWord(arg[0], arg[1]);
+		return 0;
+	case Instruction::MSTORE8:
+		accessMemory(arg[0], 1);
+		m_state.memory[arg[0]] = uint8_t(arg[1] & 0xff);
+		return 0;
+	case Instruction::SLOAD:
+		return m_state.storage[h256(arg[0])];
+	case Instruction::SSTORE:
+		m_state.storage[h256(arg[0])] = h256(arg[1]);
+		return 0;
+	case Instruction::PC:
+		return 0x77;
+	case Instruction::MSIZE:
+		return m_state.msize;
+	case Instruction::GAS:
+		return 0x99;
+	case Instruction::LOG0:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::LOG1:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::LOG2:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::LOG3:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::LOG4:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		return 0;
+	case Instruction::TLOAD:
+		return m_state.transientStorage[h256(arg[0])];
+	case Instruction::TSTORE:
+		m_state.transientStorage[h256(arg[0])] = h256(arg[1]);
+		return 0;
+	// --------------- calls ---------------
+	case Instruction::CREATE:
+		accessMemory(arg[1], arg[2]);
+		logTrace(_instruction, arg);
+		if (arg[2] != 0)
+			return (0xcccccc + arg[1]) & u256("0xffffffffffffffffffffffffffffffffffffffff");
+		else
+			return 0xcccccc;
+	case Instruction::CREATE2:
+		accessMemory(arg[1], arg[2]);
+		logTrace(_instruction, arg);
+		if (arg[2] != 0)
+			return (0xdddddd + arg[1]) & u256("0xffffffffffffffffffffffffffffffffffffffff");
+		else
+			return 0xdddddd;
+	case Instruction::CALL:
+	case Instruction::CALLCODE:
+		accessMemory(arg[3], arg[4]);
+		accessMemory(arg[5], arg[6]);
+		logTrace(_instruction, arg);
+		// Randomly fail based on the called address if it isn't a call to self.
+		// Used for fuzzing.
+		return (
+			(arg[0] > 0) &&
+			(arg[1] == util::h160::Arith(m_state.address) || (arg[1] & 1))
+		) ? 1 : 0;
+	case Instruction::DELEGATECALL:
+	case Instruction::STATICCALL:
+		accessMemory(arg[2], arg[3]);
+		accessMemory(arg[4], arg[5]);
+		logTrace(_instruction, arg);
+		// Randomly fail based on the called address if it isn't a call to self.
+		// Used for fuzzing.
+		return (
+			(arg[0] > 0) &&
+			(arg[1] == util::h160::Arith(m_state.address) || (arg[1] & 1))
+		) ? 1 : 0;
+	case Instruction::RETURN:
+	{
+		m_state.returndata = {};
+		if (accessMemory(arg[0], arg[1]))
+			m_state.returndata = m_state.readMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg, m_state.returndata);
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminatedWithReturn());
+	}
+	case Instruction::REVERT:
+		accessMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg);
+		m_state.storage.clear();
+		m_state.transientStorage.clear();
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminated());
+	case Instruction::INVALID:
+		logTrace(_instruction);
+		m_state.storage.clear();
+		m_state.transientStorage.clear();
+		m_state.trace.clear();
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminated());
+	case Instruction::SELFDESTRUCT:
+		logTrace(_instruction, arg);
+		m_state.storage.clear();
+		m_state.transientStorage.clear();
+		m_state.trace.clear();
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminated());
+	case Instruction::POP:
+		break;
+	// --------------- invalid in strict assembly ---------------
+	case Instruction::JUMP:
+	case Instruction::JUMPI:
+	case Instruction::JUMPDEST:
+	case Instruction::PUSH0:
+	case Instruction::PUSH1:
+	case Instruction::PUSH2:
+	case Instruction::PUSH3:
+	case Instruction::PUSH4:
+	case Instruction::PUSH5:
+	case Instruction::PUSH6:
+	case Instruction::PUSH7:
+	case Instruction::PUSH8:
+	case Instruction::PUSH9:
+	case Instruction::PUSH10:
+	case Instruction::PUSH11:
+	case Instruction::PUSH12:
+	case Instruction::PUSH13:
+	case Instruction::PUSH14:
+	case Instruction::PUSH15:
+	case Instruction::PUSH16:
+	case Instruction::PUSH17:
+	case Instruction::PUSH18:
+	case Instruction::PUSH19:
+	case Instruction::PUSH20:
+	case Instruction::PUSH21:
+	case Instruction::PUSH22:
+	case Instruction::PUSH23:
+	case Instruction::PUSH24:
+	case Instruction::PUSH25:
+	case Instruction::PUSH26:
+	case Instruction::PUSH27:
+	case Instruction::PUSH28:
+	case Instruction::PUSH29:
+	case Instruction::PUSH30:
+	case Instruction::PUSH31:
+	case Instruction::PUSH32:
+	case Instruction::DUP1:
+	case Instruction::DUP2:
+	case Instruction::DUP3:
+	case Instruction::DUP4:
+	case Instruction::DUP5:
+	case Instruction::DUP6:
+	case Instruction::DUP7:
+	case Instruction::DUP8:
+	case Instruction::DUP9:
+	case Instruction::DUP10:
+	case Instruction::DUP11:
+	case Instruction::DUP12:
+	case Instruction::DUP13:
+	case Instruction::DUP14:
+	case Instruction::DUP15:
+	case Instruction::DUP16:
+	case Instruction::SWAP1:
+	case Instruction::SWAP2:
+	case Instruction::SWAP3:
+	case Instruction::SWAP4:
+	case Instruction::SWAP5:
+	case Instruction::SWAP6:
+	case Instruction::SWAP7:
+	case Instruction::SWAP8:
+	case Instruction::SWAP9:
+	case Instruction::SWAP10:
+	case Instruction::SWAP11:
+	case Instruction::SWAP12:
+	case Instruction::SWAP13:
+	case Instruction::SWAP14:
+	case Instruction::SWAP15:
+	case Instruction::SWAP16:
+	{
+		yulAssert(false, "");
+		return 0;
+	}
+	}
+
+	return 0;
+}
+
+u256 EVMInstructionInterpreter::evalBuiltin(
+	BuiltinFunctionForEVM const& _fun,
+	std::vector<Expression> const& _arguments,
+	std::vector<u256> const& _evaluatedArguments
+)
+{
+	if (_fun.instruction)
+		return eval(*_fun.instruction, _evaluatedArguments);
+
+	std::string fun = _fun.name.str();
+	// Evaluate datasize/offset/copy instructions
+	if (fun == "datasize" || fun == "dataoffset")
+	{
+		std::string arg = std::get<Literal>(_arguments.at(0)).value.str();
+		if (arg.length() < 32)
+			arg.resize(32, 0);
+		if (fun == "datasize")
+			return u256(keccak256(arg)) & 0xfff;
+		else
+		{
+			// Force different value than for datasize
+			arg[31]++;
+			arg[31]++;
+			return u256(keccak256(arg)) & 0xfff;
+		}
+	}
+	else if (fun == "datacopy")
+	{
+		// This is identical to codecopy.
+		if (
+			_evaluatedArguments.at(2) != 0 &&
+			accessMemory(_evaluatedArguments.at(0), _evaluatedArguments.at(2))
+		)
+			copyZeroExtended(
+				m_state.memory,
+				m_state.code,
+				size_t(_evaluatedArguments.at(0)),
+				size_t(_evaluatedArguments.at(1) & std::numeric_limits<size_t>::max()),
+				size_t(_evaluatedArguments.at(2))
+			);
+		return 0;
+	}
+	else if (fun == "memoryguard")
+		return _evaluatedArguments.at(0);
+	else
+		yulAssert(false, "Unknown builtin: " + fun);
+	return 0;
+}
+
+
+bool EVMInstructionInterpreter::accessMemory(u256 const& _offset, u256 const& _size)
+{
+	if (_size == 0)
+		return true;
+
+	if (_offset <= (_offset + _size) && (_offset + _size) <= (_offset + _size + 0x1f))
+	{
+		u256 newMSize = (_offset + _size + 0x1f) & ~u256(0x1f);
+		m_state.msize = std::max(m_state.msize, newMSize);
+		// We only record accesses to contiguous memory chunks that are at most s_maxRangeSize bytes
+		// in size and at an offset of at most numeric_limits<size_t>::max() - s_maxRangeSize
+		return _size <= s_maxRangeSize && _offset <= u256(std::numeric_limits<size_t>::max() - s_maxRangeSize);
+	}
+
+	m_state.msize = u256(-1);
+	return false;
+}
+
+bytes EVMInstructionInterpreter::readMemory(u256 const& _offset, u256 const& _size)
+{
+	yulAssert(_size <= s_maxRangeSize, "Too large read.");
+	bytes data(size_t(_size), uint8_t(0));
+	for (size_t i = 0; i < data.size(); ++i)
+		data[i] = m_state.memory[_offset + i];
+	return data;
+}
+
+u256 EVMInstructionInterpreter::readMemoryWord(u256 const& _offset)
+{
+	return u256(h256(m_state.readMemory(_offset, 32)));
+}
+
+void EVMInstructionInterpreter::writeMemoryWord(u256 const& _offset, u256 const& _value)
+{
+	for (size_t i = 0; i < 32; i++)
+		m_state.memory[_offset + i] = uint8_t((_value >> (8 * (31 - i))) & 0xff);
+}
+
+
+void EVMInstructionInterpreter::logTrace(
+	evmasm::Instruction _instruction,
+	std::vector<u256> const& _arguments,
+	bytes const& _data
+)
+{
+	logTrace(
+		evmasm::instructionInfo(_instruction, m_evmVersion).name,
+		SemanticInformation::memory(_instruction) == SemanticInformation::Effect::Write,
+		_arguments,
+		_data
+	);
+}
+
+void EVMInstructionInterpreter::logTrace(
+	std::string const& _pseudoInstruction,
+	bool _writesToMemory,
+	std::vector<u256> const& _arguments,
+	bytes const& _data
+)
+{
+	if (!(_writesToMemory && memWriteTracingDisabled()))
+	{
+		std::string message = _pseudoInstruction + "(";
+		std::pair<bool, size_t> inputMemoryPtrModified = isInputMemoryPtrModified(_pseudoInstruction, _arguments);
+		for (size_t i = 0; i < _arguments.size(); ++i)
+		{
+			bool printZero = inputMemoryPtrModified.first && inputMemoryPtrModified.second == i;
+			u256 arg = printZero ? 0 : _arguments[i];
+			message += (i > 0 ? ", " : "") + formatNumber(arg);
+		}
+		message += ")";
+		if (!_data.empty())
+			message += " [" + util::toHex(_data) + "]";
+		m_state.trace.emplace_back(std::move(message));
+		if (m_state.maxTraceSize > 0 && m_state.trace.size() >= m_state.maxTraceSize)
+		{
+			m_state.trace.emplace_back("Trace size limit reached.");
+			BOOST_THROW_EXCEPTION(TraceLimitReached());
+		}
+	}
+}
+
+std::pair<bool, size_t> EVMInstructionInterpreter::isInputMemoryPtrModified(
+	std::string const& _pseudoInstruction,
+	std::vector<u256> const& _arguments
+)
+{
+	if (_pseudoInstruction == "RETURN" || _pseudoInstruction == "REVERT")
+	{
+		if (_arguments[1] == 0)
+			return {true, 0};
+		else
+			return {false, 0};
+	}
+	else if (
+		_pseudoInstruction == "RETURNDATACOPY" || _pseudoInstruction == "CALLDATACOPY"
+		|| _pseudoInstruction == "CODECOPY")
+	{
+		if (_arguments[2] == 0)
+			return {true, 0};
+		else
+			return {false, 0};
+	}
+	else if (_pseudoInstruction == "EXTCODECOPY")
+	{
+		if (_arguments[3] == 0)
+			return {true, 1};
+		else
+			return {false, 0};
+	}
+	else if (
+		_pseudoInstruction == "LOG0" || _pseudoInstruction == "LOG1" || _pseudoInstruction == "LOG2"
+		|| _pseudoInstruction == "LOG3" || _pseudoInstruction == "LOG4")
+	{
+		if (_arguments[1] == 0)
+			return {true, 0};
+		else
+			return {false, 0};
+	}
+	if (_pseudoInstruction == "CREATE" || _pseudoInstruction == "CREATE2")
+	{
+		if (_arguments[2] == 0)
+			return {true, 1};
+		else
+			return {false, 0};
+	}
+	if (_pseudoInstruction == "CALL" || _pseudoInstruction == "CALLCODE")
+	{
+		if (_arguments[4] == 0)
+			return {true, 3};
+		else
+			return {false, 0};
+	}
+	else if (_pseudoInstruction == "DELEGATECALL" || _pseudoInstruction == "STATICCALL")
+	{
+		if (_arguments[3] == 0)
+			return {true, 2};
+		else
+			return {false, 0};
+	}
+	else
+		return {false, 0};
+}
+
+h256 EVMInstructionInterpreter::blobHash(u256 const& _index)
+{
+	yulAssert(m_evmVersion.hasBlobHash());
+	if (_index >= m_state.blobCommitments.size())
+		return util::FixedHash<32>{};
+
+	h256 hashedCommitment = h256(picosha2::hash256(toBigEndian(m_state.blobCommitments[static_cast<size_t>(_index)])));
+	yulAssert(m_state.blobHashVersion.size == 1);
+	hashedCommitment[0] = *m_state.blobHashVersion.data();
+	yulAssert(hashedCommitment.size == 32);
+	return hashedCommitment;
+}
diff --git a/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.h b/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.h
new file mode 100644
index 00000000..d3d22111
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/EVMInstructionInterpreter.h
@@ -0,0 +1,176 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter module that evaluates EVM instructions.
+ */
+
+#pragma once
+
+#include <libyul/ASTForward.h>
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/Numeric.h>
+
+#include <liblangutil/EVMVersion.h>
+
+#include <vector>
+
+namespace solidity::evmasm
+{
+enum class Instruction: uint8_t;
+}
+
+namespace solidity::yul
+{
+class YulString;
+struct BuiltinFunctionForEVM;
+}
+
+namespace solidity::yul::test
+{
+
+/// Copy @a _size bytes of @a _source at offset @a _sourceOffset to
+/// @a _target at offset @a _targetOffset. Behaves as if @a _source would
+/// continue with an infinite sequence of zero bytes beyond its end.
+void copyZeroExtended(
+	std::map<u256, uint8_t>& _target,
+	bytes const& _source,
+	size_t _targetOffset,
+	size_t _sourceOffset,
+	size_t _size
+);
+
+/// Copy @a _size bytes of @a _source at offset @a _sourceOffset to
+/// @a _target at offset @a _targetOffset. Behaves as if @a _source would
+/// continue with an infinite sequence of zero bytes beyond its end.
+/// When target and source areas overlap, behaves as if the data was copied
+/// using an intermediate buffer.
+void copyZeroExtendedWithOverlap(
+	std::map<u256, uint8_t>& _target,
+	std::map<u256, uint8_t> const& _source,
+	size_t _targetOffset,
+	size_t _sourceOffset,
+	size_t _size
+);
+
+struct InterpreterState;
+
+/**
+ * Interprets EVM instructions based on the current state and logs instructions with
+ * side-effects.
+ *
+ * Since this is mainly meant to be used for differential fuzz testing, it is focused
+ * on a single contract only, does not do any gas counting and differs from the correct
+ * implementation in many ways:
+ *
+ * - If memory access to a "large" memory position is performed, a deterministic
+ *   value is returned. Data that is stored in a "large" memory position is not
+ *   retained.
+ * - The blockhash instruction returns a fixed value if the argument is in range.
+ * - Extcodesize returns a deterministic value depending on the address.
+ * - Extcodecopy copies a deterministic value depending on the address.
+ * - And many other things
+ *
+ * The main focus is that the generated execution trace is the same for equivalent executions
+ * and likely to be different for non-equivalent executions.
+ */
+class EVMInstructionInterpreter
+{
+public:
+	explicit EVMInstructionInterpreter(langutil::EVMVersion _evmVersion, InterpreterState& _state, bool _disableMemWriteTrace):
+		m_evmVersion(_evmVersion),
+		m_state(_state),
+		m_disableMemoryWriteInstructions(_disableMemWriteTrace)
+	{}
+	/// Evaluate instruction
+	u256 eval(evmasm::Instruction _instruction, std::vector<u256> const& _arguments);
+	/// Evaluate builtin function
+	u256 evalBuiltin(
+		BuiltinFunctionForEVM const& _fun,
+		std::vector<Expression> const& _arguments,
+		std::vector<u256> const& _evaluatedArguments
+	);
+
+	/// @returns the blob versioned hash
+	util::h256 blobHash(u256 const& _index);
+
+private:
+	/// Checks if the memory access is valid and adjusts msize accordingly.
+	/// @returns true if memory access is valid, false otherwise
+	/// A valid memory access must satisfy all of the following pre-requisites:
+	/// - Sum of @param _offset and @param _size do not overflow modulo u256
+	/// - Sum of @param _offset, @param _size, and 31 do not overflow modulo u256 (see note below)
+	/// - @param _size is lesser than or equal to @a s_maxRangeSize
+	/// - @param _offset is lesser than or equal to the difference of numeric_limits<size_t>::max()
+	/// and @a s_maxRangeSize
+	/// Note: Memory expansion is carried out in multiples of 32 bytes.
+	bool accessMemory(u256 const& _offset, u256 const& _size = 32);
+	/// @returns the memory contents at the provided address.
+	/// Does not adjust msize, use @a accessMemory for that
+	bytes readMemory(u256 const& _offset, u256 const& _size = 32);
+	/// @returns the memory contents at the provided address.
+	/// Does not adjust msize, use @a accessMemory for that
+	u256 readMemoryWord(u256 const& _offset);
+	/// @returns writes a word to memory
+	/// Does not adjust msize, use @a accessMemory for that
+	void writeMemoryWord(u256 const& _offset, u256 const& _value);
+
+	void logTrace(
+		evmasm::Instruction _instruction,
+		std::vector<u256> const& _arguments = {},
+		bytes const& _data = {}
+	);
+	/// Appends a log to the trace representing an instruction or similar operation by string,
+	/// with arguments and auxiliary data (if nonempty). Flag @param _writesToMemory indicates
+	/// whether the instruction writes to (true) or does not write to (false) memory.
+	void logTrace(
+		std::string const& _pseudoInstruction,
+		bool _writesToMemory,
+		std::vector<u256> const& _arguments = {},
+		bytes const& _data = {}
+	);
+
+	/// @returns a pair of boolean and size_t whose first value is true if @param _pseudoInstruction
+	/// is a Yul instruction that the Yul optimizer's loadResolver step rewrites the input
+	/// memory pointer value to zero if that instruction's read length (contained within @param
+	// _arguments) is zero, and whose second value is the positional index of the input memory
+	// pointer argument.
+	/// If the Yul instruction is unaffected or affected but read length is non-zero, the first
+	/// value is false.
+	std::pair<bool, size_t> isInputMemoryPtrModified(
+		std::string const& _pseudoInstruction,
+		std::vector<u256> const& _arguments
+	);
+
+	/// @returns disable trace flag.
+	bool memWriteTracingDisabled()
+	{
+		return m_disableMemoryWriteInstructions;
+	}
+
+	langutil::EVMVersion m_evmVersion;
+	InterpreterState& m_state;
+	/// Flag to disable trace of instructions that write to memory.
+	bool m_disableMemoryWriteInstructions;
+public:
+	/// Maximum length for range-based memory access operations.
+	static constexpr unsigned s_maxRangeSize = 0xffff;
+};
+
+} // solidity::yul::test
diff --git a/compiler/test/tools/yulInterpreter/Inspector.cpp b/compiler/test/tools/yulInterpreter/Inspector.cpp
new file mode 100644
index 00000000..9c4701d0
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/Inspector.cpp
@@ -0,0 +1,154 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter.
+ */
+
+#include <test/tools/yulInterpreter/Inspector.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string.hpp>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+namespace
+{
+
+void printVariable(YulString const& _name, u256 const& _value)
+{
+	std::cout << "\t" << _name.str() << " = " << _value.str();
+
+	if (_value != 0)
+		std::cout << " (" << toCompactHexWithPrefix(_value) << ")";
+
+	std::cout << std::endl;
+}
+
+}
+
+void InspectedInterpreter::run(
+	std::shared_ptr<Inspector> _inspector,
+	InterpreterState& _state,
+	Dialect const& _dialect,
+	Block const& _ast,
+	bool _disableExternalCalls,
+	bool _disableMemoryTrace
+)
+{
+	Scope scope;
+	InspectedInterpreter{_inspector, _state, _dialect, scope, _disableExternalCalls, _disableMemoryTrace}(_ast);
+}
+
+Inspector::NodeAction Inspector::queryUser(DebugData const& _data, std::map<YulString, u256> const& _variables)
+{
+	if (m_stepMode == NodeAction::RunNode)
+	{
+		// Output instructions that are being skipped/run
+		std::cout << "Running " << currentSource(_data) << std::endl;
+
+		return NodeAction::StepThroughNode;
+	}
+
+	std::string input;
+
+	while (true)
+	{
+		// Output sourcecode about to run.
+		std::cout << "> " << currentSource(_data) << std::endl;
+
+		// Ask user for action
+		std::cout << std::endl
+			<< "(s)tep/(n)ext/(i)nspect/(p)rint/all (v)ariables?"
+			<< std::endl
+			<< "# ";
+
+		std::cout.flush();
+
+		std::getline(std::cin, input);
+		boost::algorithm::trim(input);
+
+		// Imitate GDB and repeat last cmd for empty string input.
+		if (input == "")
+			input = m_lastInput;
+		else
+			m_lastInput = input;
+
+		if (input == "next" || input == "n")
+			return NodeAction::RunNode;
+		else if (input == "step" || input == "s")
+			return NodeAction::StepThroughNode;
+		else if (input == "inspect" || input == "i")
+			m_state.dumpTraceAndState(std::cout, false);
+		else if (input == "variables" || input == "v")
+		{
+			for (auto &&[yulStr, val]: _variables)
+				printVariable(yulStr, val);
+			std::cout << std::endl;
+		}
+		else if (
+			boost::starts_with(input, "print") ||
+			boost::starts_with(input, "p")
+		)
+		{
+			size_t whitespacePos = input.find(' ');
+
+			if (whitespacePos == std::string::npos)
+				std::cout << "Error parsing command! Expected variable name." << std::endl;
+
+			std::string const varname = input.substr(whitespacePos + 1);
+
+			std::vector<std::string> candidates;
+
+			bool found = false;
+			for (auto &&[yulStr, val]: _variables)
+				if (yulStr.str() == varname)
+				{
+					printVariable(yulStr, val);
+					found = true;
+					break;
+				}
+
+			if (!found)
+				std::cout << varname << " not found." << std::endl;
+		}
+	}
+}
+
+std::string Inspector::currentSource(DebugData const& _data) const
+{
+	return m_source.substr(
+		static_cast<size_t>(_data.nativeLocation.start),
+		static_cast<size_t>(_data.nativeLocation.end - _data.nativeLocation.start)
+	);
+}
+
+u256 InspectedInterpreter::evaluate(Expression const& _expression)
+{
+	InspectedExpressionEvaluator ev(m_inspector, m_state, m_dialect, *m_scope, m_variables, m_disableExternalCalls, m_disableMemoryTrace);
+	ev.visit(_expression);
+	return ev.value();
+}
+
+std::vector<u256> InspectedInterpreter::evaluateMulti(Expression const& _expression)
+{
+	InspectedExpressionEvaluator ev(m_inspector, m_state, m_dialect, *m_scope, m_variables, m_disableExternalCalls, m_disableMemoryTrace);
+	ev.visit(_expression);
+	return ev.values();
+}
diff --git a/compiler/test/tools/yulInterpreter/Inspector.h b/compiler/test/tools/yulInterpreter/Inspector.h
new file mode 100644
index 00000000..611279c6
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/Inspector.h
@@ -0,0 +1,213 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul inspector.
+ */
+
+#include <test/tools/yulInterpreter/Interpreter.h>
+
+#include <libyul/AST.h>
+
+#include <string>
+
+#pragma once
+
+namespace solidity::yul::test
+{
+
+/**
+ * Inspector class to respond to queries by the user for:
+ *
+ * * Stepping through and over instructions.
+ * * Printing a specific or all variables.
+ * * Inspecting memory, storage and calldata memory.
+ */
+class Inspector
+{
+public:
+	enum class NodeAction
+	{
+		RunNode,
+		StepThroughNode,
+	};
+
+	Inspector(std::string const& _source, InterpreterState const& _state)
+		:m_source(_source), m_state(_state) {}
+
+	/* Asks the user what action to take.
+	 * @returns NodeAction::RunNode if the current AST node (and all children nodes!) should be
+	 *          processed without stopping, else NodeAction::StepThroughNode.
+	 */
+	NodeAction queryUser(DebugData const& _data, std::map<YulString, u256> const& _variables);
+
+	void stepMode(NodeAction _action) { m_stepMode = _action; }
+
+	std::string const& source() const { return m_source; }
+
+	void interactiveVisit(DebugData const& _debugData, std::map<YulString, u256> const& _variables, std::function<void()> _visitNode)
+	{
+		Inspector::NodeAction action = queryUser(_debugData, _variables);
+
+		if (action == NodeAction::RunNode)
+		{
+			// user requested to run the whole node without stopping
+			stepMode(Inspector::NodeAction::RunNode);
+
+			_visitNode();
+
+			// Reset step mode back
+			stepMode(Inspector::NodeAction::StepThroughNode);
+		}
+		else
+			_visitNode();
+	}
+
+private:
+	std::string currentSource(DebugData const& _data) const;
+
+	/// Source of the file
+	std::string const& m_source;
+
+	/// State of the interpreter
+	InterpreterState const& m_state;
+
+	/// Last user query command
+	std::string m_lastInput;
+
+	/// Used to run AST nodes without user interaction
+	NodeAction m_stepMode = NodeAction::StepThroughNode;
+};
+
+/**
+ * Yul Interpreter with inspection. Allows the user to go through the code step
+ * by step and inspect the state using the `Inspector` class
+ */
+class InspectedInterpreter: public Interpreter
+{
+public:
+	static void run(
+		std::shared_ptr<Inspector> _inspector,
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Block const& _ast,
+		bool _disableExternalCalls,
+		bool _disableMemoryTracing
+	);
+
+	InspectedInterpreter(
+		std::shared_ptr<Inspector> _inspector,
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Scope& _scope,
+		bool _disableExternalCalls,
+		bool _disableMemoryTracing,
+		std::map<YulString, u256> _variables = {}
+	):
+		Interpreter(_state, _dialect, _scope, _disableExternalCalls, _disableMemoryTracing, _variables),
+		m_inspector(_inspector)
+	{
+	}
+
+	void operator()(ExpressionStatement const& _node) override { helper(_node); }
+	void operator()(Assignment const& _node) override { helper(_node); }
+	void operator()(VariableDeclaration const& _node) override { helper(_node); }
+	void operator()(If const& _node) override { helper(_node); }
+	void operator()(Switch const& _node) override { helper(_node); }
+	void operator()(ForLoop const& _node) override { helper(_node); }
+	void operator()(Break const& _node) override { helper(_node); }
+	void operator()(Continue const& _node) override { helper(_node); }
+	void operator()(Leave const& _node) override { helper(_node); }
+	void operator()(Block const& _node) override { helper(_node); }
+protected:
+	/// Asserts that the expression evaluates to exactly one value and returns it.
+	u256 evaluate(Expression const& _expression) override;
+	/// Evaluates the expression and returns its value.
+	std::vector<u256> evaluateMulti(Expression const& _expression) override;
+private:
+	std::shared_ptr<Inspector> m_inspector;
+
+	template <typename ConcreteNode>
+	void helper(ConcreteNode const& _node)
+	{
+		m_inspector->interactiveVisit(*_node.debugData, m_variables, [&]() {
+			Interpreter::operator()(_node);
+		});
+	}
+
+};
+
+
+class InspectedExpressionEvaluator: public ExpressionEvaluator
+{
+public:
+	InspectedExpressionEvaluator(
+		std::shared_ptr<Inspector> _inspector,
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Scope& _scope,
+		std::map<YulString, u256> const& _variables,
+		bool _disableExternalCalls,
+		bool _disableMemoryTrace
+	):
+		ExpressionEvaluator(_state, _dialect, _scope, _variables, _disableExternalCalls, _disableMemoryTrace),
+		m_inspector(_inspector)
+	{}
+
+	template <typename ConcreteNode>
+	void helper(ConcreteNode const& _node)
+	{
+		m_inspector->interactiveVisit(*_node.debugData, m_variables, [&]() {
+			ExpressionEvaluator::operator()(_node);
+		});
+	}
+
+	void operator()(Literal const& _node) override { helper(_node); }
+	void operator()(Identifier const& _node) override { helper(_node); }
+	void operator()(FunctionCall const& _node) override { helper(_node); }
+protected:
+	std::unique_ptr<Interpreter> makeInterpreterCopy(std::map<YulString, u256> _variables = {}) const override
+	{
+		return std::make_unique<InspectedInterpreter>(
+			m_inspector,
+			m_state,
+			m_dialect,
+			m_scope,
+			m_disableExternalCalls,
+			m_disableMemoryTrace,
+			std::move(_variables)
+		);
+	}
+	std::unique_ptr<Interpreter> makeInterpreterNew(InterpreterState& _state, Scope& _scope) const override
+	{
+		return std::make_unique<InspectedInterpreter>(
+			std::make_unique<Inspector>(
+				m_inspector->source(),
+				_state
+			),
+			_state,
+			m_dialect,
+			_scope,
+			m_disableExternalCalls,
+			m_disableMemoryTrace
+		);
+	}
+private:
+	std::shared_ptr<Inspector> m_inspector;
+};
+
+}
diff --git a/compiler/test/tools/yulInterpreter/Interpreter.cpp b/compiler/test/tools/yulInterpreter/Interpreter.cpp
new file mode 100644
index 00000000..a8658e92
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/Interpreter.cpp
@@ -0,0 +1,506 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter.
+ */
+
+#include <test/tools/yulInterpreter/Interpreter.h>
+
+#include <test/tools/yulInterpreter/EVMInstructionInterpreter.h>
+
+#include <libyul/AST.h>
+#include <libyul/Dialect.h>
+#include <libyul/Utilities.h>
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <liblangutil/Exceptions.h>
+
+#include <libsolutil/FixedHash.h>
+
+#include <range/v3/view/reverse.hpp>
+
+#include <ostream>
+#include <variant>
+
+using namespace solidity;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+using solidity::util::h256;
+
+void InterpreterState::dumpStorage(std::ostream& _out) const
+{
+	for (auto const& [slot, value]: storage)
+		if (value != h256{})
+			_out << "  " << slot.hex() << ": " << value.hex() << std::endl;
+}
+
+void InterpreterState::dumpTransientStorage(std::ostream& _out) const
+{
+	for (auto const& [slot, value]: transientStorage)
+		if (value != h256{})
+			_out << "  " << slot.hex() << ": " << value.hex() << std::endl;
+}
+
+void InterpreterState::dumpTraceAndState(std::ostream& _out, bool _disableMemoryTrace) const
+{
+	_out << "Trace:" << std::endl;
+	for (auto const& line: trace)
+		_out << "  " << line << std::endl;
+	if (!_disableMemoryTrace)
+	{
+		_out << "Memory dump:\n";
+		std::map<u256, u256> words;
+		for (auto const& [offset, value]: memory)
+			words[(offset / 0x20) * 0x20] |= u256(uint32_t(value)) << (256 - 8 - 8 * static_cast<size_t>(offset % 0x20));
+		for (auto const& [offset, value]: words)
+			if (value != 0)
+				_out << "  " << std::uppercase << std::hex << std::setw(4) << offset << ": " << h256(value).hex() << std::endl;
+	}
+	_out << "Storage dump:" << std::endl;
+	dumpStorage(_out);
+
+	_out << "Transient storage dump:" << std::endl;
+	dumpTransientStorage(_out);
+
+	if (!calldata.empty())
+	{
+		_out << "Calldata dump:";
+
+		for (size_t offset = 0; offset < calldata.size(); ++offset)
+			if (calldata[offset] != 0)
+			{
+				if (offset % 32 == 0)
+					_out <<
+						std::endl <<
+						"  " <<
+						std::uppercase <<
+						std::hex <<
+						std::setfill(' ') <<
+						std::setw(4) <<
+						offset <<
+						": ";
+
+				_out <<
+					std::hex <<
+					std::setw(2) <<
+					std::setfill('0') <<
+					static_cast<int>(calldata[offset]);
+			}
+
+		_out << std::endl;
+	}
+}
+
+void Interpreter::run(
+	InterpreterState& _state,
+	Dialect const& _dialect,
+	Block const& _ast,
+	bool _disableExternalCalls,
+	bool _disableMemoryTrace
+)
+{
+	Scope scope;
+	Interpreter{_state, _dialect, scope, _disableExternalCalls, _disableMemoryTrace}(_ast);
+}
+
+void Interpreter::operator()(ExpressionStatement const& _expressionStatement)
+{
+	evaluateMulti(_expressionStatement.expression);
+}
+
+void Interpreter::operator()(Assignment const& _assignment)
+{
+	solAssert(_assignment.value, "");
+	std::vector<u256> values = evaluateMulti(*_assignment.value);
+	solAssert(values.size() == _assignment.variableNames.size(), "");
+	for (size_t i = 0; i < values.size(); ++i)
+	{
+		YulString varName = _assignment.variableNames.at(i).name;
+		solAssert(m_variables.count(varName), "");
+		m_variables[varName] = values.at(i);
+	}
+}
+
+void Interpreter::operator()(VariableDeclaration const& _declaration)
+{
+	std::vector<u256> values(_declaration.variables.size(), 0);
+	if (_declaration.value)
+		values = evaluateMulti(*_declaration.value);
+
+	solAssert(values.size() == _declaration.variables.size(), "");
+	for (size_t i = 0; i < values.size(); ++i)
+	{
+		YulString varName = _declaration.variables.at(i).name;
+		solAssert(!m_variables.count(varName), "");
+		m_variables[varName] = values.at(i);
+		m_scope->names.emplace(varName, nullptr);
+	}
+}
+
+void Interpreter::operator()(If const& _if)
+{
+	solAssert(_if.condition, "");
+	if (evaluate(*_if.condition) != 0)
+		(*this)(_if.body);
+}
+
+void Interpreter::operator()(Switch const& _switch)
+{
+	solAssert(_switch.expression, "");
+	u256 val = evaluate(*_switch.expression);
+	solAssert(!_switch.cases.empty(), "");
+	for (auto const& c: _switch.cases)
+		// Default case has to be last.
+		if (!c.value || evaluate(*c.value) == val)
+		{
+			(*this)(c.body);
+			break;
+		}
+}
+
+void Interpreter::operator()(FunctionDefinition const&)
+{
+}
+
+void Interpreter::operator()(ForLoop const& _forLoop)
+{
+	solAssert(_forLoop.condition, "");
+
+	enterScope(_forLoop.pre);
+	ScopeGuard g([this]{ leaveScope(); });
+
+	for (auto const& statement: _forLoop.pre.statements)
+	{
+		visit(statement);
+		if (m_state.controlFlowState == ControlFlowState::Leave)
+			return;
+	}
+	while (evaluate(*_forLoop.condition) != 0)
+	{
+		// Increment step for each loop iteration for loops with
+		// an empty body and post blocks to prevent a deadlock.
+		if (_forLoop.body.statements.size() == 0 && _forLoop.post.statements.size() == 0)
+			incrementStep();
+
+		m_state.controlFlowState = ControlFlowState::Default;
+		(*this)(_forLoop.body);
+		if (m_state.controlFlowState == ControlFlowState::Break || m_state.controlFlowState == ControlFlowState::Leave)
+			break;
+
+		m_state.controlFlowState = ControlFlowState::Default;
+		(*this)(_forLoop.post);
+		if (m_state.controlFlowState == ControlFlowState::Leave)
+			break;
+	}
+	if (m_state.controlFlowState != ControlFlowState::Leave)
+		m_state.controlFlowState = ControlFlowState::Default;
+}
+
+void Interpreter::operator()(Break const&)
+{
+	m_state.controlFlowState = ControlFlowState::Break;
+}
+
+void Interpreter::operator()(Continue const&)
+{
+	m_state.controlFlowState = ControlFlowState::Continue;
+}
+
+void Interpreter::operator()(Leave const&)
+{
+	m_state.controlFlowState = ControlFlowState::Leave;
+}
+
+void Interpreter::operator()(Block const& _block)
+{
+	enterScope(_block);
+	// Register functions.
+	for (auto const& statement: _block.statements)
+		if (std::holds_alternative<FunctionDefinition>(statement))
+		{
+			FunctionDefinition const& funDef = std::get<FunctionDefinition>(statement);
+			m_scope->names.emplace(funDef.name, &funDef);
+		}
+
+	for (auto const& statement: _block.statements)
+	{
+		incrementStep();
+		visit(statement);
+		if (m_state.controlFlowState != ControlFlowState::Default)
+			break;
+	}
+
+	leaveScope();
+}
+
+u256 Interpreter::evaluate(Expression const& _expression)
+{
+	ExpressionEvaluator ev(m_state, m_dialect, *m_scope, m_variables, m_disableExternalCalls, m_disableMemoryTrace);
+	ev.visit(_expression);
+	return ev.value();
+}
+
+std::vector<u256> Interpreter::evaluateMulti(Expression const& _expression)
+{
+	ExpressionEvaluator ev(m_state, m_dialect, *m_scope, m_variables, m_disableExternalCalls, m_disableMemoryTrace);
+	ev.visit(_expression);
+	return ev.values();
+}
+
+void Interpreter::enterScope(Block const& _block)
+{
+	if (!m_scope->subScopes.count(&_block))
+		m_scope->subScopes[&_block] = std::make_unique<Scope>(Scope{
+			{},
+			{},
+			m_scope
+		});
+	m_scope = m_scope->subScopes[&_block].get();
+}
+
+void Interpreter::leaveScope()
+{
+	for (auto const& [var, funDeclaration]: m_scope->names)
+		if (!funDeclaration)
+			m_variables.erase(var);
+	m_scope = m_scope->parent;
+	yulAssert(m_scope, "");
+}
+
+void Interpreter::incrementStep()
+{
+	m_state.numSteps++;
+	if (m_state.maxSteps > 0 && m_state.numSteps >= m_state.maxSteps)
+	{
+		m_state.trace.emplace_back("Interpreter execution step limit reached.");
+		BOOST_THROW_EXCEPTION(StepLimitReached());
+	}
+}
+
+void ExpressionEvaluator::operator()(Literal const& _literal)
+{
+	incrementStep();
+	static YulString const trueString("true");
+	static YulString const falseString("false");
+
+	setValue(valueOfLiteral(_literal));
+}
+
+void ExpressionEvaluator::operator()(Identifier const& _identifier)
+{
+	solAssert(m_variables.count(_identifier.name), "");
+	incrementStep();
+	setValue(m_variables.at(_identifier.name));
+}
+
+void ExpressionEvaluator::operator()(FunctionCall const& _funCall)
+{
+	std::vector<std::optional<LiteralKind>> const* literalArguments = nullptr;
+	if (BuiltinFunction const* builtin = m_dialect.builtin(_funCall.functionName.name))
+		if (!builtin->literalArguments.empty())
+			literalArguments = &builtin->literalArguments;
+	evaluateArgs(_funCall.arguments, literalArguments);
+
+	if (EVMDialect const* dialect = dynamic_cast<EVMDialect const*>(&m_dialect))
+	{
+		if (BuiltinFunctionForEVM const* fun = dialect->builtin(_funCall.functionName.name))
+		{
+			EVMInstructionInterpreter interpreter(dialect->evmVersion(), m_state, m_disableMemoryTrace);
+
+			u256 const value = interpreter.evalBuiltin(*fun, _funCall.arguments, values());
+
+			if (
+				!m_disableExternalCalls &&
+				fun->instruction &&
+				evmasm::isCallInstruction(*fun->instruction)
+			)
+				runExternalCall(*fun->instruction);
+
+			setValue(value);
+			return;
+		}
+	}
+
+	Scope* scope = &m_scope;
+	for (; scope; scope = scope->parent)
+		if (scope->names.count(_funCall.functionName.name))
+			break;
+	yulAssert(scope, "");
+
+	FunctionDefinition const* fun = scope->names.at(_funCall.functionName.name);
+	yulAssert(fun, "Function not found.");
+	yulAssert(m_values.size() == fun->parameters.size(), "");
+	std::map<YulString, u256> variables;
+	for (size_t i = 0; i < fun->parameters.size(); ++i)
+		variables[fun->parameters.at(i).name] = m_values.at(i);
+	for (size_t i = 0; i < fun->returnVariables.size(); ++i)
+		variables[fun->returnVariables.at(i).name] = 0;
+
+	m_state.controlFlowState = ControlFlowState::Default;
+	std::unique_ptr<Interpreter> interpreter = makeInterpreterCopy(std::move(variables));
+	(*interpreter)(fun->body);
+	m_state.controlFlowState = ControlFlowState::Default;
+
+	m_values.clear();
+	for (auto const& retVar: fun->returnVariables)
+		m_values.emplace_back(interpreter->valueOfVariable(retVar.name));
+}
+
+u256 ExpressionEvaluator::value() const
+{
+	solAssert(m_values.size() == 1, "");
+	return m_values.front();
+}
+
+void ExpressionEvaluator::setValue(u256 _value)
+{
+	m_values.clear();
+	m_values.emplace_back(std::move(_value));
+}
+
+void ExpressionEvaluator::evaluateArgs(
+	std::vector<Expression> const& _expr,
+	std::vector<std::optional<LiteralKind>> const* _literalArguments
+)
+{
+	incrementStep();
+	std::vector<u256> values;
+	size_t i = 0;
+	/// Function arguments are evaluated in reverse.
+	for (auto const& expr: _expr | ranges::views::reverse)
+	{
+		if (!_literalArguments || !_literalArguments->at(_expr.size() - i - 1))
+			visit(expr);
+		else
+		{
+			std::string literal = std::get<Literal>(expr).value.str();
+
+			try
+			{
+				m_values = {u256(literal)};
+			}
+			catch (std::exception&)
+			{
+				m_values = {u256(0)};
+			}
+		}
+
+		values.push_back(value());
+		++i;
+	}
+	m_values = std::move(values);
+	std::reverse(m_values.begin(), m_values.end());
+}
+
+void ExpressionEvaluator::incrementStep()
+{
+	m_nestingLevel++;
+	if (m_state.maxExprNesting > 0 && m_nestingLevel > m_state.maxExprNesting)
+	{
+		m_state.trace.emplace_back("Maximum expression nesting level reached.");
+		BOOST_THROW_EXCEPTION(ExpressionNestingLimitReached());
+	}
+}
+
+void ExpressionEvaluator::runExternalCall(evmasm::Instruction _instruction)
+{
+	u256 memOutOffset = 0;
+	u256 memOutSize = 0;
+	u256 callvalue = 0;
+	u256 memInOffset = 0;
+	u256 memInSize = 0;
+
+	// Setup memOut* values
+	if (
+		_instruction == evmasm::Instruction::CALL ||
+		_instruction == evmasm::Instruction::CALLCODE
+	)
+	{
+		memOutOffset = values()[5];
+		memOutSize = values()[6];
+		callvalue = values()[2];
+		memInOffset = values()[3];
+		memInSize = values()[4];
+	}
+	else if (
+		_instruction == evmasm::Instruction::DELEGATECALL ||
+		_instruction == evmasm::Instruction::STATICCALL
+	)
+	{
+		memOutOffset = values()[4];
+		memOutSize = values()[5];
+		memInOffset = values()[2];
+		memInSize = values()[3];
+	}
+	else
+		yulAssert(false);
+
+	// Don't execute external call if it isn't our own address
+	if (values()[1] != util::h160::Arith(m_state.address))
+		return;
+
+	Scope tmpScope;
+	InterpreterState tmpState;
+	tmpState.calldata = m_state.readMemory(memInOffset, memInSize);
+	tmpState.callvalue = callvalue;
+	tmpState.numInstance = m_state.numInstance + 1;
+
+	yulAssert(tmpState.numInstance < 1024, "Detected more than 1024 recursive calls, aborting...");
+
+	// Create new interpreter for the called contract
+	std::unique_ptr<Interpreter> newInterpreter = makeInterpreterNew(tmpState, tmpScope);
+
+	Scope* abstractRootScope = &m_scope;
+	Scope* fileScope = nullptr;
+	Block const* ast = nullptr;
+
+	// Find file scope
+	while (abstractRootScope->parent)
+	{
+		fileScope = abstractRootScope;
+		abstractRootScope = abstractRootScope->parent;
+	}
+
+	// Get AST for file scope
+	for (auto&& [block, scope]: abstractRootScope->subScopes)
+		if (scope.get() == fileScope)
+		{
+			ast = block;
+			break;
+		}
+
+	yulAssert(ast);
+
+	try
+	{
+		(*newInterpreter)(*ast);
+	}
+	catch (ExplicitlyTerminatedWithReturn const&)
+	{
+		// Copy return data to our memory
+		copyZeroExtended(
+			m_state.memory,
+			newInterpreter->returnData(),
+			memOutOffset.convert_to<size_t>(),
+			0,
+			memOutSize.convert_to<size_t>()
+		);
+		m_state.returndata = newInterpreter->returnData();
+	}
+}
diff --git a/compiler/test/tools/yulInterpreter/Interpreter.h b/compiler/test/tools/yulInterpreter/Interpreter.h
new file mode 100644
index 00000000..23a98ca5
--- /dev/null
+++ b/compiler/test/tools/yulInterpreter/Interpreter.h
@@ -0,0 +1,312 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter.
+ */
+
+#pragma once
+
+#include <libyul/ASTForward.h>
+#include <libyul/optimiser/ASTWalker.h>
+
+#include <libevmasm/Instruction.h>
+
+#include <libsolutil/FixedHash.h>
+#include <libsolutil/CommonData.h>
+
+#include <libsolutil/Exceptions.h>
+
+#include <map>
+
+namespace solidity::yul
+{
+struct Dialect;
+}
+
+namespace solidity::yul::test
+{
+
+class InterpreterTerminatedGeneric: public util::Exception
+{
+};
+
+class ExplicitlyTerminated: public InterpreterTerminatedGeneric
+{
+};
+
+class ExplicitlyTerminatedWithReturn: public ExplicitlyTerminated
+{
+};
+
+class StepLimitReached: public InterpreterTerminatedGeneric
+{
+};
+
+class TraceLimitReached: public InterpreterTerminatedGeneric
+{
+};
+
+class ExpressionNestingLimitReached: public InterpreterTerminatedGeneric
+{
+};
+
+enum class ControlFlowState
+{
+	Default,
+	Continue,
+	Break,
+	Leave
+};
+
+struct InterpreterState
+{
+	bytes calldata;
+	bytes returndata;
+	std::map<u256, uint8_t> memory;
+	/// This is different than memory.size() because we ignore gas.
+	u256 msize;
+	std::map<util::h256, util::h256> storage;
+	std::map<util::h256, util::h256> transientStorage;
+	util::h160 address = util::h160("0x0000000000000000000000000000000011111111");
+	u256 balance = 0x22222222;
+	u256 selfbalance = 0x22223333;
+	util::h160 origin = util::h160("0x0000000000000000000000000000000033333333");
+	util::h160 caller = util::h160("0x0000000000000000000000000000000044444444");
+	u256 callvalue = 0x55555555;
+	/// Deployed code
+	bytes code = util::asBytes("codecodecodecodecode");
+	u256 gasprice = 0x66666666;
+	util::h160 coinbase = util::h160("0x0000000000000000000000000000000077777777");
+	u256 timestamp = 0x88888888;
+	u256 blockNumber = 1024;
+	u256 difficulty = 0x9999999;
+	u256 prevrandao = (u256(1) << 64) + 1;
+	u256 gaslimit = 4000000;
+	u256 chainid = 0x01;
+	/// The minimum value of basefee: 7 wei.
+	u256 basefee = 0x07;
+	/// The minimum value of blobbasefee: 1 wei.
+	u256 blobbasefee = 0x01;
+	/// Log of changes / effects. Sholud be structured data in the future.
+	std::vector<std::string> trace;
+	/// This is actually an input parameter that more or less limits the runtime.
+	size_t maxTraceSize = 0;
+	size_t maxSteps = 0;
+	size_t numSteps = 0;
+	size_t maxExprNesting = 0;
+	ControlFlowState controlFlowState = ControlFlowState::Default;
+
+	/// Number of the current state instance, used for recursion protection
+	size_t numInstance = 0;
+
+	// Blob commitment hash version
+	util::FixedHash<1> const blobHashVersion = util::FixedHash<1>(1);
+	// Blob commitments
+	std::array<u256, 2> const blobCommitments = {0x01, 0x02};
+
+	/// Prints execution trace and non-zero storage to @param _out.
+	/// Flag @param _disableMemoryTrace, if set, does not produce a memory dump. This
+	/// avoids false positives reports by the fuzzer when certain optimizer steps are
+	/// activated e.g., Redundant store eliminator, Equal store eliminator.
+	void dumpTraceAndState(std::ostream& _out, bool _disableMemoryTrace) const;
+	/// Prints non-zero storage to @param _out.
+	void dumpStorage(std::ostream& _out) const;
+	/// Prints non-zero transient storage to @param _out.
+	void dumpTransientStorage(std::ostream& _out) const;
+
+	bytes readMemory(u256 const& _offset, u256 const& _size)
+	{
+		yulAssert(_size <= 0xffff, "Too large read.");
+		bytes data(size_t(_size), uint8_t(0));
+		for (size_t i = 0; i < data.size(); ++i)
+			data[i] = memory[_offset + i];
+		return data;
+	}
+};
+
+/**
+ * Scope structure built and maintained during execution.
+ */
+struct Scope
+{
+	/// Used for variables and functions. Value is nullptr for variables.
+	std::map<YulString, FunctionDefinition const*> names;
+	std::map<Block const*, std::unique_ptr<Scope>> subScopes;
+	Scope* parent = nullptr;
+};
+
+/**
+ * Yul interpreter.
+ */
+class Interpreter: public ASTWalker
+{
+public:
+	/// Executes the Yul interpreter. Flag @param _disableMemoryTracing if set ensures that
+	/// instructions that write to memory do not affect @param _state. This
+	/// avoids false positives reports by the fuzzer when certain optimizer steps are
+	/// activated e.g., Redundant store eliminator, Equal store eliminator.
+	static void run(
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Block const& _ast,
+		bool _disableExternalCalls,
+		bool _disableMemoryTracing
+	);
+
+	Interpreter(
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Scope& _scope,
+		bool _disableExternalCalls,
+		bool _disableMemoryTracing,
+		std::map<YulString, u256> _variables = {}
+	):
+		m_dialect(_dialect),
+		m_state(_state),
+		m_variables(std::move(_variables)),
+		m_scope(&_scope),
+		m_disableExternalCalls(_disableExternalCalls),
+		m_disableMemoryTrace(_disableMemoryTracing)
+	{
+	}
+
+	void operator()(ExpressionStatement const& _statement) override;
+	void operator()(Assignment const& _assignment) override;
+	void operator()(VariableDeclaration const& _varDecl) override;
+	void operator()(If const& _if) override;
+	void operator()(Switch const& _switch) override;
+	void operator()(FunctionDefinition const&) override;
+	void operator()(ForLoop const&) override;
+	void operator()(Break const&) override;
+	void operator()(Continue const&) override;
+	void operator()(Leave const&) override;
+	void operator()(Block const& _block) override;
+
+	bytes returnData() const { return m_state.returndata; }
+	std::vector<std::string> const& trace() const { return m_state.trace; }
+
+	u256 valueOfVariable(YulString _name) const { return m_variables.at(_name); }
+
+protected:
+	/// Asserts that the expression evaluates to exactly one value and returns it.
+	virtual u256 evaluate(Expression const& _expression);
+	/// Evaluates the expression and returns its value.
+	virtual std::vector<u256> evaluateMulti(Expression const& _expression);
+
+	void enterScope(Block const& _block);
+	void leaveScope();
+
+	/// Increment interpreter step count, throwing exception if step limit
+	/// is reached.
+	void incrementStep();
+
+	Dialect const& m_dialect;
+	InterpreterState& m_state;
+	/// Values of variables.
+	std::map<YulString, u256> m_variables;
+	Scope* m_scope;
+	/// If not set, external calls (e.g. using `call()`) to the same contract
+	/// are evaluated in a new parser instance.
+	bool m_disableExternalCalls;
+	bool m_disableMemoryTrace;
+};
+
+/**
+ * Yul expression evaluator.
+ */
+class ExpressionEvaluator: public ASTWalker
+{
+public:
+	ExpressionEvaluator(
+		InterpreterState& _state,
+		Dialect const& _dialect,
+		Scope& _scope,
+		std::map<YulString, u256> const& _variables,
+		bool _disableExternalCalls,
+		bool _disableMemoryTrace
+	):
+		m_state(_state),
+		m_dialect(_dialect),
+		m_variables(_variables),
+		m_scope(_scope),
+		m_disableExternalCalls(_disableExternalCalls),
+		m_disableMemoryTrace(_disableMemoryTrace)
+	{}
+
+	void operator()(Literal const&) override;
+	void operator()(Identifier const&) override;
+	void operator()(FunctionCall const& _funCall) override;
+
+	/// Asserts that the expression has exactly one value and returns it.
+	u256 value() const;
+	/// Returns the list of values of the expression.
+	std::vector<u256> values() const { return m_values; }
+
+protected:
+	void runExternalCall(evmasm::Instruction _instruction);
+	virtual std::unique_ptr<Interpreter> makeInterpreterCopy(std::map<YulString, u256> _variables = {}) const
+	{
+		return std::make_unique<Interpreter>(
+			m_state,
+			m_dialect,
+			m_scope,
+			m_disableExternalCalls,
+			m_disableMemoryTrace,
+			std::move(_variables)
+		);
+	}
+	virtual std::unique_ptr<Interpreter> makeInterpreterNew(InterpreterState& _state, Scope& _scope) const
+	{
+		return std::make_unique<Interpreter>(
+			_state,
+			m_dialect,
+			_scope,
+			m_disableExternalCalls,
+			m_disableMemoryTrace
+		);
+	}
+
+	void setValue(u256 _value);
+
+	/// Evaluates the given expression from right to left and
+	/// stores it in m_value.
+	void evaluateArgs(
+		std::vector<Expression> const& _expr,
+		std::vector<std::optional<LiteralKind>> const* _literalArguments
+	);
+
+	/// Increment evaluation count, throwing exception if the
+	/// nesting level is beyond the upper bound configured in
+	/// the interpreter state.
+	void incrementStep();
+
+	InterpreterState& m_state;
+	Dialect const& m_dialect;
+	/// Values of variables.
+	std::map<YulString, u256> const& m_variables;
+	Scope& m_scope;
+	/// Current value of the expression
+	std::vector<u256> m_values;
+	/// Current expression nesting level
+	unsigned m_nestingLevel = 0;
+	bool m_disableExternalCalls;
+	/// Flag to disable memory tracing
+	bool m_disableMemoryTrace;
+};
+
+}
diff --git a/compiler/test/tools/yulopti.cpp b/compiler/test/tools/yulopti.cpp
new file mode 100644
index 00000000..20491afe
--- /dev/null
+++ b/compiler/test/tools/yulopti.cpp
@@ -0,0 +1,371 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Interactive yul optimizer
+ */
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/Exceptions.h>
+#include <libsolutil/StringUtils.h>
+#include <liblangutil/ErrorReporter.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/AsmAnalysisInfo.h>
+#include <libsolidity/parsing/Parser.h>
+#include <libyul/AST.h>
+#include <libyul/AsmParser.h>
+#include <libyul/AsmPrinter.h>
+#include <libyul/Object.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libyul/optimiser/Disambiguator.h>
+#include <libyul/optimiser/OptimiserStep.h>
+#include <libyul/optimiser/StackCompressor.h>
+#include <libyul/optimiser/VarNameCleaner.h>
+#include <libyul/optimiser/Suite.h>
+
+#include <libyul/backends/evm/EVMDialect.h>
+
+#include <libsolutil/JSON.h>
+
+#include <libsolidity/interface/OptimiserSettings.h>
+#include <liblangutil/CharStreamProvider.h>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/program_options.hpp>
+
+#include <range/v3/action/sort.hpp>
+#include <range/v3/range/conversion.hpp>
+#include <range/v3/view/concat.hpp>
+#include <range/v3/view/drop.hpp>
+#include <range/v3/view/map.hpp>
+#include <range/v3/view/set_algorithm.hpp>
+#include <range/v3/view/stride.hpp>
+#include <range/v3/view/transform.hpp>
+
+#include <cctype>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <variant>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::frontend;
+using namespace solidity::yul;
+
+namespace po = boost::program_options;
+
+class YulOpti
+{
+public:
+	static void printErrors(CharStream const& _charStream, ErrorList const& _errors)
+	{
+		SourceReferenceFormatter{
+			cerr,
+			SingletonCharStreamProvider(_charStream),
+			true,
+			false
+		}.printErrorInformation(_errors);
+	}
+
+	void parse(string const& _input)
+	{
+		ErrorList errors;
+		ErrorReporter errorReporter(errors);
+		CharStream _charStream(_input, "");
+		try
+		{
+			m_ast = yul::Parser(errorReporter, m_dialect).parse(_charStream);
+			if (!m_ast || !errorReporter.errors().empty())
+			{
+				cerr << "Error parsing source." << endl;
+				printErrors(_charStream, errors);
+				throw std::runtime_error("Could not parse source.");
+			}
+			m_analysisInfo = make_unique<yul::AsmAnalysisInfo>();
+			AsmAnalyzer analyzer(
+				*m_analysisInfo,
+				errorReporter,
+				m_dialect
+			);
+			if (!analyzer.analyze(*m_ast) || !errorReporter.errors().empty())
+			{
+				cerr << "Error analyzing source." << endl;
+				printErrors(_charStream, errors);
+				throw std::runtime_error("Could not analyze source.");
+			}
+		}
+		catch(...)
+		{
+			cerr << "Fatal error during parsing: " << endl;
+			printErrors(_charStream, errors);
+			throw;
+		}
+	}
+
+	void printUsageBanner(
+		map<char, string> const& _extraOptions,
+		size_t _columns
+	)
+	{
+		yulAssert(_columns > 0);
+		auto const& optimiserSteps = OptimiserSuite::stepAbbreviationToNameMap();
+		auto hasShorterString = [](auto const& a, auto const& b) { return a.second.size() < b.second.size(); };
+		size_t longestDescriptionLength = std::max(
+			max_element(optimiserSteps.begin(), optimiserSteps.end(), hasShorterString)->second.size(),
+			max_element(_extraOptions.begin(), _extraOptions.end(), hasShorterString)->second.size()
+		);
+
+		vector<string> overlappingAbbreviations =
+			ranges::views::set_intersection(_extraOptions | ranges::views::keys, optimiserSteps | ranges::views::keys) |
+			ranges::views::transform([](char _abbreviation){ return string(1, _abbreviation); }) |
+			ranges::to<vector>();
+
+		yulAssert(
+			overlappingAbbreviations.empty(),
+			"ERROR: Conflict between yulopti controls and the following Yul optimizer step abbreviations: " +
+			boost::join(overlappingAbbreviations, ", ") + ".\n"
+			"This is most likely caused by someone adding a new step abbreviation to "
+			"OptimiserSuite::stepNameToAbbreviationMap() and not realizing that it's used by yulopti.\n"
+			"Please update the code to use a different character and recompile yulopti."
+		);
+
+		vector<tuple<char, string>> sortedOptions =
+			ranges::views::concat(optimiserSteps, _extraOptions) |
+			ranges::to<vector<tuple<char, string>>>() |
+			ranges::actions::sort([](tuple<char, string> const& _a, tuple<char, string> const& _b) {
+				return (
+					!boost::algorithm::iequals(get<1>(_a), get<1>(_b)) ?
+					boost::algorithm::lexicographical_compare(get<1>(_a), get<1>(_b), boost::algorithm::is_iless()) :
+					toLower(get<0>(_a)) < toLower(get<0>(_b))
+				);
+			});
+
+		yulAssert(sortedOptions.size() > 0);
+		size_t rows = (sortedOptions.size() - 1) / _columns + 1;
+		for (size_t row = 0; row < rows; ++row)
+		{
+			for (auto const& [key, name]: sortedOptions | ranges::views::drop(row) | ranges::views::stride(rows))
+				cout << key << ": " << setw(static_cast<int>(longestDescriptionLength)) << setiosflags(ios::left) << name << " ";
+
+			cout << endl;
+		}
+	}
+
+	void disambiguate()
+	{
+		*m_ast = std::get<yul::Block>(Disambiguator(m_dialect, *m_analysisInfo)(*m_ast));
+		m_analysisInfo.reset();
+		m_nameDispenser.reset(*m_ast);
+	}
+
+	void runSteps(string _source, string _steps)
+	{
+		parse(_source);
+		disambiguate();
+		OptimiserSuite{m_context}.runSequence(_steps, *m_ast);
+		cout << AsmPrinter{m_dialect}(*m_ast) << endl;
+	}
+
+	void runInteractive(string _source, bool _disambiguated = false)
+	{
+		bool disambiguated = _disambiguated;
+		while (true)
+		{
+			parse(_source);
+			disambiguated = disambiguated || (disambiguate(), true);
+			map<char, string> const& extraOptions = {
+				// QUIT starts with a non-letter character on purpose to get it to show up on top of the list
+				{'#', ">>> QUIT <<<"},
+				{',', "VarNameCleaner"},
+				{';', "StackCompressor"}
+			};
+
+			printUsageBanner(extraOptions, 4);
+			cout << "? ";
+			cout.flush();
+			char option = static_cast<char>(readStandardInputChar());
+			cout << ' ' << option << endl;
+
+			try
+			{
+				switch (option)
+				{
+					case 4:
+					case '#':
+						return;
+					case ',':
+						VarNameCleaner::run(m_context, *m_ast);
+						// VarNameCleaner destroys the unique names guarantee of the disambiguator.
+						disambiguated = false;
+						break;
+					case ';':
+					{
+						Object obj;
+						obj.code = m_ast;
+						StackCompressor::run(m_dialect, obj, true, 16);
+						break;
+					}
+					default:
+						OptimiserSuite{m_context}.runSequence(
+							std::string_view(&option, 1),
+							*m_ast
+						);
+				}
+				_source = AsmPrinter{m_dialect}(*m_ast);
+			}
+			catch (...)
+			{
+				cerr << endl << "Exception during optimiser step:" << endl;
+				cerr << boost::current_exception_diagnostic_information() << endl;
+			}
+			cout << "----------------------" << endl;
+			cout << _source << endl;
+		}
+	}
+
+private:
+	shared_ptr<yul::Block> m_ast;
+	Dialect const& m_dialect{EVMDialect::strictAssemblyForEVMObjects(EVMVersion{})};
+	unique_ptr<AsmAnalysisInfo> m_analysisInfo;
+	set<YulString> const m_reservedIdentifiers = {};
+	NameDispenser m_nameDispenser{m_dialect, m_reservedIdentifiers};
+	OptimiserStepContext m_context{
+		m_dialect,
+		m_nameDispenser,
+		m_reservedIdentifiers,
+		solidity::frontend::OptimiserSettings::standard().expectedExecutionsPerDeployment
+	};
+};
+
+int main(int argc, char** argv)
+{
+	try
+	{
+		bool nonInteractive = false;
+		po::options_description options(
+			R"(yulopti, yul optimizer exploration tool.
+	Usage: yulopti [Options] <file>
+	Reads <file> as yul code and applies optimizer steps to it,
+	interactively read from stdin.
+	In non-interactive mode a list of steps has to be provided.
+	If <file> is -, yul code is read from stdin and run non-interactively.
+
+	Allowed options)",
+			po::options_description::m_default_line_length,
+			po::options_description::m_default_line_length - 23);
+		options.add_options()
+			(
+				"input-file",
+				po::value<string>(),
+				"input file"
+			)
+			(
+				"steps",
+				po::value<string>(),
+				"steps to execute non-interactively"
+			)
+			(
+				"non-interactive,n",
+				po::bool_switch(&nonInteractive)->default_value(false),
+				"stop after executing the provided steps"
+			)
+			("help,h", "Show this help screen.");
+
+		// All positional options should be interpreted as input files
+		po::positional_options_description filesPositions;
+		filesPositions.add("input-file", 1);
+
+		po::variables_map arguments;
+		po::command_line_parser cmdLineParser(argc, argv);
+		cmdLineParser.options(options).positional(filesPositions);
+		po::store(cmdLineParser.run(), arguments);
+		po::notify(arguments);
+
+		if (arguments.count("help"))
+		{
+			cout << options;
+			return 0;
+		}
+
+		string input;
+		if (arguments.count("input-file"))
+		{
+			string filename = arguments["input-file"].as<string>();
+			if (filename == "-")
+			{
+				nonInteractive = true;
+				input = readUntilEnd(cin);
+			}
+			else
+				input = readFileAsString(arguments["input-file"].as<string>());
+		}
+		else
+		{
+			cout << options;
+			return 1;
+		}
+
+		if (nonInteractive && !arguments.count("steps"))
+		{
+			cout << options;
+			return 1;
+		}
+
+		YulOpti yulOpti;
+		bool disambiguated = false;
+		if (!nonInteractive)
+			cout << input << endl;
+		if (arguments.count("steps"))
+		{
+			string sequence = arguments["steps"].as<string>();
+			if (!nonInteractive)
+				cout << "----------------------" << endl;
+			yulOpti.runSteps(input, sequence);
+			disambiguated = true;
+		}
+		if (!nonInteractive)
+			yulOpti.runInteractive(input, disambiguated);
+
+		return 0;
+	}
+	catch (po::error const& _exception)
+	{
+		cerr << _exception.what() << endl;
+		return 1;
+	}
+	catch (FileNotFound const& _exception)
+	{
+		cerr << "File not found:" << _exception.comment() << endl;
+		return 1;
+	}
+	catch (NotAFile const& _exception)
+	{
+		cerr << "Not a regular file:" << _exception.comment() << endl;
+		return 1;
+	}
+	catch(...)
+	{
+		cerr << endl << "Exception:" << endl;
+		cerr << boost::current_exception_diagnostic_information() << endl;
+		return 1;
+	}
+}
diff --git a/compiler/test/tools/yulrun.cpp b/compiler/test/tools/yulrun.cpp
new file mode 100644
index 00000000..2e1bcc01
--- /dev/null
+++ b/compiler/test/tools/yulrun.cpp
@@ -0,0 +1,169 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+/**
+ * Yul interpreter.
+ */
+
+#include <test/tools/yulInterpreter/Interpreter.h>
+#include <test/tools/yulInterpreter/Inspector.h>
+
+#include <libyul/AsmAnalysisInfo.h>
+#include <libyul/AsmAnalysis.h>
+#include <libyul/Dialect.h>
+#include <libyul/backends/evm/EVMDialect.h>
+#include <libyul/YulStack.h>
+
+#include <liblangutil/DebugInfoSelection.h>
+#include <liblangutil/Exceptions.h>
+#include <liblangutil/EVMVersion.h>
+#include <liblangutil/SourceReferenceFormatter.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/CommonData.h>
+#include <libsolutil/Exceptions.h>
+
+#include <boost/program_options.hpp>
+
+#include <string>
+#include <memory>
+#include <iostream>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+using namespace solidity::yul::test;
+
+namespace po = boost::program_options;
+
+namespace
+{
+
+pair<shared_ptr<Block>, shared_ptr<AsmAnalysisInfo>> parse(string const& _source)
+{
+	YulStack stack(
+		langutil::EVMVersion(),
+		nullopt,
+		YulStack::Language::StrictAssembly,
+		solidity::frontend::OptimiserSettings::none(),
+		DebugInfoSelection::Default()
+	);
+	if (stack.parseAndAnalyze("--INPUT--", _source))
+	{
+		yulAssert(stack.errors().empty(), "Parsed successfully but had errors.");
+		return make_pair(stack.parserResult()->code, stack.parserResult()->analysisInfo);
+	}
+	else
+	{
+		SourceReferenceFormatter(cout, stack, true, false).printErrorInformation(stack.errors());
+		return {};
+	}
+}
+
+void interpret(string const& _source, bool _inspect, bool _disableExternalCalls)
+{
+	shared_ptr<Block> ast;
+	shared_ptr<AsmAnalysisInfo> analysisInfo;
+	tie(ast, analysisInfo) = parse(_source);
+	if (!ast || !analysisInfo)
+		return;
+
+	InterpreterState state;
+	state.maxTraceSize = 10000;
+	try
+	{
+		Dialect const& dialect(EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion{}));
+
+		if (_inspect)
+			InspectedInterpreter::run(std::make_shared<Inspector>(_source, state), state, dialect, *ast, _disableExternalCalls, /*disableMemoryTracing=*/false);
+
+		else
+			Interpreter::run(state, dialect, *ast, _disableExternalCalls, /*disableMemoryTracing=*/false);
+	}
+	catch (InterpreterTerminatedGeneric const&)
+	{
+	}
+
+	state.dumpTraceAndState(cout, /*disableMemoryTracing=*/false);
+}
+
+}
+
+int main(int argc, char** argv)
+{
+	po::options_description options(
+		R"(yulrun, the Yul interpreter.
+Usage: yulrun [Options] < input
+Reads a single source from stdin, runs it and prints a trace of all side-effects.
+
+Allowed options)",
+		po::options_description::m_default_line_length,
+		po::options_description::m_default_line_length - 23);
+	options.add_options()
+		("help", "Show this help screen.")
+		("enable-external-calls", "Enable external calls")
+		("interactive", "Run interactive")
+		("input-file", po::value<vector<string>>(), "input file");
+	po::positional_options_description filesPositions;
+	filesPositions.add("input-file", -1);
+
+	po::variables_map arguments;
+	try
+	{
+		po::command_line_parser cmdLineParser(argc, argv);
+		cmdLineParser.options(options).positional(filesPositions);
+		po::store(cmdLineParser.run(), arguments);
+	}
+	catch (po::error const& _exception)
+	{
+		cerr << _exception.what() << endl;
+		return 1;
+	}
+
+	if (arguments.count("help"))
+		cout << options;
+	else
+	{
+		string input;
+		if (arguments.count("input-file"))
+			for (string path: arguments["input-file"].as<vector<string>>())
+			{
+				try
+				{
+					input += readFileAsString(path);
+				}
+				catch (FileNotFound const&)
+				{
+					cerr << "File not found: " << path << endl;
+					return 1;
+				}
+				catch (NotAFile const&)
+				{
+					cerr << "Not a regular file: " << path << endl;
+					return 1;
+				}
+			}
+		else
+			input = readUntilEnd(cin);
+
+		interpret(input, arguments.count("interactive"), !arguments.count("enable-external-calls"));
+	}
+
+	return 0;
+}
diff --git a/compiler/test/yulPhaser/AlgorithmRunner.cpp b/compiler/test/yulPhaser/AlgorithmRunner.cpp
new file mode 100644
index 00000000..00340392
--- /dev/null
+++ b/compiler/test/yulPhaser/AlgorithmRunner.cpp
@@ -0,0 +1,529 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/yulPhaser/TestHelpers.h>
+
+#include <tools/yulPhaser/AlgorithmRunner.h>
+#include <tools/yulPhaser/Common.h>
+#include <tools/yulPhaser/FitnessMetrics.h>
+
+#include <liblangutil/CharStream.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/tools/output_test_stream.hpp>
+
+#include <fstream>
+#include <regex>
+#include <sstream>
+
+using namespace std;
+using namespace boost::unit_test::framework;
+using namespace boost::test_tools;
+using namespace solidity::langutil;
+using namespace solidity::util;
+using namespace solidity::yul;
+
+namespace fs = boost::filesystem;
+
+namespace solidity::phaser::test
+{
+
+class CountingAlgorithm: public GeneticAlgorithm
+{
+public:
+	using GeneticAlgorithm::GeneticAlgorithm;
+	Population runNextRound(Population _population) override
+	{
+		++m_currentRound;
+		return _population;
+	}
+
+	size_t m_currentRound = 0;
+};
+
+class RandomisingAlgorithm: public GeneticAlgorithm
+{
+public:
+	using GeneticAlgorithm::GeneticAlgorithm;
+	Population runNextRound(Population _population) override
+	{
+		return Population::makeRandom(_population.fitnessMetric(), _population.individuals().size(), 10, 20);
+	}
+};
+
+class AlgorithmRunnerFixture
+{
+protected:
+	// NOTE: Regexes here should not contain spaces because we strip them before matching
+	regex RoundSummaryRegex{R"(-+ROUND\d+\[round:[0-9.]+s,total:[0-9.]+s\]-+)"};
+	regex InitialPopulationHeaderRegex{"-+INITIALPOPULATION-+"};
+
+	string individualPattern(Individual const& individual) const
+	{
+		ostringstream output;
+		output << individual.fitness << individual.chromosome;
+		return output.str();
+	}
+
+	string topChromosomePattern(size_t roundNumber, Individual const& individual) const
+	{
+		ostringstream output;
+		output << roundNumber << R"(\|[0-9.]+\|)" << individualPattern(individual);
+		return output.str();
+	}
+
+	bool nextLineMatches(stringstream& stream, regex const& pattern) const
+	{
+		string line;
+		if (getline(stream, line).fail())
+			return false;
+
+		return regex_match(stripWhitespace(line), pattern);
+	}
+
+	shared_ptr<FitnessMetric> m_fitnessMetric = make_shared<ChromosomeLengthMetric>();
+	Population const m_population = Population::makeRandom(m_fitnessMetric, 5, 0, 20);
+	stringstream m_output;
+	AlgorithmRunner::Options m_options;
+};
+
+class AlgorithmRunnerAutosaveFixture: public AlgorithmRunnerFixture
+{
+public:
+	static vector<string> chromosomeStrings(Population const& _population)
+	{
+		vector<string> lines;
+		for (auto const& individual: _population.individuals())
+			lines.push_back(toString(individual.chromosome));
+
+		return lines;
+	}
+
+protected:
+	TemporaryDirectory m_tempDir;
+	string const m_autosavePath = (m_tempDir.path() / "population-autosave.txt").string();
+	RandomisingAlgorithm m_algorithm;
+};
+
+BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
+BOOST_AUTO_TEST_SUITE(AlgorithmRunnerTest)
+
+BOOST_FIXTURE_TEST_CASE(run_should_call_runNextRound_once_per_round, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 5;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+
+	CountingAlgorithm algorithm;
+
+	BOOST_TEST(algorithm.m_currentRound == 0);
+	runner.run(algorithm);
+	BOOST_TEST(algorithm.m_currentRound == 5);
+	runner.run(algorithm);
+	BOOST_TEST(algorithm.m_currentRound == 10);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_round_summary_after_each_round, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = false;
+	m_options.showRoundInfo = true;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
+	for (auto const& individual: runner.population().individuals())
+		BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
+	for (auto const& individual: runner.population().individuals())
+		BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_print_round_summary_if_not_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = false;
+	m_options.showRoundInfo = false;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, regex("")));
+	for (auto const& individual: runner.population().individuals())
+		BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_print_population_if_its_empty, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = false;
+	m_options.showRoundInfo = true;
+	AlgorithmRunner runner(Population(m_fitnessMetric), {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, RoundSummaryRegex));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_only_top_chromosome_if_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = true;
+	m_options.showRoundInfo = true;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, regex(topChromosomePattern(1, runner.population().individuals()[0]))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_print_round_number_for_top_chromosome_if_round_info_not_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = true;
+	m_options.showRoundInfo = false;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(runner.population().individuals()[0]))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_print_population_if_its_empty_and_only_top_chromosome_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 3;
+	m_options.showRoundInfo = true;
+	m_options.showInitialPopulation = false;
+	m_options.showOnlyTopChromosome = true;
+	AlgorithmRunner runner(Population(m_fitnessMetric), {}, m_options, m_output);
+	RandomisingAlgorithm algorithm;
+
+	runner.run(algorithm);
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_initial_population_if_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 0;
+	m_options.showInitialPopulation = true;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = false;
+	RandomisingAlgorithm algorithm;
+
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	runner.run(algorithm);
+
+	BOOST_TEST(nextLineMatches(m_output, InitialPopulationHeaderRegex));
+	for (auto const& individual: m_population.individuals())
+		BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_print_initial_population_if_not_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 0;
+	m_options.showInitialPopulation = false;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = false;
+	RandomisingAlgorithm algorithm;
+
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	runner.run(algorithm);
+
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_whole_initial_population_even_if_only_top_chromosome_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 0;
+	m_options.showInitialPopulation = true;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = true;
+	RandomisingAlgorithm algorithm;
+
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	runner.run(algorithm);
+
+	BOOST_TEST(nextLineMatches(m_output, InitialPopulationHeaderRegex));
+	for (auto const& individual: m_population.individuals())
+		BOOST_TEST(nextLineMatches(m_output, regex(individualPattern(individual))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_cache_stats_if_requested, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 4;
+	m_options.showInitialPopulation = false;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = true;
+	m_options.showCacheStats = true;
+	RandomisingAlgorithm algorithm;
+
+	vector<CharStream> sourceStreams = {
+		CharStream("{mstore(10, 20)}", ""),
+		CharStream("{mstore(10, 20)\nsstore(10, 20)}", ""),
+	};
+	vector<Program> programs = {
+		get<Program>(Program::load(sourceStreams[0])),
+		get<Program>(Program::load(sourceStreams[1])),
+	};
+	vector<shared_ptr<ProgramCache>> caches = {
+		make_shared<ProgramCache>(programs[0]),
+		make_shared<ProgramCache>(programs[1]),
+	};
+	shared_ptr<FitnessMetric> fitnessMetric = make_shared<FitnessMetricAverage>(vector<shared_ptr<FitnessMetric>>{
+		make_shared<ProgramSize>(nullopt, caches[0], CodeWeights{}),
+		make_shared<ProgramSize>(nullopt, caches[1], CodeWeights{}),
+	});
+	Population population = Population::makeRandom(fitnessMetric, 2, 0, 5);
+
+	AlgorithmRunner runner(population, caches, m_options, m_output);
+	runner.run(algorithm);
+
+	BOOST_TEST(caches[0]->currentRound() == m_options.maxRounds.value());
+	BOOST_TEST(caches[1]->currentRound() == m_options.maxRounds.value());
+
+	CacheStats stats = caches[0]->gatherStats() + caches[1]->gatherStats();
+
+	for (size_t i = 0; i < m_options.maxRounds.value() - 1; ++i)
+	{
+		BOOST_TEST(nextLineMatches(m_output, regex(".*")));
+		BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
+		if (i > 0)
+			BOOST_TEST(nextLineMatches(m_output, regex(R"(Round\d+:\d+entries)")));
+		BOOST_TEST(nextLineMatches(m_output, regex(R"(Round\d+:\d+entries)")));
+		BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalhits:\d+)")));
+		BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalmisses:\d+)")));
+		BOOST_TEST(nextLineMatches(m_output, regex(R"(Sizeofcachedcode:\d+)")));
+	}
+
+	BOOST_REQUIRE(stats.roundEntryCounts.size() == 2);
+	BOOST_REQUIRE(stats.roundEntryCounts.count(m_options.maxRounds.value() - 1) == 1);
+	BOOST_REQUIRE(stats.roundEntryCounts.count(m_options.maxRounds.value()) == 1);
+
+	size_t round = m_options.maxRounds.value();
+	BOOST_TEST(nextLineMatches(m_output, regex(".*")));
+	BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
+	BOOST_TEST(nextLineMatches(m_output, regex("Round" + toString(round - 1) + ":" + toString(stats.roundEntryCounts[round - 1]) + "entries")));
+	BOOST_TEST(nextLineMatches(m_output, regex("Round" + toString(round) + ":" + toString(stats.roundEntryCounts[round]) + "entries")));
+	BOOST_TEST(nextLineMatches(m_output, regex("Totalhits:" + toString(stats.hits))));
+	BOOST_TEST(nextLineMatches(m_output, regex("Totalmisses:" + toString(stats.misses))));
+	BOOST_TEST(nextLineMatches(m_output, regex("Sizeofcachedcode:" + toString(stats.totalCodeSize))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_message_if_cache_stats_requested_but_cache_disabled, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = true;
+	m_options.showCacheStats = true;
+	RandomisingAlgorithm algorithm;
+
+	AlgorithmRunner runner(m_population, {nullptr}, m_options, m_output);
+	runner.run(algorithm);
+
+	BOOST_TEST(nextLineMatches(m_output, regex(".*")));
+	BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
+	BOOST_TEST(nextLineMatches(m_output, regex(stripWhitespace("Program cache disabled"))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_print_partial_stats_and_message_if_some_caches_disabled, AlgorithmRunnerFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.showInitialPopulation = false;
+	m_options.showRoundInfo = false;
+	m_options.showOnlyTopChromosome = true;
+	m_options.showCacheStats = true;
+	RandomisingAlgorithm algorithm;
+
+	CharStream sourceStream = CharStream("{}", "");
+	shared_ptr<ProgramCache> cache = make_shared<ProgramCache>(get<Program>(Program::load(sourceStream)));
+
+	AlgorithmRunner runner(m_population, {cache, nullptr}, m_options, m_output);
+	BOOST_REQUIRE(cache->gatherStats().roundEntryCounts.size() == 0);
+
+	runner.run(algorithm);
+	BOOST_TEST(nextLineMatches(m_output, regex(".*")));
+	BOOST_TEST(nextLineMatches(m_output, regex("-+CACHESTATS-+")));
+	BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalhits:\d+)")));
+	BOOST_TEST(nextLineMatches(m_output, regex(R"(Totalmisses:\d+)")));
+	BOOST_TEST(nextLineMatches(m_output, regex(R"(Sizeofcachedcode:\d+)")));
+	BOOST_TEST(nextLineMatches(m_output, regex(stripWhitespace("Program cache disabled for 1 out of 2 programs"))));
+	BOOST_TEST(m_output.peek() == EOF);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_save_initial_population_to_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
+{
+	m_options.maxRounds = 0;
+	m_options.populationAutosaveFile = m_autosavePath;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	assert(!fs::exists(m_autosavePath));
+
+	runner.run(m_algorithm);
+	assert(runner.population() == m_population);
+
+	BOOST_TEST(fs::is_regular_file(m_autosavePath));
+	BOOST_TEST(readLinesFromFile(m_autosavePath) == chromosomeStrings(runner.population()));
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_save_population_to_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
+{
+	m_options.maxRounds = 1;
+	m_options.populationAutosaveFile = m_autosavePath;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	assert(!fs::exists(m_autosavePath));
+
+	runner.run(m_algorithm);
+	assert(runner.population() != m_population);
+
+	BOOST_TEST(fs::is_regular_file(m_autosavePath));
+	BOOST_TEST(readLinesFromFile(m_autosavePath) == chromosomeStrings(runner.population()));
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_overwrite_existing_file_if_autosave_file_specified, AlgorithmRunnerAutosaveFixture)
+{
+	m_options.maxRounds = 5;
+	m_options.populationAutosaveFile = m_autosavePath;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	assert(!fs::exists(m_autosavePath));
+
+	vector<string> originalContent = {"Original content"};
+	{
+		ofstream tmpFile(m_autosavePath);
+		tmpFile << originalContent[0] << endl;
+	}
+	assert(fs::exists(m_autosavePath));
+	assert(readLinesFromFile(m_autosavePath) == originalContent);
+
+	runner.run(m_algorithm);
+
+	BOOST_TEST(fs::is_regular_file(m_autosavePath));
+	BOOST_TEST(readLinesFromFile(m_autosavePath) != originalContent);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_save_population_to_file_if_autosave_file_not_specified, AlgorithmRunnerAutosaveFixture)
+{
+	m_options.maxRounds = 5;
+	m_options.populationAutosaveFile = nullopt;
+	AlgorithmRunner runner(m_population, {}, m_options, m_output);
+	assert(!fs::exists(m_autosavePath));
+
+	runner.run(m_algorithm);
+
+	BOOST_TEST(!fs::exists(m_autosavePath));
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_randomise_duplicate_chromosomes_if_requested, AlgorithmRunnerFixture)
+{
+	Chromosome duplicate("afc");
+	Population population(m_fitnessMetric, {duplicate, duplicate, duplicate});
+	CountingAlgorithm algorithm;
+
+	m_options.maxRounds = 1;
+	m_options.randomiseDuplicates = true;
+	m_options.minChromosomeLength = 50;
+	m_options.maxChromosomeLength = 50;
+	AlgorithmRunner runner(population, {}, m_options, m_output);
+
+	runner.run(algorithm);
+
+	auto const& newIndividuals = runner.population().individuals();
+
+	BOOST_TEST(newIndividuals.size() == 3);
+	BOOST_TEST((
+		newIndividuals[0].chromosome == duplicate ||
+		newIndividuals[1].chromosome == duplicate ||
+		newIndividuals[2].chromosome == duplicate
+	));
+	BOOST_TEST(newIndividuals[0] != newIndividuals[1]);
+	BOOST_TEST(newIndividuals[0] != newIndividuals[2]);
+	BOOST_TEST(newIndividuals[1] != newIndividuals[2]);
+
+	BOOST_TEST((newIndividuals[0].chromosome.length() == 50 || newIndividuals[0].chromosome == duplicate));
+	BOOST_TEST((newIndividuals[1].chromosome.length() == 50 || newIndividuals[1].chromosome == duplicate));
+	BOOST_TEST((newIndividuals[2].chromosome.length() == 50 || newIndividuals[2].chromosome == duplicate));
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_not_randomise_duplicate_chromosomes_if_not_requested, AlgorithmRunnerFixture)
+{
+	Chromosome duplicate("afc");
+	Population population(m_fitnessMetric, {duplicate, duplicate, duplicate});
+	CountingAlgorithm algorithm;
+
+	m_options.maxRounds = 1;
+	m_options.randomiseDuplicates = false;
+	AlgorithmRunner runner(population, {}, m_options, m_output);
+
+	runner.run(algorithm);
+
+	BOOST_TEST(runner.population().individuals().size() == 3);
+	BOOST_TEST(runner.population().individuals()[0].chromosome == duplicate);
+	BOOST_TEST(runner.population().individuals()[1].chromosome == duplicate);
+	BOOST_TEST(runner.population().individuals()[2].chromosome == duplicate);
+}
+
+BOOST_FIXTURE_TEST_CASE(run_should_clear_cache_at_the_beginning_and_update_it_before_each_round, AlgorithmRunnerFixture)
+{
+	CharStream sourceStream = CharStream("{}", current_test_case().p_name);
+	vector<shared_ptr<ProgramCache>> caches = {
+		make_shared<ProgramCache>(get<Program>(Program::load(sourceStream))),
+		make_shared<ProgramCache>(get<Program>(Program::load(sourceStream))),
+	};
+
+	m_options.maxRounds = 10;
+	AlgorithmRunner runner(m_population, caches, m_options, m_output);
+	CountingAlgorithm algorithm;
+
+	BOOST_TEST(algorithm.m_currentRound == 0);
+	BOOST_TEST(caches[0]->currentRound() == 0);
+	BOOST_TEST(caches[1]->currentRound() == 0);
+
+	runner.run(algorithm);
+	BOOST_TEST(algorithm.m_currentRound == 10);
+	BOOST_TEST(caches[0]->currentRound() == 10);
+	BOOST_TEST(caches[1]->currentRound() == 10);
+
+	runner.run(algorithm);
+	BOOST_TEST(algorithm.m_currentRound == 20);
+	BOOST_TEST(caches[0]->currentRound() == 10);
+	BOOST_TEST(caches[1]->currentRound() == 10);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/yulPhaser/Chromosome.cpp b/compiler/test/yulPhaser/Chromosome.cpp
new file mode 100644
index 00000000..1d12bf18
--- /dev/null
+++ b/compiler/test/yulPhaser/Chromosome.cpp
@@ -0,0 +1,182 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/yulPhaser/TestHelpers.h>
+
+#include <tools/yulPhaser/Chromosome.h>
+#include <tools/yulPhaser/SimulationRNG.h>
+
+#include <libyul/optimiser/BlockFlattener.h>
+#include <libyul/optimiser/ConditionalSimplifier.h>
+#include <libyul/optimiser/ExpressionInliner.h>
+#include <libyul/optimiser/ExpressionSimplifier.h>
+#include <libyul/optimiser/ForLoopConditionOutOfBody.h>
+#include <libyul/optimiser/ForLoopConditionOutOfBody.h>
+#include <libyul/optimiser/ForLoopInitRewriter.h>
+#include <libyul/optimiser/FunctionHoister.h>
+#include <libyul/optimiser/LoopInvariantCodeMotion.h>
+#include <libyul/optimiser/UnusedAssignEliminator.h>
+#include <libyul/optimiser/Rematerialiser.h>
+#include <libyul/optimiser/Suite.h>
+#include <libyul/optimiser/StructuralSimplifier.h>
+#include <libyul/optimiser/UnusedPruner.h>
+
+#include <libsolutil/CommonIO.h>
+
+#include <boost/test/unit_test.hpp>
+
+using namespace std;
+using namespace solidity::yul;
+using namespace solidity::util;
+
+namespace solidity::phaser::test
+{
+
+vector<string> const ChrOmOsoMeSteps{
+	ConditionalSimplifier::name,
+	FunctionHoister::name,
+	UnusedAssignEliminator::name,
+	ForLoopConditionOutOfBody::name,
+	Rematerialiser::name,
+	ForLoopConditionOutOfBody::name,
+	ExpressionSimplifier::name,
+	ForLoopInitRewriter::name,
+	LoopInvariantCodeMotion::name,
+	ExpressionInliner::name
+};
+
+BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
+BOOST_AUTO_TEST_SUITE(ChromosomeTest)
+
+BOOST_AUTO_TEST_CASE(makeRandom_should_return_different_chromosome_each_time)
+{
+	SimulationRNG::reset(1);
+	for (size_t i = 0; i < 10; ++i)
+		BOOST_TEST(Chromosome::makeRandom(100) != Chromosome::makeRandom(100));
+}
+
+BOOST_AUTO_TEST_CASE(makeRandom_should_use_every_possible_step_with_the_same_probability)
+{
+	SimulationRNG::reset(1);
+	constexpr int samplesPerStep = 500;
+	constexpr double relativeTolerance = 0.02;
+
+	map<string, size_t> stepIndices = enumerateOptmisationSteps();
+	auto chromosome = Chromosome::makeRandom(stepIndices.size() * samplesPerStep);
+
+	vector<size_t> samples;
+	for (auto& step: chromosome.optimisationSteps())
+		samples.push_back(stepIndices.at(step));
+
+	const double expectedValue = double(stepIndices.size() - 1) / 2.0;
+	const double variance = double(stepIndices.size() * stepIndices.size() - 1) / 12.0;
+
+	BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
+	BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
+}
+
+BOOST_AUTO_TEST_CASE(constructor_should_store_genes)
+{
+	BOOST_TEST(Chromosome("ChrOmOsoMe").genes() == "ChrOmOsoMe");
+}
+
+BOOST_AUTO_TEST_CASE(constructor_should_store_optimisation_steps)
+{
+	vector<string> steps = {
+		StructuralSimplifier::name,
+		BlockFlattener::name,
+		UnusedPruner::name,
+	};
+
+	BOOST_TEST(Chromosome(steps).genes() == "tfu");
+}
+
+BOOST_AUTO_TEST_CASE(constructor_should_allow_duplicate_steps)
+{
+	vector<string> steps = {
+		StructuralSimplifier::name,
+		StructuralSimplifier::name,
+		BlockFlattener::name,
+		UnusedPruner::name,
+		BlockFlattener::name,
+	};
+
+	BOOST_TEST(Chromosome(steps).genes() == "ttfuf");
+	BOOST_TEST(Chromosome("ttfuf").genes() == "ttfuf");
+}
+
+BOOST_AUTO_TEST_CASE(constructor_should_allow_genes_that_do_not_correspond_to_any_step)
+{
+	assert(OptimiserSuite::stepAbbreviationToNameMap().count('.') == 0);
+	assert(OptimiserSuite::stepAbbreviationToNameMap().count('b') == 0);
+
+	BOOST_TEST(Chromosome(".").genes() == ".");
+	BOOST_TEST(Chromosome("a..abatbb").genes() == "a..abatbb");
+}
+
+BOOST_AUTO_TEST_CASE(output_operator_should_create_concise_and_unambiguous_string_representation)
+{
+	vector<string> allSteps;
+	for (auto const& step: OptimiserSuite::allSteps())
+		allSteps.push_back(step.first);
+	Chromosome chromosome(allSteps);
+
+	BOOST_TEST(chromosome.length() == allSteps.size());
+	BOOST_TEST(chromosome.optimisationSteps() == allSteps);
+	BOOST_TEST(toString(chromosome) == "flcCUnDEvejsxIOoighFTLMmVatrpuSd");
+}
+
+BOOST_AUTO_TEST_CASE(optimisationSteps_should_translate_chromosomes_genes_to_optimisation_step_names)
+{
+	BOOST_TEST(Chromosome("ChrOmOsoMe").optimisationSteps() == ChrOmOsoMeSteps);
+}
+
+BOOST_AUTO_TEST_CASE(randomOptimisationStep_should_return_each_step_with_same_probability)
+{
+	SimulationRNG::reset(1);
+	constexpr int samplesPerStep = 500;
+	constexpr double relativeTolerance = 0.02;
+
+	map<string, size_t> stepIndices = enumerateOptmisationSteps();
+	vector<size_t> samples;
+	for (size_t i = 0; i <= stepIndices.size() * samplesPerStep; ++i)
+		samples.push_back(stepIndices.at(Chromosome::randomOptimisationStep()));
+
+	const double expectedValue = double(stepIndices.size() - 1) / 2.0;
+	const double variance = double(stepIndices.size() * stepIndices.size() - 1) / 12.0;
+
+	BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
+	BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
+}
+
+BOOST_AUTO_TEST_CASE(stepsToGenes_should_translate_optimisation_step_names_to_abbreviations)
+{
+	BOOST_TEST(Chromosome::stepsToGenes({}) == "");
+	BOOST_TEST(Chromosome::stepsToGenes(ChrOmOsoMeSteps) == "ChrOmOsoMe");
+}
+
+BOOST_AUTO_TEST_CASE(genesToSteps_should_translate_optimisation_step_abbreviations_to_names)
+{
+	BOOST_TEST(Chromosome::genesToSteps("") == vector<string>{});
+	BOOST_TEST(Chromosome::genesToSteps("ChrOmOsoMe") == ChrOmOsoMeSteps);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/yulPhaser/Common.cpp b/compiler/test/yulPhaser/Common.cpp
new file mode 100644
index 00000000..73473848
--- /dev/null
+++ b/compiler/test/yulPhaser/Common.cpp
@@ -0,0 +1,151 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/yulPhaser/TestHelpers.h>
+
+#include <tools/yulPhaser/Common.h>
+
+#include <libsolutil/CommonData.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/tools/output_test_stream.hpp>
+
+#include <fstream>
+#include <sstream>
+#include <string>
+
+using namespace std;
+using namespace boost::test_tools;
+using namespace solidity::util;
+
+namespace solidity::phaser::test
+{
+
+class ReadLinesFromFileFixture
+{
+protected:
+	TemporaryDirectory m_tempDir;
+};
+
+namespace
+{
+
+enum class TestEnum
+{
+	A,
+	B,
+	AB,
+	CD,
+	EF,
+	GH,
+};
+
+map<TestEnum, string> const TestEnumToStringMap =
+{
+	{TestEnum::A, "a"},
+	{TestEnum::B, "b"},
+	{TestEnum::AB, "a b"},
+	{TestEnum::CD, "c-d"},
+	{TestEnum::EF, "e f"},
+};
+map<string, TestEnum> const StringToTestEnumMap = invertMap(TestEnumToStringMap);
+
+}
+
+BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
+BOOST_AUTO_TEST_SUITE(CommonTest)
+
+BOOST_FIXTURE_TEST_CASE(readLinesFromFile_should_return_all_lines_from_a_text_file_as_strings_without_newlines, ReadLinesFromFileFixture)
+{
+	{
+		ofstream tmpFile((m_tempDir.path() / "test-file.txt").string());
+		tmpFile << endl << "Line 1" << endl << endl << endl << "Line 2" << endl << "#" << endl << endl;
+	}
+
+	vector<string> lines = readLinesFromFile((m_tempDir.path() / "test-file.txt").string());
+	BOOST_TEST((lines == vector<string>{"", "Line 1", "", "", "Line 2", "#", ""}));
+}
+
+BOOST_AUTO_TEST_CASE(deserializeChoice_should_convert_string_to_enum)
+{
+	istringstream aStream("a");
+	TestEnum aResult;
+	deserializeChoice(aStream, aResult, StringToTestEnumMap);
+	BOOST_CHECK(aResult == TestEnum::A);
+	BOOST_TEST(!aStream.fail());
+
+	istringstream bStream("b");
+	TestEnum bResult;
+	deserializeChoice(bStream, bResult, StringToTestEnumMap);
+	BOOST_CHECK(bResult == TestEnum::B);
+	BOOST_TEST(!bStream.fail());
+
+	istringstream cdStream("c-d");
+	TestEnum cdResult;
+	deserializeChoice(cdStream, cdResult, StringToTestEnumMap);
+	BOOST_CHECK(cdResult == TestEnum::CD);
+	BOOST_TEST(!cdStream.fail());
+}
+
+BOOST_AUTO_TEST_CASE(deserializeChoice_should_set_failbit_if_there_is_no_enum_corresponding_to_string)
+{
+	istringstream xyzStream("xyz");
+	TestEnum xyzResult;
+	deserializeChoice(xyzStream, xyzResult, StringToTestEnumMap);
+	BOOST_TEST(xyzStream.fail());
+}
+
+BOOST_AUTO_TEST_CASE(deserializeChoice_does_not_have_to_support_strings_with_spaces)
+{
+	istringstream abStream("a b");
+	TestEnum abResult;
+	deserializeChoice(abStream, abResult, StringToTestEnumMap);
+	BOOST_CHECK(abResult == TestEnum::A);
+	BOOST_TEST(!abStream.fail());
+
+	istringstream efStream("e f");
+	TestEnum efResult;
+	deserializeChoice(efStream, efResult, StringToTestEnumMap);
+	BOOST_TEST(efStream.fail());
+}
+
+BOOST_AUTO_TEST_CASE(serializeChoice_should_convert_enum_to_string)
+{
+	output_test_stream output;
+
+	serializeChoice(output, TestEnum::A, TestEnumToStringMap);
+	BOOST_CHECK(output.is_equal("a"));
+	BOOST_TEST(!output.fail());
+
+	serializeChoice(output, TestEnum::AB, TestEnumToStringMap);
+	BOOST_CHECK(output.is_equal("a b"));
+	BOOST_TEST(!output.fail());
+}
+
+BOOST_AUTO_TEST_CASE(serializeChoice_should_set_failbit_if_there_is_no_string_corresponding_to_enum)
+{
+	output_test_stream output;
+	serializeChoice(output, TestEnum::GH, TestEnumToStringMap);
+	BOOST_TEST(output.fail());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/test/yulPhaser/Phaser.cpp b/compiler/test/yulPhaser/Phaser.cpp
new file mode 100644
index 00000000..feee2269
--- /dev/null
+++ b/compiler/test/yulPhaser/Phaser.cpp
@@ -0,0 +1,474 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <test/yulPhaser/TestHelpers.h>
+
+#include <tools/yulPhaser/Exceptions.h>
+#include <tools/yulPhaser/Phaser.h>
+
+#include <liblangutil/CharStream.h>
+
+#include <libsolutil/CommonIO.h>
+#include <libsolutil/TemporaryDirectory.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <fstream>
+
+using namespace std;
+using namespace solidity::util;
+using namespace solidity::langutil;
+using namespace solidity::yul;
+
+namespace fs = boost::filesystem;
+
+namespace solidity::phaser::test
+{
+
+class GeneticAlgorithmFactoryFixture
+{
+protected:
+	GeneticAlgorithmFactory::Options m_options = {
+		/* algorithm = */ Algorithm::Random,
+		/* minChromosomeLength = */ 50,
+		/* maxChromosomeLength = */ 100,
+		/* CrossoverChoice = */ CrossoverChoice::Uniform,
+		/* uniformCrossoverSwapChance = */ 0.5,
+		/* randomElitePoolSize = */ 0.5,
+		/* gewepMutationPoolSize = */ 0.1,
+		/* gewepCrossoverPoolSize = */ 0.1,
+		/* gewepRandomisationChance = */ 0.6,
+		/* gewepDeletionVsAdditionChance = */ 0.3,
+		/* gewepGenesToRandomise = */ 0.4,
+		/* gewepGenesToAddOrDelete = */ 0.2,
+		/* classicElitePoolSize = */ 0.0,
+		/* classicCrossoverChance = */ 0.75,
+		/* classicMutationChance = */ 0.2,
+		/* classicDeletionChance = */ 0.2,
+		/* classicAdditionChance = */ 0.2,
+	};
+};
+
+class FixtureWithPrograms
+{
+protected:
+	vector<CharStream> m_sourceStreams = {
+		CharStream("{}", ""),
+		CharStream("{{}}", ""),
+		CharStream("{{{}}}", ""),
+	};
+	vector<Program> m_programs = {
+		get<Program>(Program::load(m_sourceStreams[0])),
+		get<Program>(Program::load(m_sourceStreams[1])),
+		get<Program>(Program::load(m_sourceStreams[2])),
+	};
+};
+
+class FitnessMetricFactoryFixture: public FixtureWithPrograms
+{
+protected:
+	FitnessMetricFactory::Options m_options = {
+		/* metric = */ MetricChoice::CodeSize,
+		/* metricAggregator = */ MetricAggregatorChoice::Average,
+		/* relativeMetricScale = */ 5,
+		/* chromosomeRepetitions = */ 1,
+	};
+	CodeWeights const m_weights{};
+};
+
+class PoulationFactoryFixture
+{
+protected:
+	shared_ptr<FitnessMetric> m_fitnessMetric = make_shared<ChromosomeLengthMetric>();
+	PopulationFactory::Options m_options = {
+		/* minChromosomeLength = */ 0,
+		/* maxChromosomeLength = */ 0,
+		/* population = */ {},
+		/* randomPopulation = */ {},
+		/* populationFromFile = */ {},
+	};
+};
+
+BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
+BOOST_AUTO_TEST_SUITE(PhaserTest)
+BOOST_AUTO_TEST_SUITE(GeneticAlgorithmFactoryTest)
+
+BOOST_FIXTURE_TEST_CASE(build_should_select_the_right_algorithm_and_pass_the_options_to_it, GeneticAlgorithmFactoryFixture)
+{
+	m_options.algorithm = Algorithm::Random;
+	unique_ptr<GeneticAlgorithm> algorithm1 = GeneticAlgorithmFactory::build(m_options, 100);
+	BOOST_REQUIRE(algorithm1 != nullptr);
+
+	auto randomAlgorithm = dynamic_cast<RandomAlgorithm*>(algorithm1.get());
+	BOOST_REQUIRE(randomAlgorithm != nullptr);
+	BOOST_TEST(randomAlgorithm->options().elitePoolSize == m_options.randomElitePoolSize.value());
+	BOOST_TEST(randomAlgorithm->options().minChromosomeLength == m_options.minChromosomeLength);
+	BOOST_TEST(randomAlgorithm->options().maxChromosomeLength == m_options.maxChromosomeLength);
+
+	m_options.algorithm = Algorithm::GEWEP;
+	unique_ptr<GeneticAlgorithm> algorithm2 = GeneticAlgorithmFactory::build(m_options, 100);
+	BOOST_REQUIRE(algorithm2 != nullptr);
+
+	auto gewepAlgorithm = dynamic_cast<GenerationalElitistWithExclusivePools*>(algorithm2.get());
+	BOOST_REQUIRE(gewepAlgorithm != nullptr);
+	BOOST_TEST(gewepAlgorithm->options().crossover == m_options.crossover);
+	BOOST_TEST(gewepAlgorithm->options().uniformCrossoverSwapChance.has_value());
+	BOOST_TEST(gewepAlgorithm->options().uniformCrossoverSwapChance.value() == m_options.uniformCrossoverSwapChance);
+	BOOST_TEST(gewepAlgorithm->options().mutationPoolSize == m_options.gewepMutationPoolSize);
+	BOOST_TEST(gewepAlgorithm->options().crossoverPoolSize == m_options.gewepCrossoverPoolSize);
+	BOOST_TEST(gewepAlgorithm->options().randomisationChance == m_options.gewepRandomisationChance);
+	BOOST_TEST(gewepAlgorithm->options().deletionVsAdditionChance == m_options.gewepDeletionVsAdditionChance);
+	BOOST_TEST(gewepAlgorithm->options().percentGenesToRandomise == m_options.gewepGenesToRandomise.value());
+	BOOST_TEST(gewepAlgorithm->options().percentGenesToAddOrDelete == m_options.gewepGenesToAddOrDelete.value());
+
+	m_options.algorithm = Algorithm::Classic;
+	unique_ptr<GeneticAlgorithm> algorithm3 = GeneticAlgorithmFactory::build(m_options, 100);
+	BOOST_REQUIRE(algorithm3 != nullptr);
+
+	auto classicAlgorithm = dynamic_cast<ClassicGeneticAlgorithm*>(algorithm3.get());
+	BOOST_REQUIRE(classicAlgorithm != nullptr);
+	BOOST_TEST(classicAlgorithm->options().uniformCrossoverSwapChance.has_value());
+	BOOST_TEST(classicAlgorithm->options().uniformCrossoverSwapChance.value() == m_options.uniformCrossoverSwapChance);
+	BOOST_TEST(classicAlgorithm->options().elitePoolSize == m_options.classicElitePoolSize);
+	BOOST_TEST(classicAlgorithm->options().crossoverChance == m_options.classicCrossoverChance);
+	BOOST_TEST(classicAlgorithm->options().mutationChance == m_options.classicMutationChance);
+	BOOST_TEST(classicAlgorithm->options().deletionChance == m_options.classicDeletionChance);
+	BOOST_TEST(classicAlgorithm->options().additionChance == m_options.classicAdditionChance);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_set_random_algorithm_elite_pool_size_based_on_population_size_if_not_specified, GeneticAlgorithmFactoryFixture)
+{
+	m_options.algorithm = Algorithm::Random;
+	m_options.randomElitePoolSize = nullopt;
+	unique_ptr<GeneticAlgorithm> algorithm = GeneticAlgorithmFactory::build(m_options, 100);
+	BOOST_REQUIRE(algorithm != nullptr);
+
+	auto randomAlgorithm = dynamic_cast<RandomAlgorithm*>(algorithm.get());
+	BOOST_REQUIRE(randomAlgorithm != nullptr);
+	BOOST_TEST(randomAlgorithm->options().elitePoolSize == 1.0 / 100.0);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_set_gewep_mutation_percentages_based_on_maximum_chromosome_length_if_not_specified, GeneticAlgorithmFactoryFixture)
+{
+	m_options.algorithm = Algorithm::GEWEP;
+	m_options.gewepGenesToRandomise = nullopt;
+	m_options.gewepGenesToAddOrDelete = nullopt;
+	m_options.maxChromosomeLength = 125;
+
+	unique_ptr<GeneticAlgorithm> algorithm = GeneticAlgorithmFactory::build(m_options, 100);
+	BOOST_REQUIRE(algorithm != nullptr);
+
+	auto gewepAlgorithm = dynamic_cast<GenerationalElitistWithExclusivePools*>(algorithm.get());
+	BOOST_REQUIRE(gewepAlgorithm != nullptr);
+	BOOST_TEST(gewepAlgorithm->options().percentGenesToRandomise == 1.0 / 125.0);
+	BOOST_TEST(gewepAlgorithm->options().percentGenesToAddOrDelete == 1.0 / 125.0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(FitnessMetricFactoryTest)
+
+BOOST_FIXTURE_TEST_CASE(build_should_create_metric_of_the_right_type, FitnessMetricFactoryFixture)
+{
+	m_options.metric = MetricChoice::RelativeCodeSize;
+	m_options.metricAggregator = MetricAggregatorChoice::Sum;
+	unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
+	BOOST_REQUIRE(metric != nullptr);
+
+	auto sumMetric = dynamic_cast<FitnessMetricSum*>(metric.get());
+	BOOST_REQUIRE(sumMetric != nullptr);
+	BOOST_REQUIRE(sumMetric->metrics().size() == 1);
+	BOOST_REQUIRE(sumMetric->metrics()[0] != nullptr);
+
+	auto relativeProgramSizeMetric = dynamic_cast<RelativeProgramSize*>(sumMetric->metrics()[0].get());
+	BOOST_REQUIRE(relativeProgramSizeMetric != nullptr);
+	BOOST_TEST(toString(relativeProgramSizeMetric->program()) == toString(m_programs[0]));
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_respect_chromosome_repetitions_option, FitnessMetricFactoryFixture)
+{
+	m_options.metric = MetricChoice::CodeSize;
+	m_options.metricAggregator = MetricAggregatorChoice::Average;
+	m_options.chromosomeRepetitions = 5;
+	unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
+	BOOST_REQUIRE(metric != nullptr);
+
+	auto averageMetric = dynamic_cast<FitnessMetricAverage*>(metric.get());
+	BOOST_REQUIRE(averageMetric != nullptr);
+	BOOST_REQUIRE(averageMetric->metrics().size() == 1);
+	BOOST_REQUIRE(averageMetric->metrics()[0] != nullptr);
+
+	auto programSizeMetric = dynamic_cast<ProgramSize*>(averageMetric->metrics()[0].get());
+	BOOST_REQUIRE(programSizeMetric != nullptr);
+	BOOST_TEST(programSizeMetric->repetitionCount() == m_options.chromosomeRepetitions);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_set_relative_metric_scale, FitnessMetricFactoryFixture)
+{
+	m_options.metric = MetricChoice::RelativeCodeSize;
+	m_options.metricAggregator = MetricAggregatorChoice::Average;
+	m_options.relativeMetricScale = 10;
+	unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
+	BOOST_REQUIRE(metric != nullptr);
+
+	auto averageMetric = dynamic_cast<FitnessMetricAverage*>(metric.get());
+	BOOST_REQUIRE(averageMetric != nullptr);
+	BOOST_REQUIRE(averageMetric->metrics().size() == 1);
+	BOOST_REQUIRE(averageMetric->metrics()[0] != nullptr);
+
+	auto relativeProgramSizeMetric = dynamic_cast<RelativeProgramSize*>(averageMetric->metrics()[0].get());
+	BOOST_REQUIRE(relativeProgramSizeMetric != nullptr);
+	BOOST_TEST(relativeProgramSizeMetric->fixedPointPrecision() == m_options.relativeMetricScale);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_create_metric_for_each_input_program, FitnessMetricFactoryFixture)
+{
+	unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(
+		m_options,
+		m_programs,
+		vector<shared_ptr<ProgramCache>>(m_programs.size(), nullptr),
+		m_weights
+	);
+	BOOST_REQUIRE(metric != nullptr);
+
+	auto combinedMetric = dynamic_cast<FitnessMetricCombination*>(metric.get());
+	BOOST_REQUIRE(combinedMetric != nullptr);
+	BOOST_REQUIRE(combinedMetric->metrics().size() == m_programs.size());
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_pass_program_caches_to_metrics, FitnessMetricFactoryFixture)
+{
+	assert(m_programs.size() == 3);
+	vector<shared_ptr<ProgramCache>> caches = {
+		make_shared<ProgramCache>(m_programs[0]),
+		make_shared<ProgramCache>(m_programs[1]),
+		make_shared<ProgramCache>(m_programs[2]),
+	};
+
+	m_options.metric = MetricChoice::RelativeCodeSize;
+	unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, m_programs, caches, m_weights);
+	BOOST_REQUIRE(metric != nullptr);
+
+	auto combinedMetric = dynamic_cast<FitnessMetricCombination*>(metric.get());
+	BOOST_REQUIRE(combinedMetric != nullptr);
+	BOOST_REQUIRE(combinedMetric->metrics().size() == caches.size());
+
+	for (size_t i = 0; i < caches.size(); ++i)
+	{
+		auto programBasedMetric = dynamic_cast<ProgramBasedMetric*>(combinedMetric->metrics()[i].get());
+		BOOST_REQUIRE(programBasedMetric != nullptr);
+		BOOST_TEST(programBasedMetric->programCache() == caches[i].get());
+	}
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(PopulationFactoryTest)
+
+BOOST_FIXTURE_TEST_CASE(build_should_create_an_empty_population_if_no_specific_options_given, PoulationFactoryFixture)
+{
+	m_options.population = {};
+	m_options.randomPopulation = {};
+	m_options.populationFromFile = {};
+	BOOST_TEST(
+		PopulationFactory::build(m_options, m_fitnessMetric) ==
+		Population(m_fitnessMetric, vector<Chromosome>{})
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_respect_population_option, PoulationFactoryFixture)
+{
+	m_options.population = {"a", "afc", "xadd"};
+	BOOST_TEST(
+		PopulationFactory::build(m_options, m_fitnessMetric) ==
+		Population(m_fitnessMetric, {Chromosome("a"), Chromosome("afc"), Chromosome("xadd")})
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_respect_random_population_option, PoulationFactoryFixture)
+{
+	m_options.randomPopulation = {5, 3, 2};
+	m_options.minChromosomeLength = 5;
+	m_options.maxChromosomeLength = 10;
+
+	auto population = PopulationFactory::build(m_options, m_fitnessMetric);
+
+	BOOST_TEST(population.individuals().size() == 10);
+	BOOST_TEST(all_of(
+		population.individuals().begin(),
+		population.individuals().end(),
+		[](auto const& individual){ return 5 <= individual.chromosome.length() && individual.chromosome.length() <= 10; }
+	));
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_respect_population_from_file_option, PoulationFactoryFixture)
+{
+	map<string, vector<string>> fileContent = {
+		{"a.txt", {"a", "fff", "", "jxccLTa"}},
+		{"b.txt", {}},
+		{"c.txt", {""}},
+		{"d.txt", {"c", "T"}},
+	};
+
+	TemporaryDirectory tempDir;
+	for (auto const& [fileName, chromosomes]: fileContent)
+	{
+		ofstream tmpFile((tempDir.path() / fileName).string());
+		for (auto const& chromosome: chromosomes)
+			tmpFile << chromosome << endl;
+
+		m_options.populationFromFile.push_back((tempDir.path() / fileName).string());
+	}
+
+	BOOST_TEST(
+		PopulationFactory::build(m_options, m_fitnessMetric) ==
+		Population(m_fitnessMetric, {
+			Chromosome("a"),
+			Chromosome("fff"),
+			Chromosome(""),
+			Chromosome("jxccLTa"),
+			Chromosome(""),
+			Chromosome("c"),
+			Chromosome("T"),
+		})
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_throw_FileOpenError_if_population_file_does_not_exist, PoulationFactoryFixture)
+{
+	m_options.populationFromFile = {"a-file-that-does-not-exist.abcdefgh"};
+	assert(!fs::exists(m_options.populationFromFile[0]));
+
+	BOOST_CHECK_THROW(PopulationFactory::build(m_options, m_fitnessMetric), FileOpenError);
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_combine_populations_from_all_sources, PoulationFactoryFixture)
+{
+	TemporaryDirectory tempDir;
+	{
+		ofstream tmpFile((tempDir.path() / "population.txt").string());
+		tmpFile << "axc" << endl << "fcL" << endl;
+	}
+
+	m_options.population = {"axc", "fcL"};
+	m_options.randomPopulation = {2};
+	m_options.populationFromFile = {(tempDir.path() / "population.txt").string()};
+	m_options.minChromosomeLength = 3;
+	m_options.maxChromosomeLength = 3;
+
+	auto population = PopulationFactory::build(m_options, m_fitnessMetric);
+
+	auto begin = population.individuals().begin();
+	auto end = population.individuals().end();
+	BOOST_TEST(population.individuals().size() == 6);
+	BOOST_TEST(all_of(begin, end, [](auto const& individual){ return individual.chromosome.length() == 3; }));
+	BOOST_TEST(count(begin, end, Individual(Chromosome("axc"), *m_fitnessMetric)) >= 2);
+	BOOST_TEST(count(begin, end, Individual(Chromosome("fcL"), *m_fitnessMetric)) >= 2);
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(ProgramCacheFactoryTest)
+
+BOOST_FIXTURE_TEST_CASE(build_should_create_cache_for_each_input_program_if_cache_enabled, FixtureWithPrograms)
+{
+	ProgramCacheFactory::Options options{/* programCacheEnabled = */ true};
+	vector<shared_ptr<ProgramCache>> caches = ProgramCacheFactory::build(options, m_programs);
+	assert(m_programs.size() >= 2 && "There must be at least 2 programs for this test to be meaningful");
+
+	BOOST_TEST(caches.size() == m_programs.size());
+	for (size_t i = 0; i < m_programs.size(); ++i)
+	{
+		BOOST_REQUIRE(caches[i] != nullptr);
+		BOOST_TEST(toString(caches[i]->program()) == toString(m_programs[i]));
+	}
+}
+
+BOOST_FIXTURE_TEST_CASE(build_should_return_nullptr_for_each_input_program_if_cache_disabled, FixtureWithPrograms)
+{
+	ProgramCacheFactory::Options options{/* programCacheEnabled = */ false};
+	vector<shared_ptr<ProgramCache>> caches = ProgramCacheFactory::build(options, m_programs);
+	assert(m_programs.size() >= 2 && "There must be at least 2 programs for this test to be meaningful");
+
+	BOOST_TEST(caches.size() == m_programs.size());
+	for (size_t i = 0; i < m_programs.size(); ++i)
+		BOOST_TEST(caches[i] == nullptr);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(ProgramFactoryTest)
+
+BOOST_AUTO_TEST_CASE(build_should_load_programs_from_files)
+{
+	TemporaryDirectory tempDir;
+	vector<string> sources{"{}", "{{}}", "{{{}}}"};
+	ProgramFactory::Options options{
+		/* inputFiles = */ {
+			(tempDir.path() / "program1.yul").string(),
+			(tempDir.path() / "program2.yul").string(),
+			(tempDir.path() / "program3.yul").string(),
+		},
+		/* prefix = */ "",
+	};
+
+	for (size_t i = 0; i < sources.size(); ++i)
+	{
+		ofstream tmpFile(options.inputFiles[i]);
+		tmpFile << sources[i] << endl;
+	}
+
+	vector<Program> programs = ProgramFactory::build(options);
+
+	BOOST_TEST(programs.size() == sources.size());
+	for (size_t i = 0; i < sources.size(); ++i)
+	{
+		CharStream sourceStream(sources[i], options.inputFiles[i]);
+		BOOST_TEST(toString(programs[i]) == toString(get<Program>(Program::load(sourceStream))));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(build_should_apply_prefix)
+{
+	TemporaryDirectory tempDir;
+	ProgramFactory::Options options{
+		/* inputFiles = */ {(tempDir.path() / "program1.yul").string()},
+		/* prefix = */ "f",
+	};
+
+	CharStream nestedSource("{{{let x:= 1}}}", "");
+	Program nestedProgram = get<Program>(Program::load(nestedSource));
+	Program flatProgram = get<Program>(Program::load(nestedSource));
+	flatProgram.optimise(Chromosome::genesToSteps("f"));
+	assert(toString(nestedProgram) != toString(flatProgram));
+
+	{
+		ofstream tmpFile(options.inputFiles[0]);
+		tmpFile << nestedSource.source() << endl;
+	}
+
+	vector<Program> programs = ProgramFactory::build(options);
+
+	BOOST_TEST(programs.size() == 1);
+	BOOST_TEST(toString(programs[0]) == toString(flatProgram));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}
diff --git a/compiler/tools/CMakeLists.txt b/compiler/tools/CMakeLists.txt
deleted file mode 100644
index b442ba96..00000000
--- a/compiler/tools/CMakeLists.txt
+++ /dev/null
@@ -1,51 +0,0 @@
-add_executable(solidity-upgrade
-    solidityUpgrade/main.cpp
-    solidityUpgrade/UpgradeChange.h
-    solidityUpgrade/UpgradeChange.cpp
-    solidityUpgrade/UpgradeSuite.h
-    solidityUpgrade/Upgrade050.cpp
-    solidityUpgrade/Upgrade060.cpp
-    solidityUpgrade/Upgrade070.cpp
-    solidityUpgrade/SourceTransform.h
-    solidityUpgrade/SourceUpgrade.cpp
-)
-target_link_libraries(solidity-upgrade PRIVATE solidity Boost::boost Boost::program_options Boost::system)
-
-include(GNUInstallDirs)
-install(TARGETS solidity-upgrade DESTINATION "${CMAKE_INSTALL_BINDIR}")
-
-set(libphaser_sources
-	yulPhaser/Common.h
-	yulPhaser/Common.cpp
-	yulPhaser/AlgorithmRunner.h
-	yulPhaser/AlgorithmRunner.cpp
-	yulPhaser/Phaser.h
-	yulPhaser/Phaser.cpp
-	yulPhaser/GeneticAlgorithms.h
-	yulPhaser/GeneticAlgorithms.cpp
-	yulPhaser/Population.h
-	yulPhaser/Population.cpp
-	yulPhaser/FitnessMetrics.h
-	yulPhaser/FitnessMetrics.cpp
-	yulPhaser/Chromosome.h
-	yulPhaser/Chromosome.cpp
-	yulPhaser/Mutations.h
-	yulPhaser/Mutations.cpp
-	yulPhaser/PairSelections.h
-	yulPhaser/PairSelections.cpp
-	yulPhaser/Selections.h
-	yulPhaser/Selections.cpp
-	yulPhaser/ProgramCache.h
-	yulPhaser/ProgramCache.cpp
-	yulPhaser/Program.h
-	yulPhaser/Program.cpp
-	yulPhaser/SimulationRNG.h
-	yulPhaser/SimulationRNG.cpp
-)
-add_library(phaser ${libphaser_sources})
-target_link_libraries(phaser PUBLIC solidity Boost::boost Boost::program_options)
-
-add_executable(yul-phaser yulPhaser/main.cpp)
-target_link_libraries(yul-phaser PRIVATE phaser)
-
-install(TARGETS yul-phaser DESTINATION "${CMAKE_INSTALL_BINDIR}")
diff --git a/compiler/tools/solidityUpgrade/SourceTransform.h b/compiler/tools/solidityUpgrade/SourceTransform.h
deleted file mode 100644
index 04d12829..00000000
--- a/compiler/tools/solidityUpgrade/SourceTransform.h
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <libsolidity/analysis/OverrideChecker.h>
-
-#include <libsolidity/ast/AST.h>
-
-#include <liblangutil/CharStreamProvider.h>
-#include <liblangutil/Scanner.h>
-
-#include <sstream>
-#include <regex>
-
-namespace solidity::tools
-{
-
-/**
- * Helper for displaying location during asserts
- */
-class LocationHelper
-{
-	std::stringstream m_stream;
-
-public:
-
-	template <typename T>
-	LocationHelper& operator<<(T const& data)
-	{
-		m_stream << data;
-		return *this;
-	}
-
-	operator std::string() { return m_stream.str(); }
-};
-
-class SourceTextRetriever
-{
-public:
-	explicit SourceTextRetriever(langutil::CharStreamProvider const& _charStreamProvider):
-		m_charStreamProvider(_charStreamProvider) {}
-	std::string text(langutil::SourceLocation const& _location) const
-	{
-		solAssert(_location.hasText(), "");
-		return std::string{m_charStreamProvider.charStream(*_location.sourceName).text(_location)};
-	}
-protected:
-	langutil::CharStreamProvider const& m_charStreamProvider;
-};
-
-/**
- * Helper that provides functions which analyze certain source locations
- * on a textual base. They utilize regular expression to search for
- * keywords or to determine formatting.
- */
-class SourceAnalysis: public SourceTextRetriever
-{
-public:
-	using SourceTextRetriever::SourceTextRetriever;
-
-	bool isMultilineKeyword(
-		langutil::SourceLocation const& _location,
-		std::string const& _keyword
-	) const
-	{
-		return regex_search(
-			text(_location),
-			std::regex{"(\\b" + _keyword + "\\b\\n|\\r|\\r\\n)"}
-		);
-	}
-
-	bool hasMutabilityKeyword(langutil::SourceLocation const& _location) const
-	{
-		return regex_search(
-			text(_location),
-			std::regex{"(\\b(pure|view|nonpayable|payable)\\b)"}
-		);
-	}
-
-	bool hasVirtualKeyword(langutil::SourceLocation const& _location) const
-	{
-		return regex_search(text(_location), std::regex{"(\\b(virtual)\\b)"});
-	}
-
-	bool hasVisibilityKeyword(langutil::SourceLocation const& _location) const
-	{
-		return regex_search(text(_location), std::regex{"\\bpublic\\b"});
-	}
-};
-
-/**
- * Helper that provides functions which can analyse declarations and
- * generate source snippets based on the information retrieved.
- */
-class SourceGeneration
-{
-public:
-	using CompareFunction = frontend::OverrideChecker::CompareByID;
-	using Contracts = std::set<frontend::ContractDefinition const*, CompareFunction>;
-
-	/// Generates an `override` declaration for single overrides
-	/// or `override(...)` with contract list for multiple overrides.
-	static std::string functionOverride(Contracts const& _contracts)
-	{
-		if (_contracts.size() <= 1)
-			return "override";
-
-		std::string overrideList;
-		for (auto inheritedContract: _contracts)
-			overrideList += inheritedContract->name() + ",";
-
-		// Note: Can create incorrect replacements
-		return "override(" + overrideList.substr(0, overrideList.size() - 1) + ")";
-	}
-};
-
-/**
- * Helper that provides functions which apply changes to Solidity source code
- * on a textual base. In general, these utilize regular expressions applied
- * to the given source location.
- */
-class SourceTransform: public SourceTextRetriever
-{
-public:
-	using SourceTextRetriever::SourceTextRetriever;
-
-	/// Searches for the keyword given and prepends the expression.
-	/// E.g. `function f() view;` -> `function f() public view;`
-	std::string insertBeforeKeyword(
-		langutil::SourceLocation const& _location,
-		std::string const& _keyword,
-		std::string const& _expression
-	) const
-	{
-		auto _regex = std::regex{"(\\b" + _keyword + "\\b)"};
-		if (regex_search(text(_location), _regex))
-			return regex_replace(
-				text(_location),
-				_regex,
-				_expression + " " + _keyword,
-				std::regex_constants::format_first_only
-			);
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-	}
-
-	/// Searches for the keyword given and appends the expression.
-	/// E.g. `function f() public {}` -> `function f() public override {}`
-	std::string insertAfterKeyword(
-		langutil::SourceLocation const& _location,
-		std::string const& _keyword,
-		std::string const& _expression
-	) const
-	{
-		bool isMultiline = SourceAnalysis{m_charStreamProvider}.isMultilineKeyword(_location, _keyword);
-		std::string toAppend = isMultiline ? ("\n        " + _expression) : (" " + _expression);
-		std::regex keyword{"(\\b" + _keyword + "\\b)"};
-
-		if (regex_search(text(_location), keyword))
-			return regex_replace(text(_location), keyword, _keyword + toAppend);
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-
-	}
-
-	/// Searches for the first right parenthesis and appends the expression
-	/// given.
-	/// E.g. `function f() {}` -> `function f() public {}`
-	std::string insertAfterRightParenthesis(
-		langutil::SourceLocation const& _location,
-		std::string const& _expression
-	) const
-	{
-		auto _regex = std::regex{"(\\))"};
-		if (regex_search(text(_location), _regex))
-			return regex_replace(
-				text(_location),
-				std::regex{"(\\))"},
-				") " + _expression
-			);
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-	}
-
-	/// Searches for the `function` keyword and its identifier and replaces
-	/// both by the expression given.
-	/// E.g. `function Storage() {}` -> `constructor() {}`
-	std::string replaceFunctionName(
-		langutil::SourceLocation const& _location,
-		std::string const& _name,
-		std::string const& _expression
-	) const
-	{
-		auto _regex = std::regex{ "(\\bfunction\\s*" + _name + "\\b)"};
-		if (regex_search(text(_location), _regex))
-			return regex_replace(
-				text(_location),
-				_regex,
-				_expression
-			);
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-	}
-
-	std::string gasUpdate(langutil::SourceLocation const& _location) const
-	{
-		// dot, "gas", any number of whitespaces, left bracket
-		std::regex gasReg{"\\.gas\\s*\\("};
-
-		if (regex_search(text(_location), gasReg))
-		{
-			std::string out = regex_replace(
-				text(_location),
-				gasReg,
-				"{gas: ",
-				std::regex_constants::format_first_only
-			);
-			return regex_replace(out, std::regex{"\\)$"}, "}");
-		}
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-	}
-
-	std::string valueUpdate(langutil::SourceLocation const& _location) const
-	{
-		// dot, "value", any number of whitespaces, left bracket
-		std::regex valueReg{"\\.value\\s*\\("};
-
-		if (regex_search(text(_location), valueReg))
-		{
-			std::string out = regex_replace(
-					text(_location),
-					valueReg,
-					"{value: ",
-					std::regex_constants::format_first_only
-			);
-			return regex_replace(out, std::regex{"\\)$"}, "}");
-		}
-		else
-			solAssert(
-				false,
-				LocationHelper() << "Could not fix: " << text(_location) << " at " << _location <<
-				"\nNeeds to be fixed manually."
-			);
-
-		return "";
-	}
-
-	std::string nowUpdate(langutil::SourceLocation const& _location) const
-	{
-		return regex_replace(text(_location), std::regex{"now"}, "block.timestamp");
-	}
-
-	std::string removeVisibility(langutil::SourceLocation const& _location) const
-	{
-		std::string replacement = text(_location);
-		for (auto const& replace: {"public ", "public", "internal ", "internal", "external ", "external"})
-			replacement = regex_replace(replacement, std::regex{replace}, "");
-		return replacement;
-	}
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/SourceUpgrade.cpp b/compiler/tools/solidityUpgrade/SourceUpgrade.cpp
deleted file mode 100644
index b98b050d..00000000
--- a/compiler/tools/solidityUpgrade/SourceUpgrade.cpp
+++ /dev/null
@@ -1,541 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#include <tools/solidityUpgrade/SourceUpgrade.h>
-
-#include <liblangutil/Exceptions.h>
-#include <liblangutil/SourceReferenceFormatter.h>
-
-#include <libsolidity/ast/AST.h>
-
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/operations.hpp>
-#include <boost/algorithm/string.hpp>
-
-#include <fstream>
-
-#ifdef _WIN32 // windows
-	#include <io.h>
-	#define isatty _isatty
-	#define fileno _fileno
-#else // unix
-	#include <unistd.h>
-#endif
-
-
-namespace po = boost::program_options;
-namespace fs = boost::filesystem;
-
-using namespace solidity;
-using namespace solidity::langutil;
-using namespace solidity::tools;
-using namespace solidity::util;
-using namespace solidity::frontend;
-using namespace std;
-
-
-static string const g_argHelp = "help";
-static string const g_argVersion = "version";
-static string const g_argInputFile = "input-file";
-static string const g_argModules = "modules";
-static string const g_argDryRun = "dry-run";
-static string const g_argUnsafe = "unsafe";
-static string const g_argVerbose = "verbose";
-static string const g_argIgnoreMissingFiles = "ignore-missing";
-static string const g_argAllowPaths = "allow-paths";
-
-namespace
-{
-
-ostream& out()
-{
-	return cout;
-}
-
-AnsiColorized log()
-{
-	return AnsiColorized(cout, true, {});
-}
-
-AnsiColorized success()
-{
-	return AnsiColorized(cout, true, {formatting::CYAN});
-}
-
-AnsiColorized warning()
-{
-	return AnsiColorized(cout, true, {formatting::YELLOW});
-}
-
-AnsiColorized error()
-{
-	return AnsiColorized(cout, true, {formatting::MAGENTA});
-}
-
-void logVersion()
-{
-	/// TODO Replace by variable that can be set during build.
-	out() << "0.1.0" << endl;
-}
-
-void logProgress()
-{
-	out() << ".";
-	out().flush();
-}
-
-}
-
-bool SourceUpgrade::parseArguments(int _argc, char** _argv)
-{
-	po::options_description desc(R"(solidity-upgrade, the Solidity upgrade assistant.
-
-The solidity-upgrade tool can help upgrade smart contracts to breaking language features.
-
-It does not support all breaking changes for each version, but will hopefully assist
-upgrading your contracts to the desired Solidity version.
-
-solidity-upgrade is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY. Please be careful when running upgrades on
-your contracts.
-
-Usage: solidity-upgrade [options] contract.sol
-
-Allowed options)",
-		po::options_description::m_default_line_length,
-		po::options_description::m_default_line_length - 23
-	);
-	desc.add_options()
-		(g_argHelp.c_str(), "Show help message and exit.")
-		(g_argVersion.c_str(), "Show version and exit.")
-		(
-			g_argAllowPaths.c_str(),
-			po::value<string>()->value_name("path(s)"),
-			"Allow a given path for imports. A list of paths can be supplied by separating them "
-			"with a comma."
-		)
-		(g_argIgnoreMissingFiles.c_str(), "Ignore missing files.")
-		(
-			g_argModules.c_str(),
-			po::value<string>()->value_name("module(s)"),
-			"Only activate a specific upgrade module. A list of "
-			"modules can be supplied by separating them with a comma."
-		)
-		(g_argDryRun.c_str(), "Apply changes in-memory only and don't write to input file.")
-		(g_argVerbose.c_str(), "Print logs, errors and changes. Shortens output of upgrade patches.")
-		(g_argUnsafe.c_str(), "Accept *unsafe* changes.");
-
-
-	po::options_description allOptions = desc;
-	allOptions.add_options()("input-file", po::value<vector<string>>(), "input file");
-
-	po::positional_options_description filesPositions;
-	filesPositions.add("input-file", -1);
-
-	// parse the compiler arguments
-	try
-	{
-		po::command_line_parser cmdLineParser(_argc, _argv);
-		cmdLineParser.style(
-			po::command_line_style::default_style & (~po::command_line_style::allow_guessing)
-		);
-		cmdLineParser.options(allOptions).positional(filesPositions);
-		po::store(cmdLineParser.run(), m_args);
-	}
-	catch (po::error const& _exception)
-	{
-		error() << _exception.what() << endl;
-		return false;
-	}
-
-	if (m_args.count(g_argHelp) || (isatty(fileno(stdin)) && _argc == 1))
-	{
-		out() << endl;
-		log() << desc;
-		return false;
-	}
-
-	if (m_args.count(g_argVersion))
-	{
-		logVersion();
-		return false;
-	}
-
-	if (m_args.count(g_argModules))
-	{
-		vector<string> moduleArgs;
-		auto modules = boost::split(
-			moduleArgs, m_args[g_argModules].as<string>(), boost::is_any_of(",")
-		);
-
-		/// All modules are activated by default. Clear them before activating single ones.
-		m_suite.deactivateModules();
-
-		for (string const& module: modules)
-		{
-			if (module == "constructor")
-				m_suite.activateModule(Module::ConstructorKeyword);
-			else if (module == "visibility")
-				m_suite.activateModule(Module::VisibilitySpecifier);
-			else if (module == "abstract")
-				m_suite.activateModule(Module::AbstractContract);
-			else if (module == "override")
-				m_suite.activateModule(Module::OverridingFunction);
-			else if (module == "virtual")
-				m_suite.activateModule(Module::VirtualFunction);
-			else if (module == "dotsyntax")
-				m_suite.activateModule(Module::DotSyntax);
-			else if (module == "now")
-				m_suite.activateModule(Module::NowKeyword);
-			else if (module == "constructor-visibility")
-				m_suite.activateModule(Module::ConstrutorVisibility);
-			else
-			{
-				error() << "Unknown upgrade module \"" + module + "\"" << endl;
-				return false;
-			}
-		}
-	}
-
-	/// TODO Share with solc commandline interface.
-	if (m_args.count(g_argAllowPaths))
-	{
-		vector<string> paths;
-		auto allowedPaths = boost::split(
-			paths, m_args[g_argAllowPaths].as<string>(), boost::is_any_of(",")
-		);
-		for (string const& path: allowedPaths)
-		{
-			auto filesystem_path = boost::filesystem::path(path);
-			/// If the given path had a trailing slash, the Boost filesystem
-			/// path will have it's last component set to '.'. This breaks
-			/// path comparison in later parts of the code, so we need to strip
-			/// it.
-			if (filesystem_path.filename() == ".")
-				filesystem_path.remove_filename();
-			m_allowedDirectories.push_back(filesystem_path);
-		}
-	}
-
-
-	return true;
-}
-
-void SourceUpgrade::printPrologue()
-{
-	out() << endl;
-	out() << endl;
-
-	log() <<
-		"solidity-upgrade does not support all breaking changes for each version." <<
-		endl <<
-		"Please run `solidity-upgrade --help` and get a list of implemented upgrades." <<
-		endl <<
-		endl;
-
-	log() <<
-		"Running analysis (and upgrade) on given source files." <<
-		endl;
-}
-
-bool SourceUpgrade::processInput()
-{
-	if (!readInputFiles())
-		return false;
-
-	resetCompiler(fileReader());
-
-	tryCompile();
-	runUpgrade();
-
-	printStatistics();
-
-	return true;
-}
-
-void SourceUpgrade::tryCompile() const
-{
-	bool verbose = m_args.count(g_argVerbose);
-
-	if (verbose)
-		log() << "Running compilation phases." << endl << endl;
-	else
-		logProgress();
-
-	try
-	{
-		if (m_compiler->parse())
-		{
-			if (m_compiler->analyze())
-				m_compiler->compile();
-			else
-				if (verbose)
-				{
-					error() <<
-						"Compilation errors that solidity-upgrade may resolve occurred." <<
-						endl <<
-						endl;
-
-					printErrors();
-				}
-		}
-		else
-			if (verbose)
-			{
-				error() <<
-					"Compilation errors that solidity-upgrade cannot resolve occurred." <<
-					endl <<
-					endl;
-
-				printErrors();
-			}
-	}
-	catch (Exception const& _exception)
-	{
-		error() << "Exception during compilation: " << boost::diagnostic_information(_exception) << endl;
-	}
-	catch (std::exception const& _exception)
-	{
-		error() << "Exception during compilation: " << boost::diagnostic_information(_exception) << endl;
-	}
-	catch (...)
-	{
-		error() << "Unknown exception during compilation: " << boost::current_exception_diagnostic_information() << endl;
-	}
-}
-
-void SourceUpgrade::runUpgrade()
-{
-	bool recompile = true;
-
-	while (recompile && !m_compiler->errors().empty())
-	{
-		for (auto& sourceCode: m_sourceCodes)
-		{
-			recompile = analyzeAndUpgrade(sourceCode);
-			if (recompile)
-				break;
-		}
-
-		if (recompile)
-		{
-			m_suite.reset();
-			resetCompiler();
-			tryCompile();
-		}
-	}
-}
-
-bool SourceUpgrade::analyzeAndUpgrade(pair<string, string> const& _sourceCode)
-{
-	bool applyUnsafe = m_args.count(g_argUnsafe);
-	bool verbose = m_args.count(g_argVerbose);
-
-	if (verbose)
-		log() << "Analyzing and upgrading " << _sourceCode.first << "." << endl;
-
-	if (m_compiler->state() >= CompilerStack::State::AnalysisPerformed)
-		m_suite.analyze(*m_compiler, m_compiler->ast(_sourceCode.first));
-
-	if (!m_suite.changes().empty())
-	{
-		auto& change = m_suite.changes().front();
-
-		if (verbose)
-			change.log(*m_compiler, true);
-
-		if (change.level() == UpgradeChange::Level::Safe)
-		{
-			applyChange(_sourceCode, change);
-			return true;
-		}
-		else if (change.level() == UpgradeChange::Level::Unsafe)
-		{
-			if (applyUnsafe)
-			{
-				applyChange(_sourceCode, change);
-				return true;
-			}
-		}
-	}
-
-	return false;
-}
-
-void SourceUpgrade::applyChange(
-	pair<string, string> const& _sourceCode,
-	UpgradeChange& _change
-)
-{
-	bool dryRun = m_args.count(g_argDryRun);
-	bool verbose = m_args.count(g_argVerbose);
-
-	if (verbose)
-	{
-		log() << "Applying change to " << _sourceCode.first << endl << endl;
-		log() << _change.patch();
-	}
-
-	m_sourceCodes[_sourceCode.first] = _change.apply(_sourceCode.second);
-
-	if (!dryRun)
-		writeInputFile(_sourceCode.first, m_sourceCodes[_sourceCode.first]);
-}
-
-void SourceUpgrade::printErrors() const
-{
-	langutil::SourceReferenceFormatter formatter{cout, *m_compiler, true, false};
-
-	for (auto const& error: m_compiler->errors())
-		if (error->type() != langutil::Error::Type::Warning)
-			formatter.printErrorInformation(*error);
-}
-
-void SourceUpgrade::printStatistics() const
-{
-	out() << endl;
-	out() << endl;
-	out() << "After upgrade:" << endl;
-	out() << endl;
-	error() << "Found " << m_compiler->errors().size() << " errors." << endl;
-	success() << "Found " << m_suite.changes().size() << " upgrades." << endl;
-}
-
-bool SourceUpgrade::readInputFiles()
-{
-	bool ignoreMissing = m_args.count(g_argIgnoreMissingFiles);
-
-	/// TODO Share with solc commandline interface.
-	if (m_args.count(g_argInputFile))
-		for (string path: m_args[g_argInputFile].as<vector<string>>())
-		{
-			boost::filesystem::path infile = path;
-			if (!boost::filesystem::exists(infile))
-			{
-				if (!ignoreMissing)
-				{
-					error() << infile << " is not found." << endl;
-					return false;
-				}
-				else
-					error() << infile << " is not found. Skipping." << endl;
-
-				continue;
-			}
-
-			if (!boost::filesystem::is_regular_file(infile))
-			{
-				if (!ignoreMissing)
-				{
-					error() << infile << " is not a valid file." << endl;
-					return false;
-				}
-				else
-					error() << infile << " is not a valid file. Skipping." << endl;
-
-				continue;
-			}
-
-			m_sourceCodes[infile.generic_string()] = readFileAsString(infile);
-		}
-
-	if (m_sourceCodes.size() == 0)
-	{
-		warning() << "No input files given." << endl;
-		return false;
-	}
-
-	return true;
-}
-
-bool SourceUpgrade::writeInputFile(string const& _path, string const& _source)
-{
-	bool verbose = m_args.count(g_argVerbose);
-
-	if (verbose)
-	{
-		out() << endl;
-		log() << "Writing to input file " << _path << "." << endl;
-	}
-
-	ofstream file(_path, ios::trunc);
-	file << _source;
-
-	return true;
-}
-
-ReadCallback::Callback SourceUpgrade::fileReader()
-{
-	/// TODO Share with solc commandline interface.
-	ReadCallback::Callback fileReader = [this](string const&, string const& _path)
-	{
-		try
-		{
-			boost::filesystem::path path = _path;
-			boost::filesystem::path canonicalPath = boost::filesystem::weakly_canonical(path);
-			bool isAllowed = false;
-			for (auto const& allowedDir: m_allowedDirectories)
-			{
-				// If dir is a prefix of boostPath, we are fine.
-				if (
-					std::distance(allowedDir.begin(), allowedDir.end()) <= std::distance(canonicalPath.begin(), canonicalPath.end()) &&
-					std::equal(allowedDir.begin(), allowedDir.end(), canonicalPath.begin())
-				)
-				{
-					isAllowed = true;
-					break;
-				}
-			}
-			if (!isAllowed)
-				return ReadCallback::Result{false, "File outside of allowed directories."};
-
-			if (!boost::filesystem::exists(canonicalPath))
-				return ReadCallback::Result{false, "File not found."};
-
-			if (!boost::filesystem::is_regular_file(canonicalPath))
-				return ReadCallback::Result{false, "Not a valid file."};
-
-			string contents = readFileAsString(canonicalPath);
-			m_sourceCodes[path.generic_string()] = contents;
-			return ReadCallback::Result{true, contents};
-		}
-		catch (Exception const& _exception)
-		{
-			return ReadCallback::Result{false, "Exception in read callback: " + boost::diagnostic_information(_exception)};
-		}
-		catch (...)
-		{
-			return ReadCallback::Result{false, "Unknown exception in read callback: " + boost::current_exception_diagnostic_information()};
-		}
-	};
-
-	return fileReader;
-}
-
-void SourceUpgrade::resetCompiler()
-{
-	m_compiler->reset();
-	m_compiler->setSources(m_sourceCodes);
-	m_compiler->setParserErrorRecovery(true);
-}
-
-void SourceUpgrade::resetCompiler(ReadCallback::Callback const& _callback)
-{
-	m_compiler = std::make_unique<CompilerStack>(_callback);
-	m_compiler->setSources(m_sourceCodes);
-	m_compiler->setParserErrorRecovery(true);
-}
diff --git a/compiler/tools/solidityUpgrade/SourceUpgrade.h b/compiler/tools/solidityUpgrade/SourceUpgrade.h
deleted file mode 100644
index f3b5d357..00000000
--- a/compiler/tools/solidityUpgrade/SourceUpgrade.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#pragma once
-
-#include <tools/solidityUpgrade/UpgradeChange.h>
-#include <tools/solidityUpgrade/Upgrade050.h>
-#include <tools/solidityUpgrade/Upgrade060.h>
-#include <tools/solidityUpgrade/Upgrade070.h>
-
-#include <libsolidity/interface/CompilerStack.h>
-#include <libsolidity/interface/DebugSettings.h>
-#include <liblangutil/EVMVersion.h>
-
-#include <boost/program_options.hpp>
-#include <boost/filesystem/path.hpp>
-
-#include <memory>
-
-namespace solidity::tools
-{
-
-/**
- * The Solidity source upgrade tool. It supplies a command line interface
- * and connects this to a compiler stack that the upgrade logic is facilitated
- * with.
- */
-class SourceUpgrade
-{
-public:
-	/// Parse command line arguments and return false in case of a failure.
-	bool parseArguments(int _argc, char** _argv);
-	/// Prints additional information on the upgrade tool.
-	void printPrologue();
-	/// Parse / compile files and runs upgrade analysis on them.
-	bool processInput();
-
-private:
-	/// All available upgrade modules
-	enum class Module
-	{
-		ConstructorKeyword,
-		VisibilitySpecifier,
-		AbstractContract,
-		OverridingFunction,
-		VirtualFunction,
-		DotSyntax,
-		NowKeyword,
-		ConstrutorVisibility
-	};
-
-	/// Upgrade suite that hosts all available modules.
-	class Suite: public UpgradeSuite
-	{
-	public:
-		void analyze(langutil::CharStreamProvider const& _charStreamProvider, frontend::SourceUnit const& _sourceUnit)
-		{
-			/// Solidity 0.5.0
-			if (isActivated(Module::ConstructorKeyword))
-				ConstructorKeyword{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-			if (isActivated(Module::VisibilitySpecifier))
-				VisibilitySpecifier{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-
-			/// Solidity 0.6.0
-			if (isActivated(Module::AbstractContract))
-				AbstractContract{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-			if (isActivated(Module::OverridingFunction))
-				OverridingFunction{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-			if (isActivated(Module::VirtualFunction))
-				VirtualFunction{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-
-			/// Solidity 0.7.0
-			if (isActivated(Module::DotSyntax))
-				DotSyntax{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-			if (isActivated(Module::NowKeyword))
-				NowKeyword{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-			if (isActivated(Module::ConstrutorVisibility))
-				ConstructorVisibility{_charStreamProvider, m_changes}.analyze(_sourceUnit);
-		}
-
-		void activateModule(Module _module) { m_modules.insert(_module); }
-		void deactivateModules() { m_modules.clear(); }
-
-	private:
-		bool isActivated(Module _module) const
-		{
-			return m_modules.find(_module) != m_modules.end();
-		}
-
-		/// All modules are activated by default. Clear them before activating
-		/// single ones.
-		std::set<Module> m_modules = {
-			Module::ConstructorKeyword,
-			Module::VisibilitySpecifier,
-			Module::AbstractContract,
-			Module::OverridingFunction,
-			Module::VirtualFunction,
-			Module::DotSyntax,
-			Module::NowKeyword,
-			Module::ConstrutorVisibility
-		};
-	};
-
-	/// Parses the current sources and runs analyses as well as compilation on
-	/// them if parsing was successful.
-	void tryCompile() const;
-	/// Analyses and upgrades the sources given. The upgrade happens in a loop,
-	/// applying one change at a time, which is run until no applicable changes
-	/// are found any more. Only one change is done at a time and all sources
-	/// are being compiled again after each change.
-	void runUpgrade();
-	/// Runs upgrade analysis on source and applies upgrades changes to it.
-	/// Returns `true` if there're still changes that can be applied,
-	/// `false` otherwise.
-	bool analyzeAndUpgrade(
-		std::pair<std::string, std::string> const& _sourceCode
-	);
-
-	/// Applies the change given to its source code. If no `--dry-run` was
-	/// passed via the commandline, the upgraded source code is written back
-	/// to its file.
-	void applyChange(
-		std::pair<std::string, std::string> const& _sourceCode,
-		UpgradeChange& _change
-	);
-
-	/// Prints all errors (excluding warnings) the compiler currently reported.
-	void printErrors() const;
-	/// Prints error and upgrade overview at the end of each full run.
-	void printStatistics() const;
-
-	/// Reads all input files given and stores sources in the internal data
-	/// structure. Reports errors if files cannot be found.
-	bool readInputFiles();
-	/// Writes source to file given.
-	bool writeInputFile(std::string const& _path, std::string const& _source);
-	/// Returns a file reader function that fills `m_sources`.
-	frontend::ReadCallback::Callback fileReader();
-
-	/// Resets the compiler stack and configures sources to compile.
-	/// Also enables error recovery.
-	void resetCompiler();
-	/// Resets the compiler stack and configures sources to compile.
-	/// Also enables error recovery. Passes read callback to the compiler stack.
-	void resetCompiler(frontend::ReadCallback::Callback const& _callback);
-
-	/// Compiler arguments variable map
-	boost::program_options::variables_map m_args;
-	/// Map of input files to source code strings
-	std::map<std::string, std::string> m_sourceCodes;
-	/// Solidity compiler stack
-	std::unique_ptr<frontend::CompilerStack> m_compiler;
-	/// List of allowed directories to read files from
-	std::vector<boost::filesystem::path> m_allowedDirectories;
-	/// Holds all upgrade modules and source upgrades.
-	Suite m_suite;
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/Upgrade050.cpp b/compiler/tools/solidityUpgrade/Upgrade050.cpp
deleted file mode 100644
index c8b4de9e..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade050.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#include <tools/solidityUpgrade/Upgrade050.h>
-#include <tools/solidityUpgrade/SourceTransform.h>
-
-#include <libsolidity/analysis/OverrideChecker.h>
-
-#include <libyul/AST.h>
-
-#include <regex>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::frontend;
-using namespace solidity::tools;
-
-void ConstructorKeyword::endVisit(ContractDefinition const& _contract)
-{
-	for (auto const* function: _contract.definedFunctions())
-		if (function->name() == _contract.name())
-			m_changes.emplace_back(
-					UpgradeChange::Level::Safe,
-					function->location(),
-					SourceTransform{m_charStreamProvider}.replaceFunctionName(
-						function->location(),
-						function->name(),
-						"constructor"
-					)
-			);
-}
-
-void VisibilitySpecifier::endVisit(FunctionDefinition const& _function)
-{
-	if (_function.noVisibilitySpecified())
-		m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				_function.location(),
-				SourceTransform{m_charStreamProvider}.insertAfterRightParenthesis(_function.location(), "public")
-		);
-}
diff --git a/compiler/tools/solidityUpgrade/Upgrade050.h b/compiler/tools/solidityUpgrade/Upgrade050.h
deleted file mode 100644
index a678b04e..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade050.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#pragma once
-
-#include <tools/solidityUpgrade/UpgradeChange.h>
-#include <tools/solidityUpgrade/UpgradeSuite.h>
-
-#include <libsolidity/ast/ASTVisitor.h>
-
-namespace solidity::tools
-{
-
-/**
- * Module that performs analysis on the AST. It visits all contract
- * definitions and its defined functions and reports a source upgrade,
- * if one of the declared functions is the constructor but does not
- * use the `constructor` keyword.
- */
-class ConstructorKeyword: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::ContractDefinition const& _contract) override;
-};
-
-/**
- * Module that performs analysis on the AST. It visits function definitions
- * and reports a source upgrade, if this function's visibility is `public`,
- * but not marked explicitly as such.
- */
-class VisibilitySpecifier: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::FunctionDefinition const& _function) override;
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/Upgrade060.cpp b/compiler/tools/solidityUpgrade/Upgrade060.cpp
deleted file mode 100644
index 8caff02c..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade060.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#include <tools/solidityUpgrade/Upgrade060.h>
-#include <tools/solidityUpgrade/SourceTransform.h>
-
-#include <libsolidity/analysis/OverrideChecker.h>
-
-#include <libyul/AST.h>
-
-#include <regex>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::frontend;
-using namespace solidity::tools;
-
-void AbstractContract::endVisit(ContractDefinition const& _contract)
-{
-	bool isFullyImplemented = _contract.annotation().unimplementedDeclarations->empty();
-
-	if (
-		!isFullyImplemented &&
-		!_contract.abstract() &&
-		!_contract.isInterface()
-	)
-		m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				_contract.location(),
-				SourceTransform{m_charStreamProvider}.insertBeforeKeyword(_contract.location(), "contract", "abstract")
-		);
-}
-
-void OverridingFunction::endVisit(ContractDefinition const& _contract)
-{
-	auto const& inheritedFunctions = m_overrideChecker.inheritedFunctions(_contract);
-
-	for (auto const* function: _contract.definedFunctions())
-	{
-		Contracts expectedContracts;
-		OverrideProxy proxy{function};
-
-		if (!function->isConstructor())
-		{
-			/// Build list of contracts expected to be mentioned in the override list (if any).
-			for (auto [begin, end] = inheritedFunctions.equal_range(proxy); begin != end; begin++)
-				expectedContracts.insert(&begin->contract());
-
-			/// Add override with contract list, if needed.
-			if (!function->overrides() && expectedContracts.size() > 1)
-				m_changes.emplace_back(
-						UpgradeChange::Level::Safe,
-						function->location(),
-						appendOverride(*function, expectedContracts)
-				);
-
-			for (auto [begin, end] = inheritedFunctions.equal_range(proxy); begin != end; begin++)
-			{
-				auto& super = (*begin);
-				auto functionType = FunctionType(*function).asExternallyCallableFunction(false);
-				auto superType = super.externalFunctionType();
-
-				if (functionType && functionType->hasEqualParameterTypes(*superType))
-				{
-					/// If function does not specify override and no override with
-					/// contract list was added before.
-					if (!function->overrides() && expectedContracts.size() <= 1)
-						m_changes.emplace_back(
-								UpgradeChange::Level::Safe,
-								function->location(),
-								appendOverride(*function, expectedContracts)
-						);
-				}
-			}
-		}
-	}
-}
-
-string OverridingFunction::appendOverride(
-	FunctionDefinition const& _function,
-	Contracts const& _expectedContracts
-)
-{
-	auto location = _function.location();
-	string upgradedCode;
-	string overrideExpression = SourceGeneration::functionOverride(_expectedContracts);
-
-	if (SourceAnalysis{m_charStreamProvider}.hasVirtualKeyword(location))
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterKeyword(
-			location,
-			"virtual",
-			overrideExpression
-		);
-	else if (SourceAnalysis{m_charStreamProvider}.hasMutabilityKeyword(location))
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterKeyword(
-			location,
-			stateMutabilityToString(_function.stateMutability()),
-			overrideExpression
-		);
-	else if (SourceAnalysis{m_charStreamProvider}.hasVisibilityKeyword(location))
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterKeyword(
-			location,
-			Declaration::visibilityToString(_function.visibility()),
-			overrideExpression
-		);
-	else
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterRightParenthesis(
-			location,
-			overrideExpression
-		);
-
-	return upgradedCode;
-}
-
-void VirtualFunction::endVisit(ContractDefinition const& _contract)
-{
-	auto const& inheritedFunctions = m_overrideChecker.inheritedFunctions(_contract);
-
-	for (FunctionDefinition const* function: _contract.definedFunctions())
-	{
-		OverrideProxy proxy{function};
-
-		if (!function->isConstructor())
-		{
-			if (
-				!function->markedVirtual() &&
-				!function->isImplemented() &&
-				!function->virtualSemantics() &&
-				function->visibility() > Visibility::Private
-			)
-			{
-				m_changes.emplace_back(
-						UpgradeChange::Level::Safe,
-						function->location(),
-						appendVirtual(*function)
-				);
-			}
-
-			for (auto [begin, end] = inheritedFunctions.equal_range(proxy); begin != end; begin++)
-			{
-				auto& super = (*begin);
-				if (
-					!function->markedVirtual() &&
-					!super.virtualSemantics()
-				)
-				{
-					m_changes.emplace_back(
-						UpgradeChange::Level::Safe,
-						function->location(),
-						appendVirtual(*function)
-					);
-				}
-			}
-		}
-	}
-}
-
-string VirtualFunction::appendVirtual(FunctionDefinition const& _function) const
-{
-	auto location = _function.location();
-	string upgradedCode;
-
-	if (SourceAnalysis{m_charStreamProvider}.hasMutabilityKeyword(location))
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterKeyword(
-			location,
-			stateMutabilityToString(_function.stateMutability()),
-			"virtual"
-		);
-	else if (SourceAnalysis{m_charStreamProvider}.hasVisibilityKeyword(location))
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterKeyword(
-			location,
-			Declaration::visibilityToString(_function.visibility()),
-			"virtual"
-		);
-	else
-		upgradedCode = SourceTransform{m_charStreamProvider}.insertAfterRightParenthesis(
-			_function.location(),
-			"virtual"
-		);
-
-	return upgradedCode;
-}
-
diff --git a/compiler/tools/solidityUpgrade/Upgrade060.h b/compiler/tools/solidityUpgrade/Upgrade060.h
deleted file mode 100644
index 46b10a3a..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade060.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#pragma once
-
-#include <tools/solidityUpgrade/UpgradeChange.h>
-#include <tools/solidityUpgrade/UpgradeSuite.h>
-
-#include <libsolidity/ast/ASTVisitor.h>
-
-namespace solidity::tools
-{
-
-/**
- * Module that performs analysis on the AST. Finds abstract contracts that are
- * not marked as such and adds the `abstract` keyword.
- */
-class AbstractContract: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::ContractDefinition const& _contract) override;
-};
-
-/**
- * Module that performs analysis on the AST. Finds functions that need to be
- * marked `override` and adds the keyword to the function header.
- */
-class OverridingFunction: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	using Contracts = std::set<frontend::ContractDefinition const*, frontend::OverrideChecker::CompareByID>;
-
-	void endVisit(frontend::ContractDefinition const& _contract) override;
-
-	std::string appendOverride(
-		frontend::FunctionDefinition const& _function,
-		Contracts const& _expectedContracts
-	);
-};
-
-/**
- * Module that performs analysis on the AST. Finds functions that need to be
- * marked `virtual` and adds the keyword to the function header.
- */
-class VirtualFunction: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::ContractDefinition const& _function) override;
-
-	std::string appendVirtual(frontend::FunctionDefinition const& _function) const;
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/Upgrade070.cpp b/compiler/tools/solidityUpgrade/Upgrade070.cpp
deleted file mode 100644
index 6a26b140..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade070.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-n	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#include <tools/solidityUpgrade/Upgrade070.h>
-#include <tools/solidityUpgrade/SourceTransform.h>
-
-using namespace solidity::frontend;
-using namespace solidity::tools;
-
-void DotSyntax::endVisit(FunctionCall const& _functionCall)
-{
-	Type const* type = _functionCall.annotation().type;
-	if (auto const funcType = dynamic_cast<FunctionType const*>(type))
-	{
-		if (funcType->valueSet())
-			m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				_functionCall.location(),
-				SourceTransform{m_charStreamProvider}.valueUpdate(_functionCall.location())
-			);
-
-		if (funcType->gasSet())
-			m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				_functionCall.location(),
-				SourceTransform{m_charStreamProvider}.gasUpdate(_functionCall.location())
-			);
-	}
-}
-
-void NowKeyword::endVisit(Identifier const& _identifier)
-{
-	IdentifierAnnotation& annotation = _identifier.annotation();
-
-	if (
-		MagicVariableDeclaration const* magicVar =
-		dynamic_cast<MagicVariableDeclaration const*>(annotation.referencedDeclaration)
-	)
-		if (magicVar->type()->category() == Type::Category::Integer)
-		{
-			solAssert(_identifier.name() == "now", "");
-			m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				_identifier.location(),
-				SourceTransform{m_charStreamProvider}.nowUpdate(_identifier.location())
-			);
-		}
-}
-
-void ConstructorVisibility::endVisit(ContractDefinition const& _contract)
-{
-	if (!_contract.abstract())
-		for (FunctionDefinition const* function: _contract.definedFunctions())
-			if (
-				function->isConstructor() &&
-				!function->noVisibilitySpecified() &&
-				function->visibility() == Visibility::Internal
-			)
-				m_changes.emplace_back(
-					UpgradeChange::Level::Safe,
-					_contract.location(),
-					SourceTransform{m_charStreamProvider}.insertBeforeKeyword(_contract.location(), "contract", "abstract")
-				);
-
-	for (FunctionDefinition const* function: _contract.definedFunctions())
-		if (function->isConstructor() && !function->noVisibilitySpecified())
-			m_changes.emplace_back(
-				UpgradeChange::Level::Safe,
-				function->location(),
-				SourceTransform{m_charStreamProvider}.removeVisibility(function->location())
-			);
-}
diff --git a/compiler/tools/solidityUpgrade/Upgrade070.h b/compiler/tools/solidityUpgrade/Upgrade070.h
deleted file mode 100644
index b99f9d30..00000000
--- a/compiler/tools/solidityUpgrade/Upgrade070.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#pragma once
-
-#include <tools/solidityUpgrade/UpgradeSuite.h>
-
-#include <libsolidity/ast/AST.h>
-
-namespace solidity::tools
-{
-
-class DotSyntax: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::FunctionCall const& _expression) override;
-};
-
-class NowKeyword: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::Identifier const& _expression) override;
-};
-
-class ConstructorVisibility: public AnalysisUpgrade
-{
-public:
-	using AnalysisUpgrade::AnalysisUpgrade;
-	void analyze(frontend::SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); }
-private:
-	void endVisit(frontend::ContractDefinition const& _contract) override;
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/UpgradeChange.cpp b/compiler/tools/solidityUpgrade/UpgradeChange.cpp
deleted file mode 100644
index ce1627d0..00000000
--- a/compiler/tools/solidityUpgrade/UpgradeChange.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#include <tools/solidityUpgrade/UpgradeChange.h>
-
-#include <liblangutil/SourceReferenceExtractor.h>
-#include <liblangutil/SourceReferenceFormatter.h>
-#include <libsolutil/Numeric.h>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::langutil;
-using namespace solidity::util;
-using namespace solidity::tools;
-
-string UpgradeChange::apply(string _source) const
-{
-	_source.replace(
-		static_cast<size_t>(m_location.start),
-		static_cast<size_t>(m_location.end - m_location.start),
-		m_patch
-	);
-	return _source;
-}
-
-void UpgradeChange::log(CharStreamProvider const& _charStreamProvider, bool const _shorten) const
-{
-	stringstream os;
-	SourceReferenceFormatter formatter{os, _charStreamProvider, true, false};
-
-	string start = to_string(m_location.start);
-	string end = to_string(m_location.end);
-
-	auto color = m_level == Level::Unsafe ? formatting::MAGENTA : formatting::CYAN;
-	auto level = m_level == Level::Unsafe ? "unsafe" : "safe";
-
-	os << endl;
-	AnsiColorized(os, true, {formatting::BOLD, color}) << "Upgrade change (" << level << ")" << endl;
-	os << "=======================" << endl;
-	formatter.printSourceLocation(SourceReferenceExtractor::extract(_charStreamProvider, &m_location));
-	os << endl;
-
-	LineColumn lineEnd = _charStreamProvider.charStream(*m_location.sourceName).translatePositionToLineColumn(m_location.end);
-	int const leftpad = static_cast<int>(log10(max(lineEnd.line, 1))) + 2;
-
-	stringstream output;
-	output << (_shorten ? shortenSource(m_patch) : m_patch);
-
-	string line;
-	while (getline(output, line))
-	{
-		os << string(static_cast<size_t>(leftpad), ' ');
-		AnsiColorized(os, true, {formatting::BOLD, formatting::BLUE}) << "| ";
-		AnsiColorized(os, true, {}) << line << endl;
-	}
-	cout << os.str();
-	cout << endl;
-}
-
-string UpgradeChange::shortenSource(string const& _source)
-{
-	size_t constexpr maxSourceLength = 1000;
-	if (_source.size() > maxSourceLength)
-		return _source.substr(0, min(_source.size(), maxSourceLength)) + "...";
-	return _source;
-}
diff --git a/compiler/tools/solidityUpgrade/UpgradeChange.h b/compiler/tools/solidityUpgrade/UpgradeChange.h
deleted file mode 100644
index 6cccc154..00000000
--- a/compiler/tools/solidityUpgrade/UpgradeChange.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#pragma once
-
-#include <libsolutil/AnsiColorized.h>
-
-#include <liblangutil/SourceLocation.h>
-#include <liblangutil/CharStreamProvider.h>
-
-#include <algorithm>
-#include <utility>
-
-namespace solidity::tools
-{
-
-/**
- * Models a single source code change, based on the initial source location
- * and a patch, which needs to be applied.
- * It implements the concept of level of confidence in the change and distiguishes
- * safe from unsafe changes. A "safe" change is considered to not break
- * compilation or change semantics. An "unsafe" change is considered to potentially
- * change semantics or require further manual management.
- */
-class UpgradeChange
-{
-public:
-	enum class Level
-	{
-		Safe,
-		Unsafe
-	};
-
-	UpgradeChange(
-		Level _level,
-		langutil::SourceLocation _location,
-		std::string _patch
-	):
-		m_location(_location),
-		m_patch(std::move(_patch)),
-		m_level(_level)
-	{}
-
-	~UpgradeChange() {}
-
-	langutil::SourceLocation const& location() const { return m_location; }
-	std::string patch() const { return m_patch; }
-	Level level() const { return m_level; }
-
-	/// Performs the actual replacement on the provided original source code
-	/// and returns the modified source code.
-	std::string apply(std::string _source) const;
-	/// Does a pretty-print of this upgrade change. Since the patch
-	/// can contain a lot of code lines, it can be shortened, which is signaled
-	/// by setting the flag.
-	void log(langutil::CharStreamProvider const& _charStreamProvider, bool const _shorten = true) const;
-private:
-	langutil::SourceLocation m_location;
-	std::string m_patch;
-	Level m_level;
-
-	/// Shortens the given source to a constant limit.
-	static std::string shortenSource(std::string const& _source);
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/UpgradeSuite.h b/compiler/tools/solidityUpgrade/UpgradeSuite.h
deleted file mode 100644
index 2bde6ec0..00000000
--- a/compiler/tools/solidityUpgrade/UpgradeSuite.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#pragma once
-
-#include <tools/solidityUpgrade/UpgradeChange.h>
-
-#include <liblangutil/ErrorReporter.h>
-#include <liblangutil/CharStreamProvider.h>
-
-#include <libsolidity/ast/ASTVisitor.h>
-#include <libsolidity/analysis/OverrideChecker.h>
-
-#include <regex>
-
-namespace solidity::tools
-{
-
-/**
- * The base upgrade module that can be inherited from. Doing so
- * creates a basic upgrade module that facilitates access to
- * change reporting.
- */
-class Upgrade
-{
-public:
-	Upgrade(
-		langutil::CharStreamProvider const& _charStreamProvider,
-		std::vector<UpgradeChange>& _changes
-	): m_changes(_changes), m_charStreamProvider(_charStreamProvider) {}
-
-protected:
-	/// A reference to a suite-specific set of changes.
-	/// It is passed to all upgrade modules and meant to collect
-	/// reported changes.
-	std::vector<UpgradeChange>& m_changes;
-	langutil::CharStreamProvider const& m_charStreamProvider;
-};
-
-/**
- * A specific upgrade module meant to be run after the analysis phase
- * of the compiler.
- */
-class AnalysisUpgrade: public Upgrade, public frontend::ASTConstVisitor
-{
-public:
-	AnalysisUpgrade(
-		langutil::CharStreamProvider const& _charStreamProvider,
-		std::vector<UpgradeChange>& _changes
-	):
-		Upgrade(_charStreamProvider, _changes),
-		m_errorReporter(m_errors),
-		m_overrideChecker(m_errorReporter)
-	{}
-	/// Interface function for all upgrade modules that are meant
-	/// be run after the analysis phase of the compiler.
-	void analyze(frontend::SourceUnit const&) {}
-protected:
-	langutil::ErrorList m_errors;
-	langutil::ErrorReporter m_errorReporter;
-	frontend::OverrideChecker m_overrideChecker;
-};
-
-/**
- * The generic upgrade suite. Should be inherited from for each set of
- * desired upgrade modules.
- */
-class UpgradeSuite
-{
-public:
-	/// The base interface function that needs to be implemented for each
-	/// suite. It should create suite-specific upgrade modules and trigger
-	/// their analysis.
-	void analyze(frontend::SourceUnit const& _sourceUnit);
-	/// Resets all changes collected so far.
-	void reset() { m_changes.clear(); }
-
-	std::vector<UpgradeChange>& changes() { return m_changes; }
-	std::vector<UpgradeChange> const& changes() const { return m_changes; }
-
-protected:
-	std::vector<UpgradeChange> m_changes;
-};
-
-}
diff --git a/compiler/tools/solidityUpgrade/contracts/DocsExamplePass.sol b/compiler/tools/solidityUpgrade/contracts/DocsExamplePass.sol
deleted file mode 100644
index d8e4dc8e..00000000
--- a/compiler/tools/solidityUpgrade/contracts/DocsExamplePass.sol
+++ /dev/null
@@ -1,23 +0,0 @@
-pragma solidity >0.4.23;
-
-contract Updateable {
-    function run() public view returns (bool);
-    function update() public;
-}
-
-contract Upgradable {
-    function run() public view returns (bool);
-    function upgrade();
-}
-
-contract Source is Updateable, Upgradable {
-    function Source() public {}
-
-    function run()
-        public
-        view
-        returns (bool) {}
-
-    function update() {}
-    function upgrade() {}
-}
\ No newline at end of file
diff --git a/compiler/tools/solidityUpgrade/contracts/Test.sol b/compiler/tools/solidityUpgrade/contracts/Test.sol
deleted file mode 100644
index 8958a091..00000000
--- a/compiler/tools/solidityUpgrade/contracts/Test.sol
+++ /dev/null
@@ -1,18 +0,0 @@
-pragma solidity >0.4.23;
-
-contract Storage {
-    function Storage() public {}
-    function start();
-    function state() public view returns (bool);
-    function stop() public;
-}
-
-contract Observable {
-    function state() public view returns (bool);
-}
-
-contract VolatileStorage is Storage, Observable {
-    function start() {}
-    function state() public view returns (bool) {}
-    function stop() {}
-}
\ No newline at end of file
diff --git a/compiler/tools/solidityUpgrade/contracts/TestMultiline.sol b/compiler/tools/solidityUpgrade/contracts/TestMultiline.sol
deleted file mode 100644
index 7083da4e..00000000
--- a/compiler/tools/solidityUpgrade/contracts/TestMultiline.sol
+++ /dev/null
@@ -1,21 +0,0 @@
-pragma solidity >0.4.23;
-
-contract Storage {
-    function Storage() {}
-    function init() public;
-    function idle();
-    function destroy() public view;
-}
-
-contract VolatileStorage is Storage {
-    function init()
-        public
-    {}
-
-    function idle() {}
-
-    function destroy()
-        public
-        view
-    {}
-}
\ No newline at end of file
diff --git a/compiler/tools/solidityUpgrade/contracts/TestNonFixable.sol b/compiler/tools/solidityUpgrade/contracts/TestNonFixable.sol
deleted file mode 100644
index 0a5c2f00..00000000
--- a/compiler/tools/solidityUpgrade/contracts/TestNonFixable.sol
+++ /dev/null
@@ -1,15 +0,0 @@
-pragma solidity >0.4.23;
-
-contract Storage {
-    function Storage() {}
-    function init() public;
-    function idle();
-    function destroy() public view;
-}
-
-contract VolatileStorage is Storage {
-    uint[] array;
-    function init() public { array.length = 3; }
-    function idle() {}
-    function destroy() public view {}
-}
\ No newline at end of file
diff --git a/compiler/tools/solidityUpgrade/main.cpp b/compiler/tools/solidityUpgrade/main.cpp
deleted file mode 100644
index 55ed0118..00000000
--- a/compiler/tools/solidityUpgrade/main.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-#include <tools/solidityUpgrade/SourceUpgrade.h>
-
-#include <libsolutil/CommonIO.h>
-#include <libsolutil/AnsiColorized.h>
-
-//#include <test/Common.h>
-
-#include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/exception/all.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/program_options.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <fstream>
-#include <queue>
-#include <regex>
-
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-using namespace solidity;
-using namespace std;
-namespace po = boost::program_options;
-namespace fs = boost::filesystem;
-
-namespace
-{
-
-void setupTerminal()
-{
-#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-	// Set output mode to handle virtual terminal (ANSI escape sequences)
-	// ignore any error, as this is just a "nice-to-have"
-	// only windows needs to be taken care of, as other platforms (Linux/OSX) support them natively.
-	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
-	if (hOut == INVALID_HANDLE_VALUE)
-		return;
-
-	DWORD dwMode = 0;
-	if (!GetConsoleMode(hOut, &dwMode))
-		return;
-
-	dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-	if (!SetConsoleMode(hOut, dwMode))
-		return;
-#endif
-}
-
-}
-
-int main(int argc, char** argv)
-{
-	setupTerminal();
-
-	tools::SourceUpgrade upgrade;
-	if (!upgrade.parseArguments(argc, argv))
-		return 1;
-	upgrade.printPrologue();
-
-	try
-	{
-		if (!upgrade.processInput())
-			return 1;
-	}
-	catch (boost::exception const& _exception)
-	{
-		cerr << "Exception while processing input: " << boost::diagnostic_information(_exception) << endl;
-	}
-	catch (...)
-	{
-		cerr << "Unknown exception while processing input: " << boost::current_exception_diagnostic_information() << endl;
-	}
-
-	return 0;
-}
diff --git a/compiler/tools/yulPhaser/AlgorithmRunner.cpp b/compiler/tools/yulPhaser/AlgorithmRunner.cpp
deleted file mode 100644
index d5ad7557..00000000
--- a/compiler/tools/yulPhaser/AlgorithmRunner.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/AlgorithmRunner.h>
-
-#include <tools/yulPhaser/Exceptions.h>
-
-#include <libsolutil/Assertions.h>
-
-#include <cerrno>
-#include <cstring>
-#include <fstream>
-
-using namespace std;
-using namespace solidity::phaser;
-
-void AlgorithmRunner::run(GeneticAlgorithm& _algorithm)
-{
-	populationAutosave();
-	printInitialPopulation();
-	cacheClear();
-
-	clock_t totalTimeStart = clock();
-	for (size_t round = 0; !m_options.maxRounds.has_value() || round < m_options.maxRounds.value(); ++round)
-	{
-		clock_t roundTimeStart = clock();
-		cacheStartRound(round + 1);
-
-		m_population = _algorithm.runNextRound(m_population);
-		randomiseDuplicates();
-
-		printRoundSummary(round, roundTimeStart, totalTimeStart);
-		printCacheStats();
-		populationAutosave();
-	}
-}
-
-void AlgorithmRunner::printRoundSummary(
-	size_t _round,
-	clock_t _roundTimeStart,
-	clock_t _totalTimeStart
-) const
-{
-	clock_t now = clock();
-	double roundTime = static_cast<double>(now - _roundTimeStart) / CLOCKS_PER_SEC;
-	double totalTime = static_cast<double>(now - _totalTimeStart) / CLOCKS_PER_SEC;
-
-	if (!m_options.showOnlyTopChromosome)
-	{
-		if (m_options.showRoundInfo)
-		{
-			m_outputStream << "---------- ROUND " << _round + 1;
-			m_outputStream << " [round: " << fixed << setprecision(1) << roundTime << " s,";
-			m_outputStream << " total: " << fixed << setprecision(1) << totalTime << " s]";
-			m_outputStream << " ----------" << endl;
-		}
-		else if (m_population.individuals().size() > 0)
-			m_outputStream << endl;
-
-		m_outputStream << m_population;
-	}
-	else if (m_population.individuals().size() > 0)
-	{
-		if (m_options.showRoundInfo)
-		{
-			m_outputStream << setw(5) << _round + 1 << " | ";
-			m_outputStream << setw(5) << fixed << setprecision(1) << totalTime << " | ";
-		}
-
-		m_outputStream << m_population.individuals()[0] << endl;
-	}
-}
-
-void AlgorithmRunner::printInitialPopulation() const
-{
-	if (!m_options.showInitialPopulation)
-		return;
-
-	m_outputStream << "---------- INITIAL POPULATION ----------" << endl;
-	m_outputStream << m_population;
-}
-
-void AlgorithmRunner::printCacheStats() const
-{
-	if (!m_options.showCacheStats)
-		return;
-
-	CacheStats totalStats{};
-	size_t disabledCacheCount = 0;
-	for (size_t i = 0; i < m_programCaches.size(); ++i)
-		if (m_programCaches[i] != nullptr)
-			totalStats += m_programCaches[i]->gatherStats();
-		else
-			++disabledCacheCount;
-
-	m_outputStream << "---------- CACHE STATS ----------" << endl;
-
-	if (disabledCacheCount < m_programCaches.size())
-	{
-		for (auto& [round, count]: totalStats.roundEntryCounts)
-			m_outputStream << "Round " << round << ": " << count << " entries" << endl;
-		m_outputStream << "Total hits: " << totalStats.hits << endl;
-		m_outputStream << "Total misses: " << totalStats.misses << endl;
-		m_outputStream << "Size of cached code: " << totalStats.totalCodeSize << endl;
-	}
-
-	if (disabledCacheCount == m_programCaches.size())
-		m_outputStream << "Program cache disabled" << endl;
-	else if (disabledCacheCount > 0)
-	{
-		m_outputStream << "Program cache disabled for " << disabledCacheCount << " out of ";
-		m_outputStream << m_programCaches.size() << " programs" << endl;
-	}
-}
-
-void AlgorithmRunner::populationAutosave() const
-{
-	if (!m_options.populationAutosaveFile.has_value())
-		return;
-
-	ofstream outputStream(m_options.populationAutosaveFile.value(), ios::out | ios::trunc);
-	assertThrow(
-		outputStream.is_open(),
-		FileOpenError,
-		"Could not open file '" + m_options.populationAutosaveFile.value() + "': " + strerror(errno)
-	);
-
-	for (auto& individual: m_population.individuals())
-		outputStream << individual.chromosome << endl;
-
-	assertThrow(
-		!outputStream.bad(),
-		FileWriteError,
-		"Error while writing to file '" + m_options.populationAutosaveFile.value() + "': " + strerror(errno)
-	);
-}
-
-void AlgorithmRunner::cacheClear()
-{
-	for (auto& cache: m_programCaches)
-		if (cache != nullptr)
-			cache->clear();
-}
-
-void AlgorithmRunner::cacheStartRound(size_t _roundNumber)
-{
-	for (auto& cache: m_programCaches)
-		if (cache != nullptr)
-			cache->startRound(_roundNumber);
-}
-
-void AlgorithmRunner::randomiseDuplicates()
-{
-	if (m_options.randomiseDuplicates)
-	{
-		assert(m_options.minChromosomeLength.has_value());
-		assert(m_options.maxChromosomeLength.has_value());
-
-		m_population = randomiseDuplicates(
-			m_population,
-			m_options.minChromosomeLength.value(),
-			m_options.maxChromosomeLength.value()
-		);
-	}
-}
-
-Population AlgorithmRunner::randomiseDuplicates(
-	Population _population,
-	size_t _minChromosomeLength,
-	size_t _maxChromosomeLength
-)
-{
-	if (_population.individuals().size() == 0)
-		return _population;
-
-	vector<Individual> individuals{_population.individuals()[0]};
-	size_t duplicateCount = 0;
-	for (size_t i = 1; i < _population.individuals().size(); ++i)
-		if (_population.individuals()[i].chromosome == _population.individuals()[i - 1].chromosome)
-			++duplicateCount;
-		else
-			individuals.push_back(_population.individuals()[i]);
-
-	return (
-		Population(_population.fitnessMetric(), individuals) +
-		Population::makeRandom(_population.fitnessMetric(), duplicateCount, _minChromosomeLength, _maxChromosomeLength)
-	);
-}
diff --git a/compiler/tools/yulPhaser/AlgorithmRunner.h b/compiler/tools/yulPhaser/AlgorithmRunner.h
deleted file mode 100644
index 6e3804a1..00000000
--- a/compiler/tools/yulPhaser/AlgorithmRunner.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains the implementation of a class that manages the execution of a genetic algorithm.
- */
-
-#pragma once
-
-#include <tools/yulPhaser/GeneticAlgorithms.h>
-#include <tools/yulPhaser/Population.h>
-#include <tools/yulPhaser/ProgramCache.h>
-
-#include <cstddef>
-#include <ctime>
-#include <optional>
-#include <ostream>
-
-namespace solidity::phaser
-{
-
-/**
- * Manages a population and executes a genetic algorithm on it. It's independent of the
- * implementation details of a specific algorithm which is pluggable via @a GeneticAlgorithm class.
- *
- * The class is also responsible for providing text feedback on the execution of the algorithm
- * to the associated output stream.
- */
-class AlgorithmRunner
-{
-public:
-	struct Options
-	{
-		std::optional<size_t> maxRounds = std::nullopt;
-		std::optional<std::string> populationAutosaveFile = std::nullopt;
-		bool randomiseDuplicates = false;
-		std::optional<size_t> minChromosomeLength = std::nullopt;
-		std::optional<size_t> maxChromosomeLength = std::nullopt;
-		bool showInitialPopulation = false;
-		bool showOnlyTopChromosome = false;
-		bool showRoundInfo = true;
-		bool showCacheStats = false;
-	};
-
-	AlgorithmRunner(
-		Population _initialPopulation,
-		std::vector<std::shared_ptr<ProgramCache>> _programCaches,
-		Options _options,
-		std::ostream& _outputStream
-	):
-		m_population(std::move(_initialPopulation)),
-		m_programCaches(std::move(_programCaches)),
-		m_options(std::move(_options)),
-		m_outputStream(_outputStream) {}
-
-	void run(GeneticAlgorithm& _algorithm);
-
-	Options const& options() const { return m_options; }
-	Population const& population() const { return m_population; }
-
-private:
-	void printRoundSummary(
-		size_t _round,
-		clock_t _roundTimeStart,
-		clock_t _totalTimeStart
-	) const;
-	void printInitialPopulation() const;
-	void printCacheStats() const;
-	void populationAutosave() const;
-	void randomiseDuplicates();
-	void cacheClear();
-	void cacheStartRound(size_t _roundNumber);
-
-	static Population randomiseDuplicates(
-		Population _population,
-		size_t _minChromosomeLength,
-		size_t _maxChromosomeLength
-	);
-
-	Population m_population;
-	std::vector<std::shared_ptr<ProgramCache>> m_programCaches;
-	Options m_options;
-	std::ostream& m_outputStream;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Chromosome.cpp b/compiler/tools/yulPhaser/Chromosome.cpp
deleted file mode 100644
index 6e8d3544..00000000
--- a/compiler/tools/yulPhaser/Chromosome.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Chromosome.h>
-
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <libyul/optimiser/Suite.h>
-#include <libsolutil/CommonData.h>
-
-#include <sstream>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::yul;
-using namespace solidity::phaser;
-
-namespace solidity::phaser
-{
-
-ostream& operator<<(ostream& _stream, Chromosome const& _chromosome);
-
-}
-
-Chromosome Chromosome::makeRandom(size_t _length)
-{
-	vector<string> steps;
-	for (size_t i = 0; i < _length; ++i)
-		steps.push_back(randomOptimisationStep());
-
-	return Chromosome(std::move(steps));
-}
-
-ostream& phaser::operator<<(ostream& _stream, Chromosome const& _chromosome)
-{
-	return _stream << _chromosome.m_genes;
-}
-
-vector<string> Chromosome::allStepNames()
-{
-	vector<string> stepNames;
-	for (auto const& step: OptimiserSuite::allSteps())
-		stepNames.push_back(step.first);
-
-	return stepNames;
-}
-
-string const& Chromosome::randomOptimisationStep()
-{
-	static vector<string> stepNames = allStepNames();
-
-	return stepNames[SimulationRNG::uniformInt(0, stepNames.size() - 1)];
-}
-
-char Chromosome::randomGene()
-{
-	return OptimiserSuite::stepNameToAbbreviationMap().at(randomOptimisationStep());
-}
-
-string Chromosome::stepsToGenes(vector<string> const& _optimisationSteps)
-{
-	string genes;
-	for (string const& stepName: _optimisationSteps)
-		genes.push_back(OptimiserSuite::stepNameToAbbreviationMap().at(stepName));
-
-	return genes;
-}
-
-vector<string> Chromosome::genesToSteps(string const& _genes)
-{
-	vector<string> steps;
-	for (char abbreviation: _genes)
-		steps.push_back(OptimiserSuite::stepAbbreviationToNameMap().at(abbreviation));
-
-	return steps;
-}
diff --git a/compiler/tools/yulPhaser/Chromosome.h b/compiler/tools/yulPhaser/Chromosome.h
deleted file mode 100644
index 7dd0a32d..00000000
--- a/compiler/tools/yulPhaser/Chromosome.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <cstddef>
-#include <map>
-#include <ostream>
-#include <string>
-#include <vector>
-
-namespace solidity::phaser
-{
-
-/**
- * An object that represents a sequence of optimiser steps that can be applied to a program.
- * Such sequences are used in our genetic algorithm to represent individual members of the
- * population.
- *
- * To calculate the fitness of an individual one must apply its sequence to a specific program.
- * This class does not provide any means to do so. It just stores information.
- *
- * Once created a sequence cannot be changed. The only way to mutate it is to generate a new
- * chromosome based on the old one.
- */
-class Chromosome
-{
-public:
-	Chromosome() = default;
-	explicit Chromosome(std::vector<std::string> _optimisationSteps):
-		m_genes(stepsToGenes(_optimisationSteps)) {}
-	explicit Chromosome(std::string _genes):
-		// NOTE: We don't validate the genes - they're only checked at the point of conversion to
-		// actual optimisation steps names. This is very convenient in mutation tests.
-		m_genes(std::move(_genes)) {}
-	static Chromosome makeRandom(size_t _length);
-
-	size_t length() const { return m_genes.size(); }
-	std::string const& genes() const { return m_genes; }
-
-	std::vector<std::string> optimisationSteps() const { return genesToSteps(m_genes); }
-
-	friend std::ostream& operator<<(std::ostream& _stream, Chromosome const& _chromosome);
-
-	bool operator==(Chromosome const& _other) const { return m_genes == _other.m_genes; }
-	bool operator!=(Chromosome const& _other) const { return !(*this == _other); }
-
-	static std::string const& randomOptimisationStep();
-	static char randomGene();
-	static std::string stepsToGenes(std::vector<std::string> const& _optimisationSteps);
-	static std::vector<std::string> genesToSteps(std::string const& _genes);
-
-private:
-	static std::vector<std::string> allStepNames();
-
-	std::string m_genes;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Common.cpp b/compiler/tools/yulPhaser/Common.cpp
deleted file mode 100644
index a2321017..00000000
--- a/compiler/tools/yulPhaser/Common.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Common.h>
-
-#include <tools/yulPhaser/Exceptions.h>
-
-#include <libsolutil/Assertions.h>
-
-#include <cerrno>
-#include <cstring>
-#include <fstream>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::phaser;
-
-vector<string> phaser::readLinesFromFile(string const& _path)
-{
-	ifstream inputStream(_path);
-	assertThrow(inputStream.is_open(), FileOpenError, "Could not open file '" + _path + "': " + strerror(errno));
-
-	string line;
-	vector<string> lines;
-	while (!getline(inputStream, line).fail())
-		lines.push_back(line);
-
-	assertThrow(!inputStream.bad(), FileReadError, "Error while reading from file '" + _path + "': " + strerror(errno));
-
-	return lines;
-}
diff --git a/compiler/tools/yulPhaser/Common.h b/compiler/tools/yulPhaser/Common.h
deleted file mode 100644
index b2164cc9..00000000
--- a/compiler/tools/yulPhaser/Common.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Miscellaneous utilities for use in yul-phaser.
- */
-
-#pragma once
-
-#include <iostream>
-#include <map>
-#include <string>
-#include <vector>
-
-namespace solidity::phaser
-{
-
-/// Loads the whole file into memory, splits the content into lines, strips newlines and
-/// returns the result as a list of strings.
-///
-/// Throws FileOpenError if the file does not exist or cannot be opened for reading.
-/// Throws FileReadError if any read operation fails during the whole process.
-std::vector<std::string> readLinesFromFile(std::string const& _path);
-
-/// Reads a token from the input stream and translates it to a string using a map.
-/// Sets the failbit in the stream if there's no matching value in the map.
-template <typename C>
-std::istream& deserializeChoice(
-	std::istream& _inputStream,
-	C& _choice,
-	std::map<std::string, C> const& _stringToValueMap
-)
-{
-	std::string deserializedValue;
-	_inputStream >> deserializedValue;
-
-	auto const& pair = _stringToValueMap.find(deserializedValue);
-	if (pair != _stringToValueMap.end())
-		_choice = pair->second;
-	else
-		_inputStream.setstate(std::ios_base::failbit);
-
-	return _inputStream;
-}
-
-/// Translates a value to a string using a map and prints it to the output stream.
-/// Sets the failbit if the value is not in the map.
-template <typename C>
-std::ostream& serializeChoice(
-	std::ostream& _outputStream,
-	C const& _choice,
-	std::map<C, std::string> const& _valueToStringMap
-)
-{
-	auto const& pair = _valueToStringMap.find(_choice);
-	if (pair != _valueToStringMap.end())
-		_outputStream << pair->second;
-	else
-		_outputStream.setstate(std::ios_base::failbit);
-
-	return _outputStream;
-}
-
-}
diff --git a/compiler/tools/yulPhaser/Exceptions.h b/compiler/tools/yulPhaser/Exceptions.h
deleted file mode 100644
index e4aa19b5..00000000
--- a/compiler/tools/yulPhaser/Exceptions.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <libsolutil/Exceptions.h>
-
-namespace solidity::phaser
-{
-
-struct BadInput: virtual util::Exception {};
-struct InvalidProgram: virtual BadInput {};
-struct NoInputFiles: virtual BadInput {};
-struct MissingFile: virtual BadInput {};
-
-struct FileOpenError: virtual util::Exception {};
-struct FileReadError: virtual util::Exception {};
-struct FileWriteError: virtual util::Exception {};
-
-}
diff --git a/compiler/tools/yulPhaser/FitnessMetrics.cpp b/compiler/tools/yulPhaser/FitnessMetrics.cpp
deleted file mode 100644
index e0b719e2..00000000
--- a/compiler/tools/yulPhaser/FitnessMetrics.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/FitnessMetrics.h>
-
-#include <libsolutil/CommonIO.h>
-
-#include <cmath>
-
-using namespace std;
-using namespace solidity::util;
-using namespace solidity::yul;
-using namespace solidity::phaser;
-
-Program const& ProgramBasedMetric::program() const
-{
-	if (m_programCache == nullptr)
-		return m_program.value();
-	else
-		return m_programCache->program();
-}
-
-Program ProgramBasedMetric::optimisedProgram(Chromosome const& _chromosome)
-{
-	if (m_programCache == nullptr)
-		return optimisedProgramNoCache(_chromosome);
-
-	return m_programCache->optimiseProgram(
-		toString(_chromosome),
-		m_repetitionCount
-	);
-}
-
-Program ProgramBasedMetric::optimisedProgramNoCache(Chromosome const& _chromosome) const
-{
-	Program programCopy = program();
-	for (size_t i = 0; i < m_repetitionCount; ++i)
-		programCopy.optimise(_chromosome.optimisationSteps());
-
-	return programCopy;
-}
-
-size_t ProgramSize::evaluate(Chromosome const& _chromosome)
-{
-	return optimisedProgram(_chromosome).codeSize(codeWeights());
-}
-
-size_t RelativeProgramSize::evaluate(Chromosome const& _chromosome)
-{
-	double const scalingFactor = pow(10, m_fixedPointPrecision);
-
-	size_t unoptimisedSize = optimisedProgram(Chromosome("")).codeSize(codeWeights());
-	if (unoptimisedSize == 0)
-		return static_cast<size_t>(scalingFactor);
-
-	size_t optimisedSize = optimisedProgram(_chromosome).codeSize(codeWeights());
-
-	return static_cast<size_t>(round(
-		double(optimisedSize) / double(unoptimisedSize) * scalingFactor
-	));
-}
-
-size_t FitnessMetricAverage::evaluate(Chromosome const& _chromosome)
-{
-	assert(m_metrics.size() > 0);
-
-	size_t total = m_metrics[0]->evaluate(_chromosome);
-	for (size_t i = 1; i < m_metrics.size(); ++i)
-		total += m_metrics[i]->evaluate(_chromosome);
-
-	return total / m_metrics.size();
-}
-
-size_t FitnessMetricSum::evaluate(Chromosome const& _chromosome)
-{
-	assert(m_metrics.size() > 0);
-
-	size_t total = m_metrics[0]->evaluate(_chromosome);
-	for (size_t i = 1; i < m_metrics.size(); ++i)
-		total += m_metrics[i]->evaluate(_chromosome);
-
-	return total;
-}
-
-size_t FitnessMetricMaximum::evaluate(Chromosome const& _chromosome)
-{
-	assert(m_metrics.size() > 0);
-
-	size_t maximum = m_metrics[0]->evaluate(_chromosome);
-	for (size_t i = 1; i < m_metrics.size(); ++i)
-		maximum = max(maximum, m_metrics[i]->evaluate(_chromosome));
-
-	return maximum;
-}
-
-size_t FitnessMetricMinimum::evaluate(Chromosome const& _chromosome)
-{
-	assert(m_metrics.size() > 0);
-
-	size_t minimum = m_metrics[0]->evaluate(_chromosome);
-	for (size_t i = 1; i < m_metrics.size(); ++i)
-		minimum = min(minimum, m_metrics[i]->evaluate(_chromosome));
-
-	return minimum;
-}
diff --git a/compiler/tools/yulPhaser/FitnessMetrics.h b/compiler/tools/yulPhaser/FitnessMetrics.h
deleted file mode 100644
index f881df7a..00000000
--- a/compiler/tools/yulPhaser/FitnessMetrics.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains an abstract base class representing a fitness metric and its concrete implementations.
- */
-
-#pragma once
-
-#include <tools/yulPhaser/Chromosome.h>
-#include <tools/yulPhaser/Program.h>
-#include <tools/yulPhaser/ProgramCache.h>
-
-#include <libyul/optimiser/Metrics.h>
-
-#include <cstddef>
-#include <optional>
-
-namespace solidity::phaser
-{
-
-/**
- * Abstract base class for fitness metrics.
- *
- * The main feature is the @a evaluate() method that can tell how good a given chromosome is.
- * The lower the value, the better the fitness is. The result should be deterministic and depend
- * only on the chromosome and metric's state (which is constant).
- */
-class FitnessMetric
-{
-public:
-	FitnessMetric() = default;
-	FitnessMetric(FitnessMetric const&) = delete;
-	FitnessMetric& operator=(FitnessMetric const&) = delete;
-	virtual ~FitnessMetric() = default;
-
-	virtual size_t evaluate(Chromosome const& _chromosome) = 0;
-};
-
-/**
- * Abstract base class for fitness metrics that return values based on program size.
- *
- * The class provides utilities for optimising programs according to the information stored in
- * chromosomes. Allows using @a ProgramCache.
- *
- * It can also store weights for the @a CodeSize metric. It does not do anything with
- * them because it does not actually compute the code size but they are readily available for use
- * by derived classes.
- */
-class ProgramBasedMetric: public FitnessMetric
-{
-public:
-	explicit ProgramBasedMetric(
-		std::optional<Program> _program,
-		std::shared_ptr<ProgramCache> _programCache,
-		yul::CodeWeights const& _codeWeights,
-		size_t _repetitionCount = 1
-	):
-		m_program(std::move(_program)),
-		m_programCache(std::move(_programCache)),
-		m_codeWeights(_codeWeights),
-		m_repetitionCount(_repetitionCount)
-	{
-		assert(m_program.has_value() == (m_programCache == nullptr));
-	}
-
-	Program const& program() const;
-	ProgramCache const* programCache() const { return m_programCache.get(); }
-	yul::CodeWeights const& codeWeights() const { return m_codeWeights; }
-	size_t repetitionCount() const { return m_repetitionCount; }
-
-	Program optimisedProgram(Chromosome const& _chromosome);
-	Program optimisedProgramNoCache(Chromosome const& _chromosome) const;
-
-private:
-	std::optional<Program> m_program;
-	std::shared_ptr<ProgramCache> m_programCache;
-	yul::CodeWeights m_codeWeights;
-	size_t m_repetitionCount;
-};
-
-/**
- * Fitness metric based on the size of a specific program after applying the optimisations from the
- * chromosome to it.
- */
-class ProgramSize: public ProgramBasedMetric
-{
-public:
-	using ProgramBasedMetric::ProgramBasedMetric;
-	size_t evaluate(Chromosome const& _chromosome) override;
-};
-
-/**
- * Fitness metric based on the size of a specific program after applying the optimisations from the
- * chromosome to it in relation to the original, unoptimised program.
- *
- * Since metric values are integers, the class multiplies the ratio by 10^@a _fixedPointPrecision
- * before rounding it.
- */
-class RelativeProgramSize: public ProgramBasedMetric
-{
-public:
-	explicit RelativeProgramSize(
-		std::optional<Program> _program,
-		std::shared_ptr<ProgramCache> _programCache,
-		size_t _fixedPointPrecision,
-		yul::CodeWeights const& _weights,
-		size_t _repetitionCount = 1
-	):
-		ProgramBasedMetric(std::move(_program), std::move(_programCache), _weights, _repetitionCount),
-		m_fixedPointPrecision(_fixedPointPrecision) {}
-
-	size_t fixedPointPrecision() const { return m_fixedPointPrecision; }
-
-	size_t evaluate(Chromosome const& _chromosome) override;
-
-private:
-	size_t m_fixedPointPrecision;
-};
-
-/**
- * Abstract base class for fitness metrics that compute their value based on values of multiple
- * other, nested metrics.
- */
-class FitnessMetricCombination: public FitnessMetric
-{
-public:
-	explicit FitnessMetricCombination(std::vector<std::shared_ptr<FitnessMetric>> _metrics):
-		m_metrics(std::move(_metrics)) {}
-
-	std::vector<std::shared_ptr<FitnessMetric>> const& metrics() const { return m_metrics; }
-
-protected:
-	std::vector<std::shared_ptr<FitnessMetric>> m_metrics;
-};
-
-/**
- * Fitness metric that returns the average of values of its nested metrics.
- */
-class FitnessMetricAverage: public FitnessMetricCombination
-{
-public:
-	using FitnessMetricCombination::FitnessMetricCombination;
-	size_t evaluate(Chromosome const& _chromosome) override;
-};
-
-/**
- * Fitness metric that returns the sum of values of its nested metrics.
- */
-class FitnessMetricSum: public FitnessMetricCombination
-{
-public:
-	using FitnessMetricCombination::FitnessMetricCombination;
-	size_t evaluate(Chromosome const& _chromosome) override;
-};
-
-/**
- * Fitness metric that returns the highest of values of its nested metrics.
- */
-class FitnessMetricMaximum: public FitnessMetricCombination
-{
-public:
-	using FitnessMetricCombination::FitnessMetricCombination;
-	size_t evaluate(Chromosome const& _chromosome) override;
-};
-
-/**
- * Fitness metric that returns the lowest of values of its nested metrics.
- */
-class FitnessMetricMinimum: public FitnessMetricCombination
-{
-public:
-	using FitnessMetricCombination::FitnessMetricCombination;
-	size_t evaluate(Chromosome const& _chromosome) override;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/GeneticAlgorithms.cpp b/compiler/tools/yulPhaser/GeneticAlgorithms.cpp
deleted file mode 100644
index ff40d222..00000000
--- a/compiler/tools/yulPhaser/GeneticAlgorithms.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/GeneticAlgorithms.h>
-#include <tools/yulPhaser/Mutations.h>
-#include <tools/yulPhaser/Selections.h>
-#include <tools/yulPhaser/PairSelections.h>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::phaser;
-
-function<Crossover> phaser::buildCrossoverOperator(
-	CrossoverChoice _choice,
-	optional<double> _uniformCrossoverSwapChance
-)
-{
-	switch (_choice)
-	{
-		case CrossoverChoice::SinglePoint:
-			return randomPointCrossover();
-		case CrossoverChoice::TwoPoint:
-			return randomTwoPointCrossover();
-		case CrossoverChoice::Uniform:
-			assert(_uniformCrossoverSwapChance.has_value());
-			return uniformCrossover(_uniformCrossoverSwapChance.value());
-		default:
-			assertThrow(false, solidity::util::Exception, "Invalid CrossoverChoice value.");
-	};
-}
-
-function<SymmetricCrossover> phaser::buildSymmetricCrossoverOperator(
-	CrossoverChoice _choice,
-	optional<double> _uniformCrossoverSwapChance
-)
-{
-	switch (_choice)
-	{
-		case CrossoverChoice::SinglePoint:
-			return symmetricRandomPointCrossover();
-		case CrossoverChoice::TwoPoint:
-			return symmetricRandomTwoPointCrossover();
-		case CrossoverChoice::Uniform:
-			assert(_uniformCrossoverSwapChance.has_value());
-			return symmetricUniformCrossover(_uniformCrossoverSwapChance.value());
-		default:
-			assertThrow(false, solidity::util::Exception, "Invalid CrossoverChoice value.");
-	};
-}
-
-Population RandomAlgorithm::runNextRound(Population _population)
-{
-	RangeSelection elite(0.0, m_options.elitePoolSize);
-
-	Population elitePopulation = _population.select(elite);
-	size_t replacementCount = _population.individuals().size() - elitePopulation.individuals().size();
-
-	return
-		std::move(elitePopulation) +
-		Population::makeRandom(
-			_population.fitnessMetric(),
-			replacementCount,
-			m_options.minChromosomeLength,
-			m_options.maxChromosomeLength
-		);
-}
-
-Population GenerationalElitistWithExclusivePools::runNextRound(Population _population)
-{
-	double elitePoolSize = 1.0 - (m_options.mutationPoolSize + m_options.crossoverPoolSize);
-
-	RangeSelection elitePool(0.0, elitePoolSize);
-	RandomSelection mutationPoolFromElite(m_options.mutationPoolSize / elitePoolSize);
-	RandomPairSelection crossoverPoolFromElite(m_options.crossoverPoolSize / elitePoolSize);
-
-	std::function<Mutation> mutationOperator = alternativeMutations(
-		m_options.randomisationChance,
-		geneRandomisation(m_options.percentGenesToRandomise),
-		alternativeMutations(
-			m_options.deletionVsAdditionChance,
-			geneDeletion(m_options.percentGenesToAddOrDelete),
-			geneAddition(m_options.percentGenesToAddOrDelete)
-		)
-	);
-	std::function<Crossover> crossoverOperator = buildCrossoverOperator(
-		m_options.crossover,
-		m_options.uniformCrossoverSwapChance
-	);
-
-	return
-		_population.select(elitePool) +
-		_population.select(elitePool).mutate(mutationPoolFromElite, mutationOperator) +
-		_population.select(elitePool).crossover(crossoverPoolFromElite, crossoverOperator);
-}
-
-Population ClassicGeneticAlgorithm::runNextRound(Population _population)
-{
-	Population elite = _population.select(RangeSelection(0.0, m_options.elitePoolSize));
-	Population rest = _population.select(RangeSelection(m_options.elitePoolSize, 1.0));
-
-	Population selectedPopulation = select(_population, rest.individuals().size());
-
-	std::function<SymmetricCrossover> crossoverOperator = buildSymmetricCrossoverOperator(
-		m_options.crossover,
-		m_options.uniformCrossoverSwapChance
-	);
-
-	Population crossedPopulation = Population::combine(
-		selectedPopulation.symmetricCrossoverWithRemainder(
-			PairsFromRandomSubset(m_options.crossoverChance),
-			crossoverOperator
-		)
-	);
-
-	std::function<Mutation> mutationOperator = mutationSequence({
-		geneRandomisation(m_options.mutationChance),
-		geneDeletion(m_options.deletionChance),
-		geneAddition(m_options.additionChance),
-	});
-
-	RangeSelection all(0.0, 1.0);
-	Population mutatedPopulation = crossedPopulation.mutate(all, mutationOperator);
-
-	return elite + mutatedPopulation;
-}
-
-Population ClassicGeneticAlgorithm::select(Population _population, size_t _selectionSize)
-{
-	if (_population.individuals().size() == 0)
-		return _population;
-
-	size_t maxFitness = 0;
-	for (auto const& individual: _population.individuals())
-		maxFitness = max(maxFitness, individual.fitness);
-
-	size_t rouletteRange = 0;
-	for (auto const& individual: _population.individuals())
-		// Add 1 to make sure that every chromosome has non-zero probability of being chosen
-		rouletteRange += maxFitness + 1 - individual.fitness;
-
-	vector<Individual> selectedIndividuals;
-	for (size_t i = 0; i < _selectionSize; ++i)
-	{
-		size_t ball = SimulationRNG::uniformInt(0, rouletteRange - 1);
-
-		size_t cumulativeFitness = 0;
-		for (auto const& individual: _population.individuals())
-		{
-			size_t pocketSize = maxFitness + 1 - individual.fitness;
-			if (ball < cumulativeFitness + pocketSize)
-			{
-				selectedIndividuals.push_back(individual);
-				break;
-			}
-			cumulativeFitness += pocketSize;
-		}
-	}
-
-	assert(selectedIndividuals.size() == _selectionSize);
-	return Population(_population.fitnessMetric(), selectedIndividuals);
-}
diff --git a/compiler/tools/yulPhaser/GeneticAlgorithms.h b/compiler/tools/yulPhaser/GeneticAlgorithms.h
deleted file mode 100644
index 936139af..00000000
--- a/compiler/tools/yulPhaser/GeneticAlgorithms.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains an abstract base class representing a genetic algorithm and its concrete implementations.
- */
-
-#pragma once
-
-#include <tools/yulPhaser/Mutations.h>
-#include <tools/yulPhaser/Population.h>
-
-#include <cstddef>
-#include <optional>
-
-namespace solidity::phaser
-{
-
-enum class CrossoverChoice
-{
-	SinglePoint,
-	TwoPoint,
-	Uniform,
-};
-
-std::function<Crossover> buildCrossoverOperator(
-	CrossoverChoice _choice,
-	std::optional<double> _uniformCrossoverSwapChance
-);
-
-std::function<SymmetricCrossover> buildSymmetricCrossoverOperator(
-	CrossoverChoice _choice,
-	std::optional<double> _uniformCrossoverSwapChance
-);
-
-/**
- * Abstract base class for genetic algorithms.
- * The main feature is the @a runNextRound() method that executes one round of the algorithm,
- * on the supplied population.
- */
-class GeneticAlgorithm
-{
-public:
-	GeneticAlgorithm() {}
-	GeneticAlgorithm(GeneticAlgorithm const&) = delete;
-	GeneticAlgorithm& operator=(GeneticAlgorithm const&) = delete;
-	virtual ~GeneticAlgorithm() = default;
-
-	/// The method that actually implements the algorithm. Should accept the current population in
-	/// @a _population and return the updated one after the round.
-	virtual Population runNextRound(Population _population) = 0;
-};
-
-/**
- * Completely random genetic algorithm,
- *
- * The algorithm simply replaces the worst chromosomes with entirely new ones, generated
- * randomly and not based on any member of the current population. Only a constant proportion of the
- * chromosomes (the elite) is preserved in each round.
- *
- * Preserves the size of the population. You can use @a elitePoolSize to make the algorithm
- * generational (replacing most members in each round) or steady state (replacing only one member).
- * Both versions are equivalent in terms of the outcome but the generational one converges in a
- * smaller number of rounds while the steady state one does less work per round. This may matter
- * in case of metrics that take a long time to compute though in case of this particular
- * algorithm the same result could also be achieved by simply making the population smaller.
- */
-class RandomAlgorithm: public GeneticAlgorithm
-{
-public:
-	struct Options
-	{
-		double elitePoolSize;        ///< Percentage of the population treated as the elite
-		size_t minChromosomeLength;  ///< Minimum length of newly generated chromosomes
-		size_t maxChromosomeLength;  ///< Maximum length of newly generated chromosomes
-
-		bool isValid() const
-		{
-			return (
-				0 <= elitePoolSize && elitePoolSize <= 1.0 &&
-				minChromosomeLength <= maxChromosomeLength
-			);
-		}
-	};
-
-	explicit RandomAlgorithm(Options const& _options):
-		m_options(_options)
-	{
-		assert(_options.isValid());
-	}
-
-	Options const& options() const { return m_options; }
-
-	Population runNextRound(Population _population) override;
-
-private:
-	Options m_options;
-};
-
-/**
- * A generational, elitist genetic algorithm that replaces the population by mutating and crossing
- * over chromosomes from the elite.
- *
- * The elite consists of individuals not included in the crossover and mutation pools.
- * The crossover operator used is @a randomPointCrossover. The mutation operator is randomly chosen
- * from three possibilities: @a geneRandomisation, @a geneDeletion or @a geneAddition (with
- * configurable probabilities). Each mutation also has a parameter determining the chance of a gene
- * being affected by it.
- */
-class GenerationalElitistWithExclusivePools: public GeneticAlgorithm
-{
-public:
-	struct Options
-	{
-		double mutationPoolSize;          ///< Percentage of population to regenerate using mutations in each round.
-		double crossoverPoolSize;         ///< Percentage of population to regenerate using crossover in each round.
-		double randomisationChance;       ///< The chance of choosing @a geneRandomisation as the mutation to perform
-		double deletionVsAdditionChance;  ///< The chance of choosing @a geneDeletion as the mutation if randomisation was not chosen.
-		double percentGenesToRandomise;   ///< The chance of any given gene being mutated in gene randomisation.
-		double percentGenesToAddOrDelete; ///< The chance of a gene being added (or deleted) in gene addition (or deletion).
-		CrossoverChoice crossover;        ///< The crossover operator to use.
-		std::optional<double> uniformCrossoverSwapChance; ///< Chance of a pair of genes being swapped in uniform crossover.
-
-		bool isValid() const
-		{
-			return (
-				0 <= mutationPoolSize && mutationPoolSize <= 1.0 &&
-				0 <= crossoverPoolSize && crossoverPoolSize <= 1.0 &&
-				0 <= randomisationChance && randomisationChance <= 1.0 &&
-				0 <= deletionVsAdditionChance && deletionVsAdditionChance <= 1.0 &&
-				0 <= percentGenesToRandomise && percentGenesToRandomise <= 1.0 &&
-				0 <= percentGenesToAddOrDelete && percentGenesToAddOrDelete <= 1.0 &&
-				0 <= uniformCrossoverSwapChance && uniformCrossoverSwapChance <= 1.0 &&
-				mutationPoolSize + crossoverPoolSize <= 1.0
-			);
-		}
-	};
-
-	GenerationalElitistWithExclusivePools(Options const& _options):
-		m_options(_options)
-	{
-		assert(_options.isValid());
-	}
-
-	Options const& options() const { return m_options; }
-
-	Population runNextRound(Population _population) override;
-
-private:
-	Options m_options;
-};
-
-/**
- * A typical genetic algorithm that works in three distinct phases, each resulting in a new,
- * modified population:
- * - selection: chromosomes are selected from the population with probability proportional to their
- *   fitness. A chromosome can be selected more than once. The new population has the same size as
- *   the old one.
- * - crossover: first, for each chromosome we decide whether it undergoes crossover or not
- *   (according to crossover chance parameter). Then each selected chromosome is randomly paired
- *   with one other selected chromosome. Each pair produces a pair of children and gets replaced by
- *   it in the population.
- * - mutation: we go over each gene in the population and independently decide whether to mutate it
- *   or not (according to mutation chance parameters). This is repeated for every mutation type so
- *   one gene can undergo mutations of multiple types in a single round.
- *
- * This implementation also has the ability to preserve the top chromosomes in each round.
- */
-class ClassicGeneticAlgorithm: public GeneticAlgorithm
-{
-public:
-	struct Options
-	{
-		double elitePoolSize;      ///< Percentage of the population treated as the elite.
-		double crossoverChance;    ///< The chance of a particular chromosome being selected for crossover.
-		double mutationChance;     ///< The chance of a particular gene being randomised in @a geneRandomisation mutation.
-		double deletionChance;     ///< The chance of a particular gene being deleted in @a geneDeletion mutation.
-		double additionChance;     ///< The chance of a particular gene being added in @a geneAddition mutation.
-		CrossoverChoice crossover; ///< The crossover operator to use
-		std::optional<double> uniformCrossoverSwapChance; ///< Chance of a pair of genes being swapped in uniform crossover.
-
-		bool isValid() const
-		{
-			return (
-				0 <= elitePoolSize && elitePoolSize <= 1.0 &&
-				0 <= crossoverChance && crossoverChance <= 1.0 &&
-				0 <= mutationChance && mutationChance <= 1.0 &&
-				0 <= deletionChance && deletionChance <= 1.0 &&
-				0 <= additionChance && additionChance <= 1.0 &&
-				0 <= uniformCrossoverSwapChance && uniformCrossoverSwapChance <= 1.0
-			);
-		}
-	};
-
-	ClassicGeneticAlgorithm(Options const& _options):
-		m_options(_options)
-	{
-		assert(_options.isValid());
-	}
-
-	Options const& options() const { return m_options; }
-
-	Population runNextRound(Population _population) override;
-
-private:
-	static Population select(Population _population, size_t _selectionSize);
-
-	Options m_options;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Mutations.cpp b/compiler/tools/yulPhaser/Mutations.cpp
deleted file mode 100644
index 873fbbb9..00000000
--- a/compiler/tools/yulPhaser/Mutations.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Mutations.h>
-
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <libsolutil/CommonData.h>
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <string>
-#include <vector>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::phaser;
-
-function<Mutation> phaser::geneRandomisation(double _chance)
-{
-	return [=](Chromosome const& _chromosome)
-	{
-		string genes;
-		for (char gene: _chromosome.genes())
-			genes.push_back(
-				SimulationRNG::bernoulliTrial(_chance) ?
-				Chromosome::randomGene() :
-				gene
-			);
-
-		return Chromosome(std::move(genes));
-	};
-}
-
-function<Mutation> phaser::geneDeletion(double _chance)
-{
-	return [=](Chromosome const& _chromosome)
-	{
-		string genes;
-		for (char gene: _chromosome.genes())
-			if (!SimulationRNG::bernoulliTrial(_chance))
-				genes.push_back(gene);
-
-		return Chromosome(std::move(genes));
-	};
-}
-
-function<Mutation> phaser::geneAddition(double _chance)
-{
-	return [=](Chromosome const& _chromosome)
-	{
-		string genes;
-
-		if (SimulationRNG::bernoulliTrial(_chance))
-			genes.push_back(Chromosome::randomGene());
-
-		for (char gene: _chromosome.genes())
-		{
-			genes.push_back(gene);
-			if (SimulationRNG::bernoulliTrial(_chance))
-				genes.push_back(Chromosome::randomGene());
-		}
-
-		return Chromosome(std::move(genes));
-	};
-}
-
-function<Mutation> phaser::alternativeMutations(
-	double _firstMutationChance,
-	function<Mutation> _mutation1,
-	function<Mutation> _mutation2
-)
-{
-	return [=](Chromosome const& _chromosome)
-	{
-		if (SimulationRNG::bernoulliTrial(_firstMutationChance))
-			return _mutation1(_chromosome);
-		else
-			return _mutation2(_chromosome);
-	};
-}
-
-function<Mutation> phaser::mutationSequence(vector<function<Mutation>> _mutations)
-{
-	return [=](Chromosome const& _chromosome)
-	{
-		Chromosome mutatedChromosome = _chromosome;
-		for (size_t i = 0; i < _mutations.size(); ++i)
-			mutatedChromosome = _mutations[i](std::move(mutatedChromosome));
-
-		return mutatedChromosome;
-	};
-}
-
-namespace
-{
-
-ChromosomePair fixedPointSwap(
-	Chromosome const& _chromosome1,
-	Chromosome const& _chromosome2,
-	size_t _crossoverPoint
-)
-{
-	assert(_crossoverPoint <= _chromosome1.length());
-	assert(_crossoverPoint <= _chromosome2.length());
-
-	return {
-		Chromosome(
-			_chromosome1.genes().substr(0, _crossoverPoint) +
-			_chromosome2.genes().substr(_crossoverPoint, _chromosome2.length() - _crossoverPoint)
-		),
-		Chromosome(
-			_chromosome2.genes().substr(0, _crossoverPoint) +
-			_chromosome1.genes().substr(_crossoverPoint, _chromosome1.length() - _crossoverPoint)
-		),
-	};
-}
-
-}
-
-function<Crossover> phaser::randomPointCrossover()
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-
-		// Don't use position 0 (because this just swaps the values) unless it's the only choice.
-		size_t minPoint = (minLength > 0 ? 1 : 0);
-		assert(minPoint <= minLength);
-
-		size_t randomPoint = SimulationRNG::uniformInt(minPoint, minLength);
-		return get<0>(fixedPointSwap(_chromosome1, _chromosome2, randomPoint));
-	};
-}
-
-function<SymmetricCrossover> phaser::symmetricRandomPointCrossover()
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-
-		// Don't use position 0 (because this just swaps the values) unless it's the only choice.
-		size_t minPoint = (minLength > 0 ? 1 : 0);
-		assert(minPoint <= minLength);
-
-		size_t randomPoint = SimulationRNG::uniformInt(minPoint, minLength);
-		return fixedPointSwap(_chromosome1, _chromosome2, randomPoint);
-	};
-}
-
-function<Crossover> phaser::fixedPointCrossover(double _crossoverPoint)
-{
-	assert(0.0 <= _crossoverPoint && _crossoverPoint <= 1.0);
-
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-		size_t concretePoint = static_cast<size_t>(round(double(minLength) * _crossoverPoint));
-
-		return get<0>(fixedPointSwap(_chromosome1, _chromosome2, concretePoint));
-	};
-}
-
-namespace
-{
-
-ChromosomePair fixedTwoPointSwap(
-	Chromosome const& _chromosome1,
-	Chromosome const& _chromosome2,
-	size_t _crossoverPoint1,
-	size_t _crossoverPoint2
-)
-{
-	assert(_crossoverPoint1 <= _chromosome1.length());
-	assert(_crossoverPoint1 <= _chromosome2.length());
-	assert(_crossoverPoint2 <= _chromosome1.length());
-	assert(_crossoverPoint2 <= _chromosome2.length());
-
-	size_t lowPoint = min(_crossoverPoint1, _crossoverPoint2);
-	size_t highPoint = max(_crossoverPoint1, _crossoverPoint2);
-
-	return {
-		Chromosome(
-			_chromosome1.genes().substr(0, lowPoint) +
-			_chromosome2.genes().substr(lowPoint, highPoint - lowPoint) +
-			_chromosome1.genes().substr(highPoint, _chromosome1.length() - highPoint)
-		),
-		Chromosome(
-			_chromosome2.genes().substr(0, lowPoint) +
-			_chromosome1.genes().substr(lowPoint, highPoint - lowPoint) +
-			_chromosome2.genes().substr(highPoint, _chromosome2.length() - highPoint)
-		),
-	};
-}
-
-}
-
-function<Crossover> phaser::randomTwoPointCrossover()
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-
-		// Don't use position 0 (because this just swaps the values) unless it's the only choice.
-		size_t minPoint = (minLength > 0 ? 1 : 0);
-		assert(minPoint <= minLength);
-
-		size_t randomPoint1 = SimulationRNG::uniformInt(minPoint, minLength);
-		size_t randomPoint2 = SimulationRNG::uniformInt(randomPoint1, minLength);
-		return get<0>(fixedTwoPointSwap(_chromosome1, _chromosome2, randomPoint1, randomPoint2));
-	};
-}
-
-function<SymmetricCrossover> phaser::symmetricRandomTwoPointCrossover()
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-
-		// Don't use position 0 (because this just swaps the values) unless it's the only choice.
-		size_t minPoint = (minLength > 0 ? 1 : 0);
-		assert(minPoint <= minLength);
-
-		size_t randomPoint1 = SimulationRNG::uniformInt(minPoint, minLength);
-		size_t randomPoint2 = SimulationRNG::uniformInt(randomPoint1, minLength);
-		return fixedTwoPointSwap(_chromosome1, _chromosome2, randomPoint1, randomPoint2);
-	};
-}
-
-namespace
-{
-
-ChromosomePair uniformSwap(Chromosome const& _chromosome1, Chromosome const& _chromosome2, double _swapChance)
-{
-	string steps1;
-	string steps2;
-
-	size_t minLength = min(_chromosome1.length(), _chromosome2.length());
-	for (size_t i = 0; i < minLength; ++i)
-		if (SimulationRNG::bernoulliTrial(_swapChance))
-		{
-			steps1.push_back(_chromosome2.genes()[i]);
-			steps2.push_back(_chromosome1.genes()[i]);
-		}
-		else
-		{
-			steps1.push_back(_chromosome1.genes()[i]);
-			steps2.push_back(_chromosome2.genes()[i]);
-		}
-
-	bool swapTail = SimulationRNG::bernoulliTrial(_swapChance);
-	if (_chromosome1.length() > minLength)
-	{
-		if (swapTail)
-			steps2 += _chromosome1.genes().substr(minLength, _chromosome1.length() - minLength);
-		else
-			steps1 += _chromosome1.genes().substr(minLength, _chromosome1.length() - minLength);
-	}
-
-	if (_chromosome2.length() > minLength)
-	{
-		if (swapTail)
-			steps1 += _chromosome2.genes().substr(minLength, _chromosome2.length() - minLength);
-		else
-			steps2 += _chromosome2.genes().substr(minLength, _chromosome2.length() - minLength);
-	}
-
-	return {Chromosome(steps1), Chromosome(steps2)};
-}
-
-}
-
-function<Crossover> phaser::uniformCrossover(double _swapChance)
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		return get<0>(uniformSwap(_chromosome1, _chromosome2, _swapChance));
-	};
-}
-
-function<SymmetricCrossover> phaser::symmetricUniformCrossover(double _swapChance)
-{
-	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
-	{
-		return uniformSwap(_chromosome1, _chromosome2, _swapChance);
-	};
-}
diff --git a/compiler/tools/yulPhaser/Mutations.h b/compiler/tools/yulPhaser/Mutations.h
deleted file mode 100644
index abdc4b10..00000000
--- a/compiler/tools/yulPhaser/Mutations.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Mutation and crossover operators for use in genetic algorithms.
- */
-
-#pragma once
-
-#include <tools/yulPhaser/Chromosome.h>
-
-#include <functional>
-#include <tuple>
-
-namespace solidity::phaser
-{
-
-using ChromosomePair = std::tuple<Chromosome, Chromosome>;
-
-using Mutation = Chromosome(Chromosome const&);
-using Crossover = Chromosome(Chromosome const&, Chromosome const&);
-using SymmetricCrossover = ChromosomePair(Chromosome const&, Chromosome const&);
-
-// MUTATIONS
-
-/// Creates a mutation operator that iterates over all genes in a chromosome and with probability
-/// @a _chance replaces a gene with a random one (which could also be the same as the original).
-std::function<Mutation> geneRandomisation(double _chance);
-
-/// Creates a mutation operator that iterates over all genes in a chromosome and with probability
-/// @a _chance deletes it.
-std::function<Mutation> geneDeletion(double _chance);
-
-/// Creates a mutation operator that iterates over all positions in a chromosome (including spots
-/// at the beginning and at the end of the sequence) and with probability @a _chance insert a new,
-/// randomly chosen gene.
-std::function<Mutation> geneAddition(double _chance);
-
-/// Creates a mutation operator that always applies one of the mutations passed to it.
-/// The probability that the chosen mutation is the first one is @a _firstMutationChance.
-/// randomly chosen gene.
-std::function<Mutation> alternativeMutations(
-	double _firstMutationChance,
-	std::function<Mutation> _mutation1,
-	std::function<Mutation> _mutation2
-);
-
-/// Creates a mutation operator that sequentially applies all the operators given in @a _mutations.
-std::function<Mutation> mutationSequence(std::vector<std::function<Mutation>> _mutations);
-
-// CROSSOVER
-
-/// Creates a crossover operator that randomly selects a number between 0 and 1 and uses it as the
-/// position at which to perform perform @a fixedPointCrossover.
-std::function<Crossover> randomPointCrossover();
-
-/// Symmetric version of @a randomPointCrossover(). Creates an operator that returns a pair
-/// containing both possible results for the same crossover point.
-std::function<SymmetricCrossover> symmetricRandomPointCrossover();
-
-/// Creates a crossover operator that always chooses a point that lies at @a _crossoverPoint
-/// percent of the length of the shorter chromosome. Then creates a new chromosome by
-/// splitting both inputs at the crossover point and stitching output from the first half or first
-/// input and the second half of the second input.
-///
-/// Avoids selecting position 0 (since this just produces a chromosome identical to the second one)
-/// unless there is no other choice (i.e. one of the chromosomes is empty).
-std::function<Crossover> fixedPointCrossover(double _crossoverPoint);
-
-/// Creates a crossover operator that randomly selects two points between 0 and 1 and swaps genes
-/// from the resulting interval. The interval may be empty in which case no genes are swapped.
-std::function<Crossover> randomTwoPointCrossover();
-
-/// Symmetric version of @a randomTwoPointCrossover(). Creates an operator that returns a pair
-/// containing both possible results for the same crossover points.
-std::function<SymmetricCrossover> symmetricRandomTwoPointCrossover();
-
-/// Creates a crossover operator that goes over the length of the shorter chromosomes and for
-/// each gene independently decides whether to swap it or not (with probability given by
-/// @a _swapChance). The tail of the longer chromosome (the part that's past the length of the
-/// shorter one) is treated as a single gene and can potentially be swapped too.
-std::function<Crossover> uniformCrossover(double _swapChance);
-
-/// Symmetric version of @a uniformCrossover(). Creates an operator that returns a pair
-/// containing both possible results for the same set or swap decisions.
-std::function<SymmetricCrossover> symmetricUniformCrossover(double _swapChance);
-
-}
diff --git a/compiler/tools/yulPhaser/PairSelections.cpp b/compiler/tools/yulPhaser/PairSelections.cpp
deleted file mode 100644
index 4c9d4ee5..00000000
--- a/compiler/tools/yulPhaser/PairSelections.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/PairSelections.h>
-
-#include <tools/yulPhaser/Selections.h>
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <cmath>
-
-using namespace std;
-using namespace solidity::phaser;
-
-vector<tuple<size_t, size_t>> RandomPairSelection::materialise(size_t _poolSize) const
-{
-	if (_poolSize < 2)
-		return {};
-
-	auto count = static_cast<size_t>(round(double(_poolSize) * m_selectionSize));
-
-	vector<tuple<size_t, size_t>> selection;
-	for (size_t i = 0; i < count; ++i)
-	{
-		size_t index1 = SimulationRNG::uniformInt(0, _poolSize - 1);
-		size_t index2;
-		do
-		{
-			index2 = SimulationRNG::uniformInt(0, _poolSize - 1);
-		} while (index1 == index2);
-
-		selection.emplace_back(index1, index2);
-	}
-
-	return selection;
-}
-
-vector<tuple<size_t, size_t>> PairsFromRandomSubset::materialise(size_t _poolSize) const
-{
-	vector<size_t> selectedIndices = RandomSubset(m_selectionChance).materialise(_poolSize);
-
-	if (selectedIndices.size() % 2 != 0)
-	{
-		if (selectedIndices.size() < _poolSize && SimulationRNG::bernoulliTrial(0.5))
-		{
-			do
-			{
-				size_t extraIndex = SimulationRNG::uniformInt(0, selectedIndices.size() - 1);
-				if (find(selectedIndices.begin(), selectedIndices.end(), extraIndex) == selectedIndices.end())
-					selectedIndices.push_back(extraIndex);
-			} while (selectedIndices.size() % 2 != 0);
-		}
-		else
-			selectedIndices.erase(
-				selectedIndices.begin() +
-				static_cast<ptrdiff_t>(SimulationRNG::uniformInt(0, selectedIndices.size() - 1))
-			);
-	}
-	assert(selectedIndices.size() % 2 == 0);
-
-	vector<tuple<size_t, size_t>> selectedPairs;
-	for (size_t i = selectedIndices.size() / 2; i > 0; --i)
-	{
-		size_t position1 = SimulationRNG::uniformInt(0, selectedIndices.size() - 1);
-		size_t value1 = selectedIndices[position1];
-		selectedIndices.erase(selectedIndices.begin() + static_cast<ptrdiff_t>(position1));
-		size_t position2 = SimulationRNG::uniformInt(0, selectedIndices.size() - 1);
-		size_t value2 = selectedIndices[position2];
-		selectedIndices.erase(selectedIndices.begin() + static_cast<ptrdiff_t>(position2));
-
-		selectedPairs.emplace_back(value1, value2);
-	}
-	assert(selectedIndices.empty());
-
-	return selectedPairs;
-}
-
-vector<tuple<size_t, size_t>> PairMosaicSelection::materialise(size_t _poolSize) const
-{
-	if (_poolSize < 2)
-		return {};
-
-	size_t count = static_cast<size_t>(round(double(_poolSize) * m_selectionSize));
-
-	vector<tuple<size_t, size_t>> selection;
-	for (size_t i = 0; i < count; ++i)
-	{
-		tuple<size_t, size_t> pair = m_pattern[i % m_pattern.size()];
-		selection.emplace_back(min(get<0>(pair), _poolSize - 1), min(get<1>(pair), _poolSize - 1));
-	}
-
-	return selection;
-}
diff --git a/compiler/tools/yulPhaser/PairSelections.h b/compiler/tools/yulPhaser/PairSelections.h
deleted file mode 100644
index 12532c76..00000000
--- a/compiler/tools/yulPhaser/PairSelections.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains an abstract base class representing a selection of pairs of elements from a collection
- * and its concrete implementations.
- */
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <tuple>
-#include <vector>
-
-namespace solidity::phaser
-{
-
-/**
- * Abstract base class for selections of pairs elements from a collection.
- *
- * An instance of this class represents a specific method of selecting a set of pairs of elements
- * from containers of arbitrary sizes. The selected pairs always point at a subset of the elements
- * from the container but may indicate the same element more than once. The pairs themselves can
- * repeat too. The selection may or may not be fixed - it's up to a specific implementation whether
- * subsequent calls for the same container produce the same indices or not.
- *
- * Derived classes are meant to override the @a materialise() method.
- * This method is expected to produce pairs of selected elements given the size of the collection.
- */
-class PairSelection
-{
-public:
-	PairSelection() = default;
-	PairSelection(PairSelection const&) = delete;
-	PairSelection& operator=(PairSelection const&) = delete;
-	virtual ~PairSelection() = default;
-
-	virtual std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const = 0;
-};
-
-/**
- * A selection that selects pairs of random elements from a container. The resulting set of pairs
- * may contain the same pair more than once but does not contain pairs of duplicates. Always
- * selects as many pairs as the size of the container multiplied by @a _selectionSize (unless the
- * container is empty).
- */
-class RandomPairSelection: public PairSelection
-{
-public:
-	explicit RandomPairSelection(double _selectionSize):
-		m_selectionSize(_selectionSize) {}
-
-	std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const override;
-
-private:
-	double m_selectionSize;
-};
-
-
-/**
- * A selection that goes over all elements in a container, for each one independently decides
- * whether to select it or not and then randomly combines those elements into pairs. If the number
- * of elements is odd, randomly decides whether to take one more or exclude one.
- *
- * Each element has the same chance of being selected and can be selected at most once.
- * The number of selected elements is random and can be different with each call to
- * @a materialise().
- */
-class PairsFromRandomSubset: public PairSelection
-{
-public:
-	explicit PairsFromRandomSubset(double _selectionChance):
-		m_selectionChance(_selectionChance) {}
-
-	std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const override;
-
-private:
-	double m_selectionChance;
-};
-
-/**
- * A selection that selects pairs of elements at specific, fixed positions indicated by a repeating
- * "pattern". If the positions in the pattern exceed the size of the container, they are capped at
- * the maximum available position. Always selects as many pairs as the size of the container
- * multiplied by @a _selectionSize (unless the container is empty).
- *
- * E.g. if the pattern is {{0, 1}, {3, 9}} and collection size is 5, the selection will materialise
- * into {{0, 1}, {3, 4}, {0, 1}, {3, 4}, {0, 1}}. If the size is 3, it will be
- * {{0, 1}, {2, 2}, {0, 1}}.
- */
-class PairMosaicSelection: public PairSelection
-{
-public:
-	explicit PairMosaicSelection(std::vector<std::tuple<size_t, size_t>> _pattern, double _selectionSize = 1.0):
-		m_pattern(std::move(_pattern)),
-		m_selectionSize(_selectionSize)
-	{
-		assert(m_pattern.size() > 0 || _selectionSize == 0.0);
-	}
-
-	std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const override;
-
-private:
-	std::vector<std::tuple<size_t, size_t>> m_pattern;
-	double m_selectionSize;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Phaser.cpp b/compiler/tools/yulPhaser/Phaser.cpp
deleted file mode 100644
index db5ec35c..00000000
--- a/compiler/tools/yulPhaser/Phaser.cpp
+++ /dev/null
@@ -1,884 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Phaser.h>
-
-#include <tools/yulPhaser/AlgorithmRunner.h>
-#include <tools/yulPhaser/Common.h>
-#include <tools/yulPhaser/Exceptions.h>
-#include <tools/yulPhaser/FitnessMetrics.h>
-#include <tools/yulPhaser/GeneticAlgorithms.h>
-#include <tools/yulPhaser/Program.h>
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <liblangutil/CharStream.h>
-#include <liblangutil/CharStreamProvider.h>
-#include <liblangutil/SourceReferenceFormatter.h>
-#include <liblangutil/Scanner.h>
-
-#include <libsolutil/Assertions.h>
-#include <libsolutil/CommonData.h>
-#include <libsolutil/CommonIO.h>
-
-#include <iostream>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::langutil;
-using namespace solidity::util;
-using namespace solidity::yul;
-using namespace solidity::phaser;
-
-namespace po = boost::program_options;
-
-namespace
-{
-
-map<PhaserMode, string> const PhaserModeToStringMap =
-{
-	{PhaserMode::RunAlgorithm, "run-algorithm"},
-	{PhaserMode::PrintOptimisedPrograms, "print-optimised-programs"},
-	{PhaserMode::PrintOptimisedASTs, "print-optimised-asts"},
-};
-map<string, PhaserMode> const StringToPhaserModeMap = invertMap(PhaserModeToStringMap);
-
-map<Algorithm, string> const AlgorithmToStringMap =
-{
-	{Algorithm::Random, "random"},
-	{Algorithm::GEWEP, "GEWEP"},
-	{Algorithm::Classic, "classic"},
-};
-map<string, Algorithm> const StringToAlgorithmMap = invertMap(AlgorithmToStringMap);
-
-map<MetricChoice, string> MetricChoiceToStringMap =
-{
-	{MetricChoice::CodeSize, "code-size"},
-	{MetricChoice::RelativeCodeSize, "relative-code-size"},
-};
-map<string, MetricChoice> const StringToMetricChoiceMap = invertMap(MetricChoiceToStringMap);
-
-map<MetricAggregatorChoice, string> const MetricAggregatorChoiceToStringMap =
-{
-	{MetricAggregatorChoice::Average, "average"},
-	{MetricAggregatorChoice::Sum, "sum"},
-	{MetricAggregatorChoice::Maximum, "maximum"},
-	{MetricAggregatorChoice::Minimum, "minimum"},
-};
-map<string, MetricAggregatorChoice> const StringToMetricAggregatorChoiceMap = invertMap(MetricAggregatorChoiceToStringMap);
-
-map<CrossoverChoice, string> const CrossoverChoiceToStringMap =
-{
-	{CrossoverChoice::SinglePoint, "single-point"},
-	{CrossoverChoice::TwoPoint, "two-point"},
-	{CrossoverChoice::Uniform, "uniform"},
-};
-map<string, CrossoverChoice> const StringToCrossoverChoiceMap = invertMap(CrossoverChoiceToStringMap);
-
-}
-
-istream& phaser::operator>>(istream& _inputStream, PhaserMode& _phaserMode) { return deserializeChoice(_inputStream, _phaserMode, StringToPhaserModeMap); }
-ostream& phaser::operator<<(ostream& _outputStream, PhaserMode _phaserMode) { return serializeChoice(_outputStream, _phaserMode, PhaserModeToStringMap); }
-istream& phaser::operator>>(istream& _inputStream, Algorithm& _algorithm) { return deserializeChoice(_inputStream, _algorithm, StringToAlgorithmMap); }
-ostream& phaser::operator<<(ostream& _outputStream, Algorithm _algorithm) { return serializeChoice(_outputStream, _algorithm, AlgorithmToStringMap); }
-istream& phaser::operator>>(istream& _inputStream, MetricChoice& _metric) { return deserializeChoice(_inputStream, _metric, StringToMetricChoiceMap); }
-ostream& phaser::operator<<(ostream& _outputStream, MetricChoice _metric) { return serializeChoice(_outputStream, _metric, MetricChoiceToStringMap); }
-istream& phaser::operator>>(istream& _inputStream, MetricAggregatorChoice& _aggregator) { return deserializeChoice(_inputStream, _aggregator, StringToMetricAggregatorChoiceMap); }
-ostream& phaser::operator<<(ostream& _outputStream, MetricAggregatorChoice _aggregator) { return serializeChoice(_outputStream, _aggregator, MetricAggregatorChoiceToStringMap); }
-istream& phaser::operator>>(istream& _inputStream, CrossoverChoice& _crossover) { return deserializeChoice(_inputStream, _crossover, StringToCrossoverChoiceMap); }
-ostream& phaser::operator<<(ostream& _outputStream, CrossoverChoice _crossover) { return serializeChoice(_outputStream, _crossover, CrossoverChoiceToStringMap); }
-
-GeneticAlgorithmFactory::Options GeneticAlgorithmFactory::Options::fromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["algorithm"].as<Algorithm>(),
-		_arguments["min-chromosome-length"].as<size_t>(),
-		_arguments["max-chromosome-length"].as<size_t>(),
-		_arguments["crossover"].as<CrossoverChoice>(),
-		_arguments["uniform-crossover-swap-chance"].as<double>(),
-		_arguments.count("random-elite-pool-size") > 0 ?
-			_arguments["random-elite-pool-size"].as<double>() :
-			optional<double>{},
-		_arguments["gewep-mutation-pool-size"].as<double>(),
-		_arguments["gewep-crossover-pool-size"].as<double>(),
-		_arguments["gewep-randomisation-chance"].as<double>(),
-		_arguments["gewep-deletion-vs-addition-chance"].as<double>(),
-		_arguments.count("gewep-genes-to-randomise") > 0 ?
-			_arguments["gewep-genes-to-randomise"].as<double>() :
-			optional<double>{},
-		_arguments.count("gewep-genes-to-add-or-delete") > 0 ?
-			_arguments["gewep-genes-to-add-or-delete"].as<double>() :
-			optional<double>{},
-		_arguments["classic-elite-pool-size"].as<double>(),
-		_arguments["classic-crossover-chance"].as<double>(),
-		_arguments["classic-mutation-chance"].as<double>(),
-		_arguments["classic-deletion-chance"].as<double>(),
-		_arguments["classic-addition-chance"].as<double>(),
-	};
-}
-
-unique_ptr<GeneticAlgorithm> GeneticAlgorithmFactory::build(
-	Options const& _options,
-	size_t _populationSize
-)
-{
-	assert(_populationSize > 0);
-
-	switch (_options.algorithm)
-	{
-		case Algorithm::Random:
-		{
-			double elitePoolSize = 1.0 / double(_populationSize);
-
-			if (_options.randomElitePoolSize.has_value())
-				elitePoolSize = _options.randomElitePoolSize.value();
-
-			return make_unique<RandomAlgorithm>(RandomAlgorithm::Options{
-				/* elitePoolSize = */ elitePoolSize,
-				/* minChromosomeLength = */ _options.minChromosomeLength,
-				/* maxChromosomeLength = */ _options.maxChromosomeLength,
-			});
-		}
-		case Algorithm::GEWEP:
-		{
-			double percentGenesToRandomise = 1.0 / double(_options.maxChromosomeLength);
-			double percentGenesToAddOrDelete = percentGenesToRandomise;
-
-			if (_options.gewepGenesToRandomise.has_value())
-				percentGenesToRandomise = _options.gewepGenesToRandomise.value();
-			if (_options.gewepGenesToAddOrDelete.has_value())
-				percentGenesToAddOrDelete = _options.gewepGenesToAddOrDelete.value();
-
-			return make_unique<GenerationalElitistWithExclusivePools>(GenerationalElitistWithExclusivePools::Options{
-				/* mutationPoolSize = */ _options.gewepMutationPoolSize,
-				/* crossoverPoolSize = */ _options.gewepCrossoverPoolSize,
-				/* randomisationChance = */ _options.gewepRandomisationChance,
-				/* deletionVsAdditionChance = */ _options.gewepDeletionVsAdditionChance,
-				/* percentGenesToRandomise = */ percentGenesToRandomise,
-				/* percentGenesToAddOrDelete = */ percentGenesToAddOrDelete,
-				/* crossover = */ _options.crossover,
-				/* uniformCrossoverSwapChance = */ _options.uniformCrossoverSwapChance,
-			});
-		}
-		case Algorithm::Classic:
-		{
-			return make_unique<ClassicGeneticAlgorithm>(ClassicGeneticAlgorithm::Options{
-				/* elitePoolSize = */ _options.classicElitePoolSize,
-				/* crossoverChance = */ _options.classicCrossoverChance,
-				/* mutationChance = */ _options.classicMutationChance,
-				/* deletionChance = */ _options.classicDeletionChance,
-				/* additionChance = */ _options.classicAdditionChance,
-				/* crossover = */ _options.crossover,
-				/* uniformCrossoverSwapChance = */ _options.uniformCrossoverSwapChance,
-			});
-		}
-		default:
-			assertThrow(false, solidity::util::Exception, "Invalid Algorithm value.");
-	}
-}
-
-CodeWeights CodeWeightFactory::buildFromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["expression-statement-cost"].as<size_t>(),
-		_arguments["assignment-cost"].as<size_t>(),
-		_arguments["variable-declaration-cost"].as<size_t>(),
-		_arguments["function-definition-cost"].as<size_t>(),
-		_arguments["if-cost"].as<size_t>(),
-		_arguments["switch-cost"].as<size_t>(),
-		_arguments["case-cost"].as<size_t>(),
-		_arguments["for-loop-cost"].as<size_t>(),
-		_arguments["break-cost"].as<size_t>(),
-		_arguments["continue-cost"].as<size_t>(),
-		_arguments["leave-cost"].as<size_t>(),
-		_arguments["block-cost"].as<size_t>(),
-		_arguments["function-call-cost"].as<size_t>(),
-		_arguments["identifier-cost"].as<size_t>(),
-		_arguments["literal-cost"].as<size_t>(),
-	};
-}
-
-FitnessMetricFactory::Options FitnessMetricFactory::Options::fromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["metric"].as<MetricChoice>(),
-		_arguments["metric-aggregator"].as<MetricAggregatorChoice>(),
-		_arguments["relative-metric-scale"].as<size_t>(),
-		_arguments["chromosome-repetitions"].as<size_t>(),
-	};
-}
-
-unique_ptr<FitnessMetric> FitnessMetricFactory::build(
-	Options const& _options,
-	vector<Program> _programs,
-	vector<shared_ptr<ProgramCache>> _programCaches,
-	CodeWeights const& _weights
-)
-{
-	assert(_programCaches.size() == _programs.size());
-	assert(_programs.size() > 0 && "Validations should prevent this from being executed with zero files.");
-
-	vector<shared_ptr<FitnessMetric>> metrics;
-	switch (_options.metric)
-	{
-		case MetricChoice::CodeSize:
-		{
-			for (size_t i = 0; i < _programs.size(); ++i)
-				metrics.push_back(make_unique<ProgramSize>(
-					_programCaches[i] != nullptr ? optional<Program>{} : std::move(_programs[i]),
-					std::move(_programCaches[i]),
-					_weights,
-					_options.chromosomeRepetitions
-				));
-
-			break;
-		}
-		case MetricChoice::RelativeCodeSize:
-		{
-			for (size_t i = 0; i < _programs.size(); ++i)
-				metrics.push_back(make_unique<RelativeProgramSize>(
-					_programCaches[i] != nullptr ? optional<Program>{} : std::move(_programs[i]),
-					std::move(_programCaches[i]),
-					_options.relativeMetricScale,
-					_weights,
-					_options.chromosomeRepetitions
-				));
-			break;
-		}
-		default:
-			assertThrow(false, solidity::util::Exception, "Invalid MetricChoice value.");
-	}
-
-	switch (_options.metricAggregator)
-	{
-		case MetricAggregatorChoice::Average:
-			return make_unique<FitnessMetricAverage>(std::move(metrics));
-		case MetricAggregatorChoice::Sum:
-			return make_unique<FitnessMetricSum>(std::move(metrics));
-		case MetricAggregatorChoice::Maximum:
-			return make_unique<FitnessMetricMaximum>(std::move(metrics));
-		case MetricAggregatorChoice::Minimum:
-			return make_unique<FitnessMetricMinimum>(std::move(metrics));
-		default:
-			assertThrow(false, solidity::util::Exception, "Invalid MetricAggregatorChoice value.");
-	}
-
-	// FIXME: Workaround for spurious GCC 12.1 warning (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105794)
-	util::unreachable();
-}
-
-PopulationFactory::Options PopulationFactory::Options::fromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["min-chromosome-length"].as<size_t>(),
-		_arguments["max-chromosome-length"].as<size_t>(),
-		_arguments.count("population") > 0 ?
-			_arguments["population"].as<vector<string>>() :
-			vector<string>{},
-		_arguments.count("random-population") > 0 ?
-			_arguments["random-population"].as<vector<size_t>>() :
-			vector<size_t>{},
-		_arguments.count("population-from-file") > 0 ?
-			_arguments["population-from-file"].as<vector<string>>() :
-			vector<string>{},
-	};
-}
-
-Population PopulationFactory::build(
-	Options const& _options,
-	shared_ptr<FitnessMetric> _fitnessMetric
-)
-{
-	Population population = buildFromStrings(_options.population, _fitnessMetric);
-
-	size_t combinedSize = 0;
-	for (size_t populationSize: _options.randomPopulation)
-		combinedSize += populationSize;
-
-	population = std::move(population) + buildRandom(
-		combinedSize,
-		_options.minChromosomeLength,
-		_options.maxChromosomeLength,
-		_fitnessMetric
-	);
-
-	for (string const& populationFilePath: _options.populationFromFile)
-		population = std::move(population) + buildFromFile(populationFilePath, _fitnessMetric);
-
-	return population;
-}
-
-Population PopulationFactory::buildFromStrings(
-	vector<string> const& _geneSequences,
-	shared_ptr<FitnessMetric> _fitnessMetric
-)
-{
-	vector<Chromosome> chromosomes;
-	for (string const& geneSequence: _geneSequences)
-		chromosomes.emplace_back(geneSequence);
-
-	return Population(std::move(_fitnessMetric), std::move(chromosomes));
-}
-
-Population PopulationFactory::buildRandom(
-	size_t _populationSize,
-	size_t _minChromosomeLength,
-	size_t _maxChromosomeLength,
-	shared_ptr<FitnessMetric> _fitnessMetric
-)
-{
-	return Population::makeRandom(
-		std::move(_fitnessMetric),
-		_populationSize,
-		_minChromosomeLength,
-		_maxChromosomeLength
-	);
-}
-
-Population PopulationFactory::buildFromFile(
-	string const& _filePath,
-	shared_ptr<FitnessMetric> _fitnessMetric
-)
-{
-	return buildFromStrings(readLinesFromFile(_filePath), std::move(_fitnessMetric));
-}
-
-ProgramCacheFactory::Options ProgramCacheFactory::Options::fromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["program-cache"].as<bool>(),
-	};
-}
-
-vector<shared_ptr<ProgramCache>> ProgramCacheFactory::build(
-	Options const& _options,
-	vector<Program> _programs
-)
-{
-	vector<shared_ptr<ProgramCache>> programCaches;
-	for (Program& program: _programs)
-		programCaches.push_back(_options.programCacheEnabled ? make_shared<ProgramCache>(std::move(program)) : nullptr);
-
-	return programCaches;
-}
-
-ProgramFactory::Options ProgramFactory::Options::fromCommandLine(po::variables_map const& _arguments)
-{
-	return {
-		_arguments["input-files"].as<vector<string>>(),
-		_arguments["prefix"].as<string>(),
-	};
-}
-
-vector<Program> ProgramFactory::build(Options const& _options)
-{
-	vector<Program> inputPrograms;
-	for (auto& path: _options.inputFiles)
-	{
-		CharStream sourceCode = loadSource(path);
-		variant<Program, ErrorList> programOrErrors = Program::load(sourceCode);
-		if (holds_alternative<ErrorList>(programOrErrors))
-		{
-			SourceReferenceFormatter{cerr, SingletonCharStreamProvider(sourceCode), true, false}
-				.printErrorInformation(get<ErrorList>(programOrErrors));
-			cerr << endl;
-			assertThrow(false, InvalidProgram, "Failed to load program " + path);
-		}
-
-		get<Program>(programOrErrors).optimise(Chromosome(_options.prefix).optimisationSteps());
-		inputPrograms.push_back(std::move(get<Program>(programOrErrors)));
-	}
-
-	return inputPrograms;
-}
-
-CharStream ProgramFactory::loadSource(boost::filesystem::path const& _sourcePath)
-{
-	assertThrow(boost::filesystem::exists(_sourcePath), MissingFile, "Source file does not exist: " + _sourcePath.string());
-
-	string sourceCode = readFileAsString(_sourcePath);
-	return CharStream(sourceCode, _sourcePath.string());
-}
-
-void Phaser::main(int _argc, char** _argv)
-{
-	optional<po::variables_map> arguments = parseCommandLine(_argc, _argv);
-	if (!arguments.has_value())
-		return;
-
-	initialiseRNG(arguments.value());
-
-	runPhaser(arguments.value());
-}
-
-Phaser::CommandLineDescription Phaser::buildCommandLineDescription()
-{
-	unsigned const lineLength = po::options_description::m_default_line_length;
-	unsigned const minDescriptionLength = lineLength - 23;
-
-	po::options_description keywordDescription(
-		"yul-phaser, a tool for finding the best sequence of Yul optimisation phases.\n"
-		"\n"
-		"Usage: yul-phaser [options] <file>\n"
-		"Reads <file> as Yul code and tries to find the best order in which to run optimisation"
-		" phases using a genetic algorithm.\n"
-		"Example:\n"
-		"yul-phaser program.yul\n"
-		"\n"
-		"Allowed options",
-		lineLength,
-		minDescriptionLength
-	);
-
-	po::options_description generalDescription("GENERAL", lineLength, minDescriptionLength);
-	generalDescription.add_options()
-		("help", "Show help message and exit.")
-		("input-files", po::value<vector<string>>()->required()->value_name("<PATH>"), "Input files.")
-		(
-			"prefix",
-			po::value<string>()->value_name("<CHROMOSOME>")->default_value(""),
-			"Initial optimisation steps automatically applied to every input program.\n"
-			"The result is treated as if it was the actual input, i.e. the steps are not considered "
-			"a part of the chromosomes and cannot be mutated. The values of relative metric values "
-			"are also relative to the fitness of a program with these steps applied rather than the "
-			"fitness of the original program.\n"
-			"Note that phaser always adds a 'hgo' prefix to ensure that chromosomes can "
-			"contain arbitrary optimisation steps. This implicit prefix cannot be changed or "
-			"or removed using this option. The value given here is applied after it."
-		)
-		("seed", po::value<uint32_t>()->value_name("<NUM>"), "Seed for the random number generator.")
-		(
-			"rounds",
-			po::value<size_t>()->value_name("<NUM>"),
-			"The number of rounds after which the algorithm should stop. (default=no limit)."
-		)
-		(
-			"mode",
-			po::value<PhaserMode>()->value_name("<NAME>")->default_value(PhaserMode::RunAlgorithm),
-			(
-				"Mode of operation. The default is to run the algorithm but you can also tell phaser "
-				"to do something else with its parameters, e.g. just print the optimised programs and exit.\n"
-				"\n"
-				"AVAILABLE MODES:\n"
-				"* " + toString(PhaserMode::RunAlgorithm) + "\n" +
-				"* " + toString(PhaserMode::PrintOptimisedPrograms) + "\n" +
-				"* " + toString(PhaserMode::PrintOptimisedASTs)
-			).c_str()
-		)
-	;
-	keywordDescription.add(generalDescription);
-
-	po::options_description algorithmDescription("ALGORITHM", lineLength, minDescriptionLength);
-	algorithmDescription.add_options()
-		(
-			"algorithm",
-			po::value<Algorithm>()->value_name("<NAME>")->default_value(Algorithm::GEWEP),
-			(
-				"Algorithm\n"
-				"\n"
-				"AVAILABLE ALGORITHMS:\n"
-				"* " + toString(Algorithm::GEWEP) + "\n" +
-				"* " + toString(Algorithm::Classic) + "\n" +
-				"* " + toString(Algorithm::Random)
-			).c_str()
-		)
-		(
-			"no-randomise-duplicates",
-			po::bool_switch(),
-			"By default, after each round of the algorithm duplicate chromosomes are removed from"
-			"the population and replaced with randomly generated ones. "
-			"This option disables this postprocessing."
-		)
-		(
-			"min-chromosome-length",
-			po::value<size_t>()->value_name("<NUM>")->default_value(100),
-			"Minimum length of randomly generated chromosomes."
-		)
-		(
-			"max-chromosome-length",
-			po::value<size_t>()->value_name("<NUM>")->default_value(100),
-			"Maximum length of randomly generated chromosomes."
-		)
-		(
-			"crossover",
-			po::value<CrossoverChoice>()->value_name("<NAME>")->default_value(CrossoverChoice::Uniform),
-			(
-				"Type of the crossover operator to use.\n"
-				"\n"
-				"AVAILABLE CROSSOVER OPERATORS:\n"
-				"* " + toString(CrossoverChoice::SinglePoint) + "\n" +
-				"* " + toString(CrossoverChoice::TwoPoint) + "\n" +
-				"* " + toString(CrossoverChoice::Uniform)
-			).c_str()
-		)
-		(
-			"uniform-crossover-swap-chance",
-			po::value<double>()->value_name("<PROBABILITY>")->default_value(0.5),
-			"Chance of two genes being swapped between chromosomes in uniform crossover."
-		)
-	;
-	keywordDescription.add(algorithmDescription);
-
-	po::options_description gewepAlgorithmDescription("GEWEP ALGORITHM", lineLength, minDescriptionLength);
-	gewepAlgorithmDescription.add_options()
-		(
-			"gewep-mutation-pool-size",
-			po::value<double>()->value_name("<FRACTION>")->default_value(0.25),
-			"Percentage of population to regenerate using mutations in each round."
-		)
-		(
-			"gewep-crossover-pool-size",
-			po::value<double>()->value_name("<FRACTION>")->default_value(0.25),
-			"Percentage of population to regenerate using crossover in each round."
-		)
-		(
-			"gewep-randomisation-chance",
-			po::value<double>()->value_name("<PROBABILITY>")->default_value(0.9),
-			"The chance of choosing gene randomisation as the mutation to perform."
-		)
-		(
-			"gewep-deletion-vs-addition-chance",
-			po::value<double>()->value_name("<PROBABILITY>")->default_value(0.5),
-			"The chance of choosing gene deletion as the mutation if randomisation was not chosen."
-		)
-		(
-			"gewep-genes-to-randomise",
-			po::value<double>()->value_name("<PROBABILITY>"),
-			"The chance of any given gene being mutated in gene randomisation. "
-			"(default=1/max-chromosome-length)"
-		)
-		(
-			"gewep-genes-to-add-or-delete",
-			po::value<double>()->value_name("<PROBABILITY>"),
-			"The chance of a gene being added (or deleted) in gene addition (or deletion). "
-			"(default=1/max-chromosome-length)"
-		)
-	;
-	keywordDescription.add(gewepAlgorithmDescription);
-
-	po::options_description classicGeneticAlgorithmDescription("CLASSIC GENETIC ALGORITHM", lineLength, minDescriptionLength);
-	classicGeneticAlgorithmDescription.add_options()
-		(
-			"classic-elite-pool-size",
-			po::value<double>()->value_name("<FRACTION>")->default_value(0.25),
-			"Percentage of population to regenerate using mutations in each round."
-		)
-		(
-			"classic-crossover-chance",
-			po::value<double>()->value_name("<FRACTION>")->default_value(0.75),
-			"Chance of a chromosome being selected for crossover."
-		)
-		(
-			"classic-mutation-chance",
-			po::value<double>()->value_name("<FRACTION>")->default_value(0.01),
-			"Chance of a gene being mutated."
-		)
-		(
-			"classic-deletion-chance",
-			po::value<double>()->value_name("<PROBABILITY>")->default_value(0.01),
-			"Chance of a gene being deleted."
-		)
-		(
-			"classic-addition-chance",
-			po::value<double>()->value_name("<PROBABILITY>")->default_value(0.01),
-			"Chance of a random gene being added."
-		)
-	;
-	keywordDescription.add(classicGeneticAlgorithmDescription);
-
-	po::options_description randomAlgorithmDescription("RANDOM ALGORITHM", lineLength, minDescriptionLength);
-	randomAlgorithmDescription.add_options()
-		(
-			"random-elite-pool-size",
-			po::value<double>()->value_name("<FRACTION>"),
-			"Percentage of the population preserved in each round. "
-			"(default=one individual, regardless of population size)"
-		)
-	;
-	keywordDescription.add(randomAlgorithmDescription);
-
-	po::options_description populationDescription("POPULATION", lineLength, minDescriptionLength);
-	populationDescription.add_options()
-		(
-			"population",
-			po::value<vector<string>>()->multitoken()->value_name("<CHROMOSOMES>"),
-			"List of chromosomes to be included in the initial population. "
-			"You can specify multiple values separated with spaces or invoke the option multiple times "
-			"and all the values will be included."
-		)
-		(
-			"random-population",
-			po::value<vector<size_t>>()->value_name("<SIZE>"),
-			"The number of randomly generated chromosomes to be included in the initial population."
-		)
-		(
-			"population-from-file",
-			po::value<vector<string>>()->value_name("<FILE>"),
-			"A text file with a list of chromosomes (one per line) to be included in the initial population."
-		)
-		(
-			"population-autosave",
-			po::value<string>()->value_name("<FILE>"),
-			"If specified, the population is saved in the specified file after each round. (default=autosave disabled)"
-		)
-	;
-	keywordDescription.add(populationDescription);
-
-	po::options_description metricsDescription("METRICS", lineLength, minDescriptionLength);
-	metricsDescription.add_options()
-		(
-			"metric",
-			po::value<MetricChoice>()->value_name("<NAME>")->default_value(MetricChoice::RelativeCodeSize),
-			(
-				"Metric used to evaluate the fitness of a chromosome.\n"
-				"\n"
-				"AVAILABLE METRICS:\n"
-				"* " + toString(MetricChoice::CodeSize) + "\n" +
-				"* " + toString(MetricChoice::RelativeCodeSize)
-			).c_str()
-		)
-		(
-			"metric-aggregator",
-			po::value<MetricAggregatorChoice>()->value_name("<NAME>")->default_value(MetricAggregatorChoice::Average),
-			(
-				"Operator used to combine multiple fitness metric values obtained by evaluating a "
-				"chromosome separately for each input program.\n"
-				"\n"
-				"AVAILABLE METRIC AGGREGATORS:\n"
-				"* " + toString(MetricAggregatorChoice::Average) + "\n" +
-				"* " + toString(MetricAggregatorChoice::Sum) + "\n" +
-				"* " + toString(MetricAggregatorChoice::Maximum) + "\n" +
-				"* " + toString(MetricAggregatorChoice::Minimum)
-			).c_str()
-		)
-		(
-			"relative-metric-scale",
-			po::value<size_t>()->value_name("<EXPONENT>")->default_value(3),
-			"Scaling factor for values produced by relative fitness metrics. \n"
-			"Since all metrics must produce integer values, the fractional part of the result is discarded. "
-			"To keep the numbers meaningful, a relative metric multiples its values by a scaling factor "
-			"and this option specifies the exponent of this factor. "
-			"For example with value of 3 the factor is 10^3 = 1000 and the metric will return "
-			"500 to represent 0.5, 1000 for 1.0, 2000 for 2.0 and so on. "
-			"Using a bigger factor allows discerning smaller relative differences between chromosomes "
-			"but makes the numbers less readable and may also lose precision if the numbers are very large."
-		)
-		(
-			"chromosome-repetitions",
-			po::value<size_t>()->value_name("<COUNT>")->default_value(1),
-			"Number of times to repeat the sequence optimisation steps represented by a chromosome."
-		)
-	;
-	keywordDescription.add(metricsDescription);
-
-	po::options_description metricWeightDescription("METRIC WEIGHTS", lineLength, minDescriptionLength);
-	metricWeightDescription.add_options()
-		// TODO: We need to figure out the best set of weights for the phaser.
-		// This one is just a stopgap to make sure no statement or expression has zero cost.
-		("expression-statement-cost", po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("assignment-cost",           po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("variable-declaration-cost", po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("function-definition-cost",  po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("if-cost",                   po::value<size_t>()->value_name("<COST>")->default_value(2))
-		("switch-cost",               po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("case-cost",                 po::value<size_t>()->value_name("<COST>")->default_value(2))
-		("for-loop-cost",             po::value<size_t>()->value_name("<COST>")->default_value(3))
-		("break-cost",                po::value<size_t>()->value_name("<COST>")->default_value(2))
-		("continue-cost",             po::value<size_t>()->value_name("<COST>")->default_value(2))
-		("leave-cost",                po::value<size_t>()->value_name("<COST>")->default_value(2))
-		("block-cost",                po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("function-call-cost",        po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("identifier-cost",           po::value<size_t>()->value_name("<COST>")->default_value(1))
-		("literal-cost",              po::value<size_t>()->value_name("<COST>")->default_value(1))
-	;
-	keywordDescription.add(metricWeightDescription);
-
-	po::options_description cacheDescription("CACHE", lineLength, minDescriptionLength);
-	cacheDescription.add_options()
-		(
-			"program-cache",
-			po::bool_switch(),
-			"Enables caching of intermediate programs corresponding to chromosome prefixes.\n"
-			"This speeds up fitness evaluation by a lot but eats tons of memory if the chromosomes are long. "
-			"Disabled by default since there's currently no way to set an upper limit on memory usage but "
-			"highly recommended if your computer has enough RAM."
-		)
-	;
-	keywordDescription.add(cacheDescription);
-
-	po::options_description outputDescription("OUTPUT", lineLength, minDescriptionLength);
-	outputDescription.add_options()
-		(
-			"show-initial-population",
-			po::bool_switch(),
-			"Print the state of the population before the algorithm starts."
-		)
-		(
-			"show-only-top-chromosome",
-			po::bool_switch(),
-			"Print only the best chromosome found in each round rather than the whole population."
-		)
-		(
-			"hide-round",
-			po::bool_switch(),
-			"Hide information about the current round (round number and elapsed time)."
-		)
-		(
-			"show-cache-stats",
-			po::bool_switch(),
-			"Print information about cache size and effectiveness after each round."
-		)
-		(
-			"show-seed",
-			po::bool_switch(),
-			"Print the selected random seed."
-		)
-	;
-	keywordDescription.add(outputDescription);
-
-	po::positional_options_description positionalDescription;
-	positionalDescription.add("input-files", -1);
-
-	return {keywordDescription, positionalDescription};
-}
-
-optional<po::variables_map> Phaser::parseCommandLine(int _argc, char** _argv)
-{
-	auto [keywordDescription, positionalDescription] = buildCommandLineDescription();
-
-	po::variables_map arguments;
-	po::notify(arguments);
-
-	po::command_line_parser parser(_argc, _argv);
-	parser.options(keywordDescription).positional(positionalDescription);
-	po::store(parser.run(), arguments);
-
-	if (arguments.count("help") > 0)
-	{
-		cout << keywordDescription << endl;
-		return nullopt;
-	}
-
-	if (arguments.count("input-files") == 0)
-		assertThrow(false, NoInputFiles, "Missing argument: input-files.");
-
-	return arguments;
-}
-
-void Phaser::initialiseRNG(po::variables_map const& _arguments)
-{
-	uint32_t seed;
-	if (_arguments.count("seed") > 0)
-		seed = _arguments["seed"].as<uint32_t>();
-	else
-		seed = SimulationRNG::generateSeed();
-
-	SimulationRNG::reset(seed);
-	if (_arguments["show-seed"].as<bool>())
-		cout << "Random seed: " << seed << endl;
-}
-
-AlgorithmRunner::Options Phaser::buildAlgorithmRunnerOptions(po::variables_map const& _arguments)
-{
-	return {
-		_arguments.count("rounds") > 0 ? static_cast<optional<size_t>>(_arguments["rounds"].as<size_t>()) : nullopt,
-		_arguments.count("population-autosave") > 0 ? static_cast<optional<string>>(_arguments["population-autosave"].as<string>()) : nullopt,
-		!_arguments["no-randomise-duplicates"].as<bool>(),
-		_arguments["min-chromosome-length"].as<size_t>(),
-		_arguments["max-chromosome-length"].as<size_t>(),
-		_arguments["show-initial-population"].as<bool>(),
-		_arguments["show-only-top-chromosome"].as<bool>(),
-		!_arguments["hide-round"].as<bool>(),
-		_arguments["show-cache-stats"].as<bool>(),
-	};
-}
-
-void Phaser::runPhaser(po::variables_map const& _arguments)
-{
-	auto programOptions = ProgramFactory::Options::fromCommandLine(_arguments);
-	auto cacheOptions = ProgramCacheFactory::Options::fromCommandLine(_arguments);
-	auto metricOptions = FitnessMetricFactory::Options::fromCommandLine(_arguments);
-	auto populationOptions = PopulationFactory::Options::fromCommandLine(_arguments);
-
-	vector<Program> programs = ProgramFactory::build(programOptions);
-	vector<shared_ptr<ProgramCache>> programCaches = ProgramCacheFactory::build(cacheOptions, programs);
-	CodeWeights codeWeights = CodeWeightFactory::buildFromCommandLine(_arguments);
-	unique_ptr<FitnessMetric> fitnessMetric = FitnessMetricFactory::build(
-		metricOptions,
-		programs,
-		programCaches,
-		codeWeights
-	);
-	Population population = PopulationFactory::build(populationOptions, std::move(fitnessMetric));
-
-	if (_arguments["mode"].as<PhaserMode>() == PhaserMode::RunAlgorithm)
-		runAlgorithm(_arguments, std::move(population), std::move(programCaches));
-	else
-		printOptimisedProgramsOrASTs(_arguments, population, std::move(programs), _arguments["mode"].as<PhaserMode>());
-}
-
-void Phaser::runAlgorithm(
-	po::variables_map const& _arguments,
-	Population _population,
-	vector<shared_ptr<ProgramCache>> _programCaches
-)
-{
-	auto algorithmOptions = GeneticAlgorithmFactory::Options::fromCommandLine(_arguments);
-
-	unique_ptr<GeneticAlgorithm> geneticAlgorithm = GeneticAlgorithmFactory::build(
-		algorithmOptions,
-		_population.individuals().size()
-	);
-
-	AlgorithmRunner algorithmRunner(std::move(_population), std::move(_programCaches), buildAlgorithmRunnerOptions(_arguments), cout);
-	algorithmRunner.run(*geneticAlgorithm);
-}
-
-void Phaser::printOptimisedProgramsOrASTs(
-	po::variables_map const& _arguments,
-	Population const& _population,
-	vector<Program> _programs,
-	PhaserMode phaserMode
-)
-{
-	assert(phaserMode == PhaserMode::PrintOptimisedPrograms || phaserMode == PhaserMode::PrintOptimisedASTs);
-	assert(_programs.size() == _arguments["input-files"].as<vector<string>>().size());
-
-	if (_population.individuals().size() == 0)
-	{
-		cout << "<EMPTY POPULATION>" << endl;
-		return;
-	}
-
-	vector<string> const& paths = _arguments["input-files"].as<vector<string>>();
-	for (auto& individual: _population.individuals())
-	{
-		cout << "Chromosome: " << individual.chromosome << endl;
-
-		for (size_t i = 0; i < _programs.size(); ++i)
-		{
-			for (size_t j = 0; j < _arguments["chromosome-repetitions"].as<size_t>(); ++j)
-				_programs[i].optimise(individual.chromosome.optimisationSteps());
-
-			cout << "Program: " << paths[i] << endl;
-			if (phaserMode == PhaserMode::PrintOptimisedPrograms)
-				cout << _programs[i] << endl;
-			else
-				cout << _programs[i].toJson() << endl;
-		}
-	}
-}
diff --git a/compiler/tools/yulPhaser/Phaser.h b/compiler/tools/yulPhaser/Phaser.h
deleted file mode 100644
index 1d5c1cc2..00000000
--- a/compiler/tools/yulPhaser/Phaser.h
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains the main class that controls yul-phaser based on command-line parameters and
- * associated factories for building instances of phaser's components.
- */
-
-#pragma once
-
-#include <tools/yulPhaser/AlgorithmRunner.h>
-#include <tools/yulPhaser/GeneticAlgorithms.h>
-
-#include <boost/filesystem.hpp>
-#include <boost/program_options.hpp>
-
-#include <cstddef>
-#include <istream>
-#include <memory>
-#include <optional>
-#include <ostream>
-#include <string>
-
-namespace solidity::langutil
-{
-
-class CharStream;
-
-}
-
-namespace solidity::yul
-{
-
-struct CodeWeights;
-
-}
-
-namespace solidity::phaser
-{
-
-class FitnessMetric;
-class GeneticAlgorithm;
-class Population;
-class Program;
-class ProgramCache;
-
-enum class PhaserMode
-{
-	RunAlgorithm,
-	PrintOptimisedPrograms,
-	PrintOptimisedASTs,
-};
-
-enum class Algorithm
-{
-	Random,
-	GEWEP,
-	Classic,
-};
-
-enum class MetricChoice
-{
-	CodeSize,
-	RelativeCodeSize,
-};
-
-enum class MetricAggregatorChoice
-{
-	Average,
-	Sum,
-	Maximum,
-	Minimum,
-};
-
-std::istream& operator>>(std::istream& _inputStream, solidity::phaser::PhaserMode& _phaserMode);
-std::ostream& operator<<(std::ostream& _outputStream, solidity::phaser::PhaserMode _phaserMode);
-std::istream& operator>>(std::istream& _inputStream, solidity::phaser::Algorithm& _algorithm);
-std::ostream& operator<<(std::ostream& _outputStream, solidity::phaser::Algorithm _algorithm);
-std::istream& operator>>(std::istream& _inputStream, solidity::phaser::MetricChoice& _metric);
-std::ostream& operator<<(std::ostream& _outputStream, solidity::phaser::MetricChoice _metric);
-std::istream& operator>>(std::istream& _inputStream, solidity::phaser::MetricAggregatorChoice& _aggregator);
-std::ostream& operator<<(std::ostream& _outputStream, solidity::phaser::MetricAggregatorChoice _aggregator);
-std::istream& operator>>(std::istream& _inputStream, solidity::phaser::CrossoverChoice& _crossover);
-std::ostream& operator<<(std::ostream& _outputStream, solidity::phaser::CrossoverChoice _crossover);
-
-/**
- * Builds and validates instances of @a GeneticAlgorithm and its derived classes.
- */
-class GeneticAlgorithmFactory
-{
-public:
-	struct Options
-	{
-		Algorithm algorithm;
-		size_t minChromosomeLength;
-		size_t maxChromosomeLength;
-		CrossoverChoice crossover;
-		double uniformCrossoverSwapChance;
-
-		std::optional<double> randomElitePoolSize;
-
-		double gewepMutationPoolSize;
-		double gewepCrossoverPoolSize;
-		double gewepRandomisationChance;
-		double gewepDeletionVsAdditionChance;
-		std::optional<double> gewepGenesToRandomise;
-		std::optional<double> gewepGenesToAddOrDelete;
-
-		double classicElitePoolSize;
-		double classicCrossoverChance;
-		double classicMutationChance;
-		double classicDeletionChance;
-		double classicAdditionChance;
-
-		static Options fromCommandLine(boost::program_options::variables_map const& _arguments);
-	};
-
-	static std::unique_ptr<GeneticAlgorithm> build(
-		Options const& _options,
-		size_t _populationSize
-	);
-};
-
-/**
- * Builds and validates instances of @a CodeWeights.
- */
-class CodeWeightFactory
-{
-public:
-	static yul::CodeWeights buildFromCommandLine(
-		boost::program_options::variables_map const& _arguments
-	);
-};
-
-/**
- * Builds and validates instances of @a FitnessMetric and its derived classes.
- */
-class FitnessMetricFactory
-{
-public:
-	struct Options
-	{
-		MetricChoice metric;
-		MetricAggregatorChoice metricAggregator;
-		size_t relativeMetricScale;
-		size_t chromosomeRepetitions;
-
-		static Options fromCommandLine(boost::program_options::variables_map const& _arguments);
-	};
-
-	static std::unique_ptr<FitnessMetric> build(
-		Options const& _options,
-		std::vector<Program> _programs,
-		std::vector<std::shared_ptr<ProgramCache>> _programCaches,
-		yul::CodeWeights const& _weights
-	);
-};
-
-/**
- * Builds and validates instances of @a Population.
- */
-class PopulationFactory
-{
-public:
-	struct Options
-	{
-		size_t minChromosomeLength;
-		size_t maxChromosomeLength;
-		std::vector<std::string> population;
-		std::vector<size_t> randomPopulation;
-		std::vector<std::string> populationFromFile;
-
-		static Options fromCommandLine(boost::program_options::variables_map const& _arguments);
-	};
-
-	static Population build(
-		Options const& _options,
-		std::shared_ptr<FitnessMetric> _fitnessMetric
-	);
-	static Population buildFromStrings(
-		std::vector<std::string> const& _geneSequences,
-		std::shared_ptr<FitnessMetric> _fitnessMetric
-	);
-	static Population buildRandom(
-		size_t _populationSize,
-		size_t _minChromosomeLength,
-		size_t _maxChromosomeLength,
-		std::shared_ptr<FitnessMetric> _fitnessMetric
-	);
-	static Population buildFromFile(
-		std::string const& _filePath,
-		std::shared_ptr<FitnessMetric> _fitnessMetric
-	);
-};
-
-/**
- * Builds and validates instances of @a ProgramCache.
- */
-class ProgramCacheFactory
-{
-public:
-	struct Options
-	{
-		bool programCacheEnabled;
-
-		static Options fromCommandLine(boost::program_options::variables_map const& _arguments);
-	};
-
-	static std::vector<std::shared_ptr<ProgramCache>> build(
-		Options const& _options,
-		std::vector<Program> _programs
-	);
-};
-
-/**
- * Builds and validates instances of @a Program.
- */
-class ProgramFactory
-{
-public:
-	struct Options
-	{
-		std::vector<std::string> inputFiles;
-		std::string prefix;
-
-		static Options fromCommandLine(boost::program_options::variables_map const& _arguments);
-	};
-
-	static std::vector<Program> build(Options const& _options);
-
-private:
-	static langutil::CharStream loadSource(boost::filesystem::path const& _sourcePath);
-};
-
-/**
- * Main class that controls yul-phaser based on command-line parameters. The class is responsible
- * for command-line parsing, initialisation of global objects (like the random number generator),
- * creating instances of main components using factories and feeding them into @a AlgorithmRunner.
- */
-class Phaser
-{
-public:
-	static void main(int argc, char** argv);
-
-private:
-	struct CommandLineDescription
-	{
-		boost::program_options::options_description keywordDescription;
-		boost::program_options::positional_options_description positionalDescription;
-	};
-
-	static CommandLineDescription buildCommandLineDescription();
-	static std::optional<boost::program_options::variables_map> parseCommandLine(int _argc, char** _argv);
-	static void initialiseRNG(boost::program_options::variables_map const& _arguments);
-	static AlgorithmRunner::Options buildAlgorithmRunnerOptions(boost::program_options::variables_map const& _arguments);
-
-	static void runPhaser(boost::program_options::variables_map const& _arguments);
-	static void runAlgorithm(
-		boost::program_options::variables_map const& _arguments,
-		Population _population,
-		std::vector<std::shared_ptr<ProgramCache>> _programCaches
-	);
-	static void printOptimisedProgramsOrASTs(
-		boost::program_options::variables_map const& _arguments,
-		Population const& _population,
-		std::vector<Program> _programs,
-		PhaserMode phaserMode
-	);
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Population.cpp b/compiler/tools/yulPhaser/Population.cpp
deleted file mode 100644
index d4fe1f0b..00000000
--- a/compiler/tools/yulPhaser/Population.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Population.h>
-
-#include <tools/yulPhaser/PairSelections.h>
-#include <tools/yulPhaser/Selections.h>
-
-#include <libsolutil/CommonData.h>
-#include <libsolutil/CommonIO.h>
-
-#include <algorithm>
-#include <cassert>
-#include <numeric>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::langutil;
-using namespace solidity::util;
-using namespace solidity::phaser;
-
-namespace solidity::phaser
-{
-
-ostream& operator<<(ostream& _stream, Individual const& _individual);
-ostream& operator<<(ostream& _stream, Population const& _population);
-
-}
-
-ostream& phaser::operator<<(ostream& _stream, Individual const& _individual)
-{
-	_stream << _individual.fitness << " " << _individual.chromosome;
-
-	return _stream;
-}
-
-bool phaser::isFitter(Individual const& a, Individual const& b)
-{
-	return (
-		(a.fitness < b.fitness) ||
-		(a.fitness == b.fitness && a.chromosome.length() < b.chromosome.length()) ||
-		(a.fitness == b.fitness && a.chromosome.length() == b.chromosome.length() && a.chromosome.genes() < b.chromosome.genes())
-	);
-}
-
-Population Population::makeRandom(
-	shared_ptr<FitnessMetric> _fitnessMetric,
-	size_t _size,
-	function<size_t()> _chromosomeLengthGenerator
-)
-{
-	vector<Chromosome> chromosomes;
-	for (size_t i = 0; i < _size; ++i)
-		chromosomes.push_back(Chromosome::makeRandom(_chromosomeLengthGenerator()));
-
-	return Population(std::move(_fitnessMetric), std::move(chromosomes));
-}
-
-Population Population::makeRandom(
-	shared_ptr<FitnessMetric> _fitnessMetric,
-	size_t _size,
-	size_t _minChromosomeLength,
-	size_t _maxChromosomeLength
-)
-{
-	return makeRandom(
-		std::move(_fitnessMetric),
-		_size,
-		std::bind(uniformChromosomeLength, _minChromosomeLength, _maxChromosomeLength)
-	);
-}
-
-Population Population::select(Selection const& _selection) const
-{
-	vector<Individual> selectedIndividuals;
-	for (size_t i: _selection.materialise(m_individuals.size()))
-		selectedIndividuals.emplace_back(m_individuals[i]);
-
-	return Population(m_fitnessMetric, selectedIndividuals);
-}
-
-Population Population::mutate(Selection const& _selection, function<Mutation> _mutation) const
-{
-	vector<Individual> mutatedIndividuals;
-	for (size_t i: _selection.materialise(m_individuals.size()))
-		mutatedIndividuals.emplace_back(_mutation(m_individuals[i].chromosome), *m_fitnessMetric);
-
-	return Population(m_fitnessMetric, mutatedIndividuals);
-}
-
-Population Population::crossover(PairSelection const& _selection, function<Crossover> _crossover) const
-{
-	vector<Individual> crossedIndividuals;
-	for (auto const& [i, j]: _selection.materialise(m_individuals.size()))
-	{
-		auto childChromosome = _crossover(
-			m_individuals[i].chromosome,
-			m_individuals[j].chromosome
-		);
-		crossedIndividuals.emplace_back(std::move(childChromosome), *m_fitnessMetric);
-	}
-
-	return Population(m_fitnessMetric, crossedIndividuals);
-}
-
-tuple<Population, Population> Population::symmetricCrossoverWithRemainder(
-	PairSelection const& _selection,
-	function<SymmetricCrossover> _symmetricCrossover
-) const
-{
-	vector<int> indexSelected(m_individuals.size(), false);
-
-	vector<Individual> crossedIndividuals;
-	for (auto const& [i, j]: _selection.materialise(m_individuals.size()))
-	{
-		auto children = _symmetricCrossover(
-			m_individuals[i].chromosome,
-			m_individuals[j].chromosome
-		);
-		crossedIndividuals.emplace_back(std::move(get<0>(children)), *m_fitnessMetric);
-		crossedIndividuals.emplace_back(std::move(get<1>(children)), *m_fitnessMetric);
-		indexSelected[i] = true;
-		indexSelected[j] = true;
-	}
-
-	vector<Individual> remainder;
-	for (size_t i = 0; i < indexSelected.size(); ++i)
-		if (!indexSelected[i])
-			remainder.emplace_back(m_individuals[i]);
-
-	return {
-		Population(m_fitnessMetric, crossedIndividuals),
-		Population(m_fitnessMetric, remainder),
-	};
-}
-
-namespace solidity::phaser
-{
-
-Population operator+(Population _a, Population _b)
-{
-	// This operator is meant to be used only with populations sharing the same metric (and, to make
-	// things simple, "the same" here means the same exact object in memory).
-	assert(_a.m_fitnessMetric == _b.m_fitnessMetric);
-
-	using ::operator+; // Import the std::vector concat operator from CommonData.h
-	return Population(_a.m_fitnessMetric, std::move(_a.m_individuals) + std::move(_b.m_individuals));
-}
-
-}
-
-Population Population::combine(std::tuple<Population, Population> _populationPair)
-{
-	return get<0>(_populationPair) + get<1>(_populationPair);
-}
-
-bool Population::operator==(Population const& _other) const
-{
-	// We consider populations identical only if they share the same exact instance of the metric.
-	// It might be possible to define some notion of equality for metric objects but it would
-	// be an overkill since mixing populations using different metrics is not a common use case.
-	return m_individuals == _other.m_individuals && m_fitnessMetric == _other.m_fitnessMetric;
-}
-
-ostream& phaser::operator<<(ostream& _stream, Population const& _population)
-{
-	auto individual = _population.m_individuals.begin();
-	for (; individual != _population.m_individuals.end(); ++individual)
-		_stream << *individual << endl;
-
-	return _stream;
-}
-
-vector<Individual> Population::chromosomesToIndividuals(
-	FitnessMetric& _fitnessMetric,
-	vector<Chromosome> _chromosomes
-)
-{
-	vector<Individual> individuals;
-	for (auto& chromosome: _chromosomes)
-		individuals.emplace_back(std::move(chromosome), _fitnessMetric);
-
-	return individuals;
-}
-
-vector<Individual> Population::sortedIndividuals(vector<Individual> _individuals)
-{
-	sort(_individuals.begin(), _individuals.end(), isFitter);
-	return _individuals;
-}
diff --git a/compiler/tools/yulPhaser/Population.h b/compiler/tools/yulPhaser/Population.h
deleted file mode 100644
index 00c3e0d3..00000000
--- a/compiler/tools/yulPhaser/Population.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <tools/yulPhaser/Chromosome.h>
-#include <tools/yulPhaser/FitnessMetrics.h>
-#include <tools/yulPhaser/Mutations.h>
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <cstddef>
-#include <optional>
-#include <ostream>
-#include <vector>
-
-namespace solidity::phaser
-{
-
-class PairSelection;
-class Selection;
-
-/**
- * Information describing the state of an individual member of the population during the course
- * of the genetic algorithm.
- */
-struct Individual
-{
-	Chromosome chromosome;
-	size_t fitness;
-
-	Individual(Chromosome _chromosome, size_t _fitness):
-		chromosome(std::move(_chromosome)),
-		fitness(_fitness) {}
-	Individual(Chromosome _chromosome, FitnessMetric& _fitnessMetric):
-		chromosome(std::move(_chromosome)),
-		fitness(_fitnessMetric.evaluate(chromosome)) {}
-
-	bool operator==(Individual const& _other) const { return fitness == _other.fitness && chromosome == _other.chromosome; }
-	bool operator!=(Individual const& _other) const { return !(*this == _other); }
-
-	friend std::ostream& operator<<(std::ostream& _stream, Individual const& _individual);
-};
-
-/// Determines which individual is better by comparing fitness values. If fitness is the same
-/// takes into account all the other properties of the individual to make the comparison
-/// deterministic as long as the individuals are not equal.
-bool isFitter(Individual const& a, Individual const& b);
-
-/**
- * Represents a snapshot of a population undergoing a genetic algorithm. Consists of a set of
- * chromosomes with associated fitness values.
- *
- * An individual is a sequence of optimiser steps represented by a @a Chromosome instance.
- * Individuals are always ordered by their fitness (based on @_fitnessMetric and @a isFitter()).
- * The fitness is computed using the metric as soon as an individual is inserted into the population.
- *
- * The population is immutable. Selections, mutations and crossover work by producing a new
- * instance and copying the individuals.
- */
-class Population
-{
-public:
-	explicit Population(
-		std::shared_ptr<FitnessMetric> _fitnessMetric,
-		std::vector<Chromosome> _chromosomes = {}
-	):
-		Population(
-			_fitnessMetric,
-			chromosomesToIndividuals(*_fitnessMetric, std::move(_chromosomes))
-		) {}
-	explicit Population(std::shared_ptr<FitnessMetric> _fitnessMetric, std::vector<Individual> _individuals):
-		m_fitnessMetric(std::move(_fitnessMetric)),
-		m_individuals{sortedIndividuals(std::move(_individuals))} {}
-
-	static Population makeRandom(
-		std::shared_ptr<FitnessMetric> _fitnessMetric,
-		size_t _size,
-		std::function<size_t()> _chromosomeLengthGenerator
-	);
-	static Population makeRandom(
-		std::shared_ptr<FitnessMetric> _fitnessMetric,
-		size_t _size,
-		size_t _minChromosomeLength,
-		size_t _maxChromosomeLength
-	);
-
-	Population select(Selection const& _selection) const;
-	Population mutate(Selection const& _selection, std::function<Mutation> _mutation) const;
-	Population crossover(PairSelection const& _selection, std::function<Crossover> _crossover) const;
-	std::tuple<Population, Population> symmetricCrossoverWithRemainder(
-		PairSelection const& _selection,
-		std::function<SymmetricCrossover> _symmetricCrossover
-	) const;
-
-	friend Population operator+(Population _a, Population _b);
-	static Population combine(std::tuple<Population, Population> _populationPair);
-
-	std::shared_ptr<FitnessMetric> fitnessMetric() { return m_fitnessMetric; }
-	std::vector<Individual> const& individuals() const { return m_individuals; }
-
-	static size_t uniformChromosomeLength(size_t _min, size_t _max) { return SimulationRNG::uniformInt(_min, _max); }
-	static size_t binomialChromosomeLength(size_t _max) { return SimulationRNG::binomialInt(_max, 0.5); }
-
-	bool operator==(Population const& _other) const;
-	bool operator!=(Population const& _other) const { return !(*this == _other); }
-
-	friend std::ostream& operator<<(std::ostream& _stream, Population const& _population);
-
-private:
-	static std::vector<Individual> chromosomesToIndividuals(
-		FitnessMetric& _fitnessMetric,
-		std::vector<Chromosome> _chromosomes
-	);
-	static std::vector<Individual> sortedIndividuals(std::vector<Individual> _individuals);
-
-	std::shared_ptr<FitnessMetric> m_fitnessMetric;
-	std::vector<Individual> m_individuals;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/Program.cpp b/compiler/tools/yulPhaser/Program.cpp
deleted file mode 100644
index c62b8e13..00000000
--- a/compiler/tools/yulPhaser/Program.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Program.h>
-
-#include <liblangutil/CharStream.h>
-#include <liblangutil/ErrorReporter.h>
-#include <liblangutil/SourceReferenceFormatter.h>
-
-#include <libyul/AsmAnalysis.h>
-#include <libyul/AsmAnalysisInfo.h>
-#include <libyul/AsmJsonConverter.h>
-#include <libyul/AsmParser.h>
-#include <libyul/AsmPrinter.h>
-#include <libyul/AST.h>
-#include <libyul/ObjectParser.h>
-#include <libyul/YulString.h>
-#include <libyul/backends/evm/EVMDialect.h>
-#include <libyul/optimiser/Disambiguator.h>
-#include <libyul/optimiser/ForLoopInitRewriter.h>
-#include <libyul/optimiser/FunctionGrouper.h>
-#include <libyul/optimiser/FunctionHoister.h>
-#include <libyul/optimiser/Metrics.h>
-#include <libyul/optimiser/OptimiserStep.h>
-#include <libyul/optimiser/Suite.h>
-
-#include <libsolutil/JSON.h>
-
-#include <libsolidity/interface/OptimiserSettings.h>
-
-#include <cassert>
-#include <memory>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::langutil;
-using namespace solidity::yul;
-using namespace solidity::util;
-using namespace solidity::phaser;
-
-namespace solidity::phaser
-{
-
-ostream& operator<<(ostream& _stream, Program const& _program);
-
-}
-
-Program::Program(Program const& program):
-	m_ast(make_unique<Block>(get<Block>(ASTCopier{}(*program.m_ast)))),
-	m_dialect{program.m_dialect},
-	m_nameDispenser(program.m_nameDispenser)
-{
-}
-
-variant<Program, ErrorList> Program::load(CharStream& _sourceCode)
-{
-	// ASSUMPTION: parseSource() rewinds the stream on its own
-	Dialect const& dialect = EVMDialect::strictAssemblyForEVMObjects(EVMVersion{});
-
-	variant<unique_ptr<Block>, ErrorList> astOrErrors = parseObject(dialect, _sourceCode);
-	if (holds_alternative<ErrorList>(astOrErrors))
-		return get<ErrorList>(astOrErrors);
-
-	variant<unique_ptr<AsmAnalysisInfo>, ErrorList> analysisInfoOrErrors = analyzeAST(
-		dialect,
-		*get<unique_ptr<Block>>(astOrErrors)
-	);
-	if (holds_alternative<ErrorList>(analysisInfoOrErrors))
-		return get<ErrorList>(analysisInfoOrErrors);
-
-	Program program(
-		dialect,
-		disambiguateAST(
-			dialect,
-			*get<unique_ptr<Block>>(astOrErrors),
-			*get<unique_ptr<AsmAnalysisInfo>>(analysisInfoOrErrors)
-		)
-	);
-	program.optimise({
-		FunctionHoister::name,
-		FunctionGrouper::name,
-		ForLoopInitRewriter::name,
-	});
-
-	return program;
-}
-
-void Program::optimise(vector<string> const& _optimisationSteps)
-{
-	m_ast = applyOptimisationSteps(m_dialect, m_nameDispenser, std::move(m_ast), _optimisationSteps);
-}
-
-ostream& phaser::operator<<(ostream& _stream, Program const& _program)
-{
-	return _stream << AsmPrinter()(*_program.m_ast);
-}
-
-string Program::toJson() const
-{
-	Json::Value serializedAst = AsmJsonConverter(0)(*m_ast);
-	return jsonPrettyPrint(removeNullMembers(std::move(serializedAst)));
-}
-
-variant<unique_ptr<Block>, ErrorList> Program::parseObject(Dialect const& _dialect, CharStream _source)
-{
-	ErrorList errors;
-	ErrorReporter errorReporter(errors);
-	auto scanner = make_shared<Scanner>(_source);
-
-	ObjectParser parser(errorReporter, _dialect);
-	shared_ptr<Object> object = parser.parse(scanner, false);
-	if (object == nullptr || !errorReporter.errors().empty())
-		// NOTE: It's possible to get errors even if the returned object is non-null.
-		// For example when there are errors in a nested object.
-		return errors;
-
-	Object* deployedObject = nullptr;
-	if (object->subObjects.size() > 0)
-		for (auto& subObject: object->subObjects)
-			// solc --ir produces an object with a subobject of the same name as the outer object
-			// but suffixed with  "_deployed".
-			// The other object references the nested one which makes analysis fail. Below we try to
-			// extract just the nested one for that reason. This is just a heuristic. If there's no
-			// subobject with such a suffix we fall back to accepting the whole object as is.
-			if (subObject != nullptr && subObject->name.str() == object->name.str() + "_deployed")
-			{
-				deployedObject = dynamic_cast<Object*>(subObject.get());
-				if (deployedObject != nullptr)
-					break;
-			}
-	Object* selectedObject = (deployedObject != nullptr ? deployedObject : object.get());
-
-	// NOTE: I'm making a copy of the whole AST to get unique_ptr rather than shared_ptr.
-	// This is a slight performance hit but it's much less than the parsing itself.
-	// unique_ptr lets me be sure that two Program instances can never share the AST by mistake.
-	// The public API of the class does not provide access to the smart pointer so it won't be hard
-	// to switch to shared_ptr if the copying turns out to be an issue (though it would be better
-	// to refactor ObjectParser and Object to use unique_ptr instead).
-	auto astCopy = make_unique<Block>(get<Block>(ASTCopier{}(*selectedObject->code)));
-
-	return variant<unique_ptr<Block>, ErrorList>(std::move(astCopy));
-}
-
-variant<unique_ptr<AsmAnalysisInfo>, ErrorList> Program::analyzeAST(Dialect const& _dialect, Block const& _ast)
-{
-	ErrorList errors;
-	ErrorReporter errorReporter(errors);
-	auto analysisInfo = make_unique<AsmAnalysisInfo>();
-	AsmAnalyzer analyzer(*analysisInfo, errorReporter, _dialect);
-
-	bool analysisSuccessful = analyzer.analyze(_ast);
-	if (!analysisSuccessful)
-		return errors;
-
-	assert(errorReporter.errors().empty());
-	return variant<unique_ptr<AsmAnalysisInfo>, ErrorList>(std::move(analysisInfo));
-}
-
-unique_ptr<Block> Program::disambiguateAST(
-	Dialect const& _dialect,
-	Block const& _ast,
-	AsmAnalysisInfo const& _analysisInfo
-)
-{
-	set<YulString> const externallyUsedIdentifiers = {};
-	Disambiguator disambiguator(_dialect, _analysisInfo, externallyUsedIdentifiers);
-
-	return make_unique<Block>(get<Block>(disambiguator(_ast)));
-}
-
-unique_ptr<Block> Program::applyOptimisationSteps(
-	Dialect const& _dialect,
-	NameDispenser& _nameDispenser,
-	unique_ptr<Block> _ast,
-	vector<string> const& _optimisationSteps
-)
-{
-	// An empty set of reserved identifiers. It could be a constructor parameter but I don't
-	// think it would be useful in this tool. Other tools (like yulopti) have it empty too.
-	set<YulString> const externallyUsedIdentifiers = {};
-	OptimiserStepContext context{
-		_dialect,
-		_nameDispenser,
-		externallyUsedIdentifiers,
-		frontend::OptimiserSettings::standard().expectedExecutionsPerDeployment
-	};
-
-	for (string const& step: _optimisationSteps)
-		OptimiserSuite::allSteps().at(step)->run(context, *_ast);
-
-	return _ast;
-}
-
-size_t Program::computeCodeSize(Block const& _ast, CodeWeights const& _weights)
-{
-	return CodeSize::codeSizeIncludingFunctions(_ast, _weights);
-}
diff --git a/compiler/tools/yulPhaser/Program.h b/compiler/tools/yulPhaser/Program.h
deleted file mode 100644
index e42471d7..00000000
--- a/compiler/tools/yulPhaser/Program.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <libyul/optimiser/NameDispenser.h>
-#include <libyul/AST.h>
-
-#include <liblangutil/Exceptions.h>
-
-#include <cstddef>
-#include <optional>
-#include <ostream>
-#include <set>
-#include <string>
-#include <variant>
-#include <vector>
-
-namespace solidity::langutil
-{
-
-class CharStream;
-class Scanner;
-
-}
-
-namespace solidity::yul
-{
-
-struct AsmAnalysisInfo;
-struct Dialect;
-struct CodeWeights;
-
-}
-
-namespace solidity::phaser
-{
-
-/**
- * Class representing parsed and analysed Yul program that we can apply optimisations to.
- * The program is already disambiguated and has several prerequisite optimiser steps applied to it
- * so that the requirements of any possible step that could be later applied by the user are
- * already satisfied.
- *
- * The class allows the user to apply extra optimisations and obtain metrics and general
- * information about the resulting syntax tree.
- */
-class Program
-{
-public:
-	Program(Program const& program);
-	Program(Program&& program):
-		m_ast(std::move(program.m_ast)),
-		m_dialect{program.m_dialect},
-		m_nameDispenser(std::move(program.m_nameDispenser))
-	{}
-	Program operator=(Program const& program) = delete;
-	Program operator=(Program&& program) = delete;
-
-	static std::variant<Program, langutil::ErrorList> load(langutil::CharStream& _sourceCode);
-	void optimise(std::vector<std::string> const& _optimisationSteps);
-
-	size_t codeSize(yul::CodeWeights const& _weights) const { return computeCodeSize(*m_ast, _weights); }
-	yul::Block const& ast() const { return *m_ast; }
-
-	friend std::ostream& operator<<(std::ostream& _stream, Program const& _program);
-	std::string toJson() const;
-
-private:
-	Program(
-		yul::Dialect const& _dialect,
-		std::unique_ptr<yul::Block> _ast
-	):
-		m_ast(std::move(_ast)),
-		m_dialect{_dialect},
-		m_nameDispenser(_dialect, *m_ast, {})
-	{}
-
-	static std::variant<std::unique_ptr<yul::Block>, langutil::ErrorList> parseObject(
-		yul::Dialect const& _dialect,
-		langutil::CharStream _source
-	);
-	static std::variant<std::unique_ptr<yul::AsmAnalysisInfo>, langutil::ErrorList> analyzeAST(
-		yul::Dialect const& _dialect,
-		yul::Block const& _ast
-	);
-	static std::unique_ptr<yul::Block> disambiguateAST(
-		yul::Dialect const& _dialect,
-		yul::Block const& _ast,
-		yul::AsmAnalysisInfo const& _analysisInfo
-	);
-	static std::unique_ptr<yul::Block> applyOptimisationSteps(
-		yul::Dialect const& _dialect,
-		yul::NameDispenser& _nameDispenser,
-		std::unique_ptr<yul::Block> _ast,
-		std::vector<std::string> const& _optimisationSteps
-	);
-	static size_t computeCodeSize(yul::Block const& _ast, yul::CodeWeights const& _weights);
-
-	std::unique_ptr<yul::Block> m_ast;
-	yul::Dialect const& m_dialect;
-	yul::NameDispenser m_nameDispenser;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/ProgramCache.cpp b/compiler/tools/yulPhaser/ProgramCache.cpp
deleted file mode 100644
index 351532aa..00000000
--- a/compiler/tools/yulPhaser/ProgramCache.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/ProgramCache.h>
-
-#include <libyul/optimiser/Metrics.h>
-
-#include <libyul/optimiser/Suite.h>
-
-using namespace std;
-using namespace solidity::yul;
-using namespace solidity::phaser;
-
-CacheStats& CacheStats::operator+=(CacheStats const& _other)
-{
-	hits += _other.hits;
-	misses += _other.misses;
-	totalCodeSize += _other.totalCodeSize;
-
-	for (auto& [round, count]: _other.roundEntryCounts)
-		if (roundEntryCounts.find(round) != roundEntryCounts.end())
-			roundEntryCounts.at(round) += count;
-		else
-			roundEntryCounts.insert({round, count});
-
-	return *this;
-}
-
-bool CacheStats::operator==(CacheStats const& _other) const
-{
-	return
-		hits == _other.hits &&
-		misses == _other.misses &&
-		totalCodeSize == _other.totalCodeSize &&
-		roundEntryCounts == _other.roundEntryCounts;
-}
-
-Program ProgramCache::optimiseProgram(
-	string const& _abbreviatedOptimisationSteps,
-	size_t _repetitionCount
-)
-{
-	string targetOptimisations = _abbreviatedOptimisationSteps;
-	for (size_t i = 1; i < _repetitionCount; ++i)
-		targetOptimisations += _abbreviatedOptimisationSteps;
-
-	size_t prefixSize = 0;
-	for (size_t i = 1; i <= targetOptimisations.size(); ++i)
-	{
-		auto const& pair = m_entries.find(targetOptimisations.substr(0, i));
-		if (pair != m_entries.end())
-		{
-			pair->second.roundNumber = m_currentRound;
-			++prefixSize;
-			++m_hits;
-		}
-		else
-			break;
-	}
-
-	Program intermediateProgram = (
-		prefixSize == 0 ?
-		m_program :
-		m_entries.at(targetOptimisations.substr(0, prefixSize)).program
-	);
-
-	for (size_t i = prefixSize + 1; i <= targetOptimisations.size(); ++i)
-	{
-		string stepName = OptimiserSuite::stepAbbreviationToNameMap().at(targetOptimisations[i - 1]);
-		intermediateProgram.optimise({stepName});
-
-		m_entries.insert({targetOptimisations.substr(0, i), {intermediateProgram, m_currentRound}});
-		++m_misses;
-	}
-
-	return intermediateProgram;
-}
-
-void ProgramCache::startRound(size_t _roundNumber)
-{
-	assert(_roundNumber > m_currentRound);
-	m_currentRound = _roundNumber;
-
-	for (auto pair = m_entries.begin(); pair != m_entries.end();)
-	{
-		assert(pair->second.roundNumber < m_currentRound);
-
-		if (pair->second.roundNumber < m_currentRound - 1)
-			m_entries.erase(pair++);
-		else
-			++pair;
-	}
-}
-
-void ProgramCache::clear()
-{
-	m_entries.clear();
-	m_currentRound = 0;
-}
-
-Program const* ProgramCache::find(string const& _abbreviatedOptimisationSteps) const
-{
-	auto const& pair = m_entries.find(_abbreviatedOptimisationSteps);
-	if (pair == m_entries.end())
-		return nullptr;
-
-	return &(pair->second.program);
-}
-
-CacheStats ProgramCache::gatherStats() const
-{
-	return {
-		/* hits = */ m_hits,
-		/* misses = */ m_misses,
-		/* totalCodeSize = */ calculateTotalCachedCodeSize(),
-		/* roundEntryCounts = */ countRoundEntries(),
-	};
-}
-
-size_t ProgramCache::calculateTotalCachedCodeSize() const
-{
-	size_t size = 0;
-	for (auto const& pair: m_entries)
-		size += pair.second.program.codeSize(CacheStats::StorageWeights);
-
-	return size;
-}
-
-map<size_t, size_t> ProgramCache::countRoundEntries() const
-{
-	map<size_t, size_t> counts;
-	for (auto& pair: m_entries)
-		if (counts.find(pair.second.roundNumber) != counts.end())
-			++counts.at(pair.second.roundNumber);
-		else
-			counts.insert({pair.second.roundNumber, 1});
-
-	return counts;
-}
diff --git a/compiler/tools/yulPhaser/ProgramCache.h b/compiler/tools/yulPhaser/ProgramCache.h
deleted file mode 100644
index d7eb70d6..00000000
--- a/compiler/tools/yulPhaser/ProgramCache.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <tools/yulPhaser/Program.h>
-
-#include <libyul/optimiser/Metrics.h>
-
-#include <cstddef>
-#include <map>
-#include <string>
-
-namespace solidity::phaser
-{
-
-/**
- * Structure used by @a ProgramCache to store intermediate programs and metadata associated
- * with them.
- */
-struct CacheEntry
-{
-	Program program;
-	size_t roundNumber;
-
-	CacheEntry(Program _program, size_t _roundNumber):
-		program(std::move(_program)),
-		roundNumber(_roundNumber) {}
-};
-
-/**
- * Stores statistics about current cache usage.
- */
-struct CacheStats
-{
-	/// Weights used to compute totalCodeSize.
-	/// The goal here is to get a result proportional to the amount of memory taken by the AST.
-	/// Each statement/expression gets 1 just for existing. We add more if it contains any extra
-	/// data that won't be visited separately by ASTWalker.
-	static yul::CodeWeights constexpr StorageWeights = {
-		/* expressionStatementCost = */ 1,
-		/* assignmentCost = */ 1,
-		/* variableDeclarationCost = */ 1,
-		/* functionDefinitionCost = */ 1,
-		/* ifCost = */ 1,
-		/* switchCost = */ 1,
-		/* caseCost = */ 1,
-		/* forLoopCost = */ 1,
-		/* breakCost = */ 1,
-		/* continueCost = */ 1,
-		/* leaveCost = */ 1,
-		/* blockCost = */ 1,
-
-		/* functionCallCost = */ 1,
-		/* identifierCost = */ 1,
-		/* literalCost = */ 1,
-	};
-
-	size_t hits;
-	size_t misses;
-	size_t totalCodeSize;
-	std::map<size_t, size_t> roundEntryCounts;
-
-	CacheStats& operator+=(CacheStats const& _other);
-	CacheStats operator+(CacheStats const& _other) const { return CacheStats(*this) += _other; }
-
-	bool operator==(CacheStats const& _other) const;
-	bool operator!=(CacheStats const& _other) const { return !(*this == _other); }
-};
-
-/**
- * Class that optimises programs one step at a time which allows it to store and later reuse the
- * results of the intermediate steps.
- *
- * The cache keeps track of the current round number and associates newly created entries with it.
- * @a startRound() must be called at the beginning of a round so that entries that are too old
- * can be purged. The current strategy is to store programs corresponding to all possible prefixes
- * encountered in the current and the previous rounds. Entries older than that get removed to
- * conserve memory.
- *
- * @a gatherStats() allows getting statistics useful for determining cache effectiveness.
- *
- * The current strategy does speed things up (about 4:1 hit:miss ratio observed in my limited
- * experiments) but there's room for improvement. We could fit more useful programs in
- * the cache by being more picky about which ones we choose.
- *
- * There is currently no way to purge entries without starting a new round. Since the programs
- * take a lot of memory, this may lead to the cache eating up all the available RAM if sequences are
- * long and programs large. A limiter based on entry count or total program size would be useful.
- */
-class ProgramCache
-{
-public:
-	explicit ProgramCache(Program _program):
-		m_program(std::move(_program)) {}
-
-	Program optimiseProgram(
-		std::string const& _abbreviatedOptimisationSteps,
-		size_t _repetitionCount = 1
-	);
-	void startRound(size_t _nextRoundNumber);
-	void clear();
-
-	size_t size() const { return m_entries.size(); }
-	Program const* find(std::string const& _abbreviatedOptimisationSteps) const;
-	bool contains(std::string const& _abbreviatedOptimisationSteps) const { return find(_abbreviatedOptimisationSteps) != nullptr; }
-
-	CacheStats gatherStats() const;
-
-	std::map<std::string, CacheEntry> const& entries() const { return m_entries; }
-	Program const& program() const { return m_program; }
-	size_t currentRound() const { return m_currentRound; }
-
-private:
-	size_t calculateTotalCachedCodeSize() const;
-	std::map<size_t, size_t> countRoundEntries() const;
-
-	// The best matching data structure here would be a trie of chromosome prefixes but since
-	// the programs are orders of magnitude larger than the prefixes, it does not really matter.
-	// A map should be good enough.
-	std::map<std::string, CacheEntry> m_entries;
-
-	Program m_program;
-	size_t m_currentRound = 0;
-	size_t m_hits = 0;
-	size_t m_misses = 0;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/README.md b/compiler/tools/yulPhaser/README.md
deleted file mode 100644
index 3bc72b53..00000000
--- a/compiler/tools/yulPhaser/README.md
+++ /dev/null
@@ -1,95 +0,0 @@
-## yul-phaser
-`yul-phaser` is an internal tool for finding good sequences of [optimisation steps](/libyul/optimiser/README.md) for Yul optimiser.
-
-### How it works
-The space of possible solutions to this problem (usually referred to as _phase-ordering problem_) is extremely large and there may even be no single sequence that produces optimal results for all possible programs.
-
-The tool uses genetic algorithms to find sequences that result in better programs than others and to iteratively refine them.
-The input is a set of one or more [Yul](/docs/yul.rst) programs and each sequence is applied to all of these programs.
-Optimised programs are given numeric scores according to the selected metric.
-
-Optimisation step sequences are presented in an abbreviated form - as strings of letters where each character represents one step.
-There's a [table listing available abbreviations in the optimiser docs](/docs/yul.rst#optimization-step-sequence).
-
-### How to use it
-The application has sensible defaults for most parameters.
-An invocation can be as simple as:
-
-``` bash
-tools/yul-phaser ../test/libyul/yulOptimizerTests/fullSuite/*.yul \
-    --random-population 100
-```
-
-This assumes that you have a working copy of the Solidity repository and you're in the build directory within that working copy.
-
-Run `yul-phaser --help` for a full list of available options.
-
-#### Restarting from a previous state
-`yul-phaser` can save the list of sequences found after each round:
-
-``` bash
-tools/yul-phaser *.yul        \
-    --random-population   100 \
-    --population-autosave /tmp/population.txt
-```
-
-If you stop the application, you can later use the file to continue the search from the point you left off:
-
-``` bash
-tools/yul-phaser *.yul                         \
-    --population-from-file /tmp/population.txt \
-    --population-autosave  /tmp/population.txt
-```
-
-#### Analysing a sequence
-Apart from running the genetic algorithm, `yul-phaser` can also provide useful information about a particular sequence.
-
-For example, to see the value of a particular metric for a given sequence and program run:
-``` bash
-tools/yul-phaser *.yul            \
-    --show-initial-population     \
-    --rounds            0         \
-    --metric            code-size \
-    --metric-aggregator sum       \
-    --population        <your sequence>
-```
-
-You can also easily see program code after being optimised using that sequence:
-``` bash
-tools/yul-phaser *.yul                    \
-    --rounds     0                        \
-    --mode       print-optimised-programs \
-    --population <your sequence>
-```
-
-#### Using output from Solidity compiler
-`yul-phaser` can process the intermediate representation produced by `solc`:
-
-``` bash
-solc/solc <sol file> --ir --output-dir <output directory>
-```
-
-After running this command you'll find one or more .yul files in the output directory.
-These files contain whole Yul objects rather than just raw Yul programs but `yul-phaser` is prepared to handle them too.
-
-#### Using optimisation step sequences with the compiler
-You can tell Yul optimiser to use a specific sequence for your code by passing `--yul-optimizations` option to `solc`:
-
-``` bash
-solc/solc <sol file> --optimize --ir-optimized --yul-optimizations <sequence>
-```
-
-### How to choose good parameters
-Choosing good parameters for a genetic algorithm is not a trivial task but phaser's defaults are generally enough to find a sequence that gives results comparable or better than one hand-crafted by an experienced developer for a given set of programs.
-The difficult part is providing a fairly representative set of input files.
-If the files you give don't need certain optimisations the tool will find sequences that don't use these optimisations and perform badly for programs that could benefit from them.
-If all the provided files greatly benefit from a specific optimisation, the sequence may not work well for programs that do not.
-
-We have conducted [a set of rough experiments](https://github.com/ethereum/solidity/issues/7806#issuecomment-598644491) to evaluate some combinations of parameter values.
-The conclusions were used to adjust the defaults but you might still benefit from some general observations:
-
-1. The algorithm that performed the best was `GEWEP`.
-2. Using longer sequences in the initial population yields better results. The algorithm is good at removing superfluous steps.
-3. Preserving the top sequences from previous rounds improves results. Elite should contain at least a few individuals, especially when using the `classic` algorithm.
-4. Don't set mutation/deletion/addition chance too high. It makes results worse because it destroys the good patterns preserved by crossover. Values around 1-5% seem to work best.
-5. Keep the algorithm running for 1000 rounds or more. It usually finds good sequences faster than that but it can shorten them significantly if you let it run longer. This is especially important when starting with long sequences.
diff --git a/compiler/tools/yulPhaser/Selections.cpp b/compiler/tools/yulPhaser/Selections.cpp
deleted file mode 100644
index 5c557064..00000000
--- a/compiler/tools/yulPhaser/Selections.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Selections.h>
-
-#include <tools/yulPhaser/SimulationRNG.h>
-
-#include <cmath>
-#include <numeric>
-
-using namespace std;
-using namespace solidity::phaser;
-
-vector<size_t> RangeSelection::materialise(size_t _poolSize) const
-{
-	size_t beginIndex = static_cast<size_t>(round(double(_poolSize) * m_startPercent));
-	size_t endIndex = static_cast<size_t>(round(double(_poolSize) * m_endPercent));
-	vector<size_t> selection;
-
-	for (size_t i = beginIndex; i < endIndex; ++i)
-		selection.push_back(i);
-
-	return selection;
-}
-
-vector<size_t> MosaicSelection::materialise(size_t _poolSize) const
-{
-	size_t count = static_cast<size_t>(round(double(_poolSize) * m_selectionSize));
-
-	vector<size_t> selection;
-	for (size_t i = 0; i < count; ++i)
-		selection.push_back(min(m_pattern[i % m_pattern.size()], _poolSize - 1));
-
-	return selection;
-}
-
-vector<size_t> RandomSelection::materialise(size_t _poolSize) const
-{
-	size_t count = static_cast<size_t>(round(double(_poolSize) * m_selectionSize));
-
-	vector<size_t> selection;
-	for (size_t i = 0; i < count; ++i)
-		selection.push_back(SimulationRNG::uniformInt(0, _poolSize - 1));
-
-	return selection;
-}
-
-vector<size_t> RandomSubset::materialise(size_t _poolSize) const
-{
-	vector<size_t> selection;
-	for (size_t index = 0; index < _poolSize; ++index)
-		if (SimulationRNG::bernoulliTrial(m_selectionChance))
-			selection.push_back(index);
-
-	return selection;
-}
diff --git a/compiler/tools/yulPhaser/Selections.h b/compiler/tools/yulPhaser/Selections.h
deleted file mode 100644
index bd51cfe7..00000000
--- a/compiler/tools/yulPhaser/Selections.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-/**
- * Contains an abstract base class representing a selection of elements from a collection
- * and its concrete implementations.
- */
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <vector>
-
-namespace solidity::phaser
-{
-
-/**
- * Abstract base class for selections of elements from a collection.
- *
- * An instance of this class represents a specific method of selecting a set of elements from
- * containers of arbitrary sizes. The set of selected elements is always a subset of the container
- * but may indicate the same element more than once. The selection may or may not be fixed - it's
- * up to a specific implementation whether subsequent calls for the same container produce the same
- * indices or not.
- *
- * Derived classes are meant to override the @a materialise() method.
- * This method is expected to produce indices of selected elements given the size of the collection.
- */
-class Selection
-{
-public:
-	Selection() = default;
-	Selection(Selection const&) = delete;
-	Selection& operator=(Selection const&) = delete;
-	virtual ~Selection() = default;
-
-	virtual std::vector<size_t> materialise(size_t _poolSize) const = 0;
-};
-
-/**
- * A selection that selects a contiguous slice of the container. Start and end of this part are
- * specified as percentages of its size.
- */
-class RangeSelection: public Selection
-{
-public:
-	explicit RangeSelection(double _startPercent = 0.0, double _endPercent = 1.0):
-		m_startPercent(_startPercent),
-		m_endPercent(_endPercent)
-	{
-		assert(0 <= m_startPercent && m_startPercent <= m_endPercent && m_endPercent <= 1.0);
-	}
-
-	std::vector<size_t> materialise(size_t _poolSize) const override;
-
-private:
-	double m_startPercent;
-	double m_endPercent;
-};
-
-/**
- * A selection that selects elements at specific, fixed positions indicated by a repeating "pattern".
- * If the positions in the pattern exceed the size of the container, they are capped at the maximum
- * available position. Always selects as many elements as the size of the container multiplied by
- * @a _selectionSize (unless the container is empty).
- *
- * E.g. if the pattern is {0, 9} and collection size is 5, the selection will materialise into
- * {0, 4, 0, 4, 0}. If the size is 3, it will be {0, 2, 0}.
- */
-class MosaicSelection: public Selection
-{
-public:
-	explicit MosaicSelection(std::vector<size_t> _pattern, double _selectionSize = 1.0):
-		m_pattern(std::move(_pattern)),
-		m_selectionSize(_selectionSize)
-	{
-		assert(m_pattern.size() > 0 || _selectionSize == 0.0);
-	}
-
-	std::vector<size_t> materialise(size_t _poolSize) const override;
-
-private:
-	std::vector<size_t> m_pattern;
-	double m_selectionSize;
-};
-
-/**
- * A selection that randomly selects elements from a container. The resulting set of indices may
- * contain duplicates and is different on each call to @a materialise(). Always selects as many
- * elements as the size of the container multiplied by @a _selectionSize (unless the container is
- * empty).
- */
-class RandomSelection: public Selection
-{
-public:
-	explicit RandomSelection(double _selectionSize):
-		m_selectionSize(_selectionSize)
-	{
-		assert(_selectionSize >= 0);
-	}
-
-	std::vector<size_t> materialise(size_t _poolSize) const override;
-
-private:
-	double m_selectionSize;
-};
-
-/**
- * A selection that goes over all elements in a container, for each one independently deciding
- * whether to select it or not. Each element has the same chance of being selected and can be
- * selected at most once. The order of selected elements is the same as the order of elements in
- * the container. The number of selected elements is random and can be different with each call
- * to @a materialise().
- */
-class RandomSubset: public Selection
-{
-public:
-	explicit RandomSubset(double _selectionChance):
-		m_selectionChance(_selectionChance)
-	{
-		assert(0.0 <= _selectionChance && _selectionChance <= 1.0);
-	}
-
-	std::vector<size_t> materialise(size_t _poolSize) const override;
-
-private:
-	double m_selectionChance;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/SimulationRNG.cpp b/compiler/tools/yulPhaser/SimulationRNG.cpp
deleted file mode 100644
index 5fca4d99..00000000
--- a/compiler/tools/yulPhaser/SimulationRNG.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/SimulationRNG.h>
-
-// NOTE: The code would work with std::random but the results for a given seed would not be reproducible
-// across different STL implementations. Boost does not guarantee this either but at least it has only one
-// implementation. Reproducibility is not a hard requirement for yul-phaser but it's nice to have.
-#include <boost/random/bernoulli_distribution.hpp>
-#include <boost/random/binomial_distribution.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-
-#include <ctime>
-#include <limits>
-
-using namespace std;
-using namespace solidity;
-using namespace solidity::phaser;
-
-thread_local boost::random::mt19937 SimulationRNG::s_generator(SimulationRNG::generateSeed());
-
-bool SimulationRNG::bernoulliTrial(double _successProbability)
-{
-	boost::random::bernoulli_distribution<double> distribution(_successProbability);
-
-	return distribution(s_generator);
-}
-
-size_t SimulationRNG::uniformInt(size_t _min, size_t _max)
-{
-	boost::random::uniform_int_distribution<size_t> distribution(_min, _max);
-	return distribution(s_generator);
-}
-
-size_t SimulationRNG::binomialInt(size_t _numTrials, double _successProbability)
-{
-	// NOTE: binomial_distribution<size_t> would not work because it internally tries to use abs()
-	// and fails to compile due to ambiguous conversion.
-	assert(_numTrials <= static_cast<size_t>(numeric_limits<long>::max()));
-
-	boost::random::binomial_distribution<long> distribution(static_cast<long>(_numTrials), _successProbability);
-	return static_cast<size_t>(distribution(s_generator));
-}
-
-uint32_t SimulationRNG::generateSeed()
-{
-	// This is not a secure way to seed the generator but it's good enough for simulation purposes.
-	// The only thing that matters for us is that the sequence is different on each run and that
-	// it fits the expected distribution. It does not have to be 100% unpredictable.
-	return static_cast<uint32_t>(time(nullptr));
-}
diff --git a/compiler/tools/yulPhaser/SimulationRNG.h b/compiler/tools/yulPhaser/SimulationRNG.h
deleted file mode 100644
index b36aeba2..00000000
--- a/compiler/tools/yulPhaser/SimulationRNG.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#pragma once
-
-#include <boost/random/mersenne_twister.hpp>
-
-#include <cstddef>
-#include <cstdint>
-
-namespace solidity::phaser
-{
-
-/**
- * A class that provides functions for generating random numbers good enough for simulation purposes.
- *
- * The functions share a common instance of the generator which can be reset with a known seed
- * to deterministically generate a given sequence of numbers. Initially the generator is seeded with
- * a value from @a generateSeed() which is different on each run.
- *
- * The numbers are not cryptographically secure so do not use this for anything that requires
- * them to be truly unpredictable.
- */
-class SimulationRNG
-{
-public:
-	static bool bernoulliTrial(double _successProbability);
-	static size_t uniformInt(size_t _min, size_t _max);
-	static size_t binomialInt(size_t _numTrials, double _successProbability);
-
-	/// Resets generator to a known state given by the @a seed. Given the same seed, a fixed
-	/// sequence of calls to the members generating random values is guaranteed to produce the
-	/// same results.
-	static void reset(uint32_t seed) { s_generator = boost::random::mt19937(seed); }
-
-	/// Generates a seed that's different on each run of the program.
-	/// Does **not** use the generator and is not affected by @a reset().
-	static uint32_t generateSeed();
-
-private:
-	thread_local static boost::random::mt19937 s_generator;
-};
-
-}
diff --git a/compiler/tools/yulPhaser/main.cpp b/compiler/tools/yulPhaser/main.cpp
deleted file mode 100644
index 1ec936dd..00000000
--- a/compiler/tools/yulPhaser/main.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-// SPDX-License-Identifier: GPL-3.0
-
-#include <tools/yulPhaser/Exceptions.h>
-#include <tools/yulPhaser/Phaser.h>
-
-#include <libsolutil/Exceptions.h>
-
-#include <iostream>
-
-int main(int argc, char** argv)
-{
-	try
-	{
-		solidity::phaser::Phaser::main(argc, argv);
-		return 0;
-	}
-	catch (boost::program_options::error const& exception)
-	{
-		// Bad input data. Invalid command-line parameters.
-
-		std::cerr << std::endl;
-		std::cerr << "ERROR: " << exception.what() << std::endl;
-		return 1;
-	}
-	catch (solidity::phaser::BadInput const& exception)
-	{
-		// Bad input data. Syntax errors in the input program, semantic errors in command-line
-		// parameters, etc.
-
-		std::cerr << std::endl;
-		std::cerr << "ERROR: " << exception.what() << std::endl;
-		return 1;
-	}
-	catch (solidity::util::Exception const& exception)
-	{
-		// Something's seriously wrong. Probably a bug in the program or a missing handler (which
-		// is really also a bug). The exception should have been handled gracefully by this point
-		// if it's something that can happen in normal usage. E.g. an error in the input or a
-		// failure of some part of the system that's outside of control of the application (disk,
-		// network, etc.). The bug should be reported and investigated so our job here is just to
-		// provide as much useful information about it as possible.
-
-		std::cerr << std::endl;
-		std::cerr << "UNCAUGHT EXCEPTION!" << std::endl;
-
-		// We can print some useful diagnostic info for this particular exception type.
-		std::cerr << "Location: " << exception.lineInfo() << std::endl;
-
-		char const* const* function = boost::get_error_info<boost::throw_function>(exception);
-		if (function != nullptr)
-			std::cerr << "Function: " << *function << std::endl;
-
-		// Let it crash. The terminate() will print some more stuff useful for debugging like
-		// what() and the actual exception type.
-		throw;
-	}
-	catch (std::exception const&)
-	{
-		// Again, probably a bug but this time it's just plain std::exception so there's no point
-		// in doing anything special. terminate() will do an adequate job.
-		std::cerr << std::endl;
-		std::cerr << "UNCAUGHT EXCEPTION!" << std::endl;
-		throw;
-	}
-	catch (...)
-	{
-		// Some people don't believe these exist.
-		// I have no idea what this is and it's flying towards me so technically speaking it's an
-		// unidentified flying object.
-		std::cerr << std::endl;
-		std::cerr << "UFO SPOTTED!" << std::endl;
-		throw;
-	}
-}
diff --git a/lib/stdlib_sol.tvm b/lib/stdlib_sol.tvm
index 3535af20..661f8d4f 100644
--- a/lib/stdlib_sol.tvm
+++ b/lib/stdlib_sol.tvm
@@ -1,1898 +1,1133 @@
-.fragment __exp, {
-	.loc stdlib.sol, 83
-	PUSHINT 1
-	.loc stdlib.sol, 84
-	PUSHCONT {
-		OVER
-		NEQINT 0
-	}
+.fragment __appendSliceToStringBuilder, {
+	.loc stdlib.sol, 198
+	OVER
+	FIRST
+	BREMBITS
+	ADDCONST -7
+	.loc stdlib.sol, 199
+	PUXCPU S1, S-1, S0
+	SBITS
+	MIN
+	LDSLICEX
+	POP S2
+	PUSH2 S2, S2
+	.loc stdlib.sol, 200
+	FIRST
+	XCHG S1, S2
+	STSLICE
+	SETINDEX 0
+	POP S2
+	.loc stdlib.sol, 201
+	DUP
+	SEMPTY
 	PUSHCONT {
-		.loc stdlib.sol, 85
-		OVER
-		MODPOW2 1
-		PUSHCONT {
-			.loc stdlib.sol, 86
-			PUSH S2
-			MUL
-			.loc stdlib.sol, 87
-			OVER
-			DEC
-		}
-		PUSHCONT {
-			.loc stdlib.sol, 89
-			PUSH2 S2, S2
-			MUL
-			POP S3
-			.loc stdlib.sol, 90
-			OVER
-			RSHIFT 1
-		}
-		IFELSE
+		.loc stdlib.sol, 203
+		DUP
+		NEWC
+		STSLICE
+		.loc stdlib.sol, 204
+		PUSH S2
+		PAIR
 		POP S2
 		.loc stdlib.sol, 0
 	}
-	WHILE
-	.loc stdlib.sol, 93
-	BLKDROP2 2, 1
-	.loc stdlib.sol, 0
-}
-
-.fragment __gasGasPrice, {
-	.loc stdlib.sol, 75
-	DUP
-	EQINT 0
-	OVER
-	EQINT -1
-	OR
-	THROWIFNOT 67
-	.loc stdlib.sol, 76
-	PUSHINT 20
-	PUSHINT 21
-	CONDSEL
-	CONFIGOPTPARAM
-	.loc stdlib.sol, 77
-	DUP
-	ISNULL
-	THROWIF 68
-	.loc stdlib.sol, 78
-	DUP
-	ISNULL
-	THROWIF 63
-	CTOS
-	.loc stdlib.sol, 79
-	LDU 8
-	LDU 64
-	LDU 64
-	LDU 8
-	PLDU 64
-	BLKDROP2 4, 1
-	.loc stdlib.sol, 0
-}
-
-.fragment __gasToTon, {
-	.loc stdlib.sol, 71
-	CALLREF {
-		.inline __gasGasPrice
-	}
-	PUSHPOW2 16
-	MULDIVC
+	IFNOT
+	.loc stdlib.sol, 206
+	DROP
 	.loc stdlib.sol, 0
 }
 
-.fragment __strstr, {
-	.loc stdlib.sol, 516
-	NULL
-	.loc stdlib.sol, 517
-	PUSH S2
-	CTOS
-	.loc stdlib.sol, 518
-	PUSH S2
-	CTOS
-	.loc stdlib.sol, 519
-	DUP
-	PUSHPOW2DEC 32
-	SDATASIZE
-	DROP
-	NIP
-	.loc stdlib.sol, 520
-	PUSH S2
-	PUSHPOW2DEC 32
-	SDATASIZE
-	DROP
-	NIP
-	.loc stdlib.sol, 521
-	DUP2
-	GREATER
-	PUSHCONT {
-		.loc stdlib.sol, 522
-		ROLL 4
-		BLKDROP2 6, 1
-		.loc stdlib.sol, 0
-	}
-	IFJMP
-	.loc stdlib.sol, 524
-	OVER
-	RSHIFT 3
-	POP S2
-	.loc stdlib.sol, 525
-	RSHIFT 3
-	.loc stdlib.sol, 526
-	PUSH2 S0, S2
-	.loc stdlib.sol, 527
-	LDU 8
-	POP S5
-	.loc stdlib.sol, 528
-	FALSE ; decl return flag
-	PUSHCONT {
-		PUSH2 S3, S4
-		GEQ
-	}
+.fragment __appendStringToStringBuilder, {
+	.loc stdlib.sol, 210
 	PUSHCONT {
-		.loc stdlib.sol, 529
-		PUSH S6
-		LDU 8
-		POP S8
-		.loc stdlib.sol, 530
-		PUSH S7
-		SBITREFS
-		.loc stdlib.sol, 531
-		OVER
-		LESSINT 8
-		OVER
-		GTINT 0
-		AND
-		PUSHCONT {
-			.loc stdlib.sol, 532
-			PUSH S9
-			LDREFRTOS
-			NIP
-			POP S10
-			.loc stdlib.sol, 0
-		}
-		IF
-		.loc stdlib.sol, 534
-		PUSH2 S2, S4
-		EQUAL
-		PUSHCONT {
-			.loc stdlib.sol, 535
-			BLKPUSH 2, 9
-			PUSHCONT {
-				.loc stdlib.sol, 493
-				OVER
-				SBITS
-				.loc stdlib.sol, 494
-				OVER
-				SBITS
-				.loc stdlib.sol, 495
-				FALSE ; decl return flag
-				PUSHCONT {
-					PUSH S2
-					NEQINT 0
-					PUSH S2
-					NEQINT 0
-					AND
-				}
-				PUSHCONT {
-					.loc stdlib.sol, 496
-					BLKPUSH 2, 2
-					MIN
-					.loc stdlib.sol, 497
-					PUSH2 S5, S0
-					LDSLICEX
-					POP S7
-					.loc stdlib.sol, 498
-					PUSH2 S5, S1
-					LDSLICEX
-					POP S7
-					.loc stdlib.sol, 499
-					PUSH2 S5, S2
-					SUB
-					POP S6
-					.loc stdlib.sol, 500
-					ROT
-					PUSH S4
-					SUBR
-					POP S4
-					.loc stdlib.sol, 501
-					SDEQ
-					PUSHCONT {
-						.loc stdlib.sol, 502
-						BLKDROP 5
-						FALSE
-						PUSHINT 4
-						RETALT
-						.loc stdlib.sol, 0
-					}
-					IFNOTJMP
-					.loc stdlib.sol, 504
-					PUSH S2
-					EQINT 0
-					PUSH S5
-					SREFS
-					NEQINT 0
-					AND
-					PUSHCONT {
-						.loc stdlib.sol, 505
-						PUSH S4
-						LDREFRTOS
-						NIP
-						POP S5
-						.loc stdlib.sol, 506
-						PUSH S4
-						SBITS
-						POP S3
-						.loc stdlib.sol, 0
-					}
-					IF
-					.loc stdlib.sol, 508
-					OVER
-					EQINT 0
-					PUSH S4
-					SREFS
-					NEQINT 0
-					AND
-					PUSHCONT {
-						.loc stdlib.sol, 509
-						PUSH S3
-						LDREFRTOS
-						NIP
-						POP S4
-						.loc stdlib.sol, 510
-						PUSH S3
-						SBITS
-						POP S2
-						.loc stdlib.sol, 0
-					}
-					IF
-					.loc stdlib.sol, 0
-				}
-				WHILEBRK
-				IFRET
-				.loc stdlib.sol, 513
-				BLKDROP 4
-				TRUE
-				.loc stdlib.sol, 492
-			}
-			CALLX
-			.loc stdlib.sol, 0
-			PUSHCONT {
-				.loc stdlib.sol, 536
-				BLKSWAP 2, 5
-				SUBR
-				MODPOW2 32
-				POP S9
-				.loc stdlib.sol, 537
-				ROLL 8
-				BLKDROP2 10, 1
-				PUSHINT 4
-				RETALT
-				.loc stdlib.sol, 0
-			}
-			IFJMP
+		.loc stdlib.sol, 211
+		BLKPUSH 2, 0
+		SBITS
+		LDSLICEX
+		POP S2
+		PUXC S2, S-1
+		.loc stdlib.sol, 212
+		CALLREF {
+			.inline __appendSliceToStringBuilder
 		}
-		IF
-		.loc stdlib.sol, 540
-		BLKDROP 3
-		PUSH S3
-		DEC
-		POP S4
+		POP S2
+		.loc stdlib.sol, 213
+		DUP
+		SEMPTY
+		IFRETALT
+		.loc stdlib.sol, 215
+		LDREFRTOS
+		NIP
 		.loc stdlib.sol, 0
 	}
-	WHILEBRK
-	IFRET
-	.loc stdlib.sol, 542
-	BLKDROP 6
-	BLKDROP2 2, 1
+	AGAINBRK
+	.loc stdlib.sol, 217
+	DROP
 	.loc stdlib.sol, 0
 }
 
-.fragment assembleList, {
-	.loc stdlib.sol, 302
+.fragment __makeString, {
+	.loc stdlib.sol, 344
 	PUSHCONT {
-		OVER
-		TLEN
-		ISZERO
+		DUP
+		SECOND
+		ISNULL
 		NOT
 	}
 	PUSHCONT {
-		.loc stdlib.sol, 303
-		OVER
-		CALLREF {
-			TPOP
-			TPOP
-			ROTREV
-			DUP
-			TLEN
-			PUSHCONT {
-				TPUSH
-			}
-			PUSHCONT {
-				DROP
-			}
-			IFELSE
-		}
-		POP S3
-		.loc stdlib.sol, 304
-		STBREF
+		.loc stdlib.sol, 345
+		DUP
+		FIRST
+		.loc stdlib.sol, 346
+		SWAP
+		SECOND
+		DUP
+		ISNULL
+		THROWIF 63
+		.loc stdlib.sol, 347
+		DUP
+		FIRST
+		ROT
+		STBREFR
+		SETINDEX 0
 		.loc stdlib.sol, 0
 	}
 	WHILE
-	.loc stdlib.sol, 307
+	.loc stdlib.sol, 349
+	FIRST
 	ENDC
-	NIP
 	.loc stdlib.sol, 0
 }
 
 .fragment __subCell, {
-	.loc stdlib.sol, 406
-	PUSHREF {
-	}
-	.loc stdlib.sol, 407
+	.loc stdlib.sol, 272
+	PUSH S2
+	PUSHINT 127
+	DIVMOD
+	.loc stdlib.sol, 273
+	OVER
+	NEQINT 0
 	OVER
+	EQINT 0
+	AND
 	PUSHCONT {
-		.loc stdlib.sol, 408
-		BLKDROP2 3, 1
+		.loc stdlib.sol, 274
+		DROP
+		DEC
+		.loc stdlib.sol, 275
+		PUSHINT 127
 		.loc stdlib.sol, 0
 	}
-	IFNOTJMP
-	.loc stdlib.sol, 410
-	DROP
-	SWAP
-	PUSHINT 127
-	DIVMOD
-	.loc stdlib.sol, 411
-	ROLL 3
+	IF
+	.loc stdlib.sol, 278
+	PUSH S5
 	CTOS
-	.loc stdlib.sol, 412
-	ROT
+	.loc stdlib.sol, 279
+	PUSH S2
 	PUSHCONT {
-		.loc stdlib.sol, 413
+		.loc stdlib.sol, 280
+		DUP
+		SREFS
+		EQINT 1
+		THROWIFNOT 70
+		.loc stdlib.sol, 281
 		LDREFRTOS
 		NIP
 		.loc stdlib.sol, 0
 	}
 	REPEAT
-	.loc stdlib.sol, 415
-	SWAP
+	.loc stdlib.sol, 284
+	OVER
 	MULCONST 8
+	POP S2
+	.loc stdlib.sol, 285
+	DUP
+	SBITS
+	PUSH S2
+	GEQ
+	THROWIFNOT 70
+	.loc stdlib.sol, 286
+	OVER
 	SDSKIPFIRST
-	.loc stdlib.sol, 416
-	TUPLE 0
-	.loc stdlib.sol, 417
+	.loc stdlib.sol, 288
+	PUSH S4
+	MULCONST 8
+	POP S5
+	.loc stdlib.sol, 289
 	NEWC
-	.loc stdlib.sol, 418
-	PUSHCONT {
-		PUSH S3
-		NEQINT 0
-	}
+	NULL
+	PAIR
+	.loc stdlib.sol, 290
 	PUSHCONT {
-		.loc stdlib.sol, 419
-		OVER2
+		.loc stdlib.sol, 291
+		OVER
 		SBITS
-		RSHIFT 3
-		PUSH S2
-		BREMBITS
-		RSHIFT 3
-		MIN
+		PUSH S6
 		MIN
-		.loc stdlib.sol, 420
-		PUSH3 S1, S3, S0
-		LSHIFT 3
-		MODPOW2 10
+		UFITS 10
+		.loc stdlib.sol, 292
+		PUSH2 S6, S0
+		SUB
+		POP S7
+		PUXC S2, S-1
+		.loc stdlib.sol, 293
 		LDSLICEX
-		POP S6
-		STSLICER
-		POP S2
-		.loc stdlib.sol, 421
-		PUSH S4
-		SUBR
-		POP S4
-		.loc stdlib.sol, 422
-		PUSH S3
-		PUSHCONT {
-			.loc stdlib.sol, 423
-			PUSH S2
-			SBITS
-			PUSHCONT {
-				.loc stdlib.sol, 424
-				PUSH S2
-				LDREFRTOS
-				NIP
-				POP S3
-				.loc stdlib.sol, 0
-			}
-			IFNOT
-			.loc stdlib.sol, 426
-			DUP
-			BREMBITS
-			LESSINT 8
-			PUSHCONT {
-				.loc stdlib.sol, 427
-				CALLREF {
-					XCPU S1, S0
-					TLEN
-					PUSHCONT {
-						TPOP
-						DUP
-						TLEN
-						PUSHPOW2DEC 8
-						SUB
-						PUSHCONT {
-							TPUSH
-							TUPLE 0
-						}
-						IFNOT
-					}
-					PUSHCONT {
-						TUPLE 0
-					}
-					IFELSE
-					ROT
-					TPUSH
-					TPUSH
-				}
-				.loc stdlib.sol, 428
-				NEWC
-				.loc stdlib.sol, 0
-			}
-			IF
-			.loc stdlib.sol, 0
+		POP S3
+		.loc stdlib.sol, 294
+		CALLREF {
+			.inline __appendSliceToStringBuilder
 		}
-		IF
+		.loc stdlib.sol, 295
+		PUSH S5
+		EQINT 0
+		PUSH S2
+		SEMPTY
+		OR
+		IFRETALT
+		.loc stdlib.sol, 298
+		OVER
+		LDREFRTOS
+		NIP
+		POP S2
 		.loc stdlib.sol, 0
 	}
-	WHILE
-	.loc stdlib.sol, 432
-	CALLREF {
-		.inline assembleList
-	}
-	BLKDROP2 2, 1
-	.loc stdlib.sol, 0
-}
-
-.fragment __substr_from, {
-	.loc stdlib.sol, 392
-	OVER
-	PUSHPOW2DEC 32
-	CDATASIZE
-	DROP
-	NIP
-	.loc stdlib.sol, 393
-	RSHIFT 3
-	.loc stdlib.sol, 394
-	PUSH2 S0, S1
-	GEQ
-	THROWIFNOT 70
-	.loc stdlib.sol, 395
-	OVER
-	SUB
-	.loc stdlib.sol, 396
-	CALLREF {
-		.inline __subCell
-	}
-	.loc stdlib.sol, 0
-}
-
-.fragment __substr_from_count, {
-	.loc stdlib.sol, 400
-	PUSH S2
-	PUSHPOW2DEC 32
-	CDATASIZE
-	DROP
-	NIP
-	.loc stdlib.sol, 401
-	RSHIFT 3
-	.loc stdlib.sol, 402
-	BLKPUSH 2, 2
-	ADD
-	GEQ
-	THROWIFNOT 70
-	.loc stdlib.sol, 403
-	CALLREF {
-		.inline __subCell
-	}
-	.loc stdlib.sol, 0
-}
-
-.fragment __tonToGas, {
-	.loc stdlib.sol, 67
-	PUSHPOW2 16
+	AGAINBRK
+	.loc stdlib.sol, 300
+	BLKSWAP 2, 4
 	SWAP
+	EQINT 0
+	OR
+	THROWIFNOT 70
+	.loc stdlib.sol, 301
 	CALLREF {
-		.inline __gasGasPrice
+		.inline __makeString
 	}
-	MULDIV
+	BLKDROP2 5, 1
 	.loc stdlib.sol, 0
 }
 
-.fragment bytes_substr, {
-	.loc stdlib.sol, 381
-	PUSH S3
-	PUSHPOW2DEC 32
-	CDATASIZE
-	DROP
-	NIP
-	.loc stdlib.sol, 382
-	RSHIFT 3
-	.loc stdlib.sol, 383
-	SWAP
-	PUSHCONT {
-		.loc stdlib.sol, 384
-		DUP
-		POP S2
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 385
-	PUSH2 S1, S2
-	GEQ
+.fragment __arraySlice, {
+	.loc stdlib.sol, 266
+	DUP2
+	LEQ
 	THROWIFNOT 70
-	.loc stdlib.sol, 386
-	XCPU S1, S2
+	.loc stdlib.sol, 267
+	OVER
 	SUB
-	.loc stdlib.sol, 387
-	SWAP
-	BLKPUSH 2, 2
-	ADD
-	GEQ
-	THROWIFNOT 70
-	.loc stdlib.sol, 388
+	.loc stdlib.sol, 268
+	FALSE
 	CALLREF {
 		.inline __subCell
 	}
 	.loc stdlib.sol, 0
 }
 
-.fragment storeStringInBuilders, {
-	.loc stdlib.sol, 284
-	OVER
-	BREMBITS
-	ADDCONST -7
-	.loc stdlib.sol, 285
-	OVER
-	SBITREFS
-	.loc stdlib.sol, 286
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 287
-		PUSH S3
-		PUSHINT 0
-		PUSH S2
-		SSKIPFIRST
-		POP S4
-		.loc stdlib.sol, 0
-	}
-	IF
-	.loc stdlib.sol, 288
-	DROP
+.fragment __stringToStringBuilder, {
+	.loc stdlib.sol, 330
+	NULL
+	.loc stdlib.sol, 331
 	OVER
-	LEQ
-	.loc stdlib.sol, 289
-	PUSHCONT {
-		.loc stdlib.sol, 292
-		DUP2
-		LDSLICEX
-		POP S3
-		.loc stdlib.sol, 293
-		PUSH S3
-		STSLICE
-		POP S3
-		.loc stdlib.sol, 294
-		OVER2
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S4
-		.loc stdlib.sol, 295
-		NEWC
-		POP S3
-		.loc stdlib.sol, 296
-	}
-	IFNOT
-	PUSH2 S1, S2
-	STSLICE
-	BLKDROP2 3, 1
-	.loc stdlib.sol, 0
-}
-
-.fragment strToList, {
-	.loc stdlib.sol, 366
-	TUPLE 0
-	.loc stdlib.sol, 367
-	SWAP
 	CTOS
-	.loc stdlib.sol, 368
+	.loc stdlib.sol, 332
 	PUSHCONT {
-		DUP
-		SREFS
-		NEQINT 0
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 369
-		LDREFRTOS
-		.loc stdlib.sol, 371
-		SWAP
+		.loc stdlib.sol, 334
+		BLKPUSH 2, 0
+		SBITS
+		LDSLICEX
+		POP S2
 		NEWC
 		STSLICE
-		.loc stdlib.sol, 372
-		PUXC S2, S-1
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
+		.loc stdlib.sol, 335
+		PUSH S2
+		PAIR
 		POP S2
+		.loc stdlib.sol, 336
+		DUP
+		SEMPTY
+		IFRETALT
+		.loc stdlib.sol, 338
+		LDREFRTOS
+		NIP
 		.loc stdlib.sol, 0
 	}
-	WHILE
-	.loc stdlib.sol, 376
-	NEWC
-	STSLICE
+	AGAINBRK
+	.loc stdlib.sol, 340
+	DROP
+	DUP
+	ISNULL
+	THROWIF 63
+	NIP
 	.loc stdlib.sol, 0
 }
 
-.fragment concatenateStrings, {
-	.loc stdlib.sol, 461
+.fragment __concatenateStrings, {
+	.loc stdlib.sol, 353
 	SWAP
 	CALLREF {
-		.inline strToList
+		.inline __stringToStringBuilder
 	}
-	.loc stdlib.sol, 462
-	ROT
+	.loc stdlib.sol, 354
+	SWAP
 	CTOS
-	.loc stdlib.sol, 463
-	BLKPUSH 3, 2
 	CALLREF {
-		.inline storeStringInBuilders
+		.inline __appendStringToStringBuilder
 	}
-	POP S3
-	POP S3
-	.loc stdlib.sol, 464
-	PUSHCONT {
-		DUP
-		PUSHINT 1
-		SCHKREFSQ
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 465
-		LDREFRTOS
-		NIP
-		.loc stdlib.sol, 466
-		BLKPUSH 3, 2
-		CALLREF {
-			.inline storeStringInBuilders
-		}
-		POP S3
-		POP S3
-		.loc stdlib.sol, 0
-	}
-	WHILE
-	.loc stdlib.sol, 468
-	DROP
+	.loc stdlib.sol, 355
 	CALLREF {
-		.inline assembleList
+		.inline __makeString
 	}
 	.loc stdlib.sol, 0
 }
 
-.fragment parseInteger, {
-	.loc stdlib.sol, 99
-	TUPLE 0
-	.loc stdlib.sol, 100
-	PUSH S2
+.fragment __parseInteger, {
+	.loc stdlib.sol, 47
+	OVER
 	PUSHCONT {
-		.loc stdlib.sol, 101
+		.loc stdlib.sol, 48
 		PUSHINT 0
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		.loc stdlib.sol, 102
+		NULL
+		PAIR
 		BLKDROP2 2, 1
+		PUSHINT 1
 		.loc stdlib.sol, 0
 	}
 	IFNOTJMP
-	.loc stdlib.sol, 104
+	.loc stdlib.sol, 50
+	NULL
+	.loc stdlib.sol, 51
 	PUSHINT 0
-	.loc stdlib.sol, 105
+	.loc stdlib.sol, 52
 	PUSHCONT {
 		PUSH S3
 		NEQINT 0
 	}
 	PUSHCONT {
-		.loc stdlib.sol, 106
+		.loc stdlib.sol, 54
 		OVER2
 		DIVMOD
+		POP S5
+		XCPU S4, S2
+		.loc stdlib.sol, 55
+		PAIR
 		POP S2
-		POP S4
-		.loc stdlib.sol, 107
-		DUP2
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S2
+		.loc stdlib.sol, 56
+		INC
 		.loc stdlib.sol, 0
 	}
 	WHILE
-	DROP
-	BLKDROP2 2, 1
+	.loc stdlib.sol, 58
+	BLKDROP2 2, 2
 	.loc stdlib.sol, 0
 }
 
-.fragment convertIntToHexStr, {
-	.loc stdlib.sol, 210
+.fragment __convertIntToHexString, {
+	.loc stdlib.sol, 148
+	PUSH S3
+	LESSINT 0
+	.loc stdlib.sol, 149
+	ROLL 4
+	ABS
+	.loc stdlib.sol, 150
 	PUSH S5
+	FIRST
 	BREMBITS
 	RSHIFT 3
-	.loc stdlib.sol, 211
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 212
-		BLKPUSH 2, 7
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S8
-		.loc stdlib.sol, 213
-		NEWC
-		POP S7
-		.loc stdlib.sol, 214
-		DROP
-		PUSHINT 127
-		.loc stdlib.sol, 0
-	}
-	IFNOT
-	.loc stdlib.sol, 216
-	ROLL 3
-	PUSHINT 48
-	PUSHINT 32
-	CONDSEL
-	.loc stdlib.sol, 217
+	.loc stdlib.sol, 152
 	ROT
 	PUSHCONT {
-		.loc stdlib.sol, 218
-		PUSH S5
+		.loc stdlib.sol, 153
+		DUP
+		PUSHCONT {
+			.loc stdlib.sol, 154
+			NEWC
+			PUSH S6
+			PAIR
+			POP S6
+			.loc stdlib.sol, 155
+			DROP
+			PUSHINT 127
+			.loc stdlib.sol, 0
+		}
+		IFNOT
+		.loc stdlib.sol, 157
+		PUSH2 S5, S5
+		FIRST
 		STSLICECONST x2d
+		SETINDEX 0
 		POP S6
+		.loc stdlib.sol, 158
+		DEC
 		.loc stdlib.sol, 0
 	}
 	IF
-	.loc stdlib.sol, 219
-	OVER
-	DEC
-	POP S2
-	.loc stdlib.sol, 220
-	OVER
-	PUSHCONT {
-		.loc stdlib.sol, 221
-		BLKPUSH 2, 6
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S7
-		.loc stdlib.sol, 222
-		NEWC
-		POP S6
-		.loc stdlib.sol, 223
-		PUSHINT 127
-		POP S2
-		.loc stdlib.sol, 0
-	}
-	IFNOT
-	.loc stdlib.sol, 225
-	ROLL 4
+	.loc stdlib.sol, 161
+	SWAP
 	PUSHINT 16
 	CALLREF {
-		.inline parseInteger
-	}
-	.loc stdlib.sol, 226
-	DUP
-	CALLREF {
-		DUP
-		TLEN
-		DUP
-		PUSHCONT {
-			DEC
-			PUSHPOW2DEC 8
-			MUL
-			SWAP
-			LAST
-			TLEN
-			ADD
-		}
-		PUSHCONT {
-			NIP
-		}
-		IFELSE
+		.inline __parseInteger
 	}
-	.loc stdlib.sol, 228
-	PUSH S5
+	.loc stdlib.sol, 163
+	PUSH2 S5, S0
+	GREATER
 	PUSHCONT {
-		.loc stdlib.sol, 229
-		PUSH2 S5, S0
-		LESS
-		PUSH S6
-		GTINT 127
-		OR
-		THROWIF 69
-		.loc stdlib.sol, 231
-		PUSH2 S5, S0
+		.loc stdlib.sol, 164
+		PUSH S4
+		PUSHINT 48
+		PUSHINT 32
+		CONDSEL
+		.loc stdlib.sol, 165
+		PUSH2 S6, S1
 		SUB
-		.loc stdlib.sol, 232
+		.loc stdlib.sol, 166
 		PUSH2 S0, S4
-		LEQ
-		PUSHCONT {
-			.loc stdlib.sol, 233
-			DUP
-			PUSHCONT {
-				.loc stdlib.sol, 234
-				PUSH2 S7, S3
-				STUR 8
-				POP S8
-				.loc stdlib.sol, 0
-			}
-			REPEAT
-			.loc stdlib.sol, 236
-			PUSH2 S4, S0
-			SUB
-			POP S5
-			.loc stdlib.sol, 237
-			PUSH S4
-			PUSHCONT {
-				.loc stdlib.sol, 238
-				BLKPUSH 2, 8
-				CALLREF {
-					XCPU S1, S0
-					TLEN
-					PUSHCONT {
-						TPOP
-						DUP
-						TLEN
-						PUSHPOW2DEC 8
-						SUB
-						PUSHCONT {
-							TPUSH
-							TUPLE 0
-						}
-						IFNOT
-					}
-					PUSHCONT {
-						TUPLE 0
-					}
-					IFELSE
-					ROT
-					TPUSH
-					TPUSH
-				}
-				POP S9
-				.loc stdlib.sol, 239
-				NEWC
-				POP S8
-				.loc stdlib.sol, 240
-				PUSHINT 127
-				POP S5
-				.loc stdlib.sol, 0
-			}
-			IFNOT
-		}
-		PUSHCONT {
-			.loc stdlib.sol, 243
-			PUSH S4
-			PUSHCONT {
-				.loc stdlib.sol, 244
-				PUSH2 S7, S3
-				STUR 8
-				POP S8
-				.loc stdlib.sol, 0
-			}
-			REPEAT
-			.loc stdlib.sol, 246
-			BLKPUSH 2, 8
-			CALLREF {
-				XCPU S1, S0
-				TLEN
-				PUSHCONT {
-					TPOP
-					DUP
-					TLEN
-					PUSHPOW2DEC 8
-					SUB
-					PUSHCONT {
-						TPUSH
-						TUPLE 0
-					}
-					IFNOT
-				}
-				PUSHCONT {
-					TUPLE 0
-				}
-				IFELSE
-				ROT
-				TPUSH
-				TPUSH
-			}
-			POP S9
-			.loc stdlib.sol, 247
-			NEWC
-			POP S8
-			.loc stdlib.sol, 248
-			PUSH2 S0, S4
-			SUB
-			PUSHCONT {
-				.loc stdlib.sol, 249
-				PUSH2 S7, S3
-				STUR 8
-				POP S8
-				.loc stdlib.sol, 0
-			}
-			REPEAT
-			.loc stdlib.sol, 251
-			PUSHINT 127
-			OVER
-			SUB
-			PUSH S5
-			ADD
-			POP S5
-		}
-		IFELSE
-		.loc stdlib.sol, 0
-		DROP
-	}
-	IF
-	.loc stdlib.sol, 254
-	PUSH2 S0, S3
-	LEQ
-	PUSHCONT {
-		.loc stdlib.sol, 255
-		DUP
-		PUSHCONT {
-			.loc stdlib.sol, 256
-			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
-				PUSHCONT {
-					TPUSH
-				}
-				PUSHCONT {
-					DROP
-				}
-				IFELSE
-			}
-			POP S3
-			.loc stdlib.sol, 257
-			DUP
-			LESSINT 10
-			PUSHCONT {
-				.loc stdlib.sol, 258
-				PUSH S7
-				PUSHINT 48
-			}
-			PUSHCONT {
-				.loc stdlib.sol, 260
-				PUSH2 S7, S5
-				PUSHINT 87
-				PUSHINT 55
-				CONDSEL
-			}
-			IFELSE
-			PUSH S2
-			ADD
-			STUR 8
-			POP S8
-			.loc stdlib.sol, 0
-			DROP
-		}
-		REPEAT
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 263
-		PUSH S3
+		MIN
 		PUSHCONT {
-			.loc stdlib.sol, 264
-			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
-				PUSHCONT {
-					TPUSH
-				}
-				PUSHCONT {
-					DROP
-				}
-				IFELSE
-			}
-			POP S3
-			.loc stdlib.sol, 265
-			DUP
-			LESSINT 10
-			PUSHCONT {
-				.loc stdlib.sol, 266
-				PUSH S7
-				PUSHINT 48
-			}
-			PUSHCONT {
-				.loc stdlib.sol, 268
-				PUSH2 S7, S5
-				PUSHINT 87
-				PUSHINT 55
-				CONDSEL
-			}
-			IFELSE
-			PUSH S2
-			ADD
+			.loc stdlib.sol, 167
+			PUSH2 S8, S8
+			FIRST
+			PUSH S3
 			STUR 8
-			POP S8
+			SETINDEX 0
+			POP S9
 			.loc stdlib.sol, 0
-			DROP
 		}
 		REPEAT
-		.loc stdlib.sol, 270
-		BLKPUSH 2, 7
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
+		.loc stdlib.sol, 169
+		PUSH2 S0, S4
+		GREATER
+		PUSHCONT {
+			.loc stdlib.sol, 170
+			NEWC
+			PUSH S9
+			PAIR
+			POP S9
+			.loc stdlib.sol, 171
+			PUSH2 S0, S4
+			SUB
 			PUSHCONT {
-				TUPLE 0
+				.loc stdlib.sol, 172
+				PUSH2 S8, S8
+				FIRST
+				PUSH S3
+				STUR 8
+				SETINDEX 0
+				POP S9
+				.loc stdlib.sol, 0
 			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
+			REPEAT
+			.loc stdlib.sol, 174
+			PUSH S4
+			ADDCONST 127
+			OVER
+		}
+		PUSHCONT {
+			.loc stdlib.sol, 176
+			PUSH2 S4, S0
 		}
-		POP S8
-		.loc stdlib.sol, 271
+		IFELSE
+		SUB
+		POP S5
+		.loc stdlib.sol, 0
+		DROP2
+	}
+	IF
+	.loc stdlib.sol, 180
+	ROLL 3
+	PUSHINT 97
+	PUSHINT 65
+	CONDSEL
+	ADDCONST -10
+	.loc stdlib.sol, 181
+	PUSH2 S1, S3
+	MIN
+	PUSHCONT {
+		.loc stdlib.sol, 183
+		PUSH2 S2, S2
+		ISNULL
+		THROWIF 63
+		UNPAIR
+		POP S4
+		.loc stdlib.sol, 184
+		PUSH2 S7, S7
+		FIRST
+		XC2PU S0, S2, S0
+		LESSINT 10
+		PUSHINT 48
+		PUSH S5
+		CONDSEL
+		ADD
+		STUR 8
+		SETINDEX 0
+		POP S7
+		.loc stdlib.sol, 0
+	}
+	REPEAT
+	.loc stdlib.sol, 186
+	PUSH2 S1, S3
+	GREATER
+	PUSHCONT {
+		.loc stdlib.sol, 187
 		NEWC
+		PUSH S7
+		PAIR
 		POP S7
-		.loc stdlib.sol, 272
-		PUSH2 S0, S3
+		PUSH2 S1, S3
+		.loc stdlib.sol, 188
 		SUB
 		PUSHCONT {
-			.loc stdlib.sol, 273
-			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
-				PUSHCONT {
-					TPUSH
-				}
-				PUSHCONT {
-					DROP
-				}
-				IFELSE
-			}
-			POP S3
-			.loc stdlib.sol, 274
-			DUP
+			.loc stdlib.sol, 190
+			PUSH2 S2, S2
+			ISNULL
+			THROWIF 63
+			UNPAIR
+			POP S4
+			.loc stdlib.sol, 191
+			PUSH2 S7, S7
+			FIRST
+			XC2PU S0, S2, S0
 			LESSINT 10
-			PUSHCONT {
-				.loc stdlib.sol, 275
-				PUSH S7
-				PUSHINT 48
-			}
-			PUSHCONT {
-				.loc stdlib.sol, 277
-				PUSH2 S7, S5
-				PUSHINT 87
-				PUSHINT 55
-				CONDSEL
-			}
-			IFELSE
-			PUSH S2
+			PUSHINT 48
+			PUSH S5
+			CONDSEL
 			ADD
 			STUR 8
-			POP S8
+			SETINDEX 0
+			POP S7
 			.loc stdlib.sol, 0
-			DROP
 		}
 		REPEAT
+		.loc stdlib.sol, 0
 	}
-	IFELSE
-	.loc stdlib.sol, 280
+	IF
+	.loc stdlib.sol, 194
 	BLKDROP 6
 	.loc stdlib.sol, 0
 }
 
-.fragment convertIntToHexStr_short, {
-	.loc stdlib.sol, 206
-	ROTREV
-	PUSH S2
-	ABS
+.fragment __convertAddressToHexString, {
+	.loc stdlib.sol, 119
+	REWRITESTDADDR
+	.loc stdlib.sol, 120
+	PUXC S2, S1
 	PUSHINT 0
 	DUP
 	TRUE
-	ROLL 6
-	LESSINT 0
-	CALLREF {
-		.inline convertIntToHexStr
-	}
-	.loc stdlib.sol, 0
-}
-
-.fragment convertAddressToHexString, {
-	.loc stdlib.sol, 177
-	REWRITESTDADDR
-	.loc stdlib.sol, 178
-	OVER2
-	ROLL 3
 	CALLREF {
-		.inline convertIntToHexStr_short
+		.inline __convertIntToHexString
 	}
-	POP S3
-	POP S3
-	.loc stdlib.sol, 179
+	POP S2
+	.loc stdlib.sol, 121
 	OVER
+	FIRST
 	BREMBITS
-	.loc stdlib.sol, 180
-	GTINT 8
+	.loc stdlib.sol, 122
+	LESSINT 8
 	PUSHCONT {
-		.loc stdlib.sol, 183
-		BLKPUSH 2, 2
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S3
-		.loc stdlib.sol, 184
+		.loc stdlib.sol, 123
 		NEWC
+		PUSH S2
+		PAIR
 		POP S2
-		.loc stdlib.sol, 185
+		.loc stdlib.sol, 0
 	}
-	IFNOT
-	OVER
+	IF
+	.loc stdlib.sol, 125
+	PUSH2 S1, S1
+	FIRST
 	STSLICECONST x3a
+	SETINDEX 0
 	POP S2
-	.loc stdlib.sol, 187
+	.loc stdlib.sol, 126
 	PUSHINT 64
 	TRUE
 	DUP
-	FALSE
 	CALLREF {
-		.inline convertIntToHexStr
+		.inline __convertIntToHexString
 	}
 	.loc stdlib.sol, 0
 }
 
-.fragment convertIntToDecStr, {
-	.loc stdlib.sol, 112
+.fragment __convertIntToString, {
+	.loc stdlib.sol, 69
+	PUSH S2
+	LESSINT 0
+	.loc stdlib.sol, 70
+	ROLL 3
+	ABS
+	.loc stdlib.sol, 71
 	PUSH S4
+	FIRST
 	BREMBITS
 	RSHIFT 3
-	.loc stdlib.sol, 113
-	DUP
-	PUSHCONT {
-		.loc stdlib.sol, 114
-		BLKPUSH 2, 6
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S7
-		.loc stdlib.sol, 115
-		NEWC
-		POP S6
-		.loc stdlib.sol, 116
-		DROP
-		PUSHINT 127
-		.loc stdlib.sol, 0
-	}
-	IFNOT
-	.loc stdlib.sol, 118
-	ROT
-	PUSHINT 48
-	PUSHINT 32
-	CONDSEL
-	.loc stdlib.sol, 119
+	.loc stdlib.sol, 73
 	ROT
 	PUSHCONT {
-		.loc stdlib.sol, 120
-		PUSH S4
+		.loc stdlib.sol, 74
+		DUP
+		PUSHCONT {
+			.loc stdlib.sol, 75
+			NEWC
+			PUSH S5
+			PAIR
+			POP S5
+			.loc stdlib.sol, 76
+			DROP
+			PUSHINT 127
+			.loc stdlib.sol, 0
+		}
+		IFNOT
+		.loc stdlib.sol, 78
+		PUSH2 S4, S4
+		FIRST
 		STSLICECONST x2d
+		SETINDEX 0
 		POP S5
+		.loc stdlib.sol, 79
+		DEC
 		.loc stdlib.sol, 0
 	}
 	IF
-	.loc stdlib.sol, 121
-	OVER
-	DEC
-	POP S2
-	.loc stdlib.sol, 122
-	OVER
-	PUSHCONT {
-		.loc stdlib.sol, 123
-		BLKPUSH 2, 5
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S6
-		.loc stdlib.sol, 124
-		NEWC
-		POP S5
-		.loc stdlib.sol, 125
-		PUSHINT 127
-		POP S2
-		.loc stdlib.sol, 0
-	}
-	IFNOT
-	.loc stdlib.sol, 127
-	ROLL 3
-	PUSHINT 10
-	CALLREF {
-		.inline parseInteger
-	}
-	.loc stdlib.sol, 128
-	DUP
-	CALLREF {
-		DUP
-		TLEN
-		DUP
-		PUSHCONT {
-			DEC
-			PUSHPOW2DEC 8
-			MUL
-			SWAP
-			LAST
-			TLEN
-			ADD
-		}
-		PUSHCONT {
-			NIP
-		}
-		IFELSE
-	}
-	.loc stdlib.sol, 129
-	PUSH S4
-	PUSHCONT {
-		.loc stdlib.sol, 130
-		PUSH2 S4, S0
-		LESS
-		PUSH S5
-		GTINT 127
-		OR
-		THROWIF 66
-		.loc stdlib.sol, 132
-		PUSH2 S4, S0
-		SUB
-		.loc stdlib.sol, 133
-		PUSH2 S0, S4
-		LEQ
-		PUSHCONT {
-			.loc stdlib.sol, 134
-			DUP
-			PUSHCONT {
-				.loc stdlib.sol, 135
-				PUSH2 S6, S3
-				STUR 8
-				POP S7
-				.loc stdlib.sol, 0
-			}
-			REPEAT
-			.loc stdlib.sol, 137
-			PUSH2 S4, S0
-			SUB
-			POP S5
-			.loc stdlib.sol, 138
-			PUSH S4
-			PUSHCONT {
-				.loc stdlib.sol, 139
-				BLKPUSH 2, 7
-				CALLREF {
-					XCPU S1, S0
-					TLEN
-					PUSHCONT {
-						TPOP
-						DUP
-						TLEN
-						PUSHPOW2DEC 8
-						SUB
-						PUSHCONT {
-							TPUSH
-							TUPLE 0
-						}
-						IFNOT
-					}
-					PUSHCONT {
-						TUPLE 0
-					}
-					IFELSE
-					ROT
-					TPUSH
-					TPUSH
-				}
-				POP S8
-				.loc stdlib.sol, 140
-				NEWC
-				POP S7
-				.loc stdlib.sol, 141
-				PUSHINT 127
-				POP S5
-				.loc stdlib.sol, 0
-			}
-			IFNOT
-		}
+	.loc stdlib.sol, 82
+	SWAP
+	PUSHINT 10
+	CALLREF {
+		.inline __parseInteger
+	}
+	.loc stdlib.sol, 84
+	PUSH2 S4, S0
+	GREATER
+	PUSHCONT {
+		.loc stdlib.sol, 85
+		PUSH S3
+		PUSHINT 48
+		PUSHINT 32
+		CONDSEL
+		.loc stdlib.sol, 86
+		PUSH2 S5, S1
+		SUB
+		.loc stdlib.sol, 87
+		PUSH2 S0, S4
+		MIN
 		PUSHCONT {
-			.loc stdlib.sol, 144
-			PUSH S4
-			PUSHCONT {
-				.loc stdlib.sol, 145
-				PUSH2 S6, S3
-				STUR 8
-				POP S7
-				.loc stdlib.sol, 0
-			}
-			REPEAT
-			.loc stdlib.sol, 147
-			BLKPUSH 2, 7
-			CALLREF {
-				XCPU S1, S0
-				TLEN
-				PUSHCONT {
-					TPOP
-					DUP
-					TLEN
-					PUSHPOW2DEC 8
-					SUB
-					PUSHCONT {
-						TPUSH
-						TUPLE 0
-					}
-					IFNOT
-				}
-				PUSHCONT {
-					TUPLE 0
-				}
-				IFELSE
-				ROT
-				TPUSH
-				TPUSH
-			}
+			.loc stdlib.sol, 88
+			PUSH2 S7, S7
+			FIRST
+			PUSH S3
+			STUR 8
+			SETINDEX 0
 			POP S8
-			.loc stdlib.sol, 148
+			.loc stdlib.sol, 0
+		}
+		REPEAT
+		.loc stdlib.sol, 90
+		PUSH2 S0, S4
+		GREATER
+		PUSHCONT {
+			.loc stdlib.sol, 91
 			NEWC
-			POP S7
-			.loc stdlib.sol, 149
+			PUSH S8
+			PAIR
+			POP S8
+			.loc stdlib.sol, 92
 			PUSH2 S0, S4
 			SUB
 			PUSHCONT {
-				.loc stdlib.sol, 150
-				PUSH2 S6, S3
+				.loc stdlib.sol, 93
+				PUSH2 S7, S7
+				FIRST
+				PUSH S3
 				STUR 8
-				POP S7
+				SETINDEX 0
+				POP S8
 				.loc stdlib.sol, 0
 			}
 			REPEAT
-			.loc stdlib.sol, 152
-			PUSHINT 127
+			.loc stdlib.sol, 95
+			PUSH S4
+			ADDCONST 127
 			OVER
-			SUB
-			PUSH S5
-			ADD
-			POP S5
+		}
+		PUSHCONT {
+			.loc stdlib.sol, 97
+			PUSH2 S4, S0
 		}
 		IFELSE
+		SUB
+		POP S5
 		.loc stdlib.sol, 0
-		DROP
+		DROP2
 	}
 	IF
-	.loc stdlib.sol, 155
-	PUSH2 S0, S3
-	LEQ
+	.loc stdlib.sol, 101
+	PUSH2 S0, S2
+	MIN
 	PUSHCONT {
-		.loc stdlib.sol, 156
-		DUP
+		.loc stdlib.sol, 103
+		OVER
+		UNPAIR
+		POP S3
+		PUSH2 S6, S6
+		.loc stdlib.sol, 104
+		FIRST
+		ROT
+		ADDCONST 48
+		STUR 8
+		SETINDEX 0
+		POP S6
+		.loc stdlib.sol, 0
+	}
+	REPEAT
+	.loc stdlib.sol, 106
+	PUSH2 S0, S2
+	GREATER
+	PUSHCONT {
+		.loc stdlib.sol, 107
+		NEWC
+		PUSH S6
+		PAIR
+		POP S6
+		PUSH2 S0, S2
+		.loc stdlib.sol, 108
+		SUB
 		PUSHCONT {
-			.loc stdlib.sol, 157
+			.loc stdlib.sol, 110
 			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
-				PUSHCONT {
-					TPUSH
-				}
-				PUSHCONT {
-					DROP
-				}
-				IFELSE
-			}
+			UNPAIR
 			POP S3
-			.loc stdlib.sol, 158
-			PUSH S6
-			PUSHINT 48
+			PUSH2 S6, S6
+			.loc stdlib.sol, 111
+			FIRST
 			ROT
-			ADD
+			ADDCONST 48
 			STUR 8
+			SETINDEX 0
 			POP S6
 			.loc stdlib.sol, 0
 		}
 		REPEAT
+		.loc stdlib.sol, 0
 	}
+	IF
+	.loc stdlib.sol, 115
+	BLKDROP 5
+	.loc stdlib.sol, 0
+}
+
+.fragment __convertFixedPointToString, {
+	.loc stdlib.sol, 130
+	PUSH S2
+	LESSINT 0
 	PUSHCONT {
-		.loc stdlib.sol, 161
+		.loc stdlib.sol, 131
 		PUSH S3
+		FIRST
+		BREMBITS
+		LESSINT 8
 		PUSHCONT {
-			.loc stdlib.sol, 162
-			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
-				PUSHCONT {
-					TPUSH
-				}
-				PUSHCONT {
-					DROP
-				}
-				IFELSE
-			}
-			POP S3
-			.loc stdlib.sol, 163
-			PUSH S6
-			PUSHINT 48
-			ROT
-			ADD
-			STUR 8
-			POP S6
+			.loc stdlib.sol, 132
+			NEWC
+			PUSH S4
+			PAIR
+			POP S4
 			.loc stdlib.sol, 0
 		}
-		REPEAT
-		.loc stdlib.sol, 165
-		BLKPUSH 2, 6
-		CALLREF {
-			XCPU S1, S0
-			TLEN
+		IF
+		.loc stdlib.sol, 134
+		PUSH2 S3, S3
+		FIRST
+		STSLICECONST x2d
+		SETINDEX 0
+		POP S4
+		.loc stdlib.sol, 0
+	}
+	IF
+	.loc stdlib.sol, 136
+	ROT
+	ABS
+	SWAP
+	DIVMOD
+	.loc stdlib.sol, 137
+	PUXC S3, S1
+	PUSHINT 0
+	DUP
+	CALLREF {
+		.inline __convertIntToString
+	}
+	POP S3
+	.loc stdlib.sol, 138
+	PUSH S2
+	FIRST
+	BREMBITS
+	LESSINT 8
+	PUSHCONT {
+		.loc stdlib.sol, 139
+		NEWC
+		PUSH S3
+		PAIR
+		POP S3
+		.loc stdlib.sol, 0
+	}
+	IF
+	.loc stdlib.sol, 141
+	PUSH2 S2, S2
+	FIRST
+	STSLICECONST x2e
+	SETINDEX 0
+	POP S3
+	SWAP
+	.loc stdlib.sol, 142
+	TRUE
+	CALLREF {
+		.inline __convertIntToString
+	}
+	.loc stdlib.sol, 0
+}
+
+.fragment __gasGasPrice, {
+	.loc stdlib.sol, 28
+	DUP
+	EQINT 0
+	OVER
+	EQINT -1
+	OR
+	THROWIFNOT 67
+	.loc stdlib.sol, 29
+	PUSHINT 20
+	PUSHINT 21
+	CONDSEL
+	CONFIGOPTPARAM
+	.loc stdlib.sol, 30
+	DUP
+	ISNULL
+	THROWIF 68
+	.loc stdlib.sol, 31
+	DUP
+	ISNULL
+	THROWIF 63
+	CTOS
+	.loc stdlib.sol, 32
+	LDU 8
+	LDU 64
+	LDU 64
+	LDU 8
+	PLDU 64
+	BLKDROP2 4, 1
+	.loc stdlib.sol, 0
+}
+
+.fragment __gasToTon, {
+	.loc stdlib.sol, 24
+	CALLREF {
+		.inline __gasGasPrice
+	}
+	PUSHPOW2 16
+	MULDIVC
+	.loc stdlib.sol, 0
+}
+
+.fragment __strstr, {
+	.loc stdlib.sol, 402
+	NULL
+	.loc stdlib.sol, 403
+	PUSH S2
+	CTOS
+	.loc stdlib.sol, 404
+	PUSH S2
+	CTOS
+	.loc stdlib.sol, 405
+	PUSHINT 0
+	FALSE ; decl return flag
+	PUSHCONT {
+		.loc stdlib.sol, 406
+		OVER2
+		PUSHCONT {
+			.loc stdlib.sol, 378
+			OVER
+			SBITS
+			.loc stdlib.sol, 379
+			OVER
+			SBITS
+			.loc stdlib.sol, 380
+			FALSE ; decl return flag
 			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
+				PUSH S3
+				SEMPTY
+				NOT
+			}
+			PUSHCONT {
+				.loc stdlib.sol, 381
+				PUSH S2
 				PUSHCONT {
-					TPUSH
-					TUPLE 0
+					.loc stdlib.sol, 382
+					PUSH S4
+					SREFS
+					PUSHCONT {
+						BLKDROP 5
+						FALSE
+						PUSHINT 4
+						RETALT
+					}
+					IFNOTJMP
+					.loc stdlib.sol, 384
+					PUSH S4
+					LDREFRTOS
+					XCPU S6, S6
+					BLKDROP2 2, 1
+					.loc stdlib.sol, 385
+					SBITS
+					POP S3
+					.loc stdlib.sol, 0
 				}
 				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
-		}
-		POP S7
-		.loc stdlib.sol, 166
-		NEWC
-		POP S6
-		.loc stdlib.sol, 167
-		PUSH2 S0, S3
-		SUB
-		PUSHCONT {
-			.loc stdlib.sol, 168
-			OVER
-			CALLREF {
-				TPOP
-				TPOP
-				ROTREV
-				DUP
-				TLEN
+				.loc stdlib.sol, 387
+				OVER
 				PUSHCONT {
-					TPUSH
+					.loc stdlib.sol, 388
+					PUSH S3
+					LDREFRTOS
+					XCPU S5, S5
+					BLKDROP2 2, 1
+					.loc stdlib.sol, 389
+					SBITS
+					POP S2
+					.loc stdlib.sol, 0
 				}
+				IFNOT
+				.loc stdlib.sol, 391
+				BLKPUSH 2, 2
+				MIN
+				.loc stdlib.sol, 392
+				PUSH2 S5, S0
+				LDSLICEX
+				POP S7
+				PUSH2 S5, S1
+				.loc stdlib.sol, 393
+				LDSLICEX
+				POP S7
+				.loc stdlib.sol, 394
+				SDEQ
 				PUSHCONT {
-					DROP
+					BLKDROP 6
+					FALSE
+					PUSHINT 4
+					RETALT
 				}
-				IFELSE
+				IFNOTJMP
+				.loc stdlib.sol, 396
+				PUSH2 S3, S0
+				SUB
+				POP S4
+				.loc stdlib.sol, 397
+				PUSH S2
+				SUBR
+				POP S2
+				.loc stdlib.sol, 0
 			}
-			POP S3
-			.loc stdlib.sol, 169
-			PUSH S6
-			PUSHINT 48
-			ROT
-			ADD
-			STUR 8
-			POP S6
+			WHILEBRK
+			IFRET
+			.loc stdlib.sol, 399
+			BLKDROP 4
+			TRUE
+			.loc stdlib.sol, 377
+		}
+		CALLX
+		.loc stdlib.sol, 0
+		PUSHCONT {
+			DROP
+			BLKDROP2 5, 1
+			PUSHINT 4
+			RETALT
+		}
+		IFJMP
+		.loc stdlib.sol, 408
+		PUSH S3
+		SEMPTY
+		IFRETALT
+		.loc stdlib.sol, 410
+		PUSH S3
+		SBITS
+		PUSHCONT {
+			.loc stdlib.sol, 411
+			PUSH S3
+			LDREFRTOS
+			NIP
+			POP S4
 			.loc stdlib.sol, 0
 		}
-		REPEAT
+		IFNOT
+		.loc stdlib.sol, 412
+		PUSH S3
+		LDU 8
+		XCPU S5, S3
+		BLKDROP2 2, 1
+		.loc stdlib.sol, 413
+		INC
+		POP S2
+		.loc stdlib.sol, 0
 	}
-	IFELSE
-	.loc stdlib.sol, 173
-	BLKDROP 5
+	AGAINBRK
+	EQINT 4
+	IFRET
+	BLKDROP 6
+	.loc stdlib.sol, 415
+	NULL
 	.loc stdlib.sol, 0
 }
 
-.fragment convertFixedPointToString, {
-	.loc stdlib.sol, 191
-	OVER
-	ABS
-	.loc stdlib.sol, 192
-	PUSHINT 10
-	PUSH3 S2, S0, S2
-	OR
-	THROWIFNOT 69
-	CALLREF {
-		.inline __exp
-	}
-	DIVMOD
-	.loc stdlib.sol, 193
-	BLKPUSH 2, 5
-	ROLL 3
-	PUSHINT 0
-	DUP
-	ROLL 7
-	SGN
-	LESSINT 0
-	CALLREF {
-		.inline convertIntToDecStr
+.fragment __toLowerCase, {
+	.loc stdlib.sol, 419
+	NEWC
+	NULL
+	PAIR
+	.loc stdlib.sol, 420
+	SWAP
+	CTOS
+	NULL
+	PUSHCONT {
+		OVER
+		SEMPTY
+		NOT
 	}
-	POP S4
-	POP S4
-	.loc stdlib.sol, 194
-	PUSH S2
-	BREMBITS
-	.loc stdlib.sol, 195
-	GTINT 8
 	PUSHCONT {
-		.loc stdlib.sol, 198
-		OVER2
-		CALLREF {
-			XCPU S1, S0
-			TLEN
-			PUSHCONT {
-				TPOP
-				DUP
-				TLEN
-				PUSHPOW2DEC 8
-				SUB
-				PUSHCONT {
-					TPUSH
-					TUPLE 0
-				}
-				IFNOT
-			}
-			PUSHCONT {
-				TUPLE 0
-			}
-			IFELSE
-			ROT
-			TPUSH
-			TPUSH
+		OVER
+		LDUQ 8
+		PUSHCONT {
+			LDREFRTOS
+			NIP
+			LDU 8
 		}
-		POP S4
-		.loc stdlib.sol, 199
-		NEWC
+		IFNOT
+		BLKDROP2 2, 2
+		XCPU2 S1, S0, S0
+		.loc stdlib.sol, 422
+		GTINT 64
+		OVER
+		LESSINT 91
+		AND
+		PUSHCONT {
+			.loc stdlib.sol, 423
+			ADDCONST 32
+			.loc stdlib.sol, 0
+		}
+		IF
+		.loc stdlib.sol, 425
+		PUSH S3
+		FIRST
+		BREMBITS
+		LESSINT 8
+		PUSHCONT {
+			.loc stdlib.sol, 426
+			NEWC
+			PUSH S4
+			PAIR
+			POP S4
+			.loc stdlib.sol, 0
+		}
+		IF
+		.loc stdlib.sol, 428
+		PUSH2 S3, S3
+		FIRST
+		XCHG S1, S2
+		STU 8
+		SETINDEX 0
 		POP S3
-		.loc stdlib.sol, 200
+		.loc stdlib.sol, 0
 	}
-	IFNOT
-	PUSH S2
-	STSLICECONST x2e
-	POP S3
-	.loc stdlib.sol, 202
-	SWAP
-	TRUE
-	FALSE
+	WHILE
+	DROP2
+	.loc stdlib.sol, 430
 	CALLREF {
-		.inline convertIntToDecStr
+		.inline __makeString
 	}
 	.loc stdlib.sol, 0
 }
 
-.fragment insert_pubkey, {
-	.loc stdlib.sol, 14
+.fragment __toUpperCase, {
+	.loc stdlib.sol, 434
+	NEWC
+	NULL
+	PAIR
+	.loc stdlib.sol, 435
 	SWAP
 	CTOS
-	.loc stdlib.sol, 15
-	NEWC
-	.loc stdlib.sol, 18
-	OVER
-	LDI 1
-	POP S3
+	NULL
 	PUSHCONT {
-		.loc stdlib.sol, 19
-		STSLICECONST 1
-		.loc stdlib.sol, 20
 		OVER
-		LDU 32
-		POP S3
-		.loc stdlib.sol, 21
-		SWAP
-		STSLICECONST 1
-		STU 32
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 23
-		STSLICECONST 0
+		SEMPTY
+		NOT
 	}
-	IFELSE
-	.loc stdlib.sol, 27
-	OVER
-	LDI 1
-	POP S3
 	PUSHCONT {
-		.loc stdlib.sol, 28
-		STSLICECONST 1
-		.loc stdlib.sol, 29
 		OVER
-		LDI 1
-		LDI 1
-		POP S4
-		.loc stdlib.sol, 30
-		XCHG S2
-		STI 1
-		STI 1
+		LDUQ 8
+		PUSHCONT {
+			LDREFRTOS
+			NIP
+			LDU 8
+		}
+		IFNOT
+		BLKDROP2 2, 2
+		XCPU2 S1, S0, S0
+		.loc stdlib.sol, 437
+		GTINT 96
+		OVER
+		LESSINT 123
+		AND
+		PUSHCONT {
+			.loc stdlib.sol, 438
+			ADDCONST -32
+			.loc stdlib.sol, 0
+		}
+		IF
+		.loc stdlib.sol, 440
+		PUSH S3
+		FIRST
+		BREMBITS
+		LESSINT 8
+		PUSHCONT {
+			.loc stdlib.sol, 441
+			NEWC
+			PUSH S4
+			PAIR
+			POP S4
+			.loc stdlib.sol, 0
+		}
+		IF
+		.loc stdlib.sol, 443
+		PUSH2 S3, S3
+		FIRST
+		XCHG S1, S2
+		STU 8
+		SETINDEX 0
+		POP S3
+		.loc stdlib.sol, 0
 	}
-	PUSHCONT {
-		.loc stdlib.sol, 32
-		STSLICECONST 0
+	WHILE
+	DROP2
+	.loc stdlib.sol, 445
+	CALLREF {
+		.inline __makeString
 	}
-	IFELSE
-	.loc stdlib.sol, 36
-	OVER
-	LDDICT
-	POP S3
+	.loc stdlib.sol, 0
+}
+
+.fragment __tonToGas, {
+	.loc stdlib.sol, 20
+	PUSHPOW2 16
 	SWAP
-	STDICT
-	.loc stdlib.sol, 40
-	NEWDICT
-	.loc stdlib.sol, 41
-	PUSH S2
-	LDI 1
-	POP S4
-	PUSHCONT {
-		.loc stdlib.sol, 42
-		PUSH S2
-		LDREFRTOS
-		SWAP
-		POP S4
-		.loc stdlib.sol, 43
-		PLDDICT
-		NIP
-		.loc stdlib.sol, 0
+	CALLREF {
+		.inline __gasGasPrice
 	}
-	IF
-	.loc stdlib.sol, 45
-	ROLL 3
-	PUSHINT 0
-	ROTREV
-	NEWC
-	STU 256
-	ROTREV
-	PUSHINT 64
-	DICTUSETB
-	.loc stdlib.sol, 47
-	NEWC
-	STDICT
-	.loc stdlib.sol, 48
-	OVER
-	STSLICECONST 1
-	POP S2
-	.loc stdlib.sol, 49
-	STBREFR
-	.loc stdlib.sol, 53
-	OVER
-	LDDICT
-	POP S3
-	SWAP
-	STDICT
-	.loc stdlib.sol, 55
-	SWAP
-	SEMPTY
-	THROWIFNOT 55
-	.loc stdlib.sol, 57
-	ENDC
+	MULDIV
 	.loc stdlib.sol, 0
 }
 
-.fragment replay_protection, {
-	.loc stdlib.sol, 61
+.fragment __replayProtection, {
+	.loc stdlib.sol, 14
 	GETGLOB 3
 	OVER
 	LESS
 	THROWIFNOT 52
-	.loc stdlib.sol, 62
+	.loc stdlib.sol, 15
 	DUP
 	NOW
 	PUSHINT 1000
@@ -1901,127 +1136,137 @@
 	ADD
 	LESS
 	THROWIFNOT 52
-	.loc stdlib.sol, 63
+	.loc stdlib.sol, 16
 	SETGLOB 3
 	.loc stdlib.sol, 0
 }
 
+.fragment __exp, {
+	.loc stdlib.sol, 36
+	PUSHINT 1
+	.loc stdlib.sol, 37
+	PUSHCONT {
+		OVER
+		NEQINT 0
+	}
+	PUSHCONT {
+		.loc stdlib.sol, 38
+		OVER
+		MODPOW2 1
+		PUSHCONT {
+			.loc stdlib.sol, 39
+			PUSH S2
+			MUL
+			.loc stdlib.sol, 0
+		}
+		IF
+		.loc stdlib.sol, 40
+		PUSH2 S2, S2
+		MUL
+		POP S3
+		.loc stdlib.sol, 41
+		OVER
+		RSHIFT 1
+		POP S2
+		.loc stdlib.sol, 0
+	}
+	WHILE
+	.loc stdlib.sol, 43
+	BLKDROP2 2, 1
+	.loc stdlib.sol, 0
+}
+
 .fragment __stoi, {
-	.loc stdlib.sol, 311
+	.loc stdlib.sol, 221
 	CTOS
-	.loc stdlib.sol, 312
+	.loc stdlib.sol, 222
 	DUP
 	SBITS
 	LESSINT 8
 	PUSHCONT {
-		.loc stdlib.sol, 313
+		.loc stdlib.sol, 223
 		DROP
 		NULL
 		.loc stdlib.sol, 0
 	}
 	IFJMP
-	.loc stdlib.sol, 315
-	BLKPUSH 2, 0
-	.loc stdlib.sol, 316
-	LDU 8
-	POP S2
-	.loc stdlib.sol, 317
-	DUP
-	EQINT 45
-	.loc stdlib.sol, 318
-	PUSHINT 0
-	.loc stdlib.sol, 319
-	PUSH S3
-	SBITS
-	.loc stdlib.sol, 320
-	PUSH2 S2, S0
-	GTINT 15
-	AND
-	PUSHCONT {
-		.loc stdlib.sol, 321
-		PUSH S4
-		LDU 8
-		LDU 8
-		POP S7
-		POP S3
-		POP S4
-		.loc stdlib.sol, 0
+	.loc stdlib.sol, 226
+	DUP
+	SBITS
+	GTINT 7
+	DUP
+	PUSHCONT {
+		DROP
+		DUP
+		PLDU 8
+		EQINT 45
 	}
 	IF
-	.loc stdlib.sol, 323
-	PUSH S2
-	NOT
-	SWAP
-	GTINT 7
-	AND
+	.loc stdlib.sol, 227
+	DUP
 	PUSHCONT {
-		.loc stdlib.sol, 324
-		PUSH S3
-		LDU 8
-		POP S5
-		NIP
+		.loc stdlib.sol, 228
+		OVER
+		PUSHINT 8
+		SDSKIPFIRST
+		POP S2
 		.loc stdlib.sol, 0
 	}
 	IF
-	.loc stdlib.sol, 326
-	ROT
-	EQINT 48
-	SWAP
-	EQINT 120
-	AND
-	.loc stdlib.sol, 328
+	.loc stdlib.sol, 230
 	OVER
+	SBITS
+	GTINT 15
+	DUP
 	PUSHCONT {
-		.loc stdlib.sol, 329
-		PUSH S3
-		LDU 8
-		NIP
-		POP S4
-		.loc stdlib.sol, 0
+		DROP
+		OVER
+		PLDU 16
+		PUSHINT 12408
+		EQUAL
 	}
 	IF
-	.loc stdlib.sol, 330
+	.loc stdlib.sol, 231
 	DUP
 	PUSHCONT {
-		.loc stdlib.sol, 331
-		PUSH S3
-		LDU 8
-		LDU 8
-		BLKDROP2 2, 1
-		POP S4
+		.loc stdlib.sol, 232
+		PUSH S2
+		PUSHINT 16
+		SDSKIPFIRST
+		POP S3
 		.loc stdlib.sol, 0
 	}
 	IF
-	.loc stdlib.sol, 333
+	.loc stdlib.sol, 234
 	PUSHINT 0
-	.loc stdlib.sol, 335
-	PUSH S4
+	.loc stdlib.sol, 235
+	PUSH S3
 	SBITS
 	RSHIFT 3
-	.loc stdlib.sol, 337
+	.loc stdlib.sol, 236
 	FALSE ; decl return flag
 	ROLL 3
 	PUSHCONT {
-		.loc stdlib.sol, 338
+		.loc stdlib.sol, 237
 		FALSE ; decl return flag
 		PUSH S2
 		PUSHCONT {
-			.loc stdlib.sol, 339
-			PUSH S6
+			.loc stdlib.sol, 238
+			PUSH S5
 			LDU 8
-			POP S8
-			.loc stdlib.sol, 340
+			POP S7
+			.loc stdlib.sol, 239
 			PUSH S4
 			MULCONST 16
 			POP S5
-			.loc stdlib.sol, 341
+			.loc stdlib.sol, 240
 			DUP
 			GTINT 47
 			OVER
 			LESSINT 58
 			AND
 			PUSHCONT {
-				.loc stdlib.sol, 342
+				.loc stdlib.sol, 241
 				DUP
 				ADDCONST -48
 				PUSH S5
@@ -2036,7 +1281,7 @@
 				LESSINT 71
 				AND
 				PUSHCONT {
-					.loc stdlib.sol, 344
+					.loc stdlib.sol, 243
 					DUP
 					ADDCONST -55
 					PUSH S5
@@ -2051,7 +1296,7 @@
 					LESSINT 103
 					AND
 					PUSHCONT {
-						.loc stdlib.sol, 346
+						.loc stdlib.sol, 245
 						DUP
 						ADDCONST -87
 						PUSH S5
@@ -2060,8 +1305,8 @@
 						.loc stdlib.sol, 0
 					}
 					PUSHCONT {
-						.loc stdlib.sol, 348
-						BLKDROP 8
+						.loc stdlib.sol, 247
+						BLKDROP 7
 						NULL
 						PUSHINT 4
 						RETALT
@@ -2082,34 +1327,32 @@
 		.loc stdlib.sol, 0
 	}
 	PUSHCONT {
-		.loc stdlib.sol, 352
+		.loc stdlib.sol, 251
 		FALSE ; decl return flag
 		PUSH S2
 		PUSHCONT {
-			.loc stdlib.sol, 353
-			PUSH S6
+			.loc stdlib.sol, 252
+			PUSH S5
 			LDU 8
-			POP S8
-			.loc stdlib.sol, 354
+			POP S7
+			.loc stdlib.sol, 253
 			DUP
 			LESSINT 48
 			OVER
 			GTINT 57
 			OR
 			PUSHCONT {
-				BLKDROP 8
+				BLKDROP 7
 				NULL
 				PUSHINT 4
 				RETALT
 			}
 			IFJMP
-			.loc stdlib.sol, 356
+			.loc stdlib.sol, 255
 			PUSH S4
 			MULCONST 10
-			POP S5
-			.loc stdlib.sol, 357
+			SWAP
 			ADDCONST -48
-			PUSH S4
 			ADD
 			POP S4
 			.loc stdlib.sol, 0
@@ -2122,51 +1365,51 @@
 	}
 	IFELSE
 	IFRET
-	.loc stdlib.sol, 360
+	.loc stdlib.sol, 258
 	DROP
 	SWAP
 	PUSHCONT {
-		.loc stdlib.sol, 361
+		.loc stdlib.sol, 259
 		NEGATE
 		.loc stdlib.sol, 0
 	}
 	IF
-	.loc stdlib.sol, 362
-	BLKDROP2 2, 1
+	.loc stdlib.sol, 260
+	NIP
 	.loc stdlib.sol, 0
 }
 
-.fragment compareLongStrings, {
-	.loc stdlib.sol, 439
+.fragment __compareStrings, {
+	.loc stdlib.sol, 308
 	SWAP
 	CTOS
-	.loc stdlib.sol, 440
+	.loc stdlib.sol, 309
 	SWAP
 	CTOS
-	.loc stdlib.sol, 441
+	.loc stdlib.sol, 310
 	FALSE ; decl return flag
 	PUSHCONT {
-		.loc stdlib.sol, 442
+		.loc stdlib.sol, 311
 		BLKPUSH 2, 2
 		SDLEXCMP
-		.loc stdlib.sol, 443
+		.loc stdlib.sol, 312
 		DUP
 		PUSHCONT {
-			.loc stdlib.sol, 444
+			.loc stdlib.sol, 313
 			BLKDROP2 3, 1
 			PUSHINT 4
 			RETALT
 			.loc stdlib.sol, 0
 		}
 		IFJMP
-		.loc stdlib.sol, 446
+		.loc stdlib.sol, 315
 		DROP
 		PUSH S2
 		SREFS
-		.loc stdlib.sol, 447
+		.loc stdlib.sol, 316
 		PUSH S2
 		SREFS
-		.loc stdlib.sol, 448
+		.loc stdlib.sol, 317
 		DUP2
 		GREATER
 		PUSHCONT {
@@ -2176,7 +1419,7 @@
 			RETALT
 		}
 		IFJMP
-		.loc stdlib.sol, 450
+		.loc stdlib.sol, 319
 		PUSH2 S0, S1
 		GREATER
 		PUSHCONT {
@@ -2186,7 +1429,7 @@
 			RETALT
 		}
 		IFJMP
-		.loc stdlib.sol, 452
+		.loc stdlib.sol, 321
 		ADD
 		PUSHCONT {
 			BLKDROP 3
@@ -2195,13 +1438,12 @@
 			RETALT
 		}
 		IFNOTJMP
-		.loc stdlib.sol, 454
+		.loc stdlib.sol, 323
 		PUSH S2
 		LDREFRTOS
-		NIP
-		POP S3
-		.loc stdlib.sol, 455
-		OVER
+		XCPU S4, S3
+		BLKDROP2 2, 1
+		.loc stdlib.sol, 324
 		LDREFRTOS
 		NIP
 		POP S2
@@ -2209,18 +1451,18 @@
 	}
 	AGAINBRK
 	IFRET
-	.loc stdlib.sol, 457
+	.loc stdlib.sol, 326
 	DROP2
 	PUSHINT 0
 	.loc stdlib.sol, 0
 }
 
 .fragment __strchr, {
-	.loc stdlib.sol, 471
+	.loc stdlib.sol, 358
 	NULL
-	.loc stdlib.sol, 472
+	.loc stdlib.sol, 359
 	PUSHINT 0
-	.loc stdlib.sol, 473
+	.loc stdlib.sol, 360
 	ROLL 3
 	CTOS
 	NULL
@@ -2234,26 +1476,23 @@
 		PUSH S2
 		LDUQ 8
 		PUSHCONT {
-			PLDREF
-			CTOS
+			LDREFRTOS
+			NIP
 			LDU 8
 		}
 		IFNOT
-		POP S4
-		POP S2
-		.loc stdlib.sol, 474
-		PUSH2 S1, S5
+		BLKDROP2 2, 3
+		XCPU2 S2, S1, S5
+		.loc stdlib.sol, 361
 		EQUAL
 		PUSHCONT {
-			.loc stdlib.sol, 475
-			ROLL 3
+			XCHG S3
 			BLKDROP2 5, 1
 			PUSHINT 4
 			RETALT
-			.loc stdlib.sol, 0
 		}
 		IFJMP
-		.loc stdlib.sol, 477
+		.loc stdlib.sol, 363
 		PUSH S3
 		INC
 		POP S4
@@ -2267,11 +1506,11 @@
 }
 
 .fragment __strrchr, {
-	.loc stdlib.sol, 481
+	.loc stdlib.sol, 367
 	NULL
-	.loc stdlib.sol, 482
+	.loc stdlib.sol, 368
 	PUSHINT 0
-	.loc stdlib.sol, 483
+	.loc stdlib.sol, 369
 	ROLL 3
 	CTOS
 	NULL
@@ -2284,251 +1523,50 @@
 		OVER
 		LDUQ 8
 		PUSHCONT {
-			PLDREF
-			CTOS
+			LDREFRTOS
+			NIP
 			LDU 8
 		}
 		IFNOT
-		POP S3
-		NIP
-		.loc stdlib.sol, 484
-		PUSH2 S0, S4
+		BLKDROP2 2, 2
+		XCPU2 S1, S0, S4
+		.loc stdlib.sol, 370
 		EQUAL
 		PUSHCONT {
-			.loc stdlib.sol, 485
+			.loc stdlib.sol, 371
 			PUSH S2
 			POP S4
 			.loc stdlib.sol, 0
 		}
 		IF
-		.loc stdlib.sol, 487
-		PUSH S2
-		INC
-		POP S3
-		.loc stdlib.sol, 0
-	}
-	WHILE
-	BLKDROP 3
-	NIP
-	.loc stdlib.sol, 0
-}
-
-.fragment __toLowerCase, {
-	.loc stdlib.sol, 551
-	NEWC
-	NULL
-	PAIR
-	.loc stdlib.sol, 552
-	PUSHINT 0
-	.loc stdlib.sol, 553
-	ROT
-	CTOS
-	NULL
-	PUSHCONT {
-		OVER
-		SEMPTY
-		NOT
-	}
-	PUSHCONT {
-		OVER
-		LDUQ 8
-		PUSHCONT {
-			PLDREF
-			CTOS
-			LDU 8
-		}
-		IFNOT
-		POP S3
-		NIP
-		.loc stdlib.sol, 554
-		BLKPUSH 2, 0
-		.loc stdlib.sol, 555
-		GTINT 64
-		OVER
-		LESSINT 91
-		AND
-		PUSHCONT {
-			.loc stdlib.sol, 556
-			ADDCONST 32
-			.loc stdlib.sol, 0
-		}
-		IF
-		.loc stdlib.sol, 558
-		PUSH2 S4, S4
-		FIRST
-		XCHG S1, S2
-		STU 8
-		SETINDEX 0
-		POP S4
-		.loc stdlib.sol, 559
-		PUSH S2
-		INC
-		POP S3
-		.loc stdlib.sol, 560
-		PUSH S2
-		EQINT 127
-		PUSHCONT {
-			.loc stdlib.sol, 561
-			NEWC
-			.loc stdlib.sol, 562
-			PUSH S4
-			PAIR
-			POP S4
-			.loc stdlib.sol, 0
-		}
-		IF
-		.loc stdlib.sol, 0
-	}
-	WHILE
-	BLKDROP 3
-	.loc stdlib.sol, 565
-	DUP
-	FIRST
-	.loc stdlib.sol, 566
-	PUSHCONT {
-		OVER
-		SECOND
-		ISNULL
-		NOT
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 567
-		OVER
-		SECOND
-		DUP
-		ISNULL
-		THROWIF 63
-		POP S2
-		.loc stdlib.sol, 568
-		OVER
-		FIRST
-		.loc stdlib.sol, 569
-		STBREF
-		.loc stdlib.sol, 0
-	}
-	WHILE
-	.loc stdlib.sol, 572
-	ENDC
-	NIP
-	.loc stdlib.sol, 0
-}
-
-.fragment __toUpperCase, {
-	.loc stdlib.sol, 576
-	NEWC
-	NULL
-	PAIR
-	.loc stdlib.sol, 577
-	PUSHINT 0
-	.loc stdlib.sol, 578
-	ROT
-	CTOS
-	NULL
-	PUSHCONT {
-		OVER
-		SEMPTY
-		NOT
-	}
-	PUSHCONT {
-		OVER
-		LDUQ 8
-		PUSHCONT {
-			PLDREF
-			CTOS
-			LDU 8
-		}
-		IFNOT
-		POP S3
-		NIP
-		.loc stdlib.sol, 579
-		BLKPUSH 2, 0
-		.loc stdlib.sol, 580
-		GTINT 96
-		OVER
-		LESSINT 123
-		AND
-		PUSHCONT {
-			.loc stdlib.sol, 581
-			ADDCONST -32
-			.loc stdlib.sol, 0
-		}
-		IF
-		.loc stdlib.sol, 583
-		PUSH2 S4, S4
-		FIRST
-		XCHG S1, S2
-		STU 8
-		SETINDEX 0
-		POP S4
-		.loc stdlib.sol, 584
+		.loc stdlib.sol, 372
 		PUSH S2
 		INC
 		POP S3
-		.loc stdlib.sol, 585
-		PUSH S2
-		EQINT 127
-		PUSHCONT {
-			.loc stdlib.sol, 586
-			NEWC
-			.loc stdlib.sol, 587
-			PUSH S4
-			PAIR
-			POP S4
-			.loc stdlib.sol, 0
-		}
-		IF
 		.loc stdlib.sol, 0
 	}
 	WHILE
 	BLKDROP 3
-	.loc stdlib.sol, 590
-	DUP
-	FIRST
-	.loc stdlib.sol, 591
-	PUSHCONT {
-		OVER
-		SECOND
-		ISNULL
-		NOT
-	}
-	PUSHCONT {
-		.loc stdlib.sol, 592
-		OVER
-		SECOND
-		DUP
-		ISNULL
-		THROWIF 63
-		POP S2
-		.loc stdlib.sol, 593
-		OVER
-		FIRST
-		.loc stdlib.sol, 594
-		STBREF
-		.loc stdlib.sol, 0
-	}
-	WHILE
-	.loc stdlib.sol, 597
-	ENDC
 	NIP
 	.loc stdlib.sol, 0
 }
 
-.fragment stateInitHash, {
-	.loc stdlib.sol, 601
+.fragment __stateInitHash, {
+	.loc stdlib.sol, 449
 	NEWC
-	.loc stdlib.sol, 603
+	.loc stdlib.sol, 451
 	STSLICECONST x020134
-	.loc stdlib.sol, 615
+	.loc stdlib.sol, 463
 	ROT
 	STUR 16
-	.loc stdlib.sol, 616
+	.loc stdlib.sol, 464
 	STU 16
-	.loc stdlib.sol, 618
+	.loc stdlib.sol, 466
 	ROT
 	STUR 256
-	.loc stdlib.sol, 619
+	.loc stdlib.sol, 467
 	STU 256
-	.loc stdlib.sol, 620
+	.loc stdlib.sol, 468
 	ENDC
 	CTOS
 	SHA256U
@@ -2536,24 +1574,23 @@
 }
 
 .fragment __forwardFee, {
-	.loc stdlib.sol, 624
+	.loc stdlib.sol, 472
 	DEPTH
 	ADDCONST -3
 	PICK
 	CTOS
-	.loc stdlib.sol, 625
-	DUP
+	.loc stdlib.sol, 473
 	LDU 1
-	POP S2
-	.loc stdlib.sol, 626
+	SWAP
+	.loc stdlib.sol, 474
 	PUSHCONT {
-		.loc stdlib.sol, 637
+		.loc stdlib.sol, 485
 		DROP
 		PUSHINT 0
 		.loc stdlib.sol, 0
 	}
 	PUSHCONT {
-		.loc stdlib.sol, 631
+		.loc stdlib.sol, 479
 		LDU 3
 		LDMSGADDR
 		LDMSGADDR
@@ -2561,7 +1598,7 @@
 		LDDICT
 		LDVARUINT16
 		BLKDROP2 6, 1
-		.loc stdlib.sol, 635
+		.loc stdlib.sol, 483
 		LDVARUINT16
 		DROP
 		.loc stdlib.sol, 0
@@ -2571,29 +1608,28 @@
 }
 
 .fragment __importFee, {
-	.loc stdlib.sol, 642
+	.loc stdlib.sol, 490
 	DEPTH
 	ADDCONST -3
 	PICK
 	CTOS
-	.loc stdlib.sol, 643
-	DUP
+	.loc stdlib.sol, 491
 	LDU 2
-	POP S2
-	.loc stdlib.sol, 644
+	SWAP
+	.loc stdlib.sol, 492
 	EQINT 2
 	PUSHCONT {
-		.loc stdlib.sol, 647
+		.loc stdlib.sol, 495
 		LDMSGADDR
 		LDMSGADDR
 		BLKDROP2 2, 1
-		.loc stdlib.sol, 648
+		.loc stdlib.sol, 496
 		LDVARUINT16
 		DROP
 		.loc stdlib.sol, 0
 	}
 	PUSHCONT {
-		.loc stdlib.sol, 650
+		.loc stdlib.sol, 498
 		DROP
 		PUSHINT 0
 		.loc stdlib.sol, 0
diff --git a/sold/Cargo.toml b/sold/Cargo.toml
index 05b9dad5..143546a7 100644
--- a/sold/Cargo.toml
+++ b/sold/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 edition = '2021'
 name = 'sold'
-version = '0.72.0'
+version = '0.73.0'
 
 [[bin]]
 name = 'sold'
@@ -16,10 +16,10 @@ serde_json = { features = [ 'unbounded_depth' ], version = '1.0' }
 strip-ansi-escapes = '0.2'
 clap = { features = [ 'derive' ], version = '4.3' }
 serde = { features = [ 'derive' ], version = '1.0' }
-ton_abi = { git = 'https://github.com/tonlabs/ever-abi.git', tag = '2.3.147' }
-ton_block = { git = 'https://github.com/tonlabs/ever-block.git', tag = '1.9.104' }
-ton_types = { git = 'https://github.com/tonlabs/ever-types.git', tag = '2.0.28' }
-ton_labs_assembler = { features = [ 'gosh' ], git = 'https://github.com/tonlabs/ever-assembler.git', tag = '1.4.15' }
+ton_abi = { git = 'https://github.com/tonlabs/ever-abi.git', tag = '2.4.14' }
+ton_block = { git = 'https://github.com/tonlabs/ever-block.git', tag = '1.9.122' }
+ton_types = { git = 'https://github.com/tonlabs/ever-types.git', tag = '2.0.32' }
+ton_labs_assembler = { features = [ 'gosh' ], git = 'https://github.com/tonlabs/ever-assembler.git', tag = '1.4.39' }
 
 [build-dependencies]
 cmake = '0.1'
diff --git a/sold/build.rs b/sold/build.rs
index 941a3b2f..c5fc6abd 100644
--- a/sold/build.rs
+++ b/sold/build.rs
@@ -10,19 +10,42 @@
  * See the  GNU General Public License for more details at: https://www.gnu.org/licenses/gpl-3.0.html
  */
 
-use std::process::Command;
+fn absolute_path(path: &str) -> String {
+    let path = std::path::PathBuf::from(path);
+    let mut str = std::fs::canonicalize(path).unwrap().display().to_string();
+    // eprintln!("We will get it from {}", str.to_string());
+    if str.starts_with(r"\\?\") {
+        // https://doc.rust-lang.org/std/fs/fn.canonicalize.html
+        // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+        str = str.get(4..).unwrap().to_string();
+    }
+    return str;
+}
 
+fn full_lib_name(lib_name: &str, boost_lib_dir: &str) -> String {
+    let files = std::fs::read_dir(boost_lib_dir).unwrap();
+    for file in files {
+        let mut file_name = file.unwrap().file_name().to_str().unwrap().to_string();
+        if file_name.starts_with(lib_name) {
+            if file_name.ends_with(".lib") {
+                file_name = file_name.get(0..file_name.len()-4).unwrap().to_string();
+            }
+            return file_name.to_string();
+        }
+    }
+    panic!();
+}
+
+// To debug this use command:
+// cargo build -vv
 fn main() {
     println!("cargo:rerun-if-changed=../compiler/");
-    if cfg!(target_os = "windows") {
-        let install_deps = Command::new("powershell.exe").arg("../compiler/scripts/install_deps.ps1").output();
-        assert!(install_deps.is_ok());
-    }
 
     let profile = std::env::var("PROFILE").unwrap();
     let sol2tvm = if cfg!(target_os = "windows") {
         cmake::Config::new("../compiler")
-            .define("Boost_DIR", "../compiler/deps/boost/lib/cmake/Boost-1.77.0")
+            .define("BOOST_ROOT", absolute_path("../compiler/deps/boost/"))
+            .define("PEDANTIC", "OFF")
             .define("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded")
             .build()
     } else {
@@ -41,11 +64,18 @@ fn main() {
     println!("cargo:rustc-link-search=native={}/lib", sol2tvm.display());
     println!("cargo:rustc-link-search=native={}/build/deps/lib", sol2tvm.display());
 
+    let boost_lib_dir = "../compiler/deps/boost/lib";
     if cfg!(target_os = "windows") {
-        let path = std::path::PathBuf::from("../compiler/deps/boost/lib");
-        println!("cargo:rustc-link-search=native={}", std::fs::canonicalize(path).unwrap().display());
+        println!("cargo:rustc-link-search=native={}", absolute_path(boost_lib_dir));
     } else if cfg!(target_os = "macos") {
-        println!("cargo:rustc-link-search=native=/opt/homebrew/lib");
+        match std::env::var("HOMEBREW") {
+            Ok(homebrew) => {
+                assert!(std::path::PathBuf::from(homebrew.to_string()).exists(), "Set correct $HOMEBREW!");
+                println!("cargo:rustc-link-search=native={}/lib", homebrew)
+            }
+            // use default path
+            Err(_) => println!("cargo:rustc-link-search=native=/opt/homebrew/lib")
+        }
         println!("cargo:rustc-link-search=native=/usr/local/lib");
     } else if cfg!(target_os = "freebsd") {
         println!("cargo:rustc-link-search=native=/usr/local/lib");
@@ -61,7 +91,8 @@ fn main() {
         // so link dynamically
         println!("cargo:rustc-link-lib=boost_filesystem");
     } else if cfg!(target_os = "windows") {
-        println!("cargo:rustc-link-lib=static=libboost_filesystem-vc142-mt-s-x64-1_77");
+        let lib_name = full_lib_name("libboost_filesystem", &absolute_path(boost_lib_dir));
+        println!("cargo:rustc-link-lib=static={}", lib_name);
     }
 
     if cfg!(target_os = "macos") || cfg!(target_os = "freebsd") {
diff --git a/sold/src/printer.rs b/sold/src/printer.rs
index 36414d3b..5e60534c 100644
--- a/sold/src/printer.rs
+++ b/sold/src/printer.rs
@@ -41,21 +41,13 @@ pub fn print_abi_json_canonically(out: &mut File, value: &serde_json::Value) ->
     print(out, &root["functions"])?;
     writeln!(out, "\t],")?;
 
-    writeln!(out, "\t\"data\": [")?;
-    print_data(out, &root["data"])?;
-    writeln!(out, "\t],")?;
-
     writeln!(out, "\t\"events\": [")?;
     print(out, &root["events"])?;
+    writeln!(out, "\t],")?;
 
-    if root.contains_key("fields") {
-        writeln!(out, "\t],")?;
-        writeln!(out, "\t\"fields\": [")?;
-        print_data(out, &root["fields"])?;
-        writeln!(out, "\t]")?;
-    } else {
-        writeln!(out, "\t]")?;
-    }
+    writeln!(out, "\t\"fields\": [")?;
+    print_data(out, &root["fields"])?;
+    writeln!(out, "\t]")?;
 
     writeln!(out, "}}")?;
     Ok(())